@Override public void configure() throws CoreException { IProjectDescription description = project.getDescription(); JPFManifestBuilder.addBuilderToProject(description); project.setDescription(description, null); JPFClasspathContainer.addToProject(JavaCore.create(project)); new Job("Check JPF Manifest") { @Override protected IStatus run(IProgressMonitor monitor) { try { project.build(IncrementalProjectBuilder.FULL_BUILD, JPFManifestBuilder.BUILDER_ID, null, monitor); } catch( CoreException e ) { JPFClasspathLog.logError(e); } return Status.OK_STATUS; } }.schedule(); }
/** * @param buildType single element array; element may be altered to indicate * actual required build type */ public static PgDbParser getParserForBuilder(IProject proj, int[] buildType) { PgDbParser pnew = new PgDbParser(); PgDbParser p = PROJ_PARSERS.putIfAbsent(proj, pnew); if (p == null) { p = pnew; // prepare newly created parser ResourcesPlugin.getWorkspace().addResourceChangeListener(p, IResourceChangeEvent.PRE_CLOSE | IResourceChangeEvent.PRE_DELETE); if (buildType == null) { // not a builder call, start builder startBuildJob(proj); } else { // builder call, change build type to FULL for new parsers buildType[0] = IncrementalProjectBuilder.FULL_BUILD; } } return p; }
@Override protected IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException { if (AsciidocInstance.INSTANCE.getAsciidoctor() == null) { return new IProject[0]; } try { if (kind == IncrementalProjectBuilder.FULL_BUILD) { AsciidocBuildHelper.fullBuild(getProject(), monitor); } else { AsciidocBuildHelper.incrementalBuild(getProject(), getDelta(getProject()), monitor); } } catch (Exception e) { Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e)); } return new IProject[0]; }
@Override protected IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException { if (kind == IncrementalProjectBuilder.FULL_BUILD) { fullBuild(monitor); } else { IResourceDelta delta = getDelta(getProject()); if (delta == null) { fullBuild(monitor); } else { incrementalBuild(delta, monitor); } } return null; }
@Override public void configure() throws CoreException { // Setup the builder IProjectDescription desc = project.getDescription(); ICommand[] builders = desc.getBuildSpec(); ICommand[] newBuilders = new ICommand[builders.length + 1]; System.arraycopy(builders, 0, newBuilders, 0, builders.length); ICommand androidBuilder = desc.newCommand(); androidBuilder.setBuilderName(AndroidBuilder.ID); // We don't autobuild. androidBuilder.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, false); newBuilders[builders.length] = androidBuilder; desc.setBuildSpec(newBuilders); project.setDescription(desc, 0, new NullProgressMonitor()); }
private static void rebuildProjects(final List<IProject> projects) { String name = "rebuild";// Resources.BUNDLE.getString("preferences.compiler.rebuild.job.name"); Job job = new Job(name) { @Override protected IStatus run(IProgressMonitor monitor) { try { for (IProject project : projects) { if (project.isOpen() && project.hasNature(JSweetNature.ID)) { project.build(IncrementalProjectBuilder.CLEAN_BUILD, JSweetBuilder.ID, null, monitor); project.build(IncrementalProjectBuilder.FULL_BUILD, JSweetBuilder.ID, null, monitor); } } return Status.OK_STATUS; } catch (CoreException e) { return e.getStatus(); } } }; job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule()); job.schedule(); }
private static void cleanProjects(final List<IProject> projects) { String name = "clean";// Resources.BUNDLE.getString("preferences.compiler.rebuild.job.name"); Job job = new Job(name) { @Override protected IStatus run(IProgressMonitor monitor) { try { for (IProject project : projects) { if (project.isOpen() && project.hasNature(JSweetNature.ID)) { project.build(IncrementalProjectBuilder.CLEAN_BUILD, JSweetBuilder.ID, null, monitor); } } return Status.OK_STATUS; } catch (CoreException e) { return e.getStatus(); } } }; job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule()); job.schedule(); }
/** * Schedules a full rebuild on a project. * * @param project the project to rebuild */ public static void scheduleRebuild(final IProject project) { WorkspaceJob buildJob = new WorkspaceJob("Building " + project.getName()) { @Override public boolean belongsTo(Object family) { return ResourcesPlugin.FAMILY_MANUAL_BUILD.equals(family); } @Override public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException { project.build(IncrementalProjectBuilder.FULL_BUILD, monitor); return Status.OK_STATUS; } }; buildJob.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule()); buildJob.setUser(true); buildJob.schedule(); }
static private void doBuild(final IProgressMonitor monitor) { try { ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, monitor); // monitor.beginTask("Cleaning and building entire workspace", size); // for (final IProject p : projects) { // if (p.exists() && p.isAccessible()) { // monitor.subTask("Building " + p.getName()); // p.build(IncrementalProjectBuilder.CLEAN_BUILD, monitor); // monitor.worked(1); // } // } } catch (final CoreException e) { e.printStackTrace(); } }
/** * {@inheritDoc} */ @Override protected IProject[] build(final int kind, final Map<String, String> args, final IProgressMonitor monitor) throws CoreException { try { final Optional<? extends FeedbackJavaProject> javaProjectOptional = this.getFeedbackJavaResourceFactory().create(getProject()); if (javaProjectOptional.isPresent()) { final FeedbackJavaProject project = javaProjectOptional.get(); Logger.print(String.format("Triggered %S.", BuildTypes.INSTANCE.get(kind))); if (kind == IncrementalProjectBuilder.FULL_BUILD || kind == IncrementalProjectBuilder.CLEAN_BUILD) { fullBuild(project); } else { incrementalBuild(project); } } } catch (final RequestException e) { new RequestExceptionHandler().handle(getProject(), e); } return null; }
@Override public boolean visit(final IResourceDelta delta) throws CoreException { if (isRelevantForClean(delta)) { IProject project = delta.getResource().getAdapter(IProject.class); Job rebuild = new Job("rebuild") { @Override protected IStatus run(IProgressMonitor monitor) { try { project.build(IncrementalProjectBuilder.FULL_BUILD, monitor); } catch (CoreException e) { LOGGER.error("Exception during rebuild after opening of a project", e); return Status.CANCEL_STATUS; } return Status.OK_STATUS; } }; rebuild.schedule(); } if (isRelevantForDeregister(delta)) { BackgroundTasksAdapter.getManager().deregisterProject((IProject) delta.getResource()); } return true; }
/** * rebuildProjectIndexes */ private void rebuildProjectIndexes() { Job job = new Job(Messages.JSMetadataLoader_Rebuilding_Project_Indexes) { @Override protected IStatus run(IProgressMonitor monitor) { IWorkspace ws = ResourcesPlugin.getWorkspace(); try { ws.build(IncrementalProjectBuilder.FULL_BUILD, monitor); } catch (final CoreException e) { return e.getStatus(); } return Status.OK_STATUS; } }; job.schedule(); }
@Override protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException { if (!PlatformUI.isWorkbenchRunning()) { return new IProject[0]; } IProject[] projects = null; switch (kind) { case IncrementalProjectBuilder.CLEAN_BUILD: clean(monitor); break; case IncrementalProjectBuilder.FULL_BUILD: projects = fullBuild(args, monitor); break; case IncrementalProjectBuilder.AUTO_BUILD: case IncrementalProjectBuilder.INCREMENTAL_BUILD: projects = incrementalBuild(args, monitor); break; } return projects; }
private BuildActionGroup(IWorkbenchSite site, ISelectionProvider specialSelectionProvider, RefreshAction refreshAction) { fSelectionProvider= specialSelectionProvider != null ? specialSelectionProvider : site.getSelectionProvider(); fBuildAction= new BuildAction(new ShellProviderAdapter(site.getShell()), IncrementalProjectBuilder.INCREMENTAL_BUILD); fBuildAction.setText(ActionMessages.BuildAction_label); fBuildAction.setActionDefinitionId(IWorkbenchCommandConstants.PROJECT_BUILD_PROJECT); fRefreshAction= refreshAction; fRefreshAction.setActionDefinitionId(IWorkbenchCommandConstants.FILE_REFRESH); if (specialSelectionProvider != null) { fRefreshAction.setSpecialSelectionProvider(specialSelectionProvider); } fSelectionProvider.addSelectionChangedListener(fBuildAction); fSelectionProvider.addSelectionChangedListener(fRefreshAction); }
private void buildProjects(IProgressMonitor progressMonitor) { Set<IProject> builtProjects= new HashSet<IProject>(10); Object[] elements= fJarPackage.getElements(); for (int i= 0; i < elements.length; i++) { IProject project= null; Object element= elements[i]; if (element instanceof IResource) project= ((IResource)element).getProject(); else if (element instanceof IJavaElement) project= ((IJavaElement)element).getJavaProject().getProject(); if (project != null && !builtProjects.contains(project)) { try { project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, progressMonitor); } catch (CoreException ex) { String message= Messages.format(JarPackagerMessages.JarFileExportOperation_errorDuringProjectBuild, BasicElementLabels.getResourceName(project)); addError(message, ex); } finally { // don't try to build same project a second time even if it failed builtProjects.add(project); } } } }
protected boolean shouldBuild(int kind, IManagedBuildInfo info) { IConfiguration cfg = info.getDefaultConfiguration(); IBuilder builder = null; if (cfg != null) { builder = cfg.getEditableBuilder(); switch (kind) { case IncrementalProjectBuilder.AUTO_BUILD : return true; case IncrementalProjectBuilder.INCREMENTAL_BUILD : // now treated as the same! case IncrementalProjectBuilder.FULL_BUILD : return builder.isFullBuildEnabled() | builder.isIncrementalBuildEnabled() ; case IncrementalProjectBuilder.CLEAN_BUILD : return builder.isCleanBuildEnabled(); } } return true; }
static ICommand[] getBuildCommandsList(IProjectDescription description, ICommand[] commands) { ArrayList<ICommand> commandList = new ArrayList<ICommand>(); // Make sure the CMake builder just precedes the Common Builder for (int i = 0; i < commands.length; i++) { ICommand command = commands[i]; if (command.getBuilderName().equals(CMakeProjectBuilderImpl.BUILDER_ID)) { // ignore it } else { if (command.getBuilderName().equals(BUILDER_ID)) { // add CMake Configuration builder just before builder ICommand newCommand = description.newCommand(); newCommand.setBuilderName(CMakeProjectBuilderImpl.BUILDER_ID); newCommand.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, false); newCommand.setBuilding(IncrementalProjectBuilder.CLEAN_BUILD, true); newCommand.setBuilding(IncrementalProjectBuilder.FULL_BUILD, true); newCommand.setBuilding(IncrementalProjectBuilder.INCREMENTAL_BUILD, true); commandList.add(newCommand); } commandList.add(command); } } return commandList.toArray(new ICommand[commandList.size()]); }
@Override protected IProject[] build(final int kind, @SuppressWarnings("rawtypes") final Map args, final IProgressMonitor monitor) throws CoreException { final IProject project = getProject(); monitor.beginTask("Building Apache Karaf project: " + project.getName(), 1); try { if (kind == IncrementalProjectBuilder.FULL_BUILD) { fullBuild(monitor); } else { final IResourceDelta delta = getDelta(getProject()); if (delta == null) { fullBuild(monitor); } else { incrementalBuild(delta, monitor); } } getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor); } finally { monitor.done(); } return null; }
public static File buildProject(IProject project) throws CoreException{ project.build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor()); project.build(IncrementalProjectBuilder.FULL_BUILD, new NullProgressMonitor()); IMarker[] markers; markers = project.findMarkers(IMarker.PROBLEM, true,IResource.DEPTH_INFINITE); boolean errorsExists=false; StringBuffer sb=new StringBuffer(); for (IMarker marker : markers) { if(marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR) == IMarker.SEVERITY_ERROR) { sb.append(marker.getAttribute(IMarker.MESSAGE)).append("\n"); errorsExists=true; } } if (errorsExists){ throw new CoreException(new Status(IStatus.ERROR,Activator.PLUGIN_ID,"Compilation error exists in the project "+project.getName()+". Please resolve these error before continuing:\n"+sb.toString())); } return new File(project.getWorkspace().getRoot().getFolder(getJavaOutputDirectory(project)).getLocation().toOSString()); }
@Override public void doSave(IProgressMonitor progress) { if (isDirty()) { // save the contents of the source editor, always pfe.doSave(progress); dbBean.save(progress); // no real saving here, but some necessary cleanup xspDesignPropsBean.save(progress); page1.getDataNode().setModelModified(false); page2.getDataNode().setModelModified(false); page3.getDataNode().setModelModified(false); setModified(false); if (isBPromptRecompileOnExit()) { if( LWPDMessageDialog.openQuestion(null, "Domino Designer", // $NLX-XSPParentEditor.DominoDesigner-1$ "You have changed the minimum supported version for XPages in this application. Do you want to rebuild this application now?") ) { // $NLX-XSPParentEditor.Youhavechangedtheminimumsupported-1$ try { getDesignerProject().build(IncrementalProjectBuilder.FULL_BUILD, new NullProgressMonitor()); } catch (CoreException e) { } } setBPromptRecompileOnExit(false); // if they chose no, still should not prompt again } NSFComponentModule.setLastDesignerSave(System.currentTimeMillis()); } }
protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException { monitor.beginTask("Creating project...", 3); createProject(fProject, fPath, monitor); fProject.open(monitor); addNatureToProject(fProject, XTEXT_NATURE_ID, monitor); monitor.worked(1); monitor.subTask("Creating files..."); createMainFile(); if ((Boolean) fProperties.withExampleData.getValue()) { copyTemplate(); } fProject.build(IncrementalProjectBuilder.CLEAN_BUILD, monitor); monitor.worked(1); openFile(fProject.getFile("main.cmdline")); monitor.worked(1); }
public static void loadFilesThatNeedFixing() throws CoreException, IOException { makeJavaProject(); TestingUtils.copyBrokenFiles(testIProject.getFolder(SRC_FOLDER_NAME), new File("classesToFix/"), new File("mockLibraries/")); // Compiles the code testIProject.refreshLocal(IResource.DEPTH_INFINITE, null); testIProject.build(IncrementalProjectBuilder.FULL_BUILD, null); FindbugsPlugin.setProjectSettingsEnabled(testIProject, null, true); UserPreferences userPrefs = FindbugsPlugin.getUserPreferences(testIProject); // enables categories like Security, which are disabled by default userPrefs.getFilterSettings().clearAllCategories(); checkFBContribInstalled(); checkFindSecurityBugsInstalled(); TestingUtils.waitForUiEvents(100); }
public void test_p001_simple() throws Exception { ResolverConfiguration configuration = new ResolverConfiguration(); IProject project1 = importProject( "projects/castor/castor-p001/pom.xml", configuration ); waitForJobsToComplete(); project1.build( IncrementalProjectBuilder.FULL_BUILD, monitor ); project1.build( IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor ); waitForJobsToComplete(); assertNoErrors( project1 ); IJavaProject javaProject1 = JavaCore.create( project1 ); IClasspathEntry[] cp1 = javaProject1.getRawClasspath(); assertEquals( new Path( "/castor-p001/target/generated-sources/castor" ), cp1[3].getPath() ); assertTrue( project1.getFile( "target/generated-sources/castor/test/Tags.java" ).isSynchronized( IResource.DEPTH_ZERO ) ); assertTrue( project1.getFile( "target/generated-sources/castor/test/Tags.java" ).isAccessible() ); }
public void test_p002_simple() throws Exception { ResolverConfiguration configuration = new ResolverConfiguration(); IProject project1 = importProject( "projects/castor/castor-p002/pom.xml", configuration ); waitForJobsToComplete(); project1.build( IncrementalProjectBuilder.FULL_BUILD, monitor ); project1.build( IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor ); waitForJobsToComplete(); assertNoErrors( project1 ); IJavaProject javaProject1 = JavaCore.create( project1 ); IClasspathEntry[] cp1 = javaProject1.getRawClasspath(); assertEquals( new Path( "/castor-p002/target/generated-sources/castor" ), cp1[3].getPath() ); assertTrue( project1.getFile( "target/generated-sources/castor/test/Tags.java" ).isSynchronized( IResource.DEPTH_ZERO ) ); assertTrue( project1.getFile( "target/generated-sources/castor/test/Tags.java" ).isAccessible() ); }
@Override protected IStatus run(final IProgressMonitor monitor) { if (EmfToolsPlugin.trace) { System.out.println("Running Xtend/Xpand builder for project " + project.getName()); } try { project.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, XtendXpandBuilder.getBUILDER_ID(), null, monitor); } catch (final CoreException e) { if (EmfToolsPlugin.trace) { e.printStackTrace(); } } return Status.OK_STATUS; }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException { IProject[] retval = super.build(kind, args, monitor); if (kind == IncrementalProjectBuilder.FULL_BUILD) { fullBuild(monitor); } else { IResourceDelta delta = getDelta(project); if (delta == null) { fullBuild(monitor); } else { incrementalBuild(delta, monitor); } } return retval; }
/** * Adds a builder to the build spec for the configured project. */ protected void addToBuildSpec(String builderID) throws CoreException { IProjectDescription description = project.getDescription(); ICommand[] commands = description.getBuildSpec(); int commandIndex = getCommandIndex(commands, builderID); if (commandIndex == -1) { ICommand command = description.newCommand(); command.setBuilderName(builderID); command.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, false); // Add a build command to the build spec ICommand[] newCommands = ArrayUtil.prepend(command, commands); description.setBuildSpec(newCommands); project.setDescription(description, null); } }
protected void cleanProject() throws CoreException { getRoot().getProject(projectName).build(IncrementalProjectBuilder.CLEAN_BUILD, getNullMonitor()); boolean wasInterrupted = false; do { try { Job.getJobManager().join(ResourcesPlugin.FAMILY_MANUAL_BUILD, null); wasInterrupted = false; } catch (OperationCanceledException ignore) { } catch (InterruptedException e) { wasInterrupted = true; } } while (wasInterrupted); }
public static void fullBuild() throws CoreException { ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, getNullMonitor()); boolean interrupted = false; do { try { Job.getJobManager().wakeUp(ResourcesPlugin.FAMILY_MANUAL_BUILD); Job.getJobManager().join(ResourcesPlugin.FAMILY_MANUAL_BUILD, null); interrupted = false; } catch (OperationCanceledException ignore) { } catch (InterruptedException e) { interrupted = true; } } while (interrupted); }
public static void cleanBuild() throws CoreException { ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, getNullMonitor()); boolean wasInterrupted = false; do { try { Job.getJobManager().join(ResourcesPlugin.FAMILY_MANUAL_BUILD, null); Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null); wasInterrupted = false; } catch (OperationCanceledException ignore) { } catch (InterruptedException e) { wasInterrupted = true; } } while (wasInterrupted); }
private static void startBuildJob(IProject proj) { BuildAction build = new BuildAction( PlatformUI.getWorkbench().getActiveWorkbenchWindow(), IncrementalProjectBuilder.FULL_BUILD); build.selectionChanged(new StructuredSelection(proj)); build.runInBackground(null); }
@Override public void triggerProjectRebuild() { WorkspaceJob build = new WorkspaceJob("rebuild") { @Override public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException { ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, monitor); return Status.OK_STATUS; } }; build.schedule(); }
public void triggerBuild(IProject project) throws CoreException { if (isVisuflowNatureEnabled(project) && ResourcesPlugin.getWorkspace().isAutoBuilding()) { WorkspaceJob fullBuild = new WorkspaceJob("Full build for " + project.getName()) { @Override public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException { project.build(IncrementalProjectBuilder.FULL_BUILD, monitor); return Status.OK_STATUS; } }; fullBuild.schedule(); } }
public static void issueIncrementalBuild(final IProject project, final String builderId) { LOGGER.trace("Issuing initial build for project " + project.getName()); try { for (ICommand buildCommand : project.getDescription().getBuildSpec()) { if (buildCommand.getBuilderName().equals(builderId)) { project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, builderId, new HashMap<String, String>(), new NullProgressMonitor()); } } } catch (CoreException e) { LOGGER.fatal("Could not issue initial build for project " + project.getName() + ":\n" + e); } }
public void run(IAction action) { IResource res = (IResource) editor.getEditorInput().getAdapter(IResource.class); if (res == null) return; IProject project = res.getProject(); TexlipseProperties.setSessionProperty(project, TexlipseProperties.FORCED_REBUILD, true); try { project.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, null); } catch (CoreException e) { TexlipsePlugin.log("Force rebuild CoreException", e); } TexlipseProperties.setSessionProperty(project, TexlipseProperties.FORCED_REBUILD, null); }
@Override protected void initProjectDescription(IProjectDescription description) { description.setNatureIds(new String[] { JavaCore.NATURE_ID, AndroidNature.ID }); ICommand javaBuilder = description.newCommand(); javaBuilder.setBuilderName(JavaCore.BUILDER_ID); ICommand androidBuilder = description.newCommand(); androidBuilder.setBuilderName(AndroidBuilder.ID); androidBuilder.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, false); description.setBuildSpec(new ICommand[] { javaBuilder, androidBuilder }); }