Esempio n. 1
0
 @Override
 public Object clone() throws CloneNotSupportedException {
   NpcState clone = (NpcState) super.clone();
   clone.script = new ScriptFile();
   //        clone.script.setIndex(script.getIndex());
   //        clone.script.setFile(script.getFile());
   clone.script.setFunc(script.getFunc());
   return clone;
 }
Esempio n. 2
0
  @Override
  public void constructBuildProcess(
      @NotNull final BuildRunnerContext context,
      @NotNull final CommandlineExecutor cmd,
      @NotNull final TryFinallyBuildProcess builder)
      throws RunBuildException {
    final DockerContext ctx = new DockerContext(context);

    final File checkoutDir = ctx.getCheckoutDirectory();
    final File workDir = ctx.getWorkingDirectory();
    final String mountPoint = ctx.getCheckoutMountPoint();
    final BuildProgressLogger logger = context.getBuild().getBuildLogger();

    myScriptFile.generateScriptFile(
        ctx,
        builder,
        new ScriptFile.Builder() {
          @Override
          public void buildWithScriptFile(@NotNull final File script) throws RunBuildException {
            final String name = "teamcity_" + StringUtil.generateUniqueHash();
            final List<String> additionalCommands =
                additionalCommands(
                    context
                        .getRunnerParameters()
                        .get(VMConstants.PARAMETER_DOCKER_CUSTOM_COMMANDLINE));

            builder.addTryProcess(
                block(
                    "Pulling the image",
                    cmd.commandline(
                        checkoutDir, Arrays.asList("docker", "pull", ctx.getImageName()))));

            builder.addTryProcess(
                block(
                    "Executing the command using " + ctx.getShellLocation(),
                    cmd.commandline(
                        checkoutDir,
                        dockerRun(name, workDir, additionalCommands, scriptRun(script)))));
            builder.addFinishProcess(
                block(
                    "Terminating images (if needed)",
                    cmd.commandline(
                        checkoutDir, Arrays.asList("docker", "kill", name, "2>&1", "||", "true"))));

            builder.addFinishProcess(
                block(
                    "Fixing chown",
                    new DelegatingBuildProcess(
                        new DelegatingBuildProcess.ActionAdapter() {
                          @NotNull
                          @Override
                          public BuildProcess startImpl() throws RunBuildException {
                            final CompositeBuildProcess bp = new CompositeBuildProcessImpl();

                            final String uid = mySidAndGid.getUID();
                            final String gid = mySidAndGid.getGID();

                            if (StringUtil.isEmptyOrSpaces(uid)
                                || StringUtil.isEmptyOrSpaces(gid)) {
                              logger.warning(
                                  "SID and GID of current user were not found. chown is skipped");
                              return NOP;
                            }

                            bp.pushBuildProcess(
                                cmd.commandline(
                                    checkoutDir,
                                    dockerRun(
                                        name + "S",
                                        checkoutDir,
                                        /**
                                         * chown should be called for checkout dir to make sure all
                                         * file owners are fixed, no matter what workdir is *
                                         */
                                        Arrays.<String>asList(),
                                        Arrays.asList(
                                            ctx.getShellLocation(),
                                            "-c",
                                            "chown -R " + uid + ":" + gid + " ."))));

                            return bp;
                          }
                        })));
          }

          @NotNull
          private List<String> scriptRun(@NotNull final File script) {
            return Arrays.asList(
                ctx.getShellLocation(), "-c", "\"source " + script.getName() + "\"");
          }

          @NotNull
          private List<String> dockerRun(
              @NotNull final String name,
              @NotNull final File workDir,
              @NotNull final List<String> dockerArgs,
              @NotNull final List<String> command)
              throws RunBuildException {
            final List<String> arguments = new ArrayList<String>();

            arguments.addAll(
                Arrays.asList(
                    "docker",
                    "run",
                    "--rm=true",
                    "--name=" + name,
                    "-v",
                    checkoutDir.getPath() + ":" + mountPoint + ":rw",
                    "--workdir="
                        + mountPoint
                        + "/"
                        + RelativePaths.resolveRelativePath(checkoutDir, workDir),
                    "--interactive=false",
                    "--tty=false"));

            arguments.addAll(dockerArgs);

            arguments.add(ctx.getImageName());

            arguments.addAll(command);

            return arguments;
          }

          @NotNull
          private BuildProcess block(
              @NotNull final String blockText, @NotNull final BuildProcess proc) {
            return BaseVM.block(logger, "docker", blockText, proc);
          }
        });
  }