Java Code Examples for org.gradle.api.tasks.Copy

The following examples show how to use org.gradle.api.tasks.Copy. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
private void createProcessResourcesTaskForBinary(final ClassDirectoryBinarySpecInternal binary, final Project target) {
    final BinaryNamingScheme namingScheme = binary.getNamingScheme();
    binary.getSource().withType(JvmResourceSet.class).all(new Action<JvmResourceSet>() {
        public void execute(JvmResourceSet resourceSet) {
            Copy resourcesTask = target.getTasks().create(namingScheme.getTaskName("process", "resources"), ProcessResources.class);
            resourcesTask.setDescription(String.format("Processes %s.", resourceSet));
            new DslObject(resourcesTask).getConventionMapping().map("destinationDir", new Callable<File>() {
                public File call() throws Exception {
                    return binary.getResourcesDir();
                }
            });
            binary.getTasks().add(resourcesTask);
            binary.builtBy(resourcesTask);
            resourcesTask.from(resourceSet.getSource());
        }
    });
}
 
Example 2
Source Project: curiostack   Source File: CuriostackRootPlugin.java    License: MIT License 6 votes vote down vote up
private static void setupDataSources(Project project) {
  // TODO(choko): Preconfigure XML as well
  Configuration configuration = project.getConfigurations().create("jdbcDrivers");
  project
      .getDependencies()
      .add(configuration.getName(), "com.google.cloud.sql:mysql-socket-factory");
  project
      .getTasks()
      .register(
          "setupDataSources",
          Copy.class,
          t -> {
            t.from(configuration);
            t.into(".ideaDataSources/drivers");
          });
}
 
Example 3
private void createProcessResourcesTaskForBinary(final ClassDirectoryBinarySpecInternal binary, final Project target) {
    final BinaryNamingScheme namingScheme = binary.getNamingScheme();
    binary.getSource().withType(JvmResourceSet.class).all(new Action<JvmResourceSet>() {
        public void execute(JvmResourceSet resourceSet) {
            Copy resourcesTask = target.getTasks().create(namingScheme.getTaskName("process", "resources"), ProcessResources.class);
            resourcesTask.setDescription(String.format("Processes %s.", resourceSet));
            new DslObject(resourcesTask).getConventionMapping().map("destinationDir", new Callable<File>() {
                public File call() throws Exception {
                    return binary.getResourcesDir();
                }
            });
            binary.getTasks().add(resourcesTask);
            binary.builtBy(resourcesTask);
            resourcesTask.from(resourceSet.getSource());
        }
    });
}
 
Example 4
private void setupSolrPackaging(Project p, PackagingExtension extension, Path packageFolder, Zip zipPackage, Task cleanTargetFolder) {
    // FIXME This is only POC for Solr configuration only.
    Set<String> environments = extension.getEnvironments().get();
    Path configurationFolder = extension.getConfigurationFolder().getAsFile().get().toPath();
    for (String environment : environments) {
        Path sourceFolder = configurationFolder.resolve(environment).resolve("solr");
        Path commonFolder = configurationFolder.resolve(COMMON_CONFIG).resolve("solr");
        Path targetFolder = packageFolder.resolve("solr/config/" + environment);

        Copy copySolrCommonConfig = p.getTasks().create("copySolrCommonEnv_" + environment, Copy.class, t -> {
            t.from(commonFolder);
            t.into(targetFolder);
            t.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE);
            t.exclude(SOLR_CONFIG_EXCLUDE);
        });
        copySolrCommonConfig.dependsOn(cleanTargetFolder);

        Copy copySolrConfig = p.getTasks().create("copySolrEnv_" + environment, Copy.class, t -> {
            t.from(sourceFolder);
            t.into(targetFolder);
            t.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE);
            t.exclude(SOLR_CONFIG_EXCLUDE);
        });
        copySolrConfig.dependsOn(copySolrCommonConfig);

        zipPackage.dependsOn(copySolrConfig);
    }
}
 
Example 5
Source Project: commerce-gradle-plugin   Source File: CloudV2Plugin.java    License: Apache License 2.0 5 votes vote down vote up
private void configureCloudExtensionPackBootstrap(Project project, boolean useCloudExtensionPack) {
    if (!useCloudExtensionPack) {
        return;
    }
    Task cleanCep = project.getTasks().create("cleanCloudExtensionPack", Delete.class, d -> {
        d.delete(extension.getCloudExtensionPackFolder().getAsFile());
    });
    Copy unpackCep = project.getTasks().create("unpackCloudExtensionPack", Copy.class, c -> {
        c.dependsOn(cleanCep);
        c.from(project.provider(() -> project.getConfigurations()
                        .getByName(EXTENSION_PACK)
                        .getFiles()
                        .stream()
                        .map(project::zipTree)
                        .collect(Collectors.toSet())
                )
        );
        c.into(extension.getCloudExtensionPackFolder().getAsFile());
        c.doLast(a -> project.getConfigurations().getByName(EXTENSION_PACK)
                .getResolvedConfiguration()
                .getFirstLevelModuleDependencies()
                .forEach(r -> a.getLogger().lifecycle("Using Cloud Extension Pack: {}", r.getModuleVersion())));
    });

    Task bootstrapPlatform = project.getTasks().getByName("bootstrapPlatform");
    bootstrapPlatform.dependsOn(unpackCep);
    String reservedTypeCodes = "hybris/bin/platform/ext/core/resources/core/unittest/reservedTypecodes.txt";
    Copy copyTypeCodes = project.getTasks().create("copyCEPTypeCode", Copy.class, c -> {
        c.mustRunAfter(unpackCep);
        c.mustRunAfter("unpackPlatform");
        c.from(extension.getCloudExtensionPackFolder().file(reservedTypeCodes));
        c.into(project.file(reservedTypeCodes).getParent());
    });
    bootstrapPlatform.dependsOn(copyTypeCodes);
    PatchLocalExtensions patch = project.getTasks().create("patchLocalExtensions", PatchLocalExtensions.class, p -> {
        p.getTarget().set(project.file("hybris/config/localextensions.xml"));
        p.getCepFolder().set(extension.getCloudExtensionPackFolder());
    });
    bootstrapPlatform.dependsOn(patch);
}
 
Example 6
Source Project: javaide   Source File: JavaBasePlugin.java    License: GNU General Public License v3.0 5 votes vote down vote up
private void createProcessResourcesTaskForBinary(final SourceSet sourceSet, SourceDirectorySet resourceSet, final Project target) {
    Copy resourcesTask = target.getTasks().create(sourceSet.getProcessResourcesTaskName(), ProcessResources.class);
    resourcesTask.setDescription("Processes " + resourceSet + ".");
    new DslObject(resourcesTask).getConventionMapping().map("destinationDir", new Callable<File>() {
        public File call() throws Exception {
            return sourceSet.getOutput().getResourcesDir();
        }
    });
    resourcesTask.from(resourceSet);
}
 
Example 7
Source Project: shipkit   Source File: JavadocPlugin.java    License: MIT License 5 votes vote down vote up
@Override
public void apply(Project project) {
    project.getPlugins().apply(GitPlugin.class);
    ShipkitConfiguration conf = project.getPlugins().apply(ShipkitConfigurationPlugin.class).getConfiguration();

    CloneGitRepositoryTask cloneJavadocTask = createCloneJavadocTask(project, conf);

    GitCheckOutTask checkoutJavadocRepoBranch = createCheckoutJavadocReposBranch(project, conf);
    checkoutJavadocRepoBranch.dependsOn(cloneJavadocTask);

    CopyTasks copyTasks = createCopyJavadocToStageTasks(project);
    Task refreshVersionJavadocTask = createRefreshVersionJavadocTask(project, copyTasks.copyToVersionTasks);
    Task refreshCurrentJavadocTask = createRefreshCurrentJavadocTask(project, copyTasks.copyToCurrentTasks);

    //refresh javadoc first so that if there is no javadoc we will avoid cloning
    cloneJavadocTask.mustRunAfter(refreshVersionJavadocTask);

    Copy copyStageToRepoDir = createCopyStageToRepoDirTask(project, conf);
    copyStageToRepoDir.dependsOn(checkoutJavadocRepoBranch, refreshVersionJavadocTask, refreshCurrentJavadocTask);

    GitCommitTask commitJavadocTask = createGitCommitTask(project, conf);
    commitJavadocTask.dependsOn(copyStageToRepoDir);

    GitPushTask pushJavadoc = createPushJavadocTask(project, conf);
    pushJavadoc.dependsOn(commitJavadocTask);

    Task releaseJavadocTask = createReleaseJavadocTask(project);
    releaseJavadocTask.dependsOn(cloneJavadocTask, commitJavadocTask, pushJavadoc);
    // To avoid missing of performRelease task, when org.shipkit.javadoc plugin is applied before org.shipkit.java
    DeferredConfiguration.deferredConfiguration(project, () -> {
        Task performReleaseTask = project.getRootProject().getTasks().findByName(PERFORM_RELEASE_TASK);
        if (performReleaseTask != null) {
            performReleaseTask.dependsOn(releaseJavadocTask);
        }
    });

    deleteBuildDIrInRootProjectWhenCleanTask(project);
}
 
Example 8
Source Project: shipkit   Source File: JavadocPlugin.java    License: MIT License 5 votes vote down vote up
private CopyTasks createCopyJavadocToStageTasks(Project project) {
    Set<Copy> copyToVersionTasks = new HashSet<>();
    Set<Copy> copyToCurrentTasks = new HashSet<>();

    Set<Task> javadocJarSet = project.getTasksByName("javadocJar", true);
    if (javadocJarSet.isEmpty()) {
        LOGGER.warn("Not found any 'javadocJar' task. You probably applied 'org.shipkit.javadoc' plugin before 'org.shipkit.java'. " +
            "Please apply 'org.shipkit.java' plugin first!");
    }
    javadocJarSet.stream()
        .map(task -> (Jar) task)
        .forEach(javadocJarTask -> {
            Copy copyToVersionTask = TaskMaker.task(javadocJarTask.getProject(), COPY_JAVADOC_TO_STAGE_VERSION_DIR_TASK, Copy.class, copyTask -> {
                copyTask.setDescription("Extracts contents of javadoc jar to the staging /version directory");
                copyTask.dependsOn(javadocJarTask);
                copyTask.from(project.zipTree(javadocJarTask.getArchivePath()));
                // TODO how? : note that we need to use Closure/Callable because 'baseName' can be set by user later
                copyTask.into(getJavadocStageDir(project) + "/" + javadocJarTask.getBaseName() + "/" + project.getVersion());
            });
            copyToVersionTasks.add(copyToVersionTask);

            Copy copyToCurrentTask = TaskMaker.task(javadocJarTask.getProject(), COPY_JAVADOC_TO_STAGE_CURRENT_DIR_TASK, Copy.class, copyTask -> {
                copyTask.setDescription("Extracts contents of javadoc jar to the staging /current directory");
                copyTask.dependsOn(copyToVersionTask);
                copyTask.from(copyToVersionTask.getDestinationDir());
                // TODO how? : note that we need to use Closure/Callable because 'baseName' can be set by user later
                copyTask.into(getJavadocStageDir(project) + "/" + javadocJarTask.getBaseName() + "/current");
            });
            copyToCurrentTasks.add(copyToCurrentTask);
        });
    return new CopyTasks(copyToVersionTasks, copyToCurrentTasks);
}
 
Example 9
Source Project: shipkit   Source File: JavadocPlugin.java    License: MIT License 5 votes vote down vote up
private Copy createCopyStageToRepoDirTask(Project project,
                                          ShipkitConfiguration conf) {
    String directory = conf.getLenient().getJavadoc().getRepositoryDirectory();

    return TaskMaker.task(project, COPY_JAVADOC_STAGE_TO_REPO_DIR_TASK, Copy.class, task -> {
        task.setDescription("Copy prepared Javadocs from stage directory to the repository directory");
        task.from(getJavadocStageDir(project));
        task.into(getJavadocRepoCloneDir(project, directory));
    });
}
 
Example 10
Source Project: gradle-git-publish   Source File: GitPublishPlugin.java    License: Apache License 2.0 5 votes vote down vote up
private Copy createCopyTask(Project project, GitPublishExtension extension) {
  return project.getTasks().create(COPY_TASK, Copy.class, task -> {
    task.setGroup("publishing");
    task.setDescription("Copy contents to be published to git.");
    task.with(extension.getContents());
    task.into(extension.getRepoDir());
  });
}
 
Example 11
Source Project: crate   Source File: JdkDownloadPlugin.java    License: Apache License 2.0 5 votes vote down vote up
private static TaskProvider<?> createExtractTask(
    String taskName,
    Project rootProject,
    boolean isWindows,
    Provider<Directory> extractPath,
    Supplier<File> jdkBundle) {
    if (isWindows) {
        Action<CopySpec> removeRootDir = copy -> {
            // remove extra unnecessary directory levels
            copy.eachFile(details -> {
                Path newPathSegments = trimArchiveExtractPath(details.getRelativePath().getPathString());
                String[] segments = StreamSupport.stream(newPathSegments.spliterator(), false)
                    .map(Path::toString)
                    .toArray(String[]::new);
                details.setRelativePath(new RelativePath(true, segments));
            });
            copy.setIncludeEmptyDirs(false);
        };

        return rootProject.getTasks().register(taskName, Copy.class, copyTask -> {
            copyTask.doFirst(t -> rootProject.delete(extractPath));
            copyTask.into(extractPath);
            Callable<FileTree> fileGetter = () -> rootProject.zipTree(jdkBundle.get());
            copyTask.from(fileGetter, removeRootDir);
        });
    } else {
        /*
         * Gradle TarFileTree does not resolve symlinks, so we have to manually
         * extract and preserve the symlinks. cf. https://github.com/gradle/gradle/issues/3982
         * and https://discuss.gradle.org/t/tar-and-untar-losing-symbolic-links/2039
         */
        return rootProject.getTasks().register(taskName, SymbolicLinkPreservingUntarTask.class, task -> {
            task.getTarFile().fileProvider(rootProject.provider(jdkBundle::get));
            task.getExtractPath().set(extractPath);
            task.setTransform(JdkDownloadPlugin::trimArchiveExtractPath);
        });
    }
}
 
Example 12
private void setupDatahubPackaging(Project p, PackagingExtension extension, Path packageFolder, Zip zipPackage, Task cleanTargetFolder) {
    Copy copyDataHubWar = p.getTasks().create("copyDataHubWar", Copy.class, t -> {
        t.from(extension.getDatahubWar(), s -> s.rename(".*", "datahub-webapp.war"));
        t.into(packageFolder.resolve("datahub/bin"));
        t.onlyIf(a -> {
            if (a.getInputs().getSourceFiles().isEmpty()) {
                throw new StopExecutionException("no datahub file found");
            }
            return true;
        });
    });
    copyDataHubWar.dependsOn(cleanTargetFolder);
    zipPackage.dependsOn(copyDataHubWar);

    Set<String> environments = extension.getEnvironments().get();
    Path configurationFolder = extension.getConfigurationFolder().getAsFile().get().toPath();
    for (String environment : environments) {
        Path sourceFolder = configurationFolder.resolve(environment).resolve("datahub");
        Path commonFolder = configurationFolder.resolve(COMMON_CONFIG).resolve("datahub");
        Path targetFolder = packageFolder.resolve("datahub/config/" + environment);

        Copy copyCommonConfig = p.getTasks().create("copyDatahubCommonEnv_" + environment, Copy.class, t -> {
            t.from(commonFolder);
            t.into(targetFolder);
            t.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE);
            t.exclude(DATAHUB_CONFIG_EXCLUDE);
        });
        copyCommonConfig.dependsOn(cleanTargetFolder);

        Copy copyDatahubConfig = p.getTasks().create("copyDatahubEnv_" + environment, Copy.class, t -> {
            t.from(sourceFolder);
            t.into(targetFolder);
            t.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE);
            t.exclude(DATAHUB_CONFIG_EXCLUDE);
        });
        copyDatahubConfig.dependsOn(copyCommonConfig);

        MergePropertyFiles mergeProperties = p.getTasks().create("mergeDatahub_customer.properties_" + environment, MergePropertyFiles.class, t -> {
            t.getInputFiles().setFrom(Arrays.asList(
                    commonFolder.resolve("customer.properties"),
                    sourceFolder.resolve("customer.properties")
            ));
            t.setOutputFile(targetFolder.resolve("customer.properties"));
        });
        mergeProperties.dependsOn(copyDatahubConfig);

        zipPackage.dependsOn(mergeProperties);
    }
}
 
Example 13
Source Project: curiostack   Source File: StaticSitePlugin.java    License: MIT License 4 votes vote down vote up
@Override
public void apply(Project project) {
  project.getPlugins().apply(NodePlugin.class);

  var config = StaticSiteExtension.create(project);

  var mergeSite =
      project
          .getTasks()
          .register(
              "mergeSite",
              Copy.class,
              t -> {
                t.from("src");
                t.into("build/site");

                for (SiteProject site : config.getSites().get()) {
                  site.getProject()
                      .getPlugins()
                      .withType(
                          LifecycleBasePlugin.class,
                          unused ->
                              t.dependsOn(
                                  site.getProject()
                                      .getTasks()
                                      .named(LifecycleBasePlugin.ASSEMBLE_TASK_NAME)));
                  t.from(site.getBuildDir(), copy -> copy.into(site.getOutputSubDir()));
                }
              });

  var assemble = project.getTasks().named("assemble");
  assemble.configure(t -> t.dependsOn(mergeSite));

  var yarn = project.getRootProject().getTasks().named("yarn");

  var deployAlpha =
      project
          .getTasks()
          .register(
              "deployAlpha",
              GcloudTask.class,
              t -> {
                t.dependsOn(assemble);
                // TODO(choko): Remove this major hack - the command line has two --project flags
                // and we're just lucky the later is used.
                t.args(
                    config
                        .getAppEngineProject()
                        .map(
                            appEngineProject ->
                                ImmutableList.of(
                                    "app", "deploy", "--project=" + appEngineProject)));
              });

  var deployProd =
      project
          .getTasks()
          .register(
              "deployProd",
              NodeTask.class,
              t -> {
                t.dependsOn(yarn, assemble);
                t.args(
                    config
                        .getFirebaseProject()
                        .map(
                            firebaseProject ->
                                ImmutableList.of(
                                    "run", "firebase", "--project", firebaseProject, "deploy")));
              });

  project
      .getTasks()
      .register(
          "preview",
          NodeTask.class,
          t -> {
            t.dependsOn(yarn, assemble);
            t.args("run", "superstatic", "--port=8080");
          });

  CurioGenericCiPlugin.addToReleaseBuild(project, deployProd);

  project.afterEvaluate(
      unused -> {
        if (config.getAutoDeployAlpha().get()) {
          CurioGenericCiPlugin.addToMasterBuild(project, deployAlpha);
        }
      });
}
 
Example 14
Source Project: pygradle   Source File: PythonFlyerPlugin.java    License: Apache License 2.0 4 votes vote down vote up
@Override
public void apply(final Project project) {

    project.getPlugins().apply(PythonWebApplicationPlugin.class);

    /*
     * This configuration is used to connect the Python project to the Ember project.
     * We will use this configuration to access the static resource, create the symlink and package the resource.
     */
    final Configuration resourceConf = project.getConfigurations().create("resource");

    /*
     * Under the Python project, we need to make a link to the Ember resource(<ember-project>/dist for now).
     * By doing this, it becomes easier for the Python project to access the resource files.
     * And for both local development and LID deployment, the resource folder will have the
     * same relative directory. This will also simplify the logic in python project.
     */
    project.getTasks().create(TASK_SETUP_RESOURCE_LINK, task -> {
        task.dependsOn(resourceConf);
        task.doLast(it -> {
            if (!Paths.get(project.getProjectDir().getAbsolutePath(), "resource").toFile().exists()) {
                project.getLogger().lifecycle("Making the Symlink: {}{}resource --> {}",
                    project.getProjectDir(), File.separatorChar, String.valueOf(resourceConf.getSingleFile()));
                FileSystemUtils.makeSymLinkUnchecked(resourceConf.getSingleFile(), new File(project.getProjectDir(), "resource"));
            }
        });
    });

    project.getTasks().getByName(StandardTextValues.TASK_INSTALL_PROJECT.getValue())
        .dependsOn(project.getTasks().getByName(TASK_SETUP_RESOURCE_LINK));

    /*
     * In order to make the resource files accessible when deploying the project, we need to copy the
     * static files into the 'deployable' directory.
     */
    project.getTasks().create(TASK_PACKAGE_RESOURCE_FILES, Copy.class, copy -> {
        final DeployableExtension deployableExtension = ExtensionUtils.maybeCreateDeployableExtension(project);
        copy.dependsOn(project.getTasks().getByName(PythonWebApplicationPlugin.TASK_BUILD_WEB_APPLICATION));

        copy.from(resourceConf);
        copy.into(deployableExtension.getDeployableBuildDir().toPath().resolve("resource"));
    });

    // Make sure we've copied all the files before running the task: packageDeployable
    project.getTasks().getByName(ApplicationContainer.TASK_PACKAGE_DEPLOYABLE)
        .dependsOn(project.getTasks().getByName(TASK_PACKAGE_RESOURCE_FILES));
}
 
Example 15
Source Project: shipkit   Source File: JavadocPlugin.java    License: MIT License 4 votes vote down vote up
private Task createRefreshVersionJavadocTask(Project project, Set<Copy> copyToVersionTasks) {
    return TaskMaker.task(project, REFRESH_VERSION_JAVADOC_TASK, task -> {
        task.dependsOn(copyToVersionTasks);
        task.setDescription("Copy Javadocs from all modules to the staging /version directory");
    });
}
 
Example 16
Source Project: shipkit   Source File: JavadocPlugin.java    License: MIT License 4 votes vote down vote up
private Task createRefreshCurrentJavadocTask(Project project, Set<Copy> copyToCurrentTasks) {
    return TaskMaker.task(project, REFRESH_CURRENT_JAVADOC_TASK, task -> {
        task.dependsOn(copyToCurrentTasks);
        task.setDescription("Copy Javadocs from all modules to the staging /current directory");
    });
}
 
Example 17
Source Project: shipkit   Source File: JavadocPlugin.java    License: MIT License 4 votes vote down vote up
private CopyTasks(Set<Copy> copyToVersionTasks, Set<Copy> copyToCurrentTasks) {
    this.copyToVersionTasks = copyToVersionTasks;
    this.copyToCurrentTasks = copyToCurrentTasks;
}