Merge pull request #12238 from eparis/godeps

Godeps/Godeps.json

@@ -15,26 +15,6 @@
 			"Rev": "c2d3050044d05357eaf6c3547249ba57c5e235cb"
 		},
 		{
-			"ImportPath": "code.google.com/p/go-uuid/uuid",
-			"Comment": "null-12",
-			"Rev": "7dda39b2e7d5e265014674c5af696ba4186679e9"
-		},
-		{
-			"ImportPath": "code.google.com/p/google-api-go-client/compute/v1",
-			"Comment": "release-105",
-			"Rev": "98c78185197025f935947caac56a7b6d022f89d2"
-		},
-		{
-			"ImportPath": "code.google.com/p/google-api-go-client/container/v1beta1",
-			"Comment": "release-105",
-			"Rev": "98c78185197025f935947caac56a7b6d022f89d2"
-		},
-		{
-			"ImportPath": "code.google.com/p/google-api-go-client/googleapi",
-			"Comment": "release-105",
-			"Rev": "98c78185197025f935947caac56a7b6d022f89d2"
-		},
-		{
 			"ImportPath": "github.com/GoogleCloudPlatform/gcloud-golang/compute/metadata",
 			"Rev": "e34a32f9b0ecbc0784865fb2d47f3818c09521d4"
 		},
@@ -390,35 +370,35 @@
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/auth",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/detector",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/executor",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/mesosproto",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/mesosutil",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/messenger",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/scheduler",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/mesos/mesos-go/upid",
-			"Rev": "6440c09c9d8a1b365f3c3e9b2297dd856abd017c"
+			"Rev": "65cb9ffec50a76f4ed9fe4808405b66b3bb7010d"
 		},
 		{
 			"ImportPath": "github.com/miekg/dns",
@@ -443,6 +423,10 @@
 			"Rev": "8adf9e1730c55cdc590de7d49766cb2acc88d8f2"
 		},
 		{
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+		},
+		{
 			"ImportPath": "github.com/prometheus/client_golang/extraction",
 			"Comment": "0.4.0-1-g692492e",
 			"Rev": "692492e54b553a81013254cc1fba4b6dd76fad30"
@@ -564,6 +548,18 @@
 			"Rev": "b5adcc2dcdf009d0391547edc6ecbaff889f5bb9"
 		},
 		{
+			"ImportPath": "google.golang.org/api/compute/v1",
+			"Rev": "0c2979aeaa5b573e60d3ddffe5ce8dca8df309bd"
+		},
+		{
+			"ImportPath": "google.golang.org/api/container/v1beta1",
+			"Rev": "0c2979aeaa5b573e60d3ddffe5ce8dca8df309bd"
+		},
+		{
+			"ImportPath": "google.golang.org/api/googleapi",
+			"Rev": "0c2979aeaa5b573e60d3ddffe5ce8dca8df309bd"
+		},
+		{
 			"ImportPath": "google.golang.org/cloud/compute/metadata",
 			"Rev": "2e43671e4ad874a7bca65746ff3edb38e6e93762"
 		},

Godeps/_workspace/src/github.com/mesos/mesos-go/detector/zoo/client.go

@@ -270,9 +270,6 @@ func (zkc *Client) monitorSession(sessionEvents <-chan zk.Event, connected chan
 				default: // message buf full, this becomes a non-blocking noop
 				}
 
-			case zk.StateSyncConnected:
-				log.Infoln("syncConnected to zookper server")
-
 			case zk.StateDisconnected:
 				log.Infoln("zookeeper client disconnected")
 

Godeps/_workspace/src/github.com/mesos/mesos-go/executor/executor.go

@@ -25,7 +25,6 @@ import (
 	"sync"
 	"time"
 
-	"code.google.com/p/go-uuid/uuid"
 	"github.com/gogo/protobuf/proto"
 	log "github.com/golang/glog"
 	"github.com/mesos/mesos-go/mesosproto"
@@ -33,6 +32,7 @@ import (
 	"github.com/mesos/mesos-go/mesosutil/process"
 	"github.com/mesos/mesos-go/messenger"
 	"github.com/mesos/mesos-go/upid"
+	"github.com/pborman/uuid"
 	"golang.org/x/net/context"
 )
 

Godeps/_workspace/src/github.com/mesos/mesos-go/executor/executor_intgr_test.go

@@ -28,12 +28,12 @@ import (
 	"testing"
 	"time"
 
-	"code.google.com/p/go-uuid/uuid"
 	"github.com/gogo/protobuf/proto"
 	log "github.com/golang/glog"
 	mesos "github.com/mesos/mesos-go/mesosproto"
 	util "github.com/mesos/mesos-go/mesosutil"
 	"github.com/mesos/mesos-go/testutil"
+	"github.com/pborman/uuid"
 	"github.com/stretchr/testify/assert"
 )
 

Godeps/_workspace/src/github.com/mesos/mesos-go/scheduler/scheduler.go

@@ -28,7 +28,6 @@ import (
 	"sync"
 	"time"
 
-	"code.google.com/p/go-uuid/uuid"
 	"github.com/gogo/protobuf/proto"
 	log "github.com/golang/glog"
 	"github.com/mesos/mesos-go/auth"
@@ -38,6 +37,7 @@ import (
 	"github.com/mesos/mesos-go/mesosutil/process"
 	"github.com/mesos/mesos-go/messenger"
 	"github.com/mesos/mesos-go/upid"
+	"github.com/pborman/uuid"
 	"golang.org/x/net/context"
 )
 

Godeps/_workspace/src/github.com/pborman/uuid/CONTRIBUTORS

+Paul Borman <borman@google.com>

Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/LICENSE → Godeps/_workspace/src/github.com/pborman/uuid/LICENSE

-Copyright (c) 2009 Google Inc. All rights reserved.
+Copyright (c) 2009,2014 Google Inc. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are

Godeps/_workspace/src/github.com/pborman/uuid/json.go

+// Copyright 2014 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "errors"
+
+func (u UUID) MarshalJSON() ([]byte, error) {
+	if len(u) == 0 {
+		return []byte(`""`), nil
+	}
+	return []byte(`"` + u.String() + `"`), nil
+}
+
+func (u *UUID) UnmarshalJSON(data []byte) error {
+	if len(data) == 0 || string(data) == `""` {
+		return nil
+	}
+	if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' {
+		return errors.New("invalid UUID format")
+	}
+	data = data[1 : len(data)-1]
+	uu := Parse(string(data))
+	if uu == nil {
+		return errors.New("invalid UUID format")
+	}
+	*u = uu
+	return nil
+}

Godeps/_workspace/src/github.com/pborman/uuid/json_test.go

+// Copyright 2014 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+var testUUID = Parse("f47ac10b-58cc-0372-8567-0e02b2c3d479")
+
+func TestJSON(t *testing.T) {
+	type S struct {
+		ID1 UUID
+		ID2 UUID
+	}
+	s1 := S{ID1: testUUID}
+	data, err := json.Marshal(&s1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var s2 S
+	if err := json.Unmarshal(data, &s2); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(&s1, &s2) {
+		t.Errorf("got %#v, want %#v", s2, s1)
+	}
+}

Godeps/_workspace/src/github.com/pborman/uuid/seq_test.go

+// Copyright 2014 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"flag"
+	"runtime"
+	"testing"
+	"time"
+)
+
+// This test is only run when --regressions is passed on the go test line.
+var regressions = flag.Bool("regressions", false, "run uuid regression tests")
+
+// TestClockSeqRace tests for a particular race condition of returning two
+// identical Version1 UUIDs.  The duration of 1 minute was chosen as the race
+// condition, before being fixed, nearly always occured in under 30 seconds.
+func TestClockSeqRace(t *testing.T) {
+	if !*regressions {
+		t.Skip("skipping regression tests")
+	}
+	duration := time.Minute
+
+	done := make(chan struct{})
+	defer close(done)
+
+	ch := make(chan UUID, 10000)
+	ncpu := runtime.NumCPU()
+	switch ncpu {
+	case 0, 1:
+		// We can't run the test effectively.
+		t.Skip("skipping race test, only one CPU detected")
+		return
+	default:
+		runtime.GOMAXPROCS(ncpu)
+	}
+	for i := 0; i < ncpu; i++ {
+		go func() {
+			for {
+				select {
+				case <-done:
+					return
+				case ch <- NewUUID():
+				}
+			}
+		}()
+	}
+
+	uuids := make(map[string]bool)
+	cnt := 0
+	start := time.Now()
+	for u := range ch {
+		s := u.String()
+		if uuids[s] {
+			t.Errorf("duplicate uuid after %d in %v: %s", cnt, time.Since(start), s)
+			return
+		}
+		uuids[s] = true
+		if time.Since(start) > duration {
+			return
+		}
+		cnt++
+	}
+}

Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/time.go → Godeps/_workspace/src/github.com/pborman/uuid/time.go

@@ -40,15 +40,15 @@ func (t Time) UnixTime() (sec, nsec int64) {
 }
 
 // GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
-// adjusts the clock sequence as needed.  An error is returned if the current
-// time cannot be determined.
-func GetTime() (Time, error) {
+// clock sequence as well as adjusting the clock sequence as needed.  An error
+// is returned if the current time cannot be determined.
+func GetTime() (Time, uint16, error) {
 	defer mu.Unlock()
 	mu.Lock()
 	return getTime()
 }
 
-func getTime() (Time, error) {
+func getTime() (Time, uint16, error) {
 	t := timeNow()
 
 	// If we don't have a clock sequence already, set one.
@@ -63,7 +63,7 @@ func getTime() (Time, error) {
 		clock_seq = ((clock_seq + 1) & 0x3fff) | 0x8000
 	}
 	lasttime = now
-	return Time(now), nil
+	return Time(now), clock_seq, nil
 }
 
 // ClockSequence returns the current clock sequence, generating one if not

Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/version1.go → Godeps/_workspace/src/github.com/pborman/uuid/version1.go

@@ -19,7 +19,7 @@ func NewUUID() UUID {
 		SetNodeInterface("")
 	}
 
-	now, err := GetTime()
+	now, seq, err := GetTime()
 	if err != nil {
 		return nil
 	}
@@ -34,7 +34,7 @@ func NewUUID() UUID {
 	binary.BigEndian.PutUint32(uuid[0:], time_low)
 	binary.BigEndian.PutUint16(uuid[4:], time_mid)
 	binary.BigEndian.PutUint16(uuid[6:], time_hi)
-	binary.BigEndian.PutUint16(uuid[8:], clock_seq)
+	binary.BigEndian.PutUint16(uuid[8:], seq)
 	copy(uuid[10:], nodeID)
 
 	return uuid

Godeps/_workspace/src/code.google.com/p/google-api-go-client/googleapi/googleapi_test.go → Godeps/_workspace/src/google.golang.org/api/googleapi/googleapi_test.go

@@ -11,9 +11,15 @@ import (
 	"io/ioutil"
 	"net/http"
 	"net/url"
+	"os"
 	"reflect"
+	"regexp"
+	"strconv"
 	"strings"
 	"testing"
+	"time"
+
+	"golang.org/x/net/context"
 )
 
 type SetOpaqueTest struct {
@@ -359,3 +365,234 @@ func TestConvertVariant(t *testing.T) {
 		}
 	}
 }
+
+type unexpectedReader struct{}
+
+func (unexpectedReader) Read([]byte) (int, error) {
+	return 0, fmt.Errorf("unexpected read in test.")
+}
+
+var contentRangeRE = regexp.MustCompile(`^bytes (\d+)\-(\d+)/(\d+)$`)
+
+func (t *testTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	t.req = req
+	if rng := req.Header.Get("Content-Range"); rng != "" && !strings.HasPrefix(rng, "bytes */") { // Read the data
+		m := contentRangeRE.FindStringSubmatch(rng)
+		if len(m) != 4 {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		start, err := strconv.ParseInt(m[1], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		end, err := strconv.ParseInt(m[2], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		totalSize, err := strconv.ParseInt(m[3], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		partialSize := end - start + 1
+		t.buf, err = ioutil.ReadAll(req.Body)
+		if err != nil || int64(len(t.buf)) != partialSize {
+			return nil, fmt.Errorf("unable to read %v bytes from request data, n=%v: %v", partialSize, len(t.buf), err)
+		}
+		if totalSize == end+1 {
+			t.statusCode = 200 // signify completion of transfer
+		}
+	}
+	f := ioutil.NopCloser(unexpectedReader{})
+	res := &http.Response{
+		Body:       f,
+		StatusCode: t.statusCode,
+		Header:     http.Header{},
+	}
+	if t.rangeVal != "" {
+		res.Header.Set("Range", t.rangeVal)
+	}
+	return res, nil
+}
+
+type testTransport struct {
+	req        *http.Request
+	statusCode int
+	rangeVal   string
+	want       int64
+	buf        []byte
+}
+
+var statusTests = []*testTransport{
+	&testTransport{statusCode: 308, want: 0},
+	&testTransport{statusCode: 308, rangeVal: "bytes=0-0", want: 1},
+	&testTransport{statusCode: 308, rangeVal: "bytes=0-42", want: 43},
+}
+
+func TestTransferStatus(t *testing.T) {
+	for _, tr := range statusTests {
+		rx := &ResumableUpload{
+			Client: &http.Client{Transport: tr},
+		}
+		g, _, err := rx.transferStatus()
+		if err != nil {
+			t.Error(err)
+		}
+		if g != tr.want {
+			t.Errorf("transferStatus got %v, want %v", g, tr.want)
+		}
+	}
+}
+
+func (t *interruptedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	t.req = req
+	if rng := req.Header.Get("Content-Range"); rng != "" && !strings.HasPrefix(rng, "bytes */") {
+		t.interruptCount += 1
+		if t.interruptCount%7 == 0 { // Respond with a "service unavailable" error
+			res := &http.Response{
+				StatusCode: http.StatusServiceUnavailable,
+				Header:     http.Header{},
+			}
+			t.rangeVal = fmt.Sprintf("bytes=0-%v", len(t.buf)-1) // Set the response for next time
+			return res, nil
+		}
+		m := contentRangeRE.FindStringSubmatch(rng)
+		if len(m) != 4 {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		start, err := strconv.ParseInt(m[1], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		end, err := strconv.ParseInt(m[2], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		totalSize, err := strconv.ParseInt(m[3], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse content range: %v", rng)
+		}
+		partialSize := end - start + 1
+		buf, err := ioutil.ReadAll(req.Body)
+		if err != nil || int64(len(buf)) != partialSize {
+			return nil, fmt.Errorf("unable to read %v bytes from request data, n=%v: %v", partialSize, len(buf), err)
+		}
+		t.buf = append(t.buf, buf...)
+		if totalSize == end+1 {
+			t.statusCode = 200 // signify completion of transfer
+		}
+	}
+	f := ioutil.NopCloser(unexpectedReader{})
+	res := &http.Response{
+		Body:       f,
+		StatusCode: t.statusCode,
+		Header:     http.Header{},
+	}
+	if t.rangeVal != "" {
+		res.Header.Set("Range", t.rangeVal)
+	}
+	return res, nil
+}
+
+type interruptedTransport struct {
+	req            *http.Request
+	statusCode     int
+	rangeVal       string
+	interruptCount int
+	buf            []byte
+	progressBuf    string
+}
+
+func (tr *interruptedTransport) ProgressUpdate(current, total int64) {
+	tr.progressBuf += fmt.Sprintf("%v, %v\n", current, total)
+}
+
+func TestInterruptedTransferChunks(t *testing.T) {
+	f, err := os.Open("googleapi.go")
+	if err != nil {
+		t.Fatalf("unable to open googleapi.go: %v", err)
+	}
+	defer f.Close()
+	slurp, err := ioutil.ReadAll(f)
+	if err != nil {
+		t.Fatalf("unable to slurp file: %v", err)
+	}
+	st, err := f.Stat()
+	if err != nil {
+		t.Fatalf("unable to stat googleapi.go: %v", err)
+	}
+	tr := &interruptedTransport{
+		statusCode: 308,
+		buf:        make([]byte, 0, st.Size()),
+	}
+	oldChunkSize := chunkSize
+	defer func() { chunkSize = oldChunkSize }()
+	chunkSize = 100 // override to process small chunks for test.
+
+	sleep = func(time.Duration) {} // override time.Sleep
+	rx := &ResumableUpload{
+		Client:        &http.Client{Transport: tr},
+		Media:         f,
+		MediaType:     "text/plain",
+		ContentLength: st.Size(),
+		Callback:      tr.ProgressUpdate,
+	}
+	res, err := rx.Upload(context.Background())
+	if err != nil || res == nil || res.StatusCode != http.StatusOK {
+		if res == nil {
+			t.Errorf("transferChunks not successful, res=nil: %v", err)
+		} else {
+			t.Errorf("transferChunks not successful, statusCode=%v: %v", res.StatusCode, err)
+		}
+	}
+	if len(tr.buf) != len(slurp) || bytes.Compare(tr.buf, slurp) != 0 {
+		t.Errorf("transfered file corrupted:\ngot %s\nwant %s", tr.buf, slurp)
+	}
+	w := ""
+	for i := chunkSize; i <= st.Size(); i += chunkSize {
+		w += fmt.Sprintf("%v, %v\n", i, st.Size())
+	}
+	if st.Size()%chunkSize != 0 {
+		w += fmt.Sprintf("%v, %v\n", st.Size(), st.Size())
+	}
+	if tr.progressBuf != w {
+		t.Errorf("progress update error, got %v, want %v", tr.progressBuf, w)
+	}
+}
+
+func TestCancelUpload(t *testing.T) {
+	f, err := os.Open("googleapi.go")
+	if err != nil {
+		t.Fatalf("unable to open googleapi.go: %v", err)
+	}
+	defer f.Close()
+	st, err := f.Stat()
+	if err != nil {
+		t.Fatalf("unable to stat googleapi.go: %v", err)
+	}
+	tr := &interruptedTransport{
+		statusCode: 308,
+		buf:        make([]byte, 0, st.Size()),
+	}
+	oldChunkSize := chunkSize
+	defer func() { chunkSize = oldChunkSize }()
+	chunkSize = 100 // override to process small chunks for test.
+
+	sleep = func(time.Duration) {} // override time.Sleep
+	rx := &ResumableUpload{
+		Client:        &http.Client{Transport: tr},
+		Media:         f,
+		MediaType:     "text/plain",
+		ContentLength: st.Size(),
+		Callback:      tr.ProgressUpdate,
+	}
+	ctx, cancelFunc := context.WithCancel(context.Background())
+	cancelFunc() // stop the upload that hasn't started yet
+	res, err := rx.Upload(ctx)
+	if err == nil || res == nil || res.StatusCode != http.StatusRequestTimeout {
+		if res == nil {
+			t.Errorf("transferChunks not successful, got res=nil, err=%v, want StatusRequestTimeout", err)
+		} else {
+			t.Errorf("transferChunks not successful, got statusCode=%v, err=%v, want StatusRequestTimeout", res.StatusCode, err)
+		}
+	}
+}

contrib/mesos/pkg/scheduler/podtask/pod_task.go

@@ -21,13 +21,13 @@ import (
 	"strings"
 	"time"
 
-	"code.google.com/p/go-uuid/uuid"
 	"github.com/GoogleCloudPlatform/kubernetes/contrib/mesos/pkg/offers"
 	annotation "github.com/GoogleCloudPlatform/kubernetes/contrib/mesos/pkg/scheduler/meta"
 	"github.com/GoogleCloudPlatform/kubernetes/contrib/mesos/pkg/scheduler/metrics"
 	mresource "github.com/GoogleCloudPlatform/kubernetes/contrib/mesos/pkg/scheduler/resource"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/gogo/protobuf/proto"
+	"github.com/pborman/uuid"
 
 	log "github.com/golang/glog"
 	mesos "github.com/mesos/mesos-go/mesosproto"

contrib/mesos/pkg/scheduler/uid/uid.go

@@ -21,8 +21,8 @@ import (
 	"strconv"
 	"strings"
 
-	"code.google.com/p/go-uuid/uuid"
 	log "github.com/golang/glog"
+	"github.com/pborman/uuid"
 )
 
 type UID struct {

pkg/cloudprovider/gce/gce.go

@@ -34,12 +34,12 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/wait"
 
 	"code.google.com/p/gcfg"
-	compute "code.google.com/p/google-api-go-client/compute/v1"
-	container "code.google.com/p/google-api-go-client/container/v1beta1"
-	"code.google.com/p/google-api-go-client/googleapi"
 	"github.com/golang/glog"
 	"golang.org/x/oauth2"
 	"golang.org/x/oauth2/google"
+	compute "google.golang.org/api/compute/v1"
+	container "google.golang.org/api/container/v1beta1"
+	"google.golang.org/api/googleapi"
 	"google.golang.org/cloud/compute/metadata"
 )
 

pkg/cloudprovider/gce/token_source.go

@@ -23,10 +23,10 @@ import (
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 
-	"code.google.com/p/google-api-go-client/googleapi"
 	"github.com/prometheus/client_golang/prometheus"
 	"golang.org/x/oauth2"
 	"golang.org/x/oauth2/google"
+	"google.golang.org/api/googleapi"
 )
 
 const (

pkg/util/uuid.go

@@ -20,8 +20,8 @@ import (
 	"sync"
 	"time"
 
-	"code.google.com/p/go-uuid/uuid"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/types"
+	"github.com/pborman/uuid"
 )
 
 var uuidLock sync.Mutex