# "gsutil rsync -r" is recursive and makes directories work.
# "gsutil rsync -d" is "sync and delete files from destination if not present in source"

DOWNLOADS="$(mktemp -d)"
mkdir -p "$DOWNLOADS"
gsutil -m rsync -r "$TFCI_ARTIFACT_STAGING_GCS_URI" "$DOWNLOADS"
ls "$DOWNLOADS"

# Upload all build artifacts to e.g. gs://tensorflow/versions/2.16.0-rc1 (releases) or

            project(':child') {
                dependencies {
                    compile 'test:test:1.0'
                    compile 'test:test2:1.0'
                }
            }
"""
    }

    def "downloads only the metadata when dependency graph is queried"() {
        given:
        buildFile << """
            task graph {
                def root = configurations.compile.incoming.resolutionResult.rootComponent

					errStr = throughputHighestResults[i].Error
				}

				// if the default concurrency yields zero results, throw an error.
				if throughputHighestResults[i].Downloads == 0 && opts.concurrencyStart == concurrency {
					errStr = fmt.Sprintf("no results for downloads upon first attempt, concurrency %d and duration %s",
						opts.concurrencyStart, opts.duration)
				}

package org.gradle.distribution

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.*
import org.gradle.api.provider.*
import org.gradle.api.file.*

import groovy.transform.CompileStatic

/**
 * Downloads a given version of Gradle into a known location.
 */
@CompileStatic
class DownloadGradle extends DefaultTask {
    @Input
    final Property<String> gradleVersion = project.objects.property(String).value("5.4")

    @Override
    public void transferProgressed(TransferEvent event) {
        TransferResource resource = event.getResource();
        downloads.put(resource, event.getTransferredBytes());

        StringBuilder buffer = new StringBuilder(64);

        for (Map.Entry<TransferResource, Long> entry : downloads.entrySet()) {
            long total = entry.getKey().getContentLength();
            long complete = entry.getValue();

package main

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
)

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

// run repeatedly downloads a module while opening files in the module cache
// in a background goroutine.
//
// run uses a different temporary module cache in each iteration so that we

plugins {
    id 'base'
}

// This is defined in buildSrc
import org.gradle.distribution.DownloadGradle

version = '0.1'

tasks.register('downloadGradle', DownloadGradle) {
    description = 'Downloads the Gradle distribution with a given version.'
    gradleVersion = '4.6'
}

tasks.register('createCustomGradleDistribution', Zip) {
    description = 'Builds custom Gradle distribution and bundles initialization scripts.'

     */
    TEST_OUTPUT,

    /**
     * Flag for file download progress events. This includes various types of files, for example files downloaded during dependency resolution,
     * Gradle distribution downloads, and Java toolchain downloads.
     *
     * <p>
     * The following events are currently issued for this operation type.
     * <ul>
     *     <li>{@link org.gradle.tooling.events.download.FileDownloadStartEvent}</li>

            jdk3.absolutePath
        ])
        directories*.source == ["Auto-provisioned by Gradle", "Auto-provisioned by Gradle", "Auto-provisioned by Gradle"]
    }

    def "automatically enabled if downloads are enabled"() {
        def jdk = temporaryFolder.createDir("11.0.6.hs-adpt")

        given:
        def cacheDir = newCacheDirProvider([jdk] as Set)
        def providerFactory = Mock(ProviderFactory)

tensorflow/contrib/cmake/_build/
.idea/**
/build/
[Bb]uild/
/build_output/
/tensorflow/core/util/version_info.cc
/tensorflow/python/framework/fast_tensor_util.cpp
/tensorflow/lite/gen/**
/tensorflow/lite/tools/make/downloads/**
/tensorflow/lite/tools/make/gen/**
/api_init_files_list.txt
/estimator_api_init_files_list.txt
*.whl

# Android
.gradle
.idea
*.iml
local.properties
gradleBuild

# iOS
*.pbxproj