public static ModuleManager create() throws Exception { ModuleManager moduleManager = new ModuleManagerImpl(""); try (Reader reader = new InputStreamReader(ModuleManagerFactory.class.getResourceAsStream("/module.txt"), TerasologyConstants.CHARSET)) { ModuleMetadata metadata = new ModuleMetadataReader().read(reader); moduleManager.getRegistry().add(ClasspathModule.create(metadata, ModuleManagerFactory.class)); } moduleManager.loadEnvironment(Sets.newHashSet(moduleManager.getRegistry().getLatestModuleVersion(new Name("engine"))), true); return moduleManager; } }
private void loadGameModules() { final List<ModuleSelectionInfo> sortedGameModules = gameInfo.getManifest().getModules().stream() .sorted(Comparator.comparing(NameVersion::getName)) .map(nameVersion -> { Module module = moduleManager.getRegistry().getModule(nameVersion.getName(), nameVersion.getVersion()); if (module != null) { return ModuleSelectionInfo.strictVersion(module); } else { logger.warn("Can't find module in your classpath - {}:{}", nameVersion.getName(), nameVersion.getVersion()); module = moduleManager.getRegistry().getLatestModuleVersion(nameVersion.getName()); if (module != null) { logger.debug("Get the latest available version of module {} in your classpath", nameVersion.getName()); errors.add(String.format("Can't find module %s:%s in your classpath; loaded description for the latest available version.", nameVersion.getName(), nameVersion.getVersion())); return ModuleSelectionInfo.latestVersion(module); } logger.error("Can't find any versions of module {} in your classpath!", nameVersion.getName()); errors.add(String.format("Can't find any versions of module %s in your classpath!", nameVersion.getName())); return ModuleSelectionInfo.unavailableVersion(nameVersion.getName().toString(), nameVersion.getVersion().toString()); } }) .filter(Objects::nonNull) .collect(Collectors.toList()); gameModules.setList(sortedGameModules); gameModules.select(0); }
private List<Module> getGameplayModules() { List<Module> gameplayModules = Lists.newArrayList(); for (Name moduleId : moduleManager.getRegistry().getModuleIds()) { Module latestVersion = moduleManager.getRegistry().getLatestModuleVersion(moduleId); if (!latestVersion.isOnClasspath()) { if (StandardModuleExtension.isGameplayModule(latestVersion)) { gameplayModules.add(latestVersion); } } } gameplayModules.sort(Comparator.comparing(o -> o.getMetadata().getDisplayName().value())); return gameplayModules; }
private Set<Module> getAllModuleDependencies(final Collection<Module> modules) { return modules.stream() .filter(Objects::nonNull) .map(Module::getMetadata) .map(ModuleMetadata::getDependencies) .flatMap(Collection::stream) .filter(dep -> Objects.nonNull(dep.getId())) .map(dep -> moduleManager.getRegistry().getLatestModuleVersion(dep.getId())) .filter(Objects::nonNull) .collect(Collectors.toSet()); }
registry.add(module); } catch (IOException e) { logger.warn("Failed to load module.txt for classpath module {}", url);
private String getModulesText(Future<ServerInfoMessage> info) { try { ServerInfoMessage serverInfoMessage = info.get(); if (serverInfoMessage == null) { return FontColor.getColored(translationSystem.translate("${engine:menu#connection-failed}"), Color.RED); } List<String> codedModInfo = new ArrayList<>(); ModuleRegistry reg = moduleManager.getRegistry(); for (NameVersion entry : serverInfoMessage.getModuleList()) { boolean isInstalled = reg.getModule(entry.getName(), entry.getVersion()) != null; Color color = isInstalled ? Color.GREEN : Color.RED; codedModInfo.add(FontColor.getColored(entry.toString(), color)); } Collections.sort(codedModInfo, String.CASE_INSENSITIVE_ORDER); return Joiner.on('\n').join(codedModInfo); } catch (ExecutionException | InterruptedException e) { return FontColor.getColored(translationSystem.translate("${engine:menu#connection-failed}"), Color.RED); } }
@Override public ModuleEnvironment loadEnvironment(Set<Module> modules, boolean asPrimary) { Set<Module> finalModules = Sets.newLinkedHashSet(modules); finalModules.addAll(registry.stream().filter(Module::isOnClasspath).collect(Collectors.toList())); ModuleEnvironment newEnvironment; boolean permissiveSecurityEnabled = Boolean.parseBoolean(System.getProperty(SystemConfig.PERMISSIVE_SECURITY_ENABLED_PROPERTY)); if (permissiveSecurityEnabled) { newEnvironment = new ModuleEnvironment(finalModules, wrappingPermissionProviderFactory, Collections.<BytecodeInjector>emptyList()); } else { newEnvironment = new ModuleEnvironment(finalModules, permissionProviderFactory, Collections.<BytecodeInjector>emptyList()); } if (asPrimary) { environment = newEnvironment; } return newEnvironment; }
/** * refresh the telemetryCategories map. */ private void fetchTelemetryCategoriesFromEnvironment() { telemetryCategories = Maps.newHashMap(); DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry()); for (Name moduleId : moduleManager.getRegistry().getModuleIds()) { Module module = moduleManager.getRegistry().getLatestModuleVersion(moduleId); if (module.isCodeModule()) { ResolutionResult result = resolver.resolve(moduleId); if (result.isSuccess()) { try (ModuleEnvironment environment = moduleManager.loadEnvironment(result.getModules(), false)) { for (Class<?> holdingType : environment.getTypesAnnotatedWith(TelemetryCategory.class, new FromModule(environment, moduleId))) { TelemetryCategory telemetryCategory = holdingType.getAnnotation(TelemetryCategory.class); telemetryCategories.put(telemetryCategory, holdingType); } } } } } }
private Set<Module> processResolutionResult(ResolutionResult resolutionResult) throws DependencyResolutionFailedException { if (!resolutionResult.isSuccess()) { throw new DependencyResolutionFailedException("Module dependency resolution failed."); } return resolutionResult.getModules().stream() .filter(module -> !module.getId().equals(TerasologyConstants.ENGINE_MODULE)) .filter(module -> isOnlineVersionNewer(localRegistry.getLatestModuleVersion(module.getId()), module)) .collect(Collectors.toSet()); }
@Override public List<Module> call() throws Exception { Map<URL, Path> filesToDownload = getDownloadUrls(moduleList); logger.info("Started downloading {} modules", filesToDownload.size()); MultiFileDownloader downloader = new MultiFileDownloader(filesToDownload, downloadProgressListener); List<Path> downloadedModulesPaths = downloader.call(); logger.info("Module download completed, loading the new modules..."); List<Module> newInstalledModules = new ArrayList<>(downloadedModulesPaths.size()); ModuleLoader loader = new ModuleLoader(moduleManager.getModuleMetadataReader()); loader.setModuleInfoPath(TerasologyConstants.MODULE_INFO_FILENAME); for (Path filePath : downloadedModulesPaths) { try { Module module = loader.load(filePath); moduleManager.getRegistry().add(module); newInstalledModules.add(module); } catch (IOException e) { logger.warn("Could not load module {}", filePath.getFileName(), e); } } logger.info("Finished loading the downloaded modules"); return newInstalledModules; }
/** * Gets the server information and passes it to the client, while also checking if all required modules have been downloaded. * @param channelHandlerContext * @param message Passes the server information message to the function. */ private void receivedServerInfo(ChannelHandlerContext channelHandlerContext, NetData.ServerInfoMessage message) { logger.info("Received server info"); ((EngineTime) CoreRegistry.get(Time.class)).setGameTime(message.getTime()); this.server = new ServerImpl(networkSystem, channelHandlerContext.getChannel()); server.setServerInfo(message); // Request missing modules for (NetData.ModuleInfo info : message.getModuleList()) { if (null == moduleManager.getRegistry().getModule(new Name(info.getModuleId()), new Version(info.getModuleVersion()))) { missingModules.add(info.getModuleId().toLowerCase(Locale.ENGLISH)); } } if (missingModules.isEmpty()) { joinStatus.setCurrentActivity("Finalizing join"); sendJoin(channelHandlerContext); } else { joinStatus.setCurrentActivity("Requesting missing modules"); NetData.NetMessage.Builder builder = NetData.NetMessage.newBuilder(); for (String module : missingModules) { builder.addModuleRequest(NetData.ModuleRequest.newBuilder().setModuleId(module)); } channelHandlerContext.getChannel().write(builder.build()); } }
private void setupSandbox() { ExternalApiWhitelist.CLASSES.stream().forEach(clazz -> permissionProviderFactory.getBasePermissionSet().addAPIClass(clazz)); ExternalApiWhitelist.PACKAGES.stream().forEach(packagee -> permissionProviderFactory.getBasePermissionSet().addAPIPackage(packagee)); APIScanner apiScanner = new APIScanner(permissionProviderFactory); registry.stream().filter(Module::isOnClasspath).forEach(apiScanner::scan); permissionProviderFactory.getBasePermissionSet().grantPermission("com.google.gson", ReflectPermission.class); permissionProviderFactory.getBasePermissionSet().grantPermission("com.google.gson.internal", ReflectPermission.class); Policy.setPolicy(new ModuleSecurityPolicy()); System.setSecurityManager(new ModuleSecurityManager()); }
private Set<Class> fetchMetricsClassFromEnvironemnt(Context context) { ModuleManager moduleManager = context.get(ModuleManager.class); Set<Class> metricsClassSet = new HashSet<>(); DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry()); for (Name moduleId : moduleManager.getRegistry().getModuleIds()) { Module module = moduleManager.getRegistry().getLatestModuleVersion(moduleId); if (module.isCodeModule()) { ResolutionResult result = resolver.resolve(moduleId); if (result.isSuccess()) { try (ModuleEnvironment environment = moduleManager.loadEnvironment(result.getModules(), false)) { for (Class<?> holdingType : environment.getTypesAnnotatedWith(TelemetryCategory.class, new FromModule(environment, moduleId))) { metricsClassSet.add(holdingType); } } } } } return metricsClassSet; }
@Override public String get() { if (dependencyInfoBinding.get() != null) { return String.valueOf(moduleManager.getRegistry().getLatestModuleVersion(dependencyInfoBinding.get().getId()).getVersion()); } return ""; } });
private void setUpMockModuleEnvironment() { ModuleManager moduleManager = mock(ModuleManager.class); ModuleRegistry moduleRegistry = new TableModuleRegistry(); Module module = mock(Module.class); when(module.isCodeModule()).thenReturn(true); when(module.getId()).thenReturn(new Name(TEST_MODULE)); when(module.getVersion()).thenReturn(new Version(0, 0, 1, true)); when(module.getMetadata()).thenReturn(new ModuleMetadata()); moduleRegistry.add(module); when(moduleManager.getRegistry()).thenReturn(moduleRegistry); ModuleEnvironment environment = mock(ModuleEnvironment.class); when(moduleManager.loadEnvironment(any(), anyBoolean())).thenReturn(environment); when(moduleManager.getEnvironment()).thenReturn(environment); registerBindButtonClasses = new ArrayList<>(); when(environment.getTypesAnnotatedWith(eq(RegisterBindButton.class))).thenReturn(registerBindButtonClasses); when(environment.getTypesAnnotatedWith(eq(RegisterBindButton.class), any())).thenReturn(registerBindButtonClasses); registerRealBindAxisClasses = new ArrayList<>(); when(environment.getTypesAnnotatedWith(eq(RegisterBindAxis.class))).thenReturn(registerRealBindAxisClasses); when(environment.getTypesAnnotatedWith(eq(RegisterBindAxis.class), any())).thenReturn(registerRealBindAxisClasses); when(environment.getModuleProviding(any())).thenReturn(new Name(TEST_MODULE)); context.put(ModuleManager.class, moduleManager); }
Module module = moduleManager.getRegistry().getModule(moduleInfo.getName(), moduleInfo.getVersion()); if (module == null) { StateMainMenu mainMenu = new StateMainMenu("Missing required module: " + moduleInfo);
public void refresh() { ModuleManager moduleManager = context.get(ModuleManager.class); List<WorldGeneratorInfo> infos = Lists.newArrayList(); for (Name moduleId : moduleManager.getRegistry().getModuleIds()) { Module module = moduleManager.getRegistry().getLatestModuleVersion(moduleId); if (module.isCodeModule()) { DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry());
private void recursivelyAddModuleDependencies(Set<Name> modules, Name moduleName) { Module module = moduleManager.getRegistry().getLatestModuleVersion(moduleName); if (module != null) { for (DependencyInfo dependencyInfo : module.getMetadata().getDependencies()) { modules.add(dependencyInfo.getId()); recursivelyAddModuleDependencies(modules, dependencyInfo.getId()); } } }