static {
   IProjectFacet jsfFacet = null;
   if (ProjectFacetsManager.isProjectFacetDefined(JSF_FACET_ID)) {
     jsfFacet = ProjectFacetsManager.getProjectFacet(JSF_FACET_ID);
   }
   JSF_FACET = jsfFacet;
 }
예제 #2
0
  public static boolean isLiferayProject(IProject project) {
    boolean retval = false;

    if (project == null) {
      return retval;
    }

    try {
      IFacetedProject facetedProject = ProjectFacetsManager.create(project);

      if (facetedProject != null) {
        for (IProjectFacetVersion facet : facetedProject.getProjectFacets()) {
          IProjectFacet projectFacet = facet.getProjectFacet();

          if (projectFacet.getId().startsWith("liferay")) {
            retval = true;
            break;
          }
        }
      }
    } catch (Exception e) {
    }

    return retval;
  }
예제 #3
0
 public static IFacetedProject getFacetedProject(IProject project) {
   try {
     return ProjectFacetsManager.create(project);
   } catch (CoreException e) {
     return null;
   }
 }
예제 #4
0
 public static IProjectFacet getProjectFacet(String id) {
   try {
     return ProjectFacetsManager.getProjectFacet(id);
   } catch (IllegalArgumentException e) {
     return null;
   }
 }
  @Override
  protected IModule createModule(IProject project) {
    try {
      IFacetedProject facetedProject = ProjectFacetsManager.create(project);
      if (facetedProject != null && facetedProject.hasProjectFacet(facet)) {
        IProjectFacetVersion projectFacetVersion = facetedProject.getInstalledVersion(facet);
        String version = projectFacetVersion.getVersionString();
        IModule module =
            createModule(
                project.getName(),
                project.getName(),
                SwordfishConstants.SWORDFISH_APPLICATION_TYPE,
                version,
                project);

        SwordfishApplicationDeployable deployable = new SwordfishApplicationDeployable(project);
        deployable.initialize(module);
        moduleDelegates.add(deployable);

        return module;
      }
    } catch (CoreException e) {
      e.printStackTrace();
    }
    return null;
  }
  protected void configureWtpUtil(
      IProject project, MavenProject mavenProject, IProgressMonitor monitor) throws CoreException {
    // Adding utility facet on JEE projects is not allowed
    if (WTPProjectsUtil.isJavaEEProject(project)) {
      return;
    }

    IFacetedProject facetedProject = ProjectFacetsManager.create(project, true, monitor);
    Set<Action> actions = new LinkedHashSet<Action>();
    installJavaFacet(actions, project, facetedProject);

    if (!facetedProject.hasProjectFacet(WTPProjectsUtil.UTILITY_FACET)) {
      actions.add(
          new IFacetedProject.Action(
              IFacetedProject.Action.Type.INSTALL, WTPProjectsUtil.UTILITY_10, null));
    } else if (!facetedProject.hasProjectFacet(WTPProjectsUtil.UTILITY_10)) {
      actions.add(
          new IFacetedProject.Action(
              IFacetedProject.Action.Type.VERSION_CHANGE, WTPProjectsUtil.UTILITY_10, null));
    }

    if (!actions.isEmpty()) {
      facetedProject.modify(actions, monitor);
    }

    // MNGECLIPSE-904 remove tests folder links for utility jars
    // TODO handle modules in a parent pom (the following doesn't work)
    removeTestFolderLinks(project, mavenProject, monitor, "/");

    // Remove "library unavailable at runtime" warning.
    setNonDependencyAttributeToContainer(project, monitor);
  }
예제 #7
0
 private static IProjectFacet getWebDocletFacet() {
   try {
     return ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.DYNAMIC_WEB_XDOCLET);
   } catch (IllegalArgumentException e) {
     // the web doclet facet is not defined
     return null;
   }
 }
  static class DeploymentTypeValidator implements IValidator {

    String propertyName;

    IDataModel model;

    static final IProjectFacet EJB_FACET =
        ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EJB_MODULE);

    static final IProjectFacetVersion EJB_30 = EJB_FACET.getVersion("3.0"); // $NON-NLS-1$

    static final IProjectFacet EAR_FACET =
        ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE);

    static final IProjectFacetVersion EAR_50 = EAR_FACET.getVersion("5.0"); // $NON-NLS-1$

    /** */
    public DeploymentTypeValidator(String propertyName, IDataModel model) {
      this.propertyName = propertyName;
      this.model = model;
    }

    /** @see IValidator#validate(Object, Object) */
    public Map<String, IStatus> validate(Object value, Object context) {
      final String deploymentType = value.toString();
      if (!ISeamFacetDataModelProperties.DEPLOY_AS_WAR.equals(deploymentType)) {
        Object runtimeName =
            model.getProperty(IFacetProjectCreationDataModelProperties.FACET_RUNTIME);
        if (runtimeName != null) {
          IRuntime rt = RuntimeManager.getRuntime(runtimeName.toString());
          if (!rt.supports(EJB_30) || !rt.supports(EAR_50)) {
            return SeamValidatorFactory.createErrormessage(
                propertyName,
                new Status(
                    IStatus.ERROR,
                    SeamCorePlugin.PLUGIN_ID,
                    NLS.bind(
                        SeamCoreMessages.SEAM_INSTALL_WIZARD_PAGE_CANNOT_USE_SELECTED_DEPLOYMENT6,
                        new String[] {deploymentType.toUpperCase(), runtimeName.toString()})));
          }
        }
      }
      return SeamValidatorFactory.NO_ERRORS;
    }
  }
 /**
  * Add a mapping for some facet type to some default extension
  *
  * @param facet
  * @param extension
  * @return
  */
 public boolean addDefaultExtension(String facet, String extension) {
   if (!mapping.containsKey(facet)) {
     if (ProjectFacetsManager.isProjectFacetDefined(facet)) {
       mapping.put(facet, extension);
       return true;
     }
   }
   return false;
 }
public class SwordfishApplicationDeployableFactory extends ProjectModuleFactoryDelegate {

  private IProjectFacet facet =
      ProjectFacetsManager.getProjectFacet(SwordfishConstants.SWORDFISH_APPLICATION_TYPE);

  private List<ModuleDelegate> moduleDelegates = new ArrayList<ModuleDelegate>();

  @Override
  public ModuleDelegate getModuleDelegate(IModule module) {
    for (ModuleDelegate moduleDelegate : moduleDelegates) {
      if (moduleDelegate.getModule() == module) {
        return moduleDelegate;
      }
    }
    return null;
  }

  @Override
  protected IModule createModule(IProject project) {
    try {
      IFacetedProject facetedProject = ProjectFacetsManager.create(project);
      if (facetedProject != null && facetedProject.hasProjectFacet(facet)) {
        IProjectFacetVersion projectFacetVersion = facetedProject.getInstalledVersion(facet);
        String version = projectFacetVersion.getVersionString();
        IModule module =
            createModule(
                project.getName(),
                project.getName(),
                SwordfishConstants.SWORDFISH_APPLICATION_TYPE,
                version,
                project);

        SwordfishApplicationDeployable deployable = new SwordfishApplicationDeployable(project);
        deployable.initialize(module);
        moduleDelegates.add(deployable);

        return module;
      }
    } catch (CoreException e) {
      e.printStackTrace();
    }
    return null;
  }

  @Override
  protected IPath[] getListenerPaths() {
    return new IPath[] {
      new Path(".project"),
      new Path("feature.xml"),
      new Path(".settings/org.eclipse.wst.common.project.facet.core.xml"),
    };
  }
}
  private void initControls() {

    _switchYardProject =
        SwitchYardProjectManager.instance().getSwitchYardProject(getProject()).createWorkingCopy();
    if (_switchYardProject.needsLoading()) {
      BusyIndicator.showWhile(
          getShell().getDisplay(),
          new Runnable() {
            @Override
            public void run() {
              _switchYardProject.load(new NullProgressMonitor());
            }
          });
    }
    try {
      _ifp = ProjectFacetsManager.create(_switchYardProject.getProject());
      _ifpwc = SharedWorkingCopyManager.getWorkingCopy(_ifp);
      _configuredRuntimes = _ifpwc.getTargetedRuntimes();
    } catch (CoreException e) {
      Activator.getDefault().getLog().log(e.getStatus());
    }

    _settingsGroup.setProject(_ifpwc);

    initTargetRuntime();
    initRuntimeVersion();
    initComponentsTable();

    _useSwitchYardDependencyBOMCheckbox.setSelection(pomUsesSwitchYardBOM());

    String errmsg = null;
    if (!pomDefinesSwitchYardVersion()) {
      _settingsGroup.setRuntimeControlEnablement(false);
    } else if (pomUsesSwitchYardBOM()) {
      if (!isSelectedRuntimeVersion2OrHigher()) {
        // only valid versions with BOM dependency support are 2.0+
        errmsg = Messages.ProjectConfigurationWizardPage_errorMessage_bomRequiresVersion2;
      }
    } else if (!isSelectedConfigurationVersionOkForRuntime()) {
      String configVersion = getMajorMinorFromVersion(getRuntimeVersion().toString());
      errmsg =
          "The Configuration Version must be "
              + configVersion
              + " or lower to work with Library Version "
              + getRuntimeVersion().toString()
              + ".";
    }
    setErrorMessage(errmsg);
    getContainer().updateMessage();
  }
예제 #12
0
public class WebFacetUtils {

  public static final IProjectFacet WEB_FACET =
      ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.DYNAMIC_WEB);
  public static final IProjectFacet WEBFRAGMENT_FACET =
      ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.WEBFRAGMENT);
  public static final IProjectFacetVersion WEB_22 = WEB_FACET.getVersion("2.2"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEB_23 = WEB_FACET.getVersion("2.3"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEB_24 = WEB_FACET.getVersion("2.4"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEB_25 = WEB_FACET.getVersion("2.5"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEB_30 = WEB_FACET.getVersion("3.0"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEB_31 = WEB_FACET.getVersion("3.1"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEBFRAGMENT_30 =
      WEBFRAGMENT_FACET.getVersion("3.0"); // $NON-NLS-1$
  public static final IProjectFacetVersion WEBFRAGMENT_31 =
      WEBFRAGMENT_FACET.getVersion("3.1"); // $NON-NLS-1$

  public static final IProjectFacet WEB_XDOCLET_FACET = getWebDocletFacet();

  public static IProjectFacet getProjectFacet(String id) {
    try {
      return ProjectFacetsManager.getProjectFacet(id);
    } catch (IllegalArgumentException e) {
      return null;
    }
  }

  private static IProjectFacet getWebDocletFacet() {
    try {
      return ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.DYNAMIC_WEB_XDOCLET);
    } catch (IllegalArgumentException e) {
      // the web doclet facet is not defined
      return null;
    }
  }
}
예제 #13
0
  public static IPath getPortalDir(IProject project) {
    try {
      IFacetedProject facetedProject = ProjectFacetsManager.create(project);

      org.eclipse.wst.common.project.facet.core.runtime.IRuntime runtime =
          facetedProject.getPrimaryRuntime();

      if (runtime != null) {
        return ServerUtil.getPortalDir(runtime);
      }
    } catch (CoreException e) {
      LiferayServerCorePlugin.logError(e);
    }

    return null;
  }
  @Override
  public void configure(ProjectConfigurationRequest request, IProgressMonitor monitor)
      throws CoreException {
    final MavenProject mavenProject = request.getMavenProject();
    final Plugin liferayMavenPlugin = LiferayMavenUtil.getLiferayMavenPlugin(mavenProject);

    if (!shouldConfigure(liferayMavenPlugin)) {
      return;
    }

    final IProject project = request.getProject();
    final IFile pomFile = project.getFile(IMavenConstants.POM_FILE_NAME);
    final IFacetedProject facetedProject = ProjectFacetsManager.create(project, false, monitor);

    removeLiferayMavenMarkers(project);

    final List<MavenProblemInfo> errors = findLiferayMavenPluginProblems(project, mavenProject);

    if (errors.size() > 0) {
      try {
        this.markerManager.addErrorMarkers(
            pomFile, ILiferayMavenConstants.LIFERAY_MAVEN_MARKER_CONFIGURATION_ERROR_ID, errors);
      } catch (CoreException e) {
        // no need to log this error its just best effort
      }

      return;
    }

    if (shouldInstallNewLiferayFacet(facetedProject)) {
      final MavenProblemInfo installProblem =
          installNewLiferayFacet(facetedProject, mavenProject, monitor);

      if (installProblem != null) {
        this.markerManager.addMarker(
            pomFile,
            ILiferayMavenConstants.LIFERAY_MAVEN_MARKER_CONFIGURATION_ERROR_ID,
            installProblem.getMessage(),
            installProblem.getLocation().getLineNumber(),
            IMarker.SEVERITY_WARNING);
      }
    }
  }
예제 #15
0
  public static boolean hasFacet(IProject project, IProjectFacet checkProjectFacet) {
    boolean retval = false;
    if (project == null || checkProjectFacet == null) {
      return retval;
    }

    try {
      IFacetedProject facetedProject = ProjectFacetsManager.create(project);
      if (facetedProject != null && checkProjectFacet != null) {
        for (IProjectFacetVersion facet : facetedProject.getProjectFacets()) {
          IProjectFacet projectFacet = facet.getProjectFacet();
          if (checkProjectFacet.equals(projectFacet)) {
            retval = true;
            break;
          }
        }
      }
    } catch (CoreException e) {
    }
    return retval;
  }
 /** @return */
 private Object getDeployAsDefaultValue() {
   String result =
       SeamProjectPreferences.getStringPreference(
           SeamProjectPreferences.JBOSS_AS_DEFAULT_DEPLOY_AS);
   if (!isSeamProjectWizard()) {
     ISelection sel =
         PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection();
     IProject project = SeamWizardUtils.getInitialProject(sel);
     if (project == null) {
       SeamCorePlugin.getPluginLog()
           .logError(
               "Can't get project name to initialize SeamInstallWizardPage for ModifyFacetedProjectWizard");
       return result;
     }
     IFacetedProject facetedProject;
     try {
       facetedProject = ProjectFacetsManager.create(project);
       if (facetedProject == null) {
         SeamCorePlugin.getPluginLog()
             .logError(
                 "Can't get faceted project to initialize SeamInstallWizardPage for ModifyFacetedProjectWizard");
         return result;
       }
     } catch (CoreException e) {
       SeamCorePlugin.getPluginLog().logError(e);
       return result;
     }
     IProjectFacetVersion webVersion =
         facetedProject.getProjectFacetVersion(IJ2EEFacetConstants.DYNAMIC_WEB_FACET);
     if (webVersion != null) {
       return ISeamFacetDataModelProperties.DEPLOY_AS_WAR;
     } else {
       return ISeamFacetDataModelProperties.DEPLOY_AS_EAR;
     }
   }
   return result;
 }
예제 #17
0
/**
 * The activator class controls the plugin life cycle
 *
 * @auther Greg Amerson
 * @author Cindy Li
 */
public class PortletCore extends Plugin {

  public static final IProjectFacet JSF_FACET =
      ProjectFacetsManager.getProjectFacet(IJSFCoreConstants.JSF_CORE_FACET_ID);

  // The plugin ID
  public static final String PLUGIN_ID = "com.liferay.ide.portlet.core"; // $NON-NLS-1$

  public static final String PREF_KEY_PORTLET_SUPERCLASSES_USED =
      "portlet-superclasses-used"; //$NON-NLS-1$

  // The shared instance
  private static PortletCore plugin;

  public static BuildLanguageJob createBuildLanguageJob(IFile file) {
    BuildLanguageJob job = new BuildLanguageJob(file);

    return job;
  }

  public static IStatus createErrorStatus(Exception e) {
    return new Status(IStatus.ERROR, PLUGIN_ID, e.getMessage(), e);
  }

  public static IStatus createErrorStatus(String msg) {
    return new Status(IStatus.ERROR, PLUGIN_ID, msg);
  }

  public static IStatus createErrorStatus(String msg, Exception e) {
    return new Status(IStatus.ERROR, PLUGIN_ID, msg, e);
  }

  public static IStatus createWarningStatus(String msg) {
    return new Status(IStatus.WARNING, PLUGIN_ID, msg);
  }

  /**
   * Returns the shared instance
   *
   * @return the shared instance
   */
  public static PortletCore getDefault() {
    return plugin;
  }

  public static Preferences getPreferences() {
    @SuppressWarnings("deprecation")
    final IScopeContext scope = new InstanceScope();

    return scope.getNode(PLUGIN_ID);
  }

  public static void logError(Exception ex) {
    getDefault().getLog().log(createErrorStatus(ex));
  }

  public static void logError(String msg, Exception e) {
    getDefault().getLog().log(createErrorStatus(msg, e));
  }

  /** The constructor */
  public PortletCore() {}

  /*
   * (non-Javadoc)
   * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext )
   */
  public void start(BundleContext context) throws Exception {

    super.start(context);

    plugin = this;
  }

  /*
   * (non-Javadoc)
   * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext )
   */
  public void stop(BundleContext context) throws Exception {

    plugin = null;

    super.stop(context);
  }
}
  protected void configure(IProject project, MavenProject mavenProject, IProgressMonitor monitor)
      throws CoreException {
    IFacetedProject facetedProject = ProjectFacetsManager.create(project, true, monitor);
    IMavenProjectFacade facade =
        MavenPlugin.getMavenProjectRegistry()
            .create(project.getFile(IMavenConstants.POM_FILE_NAME), true, monitor);

    // make sure to update the main deployment folder
    WarPluginConfiguration config = new WarPluginConfiguration(mavenProject, project);
    String warSourceDirectory = config.getWarSourceDirectory();

    IFolder contentFolder = project.getFolder(warSourceDirectory);

    Set<Action> actions = new LinkedHashSet<Action>();

    installJavaFacet(actions, project, facetedProject);

    IVirtualComponent component = ComponentCore.createComponent(project, true);

    // MNGECLIPSE-2279 get the context root from the final name of the project, or artifactId by
    // default.
    String contextRoot = getContextRoot(mavenProject, config.getWarName());

    IProjectFacetVersion webFv = config.getWebFacetVersion(project);
    IDataModel webModelCfg = getWebModelConfig(warSourceDirectory, contextRoot);
    if (!facetedProject.hasProjectFacet(WebFacetUtils.WEB_FACET)) {
      removeConflictingFacets(facetedProject, webFv, actions);
      actions.add(
          new IFacetedProject.Action(IFacetedProject.Action.Type.INSTALL, webFv, webModelCfg));
    } else {
      IProjectFacetVersion projectFacetVersion =
          facetedProject.getProjectFacetVersion(WebFacetUtils.WEB_FACET);
      if (webFv.getVersionString() != null
          && !webFv.getVersionString().equals(projectFacetVersion.getVersionString())) {
        actions.add(
            new IFacetedProject.Action(
                IFacetedProject.Action.Type.VERSION_CHANGE, webFv, webModelCfg));
      }
    }

    String customWebXml = config.getCustomWebXml(project);

    if (!actions.isEmpty()) {
      ResourceCleaner fileCleaner = new ResourceCleaner(project);
      try {
        addFilesToClean(fileCleaner, facade.getResourceLocations());
        addFilesToClean(fileCleaner, facade.getCompileSourceLocations());
        IFolder libDir = project.getFolder(warSourceDirectory).getFolder("WEB-INF/lib");
        fileCleaner.addFiles(
            contentFolder.getFile("META-INF/MANIFEST.MF").getProjectRelativePath());
        fileCleaner.addFolder(libDir, false);
        if (customWebXml != null) {
          IFile defaultWebXml = project.getFolder(warSourceDirectory).getFile("WEB-INF/web.xml");
          fileCleaner.addFiles(defaultWebXml.getProjectRelativePath());
        }

        facetedProject.modify(actions, monitor);
      } finally {
        // Remove any unwanted MANIFEST.MF the Facet installation has created
        fileCleaner.cleanUp();
      }
    }

    // MECLIPSEWTP-41 Fix the missing moduleCoreNature
    fixMissingModuleCoreNature(project, monitor);

    // MNGECLIPSE-632 remove test sources/resources from WEB-INF/classes
    removeTestFolderLinks(project, mavenProject, monitor, "/WEB-INF/classes");

    addContainerAttribute(project, DEPENDENCY_ATTRIBUTE, monitor);

    // MNGECLIPSE-2279 change the context root if needed
    if (!contextRoot.equals(J2EEProjectUtilities.getServerContextRoot(project))) {
      J2EEProjectUtilities.setServerContextRoot(project, contextRoot);
    }

    // If we have a custom web.xml but WTP created one against our will, we delete it
    if (customWebXml != null) {
      linkFileFirst(project, customWebXml, "/WEB-INF/web.xml", monitor);
    }

    component = ComponentCore.createComponent(project, true);
    if (component != null) {
      IPath warPath = new Path("/").append(contentFolder.getProjectRelativePath());
      List<IPath> sourcePaths = new ArrayList<IPath>();
      sourcePaths.add(warPath);
      if (!WTPProjectsUtil.hasLink(project, ROOT_PATH, warPath, monitor)) {
        component.getRootFolder().createLink(warPath, IVirtualResource.NONE, monitor);
      }
      // MECLIPSEWTP-22 support web filtered resources. Filtered resources directory must be
      // declared BEFORE
      // the regular web source directory. First resources discovered take precedence on deployment
      IPath filteredFolder =
          new Path("/")
              .append(WebResourceFilteringConfiguration.getTargetFolder(mavenProject, project));

      boolean useBuildDir =
          MavenWtpPlugin.getDefault()
              .getMavenWtpPreferencesManager()
              .getPreferences(project)
              .isWebMavenArchiverUsesBuildDirectory();
      boolean useWebresourcefiltering =
          config.getWebResources() != null && config.getWebResources().length > 0
              || config.isFilteringDeploymentDescriptorsEnabled();

      if (useBuildDir || useWebresourcefiltering) {

        if (!useBuildDir && useWebresourcefiltering) {
          mavenMarkerManager.addMarker(
              project,
              MavenWtpConstants.WTP_MARKER_CONFIGURATION_ERROR_ID,
              Messages.markers_mavenarchiver_output_settings_ignored_warning,
              -1,
              IMarker.SEVERITY_WARNING);
        }
        sourcePaths.add(filteredFolder);
        WTPProjectsUtil.insertLinkBefore(project, filteredFolder, warPath, new Path("/"), monitor);
      } else {
        component.getRootFolder().removeLink(filteredFolder, IVirtualResource.NONE, monitor);
      }

      WTPProjectsUtil.deleteLinks(project, ROOT_PATH, sourcePaths, monitor);

      WTPProjectsUtil.setDefaultDeploymentDescriptorFolder(
          component.getRootFolder(), warPath, monitor);

      addComponentExclusionPatterns(component, config);
    }

    WTPProjectsUtil.removeWTPClasspathContainer(project);

    // MECLIPSEWTP-214 : add (in|ex)clusion patterns as .component metadata
  }
예제 #19
0
  /**
   * TODO: this is probably not the best way to do things. This one test validates most of the
   * functionality in tools.ui. However, starting and stopping a workbench takes a lot of time and
   * we need a project to run the service creation tests so...
   *
   * <p>Tests the creation of a SwitchYard project: project, pom.xml, switchyard.xml creation.
   *
   * <p>Test dependency update operation.
   *
   * <p>Tests the creation of a new SwitchYard service.
   *
   * @throws Exception if an error occurs or test fails.
   */
  public void testCreateSwitchYardProjectOperation() throws Exception {
    final IWorkspace workspace = ResourcesPlugin.getWorkspace();
    final IProject newProjectHandle =
        workspace.getRoot().getProject(CreateSwitchYardProjectTest.class.getSimpleName());
    String packageName = "test.package_name";
    String groupId = "test.project.group";
    String version = "0.0.1-SNAPSHOT";
    String runtimeVersion = "0.5.0.Final";

    assertTrue("Project already exists.", !newProjectHandle.exists());

    final NewSwitchYardProjectMetaData projectMetaData = new NewSwitchYardProjectMetaData();
    projectMetaData.setNewProjectHandle(newProjectHandle);
    projectMetaData.setPackageName(packageName);
    projectMetaData.setGroupId(groupId);
    projectMetaData.setProjectVersion(version);
    projectMetaData.setRuntimeVersion(runtimeVersion);
    projectMetaData.setComponents(
        Collections.singleton(
            SwitchYardComponentExtensionManager.instance().getRuntimeComponentExtension()));

    IWorkspaceRunnable op = new CreateSwitchYardProjectOperation(projectMetaData, null);
    workspace.run(op, new NullProgressMonitor());

    waitForJobs();
    newProjectHandle.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
    waitForJobs();
    assertNoErrors(newProjectHandle);

    // TODO: change true to false once SWITCHYARD-469 is corrected
    assertTrue(
        "Project contains errors",
        newProjectHandle.findMaxProblemSeverity(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE)
            < IMarker.SEVERITY_ERROR);

    IFile switchyardFile = newProjectHandle.getFile("src/main/resources/META-INF/switchyard.xml");
    assertTrue("Failed to create switchyard.xml", switchyardFile.exists());
    assertTrue(
        "switchyard.xml file is out of sync after project creation",
        switchyardFile.isSynchronized(IFile.DEPTH_ZERO));

    IFile pomFile = newProjectHandle.getFile("pom.xml");
    assertTrue("Failed to create pom.xml", pomFile.exists());
    assertTrue(
        "pom.xml file is out of sync after project creation",
        pomFile.isSynchronized(IFile.DEPTH_ZERO));

    IFacetedProject fp =
        ProjectFacetsManager.create(newProjectHandle, false, new NullProgressMonitor());
    assertNotNull("Project is not a faceted project.", fp);
    assertTrue(
        "switchyard.core facet not configured on project",
        fp.hasProjectFacet(ProjectFacetsManager.getProjectFacet("switchyard.core")));
    assertTrue(
        "jst.utility facet not configured on project",
        fp.hasProjectFacet(ProjectFacetsManager.getProjectFacet("jst.utility")));
    assertTrue(
        "java facet not configured on project",
        fp.hasProjectFacet(ProjectFacetsManager.getProjectFacet("java")));

    // Test project update
    op =
        new AbstractSwitchYardProjectOperation(
            null,
            Collections.singleton(
                SwitchYardComponentExtensionManager.instance()
                    .getComponentExtension("org.switchyard.components:switchyard-component-bpm")),
            true,
            "Testing SwitchYard project update",
            null) {

          @Override
          protected IProject getProject() {
            return newProjectHandle;
          }

          @Override
          protected void execute(IProgressMonitor monitor) throws CoreException {
            monitor.done();
          }
        };
    workspace.run(op, new NullProgressMonitor());

    waitForJobs();
    newProjectHandle.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
    waitForJobs();
    assertNoErrors(newProjectHandle);

    assertTrue("Failed to update pom.xml", pomFile.exists());
    assertTrue(
        "pom.xml file is out of sync after project update",
        pomFile.isSynchronized(IFile.DEPTH_ZERO));
    assertXMLFilesMatch(
        "pom dependency update failed", pomFile, "test-data/validation/add_dependency_pom.xml");

    // test new bean service and test class
    IFile testServiceFile =
        newProjectHandle
            .getFolder("src/main/java")
            .getFolder(packageName.replace('.', '/'))
            .getFile("TestService.java");
    testServiceFile.create(
        CreateSwitchYardProjectTest.class
            .getClassLoader()
            .getResourceAsStream("test-data/source/TestService.java"),
        true,
        new NullProgressMonitor());
    // the project needs to be built or we can't create the service test class
    newProjectHandle.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
    waitForJobs();

    NewBeanServiceClassWizardPage newBeanPage = new NewBeanServiceClassWizardPage();
    newBeanPage.init(new StructuredSelection(testServiceFile));
    assertTrue(
        "NewBeanServiceClassWizardPage is not initialized correctly.",
        newBeanPage.isPageComplete());
    NewServiceTestClassWizardPage newTestPage = new NewServiceTestClassWizardPage();
    newTestPage.init(new StructuredSelection(testServiceFile));
    newTestPage.setServiceContract(newBeanPage.getServiceContract(), false);
    assertTrue(
        "NewServiceTestClassWizardPage is not initialized correctly.",
        newTestPage.isPageComplete());

    op = new CreateBeanServiceOperation(newBeanPage, newTestPage, null);
    workspace.run(op, new NullProgressMonitor());

    waitForJobs();
    newProjectHandle.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
    waitForJobs();
    assertNoErrors(newProjectHandle);

    assertTrue("switchyard.xml missing after bean service creation", switchyardFile.exists());
    assertTrue(
        "switchyard.xml file is out of sync after bean service creation",
        switchyardFile.isSynchronized(IFile.DEPTH_ZERO));
    assertXMLFilesMatch(
        "bean service creation failed",
        switchyardFile,
        "test-data/validation/create_service_switchyard.xml");

    assertTrue("pom.xml missing after bean service creation", pomFile.exists());
    assertTrue(
        "pom.xml file is out of sync after bean service creation",
        pomFile.isSynchronized(IFile.DEPTH_ZERO));
    assertXMLFilesMatch(
        "bean service creation failed", pomFile, "test-data/validation/create_service_pom.xml");

    IFile testServiceImplFile =
        newProjectHandle
            .getFolder("src/main/java")
            .getFolder(packageName.replace('.', '/'))
            .getFile("TestServiceBean.java");
    IFile testServiceTestFile =
        newProjectHandle
            .getFolder("src/test/java")
            .getFolder(packageName.replace('.', '/'))
            .getFile("TestServiceTest.java");

    assertTrue("TestServiceBean missing after bean service creation", testServiceImplFile.exists());
    assertTrue(
        "TestServiceBean file is out of sync after bean service creation",
        testServiceImplFile.isSynchronized(IFile.DEPTH_ZERO));

    assertTrue(
        "testServiceTestFile missing after bean service creation", testServiceTestFile.exists());
    assertTrue(
        "testServiceTestFile file is out of sync after bean service creation",
        testServiceTestFile.isSynchronized(IFile.DEPTH_ZERO));

    // TODO: validate contents of generated files
  }
 public IProjectFacetVersion getProjectFacetVersion() {
   final IProjectFacet jaxrsFacet =
       ProjectFacetsManager.getProjectFacet(IJAXRSCoreConstants.JAXRS_FACET_ID);
   final IFacetedProject fproj = getFacetedProject();
   return fproj.getInstalledVersion(jaxrsFacet);
 }
 /*
  * Don't want to add jpa as required plugin, so use String constant instead of JptCorePlugin.FACET_ID
  */
 private IProjectFacetVersion getJpaFacetVersion() {
   IFacetedProjectWorkingCopy facetedProject =
       ((ModifyFacetedProjectWizard) getWizard()).getFacetedProjectWorkingCopy();
   return facetedProject.getProjectFacetVersion(
       ProjectFacetsManager.getProjectFacet("jpt.jpa")); // $NON-NLS-1$
 }
예제 #22
0
 public static boolean isExtProject(IProject project) {
   return hasFacet(project, ProjectFacetsManager.getProjectFacet("liferay.ext"));
 }
  protected void configure(IProject project, MavenProject mavenProject, IProgressMonitor monitor)
      throws CoreException {
    IFacetedProject facetedProject = ProjectFacetsManager.create(project, true, monitor);

    // make sure to update the main deployment folder
    WarPluginConfiguration config = new WarPluginConfiguration(mavenProject, project);
    String warSourceDirectory = config.getWarSourceDirectory();
    IFile defaultWebXml = project.getFolder(warSourceDirectory).getFile("WEB-INF/web.xml");
    IFolder libDir = project.getFolder(warSourceDirectory).getFolder("WEB-INF/lib");

    boolean alreadyHasWebXml = defaultWebXml.exists();
    boolean alreadyHasLibDir = libDir.exists();

    Set<Action> actions = new LinkedHashSet<Action>();

    installJavaFacet(actions, project, facetedProject);

    IVirtualComponent component = ComponentCore.createComponent(project);
    if (component != null && warSourceDirectory != null) {
      IPath warPath = new Path(warSourceDirectory);
      // remove the old links (if there is one) before adding the new one.
      component.getRootFolder().removeLink(warPath, IVirtualResource.NONE, monitor);
      component.getRootFolder().createLink(warPath, IVirtualResource.NONE, monitor);
    }

    // MNGECLIPSE-2279 get the context root from the final name of the project, or artifactId by
    // default.
    String contextRoot = getContextRoot(mavenProject);

    IProjectFacetVersion webFv = config.getWebFacetVersion(project);
    if (!facetedProject.hasProjectFacet(WebFacetUtils.WEB_FACET)) {
      installWebFacet(mavenProject, warSourceDirectory, contextRoot, actions, webFv);
    } else {
      IProjectFacetVersion projectFacetVersion =
          facetedProject.getProjectFacetVersion(WebFacetUtils.WEB_FACET);
      if (webFv.getVersionString() != null
          && !webFv.getVersionString().equals(projectFacetVersion.getVersionString())) {
        try {
          Action uninstallAction =
              new IFacetedProject.Action(
                  IFacetedProject.Action.Type.UNINSTALL,
                  facetedProject.getInstalledVersion(WebFacetUtils.WEB_FACET),
                  null);
          facetedProject.modify(Collections.singleton(uninstallAction), monitor);
        } catch (Exception ex) {
          MavenLogger.log("Error removing WEB facet", ex);
        }
        installWebFacet(mavenProject, warSourceDirectory, contextRoot, actions, webFv);
      }
    }

    if (!actions.isEmpty()) {
      facetedProject.modify(actions, monitor);
    }

    // MNGECLIPSE-632 remove test sources/resources from WEB-INF/classes
    removeTestFolderLinks(project, mavenProject, monitor, "/WEB-INF/classes");

    addContainerAttribute(project, DEPENDENCY_ATTRIBUTE, monitor);

    // MNGECLIPSE-2279 change the context root if needed
    if (!contextRoot.equals(J2EEProjectUtilities.getServerContextRoot(project))) {
      J2EEProjectUtilities.setServerContextRoot(project, contextRoot);
    }

    // MNGECLIPSE-2357 support custom location of web.xml
    String customWebXml = config.getCustomWebXml(project);
    // If we have a custom web.xml but WTP created one against our will, we delete it
    if (customWebXml != null && !alreadyHasWebXml && defaultWebXml.exists()) {
      defaultWebXml.delete(true, monitor);
    }
    // Maven /m2eclipse doesn't need a new lib dir.
    if (!alreadyHasLibDir && libDir.exists()) {
      libDir.delete(true, monitor);
    }
    linkFile(project, customWebXml, "WEB-INF/web.xml", monitor);

    IPath filteredFolder = WebResourceFilteringConfiguration.getTargetFolder(mavenProject, project);
    if (component != null) {
      ProjectUtils.hideM2eclipseWtpFolder(mavenProject, project);
      component.getRootFolder().removeLink(filteredFolder, IVirtualResource.NONE, monitor);
      if (config.getWebResources() != null && config.getWebResources().length > 0) {
        component.getRootFolder().createLink(filteredFolder, IVirtualResource.NONE, monitor);
      }
    }
  }
예제 #24
0
  public static IRuntime getRuntime(IProject project) throws CoreException {

    return (IRuntime)
        getRuntimeAdapter(ProjectFacetsManager.create(project).getPrimaryRuntime(), IRuntime.class);
  }
@SuppressWarnings("restriction")
public abstract class AbstractWTPTestCase extends AbstractMavenProjectTestCase {

  protected static final IProjectFacetVersion DEFAULT_WEB_VERSION =
      WebFacetUtils.WEB_FACET.getVersion("2.5");
  protected static final IProjectFacet EJB_FACET =
      ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.EJB);
  protected static final IProjectFacet UTILITY_FACET =
      ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.UTILITY);
  protected static final IProjectFacetVersion UTILITY_10 = UTILITY_FACET.getVersion("1.0");
  protected static final IProjectFacet EAR_FACET =
      ProjectFacetsManager.getProjectFacet(IJ2EEFacetConstants.ENTERPRISE_APPLICATION);
  protected static final IProjectFacetVersion DEFAULT_EAR_FACET =
      IJ2EEFacetConstants.ENTERPRISE_APPLICATION_13;

  protected static final String MAVEN_CLASSPATH_CONTAINER =
      "org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER";
  protected static final String JRE_CONTAINER_J2SE_1_5 =
      "org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5";

  protected static IClasspathContainer getWebLibClasspathContainer(IJavaProject project)
      throws JavaModelException {
    IClasspathEntry[] entries = project.getRawClasspath();
    for (int i = 0; i < entries.length; i++) {
      IClasspathEntry entry = entries[i];
      if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER
          && "org.eclipse.jst.j2ee.internal.web.container".equals(entry.getPath().segment(0))) {
        return JavaCore.getClasspathContainer(entry.getPath(), project);
      }
    }
    return null;
  }

  private static boolean hasExtraAttribute(IClasspathEntry entry, String expectedAttribute) {
    for (IClasspathAttribute cpa : entry.getExtraAttributes()) {
      if (expectedAttribute.equals(cpa.getName())) {
        return true;
      }
    }
    return false;
  }

  protected String toString(IVirtualReference[] references) {
    StringBuilder sb = new StringBuilder("[");

    String sep = "";
    for (IVirtualReference reference : references) {
      IVirtualComponent component = reference.getReferencedComponent();
      sb.append(sep).append(reference.getRuntimePath() + " - ");
      sb.append(component.getName());
      sb.append(" " + component.getMetaProperties());
      sep = ", ";
    }

    return sb.append(']').toString();
  }

  protected String toString(IFile[] files) {
    StringBuilder sb = new StringBuilder("[");

    String sep = "";
    for (IFile file : files) {
      sb.append(sep).append(file.getFullPath());
      sep = ", ";
    }

    return sb.append(']').toString();
  }

  protected void assertHasMarker(String expectedMessage, List<IMarker> markers)
      throws CoreException {
    Pattern p = Pattern.compile(expectedMessage);
    for (IMarker marker : markers) {
      String markerMsg = marker.getAttribute(IMarker.MESSAGE).toString();
      if (p.matcher(markerMsg).find()) {
        return;
      }
    }
    fail("[" + expectedMessage + "] is not a marker. Existing markers are :" + toString(markers));
  }

  protected void assertMissingMarker(String expectedMessage, List<IMarker> markers)
      throws CoreException {
    Pattern p = Pattern.compile(expectedMessage);
    for (IMarker marker : markers) {
      String markerMsg = marker.getAttribute(IMarker.MESSAGE).toString();
      if (p.matcher(markerMsg).find()) {
        fail(
            "["
                + expectedMessage
                + "] was found but should be missing. Existing markers are :"
                + toString(markers));
      }
    }
  }

  protected void assertNotDeployable(IClasspathEntry entry) {
    assertDeployable(entry, false);
  }

  protected void assertDeployable(IClasspathEntry entry, boolean expectedDeploymentStatus) {
    // Useless : IClasspathDependencyConstants.CLASSPATH_COMPONENT_DEPENDENCY doesn't seem to be
    // used in WTP 3.2.0. Has it ever worked???
    // assertEquals(entry.toString() + " " +
    // IClasspathDependencyConstants.CLASSPATH_COMPONENT_DEPENDENCY, expectedDeploymentStatus,
    // hasExtraAttribute(entry, IClasspathDependencyConstants.CLASSPATH_COMPONENT_DEPENDENCY));
    assertEquals(
        entry.toString() + " " + IClasspathDependencyConstants.CLASSPATH_COMPONENT_NON_DEPENDENCY,
        !expectedDeploymentStatus,
        hasExtraAttribute(entry, IClasspathDependencyConstants.CLASSPATH_COMPONENT_NON_DEPENDENCY));
  }

  protected static IClasspathEntry[] getClassPathEntries(IProject project) throws Exception {
    IJavaProject javaProject = JavaCore.create(project);
    IClasspathContainer container = BuildPathManager.getMaven2ClasspathContainer(javaProject);
    return container.getClasspathEntries();
  }

  protected static IResource[] getUnderlyingResources(IProject project) {
    IVirtualComponent component = ComponentCore.createComponent(project);
    IVirtualFolder root = component.getRootFolder();
    IResource[] underlyingResources = root.getUnderlyingResources();
    return underlyingResources;
  }

  protected static String getAsString(IFile file) throws IOException, CoreException {
    assert file != null;
    assert file.isAccessible();
    InputStream ins = null;
    String content = null;
    try {
      ins = file.getContents();
      content = IOUtil.toString(ins, 1024);
    } finally {
      IOUtil.close(ins);
    }
    return content;
  }

  public AbstractWTPTestCase() {
    super();
  }

  /**
   * Replace the project pom.xml with a new one, triggers new build
   *
   * @param project
   * @param newPomName
   * @throws Exception
   */
  protected void updateProject(IProject project, String newPomName) throws Exception {
    updateProject(project, newPomName, -1);
  }

  /**
   * Replace the project pom.xml with a new one, triggers new build, wait for waitTime milliseconds.
   *
   * @param project
   * @param newPomName
   * @param waitTime
   * @throws Exception
   */
  protected void updateProject(IProject project, String newPomName, int waitTime) throws Exception {

    if (newPomName != null) {
      copyContent(project, newPomName, "pom.xml");
    }

    IProjectConfigurationManager configurationManager =
        MavenPlugin.getDefault().getProjectConfigurationManager();
    ResolverConfiguration configuration = new ResolverConfiguration();
    configurationManager.enableMavenNature(project, configuration, monitor);
    configurationManager.updateProjectConfiguration(project, monitor);

    waitForJobsToComplete();
    project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
    if (waitTime > 0) {
      Thread.sleep(waitTime);
    }
    waitForJobsToComplete();
  }

  protected void updateProject(IProject project) throws Exception {
    updateProject(project, null, -1);
  }

  protected void assertContains(String findMe, String holder) {
    assertTrue("'" + findMe + "' is missing from : \n" + holder, holder.contains(findMe));
  }

  protected void assertNotContains(String findMe, String holder) {
    assertFalse("'" + findMe + "' was found in : \n" + holder, holder.contains(findMe));
  }

  protected void useBuildDirforGeneratingFiles(IProject project, boolean b) {
    IMavenWtpPreferences preferences =
        MavenWtpPlugin.getDefault().getMavenWtpPreferencesManager().getPreferences(project);
    preferences.setApplicationXmGeneratedInBuildDirectory(b);
    preferences.setWebMavenArchiverUsesBuildDirectory(b);
    MavenWtpPlugin.getDefault().getMavenWtpPreferencesManager().savePreferences(preferences, null);
  }

  protected void useBuildDirforGeneratingFiles(boolean b) {
    useBuildDirforGeneratingFiles(null, b);
  }
}