@Override public boolean isBuilt(final Module module) { final Builder builder = cache.assertBuilder(module); return builder.isBuilt(); }
private Builder makeBuilder(final Module module) { Builder builder = getEntry(module); if (builder == null) { builder = new Builder(module, ioService, moduleService, importsService, buildValidationHelpers, dependenciesClassLoaderCache, pomModelCache, packageNameWhiteListService, createSingleClassFilterPredicate()); setEntry(module, builder); } return builder; }
public void invalidateProjectCache(@Observes final InvalidateDMOModuleCacheEvent event) { PortablePreconditions.checkNotNull("event", event); final Module project = event.getModule(); //If resource was not within a Module there's nothing to invalidate if (project != null) { invalidateCache(project); } }
/** * Gets the BuildInfo for a given module. The BuildInfoService decides internally whenever the module should be * built prior to construct the BuildInfo. * @param module The module for getting the BuildInfo. * @return the BuildInfo for the given module. */ public BuildInfo getBuildInfo(final Module module) { final Builder[] result = {builderCache.getBuilder(module)}; if (result[0] == null || !result[0].isBuilt()) { ((BuildServiceImpl) buildService).build(module, builder -> result[0] = builder); } return new BuildInfoImpl(result[0]); } }
public BuildResult build(final Module module) { try { cache.invalidateCache(module); Builder builder = cache.assertBuilder(module); final BuildResults results = builder.build(); BuildMessage infoMsg = new BuildMessage(); infoMsg.setLevel(Level.INFO); infoMsg.setText(buildResultMessage(module, results).toString()); results.addBuildMessage(0, infoMsg); return new BuildResult(builder, results); } catch (Exception e) { logger.error(e.getMessage(), e); return new BuildResult(null, buildExceptionResults(e, module.getPom().getGav())); } }
public Builder assertBuilder(POM pom) throws NoBuilderFoundException { for (Module project : getKeys()) { if (project.getPom().getGav().equals(pom.getGav())) { return makeBuilder(project); } } throw new NoBuilderFoundException(); }
public Builder assertBuilder(final Module module) { return makeBuilder(module); }
public Builder getBuilder(final Module module) { return getEntry(module); }
@Test public void testGetBuildInfoWhenBuilerNotExist() { //the builder don't exists. when(cache.getBuilder(module)).thenReturn(null); testBuildIsRequired(); }
public IncrementalBuildResults applyBatchResourceChanges(final Module module, final Map<Path, Collection<ResourceChange>> changes) { IncrementalBuildResults results = new IncrementalBuildResults(); try { if (module == null) { return results; } final Builder builder = cache.assertBuilder(module); if (!builder.isBuilt()) { throw new IllegalStateException("Incremental Build requires a full build be completed first."); } else { results = builder.applyBatchResourceChanges(changes); } return results; } catch (Exception e) { logger.error(e.getMessage(), e); throw ExceptionUtilities.handleException(e); } }
@Test public void testGetBuildInfoWhenModuleIsBuilt() { when(cache.getBuilder(module)).thenReturn(builder); when(builder.isBuilt()).thenReturn(true); BuildInfo expectedBuildInfo = new BuildInfoImpl(builder); BuildInfo result = buildInfoService.getBuildInfo(module); assertEquals(expectedBuildInfo, result); verify(cache, times(1)).getBuilder(module); verify(buildService, never()).build(eq(module), any(Consumer.class)); }
public IncrementalBuildResults updatePackageResource(final Path resource) { try { final Module module = moduleService.resolveModule(resource); if (module == null) { return new IncrementalBuildResults(); } final Builder builder = cache.assertBuilder(module); if (!builder.isBuilt()) { throw new IllegalStateException("Incremental Build requires a full build be completed first."); } return builder.updateResource(Paths.convert(resource)); } catch (Exception e) { logger.error(e.getMessage(), e); throw ExceptionUtilities.handleException(e); } }
@Test public void testGetBuildInfoWhenModuleIsNotBuilt() { //the builder exists, but was never built. when(cache.getBuilder(module)).thenReturn(builderNotBuilt); when(builderNotBuilt.isBuilt()).thenReturn(false); testBuildIsRequired(); }
public IncrementalBuildResults addPackageResource(final Path resource) { try { IncrementalBuildResults results = new IncrementalBuildResults(); final KieModule module = moduleService.resolveModule(resource); if (module == null) { return results; } final Builder builder = cache.assertBuilder(module); if (!builder.isBuilt()) { throw new IllegalStateException("Incremental Build requires a full build be completed first."); } else { results = builder.addResource(Paths.convert(resource)); } return results; } catch (Exception e) { logger.error(e.getMessage(), e); throw ExceptionUtilities.handleException(e); } }
private void verifyBuilder(KieModule module, GAV gav) { Builder builder = cache.getBuilder(module); assertNotNull(builder); assertTrue(builder.isBuilt()); verify(m2RepoService, times(1)).deployJar(any(InputStream.class), eq(gav)); }
public IncrementalBuildResults deletePackageResource(final Path resource) { try { IncrementalBuildResults results = new IncrementalBuildResults(); final KieModule module = moduleService.resolveModule(resource); if (module == null) { return results; } final Builder builder = cache.assertBuilder(module); if (!builder.isBuilt()) { throw new IllegalStateException("Incremental Build requires a full build be completed first."); } else { results = builder.deleteResource(Paths.convert(resource)); } return results; } catch (Exception e) { logger.error(e.getMessage(), e); throw ExceptionUtilities.handleException(e); } }
private void testBuildIsRequired() { doAnswer(new Answer<Void>() { public Void answer(InvocationOnMock invocation) { Consumer consumer = (Consumer) invocation.getArguments()[1]; consumer.accept(builder); return null; } }).when(buildService).build(eq(module), any(Consumer.class)); BuildInfo result = buildInfoService.getBuildInfo(module); BuildInfo expectedBuildInfo = new BuildInfoImpl(builder); assertEquals(expectedBuildInfo, result); verify(cache, times(1)).getBuilder(module); verify(buildService, times(1)).build(eq(module), any(Consumer.class)); } }
@Test public void testIsBuiltFalse() { when(cache.assertBuilder(module)).thenReturn(builder); when(builder.isBuilt()).thenReturn(false); assertFalse(buildService.isBuilt(module)); }
@Test public void testIsBuiltTrue() { when(cache.assertBuilder(module)).thenReturn(builder); when(builder.isBuilt()).thenReturn(true); assertTrue(buildService.isBuilt(module)); }
final Builder builder = cache.assertBuilder(module); final InternalKieModule kieModule = (InternalKieModule) builder.getKieModule(); final ByteArrayInputStream input = new ByteArrayInputStream(kieModule.getBytes());