| /******************************************************************************* |
| * Copyright (c) 2010 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| |
| package org.eclipse.ptp.internal.rdt.core.index; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import org.eclipse.cdt.core.CCorePlugin; |
| import org.eclipse.cdt.core.model.ICProject; |
| import org.eclipse.cdt.internal.core.model.CModelManager; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceChangeEvent; |
| import org.eclipse.core.resources.IResourceChangeListener; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.ptp.rdt.core.resources.RemoteNature; |
| import org.eclipse.ptp.rdt.core.services.IRDTServiceConstants; |
| import org.eclipse.ptp.services.core.IService; |
| import org.eclipse.ptp.services.core.IServiceConfiguration; |
| import org.eclipse.ptp.services.core.ServiceModelManager; |
| |
| public class IndexBuildSequenceController implements IResourceChangeListener { |
| |
| public static String INDEX_AFTER_BUILD_OPTION_KEY = "INDEX_AFTER_BUILD"; //$NON-NLS-1$ |
| |
| public static String INDEX_STATUS_KEY = "INDEX_STATUS"; //$NON-NLS-1$ |
| public static String BUILD_STATUS_KEY = "BUILD_STATUS"; //$NON-NLS-1$ |
| |
| public static final String TRUE = String.valueOf(true); |
| public static final String FALSE = String.valueOf(false); |
| |
| public static String STATUS_NEVERRUN = "never_run"; //$NON-NLS-1$ |
| public static String STATUS_RUNNING = "running"; //$NON-NLS-1$ |
| public static String STATUS_INCOMPLETE = "incomplete"; //$NON-NLS-1$ |
| public static String STATUS_COMPLETE = "complete"; //$NON-NLS-1$ |
| |
| // To make a build complete, must follow this build sequence, build_finish, |
| // buildOutput_scanned -> build_complete |
| public static String BUILD_SEQUENCE_STATUS_FINISH = "build_finish"; //$NON-NLS-1$ |
| public static String BUILD_SEQUENCE_STATUS_SCANNED = "build_sanned"; //$NON-NLS-1$ |
| |
| private static Map<String, IndexBuildSequenceController> projectStatusMap = new HashMap<String, IndexBuildSequenceController>(); |
| |
| private IProject project; |
| |
| private String runtimeBuildStatus; |
| |
| private IndexBuildSequenceController(IProject project) { |
| this.project = project; |
| intializeProjectStatus(); |
| ResourcesPlugin.getWorkspace().addResourceChangeListener(this); |
| } |
| |
| private void intializeProjectStatus() { |
| String index_after_build_option=null; |
| String index_status = null; |
| String build_status = null; |
| try { |
| index_after_build_option = project.getPersistentProperty( |
| new QualifiedName("", //$NON-NLS-1$ |
| INDEX_AFTER_BUILD_OPTION_KEY)); |
| index_status = project.getPersistentProperty( |
| new QualifiedName("", //$NON-NLS-1$ |
| INDEX_STATUS_KEY)); |
| build_status = project.getPersistentProperty( |
| new QualifiedName("", //$NON-NLS-1$ |
| BUILD_STATUS_KEY)); |
| |
| if (index_after_build_option == null) { |
| setIndexAfterBuildOption(); |
| } |
| if (index_status == null) { |
| |
| project.setPersistentProperty( |
| new QualifiedName("", //$NON-NLS-1$ |
| INDEX_STATUS_KEY), STATUS_NEVERRUN); |
| |
| } |
| if (build_status == null) { |
| project.setPersistentProperty( |
| new QualifiedName("", //$NON-NLS-1$ |
| BUILD_STATUS_KEY), STATUS_NEVERRUN); |
| } |
| } catch (CoreException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| |
| public static IndexBuildSequenceController getIndexBuildSequenceController(IProject p) { |
| String projectName = p.getName(); |
| IndexBuildSequenceController ps = projectStatusMap.get(projectName); |
| if (ps == null) { |
| |
| ps = new IndexBuildSequenceController(p); |
| projectStatusMap.put(projectName, ps); |
| |
| } |
| return ps; |
| |
| } |
| |
| |
| |
| public String getRuntimeBuildStatus() { |
| return runtimeBuildStatus; |
| } |
| |
| |
| public void setFinalBuildStatus() { |
| if (this.runtimeBuildStatus == null) { |
| setBuildCompleted(); |
| } else if (this.runtimeBuildStatus.equals(STATUS_INCOMPLETE)) { |
| setBuildInCompleted(); |
| } |
| //clear runtime build status |
| runtimeBuildStatus=null; |
| } |
| |
| public void setRuntimeBuildStatus(String runtimeBuildStatus) { |
| this.runtimeBuildStatus = runtimeBuildStatus; |
| } |
| |
| /* |
| * status_property_key will be INDEX_STATUS_KEY or BUILD_STATUS_KEY |
| * expect_status one of STATUS |
| */ |
| public boolean checkStatus(String status_property_key, String expect_status) { |
| String status = null; |
| |
| try { |
| status = project.getPersistentProperty( |
| new QualifiedName("", //$NON-NLS-1$ |
| status_property_key)); |
| } catch (CoreException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| if (status != null) { |
| return status.equals(expect_status); |
| } else { |
| return false; |
| } |
| |
| } |
| |
| public void setIndexAfterBuildOption() { |
| setStatus(INDEX_AFTER_BUILD_OPTION_KEY, TRUE); |
| } |
| |
| public void unsetIndexAfterBuildOption() { |
| setStatus(INDEX_AFTER_BUILD_OPTION_KEY, FALSE); |
| } |
| public boolean isBuildServiceEnabled(){ |
| IService buildService = ServiceModelManager.getInstance().getService(IRDTServiceConstants.SERVICE_BUILD); |
| IServiceConfiguration serviceConfig = ServiceModelManager.getInstance().getActiveConfiguration(project); |
| if(serviceConfig.isDisabled(buildService)){ |
| return false; |
| }else{ |
| return true; |
| } |
| } |
| public boolean isIndexAfterBuildSet(){ |
| |
| //if(isBuildServiceEnabled()){ |
| return checkStatus(INDEX_AFTER_BUILD_OPTION_KEY, TRUE); |
| //}else{ |
| //return false; |
| //} |
| } |
| |
| public boolean isIndexNeverRun() { |
| return checkStatus(INDEX_STATUS_KEY, STATUS_NEVERRUN); |
| } |
| |
| public boolean isIndexRunning() { |
| return checkStatus(INDEX_STATUS_KEY, STATUS_RUNNING); |
| } |
| |
| public boolean isIndexInCompleted() { |
| return checkStatus(INDEX_STATUS_KEY, STATUS_INCOMPLETE); |
| } |
| |
| public boolean isIndexCompleted() { |
| return checkStatus(INDEX_STATUS_KEY, STATUS_COMPLETE); |
| } |
| |
| public boolean isBuildNeverRun() { |
| return checkStatus(BUILD_STATUS_KEY, STATUS_NEVERRUN); |
| } |
| |
| public boolean isBuildRunning() { |
| return checkStatus(BUILD_STATUS_KEY, STATUS_RUNNING); |
| } |
| |
| public boolean isBuildInCompleted() { |
| return checkStatus(BUILD_STATUS_KEY, STATUS_INCOMPLETE); |
| } |
| |
| public boolean isBuildCompleted() { |
| return checkStatus(BUILD_STATUS_KEY, STATUS_COMPLETE); |
| } |
| |
| public void setIndexCompleted() { |
| setStatus(INDEX_STATUS_KEY, STATUS_COMPLETE); |
| } |
| |
| public void setIndexInCompleted() { |
| setStatus(INDEX_STATUS_KEY, STATUS_INCOMPLETE); |
| } |
| |
| public void setIndexRunning() { |
| setStatus(INDEX_STATUS_KEY, STATUS_RUNNING); |
| } |
| |
| public void setBuildCompleted() { |
| setStatus(BUILD_STATUS_KEY, STATUS_COMPLETE); |
| } |
| |
| public void setBuildInCompleted() { |
| setStatus(BUILD_STATUS_KEY, STATUS_INCOMPLETE); |
| } |
| |
| /** |
| * we don't want to clean build to update a never run status |
| */ |
| public void setBuildInCompletedForCleanBuild() { |
| if(!isBuildNeverRun()){ |
| setStatus(BUILD_STATUS_KEY, STATUS_INCOMPLETE); |
| } |
| |
| } |
| |
| public void setBuildRunning() { |
| setStatus(BUILD_STATUS_KEY, STATUS_RUNNING); |
| } |
| |
| /* |
| * status_property_key will be INDEX_STATUS_KEY or BUILD_STATUS_KEY |
| * expect_status one of STATUS |
| */ |
| public void setStatus(String status_property_key, String status_to_set) { |
| try { |
| project.setPersistentProperty(new QualifiedName("", //$NON-NLS-1$ |
| status_property_key), status_to_set); |
| } catch (CoreException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| |
| /* |
| * public void setBuildStatus(String status){ |
| * if(status.equals(BUILD_SEQUENCE_STATUS_FINISH)){ build_sequence_status = |
| * BUILD_SEQUENCE_STATUS_FINISH; } |
| * if(status.equals(BUILD_SEQUENCE_STATUS_SCANNED)){ |
| * if(build_sequence_status.equals(BUILD_SEQUENCE_STATUS_FINISH)){ |
| * build_sequence_status = BUILD_SEQUENCE_STATUS_SCANNED; |
| * setStatus(BUILD_STATUS_KEY, STATUS_COMPLETE); |
| * if(start_index_after_build_complete){ startIndex(); } } } } |
| */ |
| /*** |
| * |
| * |
| * |
| * |
| * ri=reindex, iu=index update, optional ri = prompt user that build is incompleted, provide option if they want to preceed build. |
| * IF=index following build |
| * |
| * |
| * index neverRun index running index incompleted index completed |
| * build disabled as usual as usual as usual as usual |
| * consider as never build iu -> ri |
| * |
| * build never run skip iu, no ri case |
| * |
| * build running must be 1st build |
| * no need this state run IF, skip iu skip IF, skip IF skip IF |
| * provide user a iu, ri as usual iu, ri as usual iu, ri as usual |
| * warning message |
| * if build is |
| * incomplete |
| * |
| * build incomplete -> optional ri, optional ri, optional ri, optional ri |
| * skip iu iu as usual iu as usual iu as usual |
| * |
| * build complete should never be ri, iu as usual as usual as usual |
| * this case |
| * |
| * |
| * |
| * |
| * |
| * |
| */ |
| |
| /** |
| * since we run index after first time build, so the first time building |
| * must be at status of build-running and index-never-run. we want to skip |
| * index update (check when do index update) and run index after build |
| * (check in builder) in this case |
| */ |
| /* |
| public boolean isBeforeOrUnderFirstTimeBuilding() { |
| if (isBuildNeverRun()) { |
| return true; |
| } |
| if (isBuildRunning() && isIndexNeverRun()) { |
| return true; |
| } |
| return false; |
| } |
| */ |
| /** |
| * we call invoke index before update build status, so if the build status is never run at that time, |
| * it must a first build attempt. |
| * @return |
| */ |
| public boolean shouldRunIndexFollowingBuild(){ |
| return isBuildRunning(); |
| } |
| |
| /** |
| * This case should never happen since we run index for first completed build. |
| * But in case it happens, we will turn index update to reindex. |
| * @return |
| */ |
| public boolean shouldTurnIndexUpdateToReindex(){ |
| return isIndexNeverRun()&&isBuildCompleted(); |
| } |
| /** |
| * if index is not done yet, we will skip index update. The only exception is if build is completed, but this case should |
| * never happen since we run index for first completed build. |
| * @return |
| */ |
| public boolean shouldSkipIndexUpdate(){ |
| |
| if(isBuildRunning()){ |
| return true; |
| } |
| if (isIndexNeverRun()){ |
| |
| if(isBuildCompleted()){ |
| return false; |
| } |
| return true; |
| |
| |
| } |
| return false; |
| } |
| |
| /** |
| * this is called from reindex autio after user choose to continue index after an optional index prompt. |
| * the build must be failed at the time. |
| */ |
| public void setBuildIncompleteIfItIsRunning(){ |
| if(isBuildRunning()){ |
| //todo check if build is still running. |
| setBuildInCompleted(); |
| } |
| } |
| /** |
| * skip reindex during the first time build, when build is never run and index is never run. |
| * |
| * this case would alos match if user run an optional reindex(build is never run and index is never run) and select to |
| * continue do index, to solve this conflicts, we will turn index status to running after user selects continue to do index. |
| * @return |
| */ |
| public boolean shouldSkipReindex() |
| { |
| if(isBuildRunning()){ |
| return true; |
| } |
| //the case of build is disable during project creation. |
| return isBuildNeverRun()&&isIndexNeverRun(); |
| } |
| /* |
| * should be called from reindex action |
| * return true if build is never run or incomplete |
| * |
| */ |
| public boolean isOptionalIndex() { |
| return !isBuildCompleted(); |
| } |
| |
| |
| /** |
| * precondition to call this function, |
| * isIndexAfterBuildSet() ==true |
| */ |
| public void invokeIndex(){ |
| |
| |
| |
| Job job = new Job("Indexing Job"){ //$NON-NLS-1$ |
| protected IStatus run(IProgressMonitor monitor) { |
| |
| if(shouldRunIndexFollowingBuild()){ |
| setFinalBuildStatus(); |
| if(isBuildCompleted()){ |
| //for indexing following first time build, only run it after a completed build. |
| ICProject cProject = CModelManager.getDefault().getCModel().getCProject(project); |
| CCorePlugin.getIndexManager().reindex(cProject); |
| //System.out.println("running invoke indexing job. "); //$NON-NLS-1$ |
| } |
| |
| }else{ |
| //System.out.println("not running index job, just update build status. "); //$NON-NLS-1$ |
| setFinalBuildStatus(); |
| } |
| return Status.OK_STATUS; |
| } |
| |
| }; |
| ISchedulingRule rule = ResourcesPlugin.getWorkspace().getRoot(); |
| job.setRule(rule); |
| job.schedule(); |
| |
| //System.out.println("schedule invoke indexing job. "); //$NON-NLS-1$ |
| |
| |
| } |
| |
| private void deleteProjectStaus(String projectName) { |
| projectStatusMap.remove(projectName); |
| } |
| |
| |
| public void resourceChanged(IResourceChangeEvent event) { |
| if (event.getSource() instanceof IWorkspace) { |
| |
| IResource resource = event.getResource(); |
| if (event.getType() == IResourceChangeEvent.PRE_DELETE && resource.getType() == IResource.PROJECT) { |
| deleteProjectStaus(resource.getName()); |
| } |
| } |
| } |
| |
| } |
