{
      "source": {
        "git": {
          "remote": "https://github.com/grafana/grafonnet.git",
          "subdir": "gen/grafonnet-latest"
        }
      },
      "version": "18eb4e529c60ec20ab243e2da3bcb52b2fd0d223",
      "sum": "eyuJ0jOXeA4MrobbNgU4/v5a7ASDHslHZ0eS6hDdWoI="
    },
    {
      "source": {
        "git": {
          "remote": "https://github.com/grafana/grafonnet.git",

import (
	"fmt"
	"strings"

	"github.com/google/go-containerregistry/pkg/authn"
	"github.com/google/go-containerregistry/pkg/name"
	"github.com/google/go-containerregistry/pkg/v1/remote"
	"github.com/google/go-containerregistry/pkg/v1/remote/transport"
)

// Exists returns true if the image in the argument exists in a container registry.
// The argument must be a complete image name, e.g. "gcr.io/istio-release/pilot:1.20.0".

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.remote.internal;

import org.gradle.internal.remote.Address;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface OutgoingConnector {
    /**

    private final BuildCacheService remote;
    private final boolean remotePush;

    public BuildCacheServicesConfiguration(
        String buildPath,
        @Nullable LocalBuildCacheService local,
        boolean localPush,
        @Nullable BuildCacheService remote,
        boolean remotePush
    ) {
        this.buildPath = buildPath;
        this.remote = remote;
        this.remotePush = remotePush;

#!/bin/bash

sudo sysctl net.ipv6.conf.all.disable_ipv6=0

remote=$(git remote get-url upstream)
if test "$remote" != "******@****.***:minio/minio.git"; then
	echo "Script requires that the 'upstream' remote is set to ******@****.***:minio/minio.git"
	exit 1
fi

git remote update upstream && git checkout master && git rebase upstream/master

release=$(git describe --abbrev=0 --tags)

docker buildx build --push --no-cache \

            }
        }
    }
}

fun ProjectSettings.configureRunConfigurations() {
    runConfigurations {
        create<Remote>("Remote debug port 5005") {
            mode = Remote.RemoteMode.ATTACH
            transport = Remote.RemoteTransport.SOCKET
            sharedMemoryAddress = "javadebug"
            host = "localhost"
            port = 5005
        }
    }
}

}

// Remove is a fake call that returns nil.
func (f *FakeOS) Remove(path string) error {
	f.Removes = append(f.Removes, path)
	return nil
}

// RemoveAll is a fake call that just returns nil.
func (f *FakeOS) RemoveAll(path string) error {
	f.Removes = append(f.Removes, path)
	return nil
}

// Create is a fake call that creates a virtual file and returns nil.

	})
	ti.setupCmds = append(ti.setupCmds, &exec.Cmd{
		Path: xname,
		Args: []string{"ip", "address", "add", ti.local, "peer", ti.remote, "dev", ti.name},
	})
	ti.teardownCmds = append(ti.teardownCmds, &exec.Cmd{
		Path: xname,
		Args: []string{"ip", "address", "del", ti.local, "peer", ti.remote, "dev", ti.name},
	})

                remote(CustomBuildCache)
                remote(AnotherBuildCache)
            }

            gradle.rootProject {
                tasks.register('verifyBuildCache') {
                    doLast {
                        def buildCache = services.get(BuildCacheConfiguration)
                        assert buildCache.remote instanceof AnotherBuildCache

    ) {
        boolean localPush = local != null && local.config.isPush();
        boolean remotePush = remote != null && remote.config.isPush();
        return new BuildCacheServicesConfiguration(
            buildPath.getPath(),
            local != null ? local.service : null, localPush,
            remote != null ? remote.service : null, remotePush);
    }