private ResourceFactory getResourceFactory() { if (resourceFactory == null) { AddonRegistry addonRegistry = SimpleContainer.getFurnace(getClass().getClassLoader()).getAddonRegistry(); resourceFactory = addonRegistry.getServices(ResourceFactory.class).get(); } return resourceFactory; }
@Override public boolean isEnabled(UIContext context) { return !SimpleContainer.getServices(getClass().getClassLoader(), ProjectProvider.class).isUnsatisfied(); }
@Override public Project createTempProject(Iterable<Class<? extends ProjectFacet>> facetTypes) throws IllegalStateException { Imported<ProjectProvider> buildSystems = getAddonRegistry().getServices(ProjectProvider.class); if (buildSystems.isAmbiguous()) throw new IllegalStateException( "Cannot create generic temporary project in environment where multiple build systems are available. " + "A single build system must be selected."); ProjectProvider buildSystem = buildSystems.get(); return createTempProject(buildSystem, facetTypes); }
public ConverterFactory getConverterFactory() { if (converterFactory == null) { AddonRegistry addonRegistry = furnace.getAddonRegistry(); Imported<ConverterFactory> converterFactoryImport = addonRegistry.getServices(ConverterFactory.class); converterFactory = converterFactoryImport.get(); } return converterFactory; }
@Override public Result execute(UIExecutionContext context) Project project = getSelectedProject(context.getUIContext()); final DependencyFacet deps = project.getFacet(DependencyFacet.class); .getServices(getClass().getClassLoader(), DependencyInstaller.class).get(); int count = 0; for (Dependency dependency : arguments.getValue()) if (existingDep != null) if (context.getPrompt().promptBoolean( String.format("Dependency is already managed [%s:%s:%s], reference the managed dependency?", existingDep.getCoordinate().getGroupId(), existingDep.getCoordinate().getArtifactId(), existingDep.getCoordinate().getVersion()))) return Results.success("Project not updated: No changes required."); return Results.success("Installed [" + count + "] dependenc" + (count == 1 ? "y" : "ies") + "."); return Results.fail("No arguments specified.");
@Override public Result execute(UIExecutionContext context) throws Exception Furnace furnace = SimpleContainer.getFurnace(getClass().getClassLoader()); AddonRegistry registry = furnace.getAddonRegistry(); AddonManager addonManager = registry.getServices(AddonManager.class).get(); ProjectFactory projectFactory = getProjectFactory(); ResourceFactory resourceFactory = registry.getServices(ResourceFactory.class).get(); GitUtils gitUtils = registry.getServices(GitUtils.class).get(); if (project == null) return Results.fail("No project found in root " + projectRoot.getFullyQualifiedName()); Coordinate buildCoordinate = project.getFacet(MetadataFacet.class).getOutputDependency().getCoordinate(); try return Results.fail("Unable to execute project build", e); ids.add(AddonId.fromCoordinates(c)); ids.add(AddonId.from(c, buildCoordinate.getVersion())); ids.add(AddonId.from(buildCoordinate.getGroupId() + ":" + buildCoordinate.getArtifactId(), buildCoordinate.getVersion())); return Results.success("Addon(s) " + ids + " installed successfully.");
ForgeScriptEngine(ForgeScriptEngineFactory factory) { this.factory = factory; AddonRegistry addonRegistry = Furnace.instance(getClass().getClassLoader()).getAddonRegistry(); this.shellFactory = addonRegistry.getServices(ShellFactory.class).get(); this.resourceFactory = addonRegistry.getServices(ResourceFactory.class).get(); }
@Override public Result execute(UIExecutionContext context) final Furnace furnace = SimpleContainer.getFurnace(getClass().getClassLoader()); AddonManager addonManager = SimpleContainer.getServices(getClass().getClassLoader(), AddonManager.class).get(); AddonDependencyResolver resolver = SimpleContainer .getServices(getClass().getClassLoader(), AddonDependencyResolver.class).get(); try Response<AddonId[]> resolveVersions = resolver.resolveVersions(addonId.getName()); if (id.getVersion().compareTo(maxAddonId.getVersion()) > 0 && addonAPIVersion.equals(resolver.resolveAPIVersion(id).get())) for (AddonRepository r : furnace.getRepositories()) if (id.equals(maxAddonId)) return Results.fail("Addon " + maxAddonId.toCoordinates() + " is already installed with the most updated version."); if (installRequest.getActions().isEmpty()) return Results.fail("Addon " + maxAddonId.toCoordinates() + " is already installed with the most updated version."); return Results.success("Addon " + maxAddonId.toCoordinates() + " was installed successfully.");
@Override protected ProjectFactory getProjectFactory() { return SimpleContainer.getServices(getClass().getClassLoader(), ProjectFactory.class).get(); }
if (project == null) return Results.fail("No project found in root " + projectRoot.getValue().getFullyQualifiedName()); Coordinate coordinate = project.getFacet(MetadataFacet.class).getOutputDependency().getCoordinate(); try project.getFacet(PackagingFacet.class).createBuilder().runTests(false).addArguments("clean", "install") .build(); return Results.fail("Unable to execute project build", e); AddonManager addonManager = SimpleContainer.getServices(getClass().getClassLoader(), AddonManager.class).get(); AddonId id = AddonId.from(coordinate.getGroupId() + ":" + coordinate.getArtifactId(), coordinate.getVersion()); RemoveRequest removeRequest = addonManager.remove(id); removeRequest.perform(); AddonRegistry registry = SimpleContainer.getFurnace(getClass().getClassLoader()).getAddonRegistry(); Addons.waitUntilStopped(registry.getAddon(id)); InstallRequest installRequest = addonManager.install(id); installRequest.perform(); return Results.success("Addon " + coordinate.toString() + " was installed successfully.");
@Override public Result execute(UIExecutionContext context) throws Exception UIContext uiContext = context.getUIContext(); Project project = (Project) uiContext.getAttributeMap().get(Project.class); Archetype chosenArchetype = archetype.getValue(); DependencyResolver resolver = SimpleContainer.getServices(getClass().getClassLoader(), DependencyResolver.class) .get(); Dependency resolvedArtifact = resolver.resolveArtifact(depQuery); FileResource<?> artifact = resolvedArtifact.getArtifact(); MetadataFacet metadataFacet = project.getFacet(MetadataFacet.class); File fileRoot = project.getRoot().reify(DirectoryResource.class).getUnderlyingResourceObject(); ArchetypeHelper archetypeHelper = new ArchetypeHelper(artifact.getResourceInputStream(), fileRoot, metadataFacet.getProjectGroupName(), metadataFacet.getProjectName(), metadataFacet.getProjectVersion()); JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class); archetypeHelper.setPackageName(facet.getBasePackage()); archetypeHelper.execute(); return Results.success();
@Override public Result execute(UIExecutionContext context) throws Exception { Furnace furnace = SimpleContainer.getFurnace(getClass().getClassLoader()); FacetFactory facetFactory = SimpleContainer.getServices(getClass().getClassLoader(), FacetFactory.class).get(); DependencyInstaller dependencyInstaller = SimpleContainer .getServices(getClass().getClassLoader(), DependencyInstaller.class).get(); UIContext uiContext = context.getUIContext(); Project project = getSelectedProject(uiContext); facetFactory.install(project, FurnaceVersionFacet.class); project.getFacet(FurnaceVersionFacet.class).setVersion(furnace.getVersion().toString()); facetFactory.install(project, AddonTestFacet.class); for (AddonId addonId : addonDependencies.getValue()) { DependencyBuilder dependency = DependencyBuilder.create(addonId.getName()) .setVersion(addonId.getVersion().toString()).setScopeType("test"); if (!dependencyInstaller.isInstalled(project, dependency)) { dependencyInstaller.install(project, dependency); } } return Results .success("Project " + project.getFacet(MetadataFacet.class).getProjectName() + " is now configured for testing"); }
@Override public Result execute(UIExecutionContext context) throws Exception Result result = Results.success("Project named '" + named.getValue() + "' has been created."); DirectoryResource targetDir = getTargetDirectory(); boolean overwriteDir = overwrite.getValue() || useTargetLocationRoot.getValue(); ProjectFactory projectFactory = SimpleContainer.getServices(getClass().getClassLoader(), ProjectFactory.class) .get(); ProjectProvider buildSystemValue = buildSystem.getValue(); Project project = projectFactory.createProject(targetDir, buildSystemValue); if (project != null) PackagingFacet packagingFacet = project.getFacet(PackagingFacet.class); if (finalName.hasValue()) .getServices(getClass().getClassLoader(), FacetFactory.class).get(); if (value != null) result = Results.aggregate( Arrays.asList(result, Results.success("Stack '" + stackFacet.getStack().getName() + "' installed in project")));
@SuppressWarnings("unchecked") @Override public void enrich(InputComponentInjectionPoint injectionPoint, InputComponent<?, ?> input) { UIContextProvider contextProvider = SimpleContainer .getServices(getClass().getClassLoader(), UIContextProvider.class).get(); UIContext context = contextProvider.getUIContext(); // Setting for Single valued components only at the moment if (input instanceof SingleValued && context != null) { Class<?> valueType = input.getValueType(); if (ProjectFacet.class.isAssignableFrom(valueType)) { Class<? extends ProjectFacet> projectFacet = (Class<? extends ProjectFacet>) valueType; ProjectFactory projectFactory = SimpleContainer .getServices(getClass().getClassLoader(), ProjectFactory.class).get(); Project project = Projects.getSelectedProject(projectFactory, context); if (project != null && project.hasFacet(projectFacet)) { ConverterFactory converterFactory = SimpleContainer .getServices(getClass().getClassLoader(), ConverterFactory.class).get(); InputComponents.setDefaultValueFor(converterFactory, (InputComponent<?, Object>) input, project.getFacet(projectFacet)); } } } } }
@Override public Result execute(UIExecutionContext context) { Furnace furnace = SimpleContainer.getFurnace(getClass().getClassLoader()); AddonManager addonManager = SimpleContainer.getServices(getClass().getClassLoader(), AddonManager.class).get(); AddonDependencyResolver resolver = SimpleContainer .getServices(getClass().getClassLoader(), AddonDependencyResolver.class).get(); Version version = furnace.getVersion(); AddonId addonId = CoordinateUtils.resolveCoordinate(coordinate.getValue(), version, resolver); try { addonManager.install(addonId).perform(); // Invalidate project cache getProjectFactory().invalidateCaches(); return Results.success("Addon " + addonId.toCoordinates() + " was installed successfully."); } catch (Throwable t) { return Results.fail( "Addon " + addonId.toCoordinates() + " could not be installed: " + t.getCause().getMessage(), t); } }
@Override public void postCommandExecuted(UICommand command, UIExecutionContext context, Result result) Map<Object, Object> attributeMap = context.getUIContext().getAttributeMap(); String skipProjectBuild = Objects.toString(attributeMap.get(PROJECT_BUILDSTATUS_SKIP_FLAG), null); Imported<ProjectFactory> services = SimpleContainer .getServices(getClass().getClassLoader(), ProjectFactory.class); if (Boolean.parseBoolean(skipProjectBuild) || services.isUnsatisfied()) ProjectFactory projectFactory = services.get(); UIContext uiContext = context.getUIContext(); Project project = Projects.getSelectedProject(projectFactory, uiContext.getSelection()); if (project != null && project.hasFacet(PackagingFacet.class)) PackagingFacet facet = project.getFacet(PackagingFacet.class); BuildResult buildResult = facet.getBuildResult(); if (buildResult != null && !buildResult.isSuccess()) output.error(err, String.format("Project '%s' has errors", project.getRoot())); for (BuildMessage message : buildResult.getMessages())
@Override public Result execute(UIExecutionContext context) throws Exception { AddonProjectConfigurator addonProjectFactory = SimpleContainer .getServices(getClass().getClassLoader(), AddonProjectConfigurator.class).get(); final Project project = (Project) context.getUIContext().getAttributeMap().get(Project.class); Set<AddonId> dependencyAddons = new TreeSet<>(); if (addons.hasValue() || addons.hasDefaultValue()) { for (AddonId id : addons.getValue()) { dependencyAddons.add(id); } } dependencyAddons.add(furnaceContainer.getValue()); if (splitProjects.getValue()) { addonProjectFactory.setupComplexAddonProject(project, dependencyAddons); } else { addonProjectFactory.setupSimpleAddonProject(project, dependencyAddons); } return Results.success(); }
public void setup(File repoDir) { furnace = FurnaceFactory.getInstance(Thread.currentThread() .getContextClassLoader(), Thread.currentThread() .getContextClassLoader()); furnace.addRepository(AddonRepositoryMode.IMMUTABLE, repoDir); Future<Furnace> future = furnace.startAsync(); try { future.get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException("Furnace failed to start.", e); } AddonRegistry addonRegistry = furnace.getAddonRegistry(); commandFactory = addonRegistry.getServices(CommandFactory.class).get(); controllerFactory = (CommandControllerFactory) addonRegistry .getServices(CommandControllerFactory.class.getName()).get(); }
@Override public Result execute(UIExecutionContext context) throws Exception { AddonProjectConfigurator configurator = SimpleContainer .getServices(getClass().getClassLoader(), AddonProjectConfigurator.class).get(); Project project = getSelectedProject(context); AddonId addonId = AddonId.fromCoordinates(addon.getValue()); configurator.installSelectedAddons(project, Collections.singleton(addonId), false); return Results.success("Addon " + addonId + " added as a dependency to project " + project.getFacet(MetadataFacet.class).getProjectName()); }
.getServices(getClass().getClassLoader(), ConnectionProfileManagerProvider.class).get(); Iterable<String> selection = names.getValue(); StringBuffer sb = new StringBuffer(); return Results.success(message);