/** @see jaskell.compiler.JaskellVisitor#visit(QualifiedVariable) */
public Object visit(QualifiedVariable a) {
Module mod = null;
Iterator it = a.getPath().iterator();
while (it.hasNext()) {
String mname = (String) it.next();
if (mod != null) mod = (Module) mod.lookup(mname);
else mod = (Module) Module.getToplevels().get(mname);
}
/* module found */
if (mod != null) {
Expression def = mod.lookup(a.getName());
if (def == null) throw new CompilerException("Unknown variable " + a.getName());
Type t = def.getType();
if (t == null) t = (Type) def.visit(this);
/* as it is the case for variable, we assume
* that a defined symbol may be overloaded (only for primitive types)
* so we return a type variable and defers choice of
* symbol to a later stage
*/
a.setType(t);
return t;
}
throw new CompilerException("Unable to find module needed for variable " + a.getName());
}
private static Map<String, String> buildClassToSourceMap(
ModuleChunk chunk,
CompileContext context,
Set<String> toCompilePaths,
String moduleOutputPath)
throws IOException {
final Map<String, String> class2Src = new HashMap<String, String>();
for (Module module : chunk.getModules()) {
final String moduleName = module.getName().toLowerCase(Locale.US);
final SourceToOutputMapping srcToOut =
context.getDataManager().getSourceToOutputMap(moduleName, context.isCompilingTests());
for (String src : srcToOut.getKeys()) {
if (!toCompilePaths.contains(src) && isGroovyFile(src)) {
final Collection<String> outs = srcToOut.getState(src);
if (outs != null) {
for (String out : outs) {
if (out.endsWith(".class") && out.startsWith(moduleOutputPath)) {
final String className =
out.substring(moduleOutputPath.length(), out.length() - ".class".length())
.replace('/', '.');
class2Src.put(className, src);
}
}
}
}
}
}
return class2Src;
}
// same code as above!
@Override
public void checkAllHardwareStopped() throws HardwareException {
Module mainModule = (Module) lookup.getComponentByName("main");
if (mainModule == null) {
throw new IllegalArgumentException("no component named main!");
// TODO log ? or error
}
final MutableReference<HardwareException> excList = new MutableReference<>();
mainModule.proceduralWalk(
configurable -> {
if (configurable instanceof HardwareController) {
try {
((HardwareController) configurable).checkStopped();
} catch (HardwareException e) {
excList.reference =
new HardwareException(
configurable.toString() + "not stopped ", e, excList.reference);
}
}
},
null);
/* */
if (excList.reference != null) {
throw excList.reference;
}
}
public static Module parse(final URI descriptor, final Handler defaultHandler)
throws IOException, ParseException, IllegalArgumentException {
if (descriptor == null)
throw new IllegalArgumentException("The module descriptor URI cannot be null.");
// Instantiate module and load document
final Module module = new Module(descriptor, defaultHandler);
final Document document;
try {
document = builderFactory.newDocumentBuilder().parse(new File(descriptor));
} catch (SAXException e) {
throw new ParseException("Cannot parse XML document, see inner exception for details.", e);
} catch (ParserConfigurationException e) {
throw new ParseException(
"XML parser configuration invalid, see inner exception for details.", e);
}
// Verify root element
final String moduleType = extract(document, "/module/@type", "Cannot extract module type");
if (!"JAVA_MODULE".equals(moduleType))
throw new ParseException("Module \"" + module.getName() + "\" is not a Java module.");
try {
module.processComponents(document);
} catch (ParseException e) {
throw new ParseException("Cannot parse module \"" + module.getName() + "\".", e);
}
return module;
}
/**
* invoke a <TT>checkHardware</TT> on all <TT>HardwareController</TT> (except when return diag
* modifies the path of invocation)
*
* @throws HardwareException a list of HardwareException
*/
@Override
public void checkHardware() throws HardwareException {
Module mainModule = (Module) lookup.getComponentByName("main");
if (mainModule == null) {
throw new IllegalArgumentException("no component named main!");
// TODO log ? or error
}
final MutableReference<HardwareException> excList = new MutableReference<>();
mainModule.treeWalk(
configurable -> {
if (configurable instanceof HardwareController) {
try {
return ((HardwareController) configurable).checkHardware();
} catch (HardwareException e) {
excList.reference =
new HardwareException(
configurable.toString() + " fails check", e, excList.reference);
// todo: not correct: what if not fatal and we still want to return Handler-children
if (e.isFatal()) {
return TreeWalkerDiag.STOP;
}
}
}
return TreeWalkerDiag.GO;
},
null);
/*
*/
if (excList.reference != null) {
throw excList.reference;
}
}
private ModuleClassLoader getModuleClassLoader(boolean logResolveError) {
ResolutionReport report = resolve();
if (logResolveError && !Module.RESOLVED_SET.contains(module.getState())) {
String reportMessage = report.getResolutionReportMessage(module.getCurrentRevision());
equinoxContainer
.getEventPublisher()
.publishFrameworkEvent(
FrameworkEvent.ERROR,
this,
new BundleException(reportMessage, BundleException.RESOLVE_ERROR));
}
return AccessController.doPrivileged(
new PrivilegedAction<ModuleClassLoader>() {
@Override
public ModuleClassLoader run() {
ModuleWiring wiring = getModule().getCurrentRevision().getWiring();
if (wiring != null) {
ModuleLoader moduleLoader = wiring.getModuleLoader();
if (moduleLoader instanceof BundleLoader) {
return ((BundleLoader) moduleLoader).getModuleClassLoader();
}
}
return null;
}
});
}
private static boolean packageResources(
@NotNull AndroidFacet facet, @NotNull CompileContext context) {
final Module module = facet.getModule();
try {
context.processMessage(
new ProgressMessage(
AndroidJpsBundle.message(
"android.jps.progress.packaging.resources", module.getName())));
final File manifestFile = AndroidJpsUtil.getManifestFileForCompilationPath(facet);
if (manifestFile == null) {
context.processMessage(
new CompilerMessage(
BUILDER_NAME,
BuildMessage.Kind.ERROR,
AndroidJpsBundle.message(
"android.jps.errors.manifest.not.found", module.getName())));
return false;
}
final ArrayList<String> assetsDirPaths = new ArrayList<String>();
collectAssetDirs(facet, assetsDirPaths);
final File outputDir =
AndroidJpsUtil.getOutputDirectoryForPackagedFiles(context.getProjectPaths(), module);
if (outputDir == null) {
context.processMessage(
new CompilerMessage(
BUILDER_NAME,
BuildMessage.Kind.ERROR,
AndroidJpsBundle.message(
"android.jps.errors.output.dir.not.specified", module.getName())));
return false;
}
final Pair<AndroidSdk, IAndroidTarget> pair =
AndroidJpsUtil.getAndroidPlatform(module, context, BUILDER_NAME);
if (pair == null) {
return false;
}
final IAndroidTarget target = pair.getSecond();
final String outputFilePath = getPackagedResourcesFile(module, outputDir).getPath();
final String[] resourceDirPaths =
AndroidJpsUtil.collectResourceDirsForCompilation(facet, true, context);
return doPackageResources(
context,
manifestFile,
target,
resourceDirPaths,
ArrayUtil.toStringArray(assetsDirPaths),
outputFilePath,
AndroidJpsUtil.isReleaseBuild(context));
} catch (IOException e) {
AndroidJpsUtil.reportExceptionError(context, null, e, BUILDER_NAME);
return false;
}
}
public Page findPage(int pageId) {
for (Module module : getModuleList()) {
for (Page page : module.getPageList()) {
if (page.getId() == pageId) return page;
}
}
return null;
}
public Set<Module> getAllRequiredModules() {
Set<Module> modules = new LinkedHashSet<Module>();
modules.add(this);
for (Module module : this.modules) {
modules.addAll(module.getAllRequiredModules());
}
return modules;
}
private static boolean runPngCaching(
@NotNull CompileContext context,
@NotNull Module module,
@NotNull AndroidFileSetStorage storage,
@Nullable AndroidFileSetState state)
throws IOException {
final AndroidFileSetState savedState = storage.getState(module.getName());
if (context.isMake() && savedState != null && savedState.equalsTo(state)) {
return true;
}
final AndroidFacet facet = AndroidJpsUtil.getFacet(module);
if (facet == null) {
return true;
}
context.processMessage(
new CompilerMessage(
BUILDER_NAME,
BuildMessage.Kind.INFO,
AndroidJpsBundle.message("android.jps.progress.res.caching", module.getName())));
final File resourceDir = AndroidJpsUtil.getResourceDirForCompilationPath(facet);
if (resourceDir == null) {
return true;
}
final Pair<AndroidSdk, IAndroidTarget> pair =
AndroidJpsUtil.getAndroidPlatform(module, context, BUILDER_NAME);
if (pair == null) {
return false;
}
final File resCacheDir = AndroidJpsUtil.getResourcesCacheDir(context, module);
if (!resCacheDir.exists()) {
if (!resCacheDir.mkdirs()) {
context.processMessage(
new CompilerMessage(
BUILDER_NAME,
BuildMessage.Kind.ERROR,
"Cannot create directory " + resCacheDir.getPath()));
return false;
}
}
final IAndroidTarget target = pair.second;
final Map<AndroidCompilerMessageKind, List<String>> messages =
AndroidApt.crunch(
target, Collections.singletonList(resourceDir.getPath()), resCacheDir.getPath());
AndroidJpsUtil.addMessages(context, messages, BUILDER_NAME);
final boolean success = messages.get(AndroidCompilerMessageKind.ERROR).isEmpty();
storage.update(module.getName(), success ? state : null);
return success;
}
public Action findAction(int actionId) {
for (Module module : getModuleList()) {
for (Page page : module.getPageList()) {
for (Action action : page.getActionList()) {
if (action.getId() == actionId) return action;
}
}
}
return null;
}
/** forwards a HALT signal to all components (that are signalHandlers) */
@org.lsst.ccs.command.annotations.Command(description = "halt", type = SIGNAL)
@Override
public void abort() {
super.abort();
Module mainModule = (Module) lookup.getComponentByName("main");
if (mainModule == null) {
throw new IllegalArgumentException("no component named main!");
// TODO log ? or error
}
mainModule.percolateSignal(new Signal(SignalLevel.HALT));
}
public List<Action> getAllAction() {
List<Action> list = new ArrayList<Action>();
for (Module m : this.moduleList) {
for (Page p : m.getPageList()) {
for (Action a : p.getActionList()) {
list.add(a);
}
}
}
return list;
}
private ProjectWrapper(
final GantBinding binding,
final String prjDir,
final String setupScript,
final Map<String, String> pathVariables,
final boolean loadHistory) {
affectedFiles = new HashSet<String>();
myProject = new GantBasedProject(binding == null ? new GantBinding() : binding);
myProjectBuilder = myProject.getBuilder();
final File prjFile = new File(prjDir);
final boolean dirBased = !(prjFile.isFile() && prjDir.endsWith(".ipr"));
myRoot = dirBased ? getCanonicalPath(prjDir) : getCanonicalPath(prjFile.getParent());
final String loadPath = dirBased ? getAbsolutePath(myIDEADir) : prjDir;
IdeaProjectLoader.loadFromPath(
myProject,
loadPath,
pathVariables != null ? pathVariables : Collections.<String, String>emptyMap(),
setupScript);
myProjectSnapshot =
myHomeDir
+ File.separator
+ myJPSDir
+ File.separator
+ myRoot.replace(File.separatorChar, myFileSeparatorReplacement);
try {
dependencyMapping = new Mappings(getMapDir());
} catch (IOException e) {
throw new RuntimeException(e);
}
backendCallback = dependencyMapping.getCallback();
for (Module m : myProject.getModules().values()) {
myModules.put(m.getName(), new ModuleWrapper(m));
}
for (Library l : myProject.getLibraries().values()) {
myLibraries.put(l.getName(), new LibraryWrapper(l));
}
myHistory = loadHistory ? loadSnapshot(affectedFiles) : null;
if (loadHistory) {
dependencyMapping = myHistory.dependencyMapping;
}
}
/** forwards a STOP signal to all components (that are signalHandlers) */
@org.lsst.ccs.command.annotations.Command(
description = "stops with expected max delay",
type = ACTION)
@Override
public void stop(long expectedMaxDelay) throws HardwareException {
super.stop(expectedMaxDelay);
Module mainModule = (Module) lookup.getComponentByName("main");
if (mainModule == null) {
throw new IllegalArgumentException("no component named main!");
// TODO log ? or error
}
mainModule.percolateSignal(new Signal(SignalLevel.STOP, expectedMaxDelay));
}
public List<ContainerUnit> listContainers(String applicationName, boolean withModules)
throws ServiceException {
List<ContainerUnit> containers = new ArrayList<>();
try {
Application application =
findByNameAndUser(authentificationUtils.getAuthentificatedUser(), applicationName);
if (application != null) {
try {
// Serveurs
List<Server> servers = application.getServers();
// Ajout des containers de type server
for (Server server : servers) {
DockerContainer dockerContainer = new DockerContainer();
dockerContainer.setName(server.getName());
dockerContainer = DockerContainer.findOne(dockerContainer, application.getManagerIp());
server = containerMapper.mapDockerContainerToServer(dockerContainer, server);
ContainerUnit containerUnit =
new ContainerUnit(server.getName(), server.getContainerID(), "server");
containers.add(containerUnit);
}
if (withModules) {
// Ajout des containers de type module
List<Module> modules = application.getModules();
for (Module module : modules) {
// on evite de remonter les modules de type toolkit
// (git, maven...)
if (module.isTool()) {
continue;
}
DockerContainer dockerContainer = new DockerContainer();
dockerContainer.setName(module.getName());
dockerContainer =
DockerContainer.findOne(dockerContainer, application.getManagerIp());
module = containerMapper.mapDockerContainerToModule(dockerContainer, module);
ContainerUnit containerUnit =
new ContainerUnit(module.getName(), module.getContainerID(), "module");
containers.add(containerUnit);
}
}
} catch (Exception ex) {
// Si une application sort en erreur, il ne faut pas
// arrêter la suite des traitements
logger.error(application.toString(), ex);
}
}
} catch (Exception e) {
throw new ServiceException(e.getLocalizedMessage(), e);
}
return containers;
}
public List<ClasspathItemWrapper> dependsOn(final boolean tests) {
if (tests) {
if (myTestDependsOn != null) {
return myTestDependsOn;
}
} else if (myDependsOn != null) {
return myDependsOn;
}
final List<ClasspathItemWrapper> result = new ArrayList<ClasspathItemWrapper>();
for (ClasspathItem cpi : myModule.getClasspath(ClasspathKind.compile(tests))) {
if (cpi instanceof Module) {
result.add(getModule(((Module) cpi).getName()));
} else if (cpi instanceof Library) {
result.add(new LibraryWrapper((Library) cpi));
} else {
result.add(new GenericClasspathItemWrapper(cpi));
}
}
if (tests) {
myTestDependsOn = result;
} else {
myDependsOn = result;
}
return result;
}
private void _loadConfig() {
try {
_configScope.set("__instance__", this);
_loadConfigFromCloudObject(getSiteObject());
_loadConfigFromCloudObject(getEnvironmentObject());
File f;
if (!_admin) {
f = getFileSafe("_config.js");
if (f == null || !f.exists()) f = getFileSafe("_config");
} else
f =
new File(
Module.getModule("core-modules/admin").getRootFile(getVersionForLibrary("admin")),
"_config.js");
_libraryLogger.info("config file [" + f + "] exists:" + f.exists());
if (f == null || !f.exists()) return;
Convert c = new Convert(f);
JSFunction func = c.get();
func.setUsePassedInScope(true);
func.call(_configScope);
_logger.debug("config things " + _configScope.keySet());
} catch (Exception e) {
throw new RuntimeException("couldn't load config", e);
}
}
/** Save the javac_state file. */
public void save() throws IOException {
if (!needsSaving) return;
try (FileWriter out = new FileWriter(javacStateFilename)) {
StringBuilder b = new StringBuilder();
long millisNow = System.currentTimeMillis();
Date d = new Date(millisNow);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
b.append("# javac_state ver 0.3 generated " + millisNow + " " + df.format(d) + "\n");
b.append("# This format might change at any time. Please do not depend on it.\n");
b.append("# M module\n");
b.append("# P package\n");
b.append("# S C source_tobe_compiled timestamp\n");
b.append("# S L link_only_source timestamp\n");
b.append("# G C generated_source timestamp\n");
b.append("# A artifact timestamp\n");
b.append("# D dependency\n");
b.append("# I pubapi\n");
b.append("# R arguments\n");
b.append("R ").append(theArgs).append("\n");
// Copy over the javac_state for the packages that did not need recompilation.
now.copyPackagesExcept(prev, recompiledPackages, new HashSet<String>());
// Save the packages, ie package names, dependencies, pubapis and artifacts!
// I.e. the lot.
Module.saveModules(now.modules(), b);
String s = b.toString();
out.write(s, 0, s.length());
}
}
@Override
public boolean hasPermission(Object permission) {
Generation current = (Generation) module.getCurrentRevision().getRevisionInfo();
ProtectionDomain domain = current.getDomain();
if (domain != null) {
if (permission instanceof Permission) {
SecurityManager sm = System.getSecurityManager();
if (sm instanceof EquinoxSecurityManager) {
/*
* If the FrameworkSecurityManager is active, we need to do checks the "right" way.
* We can exploit our knowledge that the security context of FrameworkSecurityManager
* is an AccessControlContext to invoke it properly with the ProtectionDomain.
*/
AccessControlContext acc = new AccessControlContext(new ProtectionDomain[] {domain});
try {
sm.checkPermission((Permission) permission, acc);
return true;
} catch (Exception e) {
return false;
}
}
return domain.implies((Permission) permission);
}
return false;
}
return true;
}
public Parameter findParameter(int parameterId, boolean isRequestType) {
for (Module module : getModuleList()) {
for (Page page : module.getPageList()) {
for (Action action : page.getActionList()) {
for (Parameter parameter :
(isRequestType
? action.getRequestParameterList()
: action.getResponseParameterList())) {
if (parameter.getId() == parameterId) {
return parameter;
}
}
}
}
}
return null;
}
@Override
public void stop(int options) throws BundleException {
if (options == 0 && equinoxContainer.getConfiguration().getDebug().MONITOR_ACTIVATION) {
Debug.printStackTrace(
new Exception("A persistent stop has been called on bundle: " + this)); // $NON-NLS-1$
}
module.stop(getStopOptions(options));
}
/* (non-Javadoc)
* @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Module)
*/
public Object visit(Module a) {
try {
return visit((Namespace) a);
} catch (TypeError te) {
if (te.getLineCol() == null) te.setLineCol(a.getTag("source"));
log.severe("Type error at (" + te.getLineCol() + ") : " + te.getMessage());
throw te;
}
}
/**
* Lancer par signal de NoPublicController quand le processus sshd est démarré dans les containers
* serveur et git
*/
public Application updateEnv(Application application, User user) throws ServiceException {
logger.info("--update Env of Server--");
String command = null;
Map<String, String> configShellModule = new HashMap<>();
Map<String, String> configShellServer = new HashMap<>();
Module moduleGit = moduleService.findGitModule(user.getLogin(), application);
Server server = application.getServers().get(0);
String rootPassword = application.getUser().getPassword();
configShellModule.put("port", moduleGit.getSshPort());
configShellModule.put("dockerManagerAddress", moduleGit.getApplication().getManagerIp());
configShellModule.put("password", rootPassword);
configShellModule.put("dockerManagerAddress", application.getManagerIp());
logger.info("new server ip : " + server.getContainerIP());
try {
int counter = 0;
while (!server.getStatus().equals(Status.START)
|| !moduleGit.getStatus().equals(Status.START)) {
if (counter == 100) {
break;
}
Thread.sleep(1000);
logger.info(" wait git and server sshd processus start");
logger.info(
"SSHDSTATUS = server : " + server.getStatus() + " - module : " + moduleGit.getStatus());
moduleGit = moduleService.findById(moduleGit.getId());
server = serverService.findById(server.getId());
counter++;
}
command = ". /cloudunit/scripts/update-env.sh " + server.getContainerIP();
logger.info("command shell to execute [" + command + "]");
shellUtils.executeShell(command, configShellModule);
configShellServer.put("port", server.getSshPort());
configShellServer.put("dockerManagerAddress", server.getApplication().getManagerIp());
configShellServer.put("password", rootPassword);
command = ". /cloudunit/scripts/rm-auth-keys.sh ";
logger.info("command shell to execute [" + command + "]");
shellUtils.executeShell(command, configShellServer);
String cleanCommand = server.getServerAction().cleanCommand();
if (cleanCommand != null) {
shellUtils.executeShell(server.getServerAction().cleanCommand(), configShellServer);
}
} catch (Exception e) {
moduleGit.setStatus(Status.FAIL);
moduleGit = moduleService.saveInDB(moduleGit);
server.setStatus(Status.FAIL);
server = serverService.saveInDB(server);
logger.error("Error : Error during update Env var of GIT " + e);
throw new ServiceException(e.getLocalizedMessage(), e);
}
return application;
}
@Override
public int getState() {
switch (module.getState()) {
case INSTALLED:
return Bundle.INSTALLED;
case RESOLVED:
return Bundle.RESOLVED;
case STARTING:
case LAZY_STARTING:
return Bundle.STARTING;
case ACTIVE:
return Bundle.ACTIVE;
case STOPPING:
return Bundle.STOPPING;
case UNINSTALLED:
return Bundle.UNINSTALLED;
default:
throw new IllegalStateException(
"No valid bundle state for module state: " + module.getState()); // $NON-NLS-1$
}
}
private static boolean checkUpToDate(
@NotNull Module module,
@NotNull Map<Module, AndroidFileSetState> module2state,
@NotNull AndroidFileSetStorage storage)
throws IOException {
final AndroidFileSetState moduleState = module2state.get(module);
final AndroidFileSetState savedState = storage.getState(module.getName());
if (savedState == null || !savedState.equalsTo(moduleState)) {
return false;
}
for (AndroidFacet libFacet : AndroidJpsUtil.getAllAndroidDependencies(module, true)) {
final Module libModule = libFacet.getModule();
final AndroidFileSetState currentLibState = module2state.get(libModule);
final AndroidFileSetState savedLibState = storage.getState(libModule.getName());
if (savedLibState == null || !savedLibState.equalsTo(currentLibState)) {
return false;
}
}
return true;
}
public Parameter findChildParameter(int parameterId) {
for (Module module : getModuleList()) {
for (Page page : module.getPageList()) {
for (Action action : page.getActionList()) {
for (Parameter parameter : action.getRequestParameterList()) {
Parameter pRecur = findParameterRecursively(parameter, parameterId);
if (pRecur != null) {
return pRecur;
}
}
for (Parameter parameter : action.getResponseParameterList()) {
Parameter pRecur = findParameterRecursively(parameter, parameterId);
if (pRecur != null) {
return pRecur;
}
}
}
}
}
return null;
}
/**
* Add git container to application associated to server
*
* @param application
* @return
* @throws ServiceException
* @throws CheckException
*/
private Module addGitContainer(Application application, String tagName)
throws ServiceException, CheckException {
Module moduleGit = ModuleFactory.getModule("git");
// todo : externaliser la variable
String containerGitAddress = "/cloudunit/git/.git";
try {
// Assign fixed host ports for forwarding git ports (22)
Map<String, String> mapProxyPorts = portUtils.assignProxyPorts(application);
String freeProxySshPortNumber = mapProxyPorts.get("freeProxySshPortNumber");
// Creation of git container fo application
moduleGit.setName("git");
moduleGit.setImage(imageService.findByName("git"));
moduleGit.setApplication(application);
moduleGit.setSshPort(freeProxySshPortNumber);
moduleGit = moduleService.initModule(application, moduleGit, tagName);
application.getModules().add(moduleGit);
application.setGitContainerIP(moduleGit.getContainerIP());
application.setGitSshProxyPort(freeProxySshPortNumber);
// Update GIT respository informations in the current application
application.setGitAddress(
"ssh://"
+ AlphaNumericsCharactersCheckUtils.convertToAlphaNumerics(
application.getUser().getLogin())
+ "@"
+ application.getName()
+ "."
+ application.getSuffixCloudUnitIO().substring(1)
+ ":"
+ application.getGitSshProxyPort()
+ containerGitAddress);
moduleGit.setStatus(Status.START);
moduleGit = moduleService.update(moduleGit);
} catch (UnsupportedEncodingException e) {
moduleGit.setStatus(Status.FAIL);
logger.error("Error : Error during persist git module " + e);
throw new ServiceException(e.getLocalizedMessage(), e);
}
return moduleGit;
}
@Test
public void test() {
// Create students, and populate them into a List of there studies.
Student studenta = new Student("Paul Barber", "1000");
Student studentb = new Student("Chris Cooper", "A1000");
Student studentc = new Student("Paul, Barber", "B1000");
List<Student> studiesHistory = new ArrayList<Student>();
studiesHistory.add(studenta);
studiesHistory.add(studentb);
studiesHistory.add(studentc);
List<Student> studiesSport = new ArrayList<Student>();
studiesSport.add(studentb);
// Create exams for the modules.
Exam exam = new Exam(2);
Exam exama = new Exam(1);
// Create the modules with the above date.
Module module = new Module("HIS100", "History", exam, studiesHistory);
Module sport = new Module("SPO109", "Sport", exama, studiesSport);
List<Module> allModules = new ArrayList<Module>();
// add all the modules to an allModules list.
allModules.add(module);
allModules.add(sport);
// Set the Modules List in the Student Class.
System.out.println(module.getStudentsEnrolled());
System.out.println(sport.getStudentsEnrolled());
System.out.println(studenta.getStudiesModules());
studenta.setModules(allModules);
studentb.setModules(allModules);
studentc.setModules(allModules);
System.out.println(studenta.getStudiesModules());
System.out.println(studentb.getStudiesModules());
System.out.println(studentc.getStudiesModules());
System.out.println(module.compareTo(sport));
}
public ModuleWrapper(final Module m) {
m.forceInit();
myModule = m;
myDependsOn = null;
myTestDependsOn = null;
myName = m.getName();
myExcludes = new HashSet<String>(m.getExcludes());
mySource = new Properties(m.getSourceRoots(), m.getOutputPath(), myExcludes);
myTest = new Properties(m.getTestRoots(), m.getTestOutputPath(), myExcludes);
myLibraries = new HashSet<LibraryWrapper>();
for (Library lib : m.getLibraries().values()) {
myLibraries.add(new LibraryWrapper(lib));
}
}
