diff --git a/vendor/github.com/segmentio/backo-go b/vendor/github.com/segmentio/backo-go
deleted file mode 160000
index ed3adc5..0000000
--- a/vendor/github.com/segmentio/backo-go
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ed3adc599ae5cd72e97bd085ff1835c9d3276594
diff --git a/vendor/github.com/segmentio/backo-go/.gitmodules b/vendor/github.com/segmentio/backo-go/.gitmodules
new file mode 100644
index 0000000..36de929
--- /dev/null
+++ b/vendor/github.com/segmentio/backo-go/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "vendor/github.com/bmizerany/assert"]
+	path = vendor/github.com/bmizerany/assert
+	url = https://github.com/bmizerany/assert
diff --git a/vendor/github.com/segmentio/backo-go/README.md b/vendor/github.com/segmentio/backo-go/README.md
new file mode 100644
index 0000000..1362bec
--- /dev/null
+++ b/vendor/github.com/segmentio/backo-go/README.md
@@ -0,0 +1,80 @@
+Backo [![GoDoc](http://godoc.org/github.com/segmentio/backo-go?status.png)](http://godoc.org/github.com/segmentio/backo-go)
+-----
+
+Exponential backoff for Go (Go port of segmentio/backo).
+
+
+Usage
+-----
+
+```go
+import "github.com/segmentio/backo-go"
+
+// Create a Backo instance.
+backo := backo.NewBacko(milliseconds(100), 2, 1, milliseconds(10*1000))
+// OR with defaults.
+backo := backo.DefaultBacko()
+
+// Use the ticker API.
+ticker := b.NewTicker()
+for {
+    timeout := time.After(5 * time.Minute)
+    select {
+    case  <-ticker.C:
+        fmt.Println("ticked")
+    case <- timeout:
+        fmt.Println("timed out")
+    }
+}
+
+// Or simply work with backoff intervals directly.
+for i := 0; i < n; i++ {
+    // Sleep the current goroutine.
+    backo.Sleep(i)
+    // Retrieve the duration manually.
+    duration := backo.Duration(i)
+}
+```
+
+License
+-------
+
+```
+WWWWWW||WWWWWW
+ W W W||W W W
+      ||
+    ( OO )__________
+     /  |           \
+    /o o|    MIT     \
+    \___/||_||__||_|| *
+         || ||  || ||
+        _||_|| _||_||
+       (__|__|(__|__|
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Segment, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+
+
+ [1]: http://github.com/segmentio/backo-java
+ [2]: http://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=com.segment.backo&a=backo&v=LATEST
\ No newline at end of file
diff --git a/vendor/github.com/segmentio/backo-go/backo.go b/vendor/github.com/segmentio/backo-go/backo.go
new file mode 100644
index 0000000..6f7b6d5
--- /dev/null
+++ b/vendor/github.com/segmentio/backo-go/backo.go
@@ -0,0 +1,83 @@
+package backo
+
+import (
+	"math"
+	"math/rand"
+	"time"
+)
+
+type Backo struct {
+	base   time.Duration
+	factor uint8
+	jitter float64
+	cap    time.Duration
+}
+
+// Creates a backo instance with the given parameters
+func NewBacko(base time.Duration, factor uint8, jitter float64, cap time.Duration) *Backo {
+	return &Backo{base, factor, jitter, cap}
+}
+
+// Creates a backo instance with the following defaults:
+//   base: 100 milliseconds
+//   factor: 2
+//   jitter: 0
+//   cap: 10 seconds
+func DefaultBacko() *Backo {
+	return NewBacko(time.Millisecond*100, 2, 0, time.Second*10)
+}
+
+// Duration returns the backoff interval for the given attempt.
+func (backo *Backo) Duration(attempt int) time.Duration {
+	duration := float64(backo.base) * math.Pow(float64(backo.factor), float64(attempt))
+
+	if backo.jitter != 0 {
+		random := rand.Float64()
+		deviation := math.Floor(random * backo.jitter * duration)
+		if (int(math.Floor(random*10)) & 1) == 0 {
+			duration = duration - deviation
+		} else {
+			duration = duration + deviation
+		}
+	}
+
+	duration = math.Min(float64(duration), float64(backo.cap))
+	return time.Duration(duration)
+}
+
+// Sleep pauses the current goroutine for the backoff interval for the given attempt.
+func (backo *Backo) Sleep(attempt int) {
+	duration := backo.Duration(attempt)
+	time.Sleep(duration)
+}
+
+type Ticker struct {
+	done chan struct{}
+	C    <-chan time.Time
+}
+
+func (b *Backo) NewTicker() *Ticker {
+	c := make(chan time.Time, 1)
+	ticker := &Ticker{
+		done: make(chan struct{}, 1),
+		C:    c,
+	}
+
+	go func() {
+		for i := 0; ; i++ {
+			select {
+			case t := <-time.After(b.Duration(i)):
+				c <- t
+			case <-ticker.done:
+				close(c)
+				return
+			}
+		}
+	}()
+
+	return ticker
+}
+
+func (t *Ticker) Stop() {
+	t.done <- struct{}{}
+}
diff --git a/vendor/github.com/xtgo/uuid b/vendor/github.com/xtgo/uuid
deleted file mode 160000
index a0b1148..0000000
--- a/vendor/github.com/xtgo/uuid
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit a0b114877d4caeffbd7f87e3757c17fce570fea7
diff --git a/vendor/github.com/xtgo/uuid/AUTHORS b/vendor/github.com/xtgo/uuid/AUTHORS
new file mode 100644
index 0000000..a6f0451
--- /dev/null
+++ b/vendor/github.com/xtgo/uuid/AUTHORS
@@ -0,0 +1,5 @@
+# This source file refers to The gocql Authors for copyright purposes.
+
+Christoph Hack <christoph@tux21b.org>
+Jonathan Rudenberg <jonathan@titanous.com>
+Thorsten von Eicken <tve@rightscale.com>
diff --git a/vendor/github.com/xtgo/uuid/LICENSE b/vendor/github.com/xtgo/uuid/LICENSE
new file mode 100644
index 0000000..18d25f9
--- /dev/null
+++ b/vendor/github.com/xtgo/uuid/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The gocql Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/xtgo/uuid/uuid.go b/vendor/github.com/xtgo/uuid/uuid.go
new file mode 100644
index 0000000..a0fd7a5
--- /dev/null
+++ b/vendor/github.com/xtgo/uuid/uuid.go
@@ -0,0 +1,204 @@
+// Copyright (c) 2012 The gocql Authors. 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 can be used to generate and parse universally unique
+// identifiers, a standardized format in the form of a 128 bit number.
+//
+// http://tools.ietf.org/html/rfc4122
+package uuid
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"io"
+	"net"
+	"strconv"
+	"time"
+)
+
+type UUID [16]byte
+
+var hardwareAddr []byte
+
+const (
+	VariantNCSCompat = 0
+	VariantIETF      = 2
+	VariantMicrosoft = 6
+	VariantFuture    = 7
+)
+
+func init() {
+	if interfaces, err := net.Interfaces(); err == nil {
+		for _, i := range interfaces {
+			if i.Flags&net.FlagLoopback == 0 && len(i.HardwareAddr) > 0 {
+				hardwareAddr = i.HardwareAddr
+				break
+			}
+		}
+	}
+	if hardwareAddr == nil {
+		// If we failed to obtain the MAC address of the current computer,
+		// we will use a randomly generated 6 byte sequence instead and set
+		// the multicast bit as recommended in RFC 4122.
+		hardwareAddr = make([]byte, 6)
+		_, err := io.ReadFull(rand.Reader, hardwareAddr)
+		if err != nil {
+			panic(err)
+		}
+		hardwareAddr[0] = hardwareAddr[0] | 0x01
+	}
+}
+
+// Parse parses a 32 digit hexadecimal number (that might contain hyphens)
+// representing an UUID.
+func Parse(input string) (UUID, error) {
+	var u UUID
+	j := 0
+	for i := 0; i < len(input); i++ {
+		b := input[i]
+		switch {
+		default:
+			fallthrough
+		case j == 32:
+			goto err
+		case b == '-':
+			continue
+		case '0' <= b && b <= '9':
+			b -= '0'
+		case 'a' <= b && b <= 'f':
+			b -= 'a' - 10
+		case 'A' <= b && b <= 'F':
+			b -= 'A' - 10
+		}
+		u[j/2] |= b << byte(^j&1<<2)
+		j++
+	}
+	if j == 32 {
+		return u, nil
+	}
+err:
+	return UUID{}, errors.New("invalid UUID " + strconv.Quote(input))
+}
+
+// FromBytes converts a raw byte slice to an UUID. It will panic if the slice
+// isn't exactly 16 bytes long.
+func FromBytes(input []byte) UUID {
+	var u UUID
+	if len(input) != 16 {
+		panic("UUIDs must be exactly 16 bytes long")
+	}
+	copy(u[:], input)
+	return u
+}
+
+// NewRandom generates a totally random UUID (version 4) as described in
+// RFC 4122.
+func NewRandom() UUID {
+	var u UUID
+	io.ReadFull(rand.Reader, u[:])
+	u[6] &= 0x0F // clear version
+	u[6] |= 0x40 // set version to 4 (random uuid)
+	u[8] &= 0x3F // clear variant
+	u[8] |= 0x80 // set to IETF variant
+	return u
+}
+
+var timeBase = time.Date(1582, time.October, 15, 0, 0, 0, 0, time.UTC).Unix()
+
+// NewTime generates a new time based UUID (version 1) as described in RFC
+// 4122. This UUID contains the MAC address of the node that generated the
+// UUID, a timestamp and a sequence number.
+func NewTime() UUID {
+	var u UUID
+
+	now := time.Now().In(time.UTC)
+	t := uint64(now.Unix()-timeBase)*10000000 + uint64(now.Nanosecond()/100)
+	u[0], u[1], u[2], u[3] = byte(t>>24), byte(t>>16), byte(t>>8), byte(t)
+	u[4], u[5] = byte(t>>40), byte(t>>32)
+	u[6], u[7] = byte(t>>56)&0x0F, byte(t>>48)
+
+	var clockSeq [2]byte
+	io.ReadFull(rand.Reader, clockSeq[:])
+	u[8] = clockSeq[1]
+	u[9] = clockSeq[0]
+
+	copy(u[10:], hardwareAddr)
+
+	u[6] |= 0x10 // set version to 1 (time based uuid)
+	u[8] &= 0x3F // clear variant
+	u[8] |= 0x80 // set to IETF variant
+
+	return u
+}
+
+// String returns the UUID in it's canonical form, a 32 digit hexadecimal
+// number in the form of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+func (u UUID) String() string {
+	buf := [36]byte{8: '-', 13: '-', 18: '-', 23: '-'}
+	hex.Encode(buf[0:], u[0:4])
+	hex.Encode(buf[9:], u[4:6])
+	hex.Encode(buf[14:], u[6:8])
+	hex.Encode(buf[19:], u[8:10])
+	hex.Encode(buf[24:], u[10:])
+	return string(buf[:])
+}
+
+// Bytes returns the raw byte slice for this UUID. A UUID is always 128 bits
+// (16 bytes) long.
+func (u UUID) Bytes() []byte {
+	return u[:]
+}
+
+// Variant returns the variant of this UUID. This package will only generate
+// UUIDs in the IETF variant.
+func (u UUID) Variant() int {
+	x := u[8]
+	switch byte(0) {
+	case x & 0x80:
+		return VariantNCSCompat
+	case x & 0x40:
+		return VariantIETF
+	case x & 0x20:
+		return VariantMicrosoft
+	}
+	return VariantFuture
+}
+
+// Version extracts the version of this UUID variant. The RFC 4122 describes
+// five kinds of UUIDs.
+func (u UUID) Version() int {
+	return int(u[6] & 0xF0 >> 4)
+}
+
+// Node extracts the MAC address of the node who generated this UUID. It will
+// return nil if the UUID is not a time based UUID (version 1).
+func (u UUID) Node() []byte {
+	if u.Version() != 1 {
+		return nil
+	}
+	return u[10:]
+}
+
+// Timestamp extracts the timestamp information from a time based UUID
+// (version 1).
+func (u UUID) Timestamp() uint64 {
+	if u.Version() != 1 {
+		return 0
+	}
+	return uint64(u[0])<<24 + uint64(u[1])<<16 + uint64(u[2])<<8 +
+		uint64(u[3]) + uint64(u[4])<<40 + uint64(u[5])<<32 +
+		uint64(u[7])<<48 + uint64(u[6]&0x0F)<<56
+}
+
+// Time is like Timestamp, except that it returns a time.Time.
+func (u UUID) Time() time.Time {
+	t := u.Timestamp()
+	if t == 0 {
+		return time.Time{}
+	}
+	sec := t / 10000000
+	nsec := t - sec
+	return time.Unix(int64(sec)+timeBase, int64(nsec))
+}