Fix deps

api/runner/drivers/docker/docker.go

@@ -2,46 +2,20 @@ package docker
 
 import (
 	"context"
-	"crypto/tls"
 	"fmt"
 	"io"
-	"net"
-	"net/http"
-	"net/url"
 	"os"
 	"path"
 	"strings"
 	"time"
 
 	"github.com/Sirupsen/logrus"
-	manifest "github.com/docker/distribution/manifest/schema1"
 	"github.com/fnproject/fn/api/runner/common"
 	"github.com/fnproject/fn/api/runner/drivers"
 	"github.com/fsouza/go-dockerclient"
-	"github.com/heroku/docker-registry-client/registry"
 	"github.com/opentracing/opentracing-go"
 )
 
-const hubURL = "https://registry.hub.docker.com"
-
-var registryClient = &http.Client{
-	Transport: &http.Transport{
-		Dial: (&net.Dialer{
-			Timeout:   10 * time.Second,
-			KeepAlive: 2 * time.Minute,
-		}).Dial,
-		TLSClientConfig: &tls.Config{
-			ClientSessionCache: tls.NewLRUClientSessionCache(8192),
-		},
-		TLSHandshakeTimeout:   10 * time.Second,
-		MaxIdleConnsPerHost:   32, // TODO tune; we will likely be making lots of requests to same place
-		Proxy:                 http.ProxyFromEnvironment,
-		IdleConnTimeout:       90 * time.Second,
-		MaxIdleConns:          512,
-		ExpectContinueTimeout: 1 * time.Second,
-	},
-}
-
 // A drivers.ContainerTask should implement the Auther interface if it would
 // like to use not-necessarily-public docker images for any or all task
 // invocations.
@@ -97,122 +71,6 @@ func NewDocker(env *common.Environment, conf drivers.Config) *DockerDriver {
 	}
 }
 
-// CheckRegistry will return a sizer, which can be used to check the size of an
-// image if the returned error is nil. If the error returned is nil, then
-// authentication against the given credentials was successful, if the
-// configuration does not specify a config.ServerAddress,
-// https://hub.docker.com will be tried.  CheckRegistry is a package level
-// method since rkt can also use docker images, we may be interested in using
-// rkt w/o a docker driver configured; also, we don't have to tote around a
-// driver in any tasker that may be interested in registry information (2/2
-// cases thus far).
-func CheckRegistry(ctx context.Context, image string, config docker.AuthConfiguration) (Sizer, error) {
-	ctx, log := common.LoggerWithFields(ctx, logrus.Fields{"stack": "CheckRegistry"})
-	registry, repo, tag := drivers.ParseImage(image)
-
-	reg, err := registryForConfig(ctx, config, registry)
-	if err != nil {
-		return nil, err
-	}
-
-	mani, err := reg.Manifest(repo, tag)
-	if err != nil {
-		log.WithFields(logrus.Fields{"username": config.Username, "server": config.ServerAddress, "image": image}).WithError(err).Error("Credentials not authorized, trying next.")
-		//if !isAuthError(err) {
-		//  // TODO we might retry this, since if this was the registry that was supposed to
-		//  // auth the task will erroneously be set to 'error'
-		//}
-
-		return nil, err
-	}
-
-	return &sizer{mani, reg, repo}, nil
-}
-
-// Sizer returns size information. This interface is liable to contain more
-// than a size at some point, change as needed.
-type Sizer interface {
-	Size() (int64, error)
-}
-
-type sizer struct {
-	mani *manifest.SignedManifest
-	reg  *registry.Registry
-	repo string
-}
-
-func (s *sizer) Size() (int64, error) {
-	var sum int64
-	for _, r := range s.mani.References() {
-		desc, err := s.reg.LayerMetadata(s.repo, r.Digest)
-		if err != nil {
-			return 0, err
-		}
-		sum += desc.Size
-	}
-	return sum, nil
-}
-
-func registryURL(ctx context.Context, addr string) (string, error) {
-	log := common.Logger(ctx)
-	if addr == "" || strings.Contains(addr, "hub.docker.com") || strings.Contains(addr, "index.docker.io") {
-		return hubURL, nil
-	}
-
-	url, err := url.Parse(addr)
-	if err != nil {
-		// TODO we could error the task out from this with a user error but since
-		// we have a list of auths to check, just return the error so as to be
-		// skipped... horrible api as it is
-		log.WithFields(logrus.Fields{"auth_addr": addr}).WithError(err).Error("error parsing server address url, skipping")
-		return "", err
-	}
-
-	if url.Scheme == "" {
-		url.Scheme = "https"
-	}
-	url.Path = strings.TrimSuffix(url.Path, "/")
-	url.Path = strings.TrimPrefix(url.Path, "/v2")
-	url.Path = strings.TrimPrefix(url.Path, "/v1") // just try this, if it fails it fails, not supporting v1
-	return url.String(), nil
-}
-
-func isAuthError(err error) bool {
-	// AARGH!
-	if urlError, ok := err.(*url.Error); ok {
-		if httpError, ok := urlError.Err.(*registry.HttpStatusError); ok {
-			if httpError.Response.StatusCode == 401 {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func registryForConfig(ctx context.Context, config docker.AuthConfiguration, reg string) (*registry.Registry, error) {
-	if reg == "" {
-		reg = config.ServerAddress
-	}
-
-	var err error
-	config.ServerAddress, err = registryURL(ctx, reg)
-	if err != nil {
-		return nil, err
-	}
-
-	// Use this instead of registry.New to avoid the Ping().
-	transport := registry.WrapTransport(registryClient.Transport, reg, config.Username, config.Password)
-	r := &registry.Registry{
-		URL: config.ServerAddress,
-		Client: &http.Client{
-			Transport: transport,
-		},
-		Logf: registry.Quiet,
-	}
-	return r, nil
-}
-
 func (drv *DockerDriver) Prepare(ctx context.Context, task drivers.ContainerTask) (drivers.Cookie, error) {
 	ctx, log := common.LoggerWithFields(ctx, logrus.Fields{"stack": "Prepare"})
 	var cmd []string
@@ -348,7 +206,7 @@ func (drv *DockerDriver) pullImage(ctx context.Context, task drivers.ContainerTa
 	}
 
 	var err error
-	config.ServerAddress, err = registryURL(ctx, config.ServerAddress)
+	config.ServerAddress, err = registryURL(config.ServerAddress)
 	if err != nil {
 		return err
 	}

api/runner/drivers/docker/docker_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/fnproject/fn/api/runner/common"
 	"github.com/fnproject/fn/api/runner/drivers"
+	"github.com/fsouza/go-dockerclient"
 )
 
 type taskDockerTest struct {
@@ -89,3 +90,21 @@ func TestRunnerDockerStdin(t *testing.T) {
 		t.Errorf("Test expected output to contain '%s', got '%s'", expect, got)
 	}
 }
+
+func TestRegistry(t *testing.T) {
+	image := "funcy/hello"
+
+	sizer, err := CheckRegistry(context.Background(), image, docker.AuthConfiguration{})
+	if err != nil {
+		t.Fatal("expected registry check not to fail, got:", err)
+	}
+
+	size, err := sizer.Size()
+	if err != nil {
+		t.Fatal("expected sizer not to fail, got:", err)
+	}
+
+	if size <= 0 {
+		t.Fatalf("expected positive size for image that exists, got size:", size)
+	}
+}