Example usage for org.apache.maven.project MavenProject getBuild

List of usage examples for org.apache.maven.project MavenProject getBuild

  1. HOME
  2. Java
  3. org.apache.maven
  4. org.apache.maven.project.*
  5. MavenProject
  6. getBuild

Introduction

In this page you can find the example usage for org.apache.maven.project MavenProject getBuild.

Prototype

public Build getBuild()

Source Link

Usage

From source file:org.wso2.developerstudio.eclipse.artifact.library.project.export.LibraryArtifactHandler.java

License:Open Source License

private List<String> getPackages(List<String> exportedPackagesList, MavenProject mavenProject,
        String packagetype) throws CoreException, JavaModelException, Exception {
    List<Plugin> plugins = mavenProject.getBuild().getPlugins();
    for (Plugin plugin : plugins) {
        if ("maven-bundle-plugin".equalsIgnoreCase(plugin.getArtifactId())) {
            Xpp3Dom configurationNode = (Xpp3Dom) plugin.getConfiguration();
            Xpp3Dom[] instructions = configurationNode.getChildren("instructions");
            if (instructions.length == 1) {
                Xpp3Dom[] exportPackage = instructions[0].getChildren(packagetype);
                if (exportPackage.length == 1) {
                    exportedPackagesList.clear(); //clear default configuration (All packages by default)
                    String exportpackages = exportPackage[0].getValue();
                    if (exportpackages != null) {
                        exportedPackagesList.addAll(Arrays.asList(exportpackages.split(",")));
                    }//w  w w . j  a  va  2 s .co m
                } else {
                    log.warn("Invalid configuration for <Export-Package> entry"
                            + " using default configuration for <Export-Package>");
                }
            } else {
                log.warn("Invalid instructions configuration for plugin : maven-bundle-plugin"
                        + " using default configuration for <Export-Package>");
            }
            break; //not considering multiple versions of the maven-bundle-plugin
        }
    }
    return exportedPackagesList;
}

From source file:org.wso2.developerstudio.eclipse.artifact.library.ui.wizard.LibraryArtifactCreationWizard.java

License:Open Source License

private static void handleWorkspaceProjectResource(IProject workSpacePrj)
        throws JavaModelException, Exception, CoreException {
    File pomfile = workSpacePrj.getFile("pom.xml").getLocation().toFile();
    if (!pomfile.exists()) {
        String srcDir = "src";
        MavenProject mavenProject = MavenUtils.createMavenProject("org.wso2.carbon." + workSpacePrj.getName(),
                workSpacePrj.getName(), "1.0.0", "jar");
        IJavaProject javaProject = JavaCore.create(workSpacePrj);
        IClasspathEntry[] classpath = javaProject.getRawClasspath();
        int entryCount = 0;
        for (IClasspathEntry classpathEntry : classpath) {
            if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                if (entryCount == 0) {
                    String entryPath = "";
                    String[] pathSegments = classpathEntry.getPath().segments();
                    if (pathSegments.length > 1) {
                        for (int i = 1; i < pathSegments.length; i++) {
                            if (i == 1) {
                                entryPath = pathSegments[i];
                            } else {
                                entryPath += "/" + pathSegments[i];
                            }//  w  ww  .j a va  2  s. c  o m
                        }
                        if (entryPath.length() > 0) {
                            srcDir = entryPath;
                            ++entryCount;
                        }
                    }
                } else {
                    log.warn("multiple source directories found, Considering '" + srcDir
                            + "' as source directory");
                    break;
                }
            }
        }
        if (entryCount == 0) {
            log.warn("No source directory specified, using default source directory.");
        }

        /* adding wso2 nexus repository */
        Repository nexusRepo = new Repository();
        nexusRepo.setUrl("http://maven.wso2.org/nexus/content/groups/wso2-public/");
        nexusRepo.setId("wso2-maven2-repository-1");
        mavenProject.getModel().addRepository(nexusRepo);
        mavenProject.getModel().addPluginRepository(nexusRepo);

        /* adding maven dependencies */
        List<Dependency> libList = new ArrayList<Dependency>();
        Map<String, JavaLibraryBean> dependencyMap = JavaLibraryUtil.getDependencyInfoMap(workSpacePrj);

        for (JavaLibraryBean bean : dependencyMap.values()) {
            Dependency dependency = new Dependency();
            dependency.setArtifactId(bean.getArtifactId());
            dependency.setGroupId(bean.getGroupId());
            dependency.setVersion(bean.getVersion());
            libList.add(dependency);
        }
        mavenProject.setDependencies(libList);

        mavenProject.getBuild().setSourceDirectory(srcDir);
        MavenUtils.saveMavenProject(mavenProject, pomfile);
    }
    workSpacePrj.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
}

From source file:org.wso2.developerstudio.eclipse.artifact.mediator.project.export.MediatorExportHandler.java

License:Open Source License

private List<String> getExportPackages(IJavaProject javaProject)
        throws CoreException, JavaModelException, Exception {
    ArrayList<String> exportedPackagesList = new ArrayList<String>();
    IPackageFragment[] packages = javaProject.getPackageFragments();
    if (packages != null) {
        for (IPackageFragment iPackageFragment : packages) {
            iPackageFragment.getElementName();
            if (iPackageFragment.getKind() == IPackageFragmentRoot.K_SOURCE) {
                if (iPackageFragment.hasChildren()) {
                    exportedPackagesList.add(iPackageFragment.getElementName());
                }//from   w  ww .j a  v a  2 s.  c om
            }
        }
    }
    MavenProject mavenProject = MavenUtils
            .getMavenProject(javaProject.getProject().getFile("pom.xml").getLocation().toFile());
    List<Plugin> plugins = mavenProject.getBuild().getPlugins();
    for (Plugin plugin : plugins) {
        if ("maven-bundle-plugin".equalsIgnoreCase(plugin.getArtifactId())) {
            Xpp3Dom configurationNode = (Xpp3Dom) plugin.getConfiguration();
            Xpp3Dom[] instructions = configurationNode.getChildren("instructions");
            if (instructions.length == 1) {
                Xpp3Dom[] exportPackage = instructions[0].getChildren("Export-Package");
                if (exportPackage.length == 1) {
                    exportedPackagesList.clear(); //clear default configuration (All packages by default)
                    String exportpackages = exportPackage[0].getValue();
                    if (packages != null) {
                        exportedPackagesList.addAll(Arrays.asList(exportpackages.split(",")));
                    }
                } else {
                    log.warn("Invalid configuration for <Export-Package> entry"
                            + " using default configuration for <Export-Package>");
                }
            } else {
                log.warn("Invalid instructions configuration for plugin : maven-bundle-plugin"
                        + " using default configuration for <Export-Package>");
            }
            break; //not considering multiple versions of the maven-bundle-plugin
        }
    }
    return exportedPackagesList;
}

From source file:org.wso2.developerstudio.eclipse.artifact.registry.handler.project.export.RegistryHandlerArtifactHandler.java

License:Open Source License

public List<IResource> exportArtifact(IProject project) throws Exception {
    List<IResource> exportResources = new ArrayList<IResource>();
    List<String> exportedPackageList = new ArrayList<String>();
    String activatorClass = new String();
    String existingActivatorClass = new String();

    ArchiveManipulator archiveManipulator = new ArchiveManipulator();

    // getting maven details
    MavenProject mavenProject = MavenUtils.getMavenProject(project.getFile("pom.xml").getLocation().toFile());

    // Get the output location
    IJavaProject javaProject = JavaCore.create(project);

    clearTarget(project);//from w w  w.ja  v  a  2s.  co m
    IPath outPutPath = buildJavaProject(project);

    // get resource location
    IPath resources = getResourcePath(project);

    // getting export packages
    for (IPackageFragment pkg : javaProject.getPackageFragments()) {
        if (pkg.getKind() == IPackageFragmentRoot.K_SOURCE) {
            if (pkg.hasChildren()) {
                exportedPackageList.add(pkg.getElementName());
                for (ICompilationUnit compilationUnit : pkg.getCompilationUnits()) {
                    IType[] types = compilationUnit.getTypes();
                    for (IType type : types) {
                        if (type.getSuperInterfaceNames().length > 0
                                && Arrays.asList(type.getSuperInterfaceNames()).contains("BundleActivator")) {
                            activatorClass = type.getFullyQualifiedName();
                        }
                    }
                }
            }
        }
    }

    List<Plugin> plugins = mavenProject.getBuild().getPlugins();
    for (Plugin plugin : plugins) {
        if ("maven-bundle-plugin".equalsIgnoreCase(plugin.getArtifactId())) {
            Xpp3Dom configurationNode = (Xpp3Dom) plugin.getConfiguration();
            Xpp3Dom[] instructions = configurationNode.getChildren("instructions");
            if (instructions.length == 1) {
                Xpp3Dom[] exportPackage = instructions[0].getChildren("Export-Package");
                if (exportPackage.length == 1) {
                    exportedPackageList.clear(); //clear default configuration (All packages by default)
                    String packages = exportPackage[0].getValue();
                    if (packages != null) {
                        exportedPackageList.addAll(Arrays.asList(packages.split(",")));
                    }
                } else {
                    log.warn("Invalid configuration for <Export-Package> entry"
                            + " using default configuration for <Export-Package>");
                }
            } else {
                log.warn("Invalid instructions configuration for plugin : maven-bundle-plugin"
                        + " using default configuration for <Export-Package>");
            }
            break; //not considering multiple versions of the maven-bundle-plugin
        }
    }

    File tempProject = createTempProject();

    File bundleResources = createTempDir(tempProject, "bundle_resources");

    if (exportedPackageList.size() > 0) {
        FileUtils.copyDirectoryContents(outPutPath.toFile(), bundleResources); // copy
                                                                               // binaries
    }

    if (resources.toFile().exists()) {
        FileUtils.copyDirectoryContents(resources.toFile(), bundleResources); // copy
        // resources
    }

    @SuppressWarnings("unchecked")
    List<Dependency> dependencies = mavenProject.getDependencies();
    Iterator<Dependency> iterator = dependencies.iterator();
    while (iterator.hasNext()) {
        Dependency dependency = iterator.next();
        if ("system".equals(dependency.getScope())) {
            String systemPath = dependency.getSystemPath();
            if (systemPath != null && !systemPath.trim().isEmpty()) {
                systemPath = systemPath.replaceAll("^".concat(Pattern.quote("${basedir}/")), "");
                IFile jarFile = project.getFile(systemPath);
                if (jarFile.exists()) {
                    archiveManipulator.extract(jarFile.getLocation().toFile(), bundleResources);
                    // getting export packages
                    IPackageFragmentRoot rootPkg = JavaCore.createJarPackageFragmentRootFrom(jarFile);

                    for (IJavaElement item : rootPkg.getChildren()) {
                        if (item instanceof IPackageFragment) {
                            IPackageFragment pkg = (IPackageFragment) item;
                            if (pkg.hasChildren()) {
                                exportedPackageList.add(pkg.getElementName());
                                for (IClassFile clazz : pkg.getClassFiles()) {
                                    IType type = clazz.getType();
                                    if (type.getSuperInterfaceNames().length > 0 && Arrays
                                            .asList(type.getSuperInterfaceNames()).contains(ACTIVATOR_FQN)) {
                                        existingActivatorClass = type.getFullyQualifiedName();
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

    }

    if (activatorClass.trim().isEmpty()) {
        activatorClass = existingActivatorClass;
    }

    /* writing manifest */
    BundleManifest manifest = new BundleManifest();
    manifest.setBundleName(project.getName());
    manifest.setBundleSymbolicName(project.getName());
    if (null != mavenProject.getModel().getDescription()
            && !"".equals(mavenProject.getModel().getDescription())) {
        manifest.setBundleDescription(mavenProject.getModel().getDescription());
    } else {
        manifest.setBundleDescription(project.getName());
    }
    if (null != mavenProject.getModel().getVersion() && !"".equals(mavenProject.getDescription())) {
        manifest.setBundleVersion(mavenProject.getModel().getVersion());
    } else {
        manifest.setBundleVersion("1.0.0");
    }
    manifest.setBundleActivatorName(activatorClass);
    manifest.setExportPackagesList(exportedPackageList);
    File metaInfDir = new File(bundleResources, "META-INF");
    if (!metaInfDir.exists())
        metaInfDir.mkdir();
    File manifestFile = new File(metaInfDir, "MANIFEST.MF");
    FileUtils.createFile(manifestFile, manifest.toString());

    File tmpArchive = new File(tempProject, project.getName().concat(".jar"));
    archiveManipulator.archiveDir(tmpArchive.toString(), bundleResources.toString());

    IFile bundleArchive = getTargetArchive(project, "jar");
    FileUtils.copy(tmpArchive, bundleArchive.getLocation().toFile());
    exportResources.add((IResource) bundleArchive);

    TempFileUtils.cleanUp();

    return exportResources;

}

From source file:org.wso2.developerstudio.eclipse.artifact.registry.handler.ui.wizard.RegistryHandlerCreationWizard.java

License:Open Source License

public void updatePom(IProject project, HandlerInfo handlerInfo) throws Exception {
    File mavenProjectPomLocation = project.getFile("pom.xml").getLocation().toFile();
    MavenProject mavenProject = MavenUtils.getMavenProject(mavenProjectPomLocation);

    Properties properties = mavenProject.getModel().getProperties();
    properties.put("CApp.type", "lib/registry/handlers");
    mavenProject.getModel().setProperties(properties);

    Plugin plugin = MavenUtils.createPluginEntry(mavenProject, "org.apache.felix", "maven-bundle-plugin",
            "2.3.4", true);

    Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode(plugin);
    Xpp3Dom instructionNode = MavenUtils.createXpp3Node("instructions");
    Xpp3Dom bundleSymbolicNameNode = MavenUtils.createXpp3Node(instructionNode, "Bundle-SymbolicName");
    Xpp3Dom bundleNameNode = MavenUtils.createXpp3Node(instructionNode, "Bundle-Name");
    Xpp3Dom bundleActivatorNode = MavenUtils.createXpp3Node(instructionNode, "Bundle-Activator");
    Xpp3Dom exportPackageNode = MavenUtils.createXpp3Node(instructionNode, "Export-Package");
    Xpp3Dom dynamicImportNode = MavenUtils.createXpp3Node(instructionNode, "DynamicImport-Package");
    bundleSymbolicNameNode.setValue(project.getName());
    bundleNameNode.setValue(project.getName());
    bundleActivatorNode.setValue(BUNDLE_ACTIVATOR_NAME);
    exportPackageNode.setValue(getExportedPackage(handlerInfo));
    dynamicImportNode.setValue("*");
    configurationNode.addChild(instructionNode);

    Repository repo = new Repository();
    repo.setUrl("http://maven.wso2.org/nexus/content/groups/wso2-public/");
    repo.setId("wso2-maven2-repository-1");

    mavenProject.getModel().addRepository(repo);
    mavenProject.getModel().addPluginRepository(repo);

    List<Dependency> dependencyList = new ArrayList<Dependency>();

    Map<String, JavaLibraryBean> dependencyInfoMap = JavaLibraryUtil.getDependencyInfoMap(project);
    Map<String, String> map = ProjectDependencyConstants.DEPENDENCY_MAP;
    for (JavaLibraryBean bean : dependencyInfoMap.values()) {
        if (bean.getVersion().contains("${")) {
            for (String path : map.keySet()) {
                bean.setVersion(bean.getVersion().replace(path, map.get(path)));
            }/*from   ww  w.j a  v a  2 s .  c  om*/
        }
        Dependency dependency = new Dependency();
        dependency.setArtifactId(bean.getArtifactId());
        dependency.setGroupId(bean.getGroupId());
        dependency.setVersion(bean.getVersion());
        dependencyList.add(dependency);
    }

    if (importHandlerFromWs && importHandlerProject != null) {
        try {
            IFile pomFile = importHandlerProject.getFile("pom.xml");
            MavenProject workspaceProject;
            if (pomFile.exists()) {
                workspaceProject = MavenUtils.getMavenProject(pomFile.getLocation().toFile());
            } else {
                String srcDir = "src";
                workspaceProject = MavenUtils.createMavenProject(
                        "org.wso2.carbon." + importHandlerProject.getName(), importHandlerProject.getName(),
                        "1.0.0", "jar");
                IJavaProject javaProject = JavaCore.create(importHandlerProject);
                IClasspathEntry[] classpath = javaProject.getRawClasspath();
                int entryCount = 0;
                for (IClasspathEntry classpathEntry : classpath) {
                    if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                        if (entryCount == 0) {
                            String entryPath = "";
                            String[] pathSegments = classpathEntry.getPath().segments();
                            if (pathSegments.length > 1) {
                                for (int i = 1; i < pathSegments.length; i++) {
                                    if (i == 1) {
                                        entryPath = pathSegments[i];
                                    } else {
                                        entryPath += "/" + pathSegments[i];
                                    }
                                }
                                if (entryPath.length() > 0) {
                                    srcDir = entryPath;
                                    ++entryCount;
                                }
                            }
                        } else {
                            log.warn("multiple source directories found, Considering '" + srcDir
                                    + "' as source directory");
                            break;
                        }
                    }
                }
                if (entryCount == 0) {
                    log.warn("No source directory specified, using default source directory.");
                }
                workspaceProject.getBuild().setSourceDirectory(srcDir);

                Repository nexusRepo = new Repository();
                nexusRepo.setUrl("http://maven.wso2.org/nexus/content/groups/wso2-public/");
                nexusRepo.setId("wso2-maven2-repository-1");
                workspaceProject.getModel().addRepository(nexusRepo);
                workspaceProject.getModel().addPluginRepository(nexusRepo);

                List<Dependency> libList = new ArrayList<Dependency>();

                Map<String, JavaLibraryBean> dependencyMap = JavaLibraryUtil
                        .getDependencyInfoMap(importHandlerProject);

                for (JavaLibraryBean bean : dependencyMap.values()) {
                    Dependency dependency = new Dependency();
                    dependency.setArtifactId(bean.getArtifactId());
                    dependency.setGroupId(bean.getGroupId());
                    dependency.setVersion(bean.getVersion());
                    libList.add(dependency);
                }

                workspaceProject.setDependencies(libList);
                MavenUtils.saveMavenProject(workspaceProject, pomFile.getLocation().toFile());
                project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
            }

            Dependency dependency = new Dependency();
            dependency.setArtifactId(workspaceProject.getArtifactId());
            dependency.setGroupId(workspaceProject.getGroupId());
            dependency.setVersion(workspaceProject.getVersion());
            dependencyList.add(dependency);
        } catch (Exception e) {
            log.warn("Error reading or updating pom file.", e);
        }
    }

    MavenUtils.addMavenDependency(mavenProject, dependencyList);
    MavenUtils.saveMavenProject(mavenProject, mavenProjectPomLocation);

}

From source file:org.wso2.developerstudio.eclipse.esb.project.nature.ESBProjectNature.java

License:Open Source License

private void updatePom() {
    // TODO update the pom with the relavant packaging types & maven pligins
    File mavenProjectPomLocation = getProject().getFile("pom.xml").getLocation().toFile();
    try {//from w  w  w  .j  a v  a2s  .c o m
        MavenProject mavenProject = MavenUtils.getMavenProject(mavenProjectPomLocation);
        //Adding typrLidt property
        MavenUtils.updateMavenProjectWithCAppType(mavenProject, CAPP_TYPE);
        //Setting the directory
        mavenProject.getBuild().setDirectory("target/capp");
        //         Adding maven test skip property
        MavenUtils.updateMavenProjectWithSkipTests(mavenProject);

        //Adding maven exec plugin entry
        Plugin plugin = MavenUtils.createPluginEntry(mavenProject, "org.codehaus.mojo", "exec-maven-plugin",
                "1.4.0", true);

        {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId(ESBMavenConstants.PACKAGE_PHASE);
            pluginExecution.addGoal(ESBMavenConstants.EXEC_GOAL);
            pluginExecution.setPhase(ESBMavenConstants.PACKAGE_PHASE);

            Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
            Xpp3Dom executableNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.EXECUTABLE_TAG);
            executableNode.setValue(ESBMavenConstants.EXECUTABLE_VALUE);
            Xpp3Dom workingDirectoryNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.WORKING_DIRECTORY_TAG);
            workingDirectoryNode.setValue(ESBMavenConstants.WORKING_DIRECTORY_VALUE);
            Xpp3Dom argumentsNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.ARGUMENTS_TAG);
            Xpp3Dom cleanArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            cleanArgumentNode.setValue(ESBMavenConstants.ARGUMENT_VALUE_CLEAN);
            Xpp3Dom installArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            installArgumentNode.setValue(ESBMavenConstants.PACKAGE_PHASE);
            Xpp3Dom testSkipArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            testSkipArgumentNode.setValue(ESBMavenConstants.ARGUMENT_VALUE_SKIP_TESTS);

            pluginExecution.setConfiguration(configurationNode);

            plugin.addExecution(pluginExecution);
        }
        {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId(ESBMavenConstants.INSTALL_PHASE);
            pluginExecution.addGoal(ESBMavenConstants.EXEC_GOAL);
            pluginExecution.setPhase(ESBMavenConstants.INSTALL_PHASE);

            Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
            Xpp3Dom executableNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.EXECUTABLE_TAG);
            executableNode.setValue(ESBMavenConstants.EXECUTABLE_VALUE);
            Xpp3Dom workingDirectoryNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.WORKING_DIRECTORY_TAG);
            workingDirectoryNode.setValue(ESBMavenConstants.WORKING_DIRECTORY_VALUE);
            Xpp3Dom argumentsNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.ARGUMENTS_TAG);
            Xpp3Dom cleanArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            cleanArgumentNode.setValue(ESBMavenConstants.ARGUMENT_VALUE_CLEAN);
            Xpp3Dom installArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            installArgumentNode.setValue(ESBMavenConstants.INSTALL_PHASE);
            Xpp3Dom testSkipArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            testSkipArgumentNode.setValue(ESBMavenConstants.ARGUMENT_VALUE_SKIP_TESTS);

            pluginExecution.setConfiguration(configurationNode);

            plugin.addExecution(pluginExecution);
        }
        {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId(ESBMavenConstants.DEPLOY_PHASE);
            pluginExecution.addGoal(ESBMavenConstants.EXEC_GOAL);
            pluginExecution.setPhase(ESBMavenConstants.DEPLOY_PHASE);

            Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
            Xpp3Dom executableNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.EXECUTABLE_TAG);
            executableNode.setValue(ESBMavenConstants.EXECUTABLE_VALUE);
            Xpp3Dom workingDirectoryNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.WORKING_DIRECTORY_TAG);
            workingDirectoryNode.setValue(ESBMavenConstants.WORKING_DIRECTORY_VALUE);
            Xpp3Dom argumentsNode = MavenUtils.createXpp3Node(configurationNode,
                    ESBMavenConstants.ARGUMENTS_TAG);
            Xpp3Dom deployArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            deployArgumentNode.setValue(ESBMavenConstants.DEPLOY_PHASE);
            Xpp3Dom testSkipArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    ESBMavenConstants.ARGUMENT_TAG);
            testSkipArgumentNode.setValue(ESBMavenConstants.ARGUMENT_VALUE_SKIP_TESTS);

            pluginExecution.setConfiguration(configurationNode);

            plugin.addExecution(pluginExecution);
        }
        MavenUtils.saveMavenProject(mavenProject, mavenProjectPomLocation);

    } catch (Exception e) {
        // TODO Handle this properly.
        e.printStackTrace();
    }

    try {
        getProject().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
    } catch (CoreException e) {
        // TODO Handle this properly.
        e.printStackTrace();
    }
}

From source file:org.wso2.developerstudio.eclipse.esb.project.utils.ESBProjectUtils.java

License:Open Source License

public static void addPluginEntry(MavenProject mavenProject, String groupId, String artifactId, String version,
        String Id) {//from  ww  w.j  a va  2s  . c  om
    List<Plugin> plugins = mavenProject.getBuild().getPlugins();
    for (Plugin plg : plugins) {
        if (plg.getGroupId().equalsIgnoreCase(groupId) && plg.getArtifactId().equalsIgnoreCase(artifactId)) {
            return;
        }
    }

    Plugin plugin = MavenUtils.createPluginEntry(mavenProject, groupId, artifactId, version, true);
    PluginExecution pluginExecution = new PluginExecution();
    pluginExecution.addGoal("pom-gen");
    pluginExecution.setPhase("process-resources");
    pluginExecution.setId(Id);

    Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
    Xpp3Dom artifactLocationNode = MavenUtils.createXpp3Node(configurationNode, "artifactLocation");
    artifactLocationNode.setValue(".");
    Xpp3Dom typeListNode = MavenUtils.createXpp3Node(configurationNode, "typeList");
    typeListNode.setValue("${artifact.types}");
    pluginExecution.setConfiguration(configurationNode);
    plugin.addExecution(pluginExecution);
}

From source file:org.wso2.developerstudio.eclipse.integration.project.nature.IntegrationProjectNature.java

License:Open Source License

private void updatePom() {
    // TODO update the pom with the relavant packaging types & maven pligins
    File mavenProjectPomLocation = getProject().getFile("pom.xml").getLocation().toFile();
    try {/*from  www.j a v a2  s  .c  om*/
        MavenProject mavenProject = MavenUtils.getMavenProject(mavenProjectPomLocation);
        // Adding typrLidt property
        MavenUtils.updateMavenProjectWithCAppType(mavenProject, CAPP_TYPE);
        // Setting the directory
        mavenProject.getBuild().setDirectory("target/capp");
        // Adding maven test skip property
        MavenUtils.updateMavenProjectWithSkipTests(mavenProject);

        // Adding maven exec plugin entry
        Plugin plugin = MavenUtils.createPluginEntry(mavenProject, "org.codehaus.mojo", "exec-maven-plugin",
                "1.4.0", true);

        {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId(IntegrationMavenConstants.PACKAGE_PHASE);
            pluginExecution.addGoal(IntegrationMavenConstants.EXEC_GOAL);
            pluginExecution.setPhase(IntegrationMavenConstants.PACKAGE_PHASE);

            Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
            Xpp3Dom executableNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.EXECUTABLE_TAG);
            executableNode.setValue(IntegrationMavenConstants.EXECUTABLE_VALUE);
            Xpp3Dom workingDirectoryNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.WORKING_DIRECTORY_TAG);
            workingDirectoryNode.setValue(IntegrationMavenConstants.WORKING_DIRECTORY_VALUE);
            Xpp3Dom argumentsNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.ARGUMENTS_TAG);
            Xpp3Dom cleanArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            cleanArgumentNode.setValue(IntegrationMavenConstants.ARGUMENT_VALUE_CLEAN);
            Xpp3Dom installArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            installArgumentNode.setValue(IntegrationMavenConstants.PACKAGE_PHASE);
            Xpp3Dom testSkipArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            testSkipArgumentNode.setValue(IntegrationMavenConstants.ARGUMENT_VALUE_SKIP_TESTS);

            pluginExecution.setConfiguration(configurationNode);

            plugin.addExecution(pluginExecution);
        }
        {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId(IntegrationMavenConstants.INSTALL_PHASE);
            pluginExecution.addGoal(IntegrationMavenConstants.EXEC_GOAL);
            pluginExecution.setPhase(IntegrationMavenConstants.INSTALL_PHASE);

            Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
            Xpp3Dom executableNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.EXECUTABLE_TAG);
            executableNode.setValue(IntegrationMavenConstants.EXECUTABLE_VALUE);
            Xpp3Dom workingDirectoryNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.WORKING_DIRECTORY_TAG);
            workingDirectoryNode.setValue(IntegrationMavenConstants.WORKING_DIRECTORY_VALUE);
            Xpp3Dom argumentsNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.ARGUMENTS_TAG);
            Xpp3Dom cleanArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            cleanArgumentNode.setValue(IntegrationMavenConstants.ARGUMENT_VALUE_CLEAN);
            Xpp3Dom installArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            installArgumentNode.setValue(IntegrationMavenConstants.INSTALL_PHASE);
            Xpp3Dom testSkipArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            testSkipArgumentNode.setValue(IntegrationMavenConstants.ARGUMENT_VALUE_SKIP_TESTS);

            pluginExecution.setConfiguration(configurationNode);

            plugin.addExecution(pluginExecution);
        }
        {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId(IntegrationMavenConstants.DEPLOY_PHASE);
            pluginExecution.addGoal(IntegrationMavenConstants.EXEC_GOAL);
            pluginExecution.setPhase(IntegrationMavenConstants.DEPLOY_PHASE);

            Xpp3Dom configurationNode = MavenUtils.createMainConfigurationNode();
            Xpp3Dom executableNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.EXECUTABLE_TAG);
            executableNode.setValue(IntegrationMavenConstants.EXECUTABLE_VALUE);
            Xpp3Dom workingDirectoryNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.WORKING_DIRECTORY_TAG);
            workingDirectoryNode.setValue(IntegrationMavenConstants.WORKING_DIRECTORY_VALUE);
            Xpp3Dom argumentsNode = MavenUtils.createXpp3Node(configurationNode,
                    IntegrationMavenConstants.ARGUMENTS_TAG);
            Xpp3Dom deployArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            deployArgumentNode.setValue(IntegrationMavenConstants.DEPLOY_PHASE);
            Xpp3Dom testSkipArgumentNode = MavenUtils.createXpp3Node(argumentsNode,
                    IntegrationMavenConstants.ARGUMENT_TAG);
            testSkipArgumentNode.setValue(IntegrationMavenConstants.ARGUMENT_VALUE_SKIP_TESTS);

            pluginExecution.setConfiguration(configurationNode);

            plugin.addExecution(pluginExecution);
        }
        MavenUtils.saveMavenProject(mavenProject, mavenProjectPomLocation);

    } catch (Exception e) {
        // TODO Handle this properly.
        e.printStackTrace();
    }

    try {
        getProject().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
    } catch (CoreException e) {
        // TODO Handle this properly.
        e.printStackTrace();
    }
}

From source file:org.wso2.developerstudio.eclipse.qos.project.exporter.QoSArtfactExportHandler.java

License:Open Source License

@Override
public List<IResource> exportArtifact(IProject project) throws Exception {
    String projectPath = project.getLocation().toFile().toString();
    List<IResource> exportResources = new ArrayList<IResource>();
    clearTarget(project);/*from w  ww  .  j  a  va  2  s  . c  o m*/
    IFile pomFile = project.getFile("pom.xml");

    if (pomFile.exists()) {
        MavenProject mavenProject = MavenUtils.getMavenProject(pomFile.getLocation().toFile());
        List<Plugin> plugins = mavenProject.getBuild().getPlugins();
        for (Plugin plugin : plugins) {
            if (plugin.getArtifactId().equals("maven-qos-plugin")
                    && plugin.getGroupId().equals("org.wso2.maven")) {
                Xpp3Dom artifactNode = ((Xpp3Dom) plugin.getConfiguration()).getChild("artifact");
                String metaFile = artifactNode.getValue();
                String[] pathArray = metaFile.split("/");
                IFile qosFileRef = project.getFolder("src").getFolder("main").getFolder("resources")
                        .getFile(pathArray[pathArray.length - 1]);
                if (qosFileRef.exists()) {
                    exportResources.add((IResource) qosFileRef);
                }
            }
        }
        return exportResources;
    }
    return null;
}

From source file:org.wso2.maven.core.utils.MavenUtils.java

License:Open Source License

public static Plugin createPluginEntry(MavenProject project, String groupId, String artifactId, String version,
        boolean isExtension) {
    Plugin plugin = new Plugin();
    plugin.setGroupId(groupId);/*from   www  . ja v a2  s  . c  om*/
    plugin.setArtifactId(artifactId);
    plugin.setVersion(version);
    if (isExtension) {
        plugin.setExtensions(true);
    }
    MavenUtils.createMainConfigurationNode(plugin);
    project.getBuild().addPlugin(plugin);
    return plugin;
}