Examples with Timer org.gradle.internal.time.Timer used on opensource projects

Example 26 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class Binary2JUnitXmlReportGenerator method generate.

public void generate() {
    Timer clock = Time.startTimer();
    buildOperationExecutor.run(new RunnableBuildOperation() {

        @Override
        public void run(BuildOperationContext context) {
            File[] oldXmlFiles = testResultsDir.listFiles(new FilenameFilter() {

                @Override
                public boolean accept(File dir, String name) {
                    return name.startsWith("TEST") && name.endsWith(".xml");
                }
            });
            for (File oldXmlFile : oldXmlFiles) {
                GFileUtils.deleteQuietly(oldXmlFile);
            }
        }

        @Override
        public BuildOperationDescriptor.Builder description() {
            return BuildOperationDescriptor.displayName("Delete old JUnit XML results");
        }
    });
    buildOperationExecutor.runAll(new Action<BuildOperationQueue<JUnitXmlReportFileGenerator>>() {

        @Override
        public void execute(final BuildOperationQueue<JUnitXmlReportFileGenerator> queue) {
            testResultsProvider.visitClasses(new Action<TestClassResult>() {

                @Override
                public void execute(final TestClassResult result) {
                    final File reportFile = new File(testResultsDir, getReportFileName(result));
                    queue.add(new JUnitXmlReportFileGenerator(result, reportFile, xmlWriter));
                }
            });
        }
    });
    LOG.info("Finished generating test XML results ({}) into: {}", clock.getElapsed(), testResultsDir);
}

Example 27 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class DefaultDaemonStarter method startProcess.

private DaemonStartupInfo startProcess(List<String> args, File workingDir, File gradleUserHome, InputStream stdInput) {
    LOGGER.debug("Starting daemon process: workingDir = {}, daemonArgs: {}", workingDir, args);
    Timer clock = Time.startTimer();
    try {
        GFileUtils.mkdirs(workingDir);
        DaemonOutputConsumer outputConsumer = new DaemonOutputConsumer();
        // This factory should be injected but leaves non-daemon threads running when used from the tooling API client
        @SuppressWarnings("deprecation") DefaultExecActionFactory execActionFactory = DefaultExecActionFactory.root(gradleUserHome);
        try {
            ExecHandle handle = new DaemonExecHandleBuilder().build(args, workingDir, outputConsumer, stdInput, execActionFactory.newExec());
            handle.start();
            LOGGER.debug("Gradle daemon process is starting. Waiting for the daemon to detach...");
            handle.waitForFinish();
            LOGGER.debug("Gradle daemon process is now detached.");
        } finally {
            CompositeStoppable.stoppable(execActionFactory).stop();
        }
        return daemonGreeter.parseDaemonOutput(outputConsumer.getProcessOutput(), args);
    } catch (GradleException e) {
        throw e;
    } catch (Exception e) {
        throw new GradleException("Could not start Gradle daemon.", e);
    } finally {
        LOGGER.info("An attempt to start the daemon took {}.", clock.getElapsed());
    }
}

Example 28 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class TransientConfigurationResultsBuilder method deserialize.

private TransientConfigurationResults deserialize(Decoder decoder, ResolvedGraphResults graphResults, SelectedArtifactResults artifactResults, BuildOperationExecutor buildOperationProcessor) {
    Timer clock = Time.startTimer();
    Map<Long, DefaultResolvedDependency> allDependencies = new HashMap<>();
    Map<Dependency, DependencyGraphNodeResult> firstLevelDependencies = new LinkedHashMap<>();
    DependencyGraphNodeResult root;
    int valuesRead = 0;
    byte type = -1;
    long id;
    ResolvedArtifactSet artifacts;
    try {
        while (true) {
            type = decoder.readByte();
            valuesRead++;
            switch(type) {
                case NODE:
                    id = decoder.readSmallLong();
                    ResolvedConfigurationIdentifier details = resolvedConfigurationIdentifierSerializer.read(decoder);
                    allDependencies.put(id, new DefaultResolvedDependency(details, buildOperationProcessor));
                    break;
                case ROOT:
                    id = decoder.readSmallLong();
                    root = allDependencies.get(id);
                    if (root == null) {
                        throw new IllegalStateException(String.format("Unexpected root id %s. Seen ids: %s", id, allDependencies.keySet()));
                    }
                    // root should be the last entry
                    LOG.debug("Loaded resolved configuration results ({}) from {}", clock.getElapsed(), binaryStore);
                    return new DefaultTransientConfigurationResults(root, firstLevelDependencies);
                case FIRST_LEVEL:
                    id = decoder.readSmallLong();
                    DefaultResolvedDependency dependency = allDependencies.get(id);
                    if (dependency == null) {
                        throw new IllegalStateException(String.format("Unexpected first level id %s. Seen ids: %s", id, allDependencies.keySet()));
                    }
                    firstLevelDependencies.put(graphResults.getModuleDependency(id), dependency);
                    break;
                case EDGE:
                    long parentId = decoder.readSmallLong();
                    long childId = decoder.readSmallLong();
                    DefaultResolvedDependency parent = allDependencies.get(parentId);
                    DefaultResolvedDependency child = allDependencies.get(childId);
                    if (parent == null) {
                        throw new IllegalStateException(String.format("Unexpected parent dependency id %s. Seen ids: %s", parentId, allDependencies.keySet()));
                    }
                    if (child == null) {
                        throw new IllegalStateException(String.format("Unexpected child dependency id %s. Seen ids: %s", childId, allDependencies.keySet()));
                    }
                    parent.addChild(child);
                    artifacts = artifactResults.getArtifactsWithId(decoder.readSmallInt());
                    child.addParentSpecificArtifacts(parent, artifacts);
                    break;
                case NODE_ARTIFACTS:
                    id = decoder.readSmallLong();
                    DefaultResolvedDependency node = allDependencies.get(id);
                    if (node == null) {
                        throw new IllegalStateException(String.format("Unexpected node id %s. Seen ids: %s", node, allDependencies.keySet()));
                    }
                    artifacts = artifactResults.getArtifactsWithId(decoder.readSmallInt());
                    node.addModuleArtifacts(artifacts);
                    break;
                default:
                    throw new IOException("Unknown value type read from stream: " + type);
            }
        }
    } catch (IOException e) {
        throw new RuntimeException("Problems loading the resolved configuration. Read " + valuesRead + " values, last was: " + type, e);
    }
}

Example 29 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class ResolutionResultsStoreFactory method close.

@Override
public void close() {
    try {
        Timer clock = Time.startTimer();
        cleanUpLater.stop();
        LOG.debug("Deleted {} resolution results binary files in {}", stores.size(), clock.getElapsed());
    } finally {
        oldModelCache = null;
        newModelCache = null;
        stores.clear();
    }
}

Example 30 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class SkipEmptyWorkStep method skipExecutionWithEmptySources.

@Nonnull
private CachingResult skipExecutionWithEmptySources(UnitOfWork work, PreviousExecutionContext context) {
    ImmutableSortedMap<String, FileSystemSnapshot> outputFilesAfterPreviousExecution = context.getPreviousExecutionState().map(PreviousExecutionState::getOutputFilesProducedByWork).orElse(ImmutableSortedMap.of());
    ExecutionOutcome skipOutcome;
    Timer timer = Time.startTimer();
    if (outputFilesAfterPreviousExecution.isEmpty()) {
        LOGGER.info("Skipping {} as it has no source files and no previous output files.", work.getDisplayName());
        skipOutcome = ExecutionOutcome.SHORT_CIRCUITED;
    } else {
        boolean didWork = cleanPreviousTaskOutputs(outputFilesAfterPreviousExecution);
        if (didWork) {
            LOGGER.info("Cleaned previous output of {} as it has no source files.", work.getDisplayName());
            skipOutcome = ExecutionOutcome.EXECUTED_NON_INCREMENTALLY;
        } else {
            skipOutcome = ExecutionOutcome.SHORT_CIRCUITED;
        }
    }
    Duration duration = skipOutcome == ExecutionOutcome.SHORT_CIRCUITED ? Duration.ZERO : Duration.ofMillis(timer.getElapsedMillis());
    broadcastWorkInputs(work, true);
    return new CachingResult() {

        @Override
        public Duration getDuration() {
            return duration;
        }

        @Override
        public Try<ExecutionResult> getExecutionResult() {
            return Try.successful(new ExecutionResult() {

                @Override
                public ExecutionOutcome getOutcome() {
                    return skipOutcome;
                }

                @Override
                public Object getOutput() {
                    return work.loadRestoredOutput(context.getWorkspace());
                }
            });
        }

        @Override
        public CachingState getCachingState() {
            return CachingState.NOT_DETERMINED;
        }

        @Override
        public ImmutableList<String> getExecutionReasons() {
            return ImmutableList.of();
        }

        @Override
        public Optional<AfterExecutionState> getAfterExecutionState() {
            return Optional.empty();
        }

        @Override
        public Optional<OriginMetadata> getReusedOutputOriginMetadata() {
            return Optional.empty();
        }
    };
}