org.gradle.api.logging.Logger Java Examples

/** Task entrypoint : start the dev appserver (non-blocking). */
@TaskAction
public void startAction() throws AppEngineException, IOException {

  // Add a listener to write to a file for non-blocking starts, this really only works
  // when the gradle daemon is running (which is default for newer versions of gradle)
  File logFile = new File(devAppServerLoggingDir, "dev_appserver.out");
  FileOutputLineListener logFileWriter = new FileOutputLineListener(logFile);

  Logger taskLogger = getLogger();
  ProcessHandler processHandler =
      LegacyProcessHandler.builder()
          .addStdOutLineListener(taskLogger::lifecycle)
          .addStdOutLineListener(logFileWriter)
          .addStdErrLineListener(taskLogger::lifecycle)
          .addStdErrLineListener(logFileWriter)
          .setExitListener(new NonZeroExceptionExitListener())
          .buildDevAppServerAsync(runConfig.getStartSuccessTimeout());

  devServers.newDevAppServer(processHandler).run(runConfig.toRunConfiguration());

  getLogger().lifecycle("Dev App Server output written to : " + logFile.getAbsolutePath());
}
 

protected static ProjectOutputTypes determineProjectOutputType(Project project, Logger logger) {

        ProjectOutputTypes projectOutputType = null;

        for ( String kp: knownPlugins.keySet()) {
            if (project.getPlugins().hasPlugin(kp)) {
                logger.quiet("Found plugin: " + kp);
                projectOutputType = knownPlugins.get(kp);
                break;
            }
        }

        if (projectOutputType != null) {
            logger.quiet("Project type determined: {}", projectOutputType.toString());
        }

        return projectOutputType;
    }
 

@TaskAction
void verify() {
    try {
        GraphvizCmdLineEngine graphvizCmdLineEngine = new GraphvizCmdLineEngine();
        GraphvizjView.confirmInstalledGraphviz(graphvizCmdLineEngine);
    } catch(RuntimeException e) {
        Logger logger = getLogger();
        logger.warn("-- JIG ERROR -----------------------------------------------");
        logger.warn("+ 実行可能なGraphvizが見つけられませんでした。");
        logger.warn("+ dotにPATHが通っているか確認してください。");
        logger.warn("+ JIGはダイアグラムの出力にGraphvizを使用しています。");
        logger.warn("+ ");
        logger.warn("+ Graphvizは以下から入手できます。");
        logger.warn("+     https://www.graphviz.org/");
        logger.warn("------------------------------------------------------------");

        throw e;
    }
}
 

public TaobaoInstantRunDex(
        AppVariantContext variantContext,
        @NonNull InstantRunVariantScope transformVariantScope,
        DexByteCodeConverter dexByteCodeConverter,
        @NonNull DexOptions dexOptions,
        @NonNull Logger logger,
        int minSdkForDx,
        BaseVariantOutput variantOutput) {
    this.variantScope = transformVariantScope;
    this.variantContext = variantContext;
    this.dexByteCodeConverter = dexByteCodeConverter;
    this.dexOptions = dexOptions;
    this.logger = new LoggerWrapper(logger);
    this.minSdkForDx = minSdkForDx;
    this.variantOutput = variantOutput;
}
 

StackdriverMetrics(Gradle gradle, Logger logger) {
  this.logger = logger;
  globalContext = deserializeContext();

  ensureStackdriver(gradle);

  Stats.getViewManager()
      .registerView(
          View.create(
              View.Name.create("fireci/tasklatency"),
              "The latency in milliseconds",
              M_LATENCY,
              Aggregation.LastValue.create(),
              TAG_KEYS));

  Stats.getViewManager()
      .registerView(
          View.create(
              View.Name.create("fireci/tasksuccess"),
              "Indicated success or failure.",
              M_SUCCESS,
              Aggregation.LastValue.create(),
              TAG_KEYS));
}
 

/**
 * todo how know which app will be debugged?
 * just support taobao.apk now
 */
private static void notifyApppatching(AndroidBuilder androidBuilder, String patchPkg, Logger logger) {
    CommandExecutor executor = CommandExecutor.Factory.createDefaultCommmandExecutor();
    executor.setLogger(logger);
    executor.setCaptureStdOut(true);
    executor.setCaptureStdErr(true);
    //        List<String> killCmd = Arrays.asList("shell", "am", "force-stop", packageNameForPatch);
    //        List<String> startCmd = Arrays.asList("shell", "am", "start", packageNameForPatch + "/" +
    // launcherActivityForPatch);
    List<String> patchCmd = Arrays.asList("shell", "am", "broadcast", "-a", "com.taobao.atlas.intent.PATCH_APP",
                                          "-e", "pkg", patchPkg, "-n",
                                          patchPkg + "/com.taobao.atlas.update.AwoPatchReceiver");
    try {
        executor.executeCommand(androidBuilder.getSdkInfo().getAdb().getAbsolutePath(), patchCmd, false);
    } catch (Exception e) {
        throw new RuntimeException("error while restarting app,you can also restart by yourself", e);
    }
}
 

static WorkResult execute(ScalaJavaJointCompileSpec spec) {
    LOGGER.info("Compiling with Zinc Scala compiler.");

    xsbti.Logger logger = new SbtLoggerAdapter();

    com.typesafe.zinc.Compiler compiler = createCompiler(spec.getScalaClasspath(), spec.getZincClasspath(), logger);
    List<String> scalacOptions = new ScalaCompilerArgumentsGenerator().generate(spec);
    List<String> javacOptions = new JavaCompilerArgumentsBuilder(spec).includeClasspath(false).build();
    Inputs inputs = Inputs.create(ImmutableList.copyOf(spec.getClasspath()), ImmutableList.copyOf(spec.getSource()), spec.getDestinationDir(),
            scalacOptions, javacOptions, spec.getScalaCompileOptions().getIncrementalOptions().getAnalysisFile(), spec.getAnalysisMap(), "mixed", getIncOptions(), true);
    if (LOGGER.isDebugEnabled()) {
        Inputs.debug(inputs, logger);
    }

    try {
        compiler.compile(inputs, logger);
    } catch (xsbti.CompileFailed e) {
        throw new CompilationFailedException(e);
    }

    return new SimpleWorkResult(true);
}
 

static WorkResult execute(ScalaJavaJointCompileSpec spec) {
    LOGGER.info("Compiling with Zinc Scala compiler.");

    xsbti.Logger logger = new SbtLoggerAdapter();

    com.typesafe.zinc.Compiler compiler = createCompiler(spec.getScalaClasspath(), spec.getZincClasspath(), logger);
    List<String> scalacOptions = new ScalaCompilerArgumentsGenerator().generate(spec);
    List<String> javacOptions = new JavaCompilerArgumentsBuilder(spec).includeClasspath(false).build();
    Inputs inputs = Inputs.create(ImmutableList.copyOf(spec.getClasspath()), ImmutableList.copyOf(spec.getSource()), spec.getDestinationDir(),
            scalacOptions, javacOptions, spec.getScalaCompileOptions().getIncrementalOptions().getAnalysisFile(), spec.getAnalysisMap(), "mixed", getIncOptions(), true);
    if (LOGGER.isDebugEnabled()) {
        Inputs.debug(inputs, logger);
    }

    try {
        compiler.compile(inputs, logger);
    } catch (xsbti.CompileFailed e) {
        throw new CompilationFailedException(e);
    }

    return new SimpleWorkResult(true);
}
 

static WorkResult execute(ScalaJavaJointCompileSpec spec) {
    LOGGER.info("Compiling with Zinc Scala compiler.");

    xsbti.Logger logger = new SbtLoggerAdapter();

    com.typesafe.zinc.Compiler compiler = createCompiler(spec.getScalaClasspath(), spec.getZincClasspath(), logger);
    List<String> scalacOptions = new ScalaCompilerArgumentsGenerator().generate(spec);
    List<String> javacOptions = new JavaCompilerArgumentsBuilder(spec).includeClasspath(false).build();
    Inputs inputs = Inputs.create(ImmutableList.copyOf(spec.getClasspath()), ImmutableList.copyOf(spec.getSource()), spec.getDestinationDir(),
            scalacOptions, javacOptions, spec.getScalaCompileOptions().getIncrementalOptions().getAnalysisFile(), spec.getAnalysisMap(), "mixed", getIncOptions(), true);
    if (LOGGER.isDebugEnabled()) {
        Inputs.debug(inputs, logger);
    }

    try {
        compiler.compile(inputs, logger);
    } catch (xsbti.CompileFailed e) {
        throw new CompilationFailedException(e);
    }

    return new SimpleWorkResult(true);
}
 

static com.typesafe.zinc.Compiler createCompiler(Iterable<File> scalaClasspath, Iterable<File> zincClasspath, xsbti.Logger logger) {
    ScalaLocation scalaLocation = ScalaLocation.fromPath(Lists.newArrayList(scalaClasspath));
    SbtJars sbtJars = SbtJars.fromPath(Lists.newArrayList(zincClasspath));
    Setup setup = Setup.create(scalaLocation, sbtJars, Jvm.current().getJavaHome(), true);
    if (LOGGER.isDebugEnabled()) {
        Setup.debug(setup, logger);
    }
    return com.typesafe.zinc.Compiler.getOrCreate(setup, logger);
}
 

CompiledJavaccFile(File file, File outputDirectory, FileTree customAstClassesDirectory, File targetDirectory, Logger logger) {
    this.compiledJavaccFile = file;
    this.outputDirectory = outputDirectory;
    this.customAstClassesDirectory = customAstClassesDirectory;
    this.targetDirectory = targetDirectory;
    this.logger = logger;
}
 

static WorkResult execute(ScalaJavaJointCompileSpec spec) {
    LOGGER.info("Compiling with Zinc Scala compiler.");

    xsbti.Logger logger = new SbtLoggerAdapter();

    com.typesafe.zinc.Compiler compiler = createCompiler(spec.getScalaClasspath(), spec.getZincClasspath(), logger);
    List<String> scalacOptions = new ScalaCompilerArgumentsGenerator().generate(spec);
    List<String> javacOptions = new JavaCompilerArgumentsBuilder(spec).includeClasspath(false).build();
    Inputs inputs = Inputs.create(ImmutableList.copyOf(spec.getClasspath()), ImmutableList.copyOf(spec.getSource()), spec.getDestinationDir(),
            scalacOptions, javacOptions, spec.getScalaCompileOptions().getIncrementalOptions().getAnalysisFile(), spec.getAnalysisMap(), "mixed", getIncOptions(), true);
    if (LOGGER.isDebugEnabled()) {
        Inputs.debug(inputs, logger);
    }

    try {
        compiler.compile(inputs, logger);
    } catch (xsbti.CompileFailed e) {
        throw new CompilationFailedException(e);
    }

    return new SimpleWorkResult(true);
}
 

@Before
public void createCompiledJavaccFile() {
    outputDirectory = new File(getClass().getResource("/compiledJavaccFile/output").getFile());
    targetDirectory = new File(getClass().getResource("/compiledJavaccFile/target").getFile());
    logger = mock(Logger.class);
    
    Set<File> sourceTree = new HashSet<File>();
    sourceTree.add(new File(getClass().getResource("/compiledJavaccFile/customAstClasses").getFile()));
    customAstClassesDirectory = mock(FileTree.class);
    when(customAstClassesDirectory.getFiles()).thenReturn(sourceTree);
}
 

public ProductFlavorFactory(@NonNull Instantiator instantiator,
                            @NonNull Project project,
                            @NonNull Logger logger) {
    this.instantiator = instantiator;
    this.project = project;
    this.logger = logger;
}
 

public ResourcesShrinker(ShrinkResourcesTransform resourcesTransform, @NonNull BaseVariantData variantData,
                         @NonNull FileCollection uncompressedResources,
                         @NonNull File compressedResources,
                         @NonNull AaptGeneration aaptGeneration,
                         @NonNull FileCollection splitListInput,
                         @NonNull Logger logger,
                         AppVariantContext variantContext) {

    this.variantContext = variantContext;
    this.resourcesTransform = resourcesTransform;
    VariantScope variantScope = variantData.getScope();
    GlobalScope globalScope = variantScope.getGlobalScope();
    GradleVariantConfiguration variantConfig = variantData.getVariantConfiguration();

    this.variantData = variantData;
    this.logger = logger;

    this.sourceDir = variantScope.getRClassSourceOutputDir();
    this.resourceDir = variantScope.getOutput(TaskOutputHolder.TaskOutputType.MERGED_NOT_COMPILED_RES);
    this.mappingFileSrc =
            variantScope.hasOutput(TaskOutputHolder.TaskOutputType.APK_MAPPING)
                    ? variantScope.getOutput(TaskOutputHolder.TaskOutputType.APK_MAPPING)
                    : null;
    this.mergedManifests = variantScope.getOutput(TaskOutputHolder.TaskOutputType.MERGED_MANIFESTS);
    this.uncompressedResources = uncompressedResources;
    this.splitListInput = splitListInput;

    this.aaptGeneration = aaptGeneration;
    this.aaptOptions = globalScope.getExtension().getAaptOptions();
    this.variantType = variantData.getType();
    this.isDebuggableBuildType = variantConfig.getBuildType().isDebuggable();
    this.multiOutputPolicy = variantData.getOutputScope().getMultiOutputPolicy();
    this.compressedResources = compressedResources;
}
 

public GradleBuildComparison(
        ComparableGradleBuildExecuter sourceBuildExecuter,
        ComparableGradleBuildExecuter targetBuildExecuter,
        Logger logger,
        ProgressLogger progressLogger,
        Gradle gradle) {
    this.sourceBuildExecuter = sourceBuildExecuter;
    this.targetBuildExecuter = targetBuildExecuter;
    this.logger = logger;
    this.progressLogger = progressLogger;
    this.gradle = gradle;
}
 

String run(Logger log, List<String> commandLine) {
    // WARNING!!! ensure that masked command line is used for all logging!!!
    String maskedCommandLine = mask(join(commandLine, " "));
    log.lifecycle("  Executing:\n    " + maskedCommandLine);

    ProcessResult result = executeProcess(commandLine, maskedCommandLine);

    if (result.getExitValue() != 0) {
        return executionOfCommandFailed(maskedCommandLine, result);
    } else {
        String output = result.getOutput();
        LOG.info("Output from external process '{}':\n{}", maskedCommandLine, output);
        return output;
    }
}
 

@TaskAction
public void transcode() {
    Logger logger = getLogger();

    logger.trace("Working on files in " + inputRootDirectory.getAbsolutePath());

    if (!this.inputRootDirectory.exists()) {
        return;
    }

    this.outputRootDirectory.mkdirs();

    boolean renderAsKotlinCode = ("kotlin".compareTo(outputLanguage) == 0);

    LanguageRenderer languageRenderer = renderAsKotlinCode
            ? new KotlinLanguageRenderer()
            : new JavaLanguageRenderer();
    String outputFileNameExtension = ("java".compareTo(outputLanguage) == 0) ? ".java" : ".kt";

    logger.trace("Processing " + inputRootDirectory.getAbsolutePath() + " to " + outputRootPackageName +
            " in " + outputLanguage);

    String templateFileName = "/org/pushingpixels/photon/api/transcoder/" + outputLanguage + "/"
            + "SvgTranscoderTemplate";
    templateFileName += (useResizableTemplate ? "Resizable" : "Plain");
    templateFileName += ".templ";

    processFolder(inputRootDirectory, outputRootDirectory, outputClassNamePrefix, outputFileNameExtension,
            outputRootPackageName, languageRenderer, templateFileName);
}
 

protected void processFolder(File inputFolder, File outputFolder,
        String outputClassNamePrefix, String outputFileNameExtension,
        String outputPackageName, LanguageRenderer languageRenderer,
        String templateFile) {

    Logger logger = getLogger();
    logger.trace("Working on files in " + inputFolder.getAbsolutePath());

    // Transcode all SVG files in this folder
    transcodeAllFilesInFolder(inputFolder, outputFolder, outputClassNamePrefix, outputFileNameExtension,
            outputPackageName, languageRenderer, templateFile);

    // Now scan the folder for sub-folders
    for (File inputSubfolder : inputFolder.listFiles((File dir, String name) -> new File(dir, name).isDirectory())) {
        String subfolderName = inputSubfolder.getName();
        logger.trace("Going into sub-folder " + subfolderName);

        // Mirror the input subfolder structure to the output
        File outputSubfolder = new File(outputFolder, subfolderName);
        if (!outputSubfolder.exists()) {
            outputSubfolder.mkdir();
        }

        // And recursively process SVG content (and possible folders)
        processFolder(inputSubfolder, outputSubfolder, outputClassNamePrefix, outputFileNameExtension,
                outputPackageName + "." + subfolderName, languageRenderer,
                templateFile);
    }
    System.out.println();
}
 

@TaskAction
public void transcode() {
    Logger logger = getLogger();

    logger.trace("Working on files in " + inputDirectory.getAbsolutePath());

    if (!this.inputDirectory.exists()) {
        return;
    }

    this.outputDirectory.mkdirs();

    boolean renderAsKotlinCode = ("kotlin".compareTo(outputLanguage) == 0);

    LanguageRenderer languageRenderer = renderAsKotlinCode
            ? new KotlinLanguageRenderer()
            : new JavaLanguageRenderer();
    String outputFileNameExtension = ("java".compareTo(outputLanguage) == 0) ? ".java" : ".kt";

    logger.trace("Processing " + inputDirectory.getAbsolutePath() + " to " + outputPackageName +
            " in " + outputLanguage);

    String templateFileName = "/org/pushingpixels/photon/api/transcoder/" + outputLanguage + "/"
            + "SvgTranscoderTemplate";
    templateFileName += (useResizableTemplate ? "Resizable" : "Plain");
    templateFileName += ".templ";

    this.transcodeAllFilesInFolder(inputDirectory, outputDirectory,
            outputClassNamePrefix, outputFileNameExtension,
            outputPackageName, languageRenderer, templateFileName);
}
 

static com.typesafe.zinc.Compiler createCompiler(Iterable<File> scalaClasspath, Iterable<File> zincClasspath, xsbti.Logger logger) {
    ScalaLocation scalaLocation = ScalaLocation.fromPath(Lists.newArrayList(scalaClasspath));
    SbtJars sbtJars = SbtJars.fromPath(Lists.newArrayList(zincClasspath));
    Setup setup = Setup.create(scalaLocation, sbtJars, Jvm.current().getJavaHome(), true);
    if (LOGGER.isDebugEnabled()) {
        Setup.debug(setup, logger);
    }
    return com.typesafe.zinc.Compiler.getOrCreate(setup, logger);
}
 

static com.typesafe.zinc.Compiler createCompiler(Iterable<File> scalaClasspath, Iterable<File> zincClasspath, xsbti.Logger logger) {
    ScalaLocation scalaLocation = ScalaLocation.fromPath(Lists.newArrayList(scalaClasspath));
    SbtJars sbtJars = SbtJars.fromPath(Lists.newArrayList(zincClasspath));
    Setup setup = Setup.create(scalaLocation, sbtJars, Jvm.current().getJavaHome(), true);
    if (LOGGER.isDebugEnabled()) {
        Setup.debug(setup, logger);
    }
    return com.typesafe.zinc.Compiler.getOrCreate(setup, logger);
}
 

public CompiledJavaccFilesDirectory getCompiledJavaccFilesDirectory(File outputDirectory, FileTree customAstClassesDirectory, File targetDirectory, Logger logger) {
    if ((outputDirectory == null) || !outputDirectory.exists() || !outputDirectory.isDirectory()) {
        throw new IllegalArgumentException("outputDirectory [" + outputDirectory + "] must be an existing directory");
    }
    
    if (customAstClassesDirectory == null) {
        throw new IllegalArgumentException("customAstClassesDirectory [" + outputDirectory + "] must not be null");
    }
    
    if ((targetDirectory == null) || !targetDirectory.exists() || !targetDirectory.isDirectory()) {
        throw new IllegalArgumentException("targetDirectory [" + targetDirectory + "] must be an existing directory");
    }
    
    return new CompiledJavaccFilesDirectory(outputDirectory, customAstClassesDirectory, targetDirectory, logger);
}
 

public FTPUploader(Logger logger) {
    this.logger = logger;
}
 

public TaobaoInstantRunDependenciesApkBuilder(Logger logger, Project project, InstantRunBuildContext buildContext, AndroidBuilder androidBuilder, FileCache fileCache, PackagingScope packagingScope, CoreSigningConfig signingConf, AaptGeneration aaptGeneration, AaptOptions aaptOptions, File outputDirectory, File supportDirectory, File aaptIntermediateDirectory) {
    super(logger, project, buildContext, androidBuilder, fileCache, packagingScope, signingConf, aaptGeneration, aaptOptions, outputDirectory, supportDirectory, aaptIntermediateDirectory);
}
 

public DefaultChannelConfigFactory(Instantiator instantiator, Project project, Logger logger) {
    this.instantiator = instantiator;
    this.project = project;
    this.logger = logger;
}
 

public MixinMethod(Mixin mixin, MethodNode mn, Logger log) {
  _mixin = mixin;
  _mn = mn;
  _log = log;
}
 

public ClassTrimmer(String compileSdkVersion, ClassProvider provider, Logger log) {
  _provider = provider;
  _log = log;
  _compileSdkVersion = parseCompileSdkVersion(compileSdkVersion);
}
 

public Mixin(Logger log) {
  _log = log;
}
 

public DependencyManager(Project project, Logger logger) {
  this.project = project;
  this.logger = logger;
}