ru.tinkoff.plugins.buildmetrics.gradle.internal.utils.TasksData.kt Maven / Gradle / Ivy

Go to download
package ru.tinkoff.plugins.buildmetrics.gradle.internal.utils

import org.gradle.api.internal.tasks.TaskExecutionOutcome
import org.gradle.api.internal.tasks.execution.ExecuteTaskBuildOperationType
import ru.tinkoff.plugins.buildmetrics.api.builds.internal.BuildOperationData

/**
 * Tasks data.
 */
internal class TasksData(
    val runTasksCount: Int,
    val executedTasksCount: Int,
    val fromCacheTasksCount: Int,
    val upToDateTasksCount: Int,
    val skippedTasksCount: Int,
    val noSourceTasksCount: Int,
    val lifecycleTasksCount: Int,
    val requestedFromCacheTasksCount: Int,
    val upToDateTasksExecutionTimeSerialSum: Long,
    val upToDateTasksOriginExecutionTimeSerialSum: Long,
    val fromCacheTasksExecutionTimeSerialSum: Long,
    val fromCacheTasksOriginExecutionTimeSerialSum: Long,
) {

    internal class Builder {

        private var runTasksCount: Int = 0

        private var executedTasksCount: Int = 0

        private var fromCacheTasksCount: Int = 0

        private var upToDateTasksCount: Int = 0

        private var skippedTasksCount: Int = 0

        private var noSourceTasksCount: Int = 0

        private var lifecycleTasksCount: Int = 0

        /**
         * Tasks whose outputs were requested from cache.
         *
         * Task can request a cache if it meets the conditions:
         * - task is actionable (contains `doFirst`, `doLast` or `org.gradle.api.tasks.TaskAction`);
         * - task cache is not disabled (`cachingDisabledReasonCategory` is `null`)
         * - task executed
         *   (`skipMessage` equals `org.gradle.api.internal.tasks.TaskExecutionOutcome.EXECUTED.message`)
         *   **OR**
         *   task execution was skipped because the result was taken from the cache
         *   (`skipMessage` equals `org.gradle.api.internal.tasks.TaskExecutionOutcome.FROM_CACHE.message`)
         */
        private var requestedFromCacheTasksCount: Int = 0

        private var upToDateTasksExecutionTimeSerialSum: Long = 0L

        private var upToDateTasksOriginExecutionTimeSerialSum: Long = 0L

        private var fromCacheTasksExecutionTimeSerialSum: Long = 0L

        private var fromCacheTasksOriginExecutionTimeSerialSum: Long = 0L

        fun onBuildOperationData(data: BuildOperationData) {
            val result = data.result
            if (result is ExecuteTaskBuildOperationType.Result) {
                ++runTasksCount
                if (result.isActionable) {
                    when (result.skipMessage) {
                        TaskExecutionOutcome.EXECUTED.message -> ++executedTasksCount
                        TaskExecutionOutcome.FROM_CACHE.message -> ++fromCacheTasksCount
                        TaskExecutionOutcome.UP_TO_DATE.message -> ++upToDateTasksCount
                        TaskExecutionOutcome.SKIPPED.message -> ++skippedTasksCount
                        TaskExecutionOutcome.NO_SOURCE.message -> ++noSourceTasksCount
                    }
                    if (result.cachingDisabledReasonCategory == null &&
                        (TaskExecutionOutcome.EXECUTED.message == result.skipMessage ||
                                TaskExecutionOutcome.FROM_CACHE.message == result.skipMessage)
                    ) {
                        ++requestedFromCacheTasksCount
                    }
                } else {
                    ++lifecycleTasksCount
                }
                result.originExecutionTime?.let { originExecutionTime ->
                    when (result.skipMessage) {
                        TaskExecutionOutcome.FROM_CACHE.message -> {
                            fromCacheTasksExecutionTimeSerialSum += (data.endTime - data.startTime)
                            fromCacheTasksOriginExecutionTimeSerialSum += originExecutionTime
                        }
                        TaskExecutionOutcome.UP_TO_DATE.message -> {
                            upToDateTasksExecutionTimeSerialSum += (data.endTime - data.startTime)
                            upToDateTasksOriginExecutionTimeSerialSum += originExecutionTime
                        }
                    }
                }
            }
        }

        fun build(): TasksData = TasksData(
            runTasksCount = runTasksCount,
            executedTasksCount = executedTasksCount,
            fromCacheTasksCount = fromCacheTasksCount,
            upToDateTasksCount = upToDateTasksCount,
            skippedTasksCount = skippedTasksCount,
            noSourceTasksCount = noSourceTasksCount,
            lifecycleTasksCount = lifecycleTasksCount,
            requestedFromCacheTasksCount = requestedFromCacheTasksCount,
            upToDateTasksExecutionTimeSerialSum = upToDateTasksExecutionTimeSerialSum,
            upToDateTasksOriginExecutionTimeSerialSum = upToDateTasksOriginExecutionTimeSerialSum,
            fromCacheTasksExecutionTimeSerialSum = fromCacheTasksExecutionTimeSerialSum,
            fromCacheTasksOriginExecutionTimeSerialSum = fromCacheTasksOriginExecutionTimeSerialSum,
        )
    }
}