Merge pull request #114 from nikhita/contributing.md

Add CONTRIBUTING.md
2026-01-26 13:29:11 +01:00 · 2018-09-03 09:15:37 -04:00 · 2018-09-01 19:29:24 +05:30 · 2018-08-24 08:50:41 -04:00 · 2018-08-24 14:44:19 +02:00 · 2018-08-24 14:34:38 +02:00
1500 changed files with 199796 additions and 78 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,6 @@
 language: go
 go:
-  - 1.8.3
+  - 1.9.1
 script:
 - hack/verify-gofmt.sh
 - make build
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,23 @@
+# Contributing Guidelines
+
+Welcome to Kubernetes. We are excited about the prospect of you joining our [community](https://github.com/kubernetes/community)! The Kubernetes community abides by the CNCF [code of conduct](code-of-conduct.md). Here is an excerpt:
+
+_As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities._
+
+## Getting Started
+
+We have full documentation on how to get started contributing here:
+
+- [Contributor License Agreement](https://git.k8s.io/community/CLA.md) Kubernetes projects require that you sign a Contributor License Agreement (CLA) before we can accept your pull requests
+- [Kubernetes Contributor Guide](http://git.k8s.io/community/contributors/guide) - Main contributor documentation, or you can just jump directly to the [contributing section](http://git.k8s.io/community/contributors/guide#contributing)
+- [Contributor Cheat Sheet](https://git.k8s.io/community/contributors/guide/contributor-cheatsheet.md) - Common resources for existing developers
+
+## Mentorship
+
+- [Mentoring Initiatives](https://git.k8s.io/community/mentoring) - We have a diverse set of mentorship programs available that are always looking for volunteers!
+
+
+## Contact Information
+
+- [Slack channel](https://kubernetes.slack.com/messages/sig-scheduling)
+- [Mailing list](https://groups.google.com/forum/#!forum/kubernetes-sig-scheduling)
--- a/README.md
+++ b/README.md
@@ -130,7 +130,7 @@ spec:
    metadata:
      name: descheduler-pod
      annotations:
-        scheduler.alpha.kubernetes.io/critical-pod: "true"
+        scheduler.alpha.kubernetes.io/critical-pod: ""
    spec:
        containers:
        - name: descheduler
@@ -285,11 +285,18 @@ This roadmap is not in any particular order.

 Descheduler  | supported Kubernetes version
 -------------|-----------------------------
-0.4          | 1.9+
+0.4+          | 1.9+
 0.1-0.3      | 1.7-1.8

-## Note
+## Community, discussion, contribution, and support

-This project is under active development, and is not intended for production use.
-Any api could be changed any time with out any notice. That said, your feedback is
-very important and appreciated to make this project more stable and useful.
+Learn how to engage with the Kubernetes community on the [community page](http://kubernetes.io/community/).
+
+You can reach the maintainers of this project at:
+
+- [Slack channel](https://kubernetes.slack.com/messages/sig-scheduling)
+- [Mailing list](https://groups.google.com/forum/#!forum/kubernetes-sig-scheduling)
+
+### Code of conduct
+
+Participation in the Kubernetes community is governed by the [Kubernetes Code of Conduct](code-of-conduct.md).
--- a/14
+++ b/14
@@ -0,0 +1,14 @@
+# Defined below are the security contacts for this repo.
+#
+# They are the contact point for the Product Security Team to reach out
+# to for triaging and handling of incoming issues.
+#
+# The below names agree to abide by the
+# [Embargo Policy](https://github.com/kubernetes/sig-release/blob/master/security-release-process-documentation/security-release-process.md#embargo-policy)
+# and will be removed and replaced if they violate that agreement.
+#
+# DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE
+# INSTRUCTIONS AT https://kubernetes.io/security/
+
+aveshagarwal
+ravisantoshgudimetla
--- a/glide.lock
+++ b/glide.lock
@@ -1,10 +1,24 @@
-hash: 374e925e75f6b711fd89523308d62c744e1a1846bc5923b36b864c19809eef8b
-updated: 2018-01-09T00:39:38.149357059-05:00
+hash: ed51a8e643db6e9996ef0ffca671fb31ab5b7fe0d61ecdda828192871f9da366
+updated: 2018-05-22T18:05:00.26435-07:00
 imports:
+- name: cloud.google.com/go
+  version: 3b1ae45394a234c385be014e9a488f2bb6eef821
+  subpackages:
+  - compute/metadata
+  - internal
+- name: github.com/Azure/go-autorest
+  version: e14a70c556c8e0db173358d1a903dca345a8e75e
+  subpackages:
+  - autorest
+  - autorest/adal
+  - autorest/azure
+  - autorest/date
 - name: github.com/davecgh/go-spew
  version: 782f4967f2dc4564575ca782fe2d04090b5faca8
  subpackages:
  - spew
+- name: github.com/dgrijalva/jwt-go
+  version: 01aeca54ebda6e0fbfafd0a524d234159c05ec20
 - name: github.com/docker/distribution
  version: edc3ab29cdff8694dd6feb85cfeb4b5f1b38ed9c
  subpackages:
@@ -51,6 +65,15 @@ imports:
  - OpenAPIv2
  - compiler
  - extensions
+- name: github.com/gophercloud/gophercloud
+  version: 8183543f90d1aef267a5ecc209f2e0715b355acb
+  subpackages:
+  - openstack
+  - openstack/identity/v2/tenants
+  - openstack/identity/v2/tokens
+  - openstack/identity/v3/tokens
+  - openstack/utils
+  - pagination
 - name: github.com/gregjones/httpcache
  version: 787624de3eb7bd915c329cba748687a3b22666a6
  subpackages:
@@ -106,6 +129,7 @@ imports:
  version: 1c05540f6879653db88113bc4a2b70aec4bd491f
  subpackages:
  - context
+  - context/ctxhttp
  - html
  - html/atom
  - http2
@@ -115,6 +139,13 @@ imports:
  - lex/httplex
  - trace
  - websocket
+- name: golang.org/x/oauth2
+  version: a6bd8cefa1811bd24b86f8902872e4e8225f74c4
+  subpackages:
+  - google
+  - internal
+  - jws
+  - jwt
 - name: golang.org/x/sys
  version: 95c6576299259db960f6c5b9b69ea52422860fce
  subpackages:
@@ -138,6 +169,18 @@ imports:
  version: 8cab8a1319f0be9798e7fe78b15da75e5f94b2e9
  subpackages:
  - imports
+- name: google.golang.org/appengine
+  version: b1f26356af11148e710935ed1ac8a7f5702c7612
+  subpackages:
+  - internal
+  - internal/app_identity
+  - internal/base
+  - internal/datastore
+  - internal/log
+  - internal/modules
+  - internal/remote_api
+  - internal/urlfetch
+  - urlfetch
 - name: gopkg.in/inf.v0
  version: 3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4
 - name: gopkg.in/yaml.v2
@@ -145,6 +188,7 @@ imports:
 - name: k8s.io/api
  version: af4bc157c3a209798fc897f6d4aaaaeb6c2e0d6a
  subpackages:
+  - admission/v1beta1
  - admissionregistration/v1alpha1
  - admissionregistration/v1beta1
  - apps/v1
@@ -163,6 +207,7 @@ imports:
  - core/v1
  - events/v1beta1
  - extensions/v1beta1
+  - imagepolicy/v1alpha1
  - networking/v1
  - policy/v1beta1
  - rbac/v1
@@ -294,9 +339,15 @@ imports:
  - kubernetes/typed/storage/v1beta1/fake
  - listers/core/v1
  - pkg/version
+  - plugin/pkg/client/auth
+  - plugin/pkg/client/auth/azure
+  - plugin/pkg/client/auth/gcp
+  - plugin/pkg/client/auth/oidc
+  - plugin/pkg/client/auth/openstack
  - rest
  - rest/watch
  - testing
+  - third_party/forked/golang/template
  - tools/auth
  - tools/cache
  - tools/clientcmd
@@ -312,6 +363,7 @@ imports:
  - util/flowcontrol
  - util/homedir
  - util/integer
+  - util/jsonpath
 - name: k8s.io/code-generator
  version: fef8bcdbaf36ac6a1a18c9ef7d85200b249fad30
 - name: k8s.io/gengo
@@ -328,25 +380,85 @@ imports:
  version: 925c127ec6b946659ad0fd596fa959be43f0cc05
  subpackages:
  - pkg/api/legacyscheme
-  - pkg/api/v1
+  - pkg/api/testapi
  - pkg/api/v1/resource
+  - pkg/apis/admission
+  - pkg/apis/admission/install
+  - pkg/apis/admission/v1beta1
+  - pkg/apis/admissionregistration
+  - pkg/apis/admissionregistration/install
+  - pkg/apis/admissionregistration/v1alpha1
+  - pkg/apis/admissionregistration/v1beta1
+  - pkg/apis/apps
+  - pkg/apis/apps/install
+  - pkg/apis/apps/v1
+  - pkg/apis/apps/v1beta1
+  - pkg/apis/apps/v1beta2
+  - pkg/apis/authentication
+  - pkg/apis/authentication/install
+  - pkg/apis/authentication/v1
+  - pkg/apis/authentication/v1beta1
+  - pkg/apis/authorization
+  - pkg/apis/authorization/install
+  - pkg/apis/authorization/v1
+  - pkg/apis/authorization/v1beta1
  - pkg/apis/autoscaling
+  - pkg/apis/autoscaling/install
+  - pkg/apis/autoscaling/v1
+  - pkg/apis/autoscaling/v2beta1
+  - pkg/apis/batch
+  - pkg/apis/batch/install
+  - pkg/apis/batch/v1
+  - pkg/apis/batch/v1beta1
+  - pkg/apis/batch/v2alpha1
+  - pkg/apis/certificates
+  - pkg/apis/certificates/install
+  - pkg/apis/certificates/v1beta1
+  - pkg/apis/componentconfig
+  - pkg/apis/componentconfig/install
+  - pkg/apis/componentconfig/v1alpha1
  - pkg/apis/core
  - pkg/apis/core/helper
-  - pkg/apis/core/helper/qos
  - pkg/apis/core/install
  - pkg/apis/core/v1
  - pkg/apis/core/v1/helper
+  - pkg/apis/core/v1/helper/qos
+  - pkg/apis/events
+  - pkg/apis/events/install
+  - pkg/apis/events/v1beta1
  - pkg/apis/extensions
+  - pkg/apis/extensions/install
+  - pkg/apis/extensions/v1beta1
+  - pkg/apis/imagepolicy
+  - pkg/apis/imagepolicy/install
+  - pkg/apis/imagepolicy/v1alpha1
  - pkg/apis/networking
+  - pkg/apis/networking/install
+  - pkg/apis/networking/v1
  - pkg/apis/policy
+  - pkg/apis/policy/install
  - pkg/apis/policy/v1beta1
+  - pkg/apis/rbac
+  - pkg/apis/rbac/install
+  - pkg/apis/rbac/v1
+  - pkg/apis/rbac/v1alpha1
+  - pkg/apis/rbac/v1beta1
  - pkg/apis/scheduling
+  - pkg/apis/scheduling/install
+  - pkg/apis/scheduling/v1alpha1
+  - pkg/apis/settings
+  - pkg/apis/settings/install
+  - pkg/apis/settings/v1alpha1
+  - pkg/apis/storage
+  - pkg/apis/storage/install
+  - pkg/apis/storage/v1
+  - pkg/apis/storage/v1alpha1
+  - pkg/apis/storage/v1beta1
  - pkg/features
+  - pkg/kubelet/apis
  - pkg/kubelet/types
+  - pkg/master/ports
  - pkg/util/parsers
  - pkg/util/pointer
  - plugin/pkg/scheduler/algorithm/priorities/util
-  - plugin/pkg/scheduler/schedulercache
-  - plugin/pkg/scheduler/util
 testImports: []
--- a/glide.yaml
+++ b/glide.yaml
@@ -18,6 +18,8 @@ import:
 - package: k8s.io/gengo
 - package: github.com/ugorji/go
  version: v.1.1-beta
+- package: github.com/Azure/go-autorest
+  version: e14a70c556c8e0db173358d1a903dca345a8e75e
 - package: golang.org/x/tools
  subpackages:
  - imports
--- a/hack/e2e-gce/gcloud_create_cluster.sh
+++ b/hack/e2e-gce/gcloud_create_cluster.sh
@@ -10,7 +10,7 @@ master_uuid=$(uuid)
 node1_uuid=$(uuid)
 node2_uuid=$(uuid)
 kube_apiserver_port=6443
-kube_version=1.9.4
+kube_version=1.11.1

 DESCHEDULER_ROOT=$(dirname "${BASH_SOURCE}")/../../
 E2E_GCE_HOME=$DESCHEDULER_ROOT/hack/e2e-gce
@@ -39,7 +39,7 @@ generate_kubeadm_instance_files() {
 	master_public_ip=$(gcloud compute instances list | grep $master_uuid|awk '{print $5}')
 	node1_public_ip=$(gcloud compute instances list | grep $node1_uuid|awk '{print $5}')
 	node2_public_ip=$(gcloud compute instances list | grep $node2_uuid|awk '{print $5}')
-	echo "kubeadm init --kubernetes-version=${kube_version} --apiserver-advertise-address=${master_public_ip}" --skip-preflight-checks --pod-network-cidr=10.96.0.0/12 > $E2E_GCE_HOME/kubeadm_install.sh
+	echo "kubeadm init --kubernetes-version=${kube_version} --apiserver-advertise-address=${master_public_ip}" --ignore-preflight-errors=all --pod-network-cidr=10.96.0.0/12 > $E2E_GCE_HOME/kubeadm_install.sh
 }


--- a/hack/verify-gofmt.sh
+++ b/hack/verify-gofmt.sh
@@ -23,7 +23,7 @@ DESCHEDULER_ROOT=$(dirname "${BASH_SOURCE}")/..

 GO_VERSION=($(go version))

-if [[ -z $(echo "${GO_VERSION[2]}" | grep -E 'go1.2|go1.3|go1.4|go1.5|go1.6|go1.7|go1.8|go1.9') ]]; then
+if [[ -z $(echo "${GO_VERSION[2]}" | grep -E 'go1.2|go1.3|go1.4|go1.5|go1.6|go1.7|go1.8|go1.9|go1.10') ]]; then
  echo "Unknown go version '${GO_VERSION}', skipping gofmt."
  exit 1
 fi
--- a/kubernetes/configmap.yaml
+++ b/kubernetes/configmap.yaml
@@ -0,0 +1,26 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: descheduler-policy-configmap
+data:
+  policy.yaml: |
+    apiVersion: "descheduler/v1alpha1"
+    kind: "DeschedulerPolicy"
+    strategies:
+      "RemoveDuplicates":
+         enabled: true
+      "RemovePodsViolatingInterPodAntiAffinity":
+         enabled: true
+      "LowNodeUtilization":
+         enabled: true
+         params:
+           nodeResourceUtilizationThresholds:
+             thresholds:
+               "cpu" : 20
+               "memory": 20
+               "pods": 20
+             targetThresholds:
+               "cpu" : 50
+               "memory": 50
+               "pods": 50
+
--- a/kubernetes/job.yaml
+++ b/kubernetes/job.yaml
@@ -0,0 +1,33 @@
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: descheduler-job
+  namespace: kube-system
+spec:
+  parallelism: 1
+  completions: 1
+  template:
+    metadata:
+      name: descheduler-pod
+      annotations:
+        scheduler.alpha.kubernetes.io/critical-pod: ""
+    spec:
+        containers:
+        - name: descheduler
+          image: descheduler:latest
+          volumeMounts:
+          - mountPath: /policy-dir
+            name: policy-volume
+          command:
+            - "/bin/descheduler"
+          args:
+            - "--policy-config-file"
+            - "/policy-dir/policy.yaml"
+            - "--v"
+            - "3"
+        restartPolicy: "Never"
+        serviceAccountName: descheduler-sa
+        volumes:
+        - name: policy-volume
+          configMap:
+            name: descheduler-policy-configmap
--- a/kubernetes/rbac.yaml
+++ b/kubernetes/rbac.yaml
@@ -0,0 +1,37 @@
+---
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: descheduler-cluster-role
+  namespace: kube-system
+rules:
+- apiGroups: [""]
+  resources: ["nodes"]
+  verbs: ["get", "watch", "list"]
+- apiGroups: [""]
+  resources: ["pods"]
+  verbs: ["get", "watch", "list", "delete"]
+- apiGroups: [""]
+  resources: ["pods/eviction"]
+  verbs: ["create"]
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: descheduler-sa
+  namespace: kube-system
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: descehduler-cluster-role-binding
+  namespace: kube-system
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: descheduler-cluster-role
+subjects:
+  - name: descheduler-sa
+    kind: ServiceAccount
+    namespace: kube-system
+
--- a/pkg/descheduler/client/client.go
+++ b/pkg/descheduler/client/client.go
@@ -20,6 +20,7 @@ import (
 	"fmt"

 	clientset "k8s.io/client-go/kubernetes"
+	_ "k8s.io/client-go/plugin/pkg/client/auth"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 )
--- a/pkg/descheduler/strategies/duplicates.go
+++ b/pkg/descheduler/strategies/duplicates.go
@@ -54,7 +54,7 @@ func deleteDuplicatePods(client clientset.Interface, policyGroupVersion string,
 				glog.V(1).Infof("%#v", creator)
 				// i = 0 does not evict the first pod
 				for i := 1; i < len(pods); i++ {
-					if nodepodCount[node]+1 > maxPodsToEvict {
+					if maxPodsToEvict > 0 && nodepodCount[node]+1 > maxPodsToEvict {
 						break
 					}
 					success, err := evictions.EvictPod(client, pods[i], policyGroupVersion, dryRun)
--- a/pkg/descheduler/strategies/lownodeutilization.go
+++ b/pkg/descheduler/strategies/lownodeutilization.go
@@ -41,6 +41,7 @@ type NodeUsageMap struct {
 	bPods            []*v1.Pod
 	gPods            []*v1.Pod
 }
+
 type NodePodsMap map[*v1.Node][]*v1.Pod

 func LowNodeUtilization(ds *options.DeschedulerServer, strategy api.DeschedulerStrategy, evictionPolicyGroupVersion string, nodes []*v1.Node, nodepodCount nodePodEvictedCount) {
@@ -59,7 +60,7 @@ func LowNodeUtilization(ds *options.DeschedulerServer, strategy api.DeschedulerS
 		return
 	}

-	npm := CreateNodePodsMap(ds.Client, nodes)
+	npm := createNodePodsMap(ds.Client, nodes)
 	lowNodes, targetNodes := classifyNodes(npm, thresholds, targetThresholds)

 	glog.V(1).Infof("Criteria for a node under utilization: CPU: %v, Mem: %v, Pods: %v",
@@ -151,6 +152,9 @@ func classifyNodes(npm NodePodsMap, thresholds api.ResourceThresholds, targetThr
 	return lowNodes, targetNodes
 }

+// evictPodsFromTargetNodes evicts pods based on priority, if all the pods on the node have priority, if not
+// evicts them based on QoS as fallback option.
+// TODO: @ravig Break this function into smaller functions.
 func evictPodsFromTargetNodes(client clientset.Interface, evictionPolicyGroupVersion string, targetNodes, lowNodes []NodeUsageMap, targetThresholds api.ResourceThresholds, dryRun bool, maxPodsToEvict int, nodepodCount nodePodEvictedCount) int {
 	podsEvicted := 0

@@ -191,12 +195,27 @@ func evictPodsFromTargetNodes(client clientset.Interface, evictionPolicyGroupVer
 		glog.V(3).Infof("evicting pods from node %#v with usage: %#v", node.node.Name, node.usage)
 		currentPodsEvicted := nodepodCount[node.node]

-		// evict best effort pods
-		evictPods(node.bePods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
-		// evict burstable pods
-		evictPods(node.bPods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
-		// evict guaranteed pods
-		evictPods(node.gPods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
+		// Check if one pod has priority, if yes, assume that all pods have priority and evict pods based on priority.
+		if node.allPods[0].Spec.Priority != nil {
+			glog.V(1).Infof("All pods have priority associated with them. Evicting pods based on priority")
+			evictablePods := make([]*v1.Pod, 0)
+			evictablePods = append(append(node.bPods, node.bePods...), node.gPods...)
+
+			// sort the evictable Pods based on priority. This also sorts them based on QoS. If there are multiple pods with same priority, they are sorted based on QoS tiers.
+			sortPodsBasedOnPriority(evictablePods)
+			evictPods(evictablePods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
+		} else {
+			// TODO: Remove this when we support only priority.
+			//  Falling back to evicting pods based on priority.
+			glog.V(1).Infof("Evicting pods based on QoS")
+			glog.V(1).Infof("There are %v non-evictable pods on the node", len(node.nonRemovablePods))
+			// evict best effort pods
+			evictPods(node.bePods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
+			// evict burstable pods
+			evictPods(node.bPods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
+			// evict guaranteed pods
+			evictPods(node.gPods, client, evictionPolicyGroupVersion, targetThresholds, nodeCapacity, node.usage, &totalPods, &totalCpu, &totalMem, &currentPodsEvicted, dryRun, maxPodsToEvict)
+		}
 		nodepodCount[node.node] = currentPodsEvicted
 		podsEvicted = podsEvicted + nodepodCount[node.node]
 		glog.V(1).Infof("%v pods evicted from node %#v with usage %v", nodepodCount[node.node], node.node.Name, node.usage)
@@ -218,7 +237,7 @@ func evictPods(inputPods []*v1.Pod,
 	if IsNodeAboveTargetUtilization(nodeUsage, targetThresholds) && (*totalPods > 0 || *totalCpu > 0 || *totalMem > 0) {
 		onePodPercentage := api.Percentage((float64(1) * 100) / float64(nodeCapacity.Pods().Value()))
 		for _, pod := range inputPods {
-			if *podsEvicted+1 > maxPodsToEvict {
+			if maxPodsToEvict > 0 && *podsEvicted+1 > maxPodsToEvict {
 				break
 			}
 			cUsage := helper.GetResourceRequest(pod, v1.ResourceCPU)
@@ -269,7 +288,30 @@ func SortNodesByUsage(nodes []NodeUsageMap) {
 	})
 }

-func CreateNodePodsMap(client clientset.Interface, nodes []*v1.Node) NodePodsMap {
+// sortPodsBasedOnPriority sorts pods based on priority and if their priorities are equal, they are sorted based on QoS tiers.
+func sortPodsBasedOnPriority(evictablePods []*v1.Pod) {
+	sort.Slice(evictablePods, func(i, j int) bool {
+		if evictablePods[i].Spec.Priority == nil && evictablePods[j].Spec.Priority != nil {
+			return true
+		}
+		if evictablePods[j].Spec.Priority == nil && evictablePods[i].Spec.Priority != nil {
+			return false
+		}
+		if (evictablePods[j].Spec.Priority == nil && evictablePods[i].Spec.Priority == nil) || (*evictablePods[i].Spec.Priority == *evictablePods[j].Spec.Priority) {
+			if podutil.IsBestEffortPod(evictablePods[i]) {
+				return true
+			}
+			if podutil.IsBurstablePod(evictablePods[i]) && podutil.IsGuaranteedPod(evictablePods[j]) {
+				return true
+			}
+			return false
+		}
+		return *evictablePods[i].Spec.Priority < *evictablePods[j].Spec.Priority
+	})
+}
+
+// createNodePodsMap returns nodepodsmap with evictable pods on node.
+func createNodePodsMap(client clientset.Interface, nodes []*v1.Node) NodePodsMap {
 	npm := NodePodsMap{}
 	for _, node := range nodes {
 		pods, err := podutil.ListPodsOnANode(client, node)
@@ -308,6 +350,7 @@ func IsNodeWithLowUtilization(nodeThresholds api.ResourceThresholds, thresholds
 	return true
 }

+// Nodeutilization returns the current usage of node.
 func NodeUtilization(node *v1.Node, pods []*v1.Pod) (api.ResourceThresholds, []*v1.Pod, []*v1.Pod, []*v1.Pod, []*v1.Pod, []*v1.Pod) {
 	bePods := []*v1.Pod{}
 	nonRemovablePods := []*v1.Pod{}
--- a/pkg/descheduler/strategies/lownodeutilization_test.go
+++ b/pkg/descheduler/strategies/lownodeutilization_test.go
@@ -28,10 +28,11 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes/fake"
 	core "k8s.io/client-go/testing"
+	"reflect"
 )

 // TODO: Make this table driven.
-func TestLowNodeUtilization(t *testing.T) {
+func TestLowNodeUtilizationWithoutPriority(t *testing.T) {
 	var thresholds = make(api.ResourceThresholds)
 	var targetThresholds = make(api.ResourceThresholds)
 	thresholds[v1.ResourceCPU] = 30
@@ -110,7 +111,7 @@ func TestLowNodeUtilization(t *testing.T) {
 		return true, nil, fmt.Errorf("Wrong node: %v", getAction.GetName())
 	})
 	expectedPodsEvicted := 3
-	npm := CreateNodePodsMap(fakeClient, []*v1.Node{n1, n2, n3})
+	npm := createNodePodsMap(fakeClient, []*v1.Node{n1, n2, n3})
 	lowNodes, targetNodes := classifyNodes(npm, thresholds, targetThresholds)
 	if len(lowNodes) != 1 {
 		t.Errorf("After ignoring unschedulable nodes, expected only one node to be under utilized.")
@@ -126,6 +127,151 @@ func TestLowNodeUtilization(t *testing.T) {

 }

+// TODO: Make this table driven.
+func TestLowNodeUtilizationWithPriorities(t *testing.T) {
+	var thresholds = make(api.ResourceThresholds)
+	var targetThresholds = make(api.ResourceThresholds)
+	thresholds[v1.ResourceCPU] = 30
+	thresholds[v1.ResourcePods] = 30
+	targetThresholds[v1.ResourceCPU] = 50
+	targetThresholds[v1.ResourcePods] = 50
+	lowPriority := int32(0)
+	highPriority := int32(10000)
+	n1 := test.BuildTestNode("n1", 4000, 3000, 9)
+	n2 := test.BuildTestNode("n2", 4000, 3000, 10)
+	n3 := test.BuildTestNode("n3", 4000, 3000, 10)
+	// Making n3 node unschedulable so that it won't counted in lowUtilized nodes list.
+	n3.Spec.Unschedulable = true
+	p1 := test.BuildTestPod("p1", 400, 0, n1.Name)
+	p1.Spec.Priority = &highPriority
+	p2 := test.BuildTestPod("p2", 400, 0, n1.Name)
+	p2.Spec.Priority = &highPriority
+	p3 := test.BuildTestPod("p3", 400, 0, n1.Name)
+	p3.Spec.Priority = &highPriority
+	p4 := test.BuildTestPod("p4", 400, 0, n1.Name)
+	p4.Spec.Priority = &highPriority
+	p5 := test.BuildTestPod("p5", 400, 0, n1.Name)
+	p5.Spec.Priority = &lowPriority
+
+	// These won't be evicted.
+	p6 := test.BuildTestPod("p6", 400, 0, n1.Name)
+	p6.Spec.Priority = &highPriority
+	p7 := test.BuildTestPod("p7", 400, 0, n1.Name)
+	p7.Spec.Priority = &lowPriority
+	p8 := test.BuildTestPod("p8", 400, 0, n1.Name)
+	p8.Spec.Priority = &lowPriority
+
+	p1.ObjectMeta.OwnerReferences = test.GetReplicaSetOwnerRefList()
+	p2.ObjectMeta.OwnerReferences = test.GetReplicaSetOwnerRefList()
+	p3.ObjectMeta.OwnerReferences = test.GetReplicaSetOwnerRefList()
+	p4.ObjectMeta.OwnerReferences = test.GetReplicaSetOwnerRefList()
+	p5.ObjectMeta.OwnerReferences = test.GetReplicaSetOwnerRefList()
+	// The following 4 pods won't get evicted.
+	// A daemonset.
+	p6.ObjectMeta.OwnerReferences = test.GetDaemonSetOwnerRefList()
+	// A pod with local storage.
+	p7.ObjectMeta.OwnerReferences = test.GetNormalPodOwnerRefList()
+	p7.Spec.Volumes = []v1.Volume{
+		{
+			Name: "sample",
+			VolumeSource: v1.VolumeSource{
+				HostPath: &v1.HostPathVolumeSource{Path: "somePath"},
+				EmptyDir: &v1.EmptyDirVolumeSource{
+					SizeLimit: resource.NewQuantity(int64(10), resource.BinarySI)},
+			},
+		},
+	}
+	// A Mirror Pod.
+	p7.Annotations = test.GetMirrorPodAnnotation()
+	// A Critical Pod.
+	p8.Namespace = "kube-system"
+	p8.Annotations = test.GetCriticalPodAnnotation()
+	p9 := test.BuildTestPod("p9", 400, 0, n1.Name)
+	p9.ObjectMeta.OwnerReferences = test.GetReplicaSetOwnerRefList()
+	fakeClient := &fake.Clientset{}
+	fakeClient.Fake.AddReactor("list", "pods", func(action core.Action) (bool, runtime.Object, error) {
+		list := action.(core.ListAction)
+		fieldString := list.GetListRestrictions().Fields.String()
+		if strings.Contains(fieldString, "n1") {
+			return true, &v1.PodList{Items: []v1.Pod{*p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8}}, nil
+		}
+		if strings.Contains(fieldString, "n2") {
+			return true, &v1.PodList{Items: []v1.Pod{*p9}}, nil
+		}
+		if strings.Contains(fieldString, "n3") {
+			return true, &v1.PodList{Items: []v1.Pod{}}, nil
+		}
+		return true, nil, fmt.Errorf("Failed to list: %v", list)
+	})
+	fakeClient.Fake.AddReactor("get", "nodes", func(action core.Action) (bool, runtime.Object, error) {
+		getAction := action.(core.GetAction)
+		switch getAction.GetName() {
+		case n1.Name:
+			return true, n1, nil
+		case n2.Name:
+			return true, n2, nil
+		case n3.Name:
+			return true, n3, nil
+		}
+		return true, nil, fmt.Errorf("Wrong node: %v", getAction.GetName())
+	})
+	expectedPodsEvicted := 3
+	npm := createNodePodsMap(fakeClient, []*v1.Node{n1, n2, n3})
+	lowNodes, targetNodes := classifyNodes(npm, thresholds, targetThresholds)
+	if len(lowNodes) != 1 {
+		t.Errorf("After ignoring unschedulable nodes, expected only one node to be under utilized.")
+	}
+	npe := nodePodEvictedCount{}
+	npe[n1] = 0
+	npe[n2] = 0
+	npe[n3] = 0
+	podsEvicted := evictPodsFromTargetNodes(fakeClient, "v1", targetNodes, lowNodes, targetThresholds, false, 3, npe)
+	if expectedPodsEvicted != podsEvicted {
+		t.Errorf("Expected %#v pods to be evicted but %#v got evicted", expectedPodsEvicted, podsEvicted)
+	}
+
+}
+
+func TestSortPodsByPriority(t *testing.T) {
+	n1 := test.BuildTestNode("n1", 4000, 3000, 9)
+	lowPriority := int32(0)
+	highPriority := int32(10000)
+	p1 := test.BuildTestPod("p1", 400, 0, n1.Name)
+	p1.Spec.Priority = &lowPriority
+
+	// BestEffort
+	p2 := test.BuildTestPod("p2", 400, 0, n1.Name)
+	p2.Spec.Priority = &highPriority
+
+	p2.Spec.Containers[0].Resources.Requests = nil
+	p2.Spec.Containers[0].Resources.Limits = nil
+
+	// Burstable
+	p3 := test.BuildTestPod("p3", 400, 0, n1.Name)
+	p3.Spec.Priority = &highPriority
+
+	// Guaranteed
+	p4 := test.BuildTestPod("p4", 400, 100, n1.Name)
+	p4.Spec.Priority = &highPriority
+	p4.Spec.Containers[0].Resources.Limits[v1.ResourceCPU] = *resource.NewMilliQuantity(400, resource.DecimalSI)
+	p4.Spec.Containers[0].Resources.Limits[v1.ResourceMemory] = *resource.NewQuantity(100, resource.DecimalSI)
+
+	// Best effort with nil priorities.
+	p5 := test.BuildTestPod("p5", 400, 100, n1.Name)
+	p5.Spec.Priority = nil
+	p6 := test.BuildTestPod("p6", 400, 100, n1.Name)
+	p6.Spec.Containers[0].Resources.Limits[v1.ResourceCPU] = *resource.NewMilliQuantity(400, resource.DecimalSI)
+	p6.Spec.Containers[0].Resources.Limits[v1.ResourceMemory] = *resource.NewQuantity(100, resource.DecimalSI)
+	p6.Spec.Priority = nil
+
+	podList := []*v1.Pod{p4, p3, p2, p1, p6, p5}
+
+	sortPodsBasedOnPriority(podList)
+	if !reflect.DeepEqual(podList[len(podList)-1], p4) {
+		t.Errorf("Expected last pod in sorted list to be %v which of highest priority and guaranteed but got %v", p4, podList[len(podList)-1])
+	}
+}
+
 func TestValidateThresholds(t *testing.T) {
 	tests := []struct {
 		name    string
--- a/pkg/descheduler/strategies/node_affinity.go
+++ b/pkg/descheduler/strategies/node_affinity.go
@@ -27,8 +27,7 @@ import (
 )

 func RemovePodsViolatingNodeAffinity(ds *options.DeschedulerServer, strategy api.DeschedulerStrategy, evictionPolicyGroupVersion string, nodes []*v1.Node, nodePodCount nodePodEvictedCount) {
-	evictionCount := removePodsViolatingNodeAffinityCount(ds, strategy, evictionPolicyGroupVersion, nodes, nodePodCount, ds.MaxNoOfPodsToEvictPerNode)
-	glog.V(1).Infof("Evicted %v pods", evictionCount)
+	removePodsViolatingNodeAffinityCount(ds, strategy, evictionPolicyGroupVersion, nodes, nodePodCount, ds.MaxNoOfPodsToEvictPerNode)
 }

 func removePodsViolatingNodeAffinityCount(ds *options.DeschedulerServer, strategy api.DeschedulerStrategy, evictionPolicyGroupVersion string, nodes []*v1.Node, nodepodCount nodePodEvictedCount, maxPodsToEvict int) int {
@@ -51,14 +50,14 @@ func removePodsViolatingNodeAffinityCount(ds *options.DeschedulerServer, strateg
 				}

 				for _, pod := range pods {
-					if nodepodCount[node]+1 > maxPodsToEvict {
+					if maxPodsToEvict > 0 && nodepodCount[node]+1 > maxPodsToEvict {
 						break
 					}
 					if pod.Spec.Affinity != nil && pod.Spec.Affinity.NodeAffinity != nil && pod.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {

 						if !nodeutil.PodFitsCurrentNode(pod, node) && nodeutil.PodFitsAnyNode(pod, nodes) {
 							glog.V(1).Infof("Evicting pod: %v", pod.Name)
-							evictions.EvictPod(ds.Client, pod, evictionPolicyGroupVersion, false)
+							evictions.EvictPod(ds.Client, pod, evictionPolicyGroupVersion, ds.DryRun)
 							nodepodCount[node]++
 						}
 					}
@@ -70,5 +69,6 @@ func removePodsViolatingNodeAffinityCount(ds *options.DeschedulerServer, strateg
 			return evictedPodCount
 		}
 	}
+	glog.V(1).Infof("Evicted %v pods", evictedPodCount)
 	return evictedPodCount
 }
--- a/pkg/descheduler/strategies/node_affinity_test.go
+++ b/pkg/descheduler/strategies/node_affinity_test.go
@@ -143,16 +143,16 @@ func TestRemovePodsViolatingNodeAffinity(t *testing.T) {
 			pods:                    addPodsToNode(nodeWithoutLabels),
 			nodes:                   []*v1.Node{nodeWithoutLabels, nodeWithLabels},
 			npe:                     nodePodEvictedCount{nodeWithoutLabels: 0, nodeWithLabels: 0},
-			maxPodsToEvict:          1,
+			maxPodsToEvict:          0,
 		},
 		{
-			description:             "Pod is scheduled on node without matching labels, another schedulable node available, maxPodsToEvict set to 0, should not be evicted",
-			expectedEvictedPodCount: 0,
+			description:             "Pod is scheduled on node without matching labels, another schedulable node available, maxPodsToEvict set to 1, should not be evicted",
+			expectedEvictedPodCount: 1,
 			strategy:                requiredDuringSchedulingIgnoredDuringExecutionStrategy,
 			pods:                    addPodsToNode(nodeWithoutLabels),
 			nodes:                   []*v1.Node{nodeWithoutLabels, nodeWithLabels},
 			npe:                     nodePodEvictedCount{nodeWithoutLabels: 0, nodeWithLabels: 0},
-			maxPodsToEvict:          0,
+			maxPodsToEvict:          1,
 		},
 		{
 			description:             "Pod is scheduled on node without matching labels, but no node where pod fits is available, should not evict",
--- a/pkg/descheduler/strategies/pod_antiaffinity.go
+++ b/pkg/descheduler/strategies/pod_antiaffinity.go
@@ -49,7 +49,7 @@ func removePodsWithAffinityRules(client clientset.Interface, policyGroupVersion
 		}
 		totalPods := len(pods)
 		for i := 0; i < totalPods; i++ {
-			if nodePodCount[node]+1 > maxPodsToEvict {
+			if maxPodsToEvict > 0 && nodePodCount[node]+1 > maxPodsToEvict {
 				break
 			}
 			if checkPodsWithAntiAffinityExist(pods[i], pods) {
--- a/pkg/descheduler/strategies/pod_antiaffinity_test.go
+++ b/pkg/descheduler/strategies/pod_antiaffinity_test.go
@@ -32,63 +32,58 @@ func TestPodAntiAffinity(t *testing.T) {
 	p1 := test.BuildTestPod("p1", 100, 0, node.Name)
 	p2 := test.BuildTestPod("p2", 100, 0, node.Name)
 	p3 := test.BuildTestPod("p3", 100, 0, node.Name)
-	p3.Labels = map[string]string{"foo": "bar"}
+	p4 := test.BuildTestPod("p4", 100, 0, node.Name)
+	p2.Labels = map[string]string{"foo": "bar"}
 	p1.ObjectMeta.OwnerReferences = test.GetNormalPodOwnerRefList()
 	p2.ObjectMeta.OwnerReferences = test.GetNormalPodOwnerRefList()
 	p3.ObjectMeta.OwnerReferences = test.GetNormalPodOwnerRefList()
-	p1.Spec.Affinity = &v1.Affinity{
-		PodAntiAffinity: &v1.PodAntiAffinity{
-			RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
-				{
-					LabelSelector: &metav1.LabelSelector{
-						MatchExpressions: []metav1.LabelSelectorRequirement{
-							{
-								Key:      "foo",
-								Operator: metav1.LabelSelectorOpIn,
-								Values:   []string{"bar"},
-							},
-						},
-					},
-					TopologyKey: "region",
-				},
-			},
-		},
-	}
-	p3.Spec.Affinity = &v1.Affinity{
-		PodAntiAffinity: &v1.PodAntiAffinity{
-			RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
-				{
-					LabelSelector: &metav1.LabelSelector{
-						MatchExpressions: []metav1.LabelSelectorRequirement{
-							{
-								Key:      "foo",
-								Operator: metav1.LabelSelectorOpIn,
-								Values:   []string{"bar"},
-							},
-						},
-					},
-					TopologyKey: "region",
-				},
-			},
-		},
-	}
+	p4.ObjectMeta.OwnerReferences = test.GetNormalPodOwnerRefList()
+
+	// set pod anti affinity
+	setPodAntiAffinity(p1)
+	setPodAntiAffinity(p3)
+	setPodAntiAffinity(p4)
+
+	// create fake client
 	fakeClient := &fake.Clientset{}
 	fakeClient.Fake.AddReactor("list", "pods", func(action core.Action) (bool, runtime.Object, error) {
-		return true, &v1.PodList{Items: []v1.Pod{*p1, *p2, *p3}}, nil
+		return true, &v1.PodList{Items: []v1.Pod{*p1, *p2, *p3, *p4}}, nil
 	})
 	fakeClient.Fake.AddReactor("get", "nodes", func(action core.Action) (bool, runtime.Object, error) {
 		return true, node, nil
 	})
 	npe := nodePodEvictedCount{}
 	npe[node] = 0
-	expectedEvictedPodCount := 0
+	expectedEvictedPodCount := 3
 	podsEvicted := removePodsWithAffinityRules(fakeClient, "v1", []*v1.Node{node}, false, npe, 0)
 	if podsEvicted != expectedEvictedPodCount {
-		t.Errorf("Unexpected no of pods evicted")
+		t.Errorf("Unexpected no of pods evicted: pods evicted: %d, expected: %d", podsEvicted, expectedEvictedPodCount)
 	}
+	npe[node] = 0
 	expectedEvictedPodCount = 1
 	podsEvicted = removePodsWithAffinityRules(fakeClient, "v1", []*v1.Node{node}, false, npe, 1)
 	if podsEvicted != expectedEvictedPodCount {
-		t.Errorf("Unexpected no of pods evicted")
+		t.Errorf("Unexpected no of pods evicted: pods evicted: %d, expected: %d", podsEvicted, expectedEvictedPodCount)
+	}
+}
+
+func setPodAntiAffinity(inputPod *v1.Pod) {
+	inputPod.Spec.Affinity = &v1.Affinity{
+		PodAntiAffinity: &v1.PodAntiAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+				{
+					LabelSelector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "foo",
+								Operator: metav1.LabelSelectorOpIn,
+								Values:   []string{"bar"},
+							},
+						},
+					},
+					TopologyKey: "region",
+				},
+			},
+		},
 	}
 }
--- a/test/test_utils.go
+++ b/test/test_utils.go
@@ -37,6 +37,7 @@ func BuildTestPod(name string, cpu int64, memory int64, nodeName string) *v1.Pod
 				{
 					Resources: v1.ResourceRequirements{
 						Requests: v1.ResourceList{},
+						Limits:   v1.ResourceList{},
 					},
 				},
 			},
--- a/vendor/cloud.google.com/go/.travis.yml
+++ b/vendor/cloud.google.com/go/.travis.yml
@@ -0,0 +1,11 @@
+sudo: false
+language: go
+go:
+- 1.6
+- 1.7
+install:
+- go get -v cloud.google.com/go/...
+script:
+- openssl aes-256-cbc -K $encrypted_912ff8fa81ad_key -iv $encrypted_912ff8fa81ad_iv -in key.json.enc -out key.json -d
+- GCLOUD_TESTS_GOLANG_PROJECT_ID="dulcet-port-762" GCLOUD_TESTS_GOLANG_KEY="$(pwd)/key.json"
+  go test -race -v cloud.google.com/go/...
--- a/vendor/cloud.google.com/go/AUTHORS
+++ b/vendor/cloud.google.com/go/AUTHORS
@@ -0,0 +1,15 @@
+# This is the official list of cloud authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+
+# Names should be added to this file as:
+# Name or Organization <email address>
+# The email address is not required for organizations.
+
+Filippo Valsorda <hi@filippo.io>
+Google Inc.
+Ingo Oeser <nightlyone@googlemail.com>
+Palm Stone Games, Inc.
+Paweł Knap <pawelknap88@gmail.com>
+Péter Szilágyi <peterke@gmail.com>
+Tyler Treat <ttreat31@gmail.com>
--- a/vendor/cloud.google.com/go/CONTRIBUTING.md
+++ b/vendor/cloud.google.com/go/CONTRIBUTING.md
@@ -0,0 +1,126 @@
+# Contributing
+
+1. Sign one of the contributor license agreements below.
+1. `go get golang.org/x/review/git-codereview` to install the code reviewing tool.
+1. Get the cloud package by running `go get -d cloud.google.com/go`.
+    1. If you have already checked out the source, make sure that the remote git
+       origin is https://code.googlesource.com/gocloud:
+
+            git remote set-url origin https://code.googlesource.com/gocloud
+1. Make sure your auth is configured correctly by visiting
+   https://code.googlesource.com, clicking "Generate Password", and following
+   the directions.
+1. Make changes and create a change by running `git codereview change <name>`,
+provide a commit message, and use `git codereview mail` to create a Gerrit CL.
+1. Keep amending to the change and mail as your receive feedback.
+
+## Integration Tests
+
+In addition to the unit tests, you may run the integration test suite.
+
+To run the integrations tests, creating and configuration of a project in the
+Google Developers Console is required.
+
+After creating a project, you must [create a service account](https://developers.google.com/identity/protocols/OAuth2ServiceAccount#creatinganaccount).
+Ensure the project-level **Owner** [IAM role](console.cloud.google.com/iam-admin/iam/project)
+(or **Editor** and **Logs Configuration Writer** roles) are added to the
+service account.
+
+Once you create a project, set the following environment variables to be able to
+run the against the actual APIs.
+
+- **GCLOUD_TESTS_GOLANG_PROJECT_ID**: Developers Console project's ID (e.g. bamboo-shift-455)
+- **GCLOUD_TESTS_GOLANG_KEY**: The path to the JSON key file.
+
+Install the [gcloud command-line tool][gcloudcli] to your machine and use it
+to create the indexes used in the datastore integration tests with indexes
+found in `datastore/testdata/index.yaml`:
+
+From the project's root directory:
+
+``` sh
+# Set the default project in your env
+$ gcloud config set project $GCLOUD_TESTS_GOLANG_PROJECT_ID
+
+# Authenticate the gcloud tool with your account
+$ gcloud auth login
+
+# Create the indexes
+$ gcloud preview datastore create-indexes datastore/testdata/index.yaml
+```
+
+The Sink integration tests in preview/logging require a Google Cloud storage
+bucket with the same name as your test project, and with the Stackdriver Logging
+service account as owner:
+``` sh
+$ gsutil mb gs://$GCLOUD_TESTS_GOLANG_PROJECT_ID
+$ gsutil acl ch -g cloud-logs@google.com:O gs://$GCLOUD_TESTS_GOLANG_PROJECT_ID
+```
+
+Once you've set the environment variables, you can run the integration tests by
+running:
+
+``` sh
+$ go test -v cloud.google.com/go/...
+```
+
+## Contributor License Agreements
+
+Before we can accept your pull requests you'll need to sign a Contributor
+License Agreement (CLA):
+
+- **If you are an individual writing original source code** and **you own the
+- intellectual property**, then you'll need to sign an [individual CLA][indvcla].
+- **If you work for a company that wants to allow you to contribute your work**,
+then you'll need to sign a [corporate CLA][corpcla].
+
+You can sign these electronically (just scroll to the bottom). After that,
+we'll be able to accept your pull requests.
+
+## Contributor Code of Conduct
+
+As contributors and maintainers of this project,
+and in the interest of fostering an open and welcoming community,
+we pledge to respect all people who contribute through reporting issues,
+posting feature requests, updating documentation,
+submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project
+a harassment-free experience for everyone,
+regardless of level of experience, gender, gender identity and expression,
+sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information,
+such as physical or electronic
+addresses, without explicit permission
+* Other unethical or unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct.
+By adopting this Code of Conduct,
+project maintainers commit themselves to fairly and consistently
+applying these principles to every aspect of managing this project.
+Project maintainers who do not follow or enforce the Code of Conduct
+may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior
+may be reported by opening an issue
+or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0,
+available at [http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)
+
+[gcloudcli]: https://developers.google.com/cloud/sdk/gcloud/
+[indvcla]: https://developers.google.com/open-source/cla/individual
+[corpcla]: https://developers.google.com/open-source/cla/corporate
--- a/vendor/cloud.google.com/go/CONTRIBUTORS
+++ b/vendor/cloud.google.com/go/CONTRIBUTORS
@@ -0,0 +1,34 @@
+# People who have agreed to one of the CLAs and can contribute patches.
+# The AUTHORS file lists the copyright holders; this file
+# lists people.  For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# https://developers.google.com/open-source/cla/individual
+# https://developers.google.com/open-source/cla/corporate
+#
+# Names should be added to this file as:
+#     Name <email address>
+
+# Keep the list alphabetically sorted.
+
+Andreas Litt <andreas.litt@gmail.com>
+Andrew Gerrand <adg@golang.org>
+Brad Fitzpatrick <bradfitz@golang.org>
+Burcu Dogan <jbd@google.com>
+Dave Day <djd@golang.org>
+David Sansome <me@davidsansome.com>
+David Symonds <dsymonds@golang.org>
+Filippo Valsorda <hi@filippo.io>
+Glenn Lewis <gmlewis@google.com>
+Ingo Oeser <nightlyone@googlemail.com>
+Johan Euphrosine <proppy@google.com>
+Jonathan Amsterdam <jba@google.com>
+Luna Duclos <luna.duclos@palmstonegames.com>
+Michael McGreevy <mcgreevy@golang.org>
+Omar Jarjur <ojarjur@google.com>
+Paweł Knap <pawelknap88@gmail.com>
+Péter Szilágyi <peterke@gmail.com>
+Sarah Adams <shadams@google.com>
+Toby Burress <kurin@google.com>
+Tuo Shan <shantuo@google.com>
+Tyler Treat <ttreat31@gmail.com>
--- a/vendor/cloud.google.com/go/LICENSE
+++ b/vendor/cloud.google.com/go/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2014 Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/vendor/cloud.google.com/go/README.md
+++ b/vendor/cloud.google.com/go/README.md
@@ -0,0 +1,245 @@
+# Google Cloud for Go
+
+[![Build Status](https://travis-ci.org/GoogleCloudPlatform/google-cloud-go.svg?branch=master)](https://travis-ci.org/GoogleCloudPlatform/google-cloud-go)
+[![GoDoc](https://godoc.org/cloud.google.com/go?status.svg)](https://godoc.org/cloud.google.com/go)
+
+``` go
+import "cloud.google.com/go"
+```
+
+Go packages for Google Cloud Platform services.
+
+**NOTE:** These packages are under development, and may occasionally make
+backwards-incompatible changes.
+
+**NOTE:** Github repo is a mirror of [https://code.googlesource.com/gocloud](https://code.googlesource.com/gocloud).
+
+## News
+
+_September 8, 2016_
+
+* New clients for some of Google's Machine Learning APIs: Vision, Speech, and
+Natural Language.
+
+* Preview version of a new [Stackdriver Logging][cloud-logging] client in
+[`cloud.google.com/go/preview/logging`](https://godoc.org/cloud.google.com/go/preview/logging).
+This client uses gRPC as its transport layer, and supports log reading, sinks
+and metrics. It will replace the current client at `cloud.google.com/go/logging` shortly.
+
+## Supported APIs
+
+Google API                     | Status       | Package
+-------------------------------|--------------|-----------------------------------------------------------
+[Datastore][cloud-datastore]   | beta         | [`cloud.google.com/go/datastore`][cloud-datastore-ref]
+[Storage][cloud-storage]       | beta         | [`cloud.google.com/go/storage`][cloud-storage-ref]
+[Pub/Sub][cloud-pubsub]        | experimental | [`cloud.google.com/go/pubsub`][cloud-pubsub-ref]
+[Bigtable][cloud-bigtable]     | beta         | [`cloud.google.com/go/bigtable`][cloud-bigtable-ref]
+[BigQuery][cloud-bigquery]     | experimental | [`cloud.google.com/go/bigquery`][cloud-bigquery-ref]
+[Logging][cloud-logging]       | experimental | [`cloud.google.com/go/logging`][cloud-logging-ref]
+[Vision][cloud-vision]         | experimental | [`cloud.google.com/go/vision`][cloud-vision-ref]
+[Language][cloud-language]     | experimental | [`cloud.google.com/go/language/apiv1beta1`][cloud-language-ref]
+[Speech][cloud-speech]         | experimental | [`cloud.google.com/go/speech/apiv1beta`][cloud-speech-ref]
+
+
+> **Experimental status**: the API is still being actively developed. As a
+> result, it might change in backward-incompatible ways and is not recommended
+> for production use.
+>
+> **Beta status**: the API is largely complete, but still has outstanding
+> features and bugs to be addressed. There may be minor backwards-incompatible
+> changes where necessary.
+>
+> **Stable status**: the API is mature and ready for production use. We will
+> continue addressing bugs and feature requests.
+
+Documentation and examples are available at
+https://godoc.org/cloud.google.com/go
+
+Visit or join the
+[google-api-go-announce group](https://groups.google.com/forum/#!forum/google-api-go-announce)
+for updates on these packages.
+
+## Go Versions Supported
+
+We support the two most recent major versions of Go. If Google App Engine uses
+an older version, we support that as well. You can see which versions are
+currently supported by looking at the lines following `go:` in
+[`.travis.yml`](.travis.yml).
+
+## Authorization
+
+By default, each API will use [Google Application Default Credentials][default-creds]
+for authorization credentials used in calling the API endpoints. This will allow your
+application to run in many environments without requiring explicit configuration.
+
+Manually-configured authorization can be achieved using the
+[`golang.org/x/oauth2`](https://godoc.org/golang.org/x/oauth2) package to
+create an `oauth2.TokenSource`. This token source can be passed to the `NewClient`
+function for the relevant API using a
+[`option.WithTokenSource`](https://godoc.org/google.golang.org/api/option#WithTokenSource)
+option.
+
+## Google Cloud Datastore [![GoDoc](https://godoc.org/cloud.google.com/go/datastore?status.svg)](https://godoc.org/cloud.google.com/go/datastore)
+
+[Google Cloud Datastore][cloud-datastore] ([docs][cloud-datastore-docs]) is a fully-
+managed, schemaless database for storing non-relational data. Cloud Datastore
+automatically scales with your users and supports ACID transactions, high availability
+of reads and writes, strong consistency for reads and ancestor queries, and eventual
+consistency for all other queries.
+
+Follow the [activation instructions][cloud-datastore-activation] to use the Google
+Cloud Datastore API with your project.
+
+First create a `datastore.Client` to use throughout your application:
+
+```go
+client, err := datastore.NewClient(ctx, "my-project-id")
+if err != nil {
+	log.Fatalln(err)
+}
+```
+
+Then use that client to interact with the API:
+
+```go
+type Post struct {
+	Title       string
+	Body        string `datastore:",noindex"`
+	PublishedAt time.Time
+}
+keys := []*datastore.Key{
+	datastore.NewKey(ctx, "Post", "post1", 0, nil),
+	datastore.NewKey(ctx, "Post", "post2", 0, nil),
+}
+posts := []*Post{
+	{Title: "Post 1", Body: "...", PublishedAt: time.Now()},
+	{Title: "Post 2", Body: "...", PublishedAt: time.Now()},
+}
+if _, err := client.PutMulti(ctx, keys, posts); err != nil {
+	log.Fatal(err)
+}
+```
+
+## Google Cloud Storage [![GoDoc](https://godoc.org/cloud.google.com/go/storage?status.svg)](https://godoc.org/cloud.google.com/go/storage)
+
+[Google Cloud Storage][cloud-storage] ([docs][cloud-storage-docs]) allows you to store
+data on Google infrastructure with very high reliability, performance and availability,
+and can be used to distribute large data objects to users via direct download.
+
+https://godoc.org/cloud.google.com/go/storage
+
+First create a `storage.Client` to use throughout your application:
+
+```go
+client, err := storage.NewClient(ctx)
+if err != nil {
+	log.Fatal(err)
+}
+```
+
+```go
+// Read the object1 from bucket.
+rc, err := client.Bucket("bucket").Object("object1").NewReader(ctx)
+if err != nil {
+	log.Fatal(err)
+}
+defer rc.Close()
+body, err := ioutil.ReadAll(rc)
+if err != nil {
+	log.Fatal(err)
+}
+```
+
+## Google Cloud Pub/Sub [![GoDoc](https://godoc.org/cloud.google.com/go/pubsub?status.svg)](https://godoc.org/cloud.google.com/go/pubsub)
+
+[Google Cloud Pub/Sub][cloud-pubsub] ([docs][cloud-pubsub-docs]) allows you to connect
+your services with reliable, many-to-many, asynchronous messaging hosted on Google's
+infrastructure. Cloud Pub/Sub automatically scales as you need it and provides a foundation
+for building your own robust, global services.
+
+First create a `pubsub.Client` to use throughout your application:
+
+```go
+client, err := pubsub.NewClient(ctx, "project-id")
+if err != nil {
+	log.Fatal(err)
+}
+```
+
+```go
+// Publish "hello world" on topic1.
+topic := client.Topic("topic1")
+msgIDs, err := topic.Publish(ctx, &pubsub.Message{
+	Data: []byte("hello world"),
+})
+if err != nil {
+	log.Fatal(err)
+}
+
+// Create an iterator to pull messages via subscription1.
+it, err := client.Subscription("subscription1").Pull(ctx)
+if err != nil {
+	log.Println(err)
+}
+defer it.Stop()
+
+// Consume N messages from the iterator.
+for i := 0; i < N; i++ {
+	msg, err := it.Next()
+	if err == pubsub.Done {
+		break
+	}
+	if err != nil {
+		log.Fatalf("Failed to retrieve message: %v", err)
+	}
+
+	fmt.Printf("Message %d: %s\n", i, msg.Data)
+	msg.Done(true) // Acknowledge that we've consumed the message.
+}
+```
+
+## Contributing
+
+Contributions are welcome. Please, see the
+[CONTRIBUTING](https://github.com/GoogleCloudPlatform/google-cloud-go/blob/master/CONTRIBUTING.md)
+document for details. We're using Gerrit for our code reviews. Please don't open pull
+requests against this repo, new pull requests will be automatically closed.
+
+Please note that this project is released with a Contributor Code of Conduct.
+By participating in this project you agree to abide by its terms.
+See [Contributor Code of Conduct](https://github.com/GoogleCloudPlatform/google-cloud-go/blob/master/CONTRIBUTING.md#contributor-code-of-conduct)
+for more information.
+
+[cloud-datastore]: https://cloud.google.com/datastore/
+[cloud-datastore-ref]: https://godoc.org/cloud.google.com/go/datastore
+[cloud-datastore-docs]: https://cloud.google.com/datastore/docs
+[cloud-datastore-activation]: https://cloud.google.com/datastore/docs/activate
+
+[cloud-pubsub]: https://cloud.google.com/pubsub/
+[cloud-pubsub-ref]: https://godoc.org/cloud.google.com/go/pubsub
+[cloud-pubsub-docs]: https://cloud.google.com/pubsub/docs
+
+[cloud-storage]: https://cloud.google.com/storage/
+[cloud-storage-ref]: https://godoc.org/cloud.google.com/go/storage
+[cloud-storage-docs]: https://cloud.google.com/storage/docs/overview
+[cloud-storage-create-bucket]: https://cloud.google.com/storage/docs/cloud-console#_creatingbuckets
+
+[cloud-bigtable]: https://cloud.google.com/bigtable/
+[cloud-bigtable-ref]: https://godoc.org/cloud.google.com/go/bigtable
+
+[cloud-bigquery]: https://cloud.google.com/bigquery/
+[cloud-bigquery-ref]: https://godoc.org/cloud.google.com/go/bigquery
+
+[cloud-logging]: https://cloud.google.com/logging/
+[cloud-logging-ref]: https://godoc.org/cloud.google.com/go/logging
+
+[cloud-vision]: https://cloud.google.com/vision/
+[cloud-vision-ref]: https://godoc.org/cloud.google.com/go/vision
+
+[cloud-language]: https://cloud.google.com/natural-language
+[cloud-language-ref]: https://godoc.org/cloud.google.com/go/language/apiv1beta1
+
+[cloud-speech]: https://cloud.google.com/speech
+[cloud-speech-ref]: https://godoc.org/cloud.google.com/go/speech/apiv1beta1
+
+[default-creds]: https://developers.google.com/identity/protocols/application-default-credentials
--- a/vendor/cloud.google.com/go/appveyor.yml
+++ b/vendor/cloud.google.com/go/appveyor.yml
@@ -0,0 +1,26 @@
+# This file configures AppVeyor (http://www.appveyor.com),
+# a Windows-based CI service similar to Travis.
+
+# Identifier for this run
+version: "{build}"
+
+# Clone the repo into this path, which conforms to the standard
+# Go workspace structure.
+clone_folder: c:\gopath\src\cloud.google.com\go
+
+environment:
+  GOPATH: c:\gopath
+
+install:
+  # Info for debugging.
+  - echo %PATH%
+  - go version
+  - go env
+  - go get -v -d -t ./...
+
+# Provide a build script, or AppVeyor will call msbuild.
+build_script:
+  - go install -v ./...
+
+test_script:
+  - go test -short -v ./...
--- a/vendor/cloud.google.com/go/authexample_test.go
+++ b/vendor/cloud.google.com/go/authexample_test.go
@@ -0,0 +1,60 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cloud_test
+
+import (
+	"cloud.google.com/go/datastore"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+)
+
+func Example_applicationDefaultCredentials() {
+	ctx := context.Background()
+	// Use Google Application Default Credentials to authorize and authenticate the client.
+	// More information about Application Default Credentials and how to enable is at
+	// https://developers.google.com/identity/protocols/application-default-credentials.
+	//
+	// This is the recommended way of authorizing and authenticating.
+	//
+	// Note: The example uses the datastore client, but the same steps apply to
+	// the other client libraries underneath this package.
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		// TODO: handle error.
+	}
+	// Use the client.
+	_ = client
+}
+
+func Example_serviceAccountFile() {
+	// Warning: The better way to use service accounts is to set GOOGLE_APPLICATION_CREDENTIALS
+	// and use the Application Default Credentials.
+	ctx := context.Background()
+	// Use a JSON key file associated with a Google service account to
+	// authenticate and authorize.
+	// Go to https://console.developers.google.com/permissions/serviceaccounts to create
+	// and download a service account key for your project.
+	//
+	// Note: The example uses the datastore client, but the same steps apply to
+	// the other client libraries underneath this package.
+	client, err := datastore.NewClient(ctx,
+		"project-id",
+		option.WithServiceAccountFile("/path/to/service-account-key.json"))
+	if err != nil {
+		// TODO: handle error.
+	}
+	// Use the client.
+	_ = client
+}
--- a/vendor/cloud.google.com/go/bigquery/bigquery.go
+++ b/vendor/cloud.google.com/go/bigquery/bigquery.go
@@ -0,0 +1,175 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+// TODO(mcgreevy): support dry-run mode when creating jobs.
+
+import (
+	"fmt"
+
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+const prodAddr = "https://www.googleapis.com/bigquery/v2/"
+
+// A Source is a source of data for the Copy function.
+type Source interface {
+	implementsSource()
+}
+
+// A Destination is a destination of data for the Copy function.
+type Destination interface {
+	implementsDestination()
+}
+
+// An Option is an optional argument to Copy.
+type Option interface {
+	implementsOption()
+}
+
+// A ReadSource is a source of data for the Read function.
+type ReadSource interface {
+	implementsReadSource()
+}
+
+// A ReadOption is an optional argument to Read.
+type ReadOption interface {
+	customizeRead(conf *pagingConf)
+}
+
+const Scope = "https://www.googleapis.com/auth/bigquery"
+const userAgent = "gcloud-golang-bigquery/20160429"
+
+// Client may be used to perform BigQuery operations.
+type Client struct {
+	service   service
+	projectID string
+}
+
+// NewClient constructs a new Client which can perform BigQuery operations.
+// Operations performed via the client are billed to the specified GCP project.
+func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) {
+	o := []option.ClientOption{
+		option.WithEndpoint(prodAddr),
+		option.WithScopes(Scope),
+		option.WithUserAgent(userAgent),
+	}
+	o = append(o, opts...)
+	httpClient, endpoint, err := transport.NewHTTPClient(ctx, o...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing: %v", err)
+	}
+
+	s, err := newBigqueryService(httpClient, endpoint)
+	if err != nil {
+		return nil, fmt.Errorf("constructing bigquery client: %v", err)
+	}
+
+	c := &Client{
+		service:   s,
+		projectID: projectID,
+	}
+	return c, nil
+}
+
+// initJobProto creates and returns a bigquery Job proto.
+// The proto is customized using any jobOptions in options.
+// The list of Options is returned with the jobOptions removed.
+func initJobProto(projectID string, options []Option) (*bq.Job, []Option) {
+	job := &bq.Job{}
+
+	var other []Option
+	for _, opt := range options {
+		if o, ok := opt.(jobOption); ok {
+			o.customizeJob(job, projectID)
+		} else {
+			other = append(other, opt)
+		}
+	}
+	return job, other
+}
+
+// Copy starts a BigQuery operation to copy data from a Source to a Destination.
+func (c *Client) Copy(ctx context.Context, dst Destination, src Source, options ...Option) (*Job, error) {
+	switch dst := dst.(type) {
+	case *Table:
+		switch src := src.(type) {
+		case *GCSReference:
+			return c.load(ctx, dst, src, options)
+		case *Table:
+			return c.cp(ctx, dst, Tables{src}, options)
+		case Tables:
+			return c.cp(ctx, dst, src, options)
+		case *Query:
+			return c.query(ctx, dst, src, options)
+		}
+	case *GCSReference:
+		if src, ok := src.(*Table); ok {
+			return c.extract(ctx, dst, src, options)
+		}
+	}
+	return nil, fmt.Errorf("no Copy operation matches dst/src pair: dst: %T ; src: %T", dst, src)
+}
+
+// Query creates a query with string q. You may optionally set
+// DefaultProjectID and DefaultDatasetID on the returned query before using it.
+func (c *Client) Query(q string) *Query {
+	return &Query{Q: q, client: c}
+}
+
+// Read submits a query for execution and returns the results via an Iterator.
+//
+// Read uses a temporary table to hold the results of the query job.
+//
+// For more control over how a query is performed, don't use this method but
+// instead pass the Query as a Source to Client.Copy, and call Read on the
+// resulting Job.
+func (q *Query) Read(ctx context.Context, options ...ReadOption) (*Iterator, error) {
+	dest := &Table{}
+	job, err := q.client.Copy(ctx, dest, q, WriteTruncate)
+	if err != nil {
+		return nil, err
+	}
+	return job.Read(ctx, options...)
+}
+
+// executeQuery submits a query for execution and returns the results via an Iterator.
+func (c *Client) executeQuery(ctx context.Context, q *Query, options ...ReadOption) (*Iterator, error) {
+	dest := &Table{}
+	job, err := c.Copy(ctx, dest, q, WriteTruncate)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Read(ctx, job, options...)
+}
+
+// Dataset creates a handle to a BigQuery dataset in the client's project.
+func (c *Client) Dataset(id string) *Dataset {
+	return c.DatasetInProject(c.projectID, id)
+}
+
+// DatasetInProject creates a handle to a BigQuery dataset in the specified project.
+func (c *Client) DatasetInProject(projectID, datasetID string) *Dataset {
+	return &Dataset{
+		projectID: projectID,
+		id:        datasetID,
+		service:   c.service,
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/copy_op.go
+++ b/vendor/cloud.google.com/go/bigquery/copy_op.go
@@ -0,0 +1,47 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+type copyOption interface {
+	customizeCopy(conf *bq.JobConfigurationTableCopy)
+}
+
+func (c *Client) cp(ctx context.Context, dst *Table, src Tables, options []Option) (*Job, error) {
+	job, options := initJobProto(c.projectID, options)
+	payload := &bq.JobConfigurationTableCopy{}
+
+	dst.customizeCopyDst(payload)
+	src.customizeCopySrc(payload)
+
+	for _, opt := range options {
+		o, ok := opt.(copyOption)
+		if !ok {
+			return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
+		}
+		o.customizeCopy(payload)
+	}
+
+	job.Configuration = &bq.JobConfiguration{
+		Copy: payload,
+	}
+	return c.service.insertJob(ctx, job, c.projectID)
+}
--- a/vendor/cloud.google.com/go/bigquery/copy_test.go
+++ b/vendor/cloud.google.com/go/bigquery/copy_test.go
@@ -0,0 +1,104 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func defaultCopyJob() *bq.Job {
+	return &bq.Job{
+		Configuration: &bq.JobConfiguration{
+			Copy: &bq.JobConfigurationTableCopy{
+				DestinationTable: &bq.TableReference{
+					ProjectId: "d-project-id",
+					DatasetId: "d-dataset-id",
+					TableId:   "d-table-id",
+				},
+				SourceTables: []*bq.TableReference{
+					{
+						ProjectId: "s-project-id",
+						DatasetId: "s-dataset-id",
+						TableId:   "s-table-id",
+					},
+				},
+			},
+		},
+	}
+}
+
+func TestCopy(t *testing.T) {
+	testCases := []struct {
+		dst     *Table
+		src     Tables
+		options []Option
+		want    *bq.Job
+	}{
+		{
+			dst: &Table{
+				ProjectID: "d-project-id",
+				DatasetID: "d-dataset-id",
+				TableID:   "d-table-id",
+			},
+			src: Tables{
+				{
+					ProjectID: "s-project-id",
+					DatasetID: "s-dataset-id",
+					TableID:   "s-table-id",
+				},
+			},
+			want: defaultCopyJob(),
+		},
+		{
+			dst: &Table{
+				ProjectID: "d-project-id",
+				DatasetID: "d-dataset-id",
+				TableID:   "d-table-id",
+			},
+			src: Tables{
+				{
+					ProjectID: "s-project-id",
+					DatasetID: "s-dataset-id",
+					TableID:   "s-table-id",
+				},
+			},
+			options: []Option{CreateNever, WriteTruncate},
+			want: func() *bq.Job {
+				j := defaultCopyJob()
+				j.Configuration.Copy.CreateDisposition = "CREATE_NEVER"
+				j.Configuration.Copy.WriteDisposition = "WRITE_TRUNCATE"
+				return j
+			}(),
+		},
+	}
+
+	for _, tc := range testCases {
+		s := &testService{}
+		c := &Client{
+			service: s,
+		}
+		if _, err := c.Copy(context.Background(), tc.dst, tc.src, tc.options...); err != nil {
+			t.Errorf("err calling cp: %v", err)
+			continue
+		}
+		if !reflect.DeepEqual(s.Job, tc.want) {
+			t.Errorf("copying: got:\n%v\nwant:\n%v", s.Job, tc.want)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/create_table_test.go
+++ b/vendor/cloud.google.com/go/bigquery/create_table_test.go
@@ -0,0 +1,79 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+type createTableRecorder struct {
+	conf *createTableConf
+	service
+}
+
+func (rec *createTableRecorder) createTable(ctx context.Context, conf *createTableConf) error {
+	rec.conf = conf
+	return nil
+}
+
+func TestCreateTableOptions(t *testing.T) {
+	s := &createTableRecorder{}
+	c := &Client{
+		projectID: "p",
+		service:   s,
+	}
+	ds := c.Dataset("d")
+	table := ds.Table("t")
+	exp := time.Now()
+	q := "query"
+	if err := table.Create(context.Background(), TableExpiration(exp), ViewQuery(q)); err != nil {
+		t.Fatalf("err calling Table.Create: %v", err)
+	}
+	want := createTableConf{
+		projectID:  "p",
+		datasetID:  "d",
+		tableID:    "t",
+		expiration: exp,
+		viewQuery:  q,
+	}
+	if !reflect.DeepEqual(*s.conf, want) {
+		t.Errorf("createTableConf: got:\n%v\nwant:\n%v", *s.conf, want)
+	}
+
+	sc := Schema{fieldSchema("desc", "name", "STRING", false, true)}
+	if err := table.Create(context.Background(), TableExpiration(exp), sc); err != nil {
+		t.Fatalf("err calling Table.Create: %v", err)
+	}
+	want = createTableConf{
+		projectID:  "p",
+		datasetID:  "d",
+		tableID:    "t",
+		expiration: exp,
+		// No need for an elaborate schema, that is tested in schema_test.go.
+		schema: &bq.TableSchema{
+			Fields: []*bq.TableFieldSchema{
+				bqTableFieldSchema("desc", "name", "STRING", "REQUIRED"),
+			},
+		},
+	}
+	if !reflect.DeepEqual(*s.conf, want) {
+		t.Errorf("createTableConf: got:\n%v\nwant:\n%v", *s.conf, want)
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/dataset.go
+++ b/vendor/cloud.google.com/go/bigquery/dataset.go
@@ -0,0 +1,55 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import "golang.org/x/net/context"
+
+// Dataset is a reference to a BigQuery dataset.
+type Dataset struct {
+	projectID string
+	id        string
+	service   service
+}
+
+// ListTables returns a list of all the tables contained in the Dataset.
+func (d *Dataset) ListTables(ctx context.Context) ([]*Table, error) {
+	var tables []*Table
+
+	err := getPages("", func(pageToken string) (string, error) {
+		ts, tok, err := d.service.listTables(ctx, d.projectID, d.id, pageToken)
+		if err == nil {
+			tables = append(tables, ts...)
+		}
+		return tok, err
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	return tables, nil
+}
+
+// Create creates a dataset in the BigQuery service. An error will be returned
+// if the dataset already exists.
+func (d *Dataset) Create(ctx context.Context) error {
+	return d.service.insertDataset(ctx, d.id, d.projectID)
+}
+
+// Table creates a handle to a BigQuery table in the dataset.
+// To determine if a table exists, call Table.Metadata.
+// If the table does not already exist, use Table.Create to create it.
+func (d *Dataset) Table(tableID string) *Table {
+	return &Table{ProjectID: d.projectID, DatasetID: d.id, TableID: tableID, service: d.service}
+}
--- a/vendor/cloud.google.com/go/bigquery/dataset_test.go
+++ b/vendor/cloud.google.com/go/bigquery/dataset_test.go
@@ -0,0 +1,105 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+)
+
+// readServiceStub services read requests by returning data from an in-memory list of values.
+type listTablesServiceStub struct {
+	expectedProject, expectedDataset string
+	values                           [][]*Table        // contains pages of tables.
+	pageTokens                       map[string]string // maps incoming page token to returned page token.
+
+	service
+}
+
+func (s *listTablesServiceStub) listTables(ctx context.Context, projectID, datasetID, pageToken string) ([]*Table, string, error) {
+	if projectID != s.expectedProject {
+		return nil, "", errors.New("wrong project id")
+	}
+	if datasetID != s.expectedDataset {
+		return nil, "", errors.New("wrong dataset id")
+	}
+
+	tables := s.values[0]
+	s.values = s.values[1:]
+	return tables, s.pageTokens[pageToken], nil
+}
+
+func TestListTables(t *testing.T) {
+	t1 := &Table{ProjectID: "p1", DatasetID: "d1", TableID: "t1"}
+	t2 := &Table{ProjectID: "p1", DatasetID: "d1", TableID: "t2"}
+	t3 := &Table{ProjectID: "p1", DatasetID: "d1", TableID: "t3"}
+	testCases := []struct {
+		data       [][]*Table
+		pageTokens map[string]string
+		want       []*Table
+	}{
+		{
+			data:       [][]*Table{{t1, t2}, {t3}},
+			pageTokens: map[string]string{"": "a", "a": ""},
+			want:       []*Table{t1, t2, t3},
+		},
+		{
+			data:       [][]*Table{{t1, t2}, {t3}},
+			pageTokens: map[string]string{"": ""}, // no more pages after first one.
+			want:       []*Table{t1, t2},
+		},
+	}
+
+	for _, tc := range testCases {
+		c := &Client{
+			service: &listTablesServiceStub{
+				expectedProject: "x",
+				expectedDataset: "y",
+				values:          tc.data,
+				pageTokens:      tc.pageTokens,
+			},
+			projectID: "x",
+		}
+		got, err := c.Dataset("y").ListTables(context.Background())
+		if err != nil {
+			t.Errorf("err calling ListTables: %v", err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("reading: got:\n%v\nwant:\n%v", got, tc.want)
+		}
+	}
+}
+
+func TestListTablesError(t *testing.T) {
+	c := &Client{
+		service: &listTablesServiceStub{
+			expectedProject: "x",
+			expectedDataset: "y",
+		},
+		projectID: "x",
+	}
+	// Test that service read errors are propagated back to the caller.
+	// Passing "not y" as the dataset id will cause the service to return an error.
+	_, err := c.Dataset("not y").ListTables(context.Background())
+	if err == nil {
+		// Read should not return an error; only Err should.
+		t.Errorf("ListTables expected: non-nil err, got: nil")
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/doc.go
+++ b/vendor/cloud.google.com/go/bigquery/doc.go
@@ -0,0 +1,18 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package bigquery provides a client for the BigQuery service.
+//
+// Note: This package is a work-in-progress.  Backwards-incompatible changes should be expected.
+package bigquery // import "cloud.google.com/go/bigquery"
--- a/vendor/cloud.google.com/go/bigquery/error.go
+++ b/vendor/cloud.google.com/go/bigquery/error.go
@@ -0,0 +1,82 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+// An Error contains detailed information about a failed bigquery operation.
+type Error struct {
+	// Mirrors bq.ErrorProto, but drops DebugInfo
+	Location, Message, Reason string
+}
+
+func (e Error) Error() string {
+	return fmt.Sprintf("{Location: %q; Message: %q; Reason: %q}", e.Location, e.Message, e.Reason)
+}
+
+func errorFromErrorProto(ep *bq.ErrorProto) *Error {
+	if ep == nil {
+		return nil
+	}
+	return &Error{
+		Location: ep.Location,
+		Message:  ep.Message,
+		Reason:   ep.Reason,
+	}
+}
+
+// A MultiError contains multiple related errors.
+type MultiError []error
+
+func (m MultiError) Error() string {
+	switch len(m) {
+	case 0:
+		return "(0 errors)"
+	case 1:
+		return m[0].Error()
+	case 2:
+		return m[0].Error() + " (and 1 other error)"
+	}
+	return fmt.Sprintf("%s (and %d other errors)", m[0].Error(), len(m)-1)
+}
+
+// RowInsertionError contains all errors that occurred when attempting to insert a row.
+type RowInsertionError struct {
+	InsertID string // The InsertID associated with the affected row.
+	RowIndex int    // The 0-based index of the affected row in the batch of rows being inserted.
+	Errors   MultiError
+}
+
+func (e *RowInsertionError) Error() string {
+	errFmt := "insertion of row [insertID: %q; insertIndex: %v] failed with error: %s"
+	return fmt.Sprintf(errFmt, e.InsertID, e.RowIndex, e.Errors.Error())
+}
+
+// PutMultiError contains an error for each row which was not successfully inserted
+// into a BigQuery table.
+type PutMultiError []RowInsertionError
+
+func (pme PutMultiError) Error() string {
+	plural := "s"
+	if len(pme) == 1 {
+		plural = ""
+	}
+
+	return fmt.Sprintf("%v row insertion%s failed", len(pme), plural)
+}
--- a/vendor/cloud.google.com/go/bigquery/error_test.go
+++ b/vendor/cloud.google.com/go/bigquery/error_test.go
@@ -0,0 +1,109 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func rowInsertionError(msg string) RowInsertionError {
+	return RowInsertionError{Errors: []error{errors.New(msg)}}
+}
+
+func TestPutMultiErrorString(t *testing.T) {
+	testCases := []struct {
+		errs PutMultiError
+		want string
+	}{
+		{
+			errs: PutMultiError{},
+			want: "0 row insertions failed",
+		},
+		{
+			errs: PutMultiError{rowInsertionError("a")},
+			want: "1 row insertion failed",
+		},
+		{
+			errs: PutMultiError{rowInsertionError("a"), rowInsertionError("b")},
+			want: "2 row insertions failed",
+		},
+	}
+
+	for _, tc := range testCases {
+		if tc.errs.Error() != tc.want {
+			t.Errorf("PutMultiError string: got:\n%v\nwant:\n%v", tc.errs.Error(), tc.want)
+		}
+	}
+}
+
+func TestMultiErrorString(t *testing.T) {
+	testCases := []struct {
+		errs MultiError
+		want string
+	}{
+		{
+			errs: MultiError{},
+			want: "(0 errors)",
+		},
+		{
+			errs: MultiError{errors.New("a")},
+			want: "a",
+		},
+		{
+			errs: MultiError{errors.New("a"), errors.New("b")},
+			want: "a (and 1 other error)",
+		},
+		{
+			errs: MultiError{errors.New("a"), errors.New("b"), errors.New("c")},
+			want: "a (and 2 other errors)",
+		},
+	}
+
+	for _, tc := range testCases {
+		if tc.errs.Error() != tc.want {
+			t.Errorf("PutMultiError string: got:\n%v\nwant:\n%v", tc.errs.Error(), tc.want)
+		}
+	}
+}
+
+func TestErrorFromErrorProto(t *testing.T) {
+	for _, test := range []struct {
+		in   *bq.ErrorProto
+		want *Error
+	}{
+		{nil, nil},
+		{
+			in:   &bq.ErrorProto{Location: "L", Message: "M", Reason: "R"},
+			want: &Error{Location: "L", Message: "M", Reason: "R"},
+		},
+	} {
+		if got := errorFromErrorProto(test.in); !reflect.DeepEqual(got, test.want) {
+			t.Errorf("%v: got %v, want %v", test.in, got, test.want)
+		}
+	}
+}
+
+func TestErrorString(t *testing.T) {
+	e := &Error{Location: "<L>", Message: "<M>", Reason: "<R>"}
+	got := e.Error()
+	if !strings.Contains(got, "<L>") || !strings.Contains(got, "<M>") || !strings.Contains(got, "<R>") {
+		t.Errorf(`got %q, expected to see "<L>", "<M>" and "<R>"`, got)
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/extract_op.go
+++ b/vendor/cloud.google.com/go/bigquery/extract_op.go
@@ -0,0 +1,59 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+type extractOption interface {
+	customizeExtract(conf *bq.JobConfigurationExtract)
+}
+
+// DisableHeader returns an Option that disables the printing of a header row in exported data.
+func DisableHeader() Option { return disableHeader{} }
+
+type disableHeader struct{}
+
+func (opt disableHeader) implementsOption() {}
+
+func (opt disableHeader) customizeExtract(conf *bq.JobConfigurationExtract) {
+	f := false
+	conf.PrintHeader = &f
+}
+
+func (c *Client) extract(ctx context.Context, dst *GCSReference, src *Table, options []Option) (*Job, error) {
+	job, options := initJobProto(c.projectID, options)
+	payload := &bq.JobConfigurationExtract{}
+
+	dst.customizeExtractDst(payload)
+	src.customizeExtractSrc(payload)
+
+	for _, opt := range options {
+		o, ok := opt.(extractOption)
+		if !ok {
+			return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
+		}
+		o.customizeExtract(payload)
+	}
+
+	job.Configuration = &bq.JobConfiguration{
+		Extract: payload,
+	}
+	return c.service.insertJob(ctx, job, c.projectID)
+}
--- a/vendor/cloud.google.com/go/bigquery/extract_test.go
+++ b/vendor/cloud.google.com/go/bigquery/extract_test.go
@@ -0,0 +1,97 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func defaultExtractJob() *bq.Job {
+	return &bq.Job{
+		Configuration: &bq.JobConfiguration{
+			Extract: &bq.JobConfigurationExtract{
+				SourceTable: &bq.TableReference{
+					ProjectId: "project-id",
+					DatasetId: "dataset-id",
+					TableId:   "table-id",
+				},
+				DestinationUris: []string{"uri"},
+			},
+		},
+	}
+}
+
+func TestExtract(t *testing.T) {
+	testCases := []struct {
+		dst     *GCSReference
+		src     *Table
+		options []Option
+		want    *bq.Job
+	}{
+		{
+			dst:  defaultGCS,
+			src:  defaultTable(nil),
+			want: defaultExtractJob(),
+		},
+		{
+			dst: defaultGCS,
+			src: defaultTable(nil),
+			options: []Option{
+				DisableHeader(),
+			},
+			want: func() *bq.Job {
+				j := defaultExtractJob()
+				f := false
+				j.Configuration.Extract.PrintHeader = &f
+				return j
+			}(),
+		},
+		{
+			dst: &GCSReference{
+				uris:              []string{"uri"},
+				Compression:       Gzip,
+				DestinationFormat: JSON,
+				FieldDelimiter:    "\t",
+			},
+			src: defaultTable(nil),
+			want: func() *bq.Job {
+				j := defaultExtractJob()
+				j.Configuration.Extract.Compression = "GZIP"
+				j.Configuration.Extract.DestinationFormat = "NEWLINE_DELIMITED_JSON"
+				j.Configuration.Extract.FieldDelimiter = "\t"
+				return j
+			}(),
+		},
+	}
+
+	for _, tc := range testCases {
+		s := &testService{}
+		c := &Client{
+			service: s,
+		}
+		if _, err := c.Copy(context.Background(), tc.dst, tc.src, tc.options...); err != nil {
+			t.Errorf("err calling extract: %v", err)
+			continue
+		}
+		if !reflect.DeepEqual(s.Job, tc.want) {
+			t.Errorf("extracting: got:\n%v\nwant:\n%v", s.Job, tc.want)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/gcs.go
+++ b/vendor/cloud.google.com/go/bigquery/gcs.go
@@ -0,0 +1,112 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import bq "google.golang.org/api/bigquery/v2"
+
+// GCSReference is a reference to one or more Google Cloud Storage objects, which together constitute
+// an input or output to a BigQuery operation.
+type GCSReference struct {
+	uris []string
+
+	// FieldDelimiter is the separator for fields in a CSV file, used when loading or exporting data.
+	// The default is ",".
+	FieldDelimiter string
+
+	// The number of rows at the top of a CSV file that BigQuery will skip when loading the data.
+	SkipLeadingRows int64
+
+	// SourceFormat is the format of the GCS data to be loaded into BigQuery.
+	// Allowed values are: CSV, JSON, DatastoreBackup.  The default is CSV.
+	SourceFormat DataFormat
+	// Only used when loading data.
+	Encoding Encoding
+
+	// Quote is the value used to quote data sections in a CSV file.
+	// The default quotation character is the double quote ("), which is used if both Quote and ForceZeroQuote are unset.
+	// To specify that no character should be interpreted as a quotation character, set ForceZeroQuote to true.
+	// Only used when loading data.
+	Quote          string
+	ForceZeroQuote bool
+
+	// DestinationFormat is the format to use when writing exported files.
+	// Allowed values are: CSV, Avro, JSON.  The default is CSV.
+	// CSV is not supported for tables with nested or repeated fields.
+	DestinationFormat DataFormat
+	// Only used when writing data.  Default is None.
+	Compression Compression
+}
+
+func (gcs *GCSReference) implementsSource()      {}
+func (gcs *GCSReference) implementsDestination() {}
+
+// NewGCSReference constructs a reference to one or more Google Cloud Storage objects, which together constitute a data source or destination.
+// In the simple case, a single URI in the form gs://bucket/object may refer to a single GCS object.
+// Data may also be split into mutiple files, if multiple URIs or URIs containing wildcards are provided.
+// Each URI may contain one '*' wildcard character, which (if present) must come after the bucket name.
+// For more information about the treatment of wildcards and multiple URIs,
+// see https://cloud.google.com/bigquery/exporting-data-from-bigquery#exportingmultiple
+func (c *Client) NewGCSReference(uri ...string) *GCSReference {
+	return &GCSReference{uris: uri}
+}
+
+type DataFormat string
+
+const (
+	CSV             DataFormat = "CSV"
+	Avro            DataFormat = "AVRO"
+	JSON            DataFormat = "NEWLINE_DELIMITED_JSON"
+	DatastoreBackup DataFormat = "DATASTORE_BACKUP"
+)
+
+// Encoding specifies the character encoding of data to be loaded into BigQuery.
+// See https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.load.encoding
+// for more details about how this is used.
+type Encoding string
+
+const (
+	UTF_8      Encoding = "UTF-8"
+	ISO_8859_1 Encoding = "ISO-8859-1"
+)
+
+// Compression is the type of compression to apply when writing data to Google Cloud Storage.
+type Compression string
+
+const (
+	None Compression = "NONE"
+	Gzip Compression = "GZIP"
+)
+
+func (gcs *GCSReference) customizeLoadSrc(conf *bq.JobConfigurationLoad) {
+	conf.SourceUris = gcs.uris
+	conf.SkipLeadingRows = gcs.SkipLeadingRows
+	conf.SourceFormat = string(gcs.SourceFormat)
+	conf.Encoding = string(gcs.Encoding)
+	conf.FieldDelimiter = gcs.FieldDelimiter
+
+	if gcs.ForceZeroQuote {
+		quote := ""
+		conf.Quote = &quote
+	} else if gcs.Quote != "" {
+		conf.Quote = &gcs.Quote
+	}
+}
+
+func (gcs *GCSReference) customizeExtractDst(conf *bq.JobConfigurationExtract) {
+	conf.DestinationUris = gcs.uris
+	conf.Compression = string(gcs.Compression)
+	conf.DestinationFormat = string(gcs.DestinationFormat)
+	conf.FieldDelimiter = gcs.FieldDelimiter
+}
--- a/vendor/cloud.google.com/go/bigquery/integration_test.go
+++ b/vendor/cloud.google.com/go/bigquery/integration_test.go
@@ -0,0 +1,154 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/internal/testutil"
+	"golang.org/x/net/context"
+	"google.golang.org/api/googleapi"
+	"google.golang.org/api/option"
+)
+
+func TestIntegration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+
+	ctx := context.Background()
+	ts := testutil.TokenSource(ctx, Scope)
+	if ts == nil {
+		t.Skip("Integration tests skipped. See CONTRIBUTING.md for details")
+	}
+
+	projID := testutil.ProjID()
+	c, err := NewClient(ctx, projID, option.WithTokenSource(ts))
+	if err != nil {
+		t.Fatal(err)
+	}
+	ds := c.Dataset("bigquery_integration_test")
+	if err := ds.Create(ctx); err != nil && !hasStatusCode(err, http.StatusConflict) { // AlreadyExists is 409
+		t.Fatal(err)
+	}
+	schema := Schema([]*FieldSchema{
+		{Name: "name", Type: StringFieldType},
+		{Name: "num", Type: IntegerFieldType},
+	})
+	table := ds.Table("t1")
+	// Delete the table in case it already exists. (Ignore errors.)
+	table.Delete(ctx)
+	// Create the table.
+	err = table.Create(ctx, schema, TableExpiration(time.Now().Add(5*time.Minute)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Check table metadata.
+	md, err := table.Metadata(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// TODO(jba): check md more thorougly.
+	if got, want := md.ID, fmt.Sprintf("%s:%s.%s", projID, ds.id, table.TableID); got != want {
+		t.Errorf("metadata.ID: got %q, want %q", got, want)
+	}
+	if got, want := md.Type, RegularTable; got != want {
+		t.Errorf("metadata.Type: got %v, want %v", got, want)
+	}
+
+	// List tables in the dataset.
+	tables, err := ds.ListTables(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := len(tables), 1; got != want {
+		t.Fatalf("ListTables: got %d, want %d", got, want)
+	}
+	want := *table
+	if got := tables[0]; !reflect.DeepEqual(got, &want) {
+		t.Errorf("ListTables: got %v, want %v", got, &want)
+	}
+
+	// Populate the table.
+	upl := table.NewUploader()
+	var rows []*ValuesSaver
+	for i, name := range []string{"a", "b", "c"} {
+		rows = append(rows, &ValuesSaver{
+			Schema:   schema,
+			InsertID: name,
+			Row:      []Value{name, i},
+		})
+	}
+	if err := upl.Put(ctx, rows); err != nil {
+		t.Fatal(err)
+	}
+
+	checkRead := func(src ReadSource) {
+		it, err := c.Read(ctx, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for i := 0; it.Next(ctx); i++ {
+			var vals ValueList
+			if err := it.Get(&vals); err != nil {
+				t.Fatal(err)
+			}
+			if got, want := vals, rows[i].Row; !reflect.DeepEqual([]Value(got), want) {
+				t.Errorf("got %v, want %v", got, want)
+			}
+		}
+	}
+	// Read the table.
+	checkRead(table)
+
+	// Query the table.
+	q := &Query{
+		Q:                "select name, num from t1",
+		DefaultProjectID: projID,
+		DefaultDatasetID: ds.id,
+	}
+	checkRead(q)
+
+	// Query the long way.
+	dest := &Table{}
+	job1, err := c.Copy(ctx, dest, q, WriteTruncate)
+	if err != nil {
+		t.Fatal(err)
+	}
+	job2, err := c.JobFromID(ctx, job1.ID())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// TODO(jba): poll status until job is done
+	_, err = job2.Status(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	checkRead(job2)
+
+	// TODO(jba): patch the table
+}
+
+func hasStatusCode(err error, code int) bool {
+	if e, ok := err.(*googleapi.Error); ok && e.Code == code {
+		return true
+	}
+	return false
+}
--- a/vendor/cloud.google.com/go/bigquery/iterator.go
+++ b/vendor/cloud.google.com/go/bigquery/iterator.go
@@ -0,0 +1,186 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"fmt"
+
+	"golang.org/x/net/context"
+)
+
+// A pageFetcher returns a page of rows, starting from the row specified by token.
+type pageFetcher interface {
+	fetch(ctx context.Context, s service, token string) (*readDataResult, error)
+}
+
+// Iterator provides access to the result of a BigQuery lookup.
+// Next must be called before the first call to Get.
+type Iterator struct {
+	service service
+
+	err error // contains any error encountered during calls to Next.
+
+	// Once Next has been called at least once, schema has the result schema, rs contains the current
+	// page of data, and nextToken contains the token for fetching the next
+	// page (empty if there is no more data to be fetched).
+	schema    Schema
+	rs        [][]Value
+	nextToken string
+
+	// The remaining fields contain enough information to fetch the current
+	// page of data, and determine which row of data from this page is the
+	// current row.
+
+	pf        pageFetcher
+	pageToken string
+
+	// The offset from the start of the current page to the current row.
+	// For a new iterator, this is -1.
+	offset int64
+}
+
+func newIterator(s service, pf pageFetcher) *Iterator {
+	return &Iterator{
+		service: s,
+		pf:      pf,
+		offset:  -1,
+	}
+}
+
+// fetchPage loads the current page of data from the server.
+// The contents of rs and nextToken are replaced with the loaded data.
+// If there is an error while fetching, the error is stored in it.err and false is returned.
+func (it *Iterator) fetchPage(ctx context.Context) bool {
+	var res *readDataResult
+	var err error
+	for {
+		res, err = it.pf.fetch(ctx, it.service, it.pageToken)
+		if err != errIncompleteJob {
+			break
+		}
+	}
+
+	if err != nil {
+		it.err = err
+		return false
+	}
+
+	it.schema = res.schema
+	it.rs = res.rows
+	it.nextToken = res.pageToken
+	return true
+}
+
+// getEnoughData loads new data into rs until offset no longer points beyond the end of rs.
+func (it *Iterator) getEnoughData(ctx context.Context) bool {
+	if len(it.rs) == 0 {
+		// Either we have not yet fetched any pages, or we are iterating over an empty dataset.
+		// In the former case, we should fetch a page of data, so that we can depend on the resultant nextToken.
+		// In the latter case, it is harmless to fetch a page of data.
+		if !it.fetchPage(ctx) {
+			return false
+		}
+	}
+
+	for it.offset >= int64(len(it.rs)) {
+		// If offset is still outside the bounds of the loaded data,
+		// but there are no more pages of data to fetch, then we have
+		// failed to satisfy the offset.
+		if it.nextToken == "" {
+			return false
+		}
+
+		// offset cannot be satisfied with the currently loaded data,
+		// so we fetch the next page.  We no longer need the existing
+		// cached rows, so we remove them and update the offset to be
+		// relative to the new page that we're about to fetch.
+		// NOTE: we can't just set offset to 0, because after
+		// marshalling/unmarshalling, it's possible for the offset to
+		// point arbitrarily far beyond the end of rs.
+		// This can happen if the server returns a different size
+		// results page before and after marshalling.
+		it.offset -= int64(len(it.rs))
+		it.pageToken = it.nextToken
+		if !it.fetchPage(ctx) {
+			return false
+		}
+	}
+	return true
+}
+
+// Next advances the Iterator to the next row, making that row available
+// via the Get method.
+// Next must be called before the first call to Get or Schema, and blocks until data is available.
+// Next returns false when there are no more rows available, either because
+// the end of the output was reached, or because there was an error (consult
+// the Err method to determine which).
+func (it *Iterator) Next(ctx context.Context) bool {
+	if it.err != nil {
+		return false
+	}
+
+	// Advance offset to where we want it to be for the next call to Get.
+	it.offset++
+
+	// offset may now point beyond the end of rs, so we fetch data
+	// until offset is within its bounds again.  If there are no more
+	// results available, offset will be left pointing beyond the bounds
+	// of rs.
+	// At the end of this method, rs will contain at least one element
+	// unless the dataset we are iterating over is empty.
+	return it.getEnoughData(ctx)
+}
+
+// Err returns the last error encountered by Next, or nil for no error.
+func (it *Iterator) Err() error {
+	return it.err
+}
+
+// verifyState checks that the iterator is pointing to a valid row.
+func (it *Iterator) verifyState() error {
+	if it.err != nil {
+		return fmt.Errorf("called on iterator in error state: %v", it.err)
+	}
+
+	// If Next has been called, then offset should always index into a
+	// valid row in rs, as long as there is still data available.
+	if it.offset >= int64(len(it.rs)) || it.offset < 0 {
+		return errors.New("called without preceding successful call to Next")
+	}
+
+	return nil
+}
+
+// Get loads the current row into dst, which must implement ValueLoader.
+func (it *Iterator) Get(dst interface{}) error {
+	if err := it.verifyState(); err != nil {
+		return fmt.Errorf("Get %v", err)
+	}
+
+	if dst, ok := dst.(ValueLoader); ok {
+		return dst.Load(it.rs[it.offset])
+	}
+	return errors.New("Get called with unsupported argument type")
+}
+
+// Schema returns the schema of the result rows.
+func (it *Iterator) Schema() (Schema, error) {
+	if err := it.verifyState(); err != nil {
+		return nil, fmt.Errorf("Schema %v", err)
+	}
+
+	return it.schema, nil
+}
--- a/vendor/cloud.google.com/go/bigquery/iterator_test.go
+++ b/vendor/cloud.google.com/go/bigquery/iterator_test.go
@@ -0,0 +1,538 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+)
+
+type fetchResponse struct {
+	result *readDataResult // The result to return.
+	err    error           // The error to return.
+}
+
+// pageFetcherStub services fetch requests by returning data from an in-memory list of values.
+type pageFetcherStub struct {
+	fetchResponses map[string]fetchResponse
+
+	err error
+}
+
+func (pf *pageFetcherStub) fetch(ctx context.Context, s service, token string) (*readDataResult, error) {
+	call, ok := pf.fetchResponses[token]
+	if !ok {
+		pf.err = fmt.Errorf("Unexpected page token: %q", token)
+	}
+	return call.result, call.err
+}
+
+func TestIterator(t *testing.T) {
+	fetchFailure := errors.New("fetch failure")
+
+	testCases := []struct {
+		desc            string
+		alreadyConsumed int64 // amount to advance offset before commencing reading.
+		fetchResponses  map[string]fetchResponse
+		want            []ValueList
+		wantErr         error
+		wantSchema      Schema
+	}{
+		{
+			desc: "Iteration over single empty page",
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{},
+						schema:    Schema{},
+					},
+				},
+			},
+			want:       []ValueList{},
+			wantSchema: Schema{},
+		},
+		{
+			desc: "Iteration over single page",
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{1, 2}, {11, 12}},
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc: "Iteration over single page with different schema",
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{"1", 2}, {"11", 12}},
+						schema: Schema{
+							{Type: StringFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{"1", 2}, {"11", 12}},
+			wantSchema: Schema{
+				{Type: StringFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc: "Iteration over two pages",
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{1, 2}, {11, 12}, {101, 102}, {111, 112}},
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc: "Server response includes empty page",
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					result: &readDataResult{
+						pageToken: "b",
+						rows:      [][]Value{},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"b": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{1, 2}, {11, 12}, {101, 102}, {111, 112}},
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc: "Fetch error",
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					// We returns some data from this fetch, but also an error.
+					// So the end result should include only data from the previous fetch.
+					err: fetchFailure,
+					result: &readDataResult{
+						pageToken: "b",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want:    []ValueList{{1, 2}, {11, 12}},
+			wantErr: fetchFailure,
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc:            "Skip over a single element",
+			alreadyConsumed: 1,
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{11, 12}, {101, 102}, {111, 112}},
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc:            "Skip over an entire page",
+			alreadyConsumed: 2,
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{101, 102}, {111, 112}},
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc:            "Skip beyond start of second page",
+			alreadyConsumed: 3,
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			want: []ValueList{{111, 112}},
+			wantSchema: Schema{
+				{Type: IntegerFieldType},
+				{Type: IntegerFieldType},
+			},
+		},
+		{
+			desc:            "Skip beyond all data",
+			alreadyConsumed: 4,
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "a",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+				"a": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{101, 102}, {111, 112}},
+						schema: Schema{
+							{Type: IntegerFieldType},
+							{Type: IntegerFieldType},
+						},
+					},
+				},
+			},
+			// In this test case, Next will return false on its first call,
+			// so we won't even attempt to call Get.
+			want:       []ValueList{},
+			wantSchema: Schema{},
+		},
+	}
+
+	for _, tc := range testCases {
+		pf := &pageFetcherStub{
+			fetchResponses: tc.fetchResponses,
+		}
+		it := newIterator(nil, pf)
+		it.offset += tc.alreadyConsumed
+
+		values, schema, err := consumeIterator(it)
+		if err != nil {
+			t.Fatalf("%s: %v", tc.desc, err)
+		}
+
+		if (len(values) != 0 || len(tc.want) != 0) && !reflect.DeepEqual(values, tc.want) {
+			t.Errorf("%s: values:\ngot: %v\nwant:%v", tc.desc, values, tc.want)
+		}
+		if it.Err() != tc.wantErr {
+			t.Errorf("%s: iterator.Err:\ngot: %v\nwant: %v", tc.desc, it.Err(), tc.wantErr)
+		}
+		if (len(schema) != 0 || len(tc.wantSchema) != 0) && !reflect.DeepEqual(schema, tc.wantSchema) {
+			t.Errorf("%s: iterator.Schema:\ngot: %v\nwant: %v", tc.desc, schema, tc.wantSchema)
+		}
+	}
+}
+
+// consumeIterator reads the schema and all values from an iterator and returns them.
+func consumeIterator(it *Iterator) ([]ValueList, Schema, error) {
+	var got []ValueList
+	var schema Schema
+	for it.Next(context.Background()) {
+		var vals ValueList
+		var err error
+		if err = it.Get(&vals); err != nil {
+			return nil, Schema{}, fmt.Errorf("err calling Get: %v", err)
+		}
+		got = append(got, vals)
+		if schema, err = it.Schema(); err != nil {
+			return nil, Schema{}, fmt.Errorf("err calling Schema: %v", err)
+		}
+	}
+
+	return got, schema, nil
+}
+
+func TestGetBeforeNext(t *testing.T) {
+	// TODO: once mashalling/unmarshalling of iterators is implemented, do a similar test for unmarshalled iterators.
+	pf := &pageFetcherStub{
+		fetchResponses: map[string]fetchResponse{
+			"": {
+				result: &readDataResult{
+					pageToken: "",
+					rows:      [][]Value{{1, 2}, {11, 12}},
+				},
+			},
+		},
+	}
+	it := newIterator(nil, pf)
+	var vals ValueList
+	if err := it.Get(&vals); err == nil {
+		t.Errorf("Expected error calling Get before Next")
+	}
+}
+
+type delayedPageFetcher struct {
+	pageFetcherStub
+	delayCount int
+}
+
+func (pf *delayedPageFetcher) fetch(ctx context.Context, s service, token string) (*readDataResult, error) {
+	if pf.delayCount > 0 {
+		pf.delayCount--
+		return nil, errIncompleteJob
+	}
+	return pf.pageFetcherStub.fetch(ctx, s, token)
+}
+
+func TestIterateIncompleteJob(t *testing.T) {
+	want := []ValueList{{1, 2}, {11, 12}, {101, 102}, {111, 112}}
+	pf := pageFetcherStub{
+		fetchResponses: map[string]fetchResponse{
+			"": {
+				result: &readDataResult{
+					pageToken: "a",
+					rows:      [][]Value{{1, 2}, {11, 12}},
+				},
+			},
+			"a": {
+				result: &readDataResult{
+					pageToken: "",
+					rows:      [][]Value{{101, 102}, {111, 112}},
+				},
+			},
+		},
+	}
+	dpf := &delayedPageFetcher{
+		pageFetcherStub: pf,
+		delayCount:      1,
+	}
+	it := newIterator(nil, dpf)
+
+	values, _, err := consumeIterator(it)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if (len(values) != 0 || len(want) != 0) && !reflect.DeepEqual(values, want) {
+		t.Errorf("values: got:\n%v\nwant:\n%v", values, want)
+	}
+	if it.Err() != nil {
+		t.Fatalf("iterator.Err: got:\n%v", it.Err())
+	}
+	if dpf.delayCount != 0 {
+		t.Errorf("delayCount: got: %v, want: 0", dpf.delayCount)
+	}
+}
+
+func TestGetDuringErrorState(t *testing.T) {
+	pf := &pageFetcherStub{
+		fetchResponses: map[string]fetchResponse{
+			"": {err: errors.New("bang")},
+		},
+	}
+	it := newIterator(nil, pf)
+	var vals ValueList
+	it.Next(context.Background())
+	if it.Err() == nil {
+		t.Errorf("Expected error after calling Next")
+	}
+	if err := it.Get(&vals); err == nil {
+		t.Errorf("Expected error calling Get when iterator has a non-nil error.")
+	}
+}
+
+func TestGetAfterFinished(t *testing.T) {
+	testCases := []struct {
+		alreadyConsumed int64 // amount to advance offset before commencing reading.
+		fetchResponses  map[string]fetchResponse
+		want            []ValueList
+	}{
+		{
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+					},
+				},
+			},
+			want: []ValueList{{1, 2}, {11, 12}},
+		},
+		{
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{},
+					},
+				},
+			},
+			want: []ValueList{},
+		},
+		{
+			alreadyConsumed: 100,
+			fetchResponses: map[string]fetchResponse{
+				"": {
+					result: &readDataResult{
+						pageToken: "",
+						rows:      [][]Value{{1, 2}, {11, 12}},
+					},
+				},
+			},
+			want: []ValueList{},
+		},
+	}
+
+	for _, tc := range testCases {
+		pf := &pageFetcherStub{
+			fetchResponses: tc.fetchResponses,
+		}
+		it := newIterator(nil, pf)
+		it.offset += tc.alreadyConsumed
+
+		values, _, err := consumeIterator(it)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if (len(values) != 0 || len(tc.want) != 0) && !reflect.DeepEqual(values, tc.want) {
+			t.Errorf("values: got:\n%v\nwant:\n%v", values, tc.want)
+		}
+		if it.Err() != nil {
+			t.Fatalf("iterator.Err: got:\n%v\nwant:\n:nil", it.Err())
+		}
+		// Try calling Get again.
+		var vals ValueList
+		if err := it.Get(&vals); err == nil {
+			t.Errorf("Expected error calling Get when there are no more values")
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/job.go
+++ b/vendor/cloud.google.com/go/bigquery/job.go
@@ -0,0 +1,131 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+// A Job represents an operation which has been submitted to BigQuery for processing.
+type Job struct {
+	service   service
+	projectID string
+	jobID     string
+
+	isQuery bool
+}
+
+// JobFromID creates a Job which refers to an existing BigQuery job. The job
+// need not have been created by this package. For example, the job may have
+// been created in the BigQuery console.
+func (c *Client) JobFromID(ctx context.Context, id string) (*Job, error) {
+	jobType, err := c.service.getJobType(ctx, c.projectID, id)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Job{
+		service:   c.service,
+		projectID: c.projectID,
+		jobID:     id,
+		isQuery:   jobType == queryJobType,
+	}, nil
+}
+
+func (j *Job) ID() string {
+	return j.jobID
+}
+
+// State is one of a sequence of states that a Job progresses through as it is processed.
+type State int
+
+const (
+	Pending State = iota
+	Running
+	Done
+)
+
+// JobStatus contains the current State of a job, and errors encountered while processing that job.
+type JobStatus struct {
+	State State
+
+	err error
+
+	// All errors encountered during the running of the job.
+	// Not all Errors are fatal, so errors here do not necessarily mean that the job has completed or was unsuccessful.
+	Errors []*Error
+}
+
+// jobOption is an Option which modifies a bq.Job proto.
+// This is used for configuring values that apply to all operations, such as setting a jobReference.
+type jobOption interface {
+	customizeJob(job *bq.Job, projectID string)
+}
+
+type jobID string
+
+// JobID returns an Option that sets the job ID of a BigQuery job.
+// If this Option is not used, a job ID is generated automatically.
+func JobID(ID string) Option {
+	return jobID(ID)
+}
+
+func (opt jobID) implementsOption() {}
+
+func (opt jobID) customizeJob(job *bq.Job, projectID string) {
+	job.JobReference = &bq.JobReference{
+		JobId:     string(opt),
+		ProjectId: projectID,
+	}
+}
+
+// Done reports whether the job has completed.
+// After Done returns true, the Err method will return an error if the job completed unsuccesfully.
+func (s *JobStatus) Done() bool {
+	return s.State == Done
+}
+
+// Err returns the error that caused the job to complete unsuccesfully (if any).
+func (s *JobStatus) Err() error {
+	return s.err
+}
+
+// Status returns the current status of the job. It fails if the Status could not be determined.
+func (j *Job) Status(ctx context.Context) (*JobStatus, error) {
+	return j.service.jobStatus(ctx, j.projectID, j.jobID)
+}
+
+// Cancel requests that a job be cancelled. This method returns without waiting for
+// cancellation to take effect. To check whether the job has terminated, use Job.Status.
+// Cancelled jobs may still incur costs.
+func (j *Job) Cancel(ctx context.Context) error {
+	return j.service.jobCancel(ctx, j.projectID, j.jobID)
+}
+
+func (j *Job) implementsReadSource() {}
+
+func (j *Job) customizeReadQuery(cursor *readQueryConf) error {
+	// There are mulitple kinds of jobs, but only a query job is suitable for reading.
+	if !j.isQuery {
+		return errors.New("Cannot read from a non-query job")
+	}
+
+	cursor.projectID = j.projectID
+	cursor.jobID = j.jobID
+	return nil
+}
--- a/vendor/cloud.google.com/go/bigquery/legacy.go
+++ b/vendor/cloud.google.com/go/bigquery/legacy.go
@@ -0,0 +1,70 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+
+	"golang.org/x/net/context"
+)
+
+// OpenTable creates a handle to an existing BigQuery table. If the table does
+// not already exist, subsequent uses of the *Table will fail.
+//
+// Deprecated: use Client.DatasetInProject.Table instead.
+func (c *Client) OpenTable(projectID, datasetID, tableID string) *Table {
+	return c.Table(projectID, datasetID, tableID)
+}
+
+// Table creates a handle to a BigQuery table.
+//
+// Use this method to reference a table in a project other than that of the
+// Client.
+//
+// Deprecated: use Client.DatasetInProject.Table instead.
+func (c *Client) Table(projectID, datasetID, tableID string) *Table {
+	return &Table{ProjectID: projectID, DatasetID: datasetID, TableID: tableID, service: c.service}
+}
+
+// CreateTable creates a table in the BigQuery service and returns a handle to it.
+//
+// Deprecated: use Table.Create instead.
+func (c *Client) CreateTable(ctx context.Context, projectID, datasetID, tableID string, options ...CreateTableOption) (*Table, error) {
+	t := c.Table(projectID, datasetID, tableID)
+	if err := t.Create(ctx, options...); err != nil {
+		return nil, err
+	}
+	return t, nil
+}
+
+// Read fetches data from a ReadSource and returns the data via an Iterator.
+//
+// Deprecated: use Query.Read, Job.Read or Table.Read instead.
+func (c *Client) Read(ctx context.Context, src ReadSource, options ...ReadOption) (*Iterator, error) {
+	switch src := src.(type) {
+	case *Job:
+		return src.Read(ctx, options...)
+	case *Query:
+		// For compatibility, support Query values created by literal, rather
+		// than Client.Query.
+		if src.client == nil {
+			src.client = c
+		}
+		return src.Read(ctx, options...)
+	case *Table:
+		return src.Read(ctx, options...)
+	}
+	return nil, fmt.Errorf("src (%T) does not support the Read operation", src)
+}
--- a/vendor/cloud.google.com/go/bigquery/load_op.go
+++ b/vendor/cloud.google.com/go/bigquery/load_op.go
@@ -0,0 +1,112 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+type loadOption interface {
+	customizeLoad(conf *bq.JobConfigurationLoad)
+}
+
+// DestinationSchema returns an Option that specifies the schema to use when loading data into a new table.
+// A DestinationSchema Option must be supplied when loading data from Google Cloud Storage into a non-existent table.
+// Caveat: DestinationSchema is not required if the data being loaded is a datastore backup.
+// schema must not be nil.
+func DestinationSchema(schema Schema) Option { return destSchema{Schema: schema} }
+
+type destSchema struct {
+	Schema
+}
+
+func (opt destSchema) implementsOption() {}
+
+func (opt destSchema) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.Schema = opt.asTableSchema()
+}
+
+// MaxBadRecords returns an Option that sets the maximum number of bad records that will be ignored.
+// If this maximum is exceeded, the operation will be unsuccessful.
+func MaxBadRecords(n int64) Option { return maxBadRecords(n) }
+
+type maxBadRecords int64
+
+func (opt maxBadRecords) implementsOption() {}
+
+func (opt maxBadRecords) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.MaxBadRecords = int64(opt)
+}
+
+// AllowJaggedRows returns an Option that causes missing trailing optional columns to be tolerated in CSV data.  Missing values are treated as nulls.
+func AllowJaggedRows() Option { return allowJaggedRows{} }
+
+type allowJaggedRows struct{}
+
+func (opt allowJaggedRows) implementsOption() {}
+
+func (opt allowJaggedRows) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.AllowJaggedRows = true
+}
+
+// AllowQuotedNewlines returns an Option that allows quoted data sections containing newlines in CSV data.
+func AllowQuotedNewlines() Option { return allowQuotedNewlines{} }
+
+type allowQuotedNewlines struct{}
+
+func (opt allowQuotedNewlines) implementsOption() {}
+
+func (opt allowQuotedNewlines) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.AllowQuotedNewlines = true
+}
+
+// IgnoreUnknownValues returns an Option that causes values not matching the schema to be tolerated.
+// Unknown values are ignored. For CSV this ignores extra values at the end of a line.
+// For JSON this ignores named values that do not match any column name.
+// If this Option is not used, records containing unknown values are treated as bad records.
+// The MaxBadRecords Option can be used to customize how bad records are handled.
+func IgnoreUnknownValues() Option { return ignoreUnknownValues{} }
+
+type ignoreUnknownValues struct{}
+
+func (opt ignoreUnknownValues) implementsOption() {}
+
+func (opt ignoreUnknownValues) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.IgnoreUnknownValues = true
+}
+
+func (c *Client) load(ctx context.Context, dst *Table, src *GCSReference, options []Option) (*Job, error) {
+	job, options := initJobProto(c.projectID, options)
+	payload := &bq.JobConfigurationLoad{}
+
+	dst.customizeLoadDst(payload)
+	src.customizeLoadSrc(payload)
+
+	for _, opt := range options {
+		o, ok := opt.(loadOption)
+		if !ok {
+			return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
+		}
+		o.customizeLoad(payload)
+	}
+
+	job.Configuration = &bq.JobConfiguration{
+		Load: payload,
+	}
+	return c.service.insertJob(ctx, job, c.projectID)
+}
--- a/vendor/cloud.google.com/go/bigquery/load_test.go
+++ b/vendor/cloud.google.com/go/bigquery/load_test.go
@@ -0,0 +1,198 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func defaultLoadJob() *bq.Job {
+	return &bq.Job{
+		Configuration: &bq.JobConfiguration{
+			Load: &bq.JobConfigurationLoad{
+				DestinationTable: &bq.TableReference{
+					ProjectId: "project-id",
+					DatasetId: "dataset-id",
+					TableId:   "table-id",
+				},
+				SourceUris: []string{"uri"},
+			},
+		},
+	}
+}
+
+func stringFieldSchema() *FieldSchema {
+	return &FieldSchema{Name: "fieldname", Type: StringFieldType}
+}
+
+func nestedFieldSchema() *FieldSchema {
+	return &FieldSchema{
+		Name:   "nested",
+		Type:   RecordFieldType,
+		Schema: Schema{stringFieldSchema()},
+	}
+}
+
+func bqStringFieldSchema() *bq.TableFieldSchema {
+	return &bq.TableFieldSchema{
+		Name: "fieldname",
+		Type: "STRING",
+	}
+}
+
+func bqNestedFieldSchema() *bq.TableFieldSchema {
+	return &bq.TableFieldSchema{
+		Name:   "nested",
+		Type:   "RECORD",
+		Fields: []*bq.TableFieldSchema{bqStringFieldSchema()},
+	}
+}
+
+func TestLoad(t *testing.T) {
+	testCases := []struct {
+		dst     *Table
+		src     *GCSReference
+		options []Option
+		want    *bq.Job
+	}{
+		{
+			dst:  defaultTable(nil),
+			src:  defaultGCS,
+			want: defaultLoadJob(),
+		},
+		{
+			dst: defaultTable(nil),
+			src: defaultGCS,
+			options: []Option{
+				MaxBadRecords(1),
+				AllowJaggedRows(),
+				AllowQuotedNewlines(),
+				IgnoreUnknownValues(),
+			},
+			want: func() *bq.Job {
+				j := defaultLoadJob()
+				j.Configuration.Load.MaxBadRecords = 1
+				j.Configuration.Load.AllowJaggedRows = true
+				j.Configuration.Load.AllowQuotedNewlines = true
+				j.Configuration.Load.IgnoreUnknownValues = true
+				return j
+			}(),
+		},
+		{
+			dst: &Table{
+				ProjectID: "project-id",
+				DatasetID: "dataset-id",
+				TableID:   "table-id",
+			},
+			options: []Option{CreateNever, WriteTruncate},
+			src:     defaultGCS,
+			want: func() *bq.Job {
+				j := defaultLoadJob()
+				j.Configuration.Load.CreateDisposition = "CREATE_NEVER"
+				j.Configuration.Load.WriteDisposition = "WRITE_TRUNCATE"
+				return j
+			}(),
+		},
+		{
+			dst: &Table{
+				ProjectID: "project-id",
+				DatasetID: "dataset-id",
+				TableID:   "table-id",
+			},
+			src: defaultGCS,
+			options: []Option{
+				DestinationSchema(Schema{
+					stringFieldSchema(),
+					nestedFieldSchema(),
+				}),
+			},
+			want: func() *bq.Job {
+				j := defaultLoadJob()
+				j.Configuration.Load.Schema = &bq.TableSchema{
+					Fields: []*bq.TableFieldSchema{
+						bqStringFieldSchema(),
+						bqNestedFieldSchema(),
+					}}
+				return j
+			}(),
+		},
+		{
+			dst: defaultTable(nil),
+			src: &GCSReference{
+				uris:            []string{"uri"},
+				SkipLeadingRows: 1,
+				SourceFormat:    JSON,
+				Encoding:        UTF_8,
+				FieldDelimiter:  "\t",
+				Quote:           "-",
+			},
+			want: func() *bq.Job {
+				j := defaultLoadJob()
+				j.Configuration.Load.SkipLeadingRows = 1
+				j.Configuration.Load.SourceFormat = "NEWLINE_DELIMITED_JSON"
+				j.Configuration.Load.Encoding = "UTF-8"
+				j.Configuration.Load.FieldDelimiter = "\t"
+				hyphen := "-"
+				j.Configuration.Load.Quote = &hyphen
+				return j
+			}(),
+		},
+		{
+			dst: defaultTable(nil),
+			src: &GCSReference{
+				uris:  []string{"uri"},
+				Quote: "",
+			},
+			want: func() *bq.Job {
+				j := defaultLoadJob()
+				j.Configuration.Load.Quote = nil
+				return j
+			}(),
+		},
+		{
+			dst: defaultTable(nil),
+			src: &GCSReference{
+				uris:           []string{"uri"},
+				Quote:          "",
+				ForceZeroQuote: true,
+			},
+			want: func() *bq.Job {
+				j := defaultLoadJob()
+				empty := ""
+				j.Configuration.Load.Quote = &empty
+				return j
+			}(),
+		},
+	}
+
+	for _, tc := range testCases {
+		s := &testService{}
+		c := &Client{
+			service: s,
+		}
+		if _, err := c.Copy(context.Background(), tc.dst, tc.src, tc.options...); err != nil {
+			t.Errorf("err calling load: %v", err)
+			continue
+		}
+		if !reflect.DeepEqual(s.Job, tc.want) {
+			t.Errorf("loading: got:\n%v\nwant:\n%v", s.Job, tc.want)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/query.go
+++ b/vendor/cloud.google.com/go/bigquery/query.go
@@ -0,0 +1,44 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import bq "google.golang.org/api/bigquery/v2"
+
+// Query represents a query to be executed. Use Client.Query to create a query.
+type Query struct {
+	// The query to execute. See https://cloud.google.com/bigquery/query-reference for details.
+	Q string
+
+	// DefaultProjectID and DefaultDatasetID specify the dataset to use for unqualified table names in the query.
+	// If DefaultProjectID is set, DefaultDatasetID must also be set.
+	DefaultProjectID string
+	DefaultDatasetID string
+
+	client *Client
+}
+
+func (q *Query) implementsSource() {}
+
+func (q *Query) implementsReadSource() {}
+
+func (q *Query) customizeQuerySrc(conf *bq.JobConfigurationQuery) {
+	conf.Query = q.Q
+	if q.DefaultProjectID != "" || q.DefaultDatasetID != "" {
+		conf.DefaultDataset = &bq.DatasetReference{
+			DatasetId: q.DefaultDatasetID,
+			ProjectId: q.DefaultProjectID,
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/query_op.go
+++ b/vendor/cloud.google.com/go/bigquery/query_op.go
@@ -0,0 +1,148 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+type queryOption interface {
+	customizeQuery(conf *bq.JobConfigurationQuery)
+}
+
+// DisableQueryCache returns an Option that prevents results being fetched from the query cache.
+// If this Option is not used, results are fetched from the cache if they are available.
+// The query cache is a best-effort cache that is flushed whenever tables in the query are modified.
+// Cached results are only available when TableID is unspecified in the query's destination Table.
+// For more information, see https://cloud.google.com/bigquery/querying-data#querycaching
+func DisableQueryCache() Option { return disableQueryCache{} }
+
+type disableQueryCache struct{}
+
+func (opt disableQueryCache) implementsOption() {}
+
+func (opt disableQueryCache) customizeQuery(conf *bq.JobConfigurationQuery) {
+	f := false
+	conf.UseQueryCache = &f
+}
+
+// DisableFlattenedResults returns an Option that prevents results being flattened.
+// If this Option is not used, results from nested and repeated fields are flattened.
+// DisableFlattenedResults implies AllowLargeResults
+// For more information, see https://cloud.google.com/bigquery/docs/data#nested
+func DisableFlattenedResults() Option { return disableFlattenedResults{} }
+
+type disableFlattenedResults struct{}
+
+func (opt disableFlattenedResults) implementsOption() {}
+
+func (opt disableFlattenedResults) customizeQuery(conf *bq.JobConfigurationQuery) {
+	f := false
+	conf.FlattenResults = &f
+	// DisableFlattenedResults implies AllowLargeResults
+	allowLargeResults{}.customizeQuery(conf)
+}
+
+// AllowLargeResults returns an Option that allows the query to produce arbitrarily large result tables.
+// The destination must be a table.
+// When using this option, queries will take longer to execute, even if the result set is small.
+// For additional limitations, see https://cloud.google.com/bigquery/querying-data#largequeryresults
+func AllowLargeResults() Option { return allowLargeResults{} }
+
+type allowLargeResults struct{}
+
+func (opt allowLargeResults) implementsOption() {}
+
+func (opt allowLargeResults) customizeQuery(conf *bq.JobConfigurationQuery) {
+	conf.AllowLargeResults = true
+}
+
+// JobPriority returns an Option that causes a query to be scheduled with the specified priority.
+// The default priority is InteractivePriority.
+// For more information, see https://cloud.google.com/bigquery/querying-data#batchqueries
+func JobPriority(priority string) Option { return jobPriority(priority) }
+
+type jobPriority string
+
+func (opt jobPriority) implementsOption() {}
+
+func (opt jobPriority) customizeQuery(conf *bq.JobConfigurationQuery) {
+	conf.Priority = string(opt)
+}
+
+const (
+	BatchPriority       = "BATCH"
+	InteractivePriority = "INTERACTIVE"
+)
+
+// MaxBillingTier returns an Option that sets the maximum billing tier for a Query.
+// Queries that have resource usage beyond this tier will fail (without
+// incurring a charge). If this Option is not used, the project default will be used.
+func MaxBillingTier(tier int) Option { return maxBillingTier(tier) }
+
+type maxBillingTier int
+
+func (opt maxBillingTier) implementsOption() {}
+
+func (opt maxBillingTier) customizeQuery(conf *bq.JobConfigurationQuery) {
+	tier := int64(opt)
+	conf.MaximumBillingTier = &tier
+}
+
+// MaxBytesBilled returns an Option that limits the number of bytes billed for
+// this job.  Queries that would exceed this limit will fail (without incurring
+// a charge).
+// If this Option is not used, or bytes is < 1, the project default will be
+// used.
+func MaxBytesBilled(bytes int64) Option { return maxBytesBilled(bytes) }
+
+type maxBytesBilled int64
+
+func (opt maxBytesBilled) implementsOption() {}
+
+func (opt maxBytesBilled) customizeQuery(conf *bq.JobConfigurationQuery) {
+	if opt >= 1 {
+		conf.MaximumBytesBilled = int64(opt)
+	}
+}
+
+func (c *Client) query(ctx context.Context, dst *Table, src *Query, options []Option) (*Job, error) {
+	job, options := initJobProto(c.projectID, options)
+	payload := &bq.JobConfigurationQuery{}
+
+	dst.customizeQueryDst(payload)
+	src.customizeQuerySrc(payload)
+
+	for _, opt := range options {
+		o, ok := opt.(queryOption)
+		if !ok {
+			return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
+		}
+		o.customizeQuery(payload)
+	}
+
+	job.Configuration = &bq.JobConfiguration{
+		Query: payload,
+	}
+	j, err := c.service.insertJob(ctx, job, c.projectID)
+	if err != nil {
+		return nil, err
+	}
+	j.isQuery = true
+	return j, nil
+}
--- a/vendor/cloud.google.com/go/bigquery/query_test.go
+++ b/vendor/cloud.google.com/go/bigquery/query_test.go
@@ -0,0 +1,168 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func defaultQueryJob() *bq.Job {
+	return &bq.Job{
+		Configuration: &bq.JobConfiguration{
+			Query: &bq.JobConfigurationQuery{
+				DestinationTable: &bq.TableReference{
+					ProjectId: "project-id",
+					DatasetId: "dataset-id",
+					TableId:   "table-id",
+				},
+				Query: "query string",
+				DefaultDataset: &bq.DatasetReference{
+					ProjectId: "def-project-id",
+					DatasetId: "def-dataset-id",
+				},
+			},
+		},
+	}
+}
+
+func TestQuery(t *testing.T) {
+	testCases := []struct {
+		dst     *Table
+		src     *Query
+		options []Option
+		want    *bq.Job
+	}{
+		{
+			dst:  defaultTable(nil),
+			src:  defaultQuery,
+			want: defaultQueryJob(),
+		},
+		{
+			dst: defaultTable(nil),
+			src: &Query{
+				Q: "query string",
+			},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				j.Configuration.Query.DefaultDataset = nil
+				return j
+			}(),
+		},
+		{
+			dst: &Table{},
+			src: defaultQuery,
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				j.Configuration.Query.DestinationTable = nil
+				return j
+			}(),
+		},
+		{
+			dst: &Table{
+				ProjectID: "project-id",
+				DatasetID: "dataset-id",
+				TableID:   "table-id",
+			},
+			src:     defaultQuery,
+			options: []Option{CreateNever, WriteTruncate},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				j.Configuration.Query.WriteDisposition = "WRITE_TRUNCATE"
+				j.Configuration.Query.CreateDisposition = "CREATE_NEVER"
+				return j
+			}(),
+		},
+		{
+			dst:     defaultTable(nil),
+			src:     defaultQuery,
+			options: []Option{DisableQueryCache()},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				f := false
+				j.Configuration.Query.UseQueryCache = &f
+				return j
+			}(),
+		},
+		{
+			dst:     defaultTable(nil),
+			src:     defaultQuery,
+			options: []Option{AllowLargeResults()},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				j.Configuration.Query.AllowLargeResults = true
+				return j
+			}(),
+		},
+		{
+			dst:     defaultTable(nil),
+			src:     defaultQuery,
+			options: []Option{DisableFlattenedResults()},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				f := false
+				j.Configuration.Query.FlattenResults = &f
+				j.Configuration.Query.AllowLargeResults = true
+				return j
+			}(),
+		},
+		{
+			dst:     defaultTable(nil),
+			src:     defaultQuery,
+			options: []Option{JobPriority("low")},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				j.Configuration.Query.Priority = "low"
+				return j
+			}(),
+		},
+		{
+			dst:     defaultTable(nil),
+			src:     defaultQuery,
+			options: []Option{MaxBillingTier(3), MaxBytesBilled(5)},
+			want: func() *bq.Job {
+				j := defaultQueryJob()
+				tier := int64(3)
+				j.Configuration.Query.MaximumBillingTier = &tier
+				j.Configuration.Query.MaximumBytesBilled = 5
+				return j
+			}(),
+		},
+		{
+			dst:     defaultTable(nil),
+			src:     defaultQuery,
+			options: []Option{MaxBytesBilled(-1)},
+			want:    defaultQueryJob(),
+		},
+	}
+
+	for _, tc := range testCases {
+		s := &testService{}
+		c := &Client{
+			service: s,
+		}
+		if _, err := c.Copy(context.Background(), tc.dst, tc.src, tc.options...); err != nil {
+			t.Errorf("err calling query: %v", err)
+			continue
+		}
+		if !reflect.DeepEqual(s.Job, tc.want) {
+			t.Errorf("querying: got:\n%v\nwant:\n%v", s.Job, tc.want)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/read_op.go
+++ b/vendor/cloud.google.com/go/bigquery/read_op.go
@@ -0,0 +1,70 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import "golang.org/x/net/context"
+
+// RecordsPerRequest returns a ReadOption that sets the number of records to fetch per request when streaming data from BigQuery.
+func RecordsPerRequest(n int64) ReadOption { return recordsPerRequest(n) }
+
+type recordsPerRequest int64
+
+func (opt recordsPerRequest) customizeRead(conf *pagingConf) {
+	conf.recordsPerRequest = int64(opt)
+	conf.setRecordsPerRequest = true
+}
+
+// StartIndex returns a ReadOption that sets the zero-based index of the row to start reading from.
+func StartIndex(i uint64) ReadOption { return startIndex(i) }
+
+type startIndex uint64
+
+func (opt startIndex) customizeRead(conf *pagingConf) {
+	conf.startIndex = uint64(opt)
+}
+
+func (conf *readTableConf) fetch(ctx context.Context, s service, token string) (*readDataResult, error) {
+	return s.readTabledata(ctx, conf, token)
+}
+
+// Read fetches the contents of the table.
+func (t *Table) Read(_ context.Context, options ...ReadOption) (*Iterator, error) {
+	conf := &readTableConf{}
+	t.customizeReadSrc(conf)
+
+	for _, o := range options {
+		o.customizeRead(&conf.paging)
+	}
+
+	return newIterator(t.service, conf), nil
+}
+
+func (conf *readQueryConf) fetch(ctx context.Context, s service, token string) (*readDataResult, error) {
+	return s.readQuery(ctx, conf, token)
+}
+
+// Read fetches the results of a query job.
+func (j *Job) Read(_ context.Context, options ...ReadOption) (*Iterator, error) {
+	conf := &readQueryConf{}
+	if err := j.customizeReadQuery(conf); err != nil {
+		return nil, err
+	}
+
+	for _, o := range options {
+		o.customizeRead(&conf.paging)
+	}
+
+	return newIterator(j.service, conf), nil
+}
--- a/vendor/cloud.google.com/go/bigquery/read_test.go
+++ b/vendor/cloud.google.com/go/bigquery/read_test.go
@@ -0,0 +1,308 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+)
+
+type readTabledataArgs struct {
+	conf *readTableConf
+	tok  string
+}
+
+type readQueryArgs struct {
+	conf *readQueryConf
+	tok  string
+}
+
+// readServiceStub services read requests by returning data from an in-memory list of values.
+type readServiceStub struct {
+	// values and pageTokens are used as sources of data to return in response to calls to readTabledata or readQuery.
+	values     [][][]Value       // contains pages / rows / columns.
+	pageTokens map[string]string // maps incoming page token to returned page token.
+
+	// arguments are recorded for later inspection.
+	readTabledataCalls []readTabledataArgs
+	readQueryCalls     []readQueryArgs
+
+	service
+}
+
+func (s *readServiceStub) readValues(tok string) *readDataResult {
+	result := &readDataResult{
+		pageToken: s.pageTokens[tok],
+		rows:      s.values[0],
+	}
+	s.values = s.values[1:]
+
+	return result
+}
+func (s *readServiceStub) readTabledata(ctx context.Context, conf *readTableConf, token string) (*readDataResult, error) {
+	s.readTabledataCalls = append(s.readTabledataCalls, readTabledataArgs{conf, token})
+	return s.readValues(token), nil
+}
+
+func (s *readServiceStub) readQuery(ctx context.Context, conf *readQueryConf, token string) (*readDataResult, error) {
+	s.readQueryCalls = append(s.readQueryCalls, readQueryArgs{conf, token})
+	return s.readValues(token), nil
+}
+
+func TestRead(t *testing.T) {
+	// The data for the service stub to return is populated for each test case in the testCases for loop.
+	service := &readServiceStub{}
+	c := &Client{
+		service: service,
+	}
+
+	queryJob := &Job{
+		projectID: "project-id",
+		jobID:     "job-id",
+		service:   service,
+		isQuery:   true,
+	}
+
+	for _, src := range []ReadSource{defaultTable(service), queryJob} {
+		testCases := []struct {
+			data       [][][]Value
+			pageTokens map[string]string
+			want       []ValueList
+		}{
+			{
+				data:       [][][]Value{{{1, 2}, {11, 12}}, {{30, 40}, {31, 41}}},
+				pageTokens: map[string]string{"": "a", "a": ""},
+				want:       []ValueList{{1, 2}, {11, 12}, {30, 40}, {31, 41}},
+			},
+			{
+				data:       [][][]Value{{{1, 2}, {11, 12}}, {{30, 40}, {31, 41}}},
+				pageTokens: map[string]string{"": ""}, // no more pages after first one.
+				want:       []ValueList{{1, 2}, {11, 12}},
+			},
+		}
+
+		for _, tc := range testCases {
+			service.values = tc.data
+			service.pageTokens = tc.pageTokens
+			if got, ok := doRead(t, c, src); ok {
+				if !reflect.DeepEqual(got, tc.want) {
+					t.Errorf("reading: got:\n%v\nwant:\n%v", got, tc.want)
+				}
+			}
+		}
+	}
+}
+
+// doRead calls Read with a ReadSource. Get is repeatedly called on the Iterator returned by Read and the results are returned.
+func doRead(t *testing.T, c *Client, src ReadSource) ([]ValueList, bool) {
+	it, err := c.Read(context.Background(), src)
+	if err != nil {
+		t.Errorf("err calling Read: %v", err)
+		return nil, false
+	}
+	var got []ValueList
+	for it.Next(context.Background()) {
+		var vals ValueList
+		if err := it.Get(&vals); err != nil {
+			t.Errorf("err calling Get: %v", err)
+			return nil, false
+		} else {
+			got = append(got, vals)
+		}
+	}
+
+	return got, true
+}
+
+func TestNoMoreValues(t *testing.T) {
+	c := &Client{
+		service: &readServiceStub{
+			values: [][][]Value{{{1, 2}, {11, 12}}},
+		},
+	}
+	it, err := c.Read(context.Background(), defaultTable(c.service))
+	if err != nil {
+		t.Fatalf("err calling Read: %v", err)
+	}
+	var vals ValueList
+	// We expect to retrieve two values and then fail on the next attempt.
+	if !it.Next(context.Background()) {
+		t.Fatalf("Next: got: false: want: true")
+	}
+	if !it.Next(context.Background()) {
+		t.Fatalf("Next: got: false: want: true")
+	}
+	if err := it.Get(&vals); err != nil {
+		t.Fatalf("Get: got: %v: want: nil", err)
+	}
+	if it.Next(context.Background()) {
+		t.Fatalf("Next: got: true: want: false")
+	}
+	if err := it.Get(&vals); err == nil {
+		t.Fatalf("Get: got: %v: want: non-nil", err)
+	}
+}
+
+// delayedReadStub simulates reading results from a query that has not yet
+// completed. Its readQuery method initially reports that the query job is not
+// yet complete. Subsequently, it proxies the request through to another
+// service stub.
+type delayedReadStub struct {
+	numDelays int
+
+	readServiceStub
+}
+
+func (s *delayedReadStub) readQuery(ctx context.Context, conf *readQueryConf, token string) (*readDataResult, error) {
+	if s.numDelays > 0 {
+		s.numDelays--
+		return nil, errIncompleteJob
+	}
+	return s.readServiceStub.readQuery(ctx, conf, token)
+}
+
+// TestIncompleteJob tests that an Iterator which reads from a query job will block until the job is complete.
+func TestIncompleteJob(t *testing.T) {
+	service := &delayedReadStub{
+		numDelays: 2,
+		readServiceStub: readServiceStub{
+			values: [][][]Value{{{1, 2}}},
+		},
+	}
+	c := &Client{service: service}
+	queryJob := &Job{
+		projectID: "project-id",
+		jobID:     "job-id",
+		service:   service,
+		isQuery:   true,
+	}
+	it, err := c.Read(context.Background(), queryJob)
+	if err != nil {
+		t.Fatalf("err calling Read: %v", err)
+	}
+	var got ValueList
+	want := ValueList{1, 2}
+	if !it.Next(context.Background()) {
+		t.Fatalf("Next: got: false: want: true")
+	}
+	if err := it.Get(&got); err != nil {
+		t.Fatalf("Error calling Get: %v", err)
+	}
+	if service.numDelays != 0 {
+		t.Errorf("remaining numDelays : got: %v want:0", service.numDelays)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("reading: got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+type errorReadService struct {
+	service
+}
+
+func (s *errorReadService) readTabledata(ctx context.Context, conf *readTableConf, token string) (*readDataResult, error) {
+	return nil, errors.New("bang!")
+}
+
+func TestReadError(t *testing.T) {
+	// test that service read errors are propagated back to the caller.
+	c := &Client{service: &errorReadService{}}
+	it, err := c.Read(context.Background(), defaultTable(c.service))
+	if err != nil {
+		// Read should not return an error; only Err should.
+		t.Fatalf("err calling Read: %v", err)
+	}
+	if it.Next(context.Background()) {
+		t.Fatalf("Next: got: true: want: false")
+	}
+	if err := it.Err(); err.Error() != "bang!" {
+		t.Fatalf("Get: got: %v: want: bang!", err)
+	}
+}
+
+func TestReadTabledataOptions(t *testing.T) {
+	// test that read options are propagated.
+	s := &readServiceStub{
+		values: [][][]Value{{{1, 2}}},
+	}
+	c := &Client{service: s}
+	it, err := c.Read(context.Background(), defaultTable(s), RecordsPerRequest(5))
+
+	if err != nil {
+		t.Fatalf("err calling Read: %v", err)
+	}
+	if !it.Next(context.Background()) {
+		t.Fatalf("Next: got: false: want: true")
+	}
+
+	want := []readTabledataArgs{{
+		conf: &readTableConf{
+			projectID: "project-id",
+			datasetID: "dataset-id",
+			tableID:   "table-id",
+			paging: pagingConf{
+				recordsPerRequest:    5,
+				setRecordsPerRequest: true,
+			},
+		},
+		tok: "",
+	}}
+
+	if !reflect.DeepEqual(s.readTabledataCalls, want) {
+		t.Errorf("reading: got:\n%v\nwant:\n%v", s.readTabledataCalls, want)
+	}
+}
+
+func TestReadQueryOptions(t *testing.T) {
+	// test that read options are propagated.
+	s := &readServiceStub{
+		values: [][][]Value{{{1, 2}}},
+	}
+	c := &Client{service: s}
+
+	queryJob := &Job{
+		projectID: "project-id",
+		jobID:     "job-id",
+		service:   s,
+		isQuery:   true,
+	}
+	it, err := c.Read(context.Background(), queryJob, RecordsPerRequest(5))
+
+	if err != nil {
+		t.Fatalf("err calling Read: %v", err)
+	}
+	if !it.Next(context.Background()) {
+		t.Fatalf("Next: got: false: want: true")
+	}
+
+	want := []readQueryArgs{{
+		conf: &readQueryConf{
+			projectID: "project-id",
+			jobID:     "job-id",
+			paging: pagingConf{
+				recordsPerRequest:    5,
+				setRecordsPerRequest: true,
+			},
+		},
+		tok: "",
+	}}
+
+	if !reflect.DeepEqual(s.readQueryCalls, want) {
+		t.Errorf("reading: got:\n%v\nwant:\n%v", s.readQueryCalls, want)
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/schema.go
+++ b/vendor/cloud.google.com/go/bigquery/schema.go
@@ -0,0 +1,233 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"reflect"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+// Schema describes the fields in a table or query result.
+type Schema []*FieldSchema
+
+type FieldSchema struct {
+	// The field name.
+	// Must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_),
+	// and must start with a letter or underscore.
+	// The maximum length is 128 characters.
+	Name string
+
+	// A description of the field. The maximum length is 16,384 characters.
+	Description string
+
+	// Whether the field may contain multiple values.
+	Repeated bool
+	// Whether the field is required.  Ignored if Repeated is true.
+	Required bool
+
+	// The field data type.  If Type is Record, then this field contains a nested schema,
+	// which is described by Schema.
+	Type FieldType
+	// Describes the nested schema if Type is set to Record.
+	Schema Schema
+}
+
+func (fs *FieldSchema) asTableFieldSchema() *bq.TableFieldSchema {
+	tfs := &bq.TableFieldSchema{
+		Description: fs.Description,
+		Name:        fs.Name,
+		Type:        string(fs.Type),
+	}
+
+	if fs.Repeated {
+		tfs.Mode = "REPEATED"
+	} else if fs.Required {
+		tfs.Mode = "REQUIRED"
+	} // else leave as default, which is interpreted as NULLABLE.
+
+	for _, f := range fs.Schema {
+		tfs.Fields = append(tfs.Fields, f.asTableFieldSchema())
+	}
+
+	return tfs
+}
+
+func (s Schema) asTableSchema() *bq.TableSchema {
+	var fields []*bq.TableFieldSchema
+	for _, f := range s {
+		fields = append(fields, f.asTableFieldSchema())
+	}
+	return &bq.TableSchema{Fields: fields}
+}
+
+// customizeCreateTable allows a Schema to be used directly as an option to CreateTable.
+func (s Schema) customizeCreateTable(conf *createTableConf) {
+	conf.schema = s.asTableSchema()
+}
+
+func convertTableFieldSchema(tfs *bq.TableFieldSchema) *FieldSchema {
+	fs := &FieldSchema{
+		Description: tfs.Description,
+		Name:        tfs.Name,
+		Repeated:    tfs.Mode == "REPEATED",
+		Required:    tfs.Mode == "REQUIRED",
+		Type:        FieldType(tfs.Type),
+	}
+
+	for _, f := range tfs.Fields {
+		fs.Schema = append(fs.Schema, convertTableFieldSchema(f))
+	}
+	return fs
+}
+
+func convertTableSchema(ts *bq.TableSchema) Schema {
+	var s Schema
+	for _, f := range ts.Fields {
+		s = append(s, convertTableFieldSchema(f))
+	}
+	return s
+}
+
+type FieldType string
+
+const (
+	StringFieldType    FieldType = "STRING"
+	IntegerFieldType   FieldType = "INTEGER"
+	FloatFieldType     FieldType = "FLOAT"
+	BooleanFieldType   FieldType = "BOOLEAN"
+	TimestampFieldType FieldType = "TIMESTAMP"
+	RecordFieldType    FieldType = "RECORD"
+)
+
+var errNoStruct = errors.New("bigquery: can only infer schema from struct or pointer to struct")
+var errUnsupportedFieldType = errors.New("bigquery: unsupported type of field in struct")
+
+// InferSchema tries to derive a BigQuery schema from the supplied struct value.
+// NOTE: All fields in the returned Schema are configured to be required,
+// unless the corresponding field in the supplied struct is a slice or array.
+// It is considered an error if the struct (including nested structs) contains
+// any exported fields that are pointers or one of the following types:
+// map, interface, complex64, complex128, func, chan.
+// In these cases, an error will be returned.
+// Future versions may handle these cases without error.
+func InferSchema(st interface{}) (Schema, error) {
+	return inferStruct(reflect.TypeOf(st))
+}
+
+func inferStruct(rt reflect.Type) (Schema, error) {
+	switch rt.Kind() {
+	case reflect.Struct:
+		return inferFields(rt)
+	default:
+		return nil, errNoStruct
+	}
+
+}
+
+// inferFieldSchema infers the FieldSchema for a Go type
+func inferFieldSchema(rt reflect.Type) (*FieldSchema, error) {
+	switch {
+	case isByteSlice(rt):
+		return &FieldSchema{Required: true, Type: StringFieldType}, nil
+	case isTimeTime(rt):
+		return &FieldSchema{Required: true, Type: TimestampFieldType}, nil
+	case isRepeated(rt):
+		et := rt.Elem()
+
+		if isRepeated(et) && !isByteSlice(et) {
+			// Multi dimensional slices/arrays are not supported by BigQuery
+			return nil, errUnsupportedFieldType
+		}
+
+		f, err := inferFieldSchema(et)
+		if err != nil {
+			return nil, err
+		}
+		f.Repeated = true
+		f.Required = false
+		return f, nil
+	case isStruct(rt):
+		nested, err := inferFields(rt)
+		if err != nil {
+			return nil, err
+		}
+		return &FieldSchema{Required: true, Type: RecordFieldType, Schema: nested}, nil
+	}
+
+	switch rt.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int,
+		reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
+		return &FieldSchema{Required: true, Type: IntegerFieldType}, nil
+	case reflect.String:
+		return &FieldSchema{Required: true, Type: StringFieldType}, nil
+	case reflect.Bool:
+		return &FieldSchema{Required: true, Type: BooleanFieldType}, nil
+	case reflect.Float32, reflect.Float64:
+		return &FieldSchema{Required: true, Type: FloatFieldType}, nil
+	default:
+		return nil, errUnsupportedFieldType
+	}
+}
+
+// inferFields extracts all exported field types from struct type.
+func inferFields(rt reflect.Type) (Schema, error) {
+	var s Schema
+
+	for i := 0; i < rt.NumField(); i++ {
+		field := rt.Field(i)
+		if field.PkgPath != "" {
+			// field is unexported.
+			continue
+		}
+
+		if field.Anonymous {
+			// TODO(nightlyone) support embedded (see https://github.com/GoogleCloudPlatform/google-cloud-go/issues/238)
+			return nil, errUnsupportedFieldType
+		}
+
+		f, err := inferFieldSchema(field.Type)
+		if err != nil {
+			return nil, err
+		}
+		f.Name = field.Name
+
+		s = append(s, f)
+	}
+
+	return s, nil
+}
+
+func isByteSlice(rt reflect.Type) bool {
+	return rt.Kind() == reflect.Slice && rt.Elem().Kind() == reflect.Uint8
+}
+
+func isTimeTime(rt reflect.Type) bool {
+	return rt.PkgPath() == "time" && rt.Name() == "Time"
+}
+
+func isStruct(rt reflect.Type) bool {
+	return rt.Kind() == reflect.Struct
+}
+
+func isRepeated(rt reflect.Type) bool {
+	switch rt.Kind() {
+	case reflect.Slice, reflect.Array:
+		return true
+	default:
+		return false
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/schema_test.go
+++ b/vendor/cloud.google.com/go/bigquery/schema_test.go
@@ -0,0 +1,495 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func (fs *FieldSchema) GoString() string {
+	if fs == nil {
+		return "<nil>"
+	}
+
+	return fmt.Sprintf("{Name:%s Description:%s Repeated:%t Required:%t Type:%s Schema:%s}",
+		fs.Name,
+		fs.Description,
+		fs.Repeated,
+		fs.Required,
+		fs.Type,
+		fmt.Sprintf("%#v", fs.Schema),
+	)
+}
+
+func bqTableFieldSchema(desc, name, typ, mode string) *bq.TableFieldSchema {
+	return &bq.TableFieldSchema{
+		Description: desc,
+		Name:        name,
+		Mode:        mode,
+		Type:        typ,
+	}
+}
+
+func fieldSchema(desc, name, typ string, repeated, required bool) *FieldSchema {
+	return &FieldSchema{
+		Description: desc,
+		Name:        name,
+		Repeated:    repeated,
+		Required:    required,
+		Type:        FieldType(typ),
+	}
+}
+
+func TestSchemaConversion(t *testing.T) {
+	testCases := []struct {
+		schema   Schema
+		bqSchema *bq.TableSchema
+	}{
+		{
+			// required
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "STRING", "REQUIRED"),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "STRING", false, true),
+			},
+		},
+		{
+			// repeated
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "STRING", "REPEATED"),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "STRING", true, false),
+			},
+		},
+		{
+			// nullable, string
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "STRING", ""),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "STRING", false, false),
+			},
+		},
+		{
+			// integer
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "INTEGER", ""),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "INTEGER", false, false),
+			},
+		},
+		{
+			// float
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "FLOAT", ""),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "FLOAT", false, false),
+			},
+		},
+		{
+			// boolean
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "BOOLEAN", ""),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "BOOLEAN", false, false),
+			},
+		},
+		{
+			// timestamp
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					bqTableFieldSchema("desc", "name", "TIMESTAMP", ""),
+				},
+			},
+			schema: Schema{
+				fieldSchema("desc", "name", "TIMESTAMP", false, false),
+			},
+		},
+		{
+			// nested
+			bqSchema: &bq.TableSchema{
+				Fields: []*bq.TableFieldSchema{
+					{
+						Description: "An outer schema wrapping a nested schema",
+						Name:        "outer",
+						Mode:        "REQUIRED",
+						Type:        "RECORD",
+						Fields: []*bq.TableFieldSchema{
+							bqTableFieldSchema("inner field", "inner", "STRING", ""),
+						},
+					},
+				},
+			},
+			schema: Schema{
+				&FieldSchema{
+					Description: "An outer schema wrapping a nested schema",
+					Name:        "outer",
+					Required:    true,
+					Type:        "RECORD",
+					Schema: []*FieldSchema{
+						{
+							Description: "inner field",
+							Name:        "inner",
+							Type:        "STRING",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		bqSchema := tc.schema.asTableSchema()
+		if !reflect.DeepEqual(bqSchema, tc.bqSchema) {
+			t.Errorf("converting to TableSchema: got:\n%v\nwant:\n%v", bqSchema, tc.bqSchema)
+		}
+		schema := convertTableSchema(tc.bqSchema)
+		if !reflect.DeepEqual(schema, tc.schema) {
+			t.Errorf("converting to Schema: got:\n%v\nwant:\n%v", schema, tc.schema)
+		}
+	}
+}
+
+type allStrings struct {
+	String    string
+	ByteSlice []byte
+}
+
+type allSignedIntegers struct {
+	Int64 int64
+	Int32 int32
+	Int16 int16
+	Int8  int8
+	Int   int
+}
+
+type allUnsignedIntegers struct {
+	Uint64  uint64
+	Uint32  uint32
+	Uint16  uint16
+	Uint8   uint8
+	Uintptr uintptr
+	Uint    uint
+}
+
+type allFloat struct {
+	Float64 float64
+	Float32 float32
+	// NOTE: Complex32 and Complex64 are unsupported by BigQuery
+}
+
+type allBoolean struct {
+	Bool bool
+}
+
+type allTime struct {
+	Time time.Time
+}
+
+func TestSimpleInference(t *testing.T) {
+	testCases := []struct {
+		in   interface{}
+		want Schema
+	}{
+		{
+			in: allSignedIntegers{},
+			want: Schema{
+				fieldSchema("", "Int64", "INTEGER", false, true),
+				fieldSchema("", "Int32", "INTEGER", false, true),
+				fieldSchema("", "Int16", "INTEGER", false, true),
+				fieldSchema("", "Int8", "INTEGER", false, true),
+				fieldSchema("", "Int", "INTEGER", false, true),
+			},
+		},
+		{
+			in: allUnsignedIntegers{},
+			want: Schema{
+				fieldSchema("", "Uint64", "INTEGER", false, true),
+				fieldSchema("", "Uint32", "INTEGER", false, true),
+				fieldSchema("", "Uint16", "INTEGER", false, true),
+				fieldSchema("", "Uint8", "INTEGER", false, true),
+				fieldSchema("", "Uintptr", "INTEGER", false, true),
+				fieldSchema("", "Uint", "INTEGER", false, true),
+			},
+		},
+		{
+			in: allFloat{},
+			want: Schema{
+				fieldSchema("", "Float64", "FLOAT", false, true),
+				fieldSchema("", "Float32", "FLOAT", false, true),
+			},
+		},
+		{
+			in: allBoolean{},
+			want: Schema{
+				fieldSchema("", "Bool", "BOOLEAN", false, true),
+			},
+		},
+		{
+			in: allTime{},
+			want: Schema{
+				fieldSchema("", "Time", "TIMESTAMP", false, true),
+			},
+		},
+		{
+			in: allStrings{},
+			want: Schema{
+				fieldSchema("", "String", "STRING", false, true),
+				fieldSchema("", "ByteSlice", "STRING", false, true),
+			},
+		},
+	}
+	for i, tc := range testCases {
+		got, err := InferSchema(tc.in)
+		if err != nil {
+			t.Fatalf("%d: error inferring TableSchema: %v", i, err)
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("%d: inferring TableSchema: got:\n%#v\nwant:\n%#v", i, got, tc.want)
+		}
+	}
+}
+
+type containsNested struct {
+	hidden    string
+	NotNested int
+	Nested    struct {
+		Inside int
+	}
+}
+
+type containsDoubleNested struct {
+	NotNested int
+	Nested    struct {
+		InsideNested struct {
+			Inside int
+		}
+	}
+}
+
+func TestNestedInference(t *testing.T) {
+	testCases := []struct {
+		in   interface{}
+		want Schema
+	}{
+		{
+			in: containsNested{},
+			want: Schema{
+				fieldSchema("", "NotNested", "INTEGER", false, true),
+				&FieldSchema{
+					Name:     "Nested",
+					Required: true,
+					Type:     "RECORD",
+					Schema: []*FieldSchema{
+						{
+							Name:     "Inside",
+							Type:     "INTEGER",
+							Required: true,
+						},
+					},
+				},
+			},
+		},
+		{
+			in: containsDoubleNested{},
+			want: Schema{
+				fieldSchema("", "NotNested", "INTEGER", false, true),
+				&FieldSchema{
+					Name:     "Nested",
+					Required: true,
+					Type:     "RECORD",
+					Schema: []*FieldSchema{
+						{
+							Name:     "InsideNested",
+							Required: true,
+							Type:     "RECORD",
+							Schema: []*FieldSchema{
+								{
+									Name:     "Inside",
+									Type:     "INTEGER",
+									Required: true,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for i, tc := range testCases {
+		got, err := InferSchema(tc.in)
+		if err != nil {
+			t.Fatalf("%d: error inferring TableSchema: %v", i, err)
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("%d: inferring TableSchema: got:\n%#v\nwant:\n%#v", i, got, tc.want)
+		}
+	}
+}
+
+type simpleRepeated struct {
+	NotRepeated       []byte
+	RepeatedByteSlice [][]byte
+	Repeated          []int
+}
+
+type simpleNestedRepeated struct {
+	NotRepeated int
+	Repeated    []struct {
+		Inside int
+	}
+}
+
+func TestRepeatedInference(t *testing.T) {
+	testCases := []struct {
+		in   interface{}
+		want Schema
+	}{
+		{
+			in: simpleRepeated{},
+			want: Schema{
+				fieldSchema("", "NotRepeated", "STRING", false, true),
+				fieldSchema("", "RepeatedByteSlice", "STRING", true, false),
+				fieldSchema("", "Repeated", "INTEGER", true, false),
+			},
+		},
+		{
+			in: simpleNestedRepeated{},
+			want: Schema{
+				fieldSchema("", "NotRepeated", "INTEGER", false, true),
+				&FieldSchema{
+					Name:     "Repeated",
+					Repeated: true,
+					Type:     "RECORD",
+					Schema: []*FieldSchema{
+						{
+							Name:     "Inside",
+							Type:     "INTEGER",
+							Required: true,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for i, tc := range testCases {
+		got, err := InferSchema(tc.in)
+		if err != nil {
+			t.Fatalf("%d: error inferring TableSchema: %v", i, err)
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("%d: inferring TableSchema: got:\n%#v\nwant:\n%#v", i, got, tc.want)
+		}
+	}
+}
+
+type Embedded struct {
+	Embedded int
+}
+
+type nestedEmbedded struct {
+	Embedded
+}
+
+func TestSchemaErrors(t *testing.T) {
+	testCases := []struct {
+		in  interface{}
+		err error
+	}{
+		{
+			in:  []byte{},
+			err: errNoStruct,
+		},
+		{
+			in:  new(int),
+			err: errNoStruct,
+		},
+		{
+			in:  new(allStrings),
+			err: errNoStruct,
+		},
+		{
+			in:  struct{ Complex complex64 }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ Map map[string]int }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ Chan chan bool }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ Ptr *int }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ Interface interface{} }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ MultiDimensional [][]int }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ MultiDimensional [][][]byte }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ ChanSlice []chan bool }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ NestedChan struct{ Chan []chan bool } }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  nestedEmbedded{},
+			err: errUnsupportedFieldType,
+		},
+	}
+	for i, tc := range testCases {
+		want := tc.err
+		_, got := InferSchema(tc.in)
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("%d: inferring TableSchema: got:\n%#v\nwant:\n%#v", i, got, want)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/service.go
+++ b/vendor/cloud.google.com/go/bigquery/service.go
@@ -0,0 +1,484 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+// service provides an internal abstraction to isolate the generated
+// BigQuery API; most of this package uses this interface instead.
+// The single implementation, *bigqueryService, contains all the knowledge
+// of the generated BigQuery API.
+type service interface {
+	// Jobs
+	insertJob(ctx context.Context, job *bq.Job, projectId string) (*Job, error)
+	getJobType(ctx context.Context, projectId, jobID string) (jobType, error)
+	jobCancel(ctx context.Context, projectId, jobID string) error
+	jobStatus(ctx context.Context, projectId, jobID string) (*JobStatus, error)
+
+	// Tables
+	createTable(ctx context.Context, conf *createTableConf) error
+	getTableMetadata(ctx context.Context, projectID, datasetID, tableID string) (*TableMetadata, error)
+	deleteTable(ctx context.Context, projectID, datasetID, tableID string) error
+	listTables(ctx context.Context, projectID, datasetID, pageToken string) ([]*Table, string, error)
+	patchTable(ctx context.Context, projectID, datasetID, tableID string, conf *patchTableConf) (*TableMetadata, error)
+
+	// Table data
+	readTabledata(ctx context.Context, conf *readTableConf, pageToken string) (*readDataResult, error)
+	insertRows(ctx context.Context, projectID, datasetID, tableID string, rows []*insertionRow, conf *insertRowsConf) error
+
+	// Datasets
+	insertDataset(ctx context.Context, datasetID, projectID string) error
+
+	// Misc
+
+	// readQuery reads data resulting from a query job. If the job is
+	// incomplete, an errIncompleteJob is returned. readQuery may be called
+	// repeatedly to poll for job completion.
+	readQuery(ctx context.Context, conf *readQueryConf, pageToken string) (*readDataResult, error)
+}
+
+type bigqueryService struct {
+	s *bq.Service
+}
+
+func newBigqueryService(client *http.Client, endpoint string) (*bigqueryService, error) {
+	s, err := bq.New(client)
+	if err != nil {
+		return nil, fmt.Errorf("constructing bigquery client: %v", err)
+	}
+	s.BasePath = endpoint
+
+	return &bigqueryService{s: s}, nil
+}
+
+// getPages calls the supplied getPage function repeatedly until there are no pages left to get.
+// token is the token of the initial page to start from.  Use an empty string to start from the beginning.
+func getPages(token string, getPage func(token string) (nextToken string, err error)) error {
+	for {
+		var err error
+		token, err = getPage(token)
+		if err != nil {
+			return err
+		}
+		if token == "" {
+			return nil
+		}
+	}
+}
+
+func (s *bigqueryService) insertJob(ctx context.Context, job *bq.Job, projectID string) (*Job, error) {
+	res, err := s.s.Jobs.Insert(projectID, job).Context(ctx).Do()
+	if err != nil {
+		return nil, err
+	}
+	return &Job{service: s, projectID: projectID, jobID: res.JobReference.JobId}, nil
+}
+
+type pagingConf struct {
+	recordsPerRequest    int64
+	setRecordsPerRequest bool
+
+	startIndex uint64
+}
+
+type readTableConf struct {
+	projectID, datasetID, tableID string
+	paging                        pagingConf
+	schema                        Schema // lazily initialized when the first page of data is fetched.
+}
+
+type readDataResult struct {
+	pageToken string
+	rows      [][]Value
+	totalRows uint64
+	schema    Schema
+}
+
+type readQueryConf struct {
+	projectID, jobID string
+	paging           pagingConf
+}
+
+func (s *bigqueryService) readTabledata(ctx context.Context, conf *readTableConf, pageToken string) (*readDataResult, error) {
+	// Prepare request to fetch one page of table data.
+	req := s.s.Tabledata.List(conf.projectID, conf.datasetID, conf.tableID)
+
+	if pageToken != "" {
+		req.PageToken(pageToken)
+	} else {
+		req.StartIndex(conf.paging.startIndex)
+	}
+
+	if conf.paging.setRecordsPerRequest {
+		req.MaxResults(conf.paging.recordsPerRequest)
+	}
+
+	// Fetch the table schema in the background, if necessary.
+	var schemaErr error
+	var schemaFetch sync.WaitGroup
+	if conf.schema == nil {
+		schemaFetch.Add(1)
+		go func() {
+			defer schemaFetch.Done()
+			var t *bq.Table
+			t, schemaErr = s.s.Tables.Get(conf.projectID, conf.datasetID, conf.tableID).
+				Fields("schema").
+				Context(ctx).
+				Do()
+			if schemaErr == nil && t.Schema != nil {
+				conf.schema = convertTableSchema(t.Schema)
+			}
+		}()
+	}
+
+	res, err := req.Context(ctx).Do()
+	if err != nil {
+		return nil, err
+	}
+
+	schemaFetch.Wait()
+	if schemaErr != nil {
+		return nil, schemaErr
+	}
+
+	result := &readDataResult{
+		pageToken: res.PageToken,
+		totalRows: uint64(res.TotalRows),
+		schema:    conf.schema,
+	}
+	result.rows, err = convertRows(res.Rows, conf.schema)
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+var errIncompleteJob = errors.New("internal error: query results not available because job is not complete")
+
+// getQueryResultsTimeout controls the maximum duration of a request to the
+// BigQuery GetQueryResults endpoint.  Setting a long timeout here does not
+// cause increased overall latency, as results are returned as soon as they are
+// available.
+const getQueryResultsTimeout = time.Minute
+
+func (s *bigqueryService) readQuery(ctx context.Context, conf *readQueryConf, pageToken string) (*readDataResult, error) {
+	req := s.s.Jobs.GetQueryResults(conf.projectID, conf.jobID).
+		TimeoutMs(getQueryResultsTimeout.Nanoseconds() / 1e6)
+
+	if pageToken != "" {
+		req.PageToken(pageToken)
+	} else {
+		req.StartIndex(conf.paging.startIndex)
+	}
+
+	if conf.paging.setRecordsPerRequest {
+		req.MaxResults(conf.paging.recordsPerRequest)
+	}
+
+	res, err := req.Context(ctx).Do()
+	if err != nil {
+		return nil, err
+	}
+
+	if !res.JobComplete {
+		return nil, errIncompleteJob
+	}
+	schema := convertTableSchema(res.Schema)
+	result := &readDataResult{
+		pageToken: res.PageToken,
+		totalRows: res.TotalRows,
+		schema:    schema,
+	}
+	result.rows, err = convertRows(res.Rows, schema)
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+type insertRowsConf struct {
+	templateSuffix      string
+	ignoreUnknownValues bool
+	skipInvalidRows     bool
+}
+
+func (s *bigqueryService) insertRows(ctx context.Context, projectID, datasetID, tableID string, rows []*insertionRow, conf *insertRowsConf) error {
+	req := &bq.TableDataInsertAllRequest{
+		TemplateSuffix:      conf.templateSuffix,
+		IgnoreUnknownValues: conf.ignoreUnknownValues,
+		SkipInvalidRows:     conf.skipInvalidRows,
+	}
+	for _, row := range rows {
+		m := make(map[string]bq.JsonValue)
+		for k, v := range row.Row {
+			m[k] = bq.JsonValue(v)
+		}
+		req.Rows = append(req.Rows, &bq.TableDataInsertAllRequestRows{
+			InsertId: row.InsertID,
+			Json:     m,
+		})
+	}
+	res, err := s.s.Tabledata.InsertAll(projectID, datasetID, tableID, req).Context(ctx).Do()
+	if err != nil {
+		return err
+	}
+	if len(res.InsertErrors) == 0 {
+		return nil
+	}
+
+	var errs PutMultiError
+	for _, e := range res.InsertErrors {
+		if int(e.Index) > len(rows) {
+			return fmt.Errorf("internal error: unexpected row index: %v", e.Index)
+		}
+		rie := RowInsertionError{
+			InsertID: rows[e.Index].InsertID,
+			RowIndex: int(e.Index),
+		}
+		for _, errp := range e.Errors {
+			rie.Errors = append(rie.Errors, errorFromErrorProto(errp))
+		}
+		errs = append(errs, rie)
+	}
+	return errs
+}
+
+type jobType int
+
+const (
+	copyJobType jobType = iota
+	extractJobType
+	loadJobType
+	queryJobType
+)
+
+func (s *bigqueryService) getJobType(ctx context.Context, projectID, jobID string) (jobType, error) {
+	res, err := s.s.Jobs.Get(projectID, jobID).
+		Fields("configuration").
+		Context(ctx).
+		Do()
+
+	if err != nil {
+		return 0, err
+	}
+
+	switch {
+	case res.Configuration.Copy != nil:
+		return copyJobType, nil
+	case res.Configuration.Extract != nil:
+		return extractJobType, nil
+	case res.Configuration.Load != nil:
+		return loadJobType, nil
+	case res.Configuration.Query != nil:
+		return queryJobType, nil
+	default:
+		return 0, errors.New("unknown job type")
+	}
+}
+
+func (s *bigqueryService) jobCancel(ctx context.Context, projectID, jobID string) error {
+	// Jobs.Cancel returns a job entity, but the only relevant piece of
+	// data it may contain (the status of the job) is unreliable.  From the
+	// docs: "This call will return immediately, and the client will need
+	// to poll for the job status to see if the cancel completed
+	// successfully".  So it would be misleading to return a status.
+	_, err := s.s.Jobs.Cancel(projectID, jobID).
+		Fields(). // We don't need any of the response data.
+		Context(ctx).
+		Do()
+	return err
+}
+
+func (s *bigqueryService) jobStatus(ctx context.Context, projectID, jobID string) (*JobStatus, error) {
+	res, err := s.s.Jobs.Get(projectID, jobID).
+		Fields("status"). // Only fetch what we need.
+		Context(ctx).
+		Do()
+	if err != nil {
+		return nil, err
+	}
+	return jobStatusFromProto(res.Status)
+}
+
+var stateMap = map[string]State{"PENDING": Pending, "RUNNING": Running, "DONE": Done}
+
+func jobStatusFromProto(status *bq.JobStatus) (*JobStatus, error) {
+	state, ok := stateMap[status.State]
+	if !ok {
+		return nil, fmt.Errorf("unexpected job state: %v", status.State)
+	}
+
+	newStatus := &JobStatus{
+		State: state,
+		err:   nil,
+	}
+	if err := errorFromErrorProto(status.ErrorResult); state == Done && err != nil {
+		newStatus.err = err
+	}
+
+	for _, ep := range status.Errors {
+		newStatus.Errors = append(newStatus.Errors, errorFromErrorProto(ep))
+	}
+	return newStatus, nil
+}
+
+// listTables returns a subset of tables that belong to a dataset, and a token for fetching the next subset.
+func (s *bigqueryService) listTables(ctx context.Context, projectID, datasetID, pageToken string) ([]*Table, string, error) {
+	var tables []*Table
+	res, err := s.s.Tables.List(projectID, datasetID).
+		PageToken(pageToken).
+		Context(ctx).
+		Do()
+	if err != nil {
+		return nil, "", err
+	}
+	for _, t := range res.Tables {
+		tables = append(tables, s.convertListedTable(t))
+	}
+	return tables, res.NextPageToken, nil
+}
+
+type createTableConf struct {
+	projectID, datasetID, tableID string
+	expiration                    time.Time
+	viewQuery                     string
+	schema                        *bq.TableSchema
+}
+
+// createTable creates a table in the BigQuery service.
+// expiration is an optional time after which the table will be deleted and its storage reclaimed.
+// If viewQuery is non-empty, the created table will be of type VIEW.
+// Note: expiration can only be set during table creation.
+// Note: after table creation, a view can be modified only if its table was initially created with a view.
+func (s *bigqueryService) createTable(ctx context.Context, conf *createTableConf) error {
+	table := &bq.Table{
+		TableReference: &bq.TableReference{
+			ProjectId: conf.projectID,
+			DatasetId: conf.datasetID,
+			TableId:   conf.tableID,
+		},
+	}
+	if !conf.expiration.IsZero() {
+		table.ExpirationTime = conf.expiration.UnixNano() / 1000
+	}
+	// TODO(jba): make it impossible to provide both a view query and a schema.
+	if conf.viewQuery != "" {
+		table.View = &bq.ViewDefinition{
+			Query: conf.viewQuery,
+		}
+	}
+	if conf.schema != nil {
+		table.Schema = conf.schema
+	}
+
+	_, err := s.s.Tables.Insert(conf.projectID, conf.datasetID, table).Context(ctx).Do()
+	return err
+}
+
+func (s *bigqueryService) getTableMetadata(ctx context.Context, projectID, datasetID, tableID string) (*TableMetadata, error) {
+	table, err := s.s.Tables.Get(projectID, datasetID, tableID).Context(ctx).Do()
+	if err != nil {
+		return nil, err
+	}
+	return bqTableToMetadata(table), nil
+}
+
+func (s *bigqueryService) deleteTable(ctx context.Context, projectID, datasetID, tableID string) error {
+	return s.s.Tables.Delete(projectID, datasetID, tableID).Context(ctx).Do()
+}
+
+func bqTableToMetadata(t *bq.Table) *TableMetadata {
+	md := &TableMetadata{
+		Description: t.Description,
+		Name:        t.FriendlyName,
+		Type:        TableType(t.Type),
+		ID:          t.Id,
+		NumBytes:    t.NumBytes,
+		NumRows:     t.NumRows,
+	}
+	if t.ExpirationTime != 0 {
+		md.ExpirationTime = time.Unix(0, t.ExpirationTime*1e6)
+	}
+	if t.CreationTime != 0 {
+		md.CreationTime = time.Unix(0, t.CreationTime*1e6)
+	}
+	if t.LastModifiedTime != 0 {
+		md.LastModifiedTime = time.Unix(0, int64(t.LastModifiedTime*1e6))
+	}
+	if t.Schema != nil {
+		md.Schema = convertTableSchema(t.Schema)
+	}
+	if t.View != nil {
+		md.View = t.View.Query
+	}
+
+	return md
+}
+
+func (s *bigqueryService) convertListedTable(t *bq.TableListTables) *Table {
+	return &Table{
+		ProjectID: t.TableReference.ProjectId,
+		DatasetID: t.TableReference.DatasetId,
+		TableID:   t.TableReference.TableId,
+		service:   s,
+	}
+}
+
+// patchTableConf contains fields to be patched.
+type patchTableConf struct {
+	// These fields are omitted from the patch operation if nil.
+	Description *string
+	Name        *string
+}
+
+func (s *bigqueryService) patchTable(ctx context.Context, projectID, datasetID, tableID string, conf *patchTableConf) (*TableMetadata, error) {
+	t := &bq.Table{}
+	forceSend := func(field string) {
+		t.ForceSendFields = append(t.ForceSendFields, field)
+	}
+
+	if conf.Description != nil {
+		t.Description = *conf.Description
+		forceSend("Description")
+	}
+	if conf.Name != nil {
+		t.FriendlyName = *conf.Name
+		forceSend("FriendlyName")
+	}
+	table, err := s.s.Tables.Patch(projectID, datasetID, tableID, t).
+		Context(ctx).
+		Do()
+	if err != nil {
+		return nil, err
+	}
+	return bqTableToMetadata(table), nil
+}
+
+func (s *bigqueryService) insertDataset(ctx context.Context, datasetID, projectID string) error {
+	ds := &bq.Dataset{
+		DatasetReference: &bq.DatasetReference{DatasetId: datasetID},
+	}
+	_, err := s.s.Datasets.Insert(projectID, ds).Context(ctx).Do()
+	return err
+}
--- a/vendor/cloud.google.com/go/bigquery/table.go
+++ b/vendor/cloud.google.com/go/bigquery/table.go
@@ -0,0 +1,281 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+	"time"
+
+	"golang.org/x/net/context"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+// A Table is a reference to a BigQuery table.
+type Table struct {
+	// ProjectID, DatasetID and TableID may be omitted if the Table is the destination for a query.
+	// In this case the result will be stored in an ephemeral table.
+	ProjectID string
+	DatasetID string
+	// TableID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_).
+	// The maximum length is 1,024 characters.
+	TableID string
+
+	service service
+}
+
+// TableMetadata contains information about a BigQuery table.
+type TableMetadata struct {
+	Description string // The user-friendly description of this table.
+	Name        string // The user-friendly name for this table.
+	Schema      Schema
+	View        string
+
+	ID   string // An opaque ID uniquely identifying the table.
+	Type TableType
+
+	// The time when this table expires. If not set, the table will persist
+	// indefinitely. Expired tables will be deleted and their storage reclaimed.
+	ExpirationTime time.Time
+
+	CreationTime     time.Time
+	LastModifiedTime time.Time
+
+	// The size of the table in bytes.
+	// This does not include data that is being buffered during a streaming insert.
+	NumBytes int64
+
+	// The number of rows of data in this table.
+	// This does not include data that is being buffered during a streaming insert.
+	NumRows uint64
+}
+
+// Tables is a group of tables. The tables may belong to differing projects or datasets.
+type Tables []*Table
+
+// CreateDisposition specifies the circumstances under which destination table will be created.
+// Default is CreateIfNeeded.
+type TableCreateDisposition string
+
+const (
+	// The table will be created if it does not already exist.  Tables are created atomically on successful completion of a job.
+	CreateIfNeeded TableCreateDisposition = "CREATE_IF_NEEDED"
+
+	// The table must already exist and will not be automatically created.
+	CreateNever TableCreateDisposition = "CREATE_NEVER"
+)
+
+func CreateDisposition(disp TableCreateDisposition) Option { return disp }
+
+func (opt TableCreateDisposition) implementsOption() {}
+
+func (opt TableCreateDisposition) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.CreateDisposition = string(opt)
+}
+
+func (opt TableCreateDisposition) customizeCopy(conf *bq.JobConfigurationTableCopy) {
+	conf.CreateDisposition = string(opt)
+}
+
+func (opt TableCreateDisposition) customizeQuery(conf *bq.JobConfigurationQuery) {
+	conf.CreateDisposition = string(opt)
+}
+
+// TableWriteDisposition specifies how existing data in a destination table is treated.
+// Default is WriteAppend.
+type TableWriteDisposition string
+
+const (
+	// Data will be appended to any existing data in the destination table.
+	// Data is appended atomically on successful completion of a job.
+	WriteAppend TableWriteDisposition = "WRITE_APPEND"
+
+	// Existing data in the destination table will be overwritten.
+	// Data is overwritten atomically on successful completion of a job.
+	WriteTruncate TableWriteDisposition = "WRITE_TRUNCATE"
+
+	// Writes will fail if the destination table already contains data.
+	WriteEmpty TableWriteDisposition = "WRITE_EMPTY"
+)
+
+func WriteDisposition(disp TableWriteDisposition) Option { return disp }
+
+func (opt TableWriteDisposition) implementsOption() {}
+
+func (opt TableWriteDisposition) customizeLoad(conf *bq.JobConfigurationLoad) {
+	conf.WriteDisposition = string(opt)
+}
+
+func (opt TableWriteDisposition) customizeCopy(conf *bq.JobConfigurationTableCopy) {
+	conf.WriteDisposition = string(opt)
+}
+
+func (opt TableWriteDisposition) customizeQuery(conf *bq.JobConfigurationQuery) {
+	conf.WriteDisposition = string(opt)
+}
+
+// TableType is the type of table.
+type TableType string
+
+const (
+	RegularTable TableType = "TABLE"
+	ViewTable    TableType = "VIEW"
+)
+
+func (t *Table) implementsSource()      {}
+func (t *Table) implementsReadSource()  {}
+func (t *Table) implementsDestination() {}
+func (ts Tables) implementsSource()     {}
+
+func (t *Table) tableRefProto() *bq.TableReference {
+	return &bq.TableReference{
+		ProjectId: t.ProjectID,
+		DatasetId: t.DatasetID,
+		TableId:   t.TableID,
+	}
+}
+
+// FullyQualifiedName returns the ID of the table in projectID:datasetID.tableID format.
+func (t *Table) FullyQualifiedName() string {
+	return fmt.Sprintf("%s:%s.%s", t.ProjectID, t.DatasetID, t.TableID)
+}
+
+// implicitTable reports whether Table is an empty placeholder, which signifies that a new table should be created with an auto-generated Table ID.
+func (t *Table) implicitTable() bool {
+	return t.ProjectID == "" && t.DatasetID == "" && t.TableID == ""
+}
+
+func (t *Table) customizeLoadDst(conf *bq.JobConfigurationLoad) {
+	conf.DestinationTable = t.tableRefProto()
+}
+
+func (t *Table) customizeExtractSrc(conf *bq.JobConfigurationExtract) {
+	conf.SourceTable = t.tableRefProto()
+}
+
+func (t *Table) customizeCopyDst(conf *bq.JobConfigurationTableCopy) {
+	conf.DestinationTable = t.tableRefProto()
+}
+
+func (ts Tables) customizeCopySrc(conf *bq.JobConfigurationTableCopy) {
+	for _, t := range ts {
+		conf.SourceTables = append(conf.SourceTables, t.tableRefProto())
+	}
+}
+
+func (t *Table) customizeQueryDst(conf *bq.JobConfigurationQuery) {
+	if !t.implicitTable() {
+		conf.DestinationTable = t.tableRefProto()
+	}
+}
+
+func (t *Table) customizeReadSrc(cursor *readTableConf) {
+	cursor.projectID = t.ProjectID
+	cursor.datasetID = t.DatasetID
+	cursor.tableID = t.TableID
+}
+
+// Create creates a table in the BigQuery service.
+func (t *Table) Create(ctx context.Context, options ...CreateTableOption) error {
+	conf := &createTableConf{
+		projectID: t.ProjectID,
+		datasetID: t.DatasetID,
+		tableID:   t.TableID,
+	}
+	for _, o := range options {
+		o.customizeCreateTable(conf)
+	}
+	return t.service.createTable(ctx, conf)
+}
+
+// Metadata fetches the metadata for the table.
+func (t *Table) Metadata(ctx context.Context) (*TableMetadata, error) {
+	return t.service.getTableMetadata(ctx, t.ProjectID, t.DatasetID, t.TableID)
+}
+
+// Delete deletes the table.
+func (t *Table) Delete(ctx context.Context) error {
+	return t.service.deleteTable(ctx, t.ProjectID, t.DatasetID, t.TableID)
+}
+
+// A CreateTableOption is an optional argument to CreateTable.
+type CreateTableOption interface {
+	customizeCreateTable(*createTableConf)
+}
+
+type tableExpiration time.Time
+
+// TableExpiration returns a CreateTableOption that will cause the created table to be deleted after the expiration time.
+func TableExpiration(exp time.Time) CreateTableOption { return tableExpiration(exp) }
+
+func (opt tableExpiration) customizeCreateTable(conf *createTableConf) {
+	conf.expiration = time.Time(opt)
+}
+
+type viewQuery string
+
+// ViewQuery returns a CreateTableOption that causes the created table to be a virtual table defined by the supplied query.
+// For more information see: https://cloud.google.com/bigquery/querying-data#views
+func ViewQuery(query string) CreateTableOption { return viewQuery(query) }
+
+func (opt viewQuery) customizeCreateTable(conf *createTableConf) {
+	conf.viewQuery = string(opt)
+}
+
+// TableMetadataPatch represents a set of changes to a table's metadata.
+type TableMetadataPatch struct {
+	s                             service
+	projectID, datasetID, tableID string
+	conf                          patchTableConf
+}
+
+// Patch returns a *TableMetadataPatch, which can be used to modify specific Table metadata fields.
+// In order to apply the changes, the TableMetadataPatch's Apply method must be called.
+func (t *Table) Patch() *TableMetadataPatch {
+	return &TableMetadataPatch{
+		s:         t.service,
+		projectID: t.ProjectID,
+		datasetID: t.DatasetID,
+		tableID:   t.TableID,
+	}
+}
+
+// Description sets the table description.
+func (p *TableMetadataPatch) Description(desc string) {
+	p.conf.Description = &desc
+}
+
+// Name sets the table name.
+func (p *TableMetadataPatch) Name(name string) {
+	p.conf.Name = &name
+}
+
+// TODO(mcgreevy): support patching the schema.
+
+// Apply applies the patch operation.
+func (p *TableMetadataPatch) Apply(ctx context.Context) (*TableMetadata, error) {
+	return p.s.patchTable(ctx, p.projectID, p.datasetID, p.tableID, &p.conf)
+}
+
+// NewUploader returns an *Uploader that can be used to append rows to t.
+func (t *Table) NewUploader(opts ...UploadOption) *Uploader {
+	uploader := &Uploader{t: t}
+
+	for _, o := range opts {
+		o.customizeInsertRows(&uploader.conf)
+	}
+
+	return uploader
+}
--- a/vendor/cloud.google.com/go/bigquery/uploader.go
+++ b/vendor/cloud.google.com/go/bigquery/uploader.go
@@ -0,0 +1,121 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+	"reflect"
+
+	"golang.org/x/net/context"
+)
+
+// An UploadOption is an optional argument to NewUploader.
+type UploadOption interface {
+	customizeInsertRows(conf *insertRowsConf)
+}
+
+// An Uploader does streaming inserts into a BigQuery table.
+// It is safe for concurrent use.
+type Uploader struct {
+	conf insertRowsConf
+	t    *Table
+}
+
+// SkipInvalidRows returns an UploadOption that causes rows containing invalid data to be silently ignored.
+// The default value is false, which causes the entire request to fail, if there is an attempt to insert an invalid row.
+func SkipInvalidRows() UploadOption { return skipInvalidRows{} }
+
+type skipInvalidRows struct{}
+
+func (opt skipInvalidRows) customizeInsertRows(conf *insertRowsConf) {
+	conf.skipInvalidRows = true
+}
+
+// UploadIgnoreUnknownValues returns an UploadOption that causes values not matching the schema to be ignored.
+// If this option is not used, records containing such values are treated as invalid records.
+func UploadIgnoreUnknownValues() UploadOption { return uploadIgnoreUnknownValues{} }
+
+type uploadIgnoreUnknownValues struct{}
+
+func (opt uploadIgnoreUnknownValues) customizeInsertRows(conf *insertRowsConf) {
+	conf.ignoreUnknownValues = true
+}
+
+// A TableTemplateSuffix allows Uploaders to create tables automatically.
+//
+// Experimental: this option is experimental and may be modified or removed in future versions,
+// regardless of any other documented package stability guarantees.
+//
+// When you specify a suffix, the table you upload data to
+// will be used as a template for creating a new table, with the same schema,
+// called <table> + <suffix>.
+//
+// More information is available at
+// https://cloud.google.com/bigquery/streaming-data-into-bigquery#template-tables
+func TableTemplateSuffix(suffix string) UploadOption { return tableTemplateSuffix(suffix) }
+
+type tableTemplateSuffix string
+
+func (opt tableTemplateSuffix) customizeInsertRows(conf *insertRowsConf) {
+	conf.templateSuffix = string(opt)
+}
+
+// Put uploads one or more rows to the BigQuery service.  src must implement ValueSaver or be a slice of ValueSavers.
+// Put returns a PutMultiError if one or more rows failed to be uploaded.
+// The PutMultiError contains a RowInsertionError for each failed row.
+func (u *Uploader) Put(ctx context.Context, src interface{}) error {
+	// TODO(mcgreevy): Support structs which do not implement ValueSaver as src, a la Datastore.
+
+	if saver, ok := src.(ValueSaver); ok {
+		return u.putMulti(ctx, []ValueSaver{saver})
+	}
+
+	srcVal := reflect.ValueOf(src)
+	if srcVal.Kind() != reflect.Slice {
+		return fmt.Errorf("%T is not a ValueSaver or slice of ValueSavers", src)
+	}
+
+	var savers []ValueSaver
+	for i := 0; i < srcVal.Len(); i++ {
+		s := srcVal.Index(i).Interface()
+		saver, ok := s.(ValueSaver)
+		if !ok {
+			return fmt.Errorf("element %d of src is of type %T, which is not a ValueSaver", i, s)
+		}
+		savers = append(savers, saver)
+	}
+	return u.putMulti(ctx, savers)
+}
+
+func (u *Uploader) putMulti(ctx context.Context, src []ValueSaver) error {
+	var rows []*insertionRow
+	for _, saver := range src {
+		row, insertID, err := saver.Save()
+		if err != nil {
+			return err
+		}
+		rows = append(rows, &insertionRow{InsertID: insertID, Row: row})
+	}
+	return u.t.service.insertRows(ctx, u.t.ProjectID, u.t.DatasetID, u.t.TableID, rows, &u.conf)
+}
+
+// An insertionRow represents a row of data to be inserted into a table.
+type insertionRow struct {
+	// If InsertID is non-empty, BigQuery will use it to de-duplicate insertions of
+	// this row on a best-effort basis.
+	InsertID string
+	// The data to be inserted, represented as a map from field name to Value.
+	Row map[string]Value
+}
--- a/vendor/cloud.google.com/go/bigquery/uploader_test.go
+++ b/vendor/cloud.google.com/go/bigquery/uploader_test.go
@@ -0,0 +1,234 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/net/context"
+)
+
+type testSaver struct {
+	ir  *insertionRow
+	err error
+}
+
+func (ts testSaver) Save() (map[string]Value, string, error) {
+	return ts.ir.Row, ts.ir.InsertID, ts.err
+}
+
+func TestRejectsNonValueSavers(t *testing.T) {
+	u := Uploader{t: defaultTable(nil)}
+
+	testCases := []struct {
+		src interface{}
+	}{
+		{
+			src: 1,
+		},
+		{
+			src: []int{1, 2},
+		},
+		{
+			src: []interface{}{
+				testSaver{ir: &insertionRow{"a", map[string]Value{"one": 1}}},
+				1,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		if err := u.Put(context.Background(), tc.src); err == nil {
+			t.Errorf("put value: %v; got err: %v; want nil", tc.src, err)
+		}
+	}
+}
+
+type insertRowsRecorder struct {
+	rowBatches [][]*insertionRow
+	service
+}
+
+func (irr *insertRowsRecorder) insertRows(ctx context.Context, projectID, datasetID, tableID string, rows []*insertionRow, conf *insertRowsConf) error {
+	irr.rowBatches = append(irr.rowBatches, rows)
+	return nil
+}
+
+func TestInsertsData(t *testing.T) {
+	table := &Table{
+		ProjectID: "project-id",
+		DatasetID: "dataset-id",
+		TableID:   "table-id",
+	}
+
+	testCases := []struct {
+		data [][]*insertionRow
+	}{
+		{
+			data: [][]*insertionRow{
+				{
+					&insertionRow{"a", map[string]Value{"one": 1}},
+				},
+			},
+		},
+		{
+
+			data: [][]*insertionRow{
+				{
+					&insertionRow{"a", map[string]Value{"one": 1}},
+					&insertionRow{"b", map[string]Value{"two": 2}},
+				},
+			},
+		},
+		{
+
+			data: [][]*insertionRow{
+				{
+					&insertionRow{"a", map[string]Value{"one": 1}},
+				},
+				{
+					&insertionRow{"b", map[string]Value{"two": 2}},
+				},
+			},
+		},
+		{
+
+			data: [][]*insertionRow{
+				{
+					&insertionRow{"a", map[string]Value{"one": 1}},
+					&insertionRow{"b", map[string]Value{"two": 2}},
+				},
+				{
+					&insertionRow{"c", map[string]Value{"three": 3}},
+					&insertionRow{"d", map[string]Value{"four": 4}},
+				},
+			},
+		},
+	}
+	for _, tc := range testCases {
+		irr := &insertRowsRecorder{}
+		table.service = irr
+		u := Uploader{t: table}
+		for _, batch := range tc.data {
+			if len(batch) == 0 {
+				continue
+			}
+			var toUpload interface{}
+			if len(batch) == 1 {
+				toUpload = testSaver{ir: batch[0]}
+			} else {
+				savers := []testSaver{}
+				for _, row := range batch {
+					savers = append(savers, testSaver{ir: row})
+				}
+				toUpload = savers
+			}
+
+			err := u.Put(context.Background(), toUpload)
+			if err != nil {
+				t.Errorf("expected successful Put of ValueSaver; got: %v", err)
+			}
+		}
+		if got, want := irr.rowBatches, tc.data; !reflect.DeepEqual(got, want) {
+			t.Errorf("got: %v, want: %v", got, want)
+		}
+	}
+}
+
+type uploadOptionRecorder struct {
+	received *insertRowsConf
+	service
+}
+
+func (u *uploadOptionRecorder) insertRows(ctx context.Context, projectID, datasetID, tableID string, rows []*insertionRow, conf *insertRowsConf) error {
+	u.received = conf
+	return nil
+}
+
+func TestUploadOptionsPropagate(t *testing.T) {
+	// we don't care for the data in this testcase.
+	dummyData := testSaver{ir: &insertionRow{}}
+
+	tests := [...]struct {
+		opts []UploadOption
+		conf insertRowsConf
+	}{
+		{ // test zero options lead to zero value for insertRowsConf
+		},
+		{
+			opts: []UploadOption{
+				TableTemplateSuffix("suffix"),
+			},
+			conf: insertRowsConf{
+				templateSuffix: "suffix",
+			},
+		},
+		{
+			opts: []UploadOption{
+				UploadIgnoreUnknownValues(),
+			},
+			conf: insertRowsConf{
+				ignoreUnknownValues: true,
+			},
+		},
+		{
+			opts: []UploadOption{
+				SkipInvalidRows(),
+			},
+			conf: insertRowsConf{
+				skipInvalidRows: true,
+			},
+		},
+		{ // multiple upload options combine
+			opts: []UploadOption{
+				TableTemplateSuffix("suffix"),
+				SkipInvalidRows(),
+				UploadIgnoreUnknownValues(),
+			},
+			conf: insertRowsConf{
+				templateSuffix:      "suffix",
+				skipInvalidRows:     true,
+				ignoreUnknownValues: true,
+			},
+		},
+	}
+
+	for i, tc := range tests {
+		recorder := new(uploadOptionRecorder)
+		table := &Table{
+			ProjectID: "project-id",
+			DatasetID: "dataset-id",
+			TableID:   "table-id",
+			service:   recorder,
+		}
+
+		u := table.NewUploader(tc.opts...)
+		err := u.Put(context.Background(), dummyData)
+		if err != nil {
+			t.Fatalf("%d: expected successful Put of ValueSaver; got: %v", i, err)
+		}
+
+		if recorder.received == nil {
+			t.Fatalf("%d: received no options at all!", i)
+		}
+
+		want := tc.conf
+		got := *recorder.received
+		if got != want {
+			t.Errorf("%d: got %#v, want %#v, opts=%#v", i, got, want, tc.opts)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/utils_test.go
+++ b/vendor/cloud.google.com/go/bigquery/utils_test.go
@@ -0,0 +1,54 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"golang.org/x/net/context"
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+var defaultGCS = &GCSReference{
+	uris: []string{"uri"},
+}
+
+var defaultQuery = &Query{
+	Q:                "query string",
+	DefaultProjectID: "def-project-id",
+	DefaultDatasetID: "def-dataset-id",
+}
+
+func defaultTable(s service) *Table {
+	return &Table{
+		ProjectID: "project-id",
+		DatasetID: "dataset-id",
+		TableID:   "table-id",
+		service:   s,
+	}
+}
+
+type testService struct {
+	*bq.Job
+
+	service
+}
+
+func (s *testService) insertJob(ctx context.Context, job *bq.Job, projectID string) (*Job, error) {
+	s.Job = job
+	return &Job{}, nil
+}
+
+func (s *testService) jobStatus(ctx context.Context, projectID, jobID string) (*JobStatus, error) {
+	return &JobStatus{State: Done}, nil
+}
--- a/vendor/cloud.google.com/go/bigquery/value.go
+++ b/vendor/cloud.google.com/go/bigquery/value.go
@@ -0,0 +1,195 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"time"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+// Value stores the contents of a single cell from a BigQuery result.
+type Value interface{}
+
+// ValueLoader stores a slice of Values representing a result row from a Read operation.
+// See Iterator.Get for more information.
+type ValueLoader interface {
+	Load(v []Value) error
+}
+
+// ValueList converts a []Value to implement ValueLoader.
+type ValueList []Value
+
+// Load stores a sequence of values in a ValueList.
+func (vs *ValueList) Load(v []Value) error {
+	*vs = append(*vs, v...)
+	return nil
+}
+
+// A ValueSaver returns a row of data to be inserted into a table.
+type ValueSaver interface {
+	// Save returns a row to be inserted into a BigQuery table, represented
+	// as a map from field name to Value.
+	// If insertID is non-empty, BigQuery will use it to de-duplicate
+	// insertions of this row on a best-effort basis.
+	Save() (row map[string]Value, insertID string, err error)
+}
+
+// ValuesSaver implements ValueSaver for a slice of Values.
+type ValuesSaver struct {
+	Schema Schema
+
+	// If non-empty, BigQuery will use InsertID to de-duplicate insertions
+	// of this row on a best-effort basis.
+	InsertID string
+
+	Row []Value
+}
+
+// Save implements ValueSaver
+func (vls *ValuesSaver) Save() (map[string]Value, string, error) {
+	m, err := valuesToMap(vls.Row, vls.Schema)
+	return m, vls.InsertID, err
+}
+
+func valuesToMap(vs []Value, schema Schema) (map[string]Value, error) {
+	if len(vs) != len(schema) {
+		return nil, errors.New("Schema does not match length of row to be inserted")
+	}
+
+	m := make(map[string]Value)
+	for i, fieldSchema := range schema {
+		if fieldSchema.Type == RecordFieldType {
+			nested, ok := vs[i].([]Value)
+			if !ok {
+				return nil, errors.New("Nested record is not a []Value")
+			}
+			value, err := valuesToMap(nested, fieldSchema.Schema)
+			if err != nil {
+				return nil, err
+			}
+			m[fieldSchema.Name] = value
+		} else {
+			m[fieldSchema.Name] = vs[i]
+		}
+	}
+	return m, nil
+}
+
+// convertRows converts a series of TableRows into a series of Value slices.
+// schema is used to interpret the data from rows; its length must match the
+// length of each row.
+func convertRows(rows []*bq.TableRow, schema Schema) ([][]Value, error) {
+	var rs [][]Value
+	for _, r := range rows {
+		row, err := convertRow(r, schema)
+		if err != nil {
+			return nil, err
+		}
+		rs = append(rs, row)
+	}
+	return rs, nil
+}
+
+func convertRow(r *bq.TableRow, schema Schema) ([]Value, error) {
+	if len(schema) != len(r.F) {
+		return nil, errors.New("schema length does not match row length")
+	}
+	var values []Value
+	for i, cell := range r.F {
+		fs := schema[i]
+		v, err := convertValue(cell.V, fs.Type, fs.Schema)
+		if err != nil {
+			return nil, err
+		}
+		values = append(values, v)
+	}
+	return values, nil
+}
+
+func convertValue(val interface{}, typ FieldType, schema Schema) (Value, error) {
+	switch val := val.(type) {
+	case nil:
+		return nil, nil
+	case []interface{}:
+		return convertRepeatedRecord(val, typ, schema)
+	case map[string]interface{}:
+		return convertNestedRecord(val, schema)
+	case string:
+		return convertBasicType(val, typ)
+	default:
+		return nil, fmt.Errorf("got value %v; expected a value of type %s", val, typ)
+	}
+}
+
+func convertRepeatedRecord(vals []interface{}, typ FieldType, schema Schema) (Value, error) {
+	var values []Value
+	for _, cell := range vals {
+		// each cell contains a single entry, keyed by "v"
+		val := cell.(map[string]interface{})["v"]
+		v, err := convertValue(val, typ, schema)
+		if err != nil {
+			return nil, err
+		}
+		values = append(values, v)
+	}
+	return values, nil
+}
+
+func convertNestedRecord(val map[string]interface{}, schema Schema) (Value, error) {
+	// convertNestedRecord is similar to convertRow, as a record has the same structure as a row.
+
+	// Nested records are wrapped in a map with a single key, "f".
+	record := val["f"].([]interface{})
+	if len(record) != len(schema) {
+		return nil, errors.New("schema length does not match record length")
+	}
+
+	var values []Value
+	for i, cell := range record {
+		// each cell contains a single entry, keyed by "v"
+		val := cell.(map[string]interface{})["v"]
+
+		fs := schema[i]
+		v, err := convertValue(val, fs.Type, fs.Schema)
+		if err != nil {
+			return nil, err
+		}
+		values = append(values, v)
+	}
+	return values, nil
+}
+
+// convertBasicType returns val as an interface with a concrete type specified by typ.
+func convertBasicType(val string, typ FieldType) (Value, error) {
+	switch typ {
+	case StringFieldType:
+		return val, nil
+	case IntegerFieldType:
+		return strconv.Atoi(val)
+	case FloatFieldType:
+		return strconv.ParseFloat(val, 64)
+	case BooleanFieldType:
+		return strconv.ParseBool(val)
+	case TimestampFieldType:
+		f, err := strconv.ParseFloat(val, 64)
+		return Value(time.Unix(0, int64(f*1e9))), err
+	default:
+		return nil, errors.New("unrecognized type")
+	}
+}
--- a/vendor/cloud.google.com/go/bigquery/value_test.go
+++ b/vendor/cloud.google.com/go/bigquery/value_test.go
@@ -0,0 +1,416 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigquery
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	bq "google.golang.org/api/bigquery/v2"
+)
+
+func TestConvertBasicValues(t *testing.T) {
+	schema := []*FieldSchema{
+		{Type: StringFieldType},
+		{Type: IntegerFieldType},
+		{Type: FloatFieldType},
+		{Type: BooleanFieldType},
+	}
+	row := &bq.TableRow{
+		F: []*bq.TableCell{
+			{V: "a"},
+			{V: "1"},
+			{V: "1.2"},
+			{V: "true"},
+		},
+	}
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	want := []Value{"a", 1, 1.2, true}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("converting basic values: got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+func TestConvertTime(t *testing.T) {
+	schema := []*FieldSchema{
+		{Type: TimestampFieldType},
+	}
+	thyme := time.Date(1970, 1, 1, 10, 0, 0, 10, time.UTC)
+	row := &bq.TableRow{
+		F: []*bq.TableCell{
+			{V: fmt.Sprintf("%.10f", float64(thyme.UnixNano())/1e9)},
+		},
+	}
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	if !got[0].(time.Time).Equal(thyme) {
+		t.Errorf("converting basic values: got:\n%v\nwant:\n%v", got, thyme)
+	}
+}
+
+func TestConvertNullValues(t *testing.T) {
+	schema := []*FieldSchema{
+		{Type: StringFieldType},
+	}
+	row := &bq.TableRow{
+		F: []*bq.TableCell{
+			{V: nil},
+		},
+	}
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	want := []Value{nil}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("converting null values: got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+func TestBasicRepetition(t *testing.T) {
+	schema := []*FieldSchema{
+		{Type: IntegerFieldType, Repeated: true},
+	}
+	row := &bq.TableRow{
+		F: []*bq.TableCell{
+			{
+				V: []interface{}{
+					map[string]interface{}{
+						"v": "1",
+					},
+					map[string]interface{}{
+						"v": "2",
+					},
+					map[string]interface{}{
+						"v": "3",
+					},
+				},
+			},
+		},
+	}
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	want := []Value{[]Value{1, 2, 3}}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("converting basic repeated values: got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+func TestNestedRecordContainingRepetition(t *testing.T) {
+	schema := []*FieldSchema{
+		{
+			Type: RecordFieldType,
+			Schema: Schema{
+				{Type: IntegerFieldType, Repeated: true},
+			},
+		},
+	}
+	row := &bq.TableRow{
+		F: []*bq.TableCell{
+			{
+				V: map[string]interface{}{
+					"f": []interface{}{
+						map[string]interface{}{
+							"v": []interface{}{
+								map[string]interface{}{"v": "1"},
+								map[string]interface{}{"v": "2"},
+								map[string]interface{}{"v": "3"},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	want := []Value{[]Value{[]Value{1, 2, 3}}}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("converting basic repeated values: got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+func TestRepeatedRecordContainingRepetition(t *testing.T) {
+	schema := []*FieldSchema{
+		{
+			Type:     RecordFieldType,
+			Repeated: true,
+			Schema: Schema{
+				{Type: IntegerFieldType, Repeated: true},
+			},
+		},
+	}
+	row := &bq.TableRow{F: []*bq.TableCell{
+		{
+			V: []interface{}{ // repeated records.
+				map[string]interface{}{ // first record.
+					"v": map[string]interface{}{ // pointless single-key-map wrapper.
+						"f": []interface{}{ // list of record fields.
+							map[string]interface{}{ // only record (repeated ints)
+								"v": []interface{}{ // pointless wrapper.
+									map[string]interface{}{
+										"v": "1",
+									},
+									map[string]interface{}{
+										"v": "2",
+									},
+									map[string]interface{}{
+										"v": "3",
+									},
+								},
+							},
+						},
+					},
+				},
+				map[string]interface{}{ // second record.
+					"v": map[string]interface{}{
+						"f": []interface{}{
+							map[string]interface{}{
+								"v": []interface{}{
+									map[string]interface{}{
+										"v": "4",
+									},
+									map[string]interface{}{
+										"v": "5",
+									},
+									map[string]interface{}{
+										"v": "6",
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}}
+
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	want := []Value{ // the row is a list of length 1, containing an entry for the repeated record.
+		[]Value{ // the repeated record is a list of length 2, containing an entry for each repetition.
+			[]Value{ // the record is a list of length 1, containing an entry for the repeated integer field.
+				[]Value{1, 2, 3}, // the repeated integer field is a list of length 3.
+			},
+			[]Value{ // second record
+				[]Value{4, 5, 6},
+			},
+		},
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("converting repeated records with repeated values: got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+func TestRepeatedRecordContainingRecord(t *testing.T) {
+	schema := []*FieldSchema{
+		{
+			Type:     RecordFieldType,
+			Repeated: true,
+			Schema: Schema{
+				{
+					Type: StringFieldType,
+				},
+				{
+					Type: RecordFieldType,
+					Schema: Schema{
+						{Type: IntegerFieldType},
+						{Type: StringFieldType},
+					},
+				},
+			},
+		},
+	}
+	row := &bq.TableRow{F: []*bq.TableCell{
+		{
+			V: []interface{}{ // repeated records.
+				map[string]interface{}{ // first record.
+					"v": map[string]interface{}{ // pointless single-key-map wrapper.
+						"f": []interface{}{ // list of record fields.
+							map[string]interface{}{ // first record field (name)
+								"v": "first repeated record",
+							},
+							map[string]interface{}{ // second record field (nested record).
+								"v": map[string]interface{}{ // pointless single-key-map wrapper.
+									"f": []interface{}{ // nested record fields
+										map[string]interface{}{
+											"v": "1",
+										},
+										map[string]interface{}{
+											"v": "two",
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				map[string]interface{}{ // second record.
+					"v": map[string]interface{}{
+						"f": []interface{}{
+							map[string]interface{}{
+								"v": "second repeated record",
+							},
+							map[string]interface{}{
+								"v": map[string]interface{}{
+									"f": []interface{}{
+										map[string]interface{}{
+											"v": "3",
+										},
+										map[string]interface{}{
+											"v": "four",
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}}
+
+	got, err := convertRow(row, schema)
+	if err != nil {
+		t.Fatalf("error converting: %v", err)
+	}
+	// TODO: test with flattenresults.
+	want := []Value{ // the row is a list of length 1, containing an entry for the repeated record.
+		[]Value{ // the repeated record is a list of length 2, containing an entry for each repetition.
+			[]Value{ // record contains a string followed by a nested record.
+				"first repeated record",
+				[]Value{
+					1,
+					"two",
+				},
+			},
+			[]Value{ // second record.
+				"second repeated record",
+				[]Value{
+					3,
+					"four",
+				},
+			},
+		},
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("converting repeated records containing record : got:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+func TestValuesSaverConvertsToMap(t *testing.T) {
+	testCases := []struct {
+		vs   ValuesSaver
+		want *insertionRow
+	}{
+		{
+			vs: ValuesSaver{
+				Schema: []*FieldSchema{
+					{Name: "intField", Type: IntegerFieldType},
+					{Name: "strField", Type: StringFieldType},
+				},
+				InsertID: "iid",
+				Row:      []Value{1, "a"},
+			},
+			want: &insertionRow{
+				InsertID: "iid",
+				Row:      map[string]Value{"intField": 1, "strField": "a"},
+			},
+		},
+		{
+			vs: ValuesSaver{
+				Schema: []*FieldSchema{
+					{Name: "intField", Type: IntegerFieldType},
+					{
+						Name: "recordField",
+						Type: RecordFieldType,
+						Schema: []*FieldSchema{
+							{Name: "nestedInt", Type: IntegerFieldType, Repeated: true},
+						},
+					},
+				},
+				InsertID: "iid",
+				Row:      []Value{1, []Value{[]Value{2, 3}}},
+			},
+			want: &insertionRow{
+				InsertID: "iid",
+				Row: map[string]Value{
+					"intField": 1,
+					"recordField": map[string]Value{
+						"nestedInt": []Value{2, 3},
+					},
+				},
+			},
+		},
+	}
+	for _, tc := range testCases {
+		data, insertID, err := tc.vs.Save()
+		if err != nil {
+			t.Errorf("Expected successful save; got: %v", err)
+		}
+		got := &insertionRow{insertID, data}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("saving ValuesSaver: got:\n%v\nwant:\n%v", got, tc.want)
+		}
+	}
+}
+
+func TestConvertRows(t *testing.T) {
+	schema := []*FieldSchema{
+		{Type: StringFieldType},
+		{Type: IntegerFieldType},
+		{Type: FloatFieldType},
+		{Type: BooleanFieldType},
+	}
+	rows := []*bq.TableRow{
+		{F: []*bq.TableCell{
+			{V: "a"},
+			{V: "1"},
+			{V: "1.2"},
+			{V: "true"},
+		}},
+		{F: []*bq.TableCell{
+			{V: "b"},
+			{V: "2"},
+			{V: "2.2"},
+			{V: "false"},
+		}},
+	}
+	want := [][]Value{
+		{"a", 1, 1.2, true},
+		{"b", 2, 2.2, false},
+	}
+	got, err := convertRows(rows, schema)
+	if err != nil {
+		t.Fatalf("got %v, want nil", err)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("\ngot  %v\nwant %v", got, want)
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/admin.go
+++ b/vendor/cloud.google.com/go/bigtable/admin.go
@@ -0,0 +1,267 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	btopt "cloud.google.com/go/bigtable/internal/option"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	btapb "google.golang.org/genproto/googleapis/bigtable/admin/v2"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+const adminAddr = "bigtableadmin.googleapis.com:443"
+
+// AdminClient is a client type for performing admin operations within a specific instance.
+type AdminClient struct {
+	conn    *grpc.ClientConn
+	tClient btapb.BigtableTableAdminClient
+
+	project, instance string
+
+	// Metadata to be sent with each request.
+	md metadata.MD
+}
+
+// NewAdminClient creates a new AdminClient for a given project and instance.
+func NewAdminClient(ctx context.Context, project, instance string, opts ...option.ClientOption) (*AdminClient, error) {
+	o, err := btopt.DefaultClientOptions(adminAddr, AdminScope, clientUserAgent)
+	if err != nil {
+		return nil, err
+	}
+	o = append(o, opts...)
+	conn, err := transport.DialGRPC(ctx, o...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing: %v", err)
+	}
+	return &AdminClient{
+		conn:     conn,
+		tClient:  btapb.NewBigtableTableAdminClient(conn),
+		project:  project,
+		instance: instance,
+		md:       metadata.Pairs(resourcePrefixHeader, fmt.Sprintf("projects/%s/instances/%s", project, instance)),
+	}, nil
+}
+
+// Close closes the AdminClient.
+func (ac *AdminClient) Close() error {
+	return ac.conn.Close()
+}
+
+func (ac *AdminClient) instancePrefix() string {
+	return fmt.Sprintf("projects/%s/instances/%s", ac.project, ac.instance)
+}
+
+// Tables returns a list of the tables in the instance.
+func (ac *AdminClient) Tables(ctx context.Context) ([]string, error) {
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.ListTablesRequest{
+		Parent: prefix,
+	}
+	res, err := ac.tClient.ListTables(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	names := make([]string, 0, len(res.Tables))
+	for _, tbl := range res.Tables {
+		names = append(names, strings.TrimPrefix(tbl.Name, prefix+"/tables/"))
+	}
+	return names, nil
+}
+
+// CreateTable creates a new table in the instance.
+// This method may return before the table's creation is complete.
+func (ac *AdminClient) CreateTable(ctx context.Context, table string) error {
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.CreateTableRequest{
+		Parent:  prefix,
+		TableId: table,
+	}
+	_, err := ac.tClient.CreateTable(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// CreateColumnFamily creates a new column family in a table.
+func (ac *AdminClient) CreateColumnFamily(ctx context.Context, table, family string) error {
+	// TODO(dsymonds): Permit specifying gcexpr and any other family settings.
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.ModifyColumnFamiliesRequest{
+		Name: prefix + "/tables/" + table,
+		Modifications: []*btapb.ModifyColumnFamiliesRequest_Modification{
+			{
+				Id:  family,
+				Mod: &btapb.ModifyColumnFamiliesRequest_Modification_Create{Create: &btapb.ColumnFamily{}},
+			},
+		},
+	}
+	_, err := ac.tClient.ModifyColumnFamilies(ctx, req)
+	return err
+}
+
+// DeleteTable deletes a table and all of its data.
+func (ac *AdminClient) DeleteTable(ctx context.Context, table string) error {
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.DeleteTableRequest{
+		Name: prefix + "/tables/" + table,
+	}
+	_, err := ac.tClient.DeleteTable(ctx, req)
+	return err
+}
+
+// DeleteColumnFamily deletes a column family in a table and all of its data.
+func (ac *AdminClient) DeleteColumnFamily(ctx context.Context, table, family string) error {
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.ModifyColumnFamiliesRequest{
+		Name: prefix + "/tables/" + table,
+		Modifications: []*btapb.ModifyColumnFamiliesRequest_Modification{
+			{
+				Id:  family,
+				Mod: &btapb.ModifyColumnFamiliesRequest_Modification_Drop{Drop: true},
+			},
+		},
+	}
+	_, err := ac.tClient.ModifyColumnFamilies(ctx, req)
+	return err
+}
+
+// TableInfo represents information about a table.
+type TableInfo struct {
+	Families []string
+}
+
+// TableInfo retrieves information about a table.
+func (ac *AdminClient) TableInfo(ctx context.Context, table string) (*TableInfo, error) {
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.GetTableRequest{
+		Name: prefix + "/tables/" + table,
+	}
+	res, err := ac.tClient.GetTable(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	ti := &TableInfo{}
+	for fam := range res.ColumnFamilies {
+		ti.Families = append(ti.Families, fam)
+	}
+	return ti, nil
+}
+
+// SetGCPolicy specifies which cells in a column family should be garbage collected.
+// GC executes opportunistically in the background; table reads may return data
+// matching the GC policy.
+func (ac *AdminClient) SetGCPolicy(ctx context.Context, table, family string, policy GCPolicy) error {
+	ctx = metadata.NewContext(ctx, ac.md)
+	prefix := ac.instancePrefix()
+	req := &btapb.ModifyColumnFamiliesRequest{
+		Name: prefix + "/tables/" + table,
+		Modifications: []*btapb.ModifyColumnFamiliesRequest_Modification{
+			{
+				Id:  family,
+				Mod: &btapb.ModifyColumnFamiliesRequest_Modification_Update{Update: &btapb.ColumnFamily{GcRule: policy.proto()}},
+			},
+		},
+	}
+	_, err := ac.tClient.ModifyColumnFamilies(ctx, req)
+	return err
+}
+
+const instanceAdminAddr = "bigtableadmin.googleapis.com:443"
+
+// InstanceAdminClient is a client type for performing admin operations on instances.
+// These operations can be substantially more dangerous than those provided by AdminClient.
+type InstanceAdminClient struct {
+	conn    *grpc.ClientConn
+	iClient btapb.BigtableInstanceAdminClient
+
+	project string
+
+	// Metadata to be sent with each request.
+	md metadata.MD
+}
+
+// NewInstanceAdminClient creates a new InstanceAdminClient for a given project.
+func NewInstanceAdminClient(ctx context.Context, project string, opts ...option.ClientOption) (*InstanceAdminClient, error) {
+	o, err := btopt.DefaultClientOptions(instanceAdminAddr, InstanceAdminScope, clientUserAgent)
+	if err != nil {
+		return nil, err
+	}
+	o = append(o, opts...)
+	conn, err := transport.DialGRPC(ctx, o...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing: %v", err)
+	}
+	return &InstanceAdminClient{
+		conn:    conn,
+		iClient: btapb.NewBigtableInstanceAdminClient(conn),
+
+		project: project,
+		md:      metadata.Pairs(resourcePrefixHeader, "projects/"+project),
+	}, nil
+}
+
+// Close closes the InstanceAdminClient.
+func (iac *InstanceAdminClient) Close() error {
+	return iac.conn.Close()
+}
+
+// InstanceInfo represents information about an instance
+type InstanceInfo struct {
+	Name        string // name of the instance
+	DisplayName string // display name for UIs
+}
+
+var instanceNameRegexp = regexp.MustCompile(`^projects/([^/]+)/instances/([a-z][-a-z0-9]*)$`)
+
+// Instances returns a list of instances in the project.
+func (cac *InstanceAdminClient) Instances(ctx context.Context) ([]*InstanceInfo, error) {
+	ctx = metadata.NewContext(ctx, cac.md)
+	req := &btapb.ListInstancesRequest{
+		Parent: "projects/" + cac.project,
+	}
+	res, err := cac.iClient.ListInstances(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var is []*InstanceInfo
+	for _, i := range res.Instances {
+		m := instanceNameRegexp.FindStringSubmatch(i.Name)
+		if m == nil {
+			return nil, fmt.Errorf("malformed instance name %q", i.Name)
+		}
+		is = append(is, &InstanceInfo{
+			Name:        m[2],
+			DisplayName: i.DisplayName,
+		})
+	}
+	return is, nil
+}
--- a/vendor/cloud.google.com/go/bigtable/admin_test.go
+++ b/vendor/cloud.google.com/go/bigtable/admin_test.go
@@ -0,0 +1,73 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bigtable
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/bigtable/bttest"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/grpc"
+)
+
+func TestAdminIntegration(t *testing.T) {
+	srv, err := bttest.NewServer("127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer srv.Close()
+	t.Logf("bttest.Server running on %s", srv.Addr)
+
+	ctx, _ := context.WithTimeout(context.Background(), 2*time.Second)
+
+	conn, err := grpc.Dial(srv.Addr, grpc.WithInsecure())
+	if err != nil {
+		t.Fatalf("grpc.Dial: %v", err)
+	}
+
+	adminClient, err := NewAdminClient(ctx, "proj", "instance", option.WithGRPCConn(conn))
+	if err != nil {
+		t.Fatalf("NewAdminClient: %v", err)
+	}
+	defer adminClient.Close()
+
+	list := func() []string {
+		tbls, err := adminClient.Tables(ctx)
+		if err != nil {
+			t.Fatalf("Fetching list of tables: %v", err)
+		}
+		sort.Strings(tbls)
+		return tbls
+	}
+	if err := adminClient.CreateTable(ctx, "mytable"); err != nil {
+		t.Fatalf("Creating table: %v", err)
+	}
+	if err := adminClient.CreateTable(ctx, "myothertable"); err != nil {
+		t.Fatalf("Creating table: %v", err)
+	}
+	if got, want := list(), []string{"myothertable", "mytable"}; !reflect.DeepEqual(got, want) {
+		t.Errorf("adminClient.Tables returned %#v, want %#v", got, want)
+	}
+	if err := adminClient.DeleteTable(ctx, "myothertable"); err != nil {
+		t.Fatalf("Deleting table: %v", err)
+	}
+	if got, want := list(), []string{"mytable"}; !reflect.DeepEqual(got, want) {
+		t.Errorf("adminClient.Tables returned %#v, want %#v", got, want)
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/bigtable.go
+++ b/vendor/cloud.google.com/go/bigtable/bigtable.go
@@ -0,0 +1,717 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable // import "cloud.google.com/go/bigtable"
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+	"time"
+
+	"cloud.google.com/go/bigtable/internal/gax"
+	btopt "cloud.google.com/go/bigtable/internal/option"
+	"github.com/golang/protobuf/proto"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	btpb "google.golang.org/genproto/googleapis/bigtable/v2"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+const prodAddr = "bigtable.googleapis.com:443"
+
+// Client is a client for reading and writing data to tables in an instance.
+//
+// A Client is safe to use concurrently, except for its Close method.
+type Client struct {
+	conn              *grpc.ClientConn
+	client            btpb.BigtableClient
+	project, instance string
+}
+
+// NewClient creates a new Client for a given project and instance.
+func NewClient(ctx context.Context, project, instance string, opts ...option.ClientOption) (*Client, error) {
+	o, err := btopt.DefaultClientOptions(prodAddr, Scope, clientUserAgent)
+	if err != nil {
+		return nil, err
+	}
+	o = append(o, opts...)
+	conn, err := transport.DialGRPC(ctx, o...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing: %v", err)
+	}
+	return &Client{
+		conn:     conn,
+		client:   btpb.NewBigtableClient(conn),
+		project:  project,
+		instance: instance,
+	}, nil
+}
+
+// Close closes the Client.
+func (c *Client) Close() error {
+	return c.conn.Close()
+}
+
+var (
+	idempotentRetryCodes  = []codes.Code{codes.DeadlineExceeded, codes.Unavailable, codes.Aborted}
+	isIdempotentRetryCode = make(map[codes.Code]bool)
+	retryOptions          = []gax.CallOption{
+		gax.WithDelayTimeoutSettings(100*time.Millisecond, 2000*time.Millisecond, 1.2),
+		gax.WithRetryCodes(idempotentRetryCodes),
+	}
+)
+
+func init() {
+	for _, code := range idempotentRetryCodes {
+		isIdempotentRetryCode[code] = true
+	}
+}
+
+func (c *Client) fullTableName(table string) string {
+	return fmt.Sprintf("projects/%s/instances/%s/tables/%s", c.project, c.instance, table)
+}
+
+// A Table refers to a table.
+//
+// A Table is safe to use concurrently.
+type Table struct {
+	c     *Client
+	table string
+
+	// Metadata to be sent with each request.
+	md metadata.MD
+}
+
+// Open opens a table.
+func (c *Client) Open(table string) *Table {
+	return &Table{
+		c:     c,
+		table: table,
+		md:    metadata.Pairs(resourcePrefixHeader, c.fullTableName(table)),
+	}
+}
+
+// TODO(dsymonds): Read method that returns a sequence of ReadItems.
+
+// ReadRows reads rows from a table. f is called for each row.
+// If f returns false, the stream is shut down and ReadRows returns.
+// f owns its argument, and f is called serially in order by row key.
+//
+// By default, the yielded rows will contain all values in all cells.
+// Use RowFilter to limit the cells returned.
+func (t *Table) ReadRows(ctx context.Context, arg RowSet, f func(Row) bool, opts ...ReadOption) error {
+	ctx = metadata.NewContext(ctx, t.md)
+
+	var prevRowKey string
+	err := gax.Invoke(ctx, func(ctx context.Context) error {
+		req := &btpb.ReadRowsRequest{
+			TableName: t.c.fullTableName(t.table),
+			Rows:      arg.proto(),
+		}
+		for _, opt := range opts {
+			opt.set(req)
+		}
+		ctx, cancel := context.WithCancel(ctx) // for aborting the stream
+		defer cancel()
+
+		stream, err := t.c.client.ReadRows(ctx, req)
+		if err != nil {
+			return err
+		}
+		cr := newChunkReader()
+		for {
+			res, err := stream.Recv()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				// Reset arg for next Invoke call.
+				arg = arg.retainRowsAfter(prevRowKey)
+				return err
+			}
+
+			for _, cc := range res.Chunks {
+				row, err := cr.Process(cc)
+				if err != nil {
+					// No need to prepare for a retry, this is an unretryable error.
+					return err
+				}
+				if row == nil {
+					continue
+				}
+				prevRowKey = row.Key()
+				if !f(row) {
+					// Cancel and drain stream.
+					cancel()
+					for {
+						if _, err := stream.Recv(); err != nil {
+							// The stream has ended. We don't return an error
+							// because the caller has intentionally interrupted the scan.
+							return nil
+						}
+					}
+				}
+			}
+			if err := cr.Close(); err != nil {
+				// No need to prepare for a retry, this is an unretryable error.
+				return err
+			}
+		}
+		return err
+	}, retryOptions...)
+
+	return err
+}
+
+// ReadRow is a convenience implementation of a single-row reader.
+// A missing row will return a zero-length map and a nil error.
+func (t *Table) ReadRow(ctx context.Context, row string, opts ...ReadOption) (Row, error) {
+	var r Row
+	err := t.ReadRows(ctx, SingleRow(row), func(rr Row) bool {
+		r = rr
+		return true
+	}, opts...)
+	return r, err
+}
+
+// decodeFamilyProto adds the cell data from f to the given row.
+func decodeFamilyProto(r Row, row string, f *btpb.Family) {
+	fam := f.Name // does not have colon
+	for _, col := range f.Columns {
+		for _, cell := range col.Cells {
+			ri := ReadItem{
+				Row:       row,
+				Column:    fam + ":" + string(col.Qualifier),
+				Timestamp: Timestamp(cell.TimestampMicros),
+				Value:     cell.Value,
+			}
+			r[fam] = append(r[fam], ri)
+		}
+	}
+}
+
+// RowSet is a set of rows to be read. It is satisfied by RowList and RowRange.
+type RowSet interface {
+	proto() *btpb.RowSet
+
+	// retainRowsAfter returns a new RowSet that does not include the
+	// given row key or any row key lexicographically less than it.
+	retainRowsAfter(lastRowKey string) RowSet
+}
+
+// RowList is a sequence of row keys.
+type RowList []string
+
+func (r RowList) proto() *btpb.RowSet {
+	keys := make([][]byte, len(r))
+	for i, row := range r {
+		keys[i] = []byte(row)
+	}
+	return &btpb.RowSet{RowKeys: keys}
+}
+
+func (r RowList) retainRowsAfter(lastRowKey string) RowSet {
+	var retryKeys RowList
+	for _, key := range r {
+		if key > lastRowKey {
+			retryKeys = append(retryKeys, key)
+		}
+	}
+	return retryKeys
+}
+
+// A RowRange is a half-open interval [Start, Limit) encompassing
+// all the rows with keys at least as large as Start, and less than Limit.
+// (Bigtable string comparison is the same as Go's.)
+// A RowRange can be unbounded, encompassing all keys at least as large as Start.
+type RowRange struct {
+	start string
+	limit string
+}
+
+// NewRange returns the new RowRange [begin, end).
+func NewRange(begin, end string) RowRange {
+	return RowRange{
+		start: begin,
+		limit: end,
+	}
+}
+
+// Unbounded tests whether a RowRange is unbounded.
+func (r RowRange) Unbounded() bool {
+	return r.limit == ""
+}
+
+// Contains says whether the RowRange contains the key.
+func (r RowRange) Contains(row string) bool {
+	return r.start <= row && (r.limit == "" || r.limit > row)
+}
+
+// String provides a printable description of a RowRange.
+func (r RowRange) String() string {
+	a := strconv.Quote(r.start)
+	if r.Unbounded() {
+		return fmt.Sprintf("[%s,∞)", a)
+	}
+	return fmt.Sprintf("[%s,%q)", a, r.limit)
+}
+
+func (r RowRange) proto() *btpb.RowSet {
+	var rr *btpb.RowRange
+	rr = &btpb.RowRange{StartKey: &btpb.RowRange_StartKeyClosed{StartKeyClosed: []byte(r.start)}}
+	if !r.Unbounded() {
+		rr.EndKey = &btpb.RowRange_EndKeyOpen{EndKeyOpen: []byte(r.limit)}
+	}
+	return &btpb.RowSet{RowRanges: []*btpb.RowRange{rr}}
+}
+
+func (r RowRange) retainRowsAfter(lastRowKey string) RowSet {
+	// Set the beginning of the range to the row after the last scanned.
+	start := lastRowKey + "\x00"
+	if r.Unbounded() {
+		return InfiniteRange(start)
+	}
+	return NewRange(start, r.limit)
+}
+
+// SingleRow returns a RowRange for reading a single row.
+func SingleRow(row string) RowRange {
+	return RowRange{
+		start: row,
+		limit: row + "\x00",
+	}
+}
+
+// PrefixRange returns a RowRange consisting of all keys starting with the prefix.
+func PrefixRange(prefix string) RowRange {
+	return RowRange{
+		start: prefix,
+		limit: prefixSuccessor(prefix),
+	}
+}
+
+// InfiniteRange returns the RowRange consisting of all keys at least as
+// large as start.
+func InfiniteRange(start string) RowRange {
+	return RowRange{
+		start: start,
+		limit: "",
+	}
+}
+
+// prefixSuccessor returns the lexically smallest string greater than the
+// prefix, if it exists, or "" otherwise.  In either case, it is the string
+// needed for the Limit of a RowRange.
+func prefixSuccessor(prefix string) string {
+	if prefix == "" {
+		return "" // infinite range
+	}
+	n := len(prefix)
+	for n--; n >= 0 && prefix[n] == '\xff'; n-- {
+	}
+	if n == -1 {
+		return ""
+	}
+	ans := []byte(prefix[:n])
+	ans = append(ans, prefix[n]+1)
+	return string(ans)
+}
+
+// A ReadOption is an optional argument to ReadRows.
+type ReadOption interface {
+	set(req *btpb.ReadRowsRequest)
+}
+
+// RowFilter returns a ReadOption that applies f to the contents of read rows.
+func RowFilter(f Filter) ReadOption { return rowFilter{f} }
+
+type rowFilter struct{ f Filter }
+
+func (rf rowFilter) set(req *btpb.ReadRowsRequest) { req.Filter = rf.f.proto() }
+
+// LimitRows returns a ReadOption that will limit the number of rows to be read.
+func LimitRows(limit int64) ReadOption { return limitRows{limit} }
+
+type limitRows struct{ limit int64 }
+
+func (lr limitRows) set(req *btpb.ReadRowsRequest) { req.RowsLimit = lr.limit }
+
+// mutationsAreRetryable returns true if all mutations are idempotent
+// and therefore retryable. A mutation is idempotent iff all cell timestamps
+// have an explicit timestamp set and do not rely on the timestamp being set on the server.
+func mutationsAreRetryable(muts []*btpb.Mutation) bool {
+	serverTime := int64(ServerTime)
+	for _, mut := range muts {
+		setCell := mut.GetSetCell()
+		if setCell != nil && setCell.TimestampMicros == serverTime {
+			return false
+		}
+	}
+	return true
+}
+
+// Apply applies a Mutation to a specific row.
+func (t *Table) Apply(ctx context.Context, row string, m *Mutation, opts ...ApplyOption) error {
+	ctx = metadata.NewContext(ctx, t.md)
+	after := func(res proto.Message) {
+		for _, o := range opts {
+			o.after(res)
+		}
+	}
+
+	var callOptions []gax.CallOption
+	if m.cond == nil {
+		req := &btpb.MutateRowRequest{
+			TableName: t.c.fullTableName(t.table),
+			RowKey:    []byte(row),
+			Mutations: m.ops,
+		}
+		if mutationsAreRetryable(m.ops) {
+			callOptions = retryOptions
+		}
+		var res *btpb.MutateRowResponse
+		err := gax.Invoke(ctx, func(ctx context.Context) error {
+			var err error
+			res, err = t.c.client.MutateRow(ctx, req)
+			return err
+		}, callOptions...)
+		if err == nil {
+			after(res)
+		}
+		return err
+	}
+
+	req := &btpb.CheckAndMutateRowRequest{
+		TableName:       t.c.fullTableName(t.table),
+		RowKey:          []byte(row),
+		PredicateFilter: m.cond.proto(),
+	}
+	if m.mtrue != nil {
+		req.TrueMutations = m.mtrue.ops
+	}
+	if m.mfalse != nil {
+		req.FalseMutations = m.mfalse.ops
+	}
+	if mutationsAreRetryable(req.TrueMutations) && mutationsAreRetryable(req.FalseMutations) {
+		callOptions = retryOptions
+	}
+	var cmRes *btpb.CheckAndMutateRowResponse
+	err := gax.Invoke(ctx, func(ctx context.Context) error {
+		var err error
+		cmRes, err = t.c.client.CheckAndMutateRow(ctx, req)
+		return err
+	}, callOptions...)
+	if err == nil {
+		after(cmRes)
+	}
+	return err
+}
+
+// An ApplyOption is an optional argument to Apply.
+type ApplyOption interface {
+	after(res proto.Message)
+}
+
+type applyAfterFunc func(res proto.Message)
+
+func (a applyAfterFunc) after(res proto.Message) { a(res) }
+
+// GetCondMutationResult returns an ApplyOption that reports whether the conditional
+// mutation's condition matched.
+func GetCondMutationResult(matched *bool) ApplyOption {
+	return applyAfterFunc(func(res proto.Message) {
+		if res, ok := res.(*btpb.CheckAndMutateRowResponse); ok {
+			*matched = res.PredicateMatched
+		}
+	})
+}
+
+// Mutation represents a set of changes for a single row of a table.
+type Mutation struct {
+	ops []*btpb.Mutation
+
+	// for conditional mutations
+	cond          Filter
+	mtrue, mfalse *Mutation
+}
+
+// NewMutation returns a new mutation.
+func NewMutation() *Mutation {
+	return new(Mutation)
+}
+
+// NewCondMutation returns a conditional mutation.
+// The given row filter determines which mutation is applied:
+// If the filter matches any cell in the row, mtrue is applied;
+// otherwise, mfalse is applied.
+// Either given mutation may be nil.
+func NewCondMutation(cond Filter, mtrue, mfalse *Mutation) *Mutation {
+	return &Mutation{cond: cond, mtrue: mtrue, mfalse: mfalse}
+}
+
+// Set sets a value in a specified column, with the given timestamp.
+// The timestamp will be truncated to millisecond resolution.
+// A timestamp of ServerTime means to use the server timestamp.
+func (m *Mutation) Set(family, column string, ts Timestamp, value []byte) {
+	if ts != ServerTime {
+		// Truncate to millisecond resolution, since that's the default table config.
+		// TODO(dsymonds): Provide a way to override this behaviour.
+		ts -= ts % 1000
+	}
+	m.ops = append(m.ops, &btpb.Mutation{Mutation: &btpb.Mutation_SetCell_{&btpb.Mutation_SetCell{
+		FamilyName:      family,
+		ColumnQualifier: []byte(column),
+		TimestampMicros: int64(ts),
+		Value:           value,
+	}}})
+}
+
+// DeleteCellsInColumn will delete all the cells whose columns are family:column.
+func (m *Mutation) DeleteCellsInColumn(family, column string) {
+	m.ops = append(m.ops, &btpb.Mutation{Mutation: &btpb.Mutation_DeleteFromColumn_{&btpb.Mutation_DeleteFromColumn{
+		FamilyName:      family,
+		ColumnQualifier: []byte(column),
+	}}})
+}
+
+// DeleteTimestampRange deletes all cells whose columns are family:column
+// and whose timestamps are in the half-open interval [start, end).
+// If end is zero, it will be interpreted as infinity.
+func (m *Mutation) DeleteTimestampRange(family, column string, start, end Timestamp) {
+	m.ops = append(m.ops, &btpb.Mutation{Mutation: &btpb.Mutation_DeleteFromColumn_{&btpb.Mutation_DeleteFromColumn{
+		FamilyName:      family,
+		ColumnQualifier: []byte(column),
+		TimeRange: &btpb.TimestampRange{
+			StartTimestampMicros: int64(start),
+			EndTimestampMicros:   int64(end),
+		},
+	}}})
+}
+
+// DeleteCellsInFamily will delete all the cells whose columns are family:*.
+func (m *Mutation) DeleteCellsInFamily(family string) {
+	m.ops = append(m.ops, &btpb.Mutation{Mutation: &btpb.Mutation_DeleteFromFamily_{&btpb.Mutation_DeleteFromFamily{
+		FamilyName: family,
+	}}})
+}
+
+// DeleteRow deletes the entire row.
+func (m *Mutation) DeleteRow() {
+	m.ops = append(m.ops, &btpb.Mutation{Mutation: &btpb.Mutation_DeleteFromRow_{&btpb.Mutation_DeleteFromRow{}}})
+}
+
+// entryErr is a container that combines an entry with the error that was returned for it.
+// Err may be nil if no error was returned for the Entry, or if the Entry has not yet been processed.
+type entryErr struct {
+	Entry *btpb.MutateRowsRequest_Entry
+	Err   error
+}
+
+// ApplyBulk applies multiple Mutations.
+// Each mutation is individually applied atomically,
+// but the set of mutations may be applied in any order.
+//
+// Two types of failures may occur. If the entire process
+// fails, (nil, err) will be returned. If specific mutations
+// fail to apply, ([]err, nil) will be returned, and the errors
+// will correspond to the relevant rowKeys/muts arguments.
+//
+// Conditional mutations cannot be applied in bulk and providing one will result in an error.
+func (t *Table) ApplyBulk(ctx context.Context, rowKeys []string, muts []*Mutation, opts ...ApplyOption) ([]error, error) {
+	ctx = metadata.NewContext(ctx, t.md)
+	if len(rowKeys) != len(muts) {
+		return nil, fmt.Errorf("mismatched rowKeys and mutation array lengths: %d, %d", len(rowKeys), len(muts))
+	}
+
+	origEntries := make([]*entryErr, len(rowKeys))
+	for i, key := range rowKeys {
+		mut := muts[i]
+		if mut.cond != nil {
+			return nil, errors.New("conditional mutations cannot be applied in bulk")
+		}
+		origEntries[i] = &entryErr{Entry: &btpb.MutateRowsRequest_Entry{RowKey: []byte(key), Mutations: mut.ops}}
+	}
+
+	// entries will be reduced after each invocation to just what needs to be retried.
+	entries := make([]*entryErr, len(rowKeys))
+	copy(entries, origEntries)
+	err := gax.Invoke(ctx, func(ctx context.Context) error {
+		err := t.doApplyBulk(ctx, entries, opts...)
+		if err != nil {
+			// We want to retry the entire request with the current entries
+			return err
+		}
+		entries = t.getApplyBulkRetries(entries)
+		if len(entries) > 0 && len(idempotentRetryCodes) > 0 {
+			// We have at least one mutation that needs to be retried.
+			// Return an arbitrary error that is retryable according to callOptions.
+			return grpc.Errorf(idempotentRetryCodes[0], "Synthetic error: partial failure of ApplyBulk")
+		}
+		return nil
+	}, retryOptions...)
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Accumulate all of the errors into an array to return, interspersed with nils for successful
+	// entries. The absence of any errors means we should return nil.
+	var errs []error
+	var foundErr bool
+	for _, entry := range origEntries {
+		if entry.Err != nil {
+			foundErr = true
+		}
+		errs = append(errs, entry.Err)
+	}
+	if foundErr {
+		return errs, nil
+	}
+	return nil, nil
+}
+
+// getApplyBulkRetries returns the entries that need to be retried
+func (t *Table) getApplyBulkRetries(entries []*entryErr) []*entryErr {
+	var retryEntries []*entryErr
+	for _, entry := range entries {
+		err := entry.Err
+		if err != nil && isIdempotentRetryCode[grpc.Code(err)] && mutationsAreRetryable(entry.Entry.Mutations) {
+			// There was an error and the entry is retryable.
+			retryEntries = append(retryEntries, entry)
+		}
+	}
+	return retryEntries
+}
+
+// doApplyBulk does the work of a single ApplyBulk invocation
+func (t *Table) doApplyBulk(ctx context.Context, entryErrs []*entryErr, opts ...ApplyOption) error {
+	after := func(res proto.Message) {
+		for _, o := range opts {
+			o.after(res)
+		}
+	}
+
+	entries := make([]*btpb.MutateRowsRequest_Entry, len(entryErrs))
+	for i, entryErr := range entryErrs {
+		entries[i] = entryErr.Entry
+	}
+	req := &btpb.MutateRowsRequest{
+		TableName: t.c.fullTableName(t.table),
+		Entries:   entries,
+	}
+	stream, err := t.c.client.MutateRows(ctx, req)
+	if err != nil {
+		return err
+	}
+	for {
+		res, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		for i, entry := range res.Entries {
+			status := entry.Status
+			if status.Code == int32(codes.OK) {
+				entryErrs[i].Err = nil
+			} else {
+				entryErrs[i].Err = grpc.Errorf(codes.Code(status.Code), status.Message)
+			}
+		}
+		after(res)
+	}
+	return nil
+}
+
+// Timestamp is in units of microseconds since 1 January 1970.
+type Timestamp int64
+
+// ServerTime is a specific Timestamp that may be passed to (*Mutation).Set.
+// It indicates that the server's timestamp should be used.
+const ServerTime Timestamp = -1
+
+// Time converts a time.Time into a Timestamp.
+func Time(t time.Time) Timestamp { return Timestamp(t.UnixNano() / 1e3) }
+
+// Now returns the Timestamp representation of the current time on the client.
+func Now() Timestamp { return Time(time.Now()) }
+
+// Time converts a Timestamp into a time.Time.
+func (ts Timestamp) Time() time.Time { return time.Unix(0, int64(ts)*1e3) }
+
+// ApplyReadModifyWrite applies a ReadModifyWrite to a specific row.
+// It returns the newly written cells.
+func (t *Table) ApplyReadModifyWrite(ctx context.Context, row string, m *ReadModifyWrite) (Row, error) {
+	ctx = metadata.NewContext(ctx, t.md)
+	req := &btpb.ReadModifyWriteRowRequest{
+		TableName: t.c.fullTableName(t.table),
+		RowKey:    []byte(row),
+		Rules:     m.ops,
+	}
+	res, err := t.c.client.ReadModifyWriteRow(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	r := make(Row)
+	for _, fam := range res.Row.Families { // res is *btpb.Row, fam is *btpb.Family
+		decodeFamilyProto(r, row, fam)
+	}
+	return r, nil
+}
+
+// ReadModifyWrite represents a set of operations on a single row of a table.
+// It is like Mutation but for non-idempotent changes.
+// When applied, these operations operate on the latest values of the row's cells,
+// and result in a new value being written to the relevant cell with a timestamp
+// that is max(existing timestamp, current server time).
+//
+// The application of a ReadModifyWrite is atomic; concurrent ReadModifyWrites will
+// be executed serially by the server.
+type ReadModifyWrite struct {
+	ops []*btpb.ReadModifyWriteRule
+}
+
+// NewReadModifyWrite returns a new ReadModifyWrite.
+func NewReadModifyWrite() *ReadModifyWrite { return new(ReadModifyWrite) }
+
+// AppendValue appends a value to a specific cell's value.
+// If the cell is unset, it will be treated as an empty value.
+func (m *ReadModifyWrite) AppendValue(family, column string, v []byte) {
+	m.ops = append(m.ops, &btpb.ReadModifyWriteRule{
+		FamilyName:      family,
+		ColumnQualifier: []byte(column),
+		Rule:            &btpb.ReadModifyWriteRule_AppendValue{v},
+	})
+}
+
+// Increment interprets the value in a specific cell as a 64-bit big-endian signed integer,
+// and adds a value to it. If the cell is unset, it will be treated as zero.
+// If the cell is set and is not an 8-byte value, the entire ApplyReadModifyWrite
+// operation will fail.
+func (m *ReadModifyWrite) Increment(family, column string, delta int64) {
+	m.ops = append(m.ops, &btpb.ReadModifyWriteRule{
+		FamilyName:      family,
+		ColumnQualifier: []byte(column),
+		Rule:            &btpb.ReadModifyWriteRule_IncrementAmount{delta},
+	})
+}
--- a/vendor/cloud.google.com/go/bigtable/bigtable_test.go
+++ b/vendor/cloud.google.com/go/bigtable/bigtable_test.go
@@ -0,0 +1,596 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable
+
+import (
+	"flag"
+	"fmt"
+	"math/rand"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/bigtable/bttest"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/grpc"
+)
+
+func TestPrefix(t *testing.T) {
+	tests := []struct {
+		prefix, succ string
+	}{
+		{"", ""},
+		{"\xff", ""}, // when used, "" means Infinity
+		{"x\xff", "y"},
+		{"\xfe", "\xff"},
+	}
+	for _, tc := range tests {
+		got := prefixSuccessor(tc.prefix)
+		if got != tc.succ {
+			t.Errorf("prefixSuccessor(%q) = %q, want %s", tc.prefix, got, tc.succ)
+			continue
+		}
+		r := PrefixRange(tc.prefix)
+		if tc.succ == "" && r.limit != "" {
+			t.Errorf("PrefixRange(%q) got limit %q", tc.prefix, r.limit)
+		}
+		if tc.succ != "" && r.limit != tc.succ {
+			t.Errorf("PrefixRange(%q) got limit %q, want %q", tc.prefix, r.limit, tc.succ)
+		}
+	}
+}
+
+var useProd = flag.String("use_prod", "", `if set to "proj,instance,table", run integration test against production`)
+
+func TestClientIntegration(t *testing.T) {
+	start := time.Now()
+	lastCheckpoint := start
+	checkpoint := func(s string) {
+		n := time.Now()
+		t.Logf("[%s] %v since start, %v since last checkpoint", s, n.Sub(start), n.Sub(lastCheckpoint))
+		lastCheckpoint = n
+	}
+
+	proj, instance, table := "proj", "instance", "mytable"
+	var clientOpts []option.ClientOption
+	timeout := 20 * time.Second
+	if *useProd == "" {
+		srv, err := bttest.NewServer("127.0.0.1:0")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer srv.Close()
+		t.Logf("bttest.Server running on %s", srv.Addr)
+		conn, err := grpc.Dial(srv.Addr, grpc.WithInsecure())
+		if err != nil {
+			t.Fatalf("grpc.Dial: %v", err)
+		}
+		clientOpts = []option.ClientOption{option.WithGRPCConn(conn)}
+	} else {
+		t.Logf("Running test against production")
+		a := strings.SplitN(*useProd, ",", 3)
+		proj, instance, table = a[0], a[1], a[2]
+		timeout = 5 * time.Minute
+	}
+
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+
+	client, err := NewClient(ctx, proj, instance, clientOpts...)
+	if err != nil {
+		t.Fatalf("NewClient: %v", err)
+	}
+	defer client.Close()
+	checkpoint("dialed Client")
+
+	adminClient, err := NewAdminClient(ctx, proj, instance, clientOpts...)
+	if err != nil {
+		t.Fatalf("NewAdminClient: %v", err)
+	}
+	defer adminClient.Close()
+	checkpoint("dialed AdminClient")
+
+	// Delete the table at the end of the test.
+	// Do this even before creating the table so that if this is running
+	// against production and CreateTable fails there's a chance of cleaning it up.
+	defer adminClient.DeleteTable(ctx, table)
+
+	if err := adminClient.CreateTable(ctx, table); err != nil {
+		t.Fatalf("Creating table: %v", err)
+	}
+	checkpoint("created table")
+	if err := adminClient.CreateColumnFamily(ctx, table, "follows"); err != nil {
+		t.Fatalf("Creating column family: %v", err)
+	}
+	checkpoint(`created "follows" column family`)
+
+	tbl := client.Open(table)
+
+	// Insert some data.
+	initialData := map[string][]string{
+		"wmckinley":   {"tjefferson"},
+		"gwashington": {"jadams"},
+		"tjefferson":  {"gwashington", "jadams"}, // wmckinley set conditionally below
+		"jadams":      {"gwashington", "tjefferson"},
+	}
+	for row, ss := range initialData {
+		mut := NewMutation()
+		for _, name := range ss {
+			mut.Set("follows", name, 0, []byte("1"))
+		}
+		if err := tbl.Apply(ctx, row, mut); err != nil {
+			t.Errorf("Mutating row %q: %v", row, err)
+		}
+	}
+	checkpoint("inserted initial data")
+
+	// Do a conditional mutation with a complex filter.
+	mutTrue := NewMutation()
+	mutTrue.Set("follows", "wmckinley", 0, []byte("1"))
+	filter := ChainFilters(ColumnFilter("gwash[iz].*"), ValueFilter("."))
+	mut := NewCondMutation(filter, mutTrue, nil)
+	if err := tbl.Apply(ctx, "tjefferson", mut); err != nil {
+		t.Errorf("Conditionally mutating row: %v", err)
+	}
+	// Do a second condition mutation with a filter that does not match,
+	// and thus no changes should be made.
+	mutTrue = NewMutation()
+	mutTrue.DeleteRow()
+	filter = ColumnFilter("snoop.dogg")
+	mut = NewCondMutation(filter, mutTrue, nil)
+	if err := tbl.Apply(ctx, "tjefferson", mut); err != nil {
+		t.Errorf("Conditionally mutating row: %v", err)
+	}
+	checkpoint("did two conditional mutations")
+
+	// Fetch a row.
+	row, err := tbl.ReadRow(ctx, "jadams")
+	if err != nil {
+		t.Fatalf("Reading a row: %v", err)
+	}
+	wantRow := Row{
+		"follows": []ReadItem{
+			{Row: "jadams", Column: "follows:gwashington", Value: []byte("1")},
+			{Row: "jadams", Column: "follows:tjefferson", Value: []byte("1")},
+		},
+	}
+	for _, ris := range row {
+		sort.Sort(byColumn(ris))
+	}
+	if !reflect.DeepEqual(row, wantRow) {
+		t.Errorf("Read row mismatch.\n got %#v\nwant %#v", row, wantRow)
+	}
+	checkpoint("tested ReadRow")
+
+	// Do a bunch of reads with filters.
+	readTests := []struct {
+		desc   string
+		rr     RowRange
+		filter Filter // may be nil
+
+		// We do the read, grab all the cells, turn them into "<row>-<col>-<val>",
+		// sort that list, and join with a comma.
+		want string
+	}{
+		{
+			desc: "read all, unfiltered",
+			rr:   RowRange{},
+			want: "gwashington-jadams-1,jadams-gwashington-1,jadams-tjefferson-1,tjefferson-gwashington-1,tjefferson-jadams-1,tjefferson-wmckinley-1,wmckinley-tjefferson-1",
+		},
+		{
+			desc: "read with InfiniteRange, unfiltered",
+			rr:   InfiniteRange("tjefferson"),
+			want: "tjefferson-gwashington-1,tjefferson-jadams-1,tjefferson-wmckinley-1,wmckinley-tjefferson-1",
+		},
+		{
+			desc: "read with NewRange, unfiltered",
+			rr:   NewRange("gargamel", "hubbard"),
+			want: "gwashington-jadams-1",
+		},
+		{
+			desc: "read with PrefixRange, unfiltered",
+			rr:   PrefixRange("jad"),
+			want: "jadams-gwashington-1,jadams-tjefferson-1",
+		},
+		{
+			desc: "read with SingleRow, unfiltered",
+			rr:   SingleRow("wmckinley"),
+			want: "wmckinley-tjefferson-1",
+		},
+		{
+			desc:   "read all, with ColumnFilter",
+			rr:     RowRange{},
+			filter: ColumnFilter(".*j.*"), // matches "jadams" and "tjefferson"
+			want:   "gwashington-jadams-1,jadams-tjefferson-1,tjefferson-jadams-1,wmckinley-tjefferson-1",
+		},
+	}
+	for _, tc := range readTests {
+		var opts []ReadOption
+		if tc.filter != nil {
+			opts = append(opts, RowFilter(tc.filter))
+		}
+		var elt []string
+		err := tbl.ReadRows(context.Background(), tc.rr, func(r Row) bool {
+			for _, ris := range r {
+				for _, ri := range ris {
+					elt = append(elt, formatReadItem(ri))
+				}
+			}
+			return true
+		}, opts...)
+		if err != nil {
+			t.Errorf("%s: %v", tc.desc, err)
+			continue
+		}
+		sort.Strings(elt)
+		if got := strings.Join(elt, ","); got != tc.want {
+			t.Errorf("%s: wrong reads.\n got %q\nwant %q", tc.desc, got, tc.want)
+		}
+	}
+	// Read a RowList
+	var elt []string
+	keys := RowList{"wmckinley", "gwashington", "jadams"}
+	want := "gwashington-jadams-1,jadams-gwashington-1,jadams-tjefferson-1,wmckinley-tjefferson-1"
+	err = tbl.ReadRows(ctx, keys, func(r Row) bool {
+		for _, ris := range r {
+			for _, ri := range ris {
+				elt = append(elt, formatReadItem(ri))
+			}
+		}
+		return true
+	})
+	if err != nil {
+		t.Errorf("read RowList: %v", err)
+	}
+
+	sort.Strings(elt)
+	if got := strings.Join(elt, ","); got != want {
+		t.Errorf("bulk read: wrong reads.\n got %q\nwant %q", got, want)
+	}
+	checkpoint("tested ReadRows in a few ways")
+
+	// Do a scan and stop part way through.
+	// Verify that the ReadRows callback doesn't keep running.
+	stopped := false
+	err = tbl.ReadRows(ctx, InfiniteRange(""), func(r Row) bool {
+		if r.Key() < "h" {
+			return true
+		}
+		if !stopped {
+			stopped = true
+			return false
+		}
+		t.Errorf("ReadRows kept scanning to row %q after being told to stop", r.Key())
+		return false
+	})
+	if err != nil {
+		t.Errorf("Partial ReadRows: %v", err)
+	}
+	checkpoint("did partial ReadRows test")
+
+	// Delete a row and check it goes away.
+	mut = NewMutation()
+	mut.DeleteRow()
+	if err := tbl.Apply(ctx, "wmckinley", mut); err != nil {
+		t.Errorf("Apply DeleteRow: %v", err)
+	}
+	row, err = tbl.ReadRow(ctx, "wmckinley")
+	if err != nil {
+		t.Fatalf("Reading a row after DeleteRow: %v", err)
+	}
+	if len(row) != 0 {
+		t.Fatalf("Read non-zero row after DeleteRow: %v", row)
+	}
+	checkpoint("exercised DeleteRow")
+
+	// Check ReadModifyWrite.
+
+	if err := adminClient.CreateColumnFamily(ctx, table, "counter"); err != nil {
+		t.Fatalf("Creating column family: %v", err)
+	}
+
+	appendRMW := func(b []byte) *ReadModifyWrite {
+		rmw := NewReadModifyWrite()
+		rmw.AppendValue("counter", "likes", b)
+		return rmw
+	}
+	incRMW := func(n int64) *ReadModifyWrite {
+		rmw := NewReadModifyWrite()
+		rmw.Increment("counter", "likes", n)
+		return rmw
+	}
+	rmwSeq := []struct {
+		desc string
+		rmw  *ReadModifyWrite
+		want []byte
+	}{
+		{
+			desc: "append #1",
+			rmw:  appendRMW([]byte{0, 0, 0}),
+			want: []byte{0, 0, 0},
+		},
+		{
+			desc: "append #2",
+			rmw:  appendRMW([]byte{0, 0, 0, 0, 17}), // the remaining 40 bits to make a big-endian 17
+			want: []byte{0, 0, 0, 0, 0, 0, 0, 17},
+		},
+		{
+			desc: "increment",
+			rmw:  incRMW(8),
+			want: []byte{0, 0, 0, 0, 0, 0, 0, 25},
+		},
+	}
+	for _, step := range rmwSeq {
+		row, err := tbl.ApplyReadModifyWrite(ctx, "gwashington", step.rmw)
+		if err != nil {
+			t.Fatalf("ApplyReadModifyWrite %+v: %v", step.rmw, err)
+		}
+		clearTimestamps(row)
+		wantRow := Row{"counter": []ReadItem{{Row: "gwashington", Column: "counter:likes", Value: step.want}}}
+		if !reflect.DeepEqual(row, wantRow) {
+			t.Fatalf("After %s,\n got %v\nwant %v", step.desc, row, wantRow)
+		}
+	}
+	checkpoint("tested ReadModifyWrite")
+
+	// Test arbitrary timestamps more thoroughly.
+	if err := adminClient.CreateColumnFamily(ctx, table, "ts"); err != nil {
+		t.Fatalf("Creating column family: %v", err)
+	}
+	const numVersions = 4
+	mut = NewMutation()
+	for i := 0; i < numVersions; i++ {
+		// Timestamps are used in thousands because the server
+		// only permits that granularity.
+		mut.Set("ts", "col", Timestamp(i*1000), []byte(fmt.Sprintf("val-%d", i)))
+	}
+	if err := tbl.Apply(ctx, "testrow", mut); err != nil {
+		t.Fatalf("Mutating row: %v", err)
+	}
+	r, err := tbl.ReadRow(ctx, "testrow")
+	if err != nil {
+		t.Fatalf("Reading row: %v", err)
+	}
+	wantRow = Row{"ts": []ReadItem{
+		// These should be returned in descending timestamp order.
+		{Row: "testrow", Column: "ts:col", Timestamp: 3000, Value: []byte("val-3")},
+		{Row: "testrow", Column: "ts:col", Timestamp: 2000, Value: []byte("val-2")},
+		{Row: "testrow", Column: "ts:col", Timestamp: 1000, Value: []byte("val-1")},
+		{Row: "testrow", Column: "ts:col", Timestamp: 0, Value: []byte("val-0")},
+	}}
+	if !reflect.DeepEqual(r, wantRow) {
+		t.Errorf("Cell with multiple versions,\n got %v\nwant %v", r, wantRow)
+	}
+	// Do the same read, but filter to the latest two versions.
+	r, err = tbl.ReadRow(ctx, "testrow", RowFilter(LatestNFilter(2)))
+	if err != nil {
+		t.Fatalf("Reading row: %v", err)
+	}
+	wantRow = Row{"ts": []ReadItem{
+		{Row: "testrow", Column: "ts:col", Timestamp: 3000, Value: []byte("val-3")},
+		{Row: "testrow", Column: "ts:col", Timestamp: 2000, Value: []byte("val-2")},
+	}}
+	if !reflect.DeepEqual(r, wantRow) {
+		t.Errorf("Cell with multiple versions and LatestNFilter(2),\n got %v\nwant %v", r, wantRow)
+	}
+	// Delete the cell with timestamp 2000 and repeat the last read,
+	// checking that we get ts 3000 and ts 1000.
+	mut = NewMutation()
+	mut.DeleteTimestampRange("ts", "col", 2000, 3000) // half-open interval
+	if err := tbl.Apply(ctx, "testrow", mut); err != nil {
+		t.Fatalf("Mutating row: %v", err)
+	}
+	r, err = tbl.ReadRow(ctx, "testrow", RowFilter(LatestNFilter(2)))
+	if err != nil {
+		t.Fatalf("Reading row: %v", err)
+	}
+	wantRow = Row{"ts": []ReadItem{
+		{Row: "testrow", Column: "ts:col", Timestamp: 3000, Value: []byte("val-3")},
+		{Row: "testrow", Column: "ts:col", Timestamp: 1000, Value: []byte("val-1")},
+	}}
+	if !reflect.DeepEqual(r, wantRow) {
+		t.Errorf("Cell with multiple versions and LatestNFilter(2), after deleting timestamp 2000,\n got %v\nwant %v", r, wantRow)
+	}
+	checkpoint("tested multiple versions in a cell")
+
+	// Do highly concurrent reads/writes.
+	// TODO(dsymonds): Raise this to 1000 when https://github.com/grpc/grpc-go/issues/205 is resolved.
+	const maxConcurrency = 100
+	var wg sync.WaitGroup
+	for i := 0; i < maxConcurrency; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			switch r := rand.Intn(100); { // r ∈ [0,100)
+			case 0 <= r && r < 30:
+				// Do a read.
+				_, err := tbl.ReadRow(ctx, "testrow", RowFilter(LatestNFilter(1)))
+				if err != nil {
+					t.Errorf("Concurrent read: %v", err)
+				}
+			case 30 <= r && r < 100:
+				// Do a write.
+				mut := NewMutation()
+				mut.Set("ts", "col", 0, []byte("data"))
+				if err := tbl.Apply(ctx, "testrow", mut); err != nil {
+					t.Errorf("Concurrent write: %v", err)
+				}
+			}
+		}()
+	}
+	wg.Wait()
+	checkpoint("tested high concurrency")
+
+	// Large reads, writes and scans.
+	bigBytes := make([]byte, 3<<20) // 3 MB is large, but less than current gRPC max of 4 MB.
+	nonsense := []byte("lorem ipsum dolor sit amet, ")
+	fill(bigBytes, nonsense)
+	mut = NewMutation()
+	mut.Set("ts", "col", 0, bigBytes)
+	if err := tbl.Apply(ctx, "bigrow", mut); err != nil {
+		t.Errorf("Big write: %v", err)
+	}
+	r, err = tbl.ReadRow(ctx, "bigrow")
+	if err != nil {
+		t.Errorf("Big read: %v", err)
+	}
+	wantRow = Row{"ts": []ReadItem{
+		{Row: "bigrow", Column: "ts:col", Value: bigBytes},
+	}}
+	if !reflect.DeepEqual(r, wantRow) {
+		t.Errorf("Big read returned incorrect bytes: %v", r)
+	}
+	// Now write 1000 rows, each with 82 KB values, then scan them all.
+	medBytes := make([]byte, 82<<10)
+	fill(medBytes, nonsense)
+	sem := make(chan int, 50) // do up to 50 mutations at a time.
+	for i := 0; i < 1000; i++ {
+		mut := NewMutation()
+		mut.Set("ts", "big-scan", 0, medBytes)
+		row := fmt.Sprintf("row-%d", i)
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-sem }()
+			sem <- 1
+			if err := tbl.Apply(ctx, row, mut); err != nil {
+				t.Errorf("Preparing large scan: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+	n := 0
+	err = tbl.ReadRows(ctx, PrefixRange("row-"), func(r Row) bool {
+		for _, ris := range r {
+			for _, ri := range ris {
+				n += len(ri.Value)
+			}
+		}
+		return true
+	}, RowFilter(ColumnFilter("big-scan")))
+	if err != nil {
+		t.Errorf("Doing large scan: %v", err)
+	}
+	if want := 1000 * len(medBytes); n != want {
+		t.Errorf("Large scan returned %d bytes, want %d", n, want)
+	}
+	// Scan a subset of the 1000 rows that we just created, using a LimitRows ReadOption.
+	rc := 0
+	wantRc := 3
+	err = tbl.ReadRows(ctx, PrefixRange("row-"), func(r Row) bool {
+		rc++
+		return true
+	}, LimitRows(int64(wantRc)))
+	if rc != wantRc {
+		t.Errorf("Scan with row limit returned %d rows, want %d", rc, wantRc)
+	}
+	checkpoint("tested big read/write/scan")
+
+	// Test bulk mutations
+	if err := adminClient.CreateColumnFamily(ctx, table, "bulk"); err != nil {
+		t.Fatalf("Creating column family: %v", err)
+	}
+	bulkData := map[string][]string{
+		"red sox":  {"2004", "2007", "2013"},
+		"patriots": {"2001", "2003", "2004", "2014"},
+		"celtics":  {"1981", "1984", "1986", "2008"},
+	}
+	var rowKeys []string
+	var muts []*Mutation
+	for row, ss := range bulkData {
+		mut := NewMutation()
+		for _, name := range ss {
+			mut.Set("bulk", name, 0, []byte("1"))
+		}
+		rowKeys = append(rowKeys, row)
+		muts = append(muts, mut)
+	}
+	status, err := tbl.ApplyBulk(ctx, rowKeys, muts)
+	if err != nil {
+		t.Fatalf("Bulk mutating rows %q: %v", rowKeys, err)
+	}
+	if status != nil {
+		t.Errorf("non-nil errors: %v", err)
+	}
+	checkpoint("inserted bulk data")
+
+	// Read each row back
+	for rowKey, ss := range bulkData {
+		row, err := tbl.ReadRow(ctx, rowKey)
+		if err != nil {
+			t.Fatalf("Reading a bulk row: %v", err)
+		}
+		for _, ris := range row {
+			sort.Sort(byColumn(ris))
+		}
+		var wantItems []ReadItem
+		for _, val := range ss {
+			wantItems = append(wantItems, ReadItem{Row: rowKey, Column: "bulk:" + val, Value: []byte("1")})
+		}
+		wantRow := Row{"bulk": wantItems}
+		if !reflect.DeepEqual(row, wantRow) {
+			t.Errorf("Read row mismatch.\n got %#v\nwant %#v", row, wantRow)
+		}
+	}
+	checkpoint("tested reading from bulk insert")
+
+	// Test bulk write errors.
+	// Note: Setting timestamps as ServerTime makes sure the mutations are not retried on error.
+	badMut := NewMutation()
+	badMut.Set("badfamily", "col", ServerTime, nil)
+	badMut2 := NewMutation()
+	badMut2.Set("badfamily2", "goodcol", ServerTime, []byte("1"))
+	status, err = tbl.ApplyBulk(ctx, []string{"badrow", "badrow2"}, []*Mutation{badMut, badMut2})
+	if err != nil {
+		t.Fatalf("Bulk mutating rows %q: %v", rowKeys, err)
+	}
+	if status == nil {
+		t.Errorf("No errors for bad bulk mutation")
+	} else if status[0] == nil || status[1] == nil {
+		t.Errorf("No error for bad bulk mutation")
+	}
+}
+
+func formatReadItem(ri ReadItem) string {
+	// Use the column qualifier only to make the test data briefer.
+	col := ri.Column[strings.Index(ri.Column, ":")+1:]
+	return fmt.Sprintf("%s-%s-%s", ri.Row, col, ri.Value)
+}
+
+func fill(b, sub []byte) {
+	for len(b) > len(sub) {
+		n := copy(b, sub)
+		b = b[n:]
+	}
+}
+
+type byColumn []ReadItem
+
+func (b byColumn) Len() int           { return len(b) }
+func (b byColumn) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byColumn) Less(i, j int) bool { return b[i].Column < b[j].Column }
+
+func clearTimestamps(r Row) {
+	for _, ris := range r {
+		for i := range ris {
+			ris[i].Timestamp = 0
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/bttest/example_test.go
+++ b/vendor/cloud.google.com/go/bigtable/bttest/example_test.go
@@ -0,0 +1,83 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package bttest_test
+
+import (
+	"fmt"
+	"log"
+
+	"cloud.google.com/go/bigtable"
+	"cloud.google.com/go/bigtable/bttest"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/grpc"
+)
+
+func ExampleNewServer() {
+
+	srv, err := bttest.NewServer("127.0.0.1:0")
+
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	ctx := context.Background()
+
+	conn, err := grpc.Dial(srv.Addr, grpc.WithInsecure())
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	proj, instance := "proj", "instance"
+
+	adminClient, err := bigtable.NewAdminClient(ctx, proj, instance, option.WithGRPCConn(conn))
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	if err = adminClient.CreateTable(ctx, "example"); err != nil {
+		log.Fatalln(err)
+	}
+
+	if err = adminClient.CreateColumnFamily(ctx, "example", "links"); err != nil {
+		log.Fatalln(err)
+	}
+
+	client, err := bigtable.NewClient(ctx, proj, instance, option.WithGRPCConn(conn))
+	if err != nil {
+		log.Fatalln(err)
+	}
+	tbl := client.Open("example")
+
+	mut := bigtable.NewMutation()
+	mut.Set("links", "golang.org", bigtable.Now(), []byte("Gophers!"))
+	if err = tbl.Apply(ctx, "com.google.cloud", mut); err != nil {
+		log.Fatalln(err)
+	}
+
+	if row, err := tbl.ReadRow(ctx, "com.google.cloud"); err != nil {
+		log.Fatalln(err)
+	} else {
+		for _, column := range row["links"] {
+			fmt.Println(column.Column)
+			fmt.Println(string(column.Value))
+		}
+	}
+
+	// Output:
+	// links:golang.org
+	// Gophers!
+}
--- a/vendor/cloud.google.com/go/bigtable/bttest/inmem.go
+++ b/vendor/cloud.google.com/go/bigtable/bttest/inmem.go
@@ -0,0 +1,947 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Package bttest contains test helpers for working with the bigtable package.
+
+To use a Server, create it, and then connect to it with no security:
+(The project/instance values are ignored.)
+	srv, err := bttest.NewServer("127.0.0.1:0")
+	...
+	conn, err := grpc.Dial(srv.Addr, grpc.WithInsecure())
+	...
+	client, err := bigtable.NewClient(ctx, proj, instance,
+	        option.WithGRPCConn(conn))
+	...
+*/
+package bttest // import "cloud.google.com/go/bigtable/bttest"
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+	"math/rand"
+	"net"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	emptypb "github.com/golang/protobuf/ptypes/empty"
+	"github.com/golang/protobuf/ptypes/wrappers"
+	"golang.org/x/net/context"
+	btapb "google.golang.org/genproto/googleapis/bigtable/admin/v2"
+	btpb "google.golang.org/genproto/googleapis/bigtable/v2"
+	statpb "google.golang.org/genproto/googleapis/rpc/status"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+// Server is an in-memory Cloud Bigtable fake.
+// It is unauthenticated, and only a rough approximation.
+type Server struct {
+	Addr string
+
+	l   net.Listener
+	srv *grpc.Server
+	s   *server
+}
+
+// server is the real implementation of the fake.
+// It is a separate and unexported type so the API won't be cluttered with
+// methods that are only relevant to the fake's implementation.
+type server struct {
+	mu     sync.Mutex
+	tables map[string]*table // keyed by fully qualified name
+	gcc    chan int          // set when gcloop starts, closed when server shuts down
+
+	// Any unimplemented methods will cause a panic.
+	btapb.BigtableTableAdminServer
+	btpb.BigtableServer
+}
+
+// NewServer creates a new Server.
+// The Server will be listening for gRPC connections, without TLS,
+// on the provided address. The resolved address is named by the Addr field.
+func NewServer(laddr string, opt ...grpc.ServerOption) (*Server, error) {
+	l, err := net.Listen("tcp", laddr)
+	if err != nil {
+		return nil, err
+	}
+
+	s := &Server{
+		Addr: l.Addr().String(),
+		l:    l,
+		srv:  grpc.NewServer(opt...),
+		s: &server{
+			tables: make(map[string]*table),
+		},
+	}
+	btapb.RegisterBigtableTableAdminServer(s.srv, s.s)
+	btpb.RegisterBigtableServer(s.srv, s.s)
+
+	go s.srv.Serve(s.l)
+
+	return s, nil
+}
+
+// Close shuts down the server.
+func (s *Server) Close() {
+	s.s.mu.Lock()
+	if s.s.gcc != nil {
+		close(s.s.gcc)
+	}
+	s.s.mu.Unlock()
+
+	s.srv.Stop()
+	s.l.Close()
+}
+
+func (s *server) CreateTable(ctx context.Context, req *btapb.CreateTableRequest) (*btapb.Table, error) {
+	tbl := req.Parent + "/tables/" + req.TableId
+
+	s.mu.Lock()
+	if _, ok := s.tables[tbl]; ok {
+		s.mu.Unlock()
+		return nil, fmt.Errorf("table %q already exists", tbl)
+	}
+	s.tables[tbl] = newTable(req)
+	s.mu.Unlock()
+
+	return &btapb.Table{Name: tbl}, nil
+}
+
+func (s *server) ListTables(ctx context.Context, req *btapb.ListTablesRequest) (*btapb.ListTablesResponse, error) {
+	res := &btapb.ListTablesResponse{}
+	prefix := req.Parent + "/tables/"
+
+	s.mu.Lock()
+	for tbl := range s.tables {
+		if strings.HasPrefix(tbl, prefix) {
+			res.Tables = append(res.Tables, &btapb.Table{Name: tbl})
+		}
+	}
+	s.mu.Unlock()
+
+	return res, nil
+}
+
+func (s *server) GetTable(ctx context.Context, req *btapb.GetTableRequest) (*btapb.Table, error) {
+	tbl := req.Name
+
+	s.mu.Lock()
+	tblIns, ok := s.tables[tbl]
+	s.mu.Unlock()
+	if !ok {
+		return nil, fmt.Errorf("table %q not found", tbl)
+	}
+
+	return &btapb.Table{
+		Name:           tbl,
+		ColumnFamilies: toColumnFamilies(tblIns.columnFamilies()),
+	}, nil
+}
+
+func (s *server) DeleteTable(ctx context.Context, req *btapb.DeleteTableRequest) (*emptypb.Empty, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, ok := s.tables[req.Name]; !ok {
+		return nil, fmt.Errorf("no such table %q", req.Name)
+	}
+	delete(s.tables, req.Name)
+	return &emptypb.Empty{}, nil
+}
+
+func (s *server) ModifyColumnFamilies(ctx context.Context, req *btapb.ModifyColumnFamiliesRequest) (*btapb.Table, error) {
+	tblName := req.Name[strings.LastIndex(req.Name, "/")+1:]
+
+	s.mu.Lock()
+	tbl, ok := s.tables[req.Name]
+	s.mu.Unlock()
+	if !ok {
+		return nil, fmt.Errorf("no such table %q", req.Name)
+	}
+
+	tbl.mu.Lock()
+	defer tbl.mu.Unlock()
+
+	for _, mod := range req.Modifications {
+		if create := mod.GetCreate(); create != nil {
+			if _, ok := tbl.families[mod.Id]; ok {
+				return nil, fmt.Errorf("family %q already exists", mod.Id)
+			}
+			newcf := &columnFamily{
+				name:   req.Name + "/columnFamilies/" + mod.Id,
+				gcRule: create.GcRule,
+			}
+			tbl.families[mod.Id] = newcf
+		} else if mod.GetDrop() {
+			if _, ok := tbl.families[mod.Id]; !ok {
+				return nil, fmt.Errorf("can't delete unknown family %q", mod.Id)
+			}
+			delete(tbl.families, mod.Id)
+		} else if modify := mod.GetUpdate(); modify != nil {
+			if _, ok := tbl.families[mod.Id]; !ok {
+				return nil, fmt.Errorf("no such family %q", mod.Id)
+			}
+			newcf := &columnFamily{
+				name:   req.Name + "/columnFamilies/" + mod.Id,
+				gcRule: modify.GcRule,
+			}
+			// assume that we ALWAYS want to replace by the new setting
+			// we may need partial update through
+			tbl.families[mod.Id] = newcf
+		}
+	}
+
+	s.needGC()
+	return &btapb.Table{
+		Name:           tblName,
+		ColumnFamilies: toColumnFamilies(tbl.families),
+	}, nil
+}
+
+func (s *server) ReadRows(req *btpb.ReadRowsRequest, stream btpb.Bigtable_ReadRowsServer) error {
+	s.mu.Lock()
+	tbl, ok := s.tables[req.TableName]
+	s.mu.Unlock()
+	if !ok {
+		return fmt.Errorf("no such table %q", req.TableName)
+	}
+
+	// Rows to read can be specified by a set of row keys and/or a set of row ranges.
+	// Output is a stream of sorted, de-duped rows.
+	tbl.mu.RLock()
+
+	rowSet := make(map[string]*row)
+	if req.Rows != nil {
+		// Add the explicitly given keys
+		for _, key := range req.Rows.RowKeys {
+			start := string(key)
+			addRows(start, start+"\x00", tbl, rowSet)
+		}
+
+		// Add keys from row ranges
+		for _, rr := range req.Rows.RowRanges {
+			var start, end string
+			switch sk := rr.StartKey.(type) {
+			case *btpb.RowRange_StartKeyClosed:
+				start = string(sk.StartKeyClosed)
+			case *btpb.RowRange_StartKeyOpen:
+				start = string(sk.StartKeyOpen) + "\x00"
+			}
+			switch ek := rr.EndKey.(type) {
+			case *btpb.RowRange_EndKeyClosed:
+				end = string(ek.EndKeyClosed) + "\x00"
+			case *btpb.RowRange_EndKeyOpen:
+				end = string(ek.EndKeyOpen)
+			}
+
+			addRows(start, end, tbl, rowSet)
+		}
+	} else {
+		// Read all rows
+		addRows("", "", tbl, rowSet)
+	}
+	tbl.mu.RUnlock()
+
+	rows := make([]*row, 0, len(rowSet))
+	for _, r := range rowSet {
+		rows = append(rows, r)
+	}
+	sort.Sort(byRowKey(rows))
+
+	limit := int(req.RowsLimit)
+	for i, r := range rows {
+		if limit > 0 && i >= limit {
+			return nil
+		}
+		if err := streamRow(stream, r, req.Filter); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func addRows(start, end string, tbl *table, rowSet map[string]*row) {
+	si, ei := 0, len(tbl.rows) // half-open interval
+	if start != "" {
+		si = sort.Search(len(tbl.rows), func(i int) bool { return tbl.rows[i].key >= start })
+	}
+	// Types that are valid to be assigned to StartKey:
+	//	*RowRange_StartKeyClosed
+	//	*RowRange_StartKeyOpen
+	if end != "" {
+		ei = sort.Search(len(tbl.rows), func(i int) bool { return tbl.rows[i].key >= end })
+	}
+	if si < ei {
+		for _, row := range tbl.rows[si:ei] {
+			rowSet[row.key] = row
+		}
+	}
+}
+
+func streamRow(stream btpb.Bigtable_ReadRowsServer, r *row, f *btpb.RowFilter) error {
+	r.mu.Lock()
+	nr := r.copy()
+	r.mu.Unlock()
+	r = nr
+
+	filterRow(f, r)
+
+	rrr := &btpb.ReadRowsResponse{}
+	for col, cells := range r.cells {
+		i := strings.Index(col, ":") // guaranteed to exist
+		fam, col := col[:i], col[i+1:]
+		if len(cells) == 0 {
+			continue
+		}
+		// TODO(dsymonds): Apply transformers.
+		for _, cell := range cells {
+			rrr.Chunks = append(rrr.Chunks, &btpb.ReadRowsResponse_CellChunk{
+				RowKey:          []byte(r.key),
+				FamilyName:      &wrappers.StringValue{Value: fam},
+				Qualifier:       &wrappers.BytesValue{Value: []byte(col)},
+				TimestampMicros: cell.ts,
+				Value:           cell.value,
+			})
+		}
+	}
+	// We can't have a cell with just COMMIT set, which would imply a new empty cell.
+	// So modify the last cell to have the COMMIT flag set.
+	if len(rrr.Chunks) > 0 {
+		rrr.Chunks[len(rrr.Chunks)-1].RowStatus = &btpb.ReadRowsResponse_CellChunk_CommitRow{CommitRow: true}
+	}
+
+	return stream.Send(rrr)
+}
+
+// filterRow modifies a row with the given filter.
+func filterRow(f *btpb.RowFilter, r *row) {
+	if f == nil {
+		return
+	}
+	// Handle filters that apply beyond just including/excluding cells.
+	switch f := f.Filter.(type) {
+	case *btpb.RowFilter_Chain_:
+		for _, sub := range f.Chain.Filters {
+			filterRow(sub, r)
+		}
+		return
+	case *btpb.RowFilter_Interleave_:
+		srs := make([]*row, 0, len(f.Interleave.Filters))
+		for _, sub := range f.Interleave.Filters {
+			sr := r.copy()
+			filterRow(sub, sr)
+			srs = append(srs, sr)
+		}
+		// merge
+		// TODO(dsymonds): is this correct?
+		r.cells = make(map[string][]cell)
+		for _, sr := range srs {
+			for col, cs := range sr.cells {
+				r.cells[col] = append(r.cells[col], cs...)
+			}
+		}
+		for _, cs := range r.cells {
+			sort.Sort(byDescTS(cs))
+		}
+		return
+	case *btpb.RowFilter_CellsPerColumnLimitFilter:
+		lim := int(f.CellsPerColumnLimitFilter)
+		for col, cs := range r.cells {
+			if len(cs) > lim {
+				r.cells[col] = cs[:lim]
+			}
+		}
+		return
+	}
+
+	// Any other case, operate on a per-cell basis.
+	for key, cs := range r.cells {
+		i := strings.Index(key, ":") // guaranteed to exist
+		fam, col := key[:i], key[i+1:]
+		r.cells[key] = filterCells(f, fam, col, cs)
+	}
+}
+
+func filterCells(f *btpb.RowFilter, fam, col string, cs []cell) []cell {
+	var ret []cell
+	for _, cell := range cs {
+		if includeCell(f, fam, col, cell) {
+			ret = append(ret, cell)
+		}
+	}
+	return ret
+}
+
+func includeCell(f *btpb.RowFilter, fam, col string, cell cell) bool {
+	if f == nil {
+		return true
+	}
+	// TODO(dsymonds): Implement many more filters.
+	switch f := f.Filter.(type) {
+	default:
+		log.Printf("WARNING: don't know how to handle filter of type %T (ignoring it)", f)
+		return true
+	case *btpb.RowFilter_FamilyNameRegexFilter:
+		pat := string(f.FamilyNameRegexFilter)
+		rx, err := regexp.Compile(pat)
+		if err != nil {
+			log.Printf("Bad family_name_regex_filter pattern %q: %v", pat, err)
+			return false
+		}
+		return rx.MatchString(fam)
+	case *btpb.RowFilter_ColumnQualifierRegexFilter:
+		pat := string(f.ColumnQualifierRegexFilter)
+		rx, err := regexp.Compile(pat)
+		if err != nil {
+			log.Printf("Bad column_qualifier_regex_filter pattern %q: %v", pat, err)
+			return false
+		}
+		return rx.MatchString(col)
+	case *btpb.RowFilter_ValueRegexFilter:
+		pat := string(f.ValueRegexFilter)
+		rx, err := regexp.Compile(pat)
+		if err != nil {
+			log.Printf("Bad value_regex_filter pattern %q: %v", pat, err)
+			return false
+		}
+		return rx.Match(cell.value)
+	}
+}
+
+func (s *server) MutateRow(ctx context.Context, req *btpb.MutateRowRequest) (*btpb.MutateRowResponse, error) {
+	s.mu.Lock()
+	tbl, ok := s.tables[req.TableName]
+	s.mu.Unlock()
+	if !ok {
+		return nil, fmt.Errorf("no such table %q", req.TableName)
+	}
+
+	fs := tbl.columnFamiliesSet()
+	r := tbl.mutableRow(string(req.RowKey))
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if err := applyMutations(tbl, r, req.Mutations, fs); err != nil {
+		return nil, err
+	}
+	return &btpb.MutateRowResponse{}, nil
+}
+
+func (s *server) MutateRows(req *btpb.MutateRowsRequest, stream btpb.Bigtable_MutateRowsServer) error {
+	s.mu.Lock()
+	tbl, ok := s.tables[req.TableName]
+	s.mu.Unlock()
+	if !ok {
+		return fmt.Errorf("no such table %q", req.TableName)
+	}
+
+	res := &btpb.MutateRowsResponse{Entries: make([]*btpb.MutateRowsResponse_Entry, len(req.Entries))}
+
+	fs := tbl.columnFamiliesSet()
+
+	for i, entry := range req.Entries {
+		r := tbl.mutableRow(string(entry.RowKey))
+		r.mu.Lock()
+		code, msg := int32(codes.OK), ""
+		if err := applyMutations(tbl, r, entry.Mutations, fs); err != nil {
+			code = int32(codes.Internal)
+			msg = err.Error()
+		}
+		res.Entries[i] = &btpb.MutateRowsResponse_Entry{
+			Index:  int64(i),
+			Status: &statpb.Status{Code: code, Message: msg},
+		}
+		r.mu.Unlock()
+	}
+	stream.Send(res)
+	return nil
+}
+
+func (s *server) CheckAndMutateRow(ctx context.Context, req *btpb.CheckAndMutateRowRequest) (*btpb.CheckAndMutateRowResponse, error) {
+	s.mu.Lock()
+	tbl, ok := s.tables[req.TableName]
+	s.mu.Unlock()
+	if !ok {
+		return nil, fmt.Errorf("no such table %q", req.TableName)
+	}
+
+	res := &btpb.CheckAndMutateRowResponse{}
+
+	fs := tbl.columnFamiliesSet()
+
+	r := tbl.mutableRow(string(req.RowKey))
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	// Figure out which mutation to apply.
+	whichMut := false
+	if req.PredicateFilter == nil {
+		// Use true_mutations iff row contains any cells.
+		whichMut = len(r.cells) > 0
+	} else {
+		// Use true_mutations iff any cells in the row match the filter.
+		// TODO(dsymonds): This could be cheaper.
+		nr := r.copy()
+		filterRow(req.PredicateFilter, nr)
+		for _, cs := range nr.cells {
+			if len(cs) > 0 {
+				whichMut = true
+				break
+			}
+		}
+		// TODO(dsymonds): Figure out if this is supposed to be set
+		// even when there's no predicate filter.
+		res.PredicateMatched = whichMut
+	}
+	muts := req.FalseMutations
+	if whichMut {
+		muts = req.TrueMutations
+	}
+
+	if err := applyMutations(tbl, r, muts, fs); err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
+// applyMutations applies a sequence of mutations to a row.
+// fam should be a snapshot of the keys of tbl.families.
+// It assumes r.mu is locked.
+func applyMutations(tbl *table, r *row, muts []*btpb.Mutation, fs map[string]bool) error {
+	for _, mut := range muts {
+		switch mut := mut.Mutation.(type) {
+		default:
+			return fmt.Errorf("can't handle mutation type %T", mut)
+		case *btpb.Mutation_SetCell_:
+			set := mut.SetCell
+			if !fs[set.FamilyName] {
+				return fmt.Errorf("unknown family %q", set.FamilyName)
+			}
+			ts := set.TimestampMicros
+			if ts == -1 { // bigtable.ServerTime
+				ts = newTimestamp()
+			}
+			if !tbl.validTimestamp(ts) {
+				return fmt.Errorf("invalid timestamp %d", ts)
+			}
+			col := fmt.Sprintf("%s:%s", set.FamilyName, set.ColumnQualifier)
+
+			newCell := cell{ts: ts, value: set.Value}
+			r.cells[col] = appendOrReplaceCell(r.cells[col], newCell)
+		case *btpb.Mutation_DeleteFromColumn_:
+			del := mut.DeleteFromColumn
+			col := fmt.Sprintf("%s:%s", del.FamilyName, del.ColumnQualifier)
+
+			cs := r.cells[col]
+			if del.TimeRange != nil {
+				tsr := del.TimeRange
+				if !tbl.validTimestamp(tsr.StartTimestampMicros) {
+					return fmt.Errorf("invalid timestamp %d", tsr.StartTimestampMicros)
+				}
+				if !tbl.validTimestamp(tsr.EndTimestampMicros) {
+					return fmt.Errorf("invalid timestamp %d", tsr.EndTimestampMicros)
+				}
+				// Find half-open interval to remove.
+				// Cells are in descending timestamp order,
+				// so the predicates to sort.Search are inverted.
+				si, ei := 0, len(cs)
+				if tsr.StartTimestampMicros > 0 {
+					ei = sort.Search(len(cs), func(i int) bool { return cs[i].ts < tsr.StartTimestampMicros })
+				}
+				if tsr.EndTimestampMicros > 0 {
+					si = sort.Search(len(cs), func(i int) bool { return cs[i].ts < tsr.EndTimestampMicros })
+				}
+				if si < ei {
+					copy(cs[si:], cs[ei:])
+					cs = cs[:len(cs)-(ei-si)]
+				}
+			} else {
+				cs = nil
+			}
+			if len(cs) == 0 {
+				delete(r.cells, col)
+			} else {
+				r.cells[col] = cs
+			}
+		case *btpb.Mutation_DeleteFromRow_:
+			r.cells = make(map[string][]cell)
+		}
+	}
+	return nil
+}
+
+func maxTimestamp(x, y int64) int64 {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func newTimestamp() int64 {
+	ts := time.Now().UnixNano() / 1e3
+	ts -= ts % 1000 // round to millisecond granularity
+	return ts
+}
+
+func appendOrReplaceCell(cs []cell, newCell cell) []cell {
+	replaced := false
+	for i, cell := range cs {
+		if cell.ts == newCell.ts {
+			cs[i] = newCell
+			replaced = true
+			break
+		}
+	}
+	if !replaced {
+		cs = append(cs, newCell)
+	}
+	sort.Sort(byDescTS(cs))
+	return cs
+}
+
+func (s *server) ReadModifyWriteRow(ctx context.Context, req *btpb.ReadModifyWriteRowRequest) (*btpb.ReadModifyWriteRowResponse, error) {
+	s.mu.Lock()
+	tbl, ok := s.tables[req.TableName]
+	s.mu.Unlock()
+	if !ok {
+		return nil, fmt.Errorf("no such table %q", req.TableName)
+	}
+
+	updates := make(map[string]cell) // copy of updated cells; keyed by full column name
+
+	fs := tbl.columnFamiliesSet()
+
+	r := tbl.mutableRow(string(req.RowKey))
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	// Assume all mutations apply to the most recent version of the cell.
+	// TODO(dsymonds): Verify this assumption and document it in the proto.
+	for _, rule := range req.Rules {
+		if !fs[rule.FamilyName] {
+			return nil, fmt.Errorf("unknown family %q", rule.FamilyName)
+		}
+
+		key := fmt.Sprintf("%s:%s", rule.FamilyName, rule.ColumnQualifier)
+
+		cells := r.cells[key]
+		ts := newTimestamp()
+		var newCell, prevCell cell
+		isEmpty := len(cells) == 0
+		if !isEmpty {
+			prevCell = cells[0]
+
+			// ts is the max of now or the prev cell's timestamp in case the
+			// prev cell is in the future
+			ts = maxTimestamp(ts, prevCell.ts)
+		}
+
+		switch rule := rule.Rule.(type) {
+		default:
+			return nil, fmt.Errorf("unknown RMW rule oneof %T", rule)
+		case *btpb.ReadModifyWriteRule_AppendValue:
+			newCell = cell{ts: ts, value: append(prevCell.value, rule.AppendValue...)}
+		case *btpb.ReadModifyWriteRule_IncrementAmount:
+			var v int64
+			if !isEmpty {
+				prevVal := prevCell.value
+				if len(prevVal) != 8 {
+					return nil, fmt.Errorf("increment on non-64-bit value")
+				}
+				v = int64(binary.BigEndian.Uint64(prevVal))
+			}
+			v += rule.IncrementAmount
+			var val [8]byte
+			binary.BigEndian.PutUint64(val[:], uint64(v))
+			newCell = cell{ts: ts, value: val[:]}
+		}
+		updates[key] = newCell
+		r.cells[key] = appendOrReplaceCell(r.cells[key], newCell)
+	}
+
+	res := &btpb.Row{
+		Key: req.RowKey,
+	}
+	for col, cell := range updates {
+		i := strings.Index(col, ":")
+		fam, qual := col[:i], col[i+1:]
+		var f *btpb.Family
+		for _, ff := range res.Families {
+			if ff.Name == fam {
+				f = ff
+				break
+			}
+		}
+		if f == nil {
+			f = &btpb.Family{Name: fam}
+			res.Families = append(res.Families, f)
+		}
+		f.Columns = append(f.Columns, &btpb.Column{
+			Qualifier: []byte(qual),
+			Cells: []*btpb.Cell{{
+				Value: cell.value,
+			}},
+		})
+	}
+	return &btpb.ReadModifyWriteRowResponse{Row: res}, nil
+}
+
+// needGC is invoked whenever the server needs gcloop running.
+func (s *server) needGC() {
+	s.mu.Lock()
+	if s.gcc == nil {
+		s.gcc = make(chan int)
+		go s.gcloop(s.gcc)
+	}
+	s.mu.Unlock()
+}
+
+func (s *server) gcloop(done <-chan int) {
+	const (
+		minWait = 500  // ms
+		maxWait = 1500 // ms
+	)
+
+	for {
+		// Wait for a random time interval.
+		d := time.Duration(minWait+rand.Intn(maxWait-minWait)) * time.Millisecond
+		select {
+		case <-time.After(d):
+		case <-done:
+			return // server has been closed
+		}
+
+		// Do a GC pass over all tables.
+		var tables []*table
+		s.mu.Lock()
+		for _, tbl := range s.tables {
+			tables = append(tables, tbl)
+		}
+		s.mu.Unlock()
+		for _, tbl := range tables {
+			tbl.gc()
+		}
+	}
+}
+
+type table struct {
+	mu       sync.RWMutex
+	families map[string]*columnFamily // keyed by plain family name
+	rows     []*row                   // sorted by row key
+	rowIndex map[string]*row          // indexed by row key
+}
+
+func newTable(ctr *btapb.CreateTableRequest) *table {
+	fams := make(map[string]*columnFamily)
+	if ctr.Table != nil {
+		for id, cf := range ctr.Table.ColumnFamilies {
+			fams[id] = &columnFamily{
+				name:   ctr.Parent + "/columnFamilies/" + id,
+				gcRule: cf.GcRule,
+			}
+		}
+	}
+	return &table{
+		families: fams,
+		rowIndex: make(map[string]*row),
+	}
+}
+
+func (t *table) validTimestamp(ts int64) bool {
+	// Assume millisecond granularity is required.
+	return ts%1000 == 0
+}
+
+func (t *table) columnFamilies() map[string]*columnFamily {
+	cp := make(map[string]*columnFamily)
+	t.mu.RLock()
+	for fam, cf := range t.families {
+		cp[fam] = cf
+	}
+	t.mu.RUnlock()
+	return cp
+}
+
+func (t *table) columnFamiliesSet() map[string]bool {
+	fs := make(map[string]bool)
+	for fam := range t.columnFamilies() {
+		fs[fam] = true
+	}
+	return fs
+}
+
+func (t *table) mutableRow(row string) *row {
+	// Try fast path first.
+	t.mu.RLock()
+	r := t.rowIndex[row]
+	t.mu.RUnlock()
+	if r != nil {
+		return r
+	}
+
+	// We probably need to create the row.
+	t.mu.Lock()
+	r = t.rowIndex[row]
+	if r == nil {
+		r = newRow(row)
+		t.rowIndex[row] = r
+		t.rows = append(t.rows, r)
+		sort.Sort(byRowKey(t.rows)) // yay, inefficient!
+	}
+	t.mu.Unlock()
+	return r
+}
+
+func (t *table) gc() {
+	// This method doesn't add or remove rows, so we only need a read lock for the table.
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+
+	// Gather GC rules we'll apply.
+	rules := make(map[string]*btapb.GcRule) // keyed by "fam"
+	for fam, cf := range t.families {
+		if cf.gcRule != nil {
+			rules[fam] = cf.gcRule
+		}
+	}
+	if len(rules) == 0 {
+		return
+	}
+
+	for _, r := range t.rows {
+		r.mu.Lock()
+		r.gc(rules)
+		r.mu.Unlock()
+	}
+}
+
+type byRowKey []*row
+
+func (b byRowKey) Len() int           { return len(b) }
+func (b byRowKey) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byRowKey) Less(i, j int) bool { return b[i].key < b[j].key }
+
+type row struct {
+	key string
+
+	mu    sync.Mutex
+	cells map[string][]cell // keyed by full column name; cells are in descending timestamp order
+}
+
+func newRow(key string) *row {
+	return &row{
+		key:   key,
+		cells: make(map[string][]cell),
+	}
+}
+
+// copy returns a copy of the row.
+// Cell values are aliased.
+// r.mu should be held.
+func (r *row) copy() *row {
+	nr := &row{
+		key:   r.key,
+		cells: make(map[string][]cell, len(r.cells)),
+	}
+	for col, cs := range r.cells {
+		// Copy the []cell slice, but not the []byte inside each cell.
+		nr.cells[col] = append([]cell(nil), cs...)
+	}
+	return nr
+}
+
+// gc applies the given GC rules to the row.
+// r.mu should be held.
+func (r *row) gc(rules map[string]*btapb.GcRule) {
+	for col, cs := range r.cells {
+		fam := col[:strings.Index(col, ":")]
+		rule, ok := rules[fam]
+		if !ok {
+			continue
+		}
+		r.cells[col] = applyGC(cs, rule)
+	}
+}
+
+var gcTypeWarn sync.Once
+
+// applyGC applies the given GC rule to the cells.
+func applyGC(cells []cell, rule *btapb.GcRule) []cell {
+	switch rule := rule.Rule.(type) {
+	default:
+		// TODO(dsymonds): Support GcRule_Intersection_
+		gcTypeWarn.Do(func() {
+			log.Printf("Unsupported GC rule type %T", rule)
+		})
+	case *btapb.GcRule_Union_:
+		for _, sub := range rule.Union.Rules {
+			cells = applyGC(cells, sub)
+		}
+		return cells
+	case *btapb.GcRule_MaxAge:
+		// Timestamps are in microseconds.
+		cutoff := time.Now().UnixNano() / 1e3
+		cutoff -= rule.MaxAge.Seconds * 1e6
+		cutoff -= int64(rule.MaxAge.Nanos) / 1e3
+		// The slice of cells in in descending timestamp order.
+		// This sort.Search will return the index of the first cell whose timestamp is chronologically before the cutoff.
+		si := sort.Search(len(cells), func(i int) bool { return cells[i].ts < cutoff })
+		if si < len(cells) {
+			log.Printf("bttest: GC MaxAge(%v) deleted %d cells.", rule.MaxAge, len(cells)-si)
+		}
+		return cells[:si]
+	case *btapb.GcRule_MaxNumVersions:
+		n := int(rule.MaxNumVersions)
+		if len(cells) > n {
+			cells = cells[:n]
+		}
+		return cells
+	}
+	return cells
+}
+
+type cell struct {
+	ts    int64
+	value []byte
+}
+
+type byDescTS []cell
+
+func (b byDescTS) Len() int           { return len(b) }
+func (b byDescTS) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byDescTS) Less(i, j int) bool { return b[i].ts > b[j].ts }
+
+type columnFamily struct {
+	name   string
+	gcRule *btapb.GcRule
+}
+
+func (c *columnFamily) proto() *btapb.ColumnFamily {
+	return &btapb.ColumnFamily{
+		GcRule: c.gcRule,
+	}
+}
+
+func toColumnFamilies(families map[string]*columnFamily) map[string]*btapb.ColumnFamily {
+	fs := make(map[string]*btapb.ColumnFamily)
+	for k, v := range families {
+		fs[k] = v.proto()
+	}
+	return fs
+}
--- a/vendor/cloud.google.com/go/bigtable/bttest/inmem_test.go
+++ b/vendor/cloud.google.com/go/bigtable/bttest/inmem_test.go
@@ -0,0 +1,175 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bttest
+
+import (
+	"fmt"
+	"math/rand"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"golang.org/x/net/context"
+	btapb "google.golang.org/genproto/googleapis/bigtable/admin/v2"
+	btpb "google.golang.org/genproto/googleapis/bigtable/v2"
+)
+
+func TestConcurrentMutationsReadModifyAndGC(t *testing.T) {
+	s := &server{
+		tables: make(map[string]*table),
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+	defer cancel()
+	if _, err := s.CreateTable(
+		ctx,
+		&btapb.CreateTableRequest{Parent: "cluster", TableId: "t"}); err != nil {
+		t.Fatal(err)
+	}
+	const name = `cluster/tables/t`
+	tbl := s.tables[name]
+	req := &btapb.ModifyColumnFamiliesRequest{
+		Name: name,
+		Modifications: []*btapb.ModifyColumnFamiliesRequest_Modification{
+			{
+				Id:  "cf",
+				Mod: &btapb.ModifyColumnFamiliesRequest_Modification_Create{Create: &btapb.ColumnFamily{}},
+			},
+		},
+	}
+	_, err := s.ModifyColumnFamilies(ctx, req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req = &btapb.ModifyColumnFamiliesRequest{
+		Name: name,
+		Modifications: []*btapb.ModifyColumnFamiliesRequest_Modification{
+			{
+				Id: "cf",
+				Mod: &btapb.ModifyColumnFamiliesRequest_Modification_Update{
+					Update: &btapb.ColumnFamily{GcRule: &btapb.GcRule{Rule: &btapb.GcRule_MaxNumVersions{MaxNumVersions: 1}}}},
+			},
+		},
+	}
+	if _, err := s.ModifyColumnFamilies(ctx, req); err != nil {
+		t.Fatal(err)
+	}
+
+	var wg sync.WaitGroup
+	var ts int64
+	ms := func() []*btpb.Mutation {
+		return []*btpb.Mutation{
+			{
+				Mutation: &btpb.Mutation_SetCell_{
+					SetCell: &btpb.Mutation_SetCell{
+						FamilyName:      "cf",
+						ColumnQualifier: []byte(`col`),
+						TimestampMicros: atomic.AddInt64(&ts, 1000),
+					},
+				},
+			},
+		}
+	}
+
+	rmw := func() *btpb.ReadModifyWriteRowRequest {
+		return &btpb.ReadModifyWriteRowRequest{
+			TableName: name,
+			RowKey:    []byte(fmt.Sprint(rand.Intn(100))),
+			Rules: []*btpb.ReadModifyWriteRule{
+				{
+					FamilyName:      "cf",
+					ColumnQualifier: []byte("col"),
+					Rule:            &btpb.ReadModifyWriteRule_IncrementAmount{IncrementAmount: 1},
+				},
+			},
+		}
+	}
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for ctx.Err() == nil {
+				req := &btpb.MutateRowRequest{
+					TableName: name,
+					RowKey:    []byte(fmt.Sprint(rand.Intn(100))),
+					Mutations: ms(),
+				}
+				s.MutateRow(ctx, req)
+			}
+		}()
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for ctx.Err() == nil {
+				_, _ = s.ReadModifyWriteRow(ctx, rmw())
+			}
+		}()
+
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			tbl.gc()
+		}()
+	}
+	done := make(chan struct{})
+	go func() {
+		wg.Wait()
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(100 * time.Millisecond):
+		t.Error("Concurrent mutations and GCs haven't completed after 100ms")
+	}
+}
+
+func TestCreateTableWithFamily(t *testing.T) {
+	// The Go client currently doesn't support creating a table with column families
+	// in one operation but it is allowed by the API. This must still be supported by the
+	// fake server so this test lives here instead of in the main bigtable
+	// integration test.
+	s := &server{
+		tables: make(map[string]*table),
+	}
+	ctx := context.Background()
+	newTbl := btapb.Table{
+		ColumnFamilies: map[string]*btapb.ColumnFamily{
+			"cf1": {GcRule: &btapb.GcRule{Rule: &btapb.GcRule_MaxNumVersions{MaxNumVersions: 123}}},
+			"cf2": {GcRule: &btapb.GcRule{Rule: &btapb.GcRule_MaxNumVersions{MaxNumVersions: 456}}},
+		},
+	}
+	cTbl, err := s.CreateTable(ctx, &btapb.CreateTableRequest{Parent: "cluster", TableId: "t", Table: &newTbl})
+	if err != nil {
+		t.Fatalf("Creating table: %v", err)
+	}
+	tbl, err := s.GetTable(ctx, &btapb.GetTableRequest{Name: cTbl.Name})
+	if err != nil {
+		t.Fatalf("Getting table: %v", err)
+	}
+	cf := tbl.ColumnFamilies["cf1"]
+	if cf == nil {
+		t.Fatalf("Missing col family cf1")
+	}
+	if got, want := cf.GcRule.GetMaxNumVersions(), int32(123); got != want {
+		t.Errorf("Invalid MaxNumVersions: wanted:%d, got:%d", want, got)
+	}
+	cf = tbl.ColumnFamilies["cf2"]
+	if cf == nil {
+		t.Fatalf("Missing col family cf2")
+	}
+	if got, want := cf.GcRule.GetMaxNumVersions(), int32(456); got != want {
+		t.Errorf("Invalid MaxNumVersions: wanted:%d, got:%d", want, got)
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/cmd/cbt/cbt.go
+++ b/vendor/cloud.google.com/go/bigtable/cmd/cbt/cbt.go
@@ -0,0 +1,738 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+// Command docs are in cbtdoc.go.
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"log"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+	"text/template"
+	"time"
+
+	"cloud.google.com/go/bigtable"
+	"cloud.google.com/go/bigtable/internal/cbtrc"
+	"golang.org/x/net/context"
+)
+
+var (
+	oFlag = flag.String("o", "", "if set, redirect stdout to this file")
+
+	config              *cbtrc.Config
+	client              *bigtable.Client
+	adminClient         *bigtable.AdminClient
+	instanceAdminClient *bigtable.InstanceAdminClient
+)
+
+func getClient() *bigtable.Client {
+	if client == nil {
+		var err error
+		client, err = bigtable.NewClient(context.Background(), config.Project, config.Instance)
+		if err != nil {
+			log.Fatalf("Making bigtable.Client: %v", err)
+		}
+	}
+	return client
+}
+
+func getAdminClient() *bigtable.AdminClient {
+	if adminClient == nil {
+		var err error
+		adminClient, err = bigtable.NewAdminClient(context.Background(), config.Project, config.Instance)
+		if err != nil {
+			log.Fatalf("Making bigtable.AdminClient: %v", err)
+		}
+	}
+	return adminClient
+}
+
+func getInstanceAdminClient() *bigtable.InstanceAdminClient {
+	if instanceAdminClient == nil {
+		var err error
+		instanceAdminClient, err = bigtable.NewInstanceAdminClient(context.Background(), config.Project)
+		if err != nil {
+			log.Fatalf("Making bigtable.InstanceAdminClient: %v", err)
+		}
+	}
+	return instanceAdminClient
+}
+
+func main() {
+	var err error
+	config, err = cbtrc.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+	config.RegisterFlags()
+
+	flag.Usage = func() { usage(os.Stderr) }
+	flag.Parse()
+	if err := config.CheckFlags(); err != nil {
+		log.Fatal(err)
+	}
+	if config.Creds != "" {
+		os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", config.Creds)
+	}
+	if flag.NArg() == 0 {
+		usage(os.Stderr)
+		os.Exit(1)
+	}
+
+	if *oFlag != "" {
+		f, err := os.Create(*oFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer func() {
+			if err := f.Close(); err != nil {
+				log.Fatal(err)
+			}
+		}()
+		os.Stdout = f
+	}
+
+	ctx := context.Background()
+	for _, cmd := range commands {
+		if cmd.Name == flag.Arg(0) {
+			cmd.do(ctx, flag.Args()[1:]...)
+			return
+		}
+	}
+	log.Fatalf("Unknown command %q", flag.Arg(0))
+}
+
+func usage(w io.Writer) {
+	fmt.Fprintf(w, "Usage: %s [flags] <command> ...\n", os.Args[0])
+	flag.CommandLine.SetOutput(w)
+	flag.CommandLine.PrintDefaults()
+	fmt.Fprintf(w, "\n%s", cmdSummary)
+}
+
+var cmdSummary string // generated in init, below
+
+func init() {
+	var buf bytes.Buffer
+	tw := tabwriter.NewWriter(&buf, 10, 8, 4, '\t', 0)
+	for _, cmd := range commands {
+		fmt.Fprintf(tw, "cbt %s\t%s\n", cmd.Name, cmd.Desc)
+	}
+	tw.Flush()
+	buf.WriteString(configHelp)
+	cmdSummary = buf.String()
+}
+
+var configHelp = `
+For convenience, values of the -project, -instance and -creds flags
+may be specified in ` + cbtrc.Filename() + ` in this format:
+	project = my-project-123
+	instance = my-instance
+	creds = path-to-account-key.json
+All values are optional, and all will be overridden by flags.
+`
+
+var commands = []struct {
+	Name, Desc string
+	do         func(context.Context, ...string)
+	Usage      string
+}{
+	{
+		Name:  "count",
+		Desc:  "Count rows in a table",
+		do:    doCount,
+		Usage: "cbt count <table>",
+	},
+	{
+		Name:  "createfamily",
+		Desc:  "Create a column family",
+		do:    doCreateFamily,
+		Usage: "cbt createfamily <table> <family>",
+	},
+	{
+		Name:  "createtable",
+		Desc:  "Create a table",
+		do:    doCreateTable,
+		Usage: "cbt createtable <table>",
+	},
+	{
+		Name:  "deletefamily",
+		Desc:  "Delete a column family",
+		do:    doDeleteFamily,
+		Usage: "cbt deletefamily <table> <family>",
+	},
+	{
+		Name:  "deleterow",
+		Desc:  "Delete a row",
+		do:    doDeleteRow,
+		Usage: "cbt deleterow <table> <row>",
+	},
+	{
+		Name:  "deletetable",
+		Desc:  "Delete a table",
+		do:    doDeleteTable,
+		Usage: "cbt deletetable <table>",
+	},
+	{
+		Name:  "doc",
+		Desc:  "Print godoc-suitable documentation for cbt",
+		do:    doDoc,
+		Usage: "cbt doc",
+	},
+	{
+		Name:  "help",
+		Desc:  "Print help text",
+		do:    doHelp,
+		Usage: "cbt help [command]",
+	},
+	{
+		Name:  "listinstances",
+		Desc:  "List instances in a project",
+		do:    doListInstances,
+		Usage: "cbt listinstances",
+	},
+	{
+		Name:  "lookup",
+		Desc:  "Read from a single row",
+		do:    doLookup,
+		Usage: "cbt lookup <table> <row>",
+	},
+	{
+		Name: "ls",
+		Desc: "List tables and column families",
+		do:   doLS,
+		Usage: "cbt ls			List tables\n" +
+			"cbt ls <table>		List column families in <table>",
+	},
+	{
+		Name:  "mddoc",
+		Desc:  "Print documentation for cbt in Markdown format",
+		do:    doMDDoc,
+		Usage: "cbt mddoc",
+	},
+	{
+		Name: "read",
+		Desc: "Read rows",
+		do:   doRead,
+		Usage: "cbt read <table> [start=<row>] [end=<row>] [prefix=<prefix>] [count=<n>]\n" +
+			"  start=<row>		Start reading at this row\n" +
+			"  end=<row>		Stop reading before this row\n" +
+			"  prefix=<prefix>	Read rows with this prefix\n" +
+			"  count=<n>		Read only this many rows\n",
+	},
+	{
+		Name: "set",
+		Desc: "Set value of a cell",
+		do:   doSet,
+		Usage: "cbt set <table> <row> family:column=val[@ts] ...\n" +
+			"  family:column=val[@ts] may be repeated to set multiple cells.\n" +
+			"\n" +
+			"  ts is an optional integer timestamp.\n" +
+			"  If it cannot be parsed, the `@ts` part will be\n" +
+			"  interpreted as part of the value.",
+	},
+	{
+		Name: "setgcpolicy",
+		Desc: "Set the GC policy for a column family",
+		do:   doSetGCPolicy,
+		Usage: "cbt setgcpolicy <table> <family> ( maxage=<d> | maxversions=<n> )\n" +
+			"\n" +
+			`  maxage=<d>		Maximum timestamp age to preserve (e.g. "1h", "4d")` + "\n" +
+			"  maxversions=<n>	Maximum number of versions to preserve",
+	},
+}
+
+func doCount(ctx context.Context, args ...string) {
+	if len(args) != 1 {
+		log.Fatal("usage: cbt count <table>")
+	}
+	tbl := getClient().Open(args[0])
+
+	n := 0
+	err := tbl.ReadRows(ctx, bigtable.InfiniteRange(""), func(_ bigtable.Row) bool {
+		n++
+		return true
+	}, bigtable.RowFilter(bigtable.StripValueFilter()))
+	if err != nil {
+		log.Fatalf("Reading rows: %v", err)
+	}
+	fmt.Println(n)
+}
+
+func doCreateFamily(ctx context.Context, args ...string) {
+	if len(args) != 2 {
+		log.Fatal("usage: cbt createfamily <table> <family>")
+	}
+	err := getAdminClient().CreateColumnFamily(ctx, args[0], args[1])
+	if err != nil {
+		log.Fatalf("Creating column family: %v", err)
+	}
+}
+
+func doCreateTable(ctx context.Context, args ...string) {
+	if len(args) != 1 {
+		log.Fatal("usage: cbt createtable <table>")
+	}
+	err := getAdminClient().CreateTable(ctx, args[0])
+	if err != nil {
+		log.Fatalf("Creating table: %v", err)
+	}
+}
+
+func doDeleteFamily(ctx context.Context, args ...string) {
+	if len(args) != 2 {
+		log.Fatal("usage: cbt deletefamily <table> <family>")
+	}
+	err := getAdminClient().DeleteColumnFamily(ctx, args[0], args[1])
+	if err != nil {
+		log.Fatalf("Deleting column family: %v", err)
+	}
+}
+
+func doDeleteRow(ctx context.Context, args ...string) {
+	if len(args) != 2 {
+		log.Fatal("usage: cbt deleterow <table> <row>")
+	}
+	tbl := getClient().Open(args[0])
+	mut := bigtable.NewMutation()
+	mut.DeleteRow()
+	if err := tbl.Apply(ctx, args[1], mut); err != nil {
+		log.Fatalf("Deleting row: %v", err)
+	}
+}
+
+func doDeleteTable(ctx context.Context, args ...string) {
+	if len(args) != 1 {
+		log.Fatalf("Can't do `cbt deletetable %s`", args)
+	}
+	err := getAdminClient().DeleteTable(ctx, args[0])
+	if err != nil {
+		log.Fatalf("Deleting table: %v", err)
+	}
+}
+
+// to break circular dependencies
+var (
+	doDocFn   func(ctx context.Context, args ...string)
+	doHelpFn  func(ctx context.Context, args ...string)
+	doMDDocFn func(ctx context.Context, args ...string)
+)
+
+func init() {
+	doDocFn = doDocReal
+	doHelpFn = doHelpReal
+	doMDDocFn = doMDDocReal
+}
+
+func doDoc(ctx context.Context, args ...string)   { doDocFn(ctx, args...) }
+func doHelp(ctx context.Context, args ...string)  { doHelpFn(ctx, args...) }
+func doMDDoc(ctx context.Context, args ...string) { doMDDocFn(ctx, args...) }
+
+func docFlags() []*flag.Flag {
+	// Only include specific flags, in a specific order.
+	var flags []*flag.Flag
+	for _, name := range []string{"project", "instance", "creds"} {
+		f := flag.Lookup(name)
+		if f == nil {
+			log.Fatalf("Flag not linked: -%s", name)
+		}
+		flags = append(flags, f)
+	}
+	return flags
+}
+
+func doDocReal(ctx context.Context, args ...string) {
+	data := map[string]interface{}{
+		"Commands": commands,
+		"Flags":    docFlags(),
+	}
+	var buf bytes.Buffer
+	if err := docTemplate.Execute(&buf, data); err != nil {
+		log.Fatalf("Bad doc template: %v", err)
+	}
+	out, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatalf("Bad doc output: %v", err)
+	}
+	os.Stdout.Write(out)
+}
+
+func indentLines(s, ind string) string {
+	ss := strings.Split(s, "\n")
+	for i, p := range ss {
+		ss[i] = ind + p
+	}
+	return strings.Join(ss, "\n")
+}
+
+var docTemplate = template.Must(template.New("doc").Funcs(template.FuncMap{
+	"indent": indentLines,
+}).
+	Parse(`
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// DO NOT EDIT. THIS IS AUTOMATICALLY GENERATED.
+// Run "go generate" to regenerate.
+//go:generate go run cbt.go -o cbtdoc.go doc
+
+/*
+Cbt is a tool for doing basic interactions with Cloud Bigtable.
+
+Usage:
+
+	cbt [options] command [arguments]
+
+The commands are:
+{{range .Commands}}
+	{{printf "%-25s %s" .Name .Desc}}{{end}}
+
+Use "cbt help <command>" for more information about a command.
+
+The options are:
+{{range .Flags}}
+	-{{.Name}} string
+		{{.Usage}}{{end}}
+
+{{range .Commands}}
+{{.Desc}}
+
+Usage:
+{{indent .Usage "\t"}}
+
+
+
+{{end}}
+*/
+package main
+`))
+
+func doHelpReal(ctx context.Context, args ...string) {
+	if len(args) == 0 {
+		usage(os.Stdout)
+		return
+	}
+	for _, cmd := range commands {
+		if cmd.Name == args[0] {
+			fmt.Println(cmd.Usage)
+			return
+		}
+	}
+	log.Fatalf("Don't know command %q", args[0])
+}
+
+func doListInstances(ctx context.Context, args ...string) {
+	if len(args) != 0 {
+		log.Fatalf("usage: cbt listinstances")
+	}
+	is, err := getInstanceAdminClient().Instances(ctx)
+	if err != nil {
+		log.Fatalf("Getting list of instances: %v", err)
+	}
+	tw := tabwriter.NewWriter(os.Stdout, 10, 8, 4, '\t', 0)
+	fmt.Fprintf(tw, "Instance Name\tInfo\n")
+	fmt.Fprintf(tw, "-------------\t----\n")
+	for _, i := range is {
+		fmt.Fprintf(tw, "%s\t%s\n", i.Name, i.DisplayName)
+	}
+	tw.Flush()
+}
+
+func doLookup(ctx context.Context, args ...string) {
+	if len(args) != 2 {
+		log.Fatalf("usage: cbt lookup <table> <row>")
+	}
+	table, row := args[0], args[1]
+	tbl := getClient().Open(table)
+	r, err := tbl.ReadRow(ctx, row)
+	if err != nil {
+		log.Fatalf("Reading row: %v", err)
+	}
+	printRow(r)
+}
+
+func printRow(r bigtable.Row) {
+	fmt.Println(strings.Repeat("-", 40))
+	fmt.Println(r.Key())
+
+	var fams []string
+	for fam := range r {
+		fams = append(fams, fam)
+	}
+	sort.Strings(fams)
+	for _, fam := range fams {
+		ris := r[fam]
+		sort.Sort(byColumn(ris))
+		for _, ri := range ris {
+			ts := time.Unix(0, int64(ri.Timestamp)*1e3)
+			fmt.Printf("  %-40s @ %s\n", ri.Column, ts.Format("2006/01/02-15:04:05.000000"))
+			fmt.Printf("    %q\n", ri.Value)
+		}
+	}
+}
+
+type byColumn []bigtable.ReadItem
+
+func (b byColumn) Len() int           { return len(b) }
+func (b byColumn) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byColumn) Less(i, j int) bool { return b[i].Column < b[j].Column }
+
+func doLS(ctx context.Context, args ...string) {
+	switch len(args) {
+	default:
+		log.Fatalf("Can't do `cbt ls %s`", args)
+	case 0:
+		tables, err := getAdminClient().Tables(ctx)
+		if err != nil {
+			log.Fatalf("Getting list of tables: %v", err)
+		}
+		sort.Strings(tables)
+		for _, table := range tables {
+			fmt.Println(table)
+		}
+	case 1:
+		table := args[0]
+		ti, err := getAdminClient().TableInfo(ctx, table)
+		if err != nil {
+			log.Fatalf("Getting table info: %v", err)
+		}
+		sort.Strings(ti.Families)
+		for _, fam := range ti.Families {
+			fmt.Println(fam)
+		}
+	}
+}
+
+func doMDDocReal(ctx context.Context, args ...string) {
+	data := map[string]interface{}{
+		"Commands": commands,
+		"Flags":    docFlags(),
+	}
+	var buf bytes.Buffer
+	if err := mddocTemplate.Execute(&buf, data); err != nil {
+		log.Fatalf("Bad mddoc template: %v", err)
+	}
+	io.Copy(os.Stdout, &buf)
+}
+
+var mddocTemplate = template.Must(template.New("mddoc").Funcs(template.FuncMap{
+	"indent": indentLines,
+}).
+	Parse(`
+Cbt is a tool for doing basic interactions with Cloud Bigtable.
+
+Usage:
+
+	cbt [options] command [arguments]
+
+The commands are:
+{{range .Commands}}
+	{{printf "%-25s %s" .Name .Desc}}{{end}}
+
+Use "cbt help <command>" for more information about a command.
+
+The options are:
+{{range .Flags}}
+	-{{.Name}} string
+		{{.Usage}}{{end}}
+
+{{range .Commands}}
+## {{.Desc}}
+
+{{indent .Usage "\t"}}
+
+
+
+{{end}}
+`))
+
+func doRead(ctx context.Context, args ...string) {
+	if len(args) < 1 {
+		log.Fatalf("usage: cbt read <table> [args ...]")
+	}
+	tbl := getClient().Open(args[0])
+
+	parsed := make(map[string]string)
+	for _, arg := range args[1:] {
+		i := strings.Index(arg, "=")
+		if i < 0 {
+			log.Fatalf("Bad arg %q", arg)
+		}
+		key, val := arg[:i], arg[i+1:]
+		switch key {
+		default:
+			log.Fatalf("Unknown arg key %q", key)
+		case "limit":
+			// Be nicer; we used to support this, but renamed it to "end".
+			log.Fatalf("Unknown arg key %q; did you mean %q?", key, "end")
+		case "start", "end", "prefix", "count":
+			parsed[key] = val
+		}
+	}
+	if (parsed["start"] != "" || parsed["end"] != "") && parsed["prefix"] != "" {
+		log.Fatal(`"start"/"end" may not be mixed with "prefix"`)
+	}
+
+	var rr bigtable.RowRange
+	if start, end := parsed["start"], parsed["end"]; end != "" {
+		rr = bigtable.NewRange(start, end)
+	} else if start != "" {
+		rr = bigtable.InfiniteRange(start)
+	}
+	if prefix := parsed["prefix"]; prefix != "" {
+		rr = bigtable.PrefixRange(prefix)
+	}
+
+	var opts []bigtable.ReadOption
+	if count := parsed["count"]; count != "" {
+		n, err := strconv.ParseInt(count, 0, 64)
+		if err != nil {
+			log.Fatalf("Bad count %q: %v", count, err)
+		}
+		opts = append(opts, bigtable.LimitRows(n))
+	}
+
+	// TODO(dsymonds): Support filters.
+	err := tbl.ReadRows(ctx, rr, func(r bigtable.Row) bool {
+		printRow(r)
+		return true
+	}, opts...)
+	if err != nil {
+		log.Fatalf("Reading rows: %v", err)
+	}
+}
+
+var setArg = regexp.MustCompile(`([^:]+):([^=]*)=(.*)`)
+
+func doSet(ctx context.Context, args ...string) {
+	if len(args) < 3 {
+		log.Fatalf("usage: cbt set <table> <row> family:[column]=val[@ts] ...")
+	}
+	tbl := getClient().Open(args[0])
+	row := args[1]
+	mut := bigtable.NewMutation()
+	for _, arg := range args[2:] {
+		m := setArg.FindStringSubmatch(arg)
+		if m == nil {
+			log.Fatalf("Bad set arg %q", arg)
+		}
+		val := m[3]
+		ts := bigtable.Now()
+		if i := strings.LastIndex(val, "@"); i >= 0 {
+			// Try parsing a timestamp.
+			n, err := strconv.ParseInt(val[i+1:], 0, 64)
+			if err == nil {
+				val = val[:i]
+				ts = bigtable.Timestamp(n)
+			}
+		}
+		mut.Set(m[1], m[2], ts, []byte(val))
+	}
+	if err := tbl.Apply(ctx, row, mut); err != nil {
+		log.Fatalf("Applying mutation: %v", err)
+	}
+}
+
+func doSetGCPolicy(ctx context.Context, args ...string) {
+	if len(args) < 3 {
+		log.Fatalf("usage: cbt setgcpolicy <table> <family> ( maxage=<d> | maxversions=<n> )")
+	}
+	table := args[0]
+	fam := args[1]
+
+	var pol bigtable.GCPolicy
+	switch p := args[2]; {
+	case strings.HasPrefix(p, "maxage="):
+		d, err := parseDuration(p[7:])
+		if err != nil {
+			log.Fatal(err)
+		}
+		pol = bigtable.MaxAgePolicy(d)
+	case strings.HasPrefix(p, "maxversions="):
+		n, err := strconv.ParseUint(p[12:], 10, 16)
+		if err != nil {
+			log.Fatal(err)
+		}
+		pol = bigtable.MaxVersionsPolicy(int(n))
+	default:
+		log.Fatalf("Bad GC policy %q", p)
+	}
+	if err := getAdminClient().SetGCPolicy(ctx, table, fam, pol); err != nil {
+		log.Fatalf("Setting GC policy: %v", err)
+	}
+}
+
+// parseDuration parses a duration string.
+// It is similar to Go's time.ParseDuration, except with a different set of supported units,
+// and only simple formats supported.
+func parseDuration(s string) (time.Duration, error) {
+	// [0-9]+[a-z]+
+
+	// Split [0-9]+ from [a-z]+.
+	i := 0
+	for ; i < len(s); i++ {
+		c := s[i]
+		if c < '0' || c > '9' {
+			break
+		}
+	}
+	ds, u := s[:i], s[i:]
+	if ds == "" || u == "" {
+		return 0, fmt.Errorf("invalid duration %q", s)
+	}
+	// Parse them.
+	d, err := strconv.ParseUint(ds, 10, 32)
+	if err != nil {
+		return 0, fmt.Errorf("invalid duration %q: %v", s, err)
+	}
+	unit, ok := unitMap[u]
+	if !ok {
+		return 0, fmt.Errorf("unknown unit %q in duration %q", u, s)
+	}
+	if d > uint64((1<<63-1)/unit) {
+		// overflow
+		return 0, fmt.Errorf("invalid duration %q overflows", s)
+	}
+	return time.Duration(d) * unit, nil
+}
+
+var unitMap = map[string]time.Duration{
+	"ms": time.Millisecond,
+	"s":  time.Second,
+	"m":  time.Minute,
+	"h":  time.Hour,
+	"d":  24 * time.Hour,
+}
--- a/vendor/cloud.google.com/go/bigtable/cmd/cbt/cbt_test.go
+++ b/vendor/cloud.google.com/go/bigtable/cmd/cbt/cbt_test.go
@@ -0,0 +1,59 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"testing"
+	"time"
+)
+
+func TestParseDuration(t *testing.T) {
+	tests := []struct {
+		in string
+		// out or fail are mutually exclusive
+		out  time.Duration
+		fail bool
+	}{
+		{in: "10ms", out: 10 * time.Millisecond},
+		{in: "3s", out: 3 * time.Second},
+		{in: "60m", out: 60 * time.Minute},
+		{in: "12h", out: 12 * time.Hour},
+		{in: "7d", out: 168 * time.Hour},
+
+		{in: "", fail: true},
+		{in: "0", fail: true},
+		{in: "7ns", fail: true},
+		{in: "14mo", fail: true},
+		{in: "3.5h", fail: true},
+		{in: "106752d", fail: true}, // overflow
+	}
+	for _, tc := range tests {
+		got, err := parseDuration(tc.in)
+		if !tc.fail && err != nil {
+			t.Errorf("parseDuration(%q) unexpectedly failed: %v", tc.in, err)
+			continue
+		}
+		if tc.fail && err == nil {
+			t.Errorf("parseDuration(%q) did not fail", tc.in)
+			continue
+		}
+		if tc.fail {
+			continue
+		}
+		if got != tc.out {
+			t.Errorf("parseDuration(%q) = %v, want %v", tc.in, got, tc.out)
+		}
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/cmd/cbt/cbtdoc.go
+++ b/vendor/cloud.google.com/go/bigtable/cmd/cbt/cbtdoc.go
@@ -0,0 +1,191 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// DO NOT EDIT. THIS IS AUTOMATICALLY GENERATED.
+// Run "go generate" to regenerate.
+//go:generate go run cbt.go -o cbtdoc.go doc
+
+/*
+Cbt is a tool for doing basic interactions with Cloud Bigtable.
+
+Usage:
+
+	cbt [options] command [arguments]
+
+The commands are:
+
+	count                     Count rows in a table
+	createfamily              Create a column family
+	createtable               Create a table
+	deletefamily              Delete a column family
+	deleterow                 Delete a row
+	deletetable               Delete a table
+	doc                       Print godoc-suitable documentation for cbt
+	help                      Print help text
+	listinstances             List instances in a project
+	lookup                    Read from a single row
+	ls                        List tables and column families
+	mddoc                     Print documentation for cbt in Markdown format
+	read                      Read rows
+	set                       Set value of a cell
+	setgcpolicy               Set the GC policy for a column family
+
+Use "cbt help <command>" for more information about a command.
+
+The options are:
+
+	-project string
+		project ID
+	-instance string
+		Cloud Bigtable instance
+	-creds string
+		if set, use application credentials in this file
+
+
+Count rows in a table
+
+Usage:
+	cbt count <table>
+
+
+
+
+Create a column family
+
+Usage:
+	cbt createfamily <table> <family>
+
+
+
+
+Create a table
+
+Usage:
+	cbt createtable <table>
+
+
+
+
+Delete a column family
+
+Usage:
+	cbt deletefamily <table> <family>
+
+
+
+
+Delete a row
+
+Usage:
+	cbt deleterow <table> <row>
+
+
+
+
+Delete a table
+
+Usage:
+	cbt deletetable <table>
+
+
+
+
+Print godoc-suitable documentation for cbt
+
+Usage:
+	cbt doc
+
+
+
+
+Print help text
+
+Usage:
+	cbt help [command]
+
+
+
+
+List instances in a project
+
+Usage:
+	cbt listinstances
+
+
+
+
+Read from a single row
+
+Usage:
+	cbt lookup <table> <row>
+
+
+
+
+List tables and column families
+
+Usage:
+	cbt ls			List tables
+	cbt ls <table>		List column families in <table>
+
+
+
+
+Print documentation for cbt in Markdown format
+
+Usage:
+	cbt mddoc
+
+
+
+
+Read rows
+
+Usage:
+	cbt read <table> [start=<row>] [end=<row>] [prefix=<prefix>] [count=<n>]
+	  start=<row>		Start reading at this row
+	  end=<row>		Stop reading before this row
+	  prefix=<prefix>	Read rows with this prefix
+	  count=<n>		Read only this many rows
+
+
+
+
+
+Set value of a cell
+
+Usage:
+	cbt set <table> <row> family:column=val[@ts] ...
+	  family:column=val[@ts] may be repeated to set multiple cells.
+
+	  ts is an optional integer timestamp.
+	  If it cannot be parsed, the `@ts` part will be
+	  interpreted as part of the value.
+
+
+
+
+Set the GC policy for a column family
+
+Usage:
+	cbt setgcpolicy <table> <family> ( maxage=<d> | maxversions=<n> )
+
+	  maxage=<d>		Maximum timestamp age to preserve (e.g. "1h", "4d")
+	  maxversions=<n>	Maximum number of versions to preserve
+
+
+
+
+*/
+package main
--- a/vendor/cloud.google.com/go/bigtable/cmd/emulator/cbtemulator.go
+++ b/vendor/cloud.google.com/go/bigtable/cmd/emulator/cbtemulator.go
@@ -0,0 +1,42 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*
+cbtemulator launches the in-memory Cloud Bigtable server on the given address.
+*/
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+
+	"cloud.google.com/go/bigtable/bttest"
+)
+
+var (
+	host = flag.String("host", "localhost", "the address to bind to on the local machine")
+	port = flag.Int("port", 9000, "the port number to bind to on the local machine")
+)
+
+func main() {
+	flag.Parse()
+	srv, err := bttest.NewServer(fmt.Sprintf("%s:%d", *host, *port))
+	if err != nil {
+		log.Fatalf("failed to start emulator: %v", err)
+	}
+
+	fmt.Printf("Cloud Bigtable emulator running on %s\n", srv.Addr)
+	select {}
+}
--- a/vendor/cloud.google.com/go/bigtable/cmd/loadtest/loadtest.go
+++ b/vendor/cloud.google.com/go/bigtable/cmd/loadtest/loadtest.go
@@ -0,0 +1,186 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Loadtest does some load testing through the Go client library for Cloud Bigtable.
+*/
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"cloud.google.com/go/bigtable"
+	"cloud.google.com/go/bigtable/internal/cbtrc"
+	"cloud.google.com/go/bigtable/internal/stat"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+)
+
+var (
+	runFor       = flag.Duration("run_for", 5*time.Second, "how long to run the load test for")
+	scratchTable = flag.String("scratch_table", "loadtest-scratch", "name of table to use; should not already exist")
+	csvOutput    = flag.String("csv_output", "",
+		"output path for statistics in .csv format. If this file already exists it will be overwritten.")
+	poolSize = flag.Int("pool_size", 1, "size of the gRPC connection pool to use for the data client")
+	reqCount = flag.Int("req_count", 100, "number of concurrent requests")
+
+	config      *cbtrc.Config
+	client      *bigtable.Client
+	adminClient *bigtable.AdminClient
+)
+
+func main() {
+	var err error
+	config, err = cbtrc.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+	config.RegisterFlags()
+
+	flag.Parse()
+	if err := config.CheckFlags(); err != nil {
+		log.Fatal(err)
+	}
+	if config.Creds != "" {
+		os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", config.Creds)
+	}
+	if flag.NArg() != 0 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	var options []option.ClientOption
+	if *poolSize > 1 {
+		options = append(options, option.WithGRPCConnectionPool(*poolSize))
+	}
+
+	var csvFile *os.File
+	if *csvOutput != "" {
+		csvFile, err = os.Create(*csvOutput)
+		if err != nil {
+			log.Fatalf("creating csv output file: %v", err)
+		}
+		defer csvFile.Close()
+		log.Printf("Writing statistics to %q ...", *csvOutput)
+	}
+
+	log.Printf("Dialing connections...")
+	client, err = bigtable.NewClient(context.Background(), config.Project, config.Instance, options...)
+	if err != nil {
+		log.Fatalf("Making bigtable.Client: %v", err)
+	}
+	defer client.Close()
+	adminClient, err = bigtable.NewAdminClient(context.Background(), config.Project, config.Instance)
+	if err != nil {
+		log.Fatalf("Making bigtable.AdminClient: %v", err)
+	}
+	defer adminClient.Close()
+
+	// Create a scratch table.
+	log.Printf("Setting up scratch table...")
+	if err := adminClient.CreateTable(context.Background(), *scratchTable); err != nil {
+		log.Fatalf("Making scratch table %q: %v", *scratchTable, err)
+	}
+	if err := adminClient.CreateColumnFamily(context.Background(), *scratchTable, "f"); err != nil {
+		log.Fatalf("Making scratch table column family: %v", err)
+	}
+	// Upon a successful run, delete the table. Don't bother checking for errors.
+	defer adminClient.DeleteTable(context.Background(), *scratchTable)
+
+	log.Printf("Starting load test... (run for %v)", *runFor)
+	tbl := client.Open(*scratchTable)
+	sem := make(chan int, *reqCount) // limit the number of requests happening at once
+	var reads, writes stats
+	stopTime := time.Now().Add(*runFor)
+	var wg sync.WaitGroup
+	for time.Now().Before(stopTime) {
+		sem <- 1
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-sem }()
+
+			ok := true
+			opStart := time.Now()
+			var stats *stats
+			defer func() {
+				stats.Record(ok, time.Since(opStart))
+			}()
+
+			row := fmt.Sprintf("row%d", rand.Intn(100)) // operate on 1 of 100 rows
+
+			switch rand.Intn(10) {
+			default:
+				// read
+				stats = &reads
+				_, err := tbl.ReadRow(context.Background(), row, bigtable.RowFilter(bigtable.LatestNFilter(1)))
+				if err != nil {
+					log.Printf("Error doing read: %v", err)
+					ok = false
+				}
+			case 0, 1, 2, 3, 4:
+				// write
+				stats = &writes
+				mut := bigtable.NewMutation()
+				mut.Set("f", "col", bigtable.Now(), bytes.Repeat([]byte("0"), 1<<10)) // 1 KB write
+				if err := tbl.Apply(context.Background(), row, mut); err != nil {
+					log.Printf("Error doing mutation: %v", err)
+					ok = false
+				}
+			}
+		}()
+	}
+	wg.Wait()
+
+	readsAgg := stat.NewAggregate("reads", reads.ds, reads.tries-reads.ok)
+	writesAgg := stat.NewAggregate("writes", writes.ds, writes.tries-writes.ok)
+	log.Printf("Reads (%d ok / %d tries):\n%v", reads.ok, reads.tries, readsAgg)
+	log.Printf("Writes (%d ok / %d tries):\n%v", writes.ok, writes.tries, writesAgg)
+
+	if csvFile != nil {
+		stat.WriteCSV([]*stat.Aggregate{readsAgg, writesAgg}, csvFile)
+	}
+}
+
+var allStats int64 // atomic
+
+type stats struct {
+	mu        sync.Mutex
+	tries, ok int
+	ds        []time.Duration
+}
+
+func (s *stats) Record(ok bool, d time.Duration) {
+	s.mu.Lock()
+	s.tries++
+	if ok {
+		s.ok++
+	}
+	s.ds = append(s.ds, d)
+	s.mu.Unlock()
+
+	if n := atomic.AddInt64(&allStats, 1); n%1000 == 0 {
+		log.Printf("Progress: done %d ops", n)
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/cmd/scantest/scantest.go
+++ b/vendor/cloud.google.com/go/bigtable/cmd/scantest/scantest.go
@@ -0,0 +1,155 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Scantest does scan-related load testing against Cloud Bigtable. The logic here
+mimics a similar test written using the Java client.
+*/
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"sync"
+	"sync/atomic"
+	"text/tabwriter"
+	"time"
+
+	"cloud.google.com/go/bigtable"
+	"cloud.google.com/go/bigtable/internal/cbtrc"
+	"cloud.google.com/go/bigtable/internal/stat"
+	"golang.org/x/net/context"
+)
+
+var (
+	runFor   = flag.Duration("run_for", 5*time.Second, "how long to run the load test for")
+	numScans = flag.Int("concurrent_scans", 1, "number of concurrent scans")
+	rowLimit = flag.Int("row_limit", 10000, "max number of records per scan")
+
+	config *cbtrc.Config
+	client *bigtable.Client
+)
+
+func main() {
+	flag.Usage = func() {
+		fmt.Printf("Usage: scantest [options] <table_name>\n\n")
+		flag.PrintDefaults()
+	}
+
+	var err error
+	config, err = cbtrc.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+	config.RegisterFlags()
+
+	flag.Parse()
+	if err := config.CheckFlags(); err != nil {
+		log.Fatal(err)
+	}
+	if config.Creds != "" {
+		os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", config.Creds)
+	}
+	if flag.NArg() != 1 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	table := flag.Arg(0)
+
+	log.Printf("Dialing connections...")
+	client, err = bigtable.NewClient(context.Background(), config.Project, config.Instance)
+	if err != nil {
+		log.Fatalf("Making bigtable.Client: %v", err)
+	}
+	defer client.Close()
+
+	log.Printf("Starting scan test... (run for %v)", *runFor)
+	tbl := client.Open(table)
+	sem := make(chan int, *numScans) // limit the number of requests happening at once
+	var scans stats
+
+	stopTime := time.Now().Add(*runFor)
+	var wg sync.WaitGroup
+	for time.Now().Before(stopTime) {
+		sem <- 1
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-sem }()
+
+			ok := true
+			opStart := time.Now()
+			defer func() {
+				scans.Record(ok, time.Since(opStart))
+			}()
+
+			// Start at a random row key
+			key := fmt.Sprintf("user%d", rand.Int63())
+			limit := bigtable.LimitRows(int64(*rowLimit))
+			noop := func(bigtable.Row) bool { return true }
+			if err := tbl.ReadRows(context.Background(), bigtable.NewRange(key, ""), noop, limit); err != nil {
+				log.Printf("Error during scan: %v", err)
+				ok = false
+			}
+		}()
+	}
+	wg.Wait()
+
+	agg := stat.NewAggregate("scans", scans.ds, scans.tries-scans.ok)
+	log.Printf("Scans (%d ok / %d tries):\nscan times:\n%v\nthroughput (rows/second):\n%v",
+		scans.ok, scans.tries, agg, throughputString(agg))
+}
+
+func throughputString(agg *stat.Aggregate) string {
+	var buf bytes.Buffer
+	tw := tabwriter.NewWriter(&buf, 0, 0, 1, ' ', 0) // one-space padding
+	rowLimitF := float64(*rowLimit)
+	fmt.Fprintf(
+		tw,
+		"min:\t%.2f\nmedian:\t%.2f\nmax:\t%.2f\n",
+		rowLimitF/agg.Max.Seconds(),
+		rowLimitF/agg.Median.Seconds(),
+		rowLimitF/agg.Min.Seconds())
+	tw.Flush()
+	return buf.String()
+}
+
+var allStats int64 // atomic
+
+type stats struct {
+	mu        sync.Mutex
+	tries, ok int
+	ds        []time.Duration
+}
+
+func (s *stats) Record(ok bool, d time.Duration) {
+	s.mu.Lock()
+	s.tries++
+	if ok {
+		s.ok++
+	}
+	s.ds = append(s.ds, d)
+	s.mu.Unlock()
+
+	if n := atomic.AddInt64(&allStats, 1); n%1000 == 0 {
+		log.Printf("Progress: done %d ops", n)
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/doc.go
+++ b/vendor/cloud.google.com/go/bigtable/doc.go
@@ -0,0 +1,119 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Package bigtable is an API to Google Cloud Bigtable.
+
+See https://cloud.google.com/bigtable/docs/ for general product documentation.
+
+Setup and Credentials
+
+Use NewClient or NewAdminClient to create a client that can be used to access
+the data or admin APIs respectively. Both require credentials that have permission
+to access the Cloud Bigtable API.
+
+If your program is run on Google App Engine or Google Compute Engine, using the Application Default Credentials
+(https://developers.google.com/accounts/docs/application-default-credentials)
+is the simplest option. Those credentials will be used by default when NewClient or NewAdminClient are called.
+
+To use alternate credentials, pass them to NewClient or NewAdminClient using option.WithTokenSource.
+For instance, you can use service account credentials by visiting
+https://cloud.google.com/console/project/MYPROJECT/apiui/credential,
+creating a new OAuth "Client ID", storing the JSON key somewhere accessible, and writing
+	jsonKey, err := ioutil.ReadFile(pathToKeyFile)
+	...
+	config, err := google.JWTConfigFromJSON(jsonKey, bigtable.Scope) // or bigtable.AdminScope, etc.
+	...
+	client, err := bigtable.NewClient(ctx, project, instance, option.WithTokenSource(config.TokenSource(ctx)))
+	...
+Here, `google` means the golang.org/x/oauth2/google package
+and `option` means the google.golang.org/api/option package.
+
+Reading
+
+The principal way to read from a Bigtable is to use the ReadRows method on *Table.
+A RowRange specifies a contiguous portion of a table. A Filter may be provided through
+RowFilter to limit or transform the data that is returned.
+	tbl := client.Open("mytable")
+	...
+	// Read all the rows starting with "com.google.",
+	// but only fetch the columns in the "links" family.
+	rr := bigtable.PrefixRange("com.google.")
+	err := tbl.ReadRows(ctx, rr, func(r Row) bool {
+		// do something with r
+		return true // keep going
+	}, bigtable.RowFilter(bigtable.FamilyFilter("links")))
+	...
+
+To read a single row, use the ReadRow helper method.
+	r, err := tbl.ReadRow(ctx, "com.google.cloud") // "com.google.cloud" is the entire row key
+	...
+
+Writing
+
+This API exposes two distinct forms of writing to a Bigtable: a Mutation and a ReadModifyWrite.
+The former expresses idempotent operations.
+The latter expresses non-idempotent operations and returns the new values of updated cells.
+These operations are performed by creating a Mutation or ReadModifyWrite (with NewMutation or NewReadModifyWrite),
+building up one or more operations on that, and then using the Apply or ApplyReadModifyWrite
+methods on a Table.
+
+For instance, to set a couple of cells in a table,
+	tbl := client.Open("mytable")
+	mut := bigtable.NewMutation()
+	mut.Set("links", "maps.google.com", bigtable.Now(), []byte("1"))
+	mut.Set("links", "golang.org", bigtable.Now(), []byte("1"))
+	err := tbl.Apply(ctx, "com.google.cloud", mut)
+	...
+
+To increment an encoded value in one cell,
+	tbl := client.Open("mytable")
+	rmw := bigtable.NewReadModifyWrite()
+	rmw.Increment("links", "golang.org", 12) // add 12 to the cell in column "links:golang.org"
+	r, err := tbl.ApplyReadModifyWrite(ctx, "com.google.cloud", rmw)
+	...
+
+Retries
+
+If a read or write operation encounters a transient error it will be retried until a successful
+response, an unretryable error or the context deadline is reached. Non-idempotent writes (where
+the timestamp is set to ServerTime) will not be retried. In the case of ReadRows, retried calls
+will not re-scan rows that have already been processed.
+*/
+package bigtable // import "cloud.google.com/go/bigtable"
+
+// Scope constants for authentication credentials.
+// These should be used when using credential creation functions such as oauth.NewServiceAccountFromFile.
+const (
+	// Scope is the OAuth scope for Cloud Bigtable data operations.
+	Scope = "https://www.googleapis.com/auth/bigtable.data"
+	// ReadonlyScope is the OAuth scope for Cloud Bigtable read-only data operations.
+	ReadonlyScope = "https://www.googleapis.com/auth/bigtable.readonly"
+
+	// AdminScope is the OAuth scope for Cloud Bigtable table admin operations.
+	AdminScope = "https://www.googleapis.com/auth/bigtable.admin.table"
+
+	// InstanceAdminScope is the OAuth scope for Cloud Bigtable instance (and cluster) admin operations.
+	InstanceAdminScope = "https://www.googleapis.com/auth/bigtable.admin.cluster"
+)
+
+// clientUserAgent identifies the version of this package.
+// It should be bumped upon significant changes only.
+const clientUserAgent = "cbt-go/20160628"
+
+// resourcePrefixHeader is the name of the metadata header used to indicate
+// the resource being operated on.
+const resourcePrefixHeader = "google-cloud-resource-prefix"
--- a/vendor/cloud.google.com/go/bigtable/filter.go
+++ b/vendor/cloud.google.com/go/bigtable/filter.go
@@ -0,0 +1,156 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable
+
+import (
+	"fmt"
+	"strings"
+
+	btpb "google.golang.org/genproto/googleapis/bigtable/v2"
+)
+
+// A Filter represents a row filter.
+type Filter interface {
+	String() string
+	proto() *btpb.RowFilter
+}
+
+// ChainFilters returns a filter that applies a sequence of filters.
+func ChainFilters(sub ...Filter) Filter { return chainFilter{sub} }
+
+type chainFilter struct {
+	sub []Filter
+}
+
+func (cf chainFilter) String() string {
+	var ss []string
+	for _, sf := range cf.sub {
+		ss = append(ss, sf.String())
+	}
+	return "(" + strings.Join(ss, " | ") + ")"
+}
+
+func (cf chainFilter) proto() *btpb.RowFilter {
+	chain := &btpb.RowFilter_Chain{}
+	for _, sf := range cf.sub {
+		chain.Filters = append(chain.Filters, sf.proto())
+	}
+	return &btpb.RowFilter{
+		Filter: &btpb.RowFilter_Chain_{chain},
+	}
+}
+
+// InterleaveFilters returns a filter that applies a set of filters in parallel
+// and interleaves the results.
+func InterleaveFilters(sub ...Filter) Filter { return interleaveFilter{sub} }
+
+type interleaveFilter struct {
+	sub []Filter
+}
+
+func (ilf interleaveFilter) String() string {
+	var ss []string
+	for _, sf := range ilf.sub {
+		ss = append(ss, sf.String())
+	}
+	return "(" + strings.Join(ss, " + ") + ")"
+}
+
+func (ilf interleaveFilter) proto() *btpb.RowFilter {
+	inter := &btpb.RowFilter_Interleave{}
+	for _, sf := range ilf.sub {
+		inter.Filters = append(inter.Filters, sf.proto())
+	}
+	return &btpb.RowFilter{
+		Filter: &btpb.RowFilter_Interleave_{inter},
+	}
+}
+
+// RowKeyFilter returns a filter that matches cells from rows whose
+// key matches the provided RE2 pattern.
+// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
+func RowKeyFilter(pattern string) Filter { return rowKeyFilter(pattern) }
+
+type rowKeyFilter string
+
+func (rkf rowKeyFilter) String() string { return fmt.Sprintf("row(%s)", string(rkf)) }
+
+func (rkf rowKeyFilter) proto() *btpb.RowFilter {
+	return &btpb.RowFilter{Filter: &btpb.RowFilter_RowKeyRegexFilter{[]byte(rkf)}}
+}
+
+// FamilyFilter returns a filter that matches cells whose family name
+// matches the provided RE2 pattern.
+// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
+func FamilyFilter(pattern string) Filter { return familyFilter(pattern) }
+
+type familyFilter string
+
+func (ff familyFilter) String() string { return fmt.Sprintf("col(%s:)", string(ff)) }
+
+func (ff familyFilter) proto() *btpb.RowFilter {
+	return &btpb.RowFilter{Filter: &btpb.RowFilter_FamilyNameRegexFilter{string(ff)}}
+}
+
+// ColumnFilter returns a filter that matches cells whose column name
+// matches the provided RE2 pattern.
+// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
+func ColumnFilter(pattern string) Filter { return columnFilter(pattern) }
+
+type columnFilter string
+
+func (cf columnFilter) String() string { return fmt.Sprintf("col(.*:%s)", string(cf)) }
+
+func (cf columnFilter) proto() *btpb.RowFilter {
+	return &btpb.RowFilter{Filter: &btpb.RowFilter_ColumnQualifierRegexFilter{[]byte(cf)}}
+}
+
+// ValueFilter returns a filter that matches cells whose value
+// matches the provided RE2 pattern.
+// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
+func ValueFilter(pattern string) Filter { return valueFilter(pattern) }
+
+type valueFilter string
+
+func (vf valueFilter) String() string { return fmt.Sprintf("value_match(%s)", string(vf)) }
+
+func (vf valueFilter) proto() *btpb.RowFilter {
+	return &btpb.RowFilter{Filter: &btpb.RowFilter_ValueRegexFilter{[]byte(vf)}}
+}
+
+// LatestNFilter returns a filter that matches the most recent N cells in each column.
+func LatestNFilter(n int) Filter { return latestNFilter(n) }
+
+type latestNFilter int32
+
+func (lnf latestNFilter) String() string { return fmt.Sprintf("col(*,%d)", lnf) }
+
+func (lnf latestNFilter) proto() *btpb.RowFilter {
+	return &btpb.RowFilter{Filter: &btpb.RowFilter_CellsPerColumnLimitFilter{int32(lnf)}}
+}
+
+// StripValueFilter returns a filter that replaces each value with the empty string.
+func StripValueFilter() Filter { return stripValueFilter{} }
+
+type stripValueFilter struct{}
+
+func (stripValueFilter) String() string { return "strip_value()" }
+func (stripValueFilter) proto() *btpb.RowFilter {
+	return &btpb.RowFilter{Filter: &btpb.RowFilter_StripValueTransformer{true}}
+}
+
+// TODO(dsymonds): More filters: cond, col/ts/value range, sampling
--- a/vendor/cloud.google.com/go/bigtable/gc.go
+++ b/vendor/cloud.google.com/go/bigtable/gc.go
@@ -0,0 +1,131 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	durpb "github.com/golang/protobuf/ptypes/duration"
+	bttdpb "google.golang.org/genproto/googleapis/bigtable/admin/v2"
+)
+
+// A GCPolicy represents a rule that determines which cells are eligible for garbage collection.
+type GCPolicy interface {
+	String() string
+	proto() *bttdpb.GcRule
+}
+
+// IntersectionPolicy returns a GC policy that only applies when all its sub-policies apply.
+func IntersectionPolicy(sub ...GCPolicy) GCPolicy { return intersectionPolicy{sub} }
+
+type intersectionPolicy struct {
+	sub []GCPolicy
+}
+
+func (ip intersectionPolicy) String() string {
+	var ss []string
+	for _, sp := range ip.sub {
+		ss = append(ss, sp.String())
+	}
+	return "(" + strings.Join(ss, " && ") + ")"
+}
+
+func (ip intersectionPolicy) proto() *bttdpb.GcRule {
+	inter := &bttdpb.GcRule_Intersection{}
+	for _, sp := range ip.sub {
+		inter.Rules = append(inter.Rules, sp.proto())
+	}
+	return &bttdpb.GcRule{
+		Rule: &bttdpb.GcRule_Intersection_{inter},
+	}
+}
+
+// UnionPolicy returns a GC policy that applies when any of its sub-policies apply.
+func UnionPolicy(sub ...GCPolicy) GCPolicy { return unionPolicy{sub} }
+
+type unionPolicy struct {
+	sub []GCPolicy
+}
+
+func (up unionPolicy) String() string {
+	var ss []string
+	for _, sp := range up.sub {
+		ss = append(ss, sp.String())
+	}
+	return "(" + strings.Join(ss, " || ") + ")"
+}
+
+func (up unionPolicy) proto() *bttdpb.GcRule {
+	union := &bttdpb.GcRule_Union{}
+	for _, sp := range up.sub {
+		union.Rules = append(union.Rules, sp.proto())
+	}
+	return &bttdpb.GcRule{
+		Rule: &bttdpb.GcRule_Union_{union},
+	}
+}
+
+// MaxVersionsPolicy returns a GC policy that applies to all versions of a cell
+// except for the most recent n.
+func MaxVersionsPolicy(n int) GCPolicy { return maxVersionsPolicy(n) }
+
+type maxVersionsPolicy int
+
+func (mvp maxVersionsPolicy) String() string { return fmt.Sprintf("versions() > %d", int(mvp)) }
+
+func (mvp maxVersionsPolicy) proto() *bttdpb.GcRule {
+	return &bttdpb.GcRule{Rule: &bttdpb.GcRule_MaxNumVersions{int32(mvp)}}
+}
+
+// MaxAgePolicy returns a GC policy that applies to all cells
+// older than the given age.
+func MaxAgePolicy(d time.Duration) GCPolicy { return maxAgePolicy(d) }
+
+type maxAgePolicy time.Duration
+
+var units = []struct {
+	d      time.Duration
+	suffix string
+}{
+	{24 * time.Hour, "d"},
+	{time.Hour, "h"},
+	{time.Minute, "m"},
+}
+
+func (ma maxAgePolicy) String() string {
+	d := time.Duration(ma)
+	for _, u := range units {
+		if d%u.d == 0 {
+			return fmt.Sprintf("age() > %d%s", d/u.d, u.suffix)
+		}
+	}
+	return fmt.Sprintf("age() > %d", d/time.Microsecond)
+}
+
+func (ma maxAgePolicy) proto() *bttdpb.GcRule {
+	// This doesn't handle overflows, etc.
+	// Fix this if people care about GC policies over 290 years.
+	ns := time.Duration(ma).Nanoseconds()
+	return &bttdpb.GcRule{
+		Rule: &bttdpb.GcRule_MaxAge{&durpb.Duration{
+			Seconds: ns / 1e9,
+			Nanos:   int32(ns % 1e9),
+		}},
+	}
+}
--- a/vendor/cloud.google.com/go/bigtable/internal/cbtrc/cbtrc.go
+++ b/vendor/cloud.google.com/go/bigtable/internal/cbtrc/cbtrc.go
@@ -0,0 +1,99 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package cbtrc encapsulates common code for reading .cbtrc files.
+package cbtrc
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Config represents a configuration.
+type Config struct {
+	Project, Instance string // required
+	Creds             string // optional
+}
+
+// RegisterFlags registers a set of standard flags for this config.
+// It should be called before flag.Parse.
+func (c *Config) RegisterFlags() {
+	flag.StringVar(&c.Project, "project", c.Project, "project ID")
+	flag.StringVar(&c.Instance, "instance", c.Instance, "Cloud Bigtable instance")
+	flag.StringVar(&c.Creds, "creds", c.Creds, "if set, use application credentials in this file")
+}
+
+// CheckFlags checks that the required config values are set.
+func (c *Config) CheckFlags() error {
+	var missing []string
+	if c.Project == "" {
+		missing = append(missing, "-project")
+	}
+	if c.Instance == "" {
+		missing = append(missing, "-instance")
+	}
+	if len(missing) > 0 {
+		return fmt.Errorf("Missing %s", strings.Join(missing, " and "))
+	}
+	return nil
+}
+
+// Filename returns the filename consulted for standard configuration.
+func Filename() string {
+	// TODO(dsymonds): Might need tweaking for Windows.
+	return filepath.Join(os.Getenv("HOME"), ".cbtrc")
+}
+
+// Load loads a .cbtrc file.
+// If the file is not present, an empty config is returned.
+func Load() (*Config, error) {
+	filename := Filename()
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		// silent fail if the file isn't there
+		if os.IsNotExist(err) {
+			return &Config{}, nil
+		}
+		return nil, fmt.Errorf("Reading %s: %v", filename, err)
+	}
+	c := new(Config)
+	s := bufio.NewScanner(bytes.NewReader(data))
+	for s.Scan() {
+		line := s.Text()
+		i := strings.Index(line, "=")
+		if i < 0 {
+			return nil, fmt.Errorf("Bad line in %s: %q", filename, line)
+		}
+		key, val := strings.TrimSpace(line[:i]), strings.TrimSpace(line[i+1:])
+		switch key {
+		default:
+			return nil, fmt.Errorf("Unknown key in %s: %q", filename, key)
+		case "project":
+			c.Project = val
+		case "instance":
+			c.Instance = val
+		case "creds":
+			c.Creds = val
+		}
+	}
+	return c, s.Err()
+}
--- a/vendor/cloud.google.com/go/bigtable/internal/gax/call_option.go
+++ b/vendor/cloud.google.com/go/bigtable/internal/gax/call_option.go
@@ -0,0 +1,106 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This is ia snapshot from github.com/googleapis/gax-go with minor modifications.
+package gax
+
+import (
+	"time"
+
+	"google.golang.org/grpc/codes"
+)
+
+type CallOption interface {
+	Resolve(*CallSettings)
+}
+
+type callOptions []CallOption
+
+func (opts callOptions) Resolve(s *CallSettings) *CallSettings {
+	for _, opt := range opts {
+		opt.Resolve(s)
+	}
+	return s
+}
+
+// Encapsulates the call settings for a particular API call.
+type CallSettings struct {
+	Timeout       time.Duration
+	RetrySettings RetrySettings
+}
+
+// Per-call configurable settings for retrying upon transient failure.
+type RetrySettings struct {
+	RetryCodes      map[codes.Code]bool
+	BackoffSettings BackoffSettings
+}
+
+// Parameters to the exponential backoff algorithm for retrying.
+type BackoffSettings struct {
+	DelayTimeoutSettings MultipliableDuration
+	RPCTimeoutSettings   MultipliableDuration
+}
+
+type MultipliableDuration struct {
+	Initial    time.Duration
+	Max        time.Duration
+	Multiplier float64
+}
+
+func (w CallSettings) Resolve(s *CallSettings) {
+	s.Timeout = w.Timeout
+	s.RetrySettings = w.RetrySettings
+
+	s.RetrySettings.RetryCodes = make(map[codes.Code]bool, len(w.RetrySettings.RetryCodes))
+	for key, value := range w.RetrySettings.RetryCodes {
+		s.RetrySettings.RetryCodes[key] = value
+	}
+}
+
+type withRetryCodes []codes.Code
+
+func (w withRetryCodes) Resolve(s *CallSettings) {
+	s.RetrySettings.RetryCodes = make(map[codes.Code]bool)
+	for _, code := range w {
+		s.RetrySettings.RetryCodes[code] = true
+	}
+}
+
+// WithRetryCodes sets a list of Google API canonical error codes upon which a
+// retry should be attempted.
+func WithRetryCodes(retryCodes []codes.Code) CallOption {
+	return withRetryCodes(retryCodes)
+}
+
+type withDelayTimeoutSettings MultipliableDuration
+
+func (w withDelayTimeoutSettings) Resolve(s *CallSettings) {
+	s.RetrySettings.BackoffSettings.DelayTimeoutSettings = MultipliableDuration(w)
+}
+
+// WithDelayTimeoutSettings specifies:
+// - The initial delay time, in milliseconds, between the completion of
+//   the first failed request and the initiation of the first retrying
+//   request.
+// - The multiplier by which to increase the delay time between the
+//   completion of failed requests, and the initiation of the subsequent
+//   retrying request.
+// - The maximum delay time, in milliseconds, between requests. When this
+//   value is reached, `RetryDelayMultiplier` will no longer be used to
+//   increase delay time.
+func WithDelayTimeoutSettings(initial time.Duration, max time.Duration, multiplier float64) CallOption {
+	return withDelayTimeoutSettings(MultipliableDuration{initial, max, multiplier})
+}
--- a/vendor/cloud.google.com/go/bigtable/internal/gax/invoke.go
+++ b/vendor/cloud.google.com/go/bigtable/internal/gax/invoke.go
@@ -0,0 +1,84 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This is ia snapshot from github.com/googleapis/gax-go with minor modifications.
+package gax
+
+import (
+	"math/rand"
+	"time"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"log"
+	"os"
+)
+
+var logger *log.Logger = log.New(os.Stderr, "", log.LstdFlags)
+
+// A user defined call stub.
+type APICall func(context.Context) error
+
+// scaleDuration returns the product of a and mult.
+func scaleDuration(a time.Duration, mult float64) time.Duration {
+	ns := float64(a) * mult
+	return time.Duration(ns)
+}
+
+// invokeWithRetry calls stub using an exponential backoff retry mechanism
+// based on the values provided in callSettings.
+func invokeWithRetry(ctx context.Context, stub APICall, callSettings CallSettings) error {
+	retrySettings := callSettings.RetrySettings
+	backoffSettings := callSettings.RetrySettings.BackoffSettings
+	delay := backoffSettings.DelayTimeoutSettings.Initial
+	for {
+		// If the deadline is exceeded...
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		err := stub(ctx)
+		code := grpc.Code(err)
+		if code == codes.OK {
+			return nil
+		}
+
+		if !retrySettings.RetryCodes[code] {
+			return err
+		}
+
+		// Sleep a random amount up to the current delay
+		d := time.Duration(rand.Int63n(int64(delay)))
+		delayCtx, _ := context.WithTimeout(ctx, delay)
+		logger.Printf("Retryable error: %v, retrying in %v", err, d)
+		<-delayCtx.Done()
+
+		delay = scaleDuration(delay, backoffSettings.DelayTimeoutSettings.Multiplier)
+		if delay > backoffSettings.DelayTimeoutSettings.Max {
+			delay = backoffSettings.DelayTimeoutSettings.Max
+		}
+	}
+}
+
+// Invoke calls stub with a child of context modified by the specified options.
+func Invoke(ctx context.Context, stub APICall, opts ...CallOption) error {
+	settings := &CallSettings{}
+	callOptions(opts).Resolve(settings)
+	if len(settings.RetrySettings.RetryCodes) > 0 {
+		return invokeWithRetry(ctx, stub, *settings)
+	}
+	return stub(ctx)
+}
--- a/vendor/cloud.google.com/go/bigtable/internal/gax/invoke_test.go
+++ b/vendor/cloud.google.com/go/bigtable/internal/gax/invoke_test.go
@@ -0,0 +1,49 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package gax
+
+import (
+	"testing"
+	"time"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+func TestRandomizedDelays(t *testing.T) {
+	max := 200 * time.Millisecond
+	settings := []CallOption{
+		WithRetryCodes([]codes.Code{codes.Unavailable, codes.DeadlineExceeded}),
+		WithDelayTimeoutSettings(10*time.Millisecond, max, 1.5),
+	}
+
+	deadline := time.Now().Add(1 * time.Second)
+	ctx, _ := context.WithDeadline(context.Background(), deadline)
+	var invokeTime time.Time
+	Invoke(ctx, func(childCtx context.Context) error {
+		// Keep failing, make sure we never slept more than max (plus a fudge factor)
+		if !invokeTime.IsZero() {
+			if time.Since(invokeTime) > (max + 20*time.Millisecond) {
+				t.Fatalf("Slept too long: %v", max)
+			}
+		}
+		invokeTime = time.Now()
+		// Workaround for `go vet`: https://github.com/grpc/grpc-go/issues/90
+		errf := grpc.Errorf
+		return errf(codes.Unavailable, "")
+	}, settings...)
+}
--- a/vendor/cloud.google.com/go/bigtable/internal/option/option.go
+++ b/vendor/cloud.google.com/go/bigtable/internal/option/option.go
@@ -0,0 +1,48 @@
+/*
+Copyright 2015 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package option contains common code for dealing with client options.
+package option
+
+import (
+	"fmt"
+	"os"
+
+	"google.golang.org/api/option"
+	"google.golang.org/grpc"
+)
+
+// DefaultClientOptions returns the default client options to use for the
+// client's gRPC connection.
+func DefaultClientOptions(endpoint, scope, userAgent string) ([]option.ClientOption, error) {
+	var o []option.ClientOption
+	// Check the environment variables for the bigtable emulator.
+	// Dial it directly and don't pass any credentials.
+	if addr := os.Getenv("BIGTABLE_EMULATOR_HOST"); addr != "" {
+		conn, err := grpc.Dial(addr, grpc.WithInsecure())
+		if err != nil {
+			return nil, fmt.Errorf("emulator grpc.Dial: %v", err)
+		}
+		o = []option.ClientOption{option.WithGRPCConn(conn)}
+	} else {
+		o = []option.ClientOption{
+			option.WithEndpoint(endpoint),
+			option.WithScopes(scope),
+			option.WithUserAgent(userAgent),
+		}
+	}
+	return o, nil
+}
--- a/vendor/cloud.google.com/go/bigtable/internal/stat/stats.go
+++ b/vendor/cloud.google.com/go/bigtable/internal/stat/stats.go
@@ -0,0 +1,144 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package stat
+
+import (
+	"bytes"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"math"
+	"sort"
+	"strconv"
+	"text/tabwriter"
+	"time"
+)
+
+type byDuration []time.Duration
+
+func (data byDuration) Len() int           { return len(data) }
+func (data byDuration) Swap(i, j int)      { data[i], data[j] = data[j], data[i] }
+func (data byDuration) Less(i, j int) bool { return data[i] < data[j] }
+
+// quantile returns a value representing the kth of q quantiles.
+// May alter the order of data.
+func quantile(data []time.Duration, k, q int) (quantile time.Duration, ok bool) {
+	if len(data) < 1 {
+		return 0, false
+	}
+	if k > q {
+		return 0, false
+	}
+	if k < 0 || q < 1 {
+		return 0, false
+	}
+
+	sort.Sort(byDuration(data))
+
+	if k == 0 {
+		return data[0], true
+	}
+	if k == q {
+		return data[len(data)-1], true
+	}
+
+	bucketSize := float64(len(data)-1) / float64(q)
+	i := float64(k) * bucketSize
+
+	lower := int(math.Trunc(i))
+	var upper int
+	if i > float64(lower) && lower+1 < len(data) {
+		// If the quantile lies between two elements
+		upper = lower + 1
+	} else {
+		upper = lower
+	}
+	weightUpper := i - float64(lower)
+	weightLower := 1 - weightUpper
+	return time.Duration(weightLower*float64(data[lower]) + weightUpper*float64(data[upper])), true
+}
+
+type Aggregate struct {
+	Name               string
+	Count, Errors      int
+	Min, Median, Max   time.Duration
+	P75, P90, P95, P99 time.Duration // percentiles
+}
+
+// NewAggregate constructs an aggregate from latencies. Returns nil if latencies does not contain aggregateable data.
+func NewAggregate(name string, latencies []time.Duration, errorCount int) *Aggregate {
+	agg := Aggregate{Name: name, Count: len(latencies), Errors: errorCount}
+
+	if len(latencies) == 0 {
+		return nil
+	}
+	var ok bool
+	if agg.Min, ok = quantile(latencies, 0, 2); !ok {
+		return nil
+	}
+	if agg.Median, ok = quantile(latencies, 1, 2); !ok {
+		return nil
+	}
+	if agg.Max, ok = quantile(latencies, 2, 2); !ok {
+		return nil
+	}
+	if agg.P75, ok = quantile(latencies, 75, 100); !ok {
+		return nil
+	}
+	if agg.P90, ok = quantile(latencies, 90, 100); !ok {
+		return nil
+	}
+	if agg.P95, ok = quantile(latencies, 95, 100); !ok {
+		return nil
+	}
+	if agg.P99, ok = quantile(latencies, 99, 100); !ok {
+		return nil
+	}
+	return &agg
+}
+
+func (agg *Aggregate) String() string {
+	if agg == nil {
+		return "no data"
+	}
+	var buf bytes.Buffer
+	tw := tabwriter.NewWriter(&buf, 0, 0, 1, ' ', 0) // one-space padding
+	fmt.Fprintf(tw, "min:\t%v\nmedian:\t%v\nmax:\t%v\n95th percentile:\t%v\n99th percentile:\t%v\n",
+		agg.Min, agg.Median, agg.Max, agg.P95, agg.P99)
+	tw.Flush()
+	return buf.String()
+}
+
+// WriteCSV writes a csv file to the given Writer,
+// with a header row and one row per aggregate.
+func WriteCSV(aggs []*Aggregate, iow io.Writer) error {
+	w := csv.NewWriter(iow)
+	defer w.Flush()
+	err := w.Write([]string{"name", "count", "errors", "min", "median", "max", "p75", "p90", "p95", "p99"})
+	if err != nil {
+		return err
+	}
+	for _, agg := range aggs {
+		err = w.Write([]string{
+			agg.Name, strconv.Itoa(agg.Count), strconv.Itoa(agg.Errors),
+			agg.Min.String(), agg.Median.String(), agg.Max.String(),
+			agg.P75.String(), agg.P90.String(), agg.P95.String(), agg.P99.String(),
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
--- a/vendor/cloud.google.com/go/bigtable/reader.go
+++ b/vendor/cloud.google.com/go/bigtable/reader.go
@@ -0,0 +1,250 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable
+
+import (
+	"bytes"
+	"fmt"
+
+	btpb "google.golang.org/genproto/googleapis/bigtable/v2"
+)
+
+// A Row is returned by ReadRows. The map is keyed by column family (the prefix
+// of the column name before the colon). The values are the returned ReadItems
+// for that column family in the order returned by Read.
+type Row map[string][]ReadItem
+
+// Key returns the row's key, or "" if the row is empty.
+func (r Row) Key() string {
+	for _, items := range r {
+		if len(items) > 0 {
+			return items[0].Row
+		}
+	}
+	return ""
+}
+
+// A ReadItem is returned by Read. A ReadItem contains data from a specific row and column.
+type ReadItem struct {
+	Row, Column string
+	Timestamp   Timestamp
+	Value       []byte
+}
+
+// The current state of the read rows state machine.
+type rrState int64
+
+const (
+	newRow rrState = iota
+	rowInProgress
+	cellInProgress
+)
+
+// chunkReader handles cell chunks from the read rows response and combines
+// them into full Rows.
+type chunkReader struct {
+	state   rrState
+	curKey  []byte
+	curFam  string
+	curQual []byte
+	curTS   int64
+	curVal  []byte
+	curRow  Row
+	lastKey string
+}
+
+// newChunkReader returns a new chunkReader for handling read rows responses.
+func newChunkReader() *chunkReader {
+	return &chunkReader{state: newRow}
+}
+
+// Process takes a cell chunk and returns a new Row if the given chunk
+// completes a Row, or nil otherwise.
+func (cr *chunkReader) Process(cc *btpb.ReadRowsResponse_CellChunk) (Row, error) {
+	var row Row
+	switch cr.state {
+	case newRow:
+		if err := cr.validateNewRow(cc); err != nil {
+			return nil, err
+		}
+
+		cr.curRow = make(Row)
+		cr.curKey = cc.RowKey
+		cr.curFam = cc.FamilyName.Value
+		cr.curQual = cc.Qualifier.Value
+		cr.curTS = cc.TimestampMicros
+		row = cr.handleCellValue(cc)
+
+	case rowInProgress:
+		if err := cr.validateRowInProgress(cc); err != nil {
+			return nil, err
+		}
+
+		if cc.GetResetRow() {
+			cr.resetToNewRow()
+			return nil, nil
+		}
+
+		if cc.FamilyName != nil {
+			cr.curFam = cc.FamilyName.Value
+		}
+		if cc.Qualifier != nil {
+			cr.curQual = cc.Qualifier.Value
+		}
+		cr.curTS = cc.TimestampMicros
+		row = cr.handleCellValue(cc)
+
+	case cellInProgress:
+		if err := cr.validateCellInProgress(cc); err != nil {
+			return nil, err
+		}
+		if cc.GetResetRow() {
+			cr.resetToNewRow()
+			return nil, nil
+		}
+		row = cr.handleCellValue(cc)
+	}
+
+	return row, nil
+}
+
+// Close must be called after all cell chunks from the response
+// have been processed. An error will be returned if the reader is
+// in an invalid state, in which case the error should be propagated to the caller.
+func (cr *chunkReader) Close() error {
+	if cr.state != newRow {
+		return fmt.Errorf("invalid state for end of stream %q", cr.state)
+	}
+	return nil
+}
+
+// handleCellValue returns a Row if the cell value includes a commit, otherwise nil.
+func (cr *chunkReader) handleCellValue(cc *btpb.ReadRowsResponse_CellChunk) Row {
+	if cc.ValueSize > 0 {
+		// ValueSize is specified so expect a split value of ValueSize bytes
+		if cr.curVal == nil {
+			cr.curVal = make([]byte, 0, cc.ValueSize)
+		}
+		cr.curVal = append(cr.curVal, cc.Value...)
+		cr.state = cellInProgress
+	} else {
+		// This cell is either the complete value or the last chunk of a split
+		if cr.curVal == nil {
+			cr.curVal = cc.Value
+		} else {
+			cr.curVal = append(cr.curVal, cc.Value...)
+		}
+		cr.finishCell()
+
+		if cc.GetCommitRow() {
+			return cr.commitRow()
+		} else {
+			cr.state = rowInProgress
+		}
+	}
+
+	return nil
+}
+
+func (cr *chunkReader) finishCell() {
+	ri := ReadItem{
+		Row:       string(cr.curKey),
+		Column:    fmt.Sprintf("%s:%s", cr.curFam, cr.curQual),
+		Timestamp: Timestamp(cr.curTS),
+		Value:     cr.curVal,
+	}
+	cr.curRow[cr.curFam] = append(cr.curRow[cr.curFam], ri)
+	cr.curVal = nil
+}
+
+func (cr *chunkReader) commitRow() Row {
+	row := cr.curRow
+	cr.lastKey = cr.curRow.Key()
+	cr.resetToNewRow()
+	return row
+}
+
+func (cr *chunkReader) resetToNewRow() {
+	cr.curKey = nil
+	cr.curFam = ""
+	cr.curQual = nil
+	cr.curVal = nil
+	cr.curRow = nil
+	cr.curTS = 0
+	cr.state = newRow
+}
+
+func (cr *chunkReader) validateNewRow(cc *btpb.ReadRowsResponse_CellChunk) error {
+	if cc.GetResetRow() {
+		return fmt.Errorf("reset_row not allowed between rows")
+	}
+	if cc.RowKey == nil || cc.FamilyName == nil || cc.Qualifier == nil {
+		return fmt.Errorf("missing key field for new row %v", cc)
+	}
+	if cr.lastKey != "" && cr.lastKey >= string(cc.RowKey) {
+		return fmt.Errorf("out of order row key: %q, %q", cr.lastKey, string(cc.RowKey))
+	}
+	return nil
+}
+
+func (cr *chunkReader) validateRowInProgress(cc *btpb.ReadRowsResponse_CellChunk) error {
+	if err := cr.validateRowStatus(cc); err != nil {
+		return err
+	}
+	if cc.RowKey != nil && !bytes.Equal(cc.RowKey, cr.curKey) {
+		return fmt.Errorf("received new row key %q during existing row %q", cc.RowKey, cr.curKey)
+	}
+	if cc.FamilyName != nil && cc.Qualifier == nil {
+		return fmt.Errorf("family name %q specified without a qualifier", cc.FamilyName)
+	}
+	return nil
+}
+
+func (cr *chunkReader) validateCellInProgress(cc *btpb.ReadRowsResponse_CellChunk) error {
+	if err := cr.validateRowStatus(cc); err != nil {
+		return err
+	}
+	if cr.curVal == nil {
+		return fmt.Errorf("no cached cell while CELL_IN_PROGRESS %v", cc)
+	}
+	if cc.GetResetRow() == false && cr.isAnyKeyPresent(cc) {
+		return fmt.Errorf("cell key components found while CELL_IN_PROGRESS %v", cc)
+	}
+	return nil
+}
+
+func (cr *chunkReader) isAnyKeyPresent(cc *btpb.ReadRowsResponse_CellChunk) bool {
+	return cc.RowKey != nil ||
+		cc.FamilyName != nil ||
+		cc.Qualifier != nil ||
+		cc.TimestampMicros != 0
+}
+
+// Validate a RowStatus, commit or reset, if present.
+func (cr *chunkReader) validateRowStatus(cc *btpb.ReadRowsResponse_CellChunk) error {
+	// Resets can't be specified with any other part of a cell
+	if cc.GetResetRow() && (cr.isAnyKeyPresent(cc) ||
+		cc.Value != nil ||
+		cc.ValueSize != 0 ||
+		cc.Labels != nil) {
+		return fmt.Errorf("reset must not be specified with other fields %v", cc)
+	}
+	if cc.GetCommitRow() && cc.ValueSize > 0 {
+		return fmt.Errorf("commit row found in between chunks in a cell")
+	}
+	return nil
+}
--- a/vendor/cloud.google.com/go/bigtable/reader_test.go
+++ b/vendor/cloud.google.com/go/bigtable/reader_test.go
@@ -0,0 +1,343 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bigtable
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes/wrappers"
+	btspb "google.golang.org/genproto/googleapis/bigtable/v2"
+)
+
+// Indicates that a field in the proto should be omitted, rather than included
+// as a wrapped empty string.
+const nilStr = "<>"
+
+func TestSingleCell(t *testing.T) {
+	cr := newChunkReader()
+
+	// All in one cell
+	row, err := cr.Process(cc("rk", "fm", "col", 1, "value", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	if row == nil {
+		t.Fatalf("Missing row")
+	}
+	if len(row["fm"]) != 1 {
+		t.Fatalf("Family name length mismatch %d, %d", 1, len(row["fm"]))
+	}
+	want := []ReadItem{ri("rk", "fm", "col", 1, "value")}
+	if !reflect.DeepEqual(row["fm"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm"], want)
+	}
+	if err := cr.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+}
+
+func TestMultipleCells(t *testing.T) {
+	cr := newChunkReader()
+
+	cr.Process(cc("rs", "fm1", "col1", 0, "val1", 0, false))
+	cr.Process(cc("rs", "fm1", "col1", 1, "val2", 0, false))
+	cr.Process(cc("rs", "fm1", "col2", 0, "val3", 0, false))
+	cr.Process(cc("rs", "fm2", "col1", 0, "val4", 0, false))
+	row, err := cr.Process(cc("rs", "fm2", "col2", 1, "extralongval5", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	if row == nil {
+		t.Fatalf("Missing row")
+	}
+
+	want := []ReadItem{
+		ri("rs", "fm1", "col1", 0, "val1"),
+		ri("rs", "fm1", "col1", 1, "val2"),
+		ri("rs", "fm1", "col2", 0, "val3"),
+	}
+	if !reflect.DeepEqual(row["fm1"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm1"], want)
+	}
+	want = []ReadItem{
+		ri("rs", "fm2", "col1", 0, "val4"),
+		ri("rs", "fm2", "col2", 1, "extralongval5"),
+	}
+	if !reflect.DeepEqual(row["fm2"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm2"], want)
+	}
+	if err := cr.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+}
+
+func TestSplitCells(t *testing.T) {
+	cr := newChunkReader()
+
+	cr.Process(cc("rs", "fm1", "col1", 0, "hello ", 11, false))
+	cr.Process(ccData("world", 0, false))
+	row, err := cr.Process(cc("rs", "fm1", "col2", 0, "val2", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	if row == nil {
+		t.Fatalf("Missing row")
+	}
+
+	want := []ReadItem{
+		ri("rs", "fm1", "col1", 0, "hello world"),
+		ri("rs", "fm1", "col2", 0, "val2"),
+	}
+	if !reflect.DeepEqual(row["fm1"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm1"], want)
+	}
+	if err := cr.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+}
+
+func TestMultipleRows(t *testing.T) {
+	cr := newChunkReader()
+
+	row, err := cr.Process(cc("rs1", "fm1", "col1", 1, "val1", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	want := []ReadItem{ri("rs1", "fm1", "col1", 1, "val1")}
+	if !reflect.DeepEqual(row["fm1"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm1"], want)
+	}
+
+	row, err = cr.Process(cc("rs2", "fm2", "col2", 2, "val2", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	want = []ReadItem{ri("rs2", "fm2", "col2", 2, "val2")}
+	if !reflect.DeepEqual(row["fm2"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm2"], want)
+	}
+
+	if err := cr.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+}
+
+func TestBlankQualifier(t *testing.T) {
+	cr := newChunkReader()
+
+	row, err := cr.Process(cc("rs1", "fm1", "", 1, "val1", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	want := []ReadItem{ri("rs1", "fm1", "", 1, "val1")}
+	if !reflect.DeepEqual(row["fm1"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm1"], want)
+	}
+
+	row, err = cr.Process(cc("rs2", "fm2", "col2", 2, "val2", 0, true))
+	if err != nil {
+		t.Fatalf("Processing chunk: %v", err)
+	}
+	want = []ReadItem{ri("rs2", "fm2", "col2", 2, "val2")}
+	if !reflect.DeepEqual(row["fm2"], want) {
+		t.Fatalf("Incorrect ReadItem: got: %v\nwant: %v\n", row["fm2"], want)
+	}
+
+	if err := cr.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+}
+
+func TestReset(t *testing.T) {
+	cr := newChunkReader()
+
+	cr.Process(cc("rs", "fm1", "col1", 0, "val1", 0, false))
+	cr.Process(cc("rs", "fm1", "col1", 1, "val2", 0, false))
+	cr.Process(cc("rs", "fm1", "col2", 0, "val3", 0, false))
+	cr.Process(ccReset())
+	row, _ := cr.Process(cc("rs1", "fm1", "col1", 1, "val1", 0, true))
+	want := []ReadItem{ri("rs1", "fm1", "col1", 1, "val1")}
+	if !reflect.DeepEqual(row["fm1"], want) {
+		t.Fatalf("Reset: got: %v\nwant: %v\n", row["fm1"], want)
+	}
+	if err := cr.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+}
+
+func TestNewFamEmptyQualifier(t *testing.T) {
+	cr := newChunkReader()
+
+	cr.Process(cc("rs", "fm1", "col1", 0, "val1", 0, false))
+	_, err := cr.Process(cc(nilStr, "fm2", nilStr, 0, "val2", 0, true))
+	if err == nil {
+		t.Fatalf("Expected error on second chunk with no qualifier set")
+	}
+}
+
+// The read rows acceptance test reads a json file specifying a number of tests,
+// each consisting of one or more cell chunk text protos and one or more resulting
+// cells or errors.
+type AcceptanceTest struct {
+	Tests []TestCase `json:"tests"`
+}
+
+type TestCase struct {
+	Name    string       `json:"name"`
+	Chunks  []string     `json:"chunks"`
+	Results []TestResult `json:"results"`
+}
+
+type TestResult struct {
+	RK    string `json:"rk"`
+	FM    string `json:"fm"`
+	Qual  string `json:"qual"`
+	TS    int64  `json:"ts"`
+	Value string `json:"value"`
+	Error bool   `json:"error"` // If true, expect an error. Ignore any other field.
+}
+
+func TestAcceptance(t *testing.T) {
+	testJson, err := ioutil.ReadFile("./testdata/read-rows-acceptance-test.json")
+	if err != nil {
+		t.Fatalf("could not open acceptance test file %v", err)
+	}
+
+	var accTest AcceptanceTest
+	err = json.Unmarshal(testJson, &accTest)
+	if err != nil {
+		t.Fatalf("could not parse acceptance test file: %v", err)
+	}
+
+	for _, test := range accTest.Tests {
+		runTestCase(t, test)
+	}
+}
+
+func runTestCase(t *testing.T, test TestCase) {
+	// Increment an index into the result array as we get results
+	cr := newChunkReader()
+	var results []TestResult
+	var seenErr bool
+	for _, chunkText := range test.Chunks {
+		// Parse and pass each cell chunk to the ChunkReader
+		cc := &btspb.ReadRowsResponse_CellChunk{}
+		err := proto.UnmarshalText(chunkText, cc)
+		if err != nil {
+			t.Errorf("[%s] failed to unmarshal text proto: %s\n%s", test.Name, chunkText, err)
+			return
+		}
+		row, err := cr.Process(cc)
+		if err != nil {
+			results = append(results, TestResult{Error: true})
+			seenErr = true
+			break
+		} else {
+			// Turn the Row into TestResults
+			for fm, ris := range row {
+				for _, ri := range ris {
+					tr := TestResult{
+						RK:    ri.Row,
+						FM:    fm,
+						Qual:  strings.Split(ri.Column, ":")[1],
+						TS:    int64(ri.Timestamp),
+						Value: string(ri.Value),
+					}
+					results = append(results, tr)
+				}
+			}
+		}
+	}
+
+	// Only Close if we don't have an error yet, otherwise Close: is expected.
+	if !seenErr {
+		err := cr.Close()
+		if err != nil {
+			results = append(results, TestResult{Error: true})
+		}
+	}
+
+	got := toSet(results)
+	want := toSet(test.Results)
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("[%s]: got: %v\nwant: %v\n", test.Name, got, want)
+	}
+}
+
+func toSet(res []TestResult) map[TestResult]bool {
+	set := make(map[TestResult]bool)
+	for _, tr := range res {
+		set[tr] = true
+	}
+	return set
+}
+
+// ri returns a ReadItem for the given components
+func ri(rk string, fm string, qual string, ts int64, val string) ReadItem {
+	return ReadItem{Row: rk, Column: fmt.Sprintf("%s:%s", fm, qual), Value: []byte(val), Timestamp: Timestamp(ts)}
+}
+
+// cc returns a CellChunk proto
+func cc(rk string, fm string, qual string, ts int64, val string, size int32, commit bool) *btspb.ReadRowsResponse_CellChunk {
+	// The components of the cell key are wrapped and can be null or empty
+	var rkWrapper []byte
+	if rk == nilStr {
+		rkWrapper = nil
+	} else {
+		rkWrapper = []byte(rk)
+	}
+
+	var fmWrapper *wrappers.StringValue
+	if fm != nilStr {
+		fmWrapper = &wrappers.StringValue{Value: fm}
+	} else {
+		fmWrapper = nil
+	}
+
+	var qualWrapper *wrappers.BytesValue
+	if qual != nilStr {
+		qualWrapper = &wrappers.BytesValue{Value: []byte(qual)}
+	} else {
+		qualWrapper = nil
+	}
+
+	return &btspb.ReadRowsResponse_CellChunk{
+		RowKey:          rkWrapper,
+		FamilyName:      fmWrapper,
+		Qualifier:       qualWrapper,
+		TimestampMicros: ts,
+		Value:           []byte(val),
+		ValueSize:       size,
+		RowStatus:       &btspb.ReadRowsResponse_CellChunk_CommitRow{CommitRow: commit}}
+}
+
+// ccData returns a CellChunk with only a value and size
+func ccData(val string, size int32, commit bool) *btspb.ReadRowsResponse_CellChunk {
+	return cc(nilStr, nilStr, nilStr, 0, val, size, commit)
+}
+
+// ccReset returns a CellChunk with RestRow set to true
+func ccReset() *btspb.ReadRowsResponse_CellChunk {
+	return &btspb.ReadRowsResponse_CellChunk{
+		RowStatus: &btspb.ReadRowsResponse_CellChunk_ResetRow{ResetRow: true}}
+}
--- a/vendor/cloud.google.com/go/bigtable/retry_test.go
+++ b/vendor/cloud.google.com/go/bigtable/retry_test.go
@@ -0,0 +1,359 @@
+/*
+Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package bigtable
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/bigtable/bttest"
+	"github.com/golang/protobuf/ptypes/wrappers"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	btpb "google.golang.org/genproto/googleapis/bigtable/v2"
+	rpcpb "google.golang.org/genproto/googleapis/rpc/status"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+func setupFakeServer(opt ...grpc.ServerOption) (tbl *Table, cleanup func(), err error) {
+	srv, err := bttest.NewServer("127.0.0.1:0", opt...)
+	if err != nil {
+		return nil, nil, err
+	}
+	conn, err := grpc.Dial(srv.Addr, grpc.WithInsecure())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	client, err := NewClient(context.Background(), "client", "instance", option.WithGRPCConn(conn))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	adminClient, err := NewAdminClient(context.Background(), "client", "instance", option.WithGRPCConn(conn))
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := adminClient.CreateTable(context.Background(), "table"); err != nil {
+		return nil, nil, err
+	}
+	if err := adminClient.CreateColumnFamily(context.Background(), "table", "cf"); err != nil {
+		return nil, nil, err
+	}
+	t := client.Open("table")
+
+	cleanupFunc := func() {
+		adminClient.Close()
+		client.Close()
+		srv.Close()
+	}
+	return t, cleanupFunc, nil
+}
+
+func TestRetryApply(t *testing.T) {
+	ctx := context.Background()
+
+	errCount := 0
+	code := codes.Unavailable // Will be retried
+	// Intercept requests and return an error or defer to the underlying handler
+	errInjector := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+		if strings.HasSuffix(info.FullMethod, "MutateRow") && errCount < 3 {
+			errCount++
+			return nil, grpc.Errorf(code, "")
+		}
+		return handler(ctx, req)
+	}
+	tbl, cleanup, err := setupFakeServer(grpc.UnaryInterceptor(errInjector))
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("fake server setup: %v", err)
+	}
+
+	mut := NewMutation()
+	mut.Set("cf", "col", 1, []byte("val"))
+	if err := tbl.Apply(ctx, "row1", mut); err != nil {
+		t.Errorf("applying single mutation with retries: %v", err)
+	}
+	row, err := tbl.ReadRow(ctx, "row1")
+	if err != nil {
+		t.Errorf("reading single value with retries: %v", err)
+	}
+	if row == nil {
+		t.Errorf("applying single mutation with retries: could not read back row")
+	}
+
+	code = codes.FailedPrecondition // Won't be retried
+	errCount = 0
+	if err := tbl.Apply(ctx, "row", mut); err == nil {
+		t.Errorf("applying single mutation with no retries: no error")
+	}
+
+	// Check and mutate
+	mutTrue := NewMutation()
+	mutTrue.DeleteRow()
+	mutFalse := NewMutation()
+	mutFalse.Set("cf", "col", 1, []byte("val"))
+	condMut := NewCondMutation(ValueFilter("."), mutTrue, mutFalse)
+
+	errCount = 0
+	code = codes.Unavailable // Will be retried
+	if err := tbl.Apply(ctx, "row1", condMut); err != nil {
+		t.Errorf("conditionally mutating row with retries: %v", err)
+	}
+	row, err = tbl.ReadRow(ctx, "row1") // row1 already in the table
+	if err != nil {
+		t.Errorf("reading single value after conditional mutation: %v", err)
+	}
+	if row != nil {
+		t.Errorf("reading single value after conditional mutation: row not deleted")
+	}
+
+	errCount = 0
+	code = codes.FailedPrecondition // Won't be retried
+	if err := tbl.Apply(ctx, "row", condMut); err == nil {
+		t.Errorf("conditionally mutating row with no retries: no error")
+	}
+}
+
+func TestRetryApplyBulk(t *testing.T) {
+	ctx := context.Background()
+
+	// Intercept requests and delegate to an interceptor defined by the test case
+	errCount := 0
+	var f func(grpc.ServerStream) error
+	errInjector := func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		if strings.HasSuffix(info.FullMethod, "MutateRows") {
+			return f(ss)
+		}
+		return handler(ctx, ss)
+	}
+
+	tbl, cleanup, err := setupFakeServer(grpc.StreamInterceptor(errInjector))
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("fake server setup: %v", err)
+	}
+
+	errCount = 0
+	// Test overall request failure and retries
+	f = func(ss grpc.ServerStream) error {
+		if errCount < 3 {
+			errCount++
+			return grpc.Errorf(codes.Aborted, "")
+		}
+		return nil
+	}
+	mut := NewMutation()
+	mut.Set("cf", "col", 1, []byte{})
+	errors, err := tbl.ApplyBulk(ctx, []string{"row2"}, []*Mutation{mut})
+	if errors != nil || err != nil {
+		t.Errorf("bulk with request failure: got: %v, %v, want: nil", errors, err)
+	}
+
+	// Test failures and retries in one request
+	errCount = 0
+	m1 := NewMutation()
+	m1.Set("cf", "col", 1, []byte{})
+	m2 := NewMutation()
+	m2.Set("cf", "col2", 1, []byte{})
+	m3 := NewMutation()
+	m3.Set("cf", "col3", 1, []byte{})
+	f = func(ss grpc.ServerStream) error {
+		var err error
+		req := new(btpb.MutateRowsRequest)
+		ss.RecvMsg(req)
+		switch errCount {
+		case 0:
+			// Retryable request failure
+			err = grpc.Errorf(codes.Unavailable, "")
+		case 1:
+			// Two mutations fail
+			writeMutateRowsResponse(ss, codes.Unavailable, codes.OK, codes.Aborted)
+			err = nil
+		case 2:
+			// Two failures were retried. One will succeed.
+			if want, got := 2, len(req.Entries); want != got {
+				t.Errorf("2 bulk retries, got: %d, want %d", got, want)
+			}
+			writeMutateRowsResponse(ss, codes.OK, codes.Aborted)
+			err = nil
+		case 3:
+			// One failure was retried and will succeed.
+			if want, got := 1, len(req.Entries); want != got {
+				t.Errorf("1 bulk retry, got: %d, want %d", got, want)
+			}
+			writeMutateRowsResponse(ss, codes.OK)
+			err = nil
+		}
+		errCount++
+		return err
+	}
+	errors, err = tbl.ApplyBulk(ctx, []string{"row1", "row2", "row3"}, []*Mutation{m1, m2, m3})
+	if errors != nil || err != nil {
+		t.Errorf("bulk with retries: got: %v, %v, want: nil", errors, err)
+	}
+
+	// Test unretryable errors
+	niMut := NewMutation()
+	niMut.Set("cf", "col", ServerTime, []byte{}) // Non-idempotent
+	errCount = 0
+	f = func(ss grpc.ServerStream) error {
+		var err error
+		req := new(btpb.MutateRowsRequest)
+		ss.RecvMsg(req)
+		switch errCount {
+		case 0:
+			// Give non-idempotent mutation a retryable error code.
+			// Nothing should be retried.
+			writeMutateRowsResponse(ss, codes.FailedPrecondition, codes.Aborted)
+			err = nil
+		case 1:
+			t.Errorf("unretryable errors: got one retry, want no retries")
+		}
+		errCount++
+		return err
+	}
+	errors, err = tbl.ApplyBulk(ctx, []string{"row1", "row2"}, []*Mutation{m1, niMut})
+	if err != nil {
+		t.Errorf("unretryable errors: request failed %v")
+	}
+	want := []error{
+		grpc.Errorf(codes.FailedPrecondition, ""),
+		grpc.Errorf(codes.Aborted, ""),
+	}
+	if !reflect.DeepEqual(want, errors) {
+		t.Errorf("unretryable errors: got: %v, want: %v", errors, want)
+	}
+
+	// Test individual errors and a deadline exceeded
+	f = func(ss grpc.ServerStream) error {
+		writeMutateRowsResponse(ss, codes.FailedPrecondition, codes.OK, codes.Aborted)
+		return nil
+	}
+	ctx, _ = context.WithTimeout(ctx, 100*time.Millisecond)
+	errors, err = tbl.ApplyBulk(ctx, []string{"row1", "row2", "row3"}, []*Mutation{m1, m2, m3})
+	wantErr := context.DeadlineExceeded
+	if wantErr != err {
+		t.Errorf("deadline exceeded error: got: %v, want: %v", err, wantErr)
+	}
+	if errors != nil {
+		t.Errorf("deadline exceeded errors: got: %v, want: nil", err)
+	}
+}
+
+func writeMutateRowsResponse(ss grpc.ServerStream, codes ...codes.Code) error {
+	res := &btpb.MutateRowsResponse{Entries: make([]*btpb.MutateRowsResponse_Entry, len(codes))}
+	for i, code := range codes {
+		res.Entries[i] = &btpb.MutateRowsResponse_Entry{
+			Index:  int64(i),
+			Status: &rpcpb.Status{Code: int32(code), Message: ""},
+		}
+	}
+	return ss.SendMsg(res)
+}
+
+func TestRetainRowsAfter(t *testing.T) {
+	prevRowRange := NewRange("a", "z")
+	prevRowKey := "m"
+	want := NewRange("m\x00", "z")
+	got := prevRowRange.retainRowsAfter(prevRowKey)
+	if !reflect.DeepEqual(want, got) {
+		t.Errorf("range retry: got %v, want %v", got, want)
+	}
+
+	prevRowList := RowList{"a", "b", "c", "d", "e", "f"}
+	prevRowKey = "b"
+	wantList := RowList{"c", "d", "e", "f"}
+	got = prevRowList.retainRowsAfter(prevRowKey)
+	if !reflect.DeepEqual(wantList, got) {
+		t.Errorf("list retry: got %v, want %v", got, wantList)
+	}
+}
+
+func TestRetryReadRows(t *testing.T) {
+	ctx := context.Background()
+
+	// Intercept requests and delegate to an interceptor defined by the test case
+	errCount := 0
+	var f func(grpc.ServerStream) error
+	errInjector := func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		if strings.HasSuffix(info.FullMethod, "ReadRows") {
+			return f(ss)
+		}
+		return handler(ctx, ss)
+	}
+
+	tbl, cleanup, err := setupFakeServer(grpc.StreamInterceptor(errInjector))
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("fake server setup: %v", err)
+	}
+
+	errCount = 0
+	// Test overall request failure and retries
+	f = func(ss grpc.ServerStream) error {
+		var err error
+		req := new(btpb.ReadRowsRequest)
+		ss.RecvMsg(req)
+		switch errCount {
+		case 0:
+			// Retryable request failure
+			err = grpc.Errorf(codes.Unavailable, "")
+		case 1:
+			// Write two rows then error
+			writeReadRowsResponse(ss, "a", "b")
+			err = grpc.Errorf(codes.Unavailable, "")
+		case 2:
+			// Retryable request failure
+			if want, got := "b\x00", string(req.Rows.RowRanges[0].GetStartKeyClosed()); want != got {
+				t.Errorf("2 range retries: got %q, want %q", got, want)
+			}
+			err = grpc.Errorf(codes.Unavailable, "")
+		case 3:
+			// Write two more rows
+			writeReadRowsResponse(ss, "c", "d")
+			err = nil
+		}
+		errCount++
+		return err
+	}
+
+	var got []string
+	tbl.ReadRows(ctx, NewRange("a", "z"), func(r Row) bool {
+		got = append(got, r.Key())
+		return true
+	})
+	want := []string{"a", "b", "c", "d"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("retry range integration: got %v, want %v", got, want)
+	}
+}
+
+func writeReadRowsResponse(ss grpc.ServerStream, rowKeys ...string) error {
+	var chunks []*btpb.ReadRowsResponse_CellChunk
+	for _, key := range rowKeys {
+		chunks = append(chunks, &btpb.ReadRowsResponse_CellChunk{
+			RowKey:     []byte(key),
+			FamilyName: &wrappers.StringValue{Value: "fm"},
+			Qualifier:  &wrappers.BytesValue{Value: []byte("col")},
+			RowStatus:  &btpb.ReadRowsResponse_CellChunk_CommitRow{CommitRow: true},
+		})
+	}
+	return ss.SendMsg(&btpb.ReadRowsResponse{Chunks: chunks})
+}
--- a/vendor/cloud.google.com/go/bigtable/testdata/read-rows-acceptance-test.json
+++ b/vendor/cloud.google.com/go/bigtable/testdata/read-rows-acceptance-test.json
--- a/vendor/cloud.google.com/go/cloud.go
+++ b/vendor/cloud.google.com/go/cloud.go
@@ -0,0 +1,20 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package cloud is the root of the packages used to access Google Cloud
+// Services. See https://godoc.org/cloud.google.com/go for a full list
+// of sub-packages.
+//
+// This package documents how to authorize and authenticate the sub packages.
+package cloud // import "cloud.google.com/go"
--- a/vendor/cloud.google.com/go/compute/metadata/metadata.go
+++ b/vendor/cloud.google.com/go/compute/metadata/metadata.go
@@ -0,0 +1,438 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package metadata provides access to Google Compute Engine (GCE)
+// metadata and API service accounts.
+//
+// This package is a wrapper around the GCE metadata service,
+// as documented at https://developers.google.com/compute/docs/metadata.
+package metadata // import "cloud.google.com/go/compute/metadata"
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/net/context"
+	"golang.org/x/net/context/ctxhttp"
+
+	"cloud.google.com/go/internal"
+)
+
+const (
+	// metadataIP is the documented metadata server IP address.
+	metadataIP = "169.254.169.254"
+
+	// metadataHostEnv is the environment variable specifying the
+	// GCE metadata hostname.  If empty, the default value of
+	// metadataIP ("169.254.169.254") is used instead.
+	// This is variable name is not defined by any spec, as far as
+	// I know; it was made up for the Go package.
+	metadataHostEnv = "GCE_METADATA_HOST"
+)
+
+type cachedValue struct {
+	k    string
+	trim bool
+	mu   sync.Mutex
+	v    string
+}
+
+var (
+	projID  = &cachedValue{k: "project/project-id", trim: true}
+	projNum = &cachedValue{k: "project/numeric-project-id", trim: true}
+	instID  = &cachedValue{k: "instance/id", trim: true}
+)
+
+var (
+	metaClient = &http.Client{
+		Transport: &internal.Transport{
+			Base: &http.Transport{
+				Dial: (&net.Dialer{
+					Timeout:   2 * time.Second,
+					KeepAlive: 30 * time.Second,
+				}).Dial,
+				ResponseHeaderTimeout: 2 * time.Second,
+			},
+		},
+	}
+	subscribeClient = &http.Client{
+		Transport: &internal.Transport{
+			Base: &http.Transport{
+				Dial: (&net.Dialer{
+					Timeout:   2 * time.Second,
+					KeepAlive: 30 * time.Second,
+				}).Dial,
+			},
+		},
+	}
+)
+
+// NotDefinedError is returned when requested metadata is not defined.
+//
+// The underlying string is the suffix after "/computeMetadata/v1/".
+//
+// This error is not returned if the value is defined to be the empty
+// string.
+type NotDefinedError string
+
+func (suffix NotDefinedError) Error() string {
+	return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix))
+}
+
+// Get returns a value from the metadata service.
+// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
+//
+// If the GCE_METADATA_HOST environment variable is not defined, a default of
+// 169.254.169.254 will be used instead.
+//
+// If the requested metadata is not defined, the returned error will
+// be of type NotDefinedError.
+func Get(suffix string) (string, error) {
+	val, _, err := getETag(metaClient, suffix)
+	return val, err
+}
+
+// getETag returns a value from the metadata service as well as the associated
+// ETag using the provided client. This func is otherwise equivalent to Get.
+func getETag(client *http.Client, suffix string) (value, etag string, err error) {
+	// Using a fixed IP makes it very difficult to spoof the metadata service in
+	// a container, which is an important use-case for local testing of cloud
+	// deployments. To enable spoofing of the metadata service, the environment
+	// variable GCE_METADATA_HOST is first inspected to decide where metadata
+	// requests shall go.
+	host := os.Getenv(metadataHostEnv)
+	if host == "" {
+		// Using 169.254.169.254 instead of "metadata" here because Go
+		// binaries built with the "netgo" tag and without cgo won't
+		// know the search suffix for "metadata" is
+		// ".google.internal", and this IP address is documented as
+		// being stable anyway.
+		host = metadataIP
+	}
+	url := "http://" + host + "/computeMetadata/v1/" + suffix
+	req, _ := http.NewRequest("GET", url, nil)
+	req.Header.Set("Metadata-Flavor", "Google")
+	res, err := client.Do(req)
+	if err != nil {
+		return "", "", err
+	}
+	defer res.Body.Close()
+	if res.StatusCode == http.StatusNotFound {
+		return "", "", NotDefinedError(suffix)
+	}
+	if res.StatusCode != 200 {
+		return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url)
+	}
+	all, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", "", err
+	}
+	return string(all), res.Header.Get("Etag"), nil
+}
+
+func getTrimmed(suffix string) (s string, err error) {
+	s, err = Get(suffix)
+	s = strings.TrimSpace(s)
+	return
+}
+
+func (c *cachedValue) get() (v string, err error) {
+	defer c.mu.Unlock()
+	c.mu.Lock()
+	if c.v != "" {
+		return c.v, nil
+	}
+	if c.trim {
+		v, err = getTrimmed(c.k)
+	} else {
+		v, err = Get(c.k)
+	}
+	if err == nil {
+		c.v = v
+	}
+	return
+}
+
+var (
+	onGCEOnce sync.Once
+	onGCE     bool
+)
+
+// OnGCE reports whether this process is running on Google Compute Engine.
+func OnGCE() bool {
+	onGCEOnce.Do(initOnGCE)
+	return onGCE
+}
+
+func initOnGCE() {
+	onGCE = testOnGCE()
+}
+
+func testOnGCE() bool {
+	// The user explicitly said they're on GCE, so trust them.
+	if os.Getenv(metadataHostEnv) != "" {
+		return true
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	resc := make(chan bool, 2)
+
+	// Try two strategies in parallel.
+	// See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/194
+	go func() {
+		res, err := ctxhttp.Get(ctx, metaClient, "http://"+metadataIP)
+		if err != nil {
+			resc <- false
+			return
+		}
+		defer res.Body.Close()
+		resc <- res.Header.Get("Metadata-Flavor") == "Google"
+	}()
+
+	go func() {
+		addrs, err := net.LookupHost("metadata.google.internal")
+		if err != nil || len(addrs) == 0 {
+			resc <- false
+			return
+		}
+		resc <- strsContains(addrs, metadataIP)
+	}()
+
+	tryHarder := systemInfoSuggestsGCE()
+	if tryHarder {
+		res := <-resc
+		if res {
+			// The first strategy succeeded, so let's use it.
+			return true
+		}
+		// Wait for either the DNS or metadata server probe to
+		// contradict the other one and say we are running on
+		// GCE. Give it a lot of time to do so, since the system
+		// info already suggests we're running on a GCE BIOS.
+		timer := time.NewTimer(5 * time.Second)
+		defer timer.Stop()
+		select {
+		case res = <-resc:
+			return res
+		case <-timer.C:
+			// Too slow. Who knows what this system is.
+			return false
+		}
+	}
+
+	// There's no hint from the system info that we're running on
+	// GCE, so use the first probe's result as truth, whether it's
+	// true or false. The goal here is to optimize for speed for
+	// users who are NOT running on GCE. We can't assume that
+	// either a DNS lookup or an HTTP request to a blackholed IP
+	// address is fast. Worst case this should return when the
+	// metaClient's Transport.ResponseHeaderTimeout or
+	// Transport.Dial.Timeout fires (in two seconds).
+	return <-resc
+}
+
+// systemInfoSuggestsGCE reports whether the local system (without
+// doing network requests) suggests that we're running on GCE. If this
+// returns true, testOnGCE tries a bit harder to reach its metadata
+// server.
+func systemInfoSuggestsGCE() bool {
+	if runtime.GOOS != "linux" {
+		// We don't have any non-Linux clues available, at least yet.
+		return false
+	}
+	slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name")
+	name := strings.TrimSpace(string(slurp))
+	return name == "Google" || name == "Google Compute Engine"
+}
+
+// Subscribe subscribes to a value from the metadata service.
+// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
+// The suffix may contain query parameters.
+//
+// Subscribe calls fn with the latest metadata value indicated by the provided
+// suffix. If the metadata value is deleted, fn is called with the empty string
+// and ok false. Subscribe blocks until fn returns a non-nil error or the value
+// is deleted. Subscribe returns the error value returned from the last call to
+// fn, which may be nil when ok == false.
+func Subscribe(suffix string, fn func(v string, ok bool) error) error {
+	const failedSubscribeSleep = time.Second * 5
+
+	// First check to see if the metadata value exists at all.
+	val, lastETag, err := getETag(subscribeClient, suffix)
+	if err != nil {
+		return err
+	}
+
+	if err := fn(val, true); err != nil {
+		return err
+	}
+
+	ok := true
+	if strings.ContainsRune(suffix, '?') {
+		suffix += "&wait_for_change=true&last_etag="
+	} else {
+		suffix += "?wait_for_change=true&last_etag="
+	}
+	for {
+		val, etag, err := getETag(subscribeClient, suffix+url.QueryEscape(lastETag))
+		if err != nil {
+			if _, deleted := err.(NotDefinedError); !deleted {
+				time.Sleep(failedSubscribeSleep)
+				continue // Retry on other errors.
+			}
+			ok = false
+		}
+		lastETag = etag
+
+		if err := fn(val, ok); err != nil || !ok {
+			return err
+		}
+	}
+}
+
+// ProjectID returns the current instance's project ID string.
+func ProjectID() (string, error) { return projID.get() }
+
+// NumericProjectID returns the current instance's numeric project ID.
+func NumericProjectID() (string, error) { return projNum.get() }
+
+// InternalIP returns the instance's primary internal IP address.
+func InternalIP() (string, error) {
+	return getTrimmed("instance/network-interfaces/0/ip")
+}
+
+// ExternalIP returns the instance's primary external (public) IP address.
+func ExternalIP() (string, error) {
+	return getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip")
+}
+
+// Hostname returns the instance's hostname. This will be of the form
+// "<instanceID>.c.<projID>.internal".
+func Hostname() (string, error) {
+	return getTrimmed("instance/hostname")
+}
+
+// InstanceTags returns the list of user-defined instance tags,
+// assigned when initially creating a GCE instance.
+func InstanceTags() ([]string, error) {
+	var s []string
+	j, err := Get("instance/tags")
+	if err != nil {
+		return nil, err
+	}
+	if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+// InstanceID returns the current VM's numeric instance ID.
+func InstanceID() (string, error) {
+	return instID.get()
+}
+
+// InstanceName returns the current VM's instance ID string.
+func InstanceName() (string, error) {
+	host, err := Hostname()
+	if err != nil {
+		return "", err
+	}
+	return strings.Split(host, ".")[0], nil
+}
+
+// Zone returns the current VM's zone, such as "us-central1-b".
+func Zone() (string, error) {
+	zone, err := getTrimmed("instance/zone")
+	// zone is of the form "projects/<projNum>/zones/<zoneName>".
+	if err != nil {
+		return "", err
+	}
+	return zone[strings.LastIndex(zone, "/")+1:], nil
+}
+
+// InstanceAttributes returns the list of user-defined attributes,
+// assigned when initially creating a GCE VM instance. The value of an
+// attribute can be obtained with InstanceAttributeValue.
+func InstanceAttributes() ([]string, error) { return lines("instance/attributes/") }
+
+// ProjectAttributes returns the list of user-defined attributes
+// applying to the project as a whole, not just this VM.  The value of
+// an attribute can be obtained with ProjectAttributeValue.
+func ProjectAttributes() ([]string, error) { return lines("project/attributes/") }
+
+func lines(suffix string) ([]string, error) {
+	j, err := Get(suffix)
+	if err != nil {
+		return nil, err
+	}
+	s := strings.Split(strings.TrimSpace(j), "\n")
+	for i := range s {
+		s[i] = strings.TrimSpace(s[i])
+	}
+	return s, nil
+}
+
+// InstanceAttributeValue returns the value of the provided VM
+// instance attribute.
+//
+// If the requested attribute is not defined, the returned error will
+// be of type NotDefinedError.
+//
+// InstanceAttributeValue may return ("", nil) if the attribute was
+// defined to be the empty string.
+func InstanceAttributeValue(attr string) (string, error) {
+	return Get("instance/attributes/" + attr)
+}
+
+// ProjectAttributeValue returns the value of the provided
+// project attribute.
+//
+// If the requested attribute is not defined, the returned error will
+// be of type NotDefinedError.
+//
+// ProjectAttributeValue may return ("", nil) if the attribute was
+// defined to be the empty string.
+func ProjectAttributeValue(attr string) (string, error) {
+	return Get("project/attributes/" + attr)
+}
+
+// Scopes returns the service account scopes for the given account.
+// The account may be empty or the string "default" to use the instance's
+// main account.
+func Scopes(serviceAccount string) ([]string, error) {
+	if serviceAccount == "" {
+		serviceAccount = "default"
+	}
+	return lines("instance/service-accounts/" + serviceAccount + "/scopes")
+}
+
+func strsContains(ss []string, s string) bool {
+	for _, v := range ss {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}
--- a/vendor/cloud.google.com/go/compute/metadata/metadata_test.go
+++ b/vendor/cloud.google.com/go/compute/metadata/metadata_test.go
@@ -0,0 +1,48 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"os"
+	"sync"
+	"testing"
+)
+
+func TestOnGCE_Stress(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in -short mode")
+	}
+	var last bool
+	for i := 0; i < 100; i++ {
+		onGCEOnce = sync.Once{}
+
+		now := OnGCE()
+		if i > 0 && now != last {
+			t.Errorf("%d. changed from %v to %v", i, last, now)
+		}
+		last = now
+	}
+	t.Logf("OnGCE() = %v", last)
+}
+
+func TestOnGCE_Force(t *testing.T) {
+	onGCEOnce = sync.Once{}
+	old := os.Getenv(metadataHostEnv)
+	defer os.Setenv(metadataHostEnv, old)
+	os.Setenv(metadataHostEnv, "127.0.0.1")
+	if !OnGCE() {
+		t.Error("OnGCE() = false; want true")
+	}
+}
--- a/vendor/cloud.google.com/go/container/container.go
+++ b/vendor/cloud.google.com/go/container/container.go
@@ -0,0 +1,273 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package container contains a Google Container Engine client.
+//
+// For more information about the API,
+// see https://cloud.google.com/container-engine/docs
+package container // import "cloud.google.com/go/container"
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"golang.org/x/net/context"
+	raw "google.golang.org/api/container/v1"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+)
+
+type Type string
+
+const (
+	TypeCreate = Type("createCluster")
+	TypeDelete = Type("deleteCluster")
+)
+
+type Status string
+
+const (
+	StatusDone         = Status("done")
+	StatusPending      = Status("pending")
+	StatusRunning      = Status("running")
+	StatusError        = Status("error")
+	StatusProvisioning = Status("provisioning")
+	StatusStopping     = Status("stopping")
+)
+
+const prodAddr = "https://container.googleapis.com/"
+const userAgent = "gcloud-golang-container/20151008"
+
+// Client is a Google Container Engine client, which may be used to manage
+// clusters with a project.  It must be constructed via NewClient.
+type Client struct {
+	projectID string
+	svc       *raw.Service
+}
+
+// NewClient creates a new Google Container Engine client.
+func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) {
+	o := []option.ClientOption{
+		option.WithEndpoint(prodAddr),
+		option.WithScopes(raw.CloudPlatformScope),
+		option.WithUserAgent(userAgent),
+	}
+	o = append(o, opts...)
+	httpClient, endpoint, err := transport.NewHTTPClient(ctx, o...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing: %v", err)
+	}
+
+	svc, err := raw.New(httpClient)
+	if err != nil {
+		return nil, fmt.Errorf("constructing container client: %v", err)
+	}
+	svc.BasePath = endpoint
+
+	c := &Client{
+		projectID: projectID,
+		svc:       svc,
+	}
+
+	return c, nil
+}
+
+// Resource is a Google Container Engine cluster resource.
+type Resource struct {
+	// Name is the name of this cluster. The name must be unique
+	// within this project and zone, and can be up to 40 characters.
+	Name string
+
+	// Description is the description of the cluster. Optional.
+	Description string
+
+	// Zone is the Google Compute Engine zone in which the cluster resides.
+	Zone string
+
+	// Status is the current status of the cluster. It could either be
+	// StatusError, StatusProvisioning, StatusRunning or StatusStopping.
+	Status Status
+
+	// Num is the number of the nodes in this cluster resource.
+	Num int64
+
+	// APIVersion is the version of the Kubernetes master and kubelets running
+	// in this cluster. Allowed value is 0.4.2, or leave blank to
+	// pick up the latest stable release.
+	APIVersion string
+
+	// Endpoint is the IP address of this cluster's Kubernetes master.
+	// The endpoint can be accessed at https://username:password@endpoint/.
+	// See Username and Password fields for the username and password information.
+	Endpoint string
+
+	// Username is the username to use when accessing the Kubernetes master endpoint.
+	Username string
+
+	// Password is the password to use when accessing the Kubernetes master endpoint.
+	Password string
+
+	// ContainerIPv4CIDR is the IP addresses of the container pods in
+	// this cluster, in CIDR notation (e.g. 1.2.3.4/29).
+	ContainerIPv4CIDR string
+
+	// ServicesIPv4CIDR is the IP addresses of the Kubernetes services in this
+	// cluster, in CIDR notation (e.g. 1.2.3.4/29). Service addresses are
+	// always in the 10.0.0.0/16 range.
+	ServicesIPv4CIDR string
+
+	// MachineType is a Google Compute Engine machine type (e.g. n1-standard-1).
+	// If none set, the default type is used while creating a new cluster.
+	MachineType string
+
+	// This field is ignored. It was removed from the underlying container API in v1.
+	SourceImage string
+
+	// Created is the creation time of this cluster.
+	Created time.Time
+}
+
+func resourceFromRaw(c *raw.Cluster) *Resource {
+	if c == nil {
+		return nil
+	}
+	r := &Resource{
+		Name:              c.Name,
+		Description:       c.Description,
+		Zone:              c.Zone,
+		Status:            Status(c.Status),
+		Num:               c.InitialNodeCount,
+		APIVersion:        c.InitialClusterVersion,
+		Endpoint:          c.Endpoint,
+		Username:          c.MasterAuth.Username,
+		Password:          c.MasterAuth.Password,
+		ContainerIPv4CIDR: c.ClusterIpv4Cidr,
+		ServicesIPv4CIDR:  c.ServicesIpv4Cidr,
+		MachineType:       c.NodeConfig.MachineType,
+	}
+	r.Created, _ = time.Parse(time.RFC3339, c.CreateTime)
+	return r
+}
+
+func resourcesFromRaw(c []*raw.Cluster) []*Resource {
+	r := make([]*Resource, len(c))
+	for i, val := range c {
+		r[i] = resourceFromRaw(val)
+	}
+	return r
+}
+
+// Op represents a Google Container Engine API operation.
+type Op struct {
+	// Name is the name of the operation.
+	Name string
+
+	// Zone is the Google Compute Engine zone.
+	Zone string
+
+	// This field is ignored. It was removed from the underlying container API in v1.
+	TargetURL string
+
+	// Type is the operation type. It could be either be TypeCreate or TypeDelete.
+	Type Type
+
+	// Status is the current status of this operation. It could be either
+	// OpDone or OpPending.
+	Status Status
+}
+
+func opFromRaw(o *raw.Operation) *Op {
+	if o == nil {
+		return nil
+	}
+	return &Op{
+		Name:   o.Name,
+		Zone:   o.Zone,
+		Type:   Type(o.OperationType),
+		Status: Status(o.Status),
+	}
+}
+
+func opsFromRaw(o []*raw.Operation) []*Op {
+	ops := make([]*Op, len(o))
+	for i, val := range o {
+		ops[i] = opFromRaw(val)
+	}
+	return ops
+}
+
+// Clusters returns a list of cluster resources from the specified zone.
+// If no zone is specified, it returns all clusters under the user project.
+func (c *Client) Clusters(ctx context.Context, zone string) ([]*Resource, error) {
+	if zone == "" {
+		zone = "-"
+	}
+	resp, err := c.svc.Projects.Zones.Clusters.List(c.projectID, zone).Do()
+	if err != nil {
+		return nil, err
+	}
+	return resourcesFromRaw(resp.Clusters), nil
+}
+
+// Cluster returns metadata about the specified cluster.
+func (c *Client) Cluster(ctx context.Context, zone, name string) (*Resource, error) {
+	resp, err := c.svc.Projects.Zones.Clusters.Get(c.projectID, zone, name).Do()
+	if err != nil {
+		return nil, err
+	}
+	return resourceFromRaw(resp), nil
+}
+
+// CreateCluster creates a new cluster with the provided metadata
+// in the specified zone.
+func (c *Client) CreateCluster(ctx context.Context, zone string, resource *Resource) (*Resource, error) {
+	panic("not implemented")
+}
+
+// DeleteCluster deletes a cluster.
+func (c *Client) DeleteCluster(ctx context.Context, zone, name string) error {
+	_, err := c.svc.Projects.Zones.Clusters.Delete(c.projectID, zone, name).Do()
+	return err
+}
+
+// Operations returns a list of operations from the specified zone.
+// If no zone is specified, it looks up for all of the operations
+// that are running under the user's project.
+func (c *Client) Operations(ctx context.Context, zone string) ([]*Op, error) {
+	if zone == "" {
+		resp, err := c.svc.Projects.Zones.Operations.List(c.projectID, "-").Do()
+		if err != nil {
+			return nil, err
+		}
+		return opsFromRaw(resp.Operations), nil
+	}
+	resp, err := c.svc.Projects.Zones.Operations.List(c.projectID, zone).Do()
+	if err != nil {
+		return nil, err
+	}
+	return opsFromRaw(resp.Operations), nil
+}
+
+// Operation returns an operation.
+func (c *Client) Operation(ctx context.Context, zone, name string) (*Op, error) {
+	resp, err := c.svc.Projects.Zones.Operations.Get(c.projectID, zone, name).Do()
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusMessage != "" {
+		return nil, errors.New(resp.StatusMessage)
+	}
+	return opFromRaw(resp), nil
+}
--- a/vendor/cloud.google.com/go/datastore/datastore.go
+++ b/vendor/cloud.google.com/go/datastore/datastore.go
@@ -0,0 +1,588 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datastore
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+
+	"github.com/golang/protobuf/proto"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	pb "google.golang.org/genproto/googleapis/datastore/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+const (
+	prodAddr  = "datastore.googleapis.com:443"
+	userAgent = "gcloud-golang-datastore/20160401"
+)
+
+// ScopeDatastore grants permissions to view and/or manage datastore entities
+const ScopeDatastore = "https://www.googleapis.com/auth/datastore"
+
+// protoClient is an interface for *transport.ProtoClient to support injecting
+// fake clients in tests.
+type protoClient interface {
+	Call(context.Context, string, proto.Message, proto.Message) error
+}
+
+// datastoreClient is a wrapper for the pb.DatastoreClient that includes gRPC
+// metadata to be sent in each request for server-side traffic management.
+type datastoreClient struct {
+	c  pb.DatastoreClient
+	md metadata.MD
+}
+
+func newDatastoreClient(conn *grpc.ClientConn, projectID string) pb.DatastoreClient {
+	return &datastoreClient{
+		c:  pb.NewDatastoreClient(conn),
+		md: metadata.Pairs(resourcePrefixHeader, "projects/"+projectID),
+	}
+}
+
+func (dc *datastoreClient) Lookup(ctx context.Context, in *pb.LookupRequest, opts ...grpc.CallOption) (*pb.LookupResponse, error) {
+	return dc.c.Lookup(metadata.NewContext(ctx, dc.md), in, opts...)
+}
+
+func (dc *datastoreClient) RunQuery(ctx context.Context, in *pb.RunQueryRequest, opts ...grpc.CallOption) (*pb.RunQueryResponse, error) {
+	return dc.c.RunQuery(metadata.NewContext(ctx, dc.md), in, opts...)
+}
+
+func (dc *datastoreClient) BeginTransaction(ctx context.Context, in *pb.BeginTransactionRequest, opts ...grpc.CallOption) (*pb.BeginTransactionResponse, error) {
+	return dc.c.BeginTransaction(metadata.NewContext(ctx, dc.md), in, opts...)
+}
+
+func (dc *datastoreClient) Commit(ctx context.Context, in *pb.CommitRequest, opts ...grpc.CallOption) (*pb.CommitResponse, error) {
+	return dc.c.Commit(metadata.NewContext(ctx, dc.md), in, opts...)
+}
+
+func (dc *datastoreClient) Rollback(ctx context.Context, in *pb.RollbackRequest, opts ...grpc.CallOption) (*pb.RollbackResponse, error) {
+	return dc.c.Rollback(metadata.NewContext(ctx, dc.md), in, opts...)
+}
+
+func (dc *datastoreClient) AllocateIds(ctx context.Context, in *pb.AllocateIdsRequest, opts ...grpc.CallOption) (*pb.AllocateIdsResponse, error) {
+	return dc.c.AllocateIds(metadata.NewContext(ctx, dc.md), in, opts...)
+}
+
+// Client is a client for reading and writing data in a datastore dataset.
+type Client struct {
+	conn     *grpc.ClientConn
+	client   pb.DatastoreClient
+	endpoint string
+	dataset  string // Called dataset by the datastore API, synonym for project ID.
+}
+
+// NewClient creates a new Client for a given dataset.
+// If the project ID is empty, it is derived from the DATASTORE_PROJECT_ID environment variable.
+// If the DATASTORE_EMULATOR_HOST environment variable is set, client will use its value
+// to connect to a locally-running datastore emulator.
+func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) {
+	var o []option.ClientOption
+	// Environment variables for gcd emulator:
+	// https://cloud.google.com/datastore/docs/tools/datastore-emulator
+	// If the emulator is available, dial it directly (and don't pass any credentials).
+	if addr := os.Getenv("DATASTORE_EMULATOR_HOST"); addr != "" {
+		conn, err := grpc.Dial(addr, grpc.WithInsecure())
+		if err != nil {
+			return nil, fmt.Errorf("grpc.Dial: %v", err)
+		}
+		o = []option.ClientOption{option.WithGRPCConn(conn)}
+	} else {
+		o = []option.ClientOption{
+			option.WithEndpoint(prodAddr),
+			option.WithScopes(ScopeDatastore),
+			option.WithUserAgent(userAgent),
+		}
+	}
+	// Warn if we see the legacy emulator environment variables.
+	if os.Getenv("DATASTORE_HOST") != "" && os.Getenv("DATASTORE_EMULATOR_HOST") == "" {
+		log.Print("WARNING: legacy environment variable DATASTORE_HOST is ignored. Use DATASTORE_EMULATOR_HOST instead.")
+	}
+	if os.Getenv("DATASTORE_DATASET") != "" && os.Getenv("DATASTORE_PROJECT_ID") == "" {
+		log.Print("WARNING: legacy environment variable DATASTORE_DATASET is ignored. Use DATASTORE_PROJECT_ID instead.")
+	}
+	if projectID == "" {
+		projectID = os.Getenv("DATASTORE_PROJECT_ID")
+	}
+	if projectID == "" {
+		return nil, errors.New("datastore: missing project/dataset id")
+	}
+	o = append(o, opts...)
+	conn, err := transport.DialGRPC(ctx, o...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing: %v", err)
+	}
+	return &Client{
+		conn:    conn,
+		client:  newDatastoreClient(conn, projectID),
+		dataset: projectID,
+	}, nil
+
+}
+
+var (
+	// ErrInvalidEntityType is returned when functions like Get or Next are
+	// passed a dst or src argument of invalid type.
+	ErrInvalidEntityType = errors.New("datastore: invalid entity type")
+	// ErrInvalidKey is returned when an invalid key is presented.
+	ErrInvalidKey = errors.New("datastore: invalid key")
+	// ErrNoSuchEntity is returned when no entity was found for a given key.
+	ErrNoSuchEntity = errors.New("datastore: no such entity")
+)
+
+type multiArgType int
+
+const (
+	multiArgTypeInvalid multiArgType = iota
+	multiArgTypePropertyLoadSaver
+	multiArgTypeStruct
+	multiArgTypeStructPtr
+	multiArgTypeInterface
+)
+
+// nsKey is the type of the context.Context key to store the datastore
+// namespace.
+type nsKey struct{}
+
+// WithNamespace returns a new context that limits the scope its parent
+// context with a Datastore namespace.
+func WithNamespace(parent context.Context, namespace string) context.Context {
+	return context.WithValue(parent, nsKey{}, namespace)
+}
+
+// ctxNamespace returns the active namespace for a context.
+// It defaults to "" if no namespace was specified.
+func ctxNamespace(ctx context.Context) string {
+	v, _ := ctx.Value(nsKey{}).(string)
+	return v
+}
+
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct.
+// StructType is the type of the struct pointed to by the destination argument
+// passed to Get or to Iterator.Next.
+type ErrFieldMismatch struct {
+	StructType reflect.Type
+	FieldName  string
+	Reason     string
+}
+
+func (e *ErrFieldMismatch) Error() string {
+	return fmt.Sprintf("datastore: cannot load field %q into a %q: %s",
+		e.FieldName, e.StructType, e.Reason)
+}
+
+// GeoPoint represents a location as latitude/longitude in degrees.
+type GeoPoint struct {
+	Lat, Lng float64
+}
+
+// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude.
+func (g GeoPoint) Valid() bool {
+	return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180
+}
+
+func keyToProto(k *Key) *pb.Key {
+	if k == nil {
+		return nil
+	}
+
+	// TODO(jbd): Eliminate unrequired allocations.
+	var path []*pb.Key_PathElement
+	for {
+		el := &pb.Key_PathElement{Kind: k.kind}
+		if k.id != 0 {
+			el.IdType = &pb.Key_PathElement_Id{k.id}
+		} else if k.name != "" {
+			el.IdType = &pb.Key_PathElement_Name{k.name}
+		}
+		path = append([]*pb.Key_PathElement{el}, path...)
+		if k.parent == nil {
+			break
+		}
+		k = k.parent
+	}
+	key := &pb.Key{Path: path}
+	if k.namespace != "" {
+		key.PartitionId = &pb.PartitionId{
+			NamespaceId: k.namespace,
+		}
+	}
+	return key
+}
+
+// protoToKey decodes a protocol buffer representation of a key into an
+// equivalent *Key object. If the key is invalid, protoToKey will return the
+// invalid key along with ErrInvalidKey.
+func protoToKey(p *pb.Key) (*Key, error) {
+	var key *Key
+	var namespace string
+	if partition := p.PartitionId; partition != nil {
+		namespace = partition.NamespaceId
+	}
+	for _, el := range p.Path {
+		key = &Key{
+			namespace: namespace,
+			kind:      el.Kind,
+			id:        el.GetId(),
+			name:      el.GetName(),
+			parent:    key,
+		}
+	}
+	if !key.valid() { // Also detects key == nil.
+		return key, ErrInvalidKey
+	}
+	return key, nil
+}
+
+// multiKeyToProto is a batch version of keyToProto.
+func multiKeyToProto(keys []*Key) []*pb.Key {
+	ret := make([]*pb.Key, len(keys))
+	for i, k := range keys {
+		ret[i] = keyToProto(k)
+	}
+	return ret
+}
+
+// multiKeyToProto is a batch version of keyToProto.
+func multiProtoToKey(keys []*pb.Key) ([]*Key, error) {
+	hasErr := false
+	ret := make([]*Key, len(keys))
+	err := make(MultiError, len(keys))
+	for i, k := range keys {
+		ret[i], err[i] = protoToKey(k)
+		if err[i] != nil {
+			hasErr = true
+		}
+	}
+	if hasErr {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// multiValid is a batch version of Key.valid. It returns an error, not a
+// []bool.
+func multiValid(key []*Key) error {
+	invalid := false
+	for _, k := range key {
+		if !k.valid() {
+			invalid = true
+			break
+		}
+	}
+	if !invalid {
+		return nil
+	}
+	err := make(MultiError, len(key))
+	for i, k := range key {
+		if !k.valid() {
+			err[i] = ErrInvalidKey
+		}
+	}
+	return err
+}
+
+// checkMultiArg checks that v has type []S, []*S, []I, or []P, for some struct
+// type S, for some interface type I, or some non-interface non-pointer type P
+// such that P or *P implements PropertyLoadSaver.
+//
+// It returns what category the slice's elements are, and the reflect.Type
+// that represents S, I or P.
+//
+// As a special case, PropertyList is an invalid type for v.
+//
+// TODO(djd): multiArg is very confusing. Fold this logic into the
+// relevant Put/Get methods to make the logic less opaque.
+func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
+	if v.Kind() != reflect.Slice {
+		return multiArgTypeInvalid, nil
+	}
+	if v.Type() == typeOfPropertyList {
+		return multiArgTypeInvalid, nil
+	}
+	elemType = v.Type().Elem()
+	if reflect.PtrTo(elemType).Implements(typeOfPropertyLoadSaver) {
+		return multiArgTypePropertyLoadSaver, elemType
+	}
+	switch elemType.Kind() {
+	case reflect.Struct:
+		return multiArgTypeStruct, elemType
+	case reflect.Interface:
+		return multiArgTypeInterface, elemType
+	case reflect.Ptr:
+		elemType = elemType.Elem()
+		if elemType.Kind() == reflect.Struct {
+			return multiArgTypeStructPtr, elemType
+		}
+	}
+	return multiArgTypeInvalid, nil
+}
+
+// Close closes the Client.
+func (c *Client) Close() {
+	c.conn.Close()
+}
+
+// Get loads the entity stored for key into dst, which must be a struct pointer
+// or implement PropertyLoadSaver. If there is no such entity for the key, Get
+// returns ErrNoSuchEntity.
+//
+// The values of dst's unmatched struct fields are not modified, and matching
+// slice-typed fields are not reset before appending to them. In particular, it
+// is recommended to pass a pointer to a zero valued struct on each Get call.
+//
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct. ErrFieldMismatch is only returned if
+// dst is a struct pointer.
+func (c *Client) Get(ctx context.Context, key *Key, dst interface{}) error {
+	if dst == nil { // get catches nil interfaces; we need to catch nil ptr here
+		return ErrInvalidEntityType
+	}
+	err := c.get(ctx, []*Key{key}, []interface{}{dst}, nil)
+	if me, ok := err.(MultiError); ok {
+		return me[0]
+	}
+	return err
+}
+
+// GetMulti is a batch version of Get.
+//
+// dst must be a []S, []*S, []I or []P, for some struct type S, some interface
+// type I, or some non-interface non-pointer type P such that P or *P
+// implements PropertyLoadSaver. If an []I, each element must be a valid dst
+// for Get: it must be a struct pointer or implement PropertyLoadSaver.
+//
+// As a special case, PropertyList is an invalid type for dst, even though a
+// PropertyList is a slice of structs. It is treated as invalid to avoid being
+// mistakenly passed when []PropertyList was intended.
+func (c *Client) GetMulti(ctx context.Context, keys []*Key, dst interface{}) error {
+	return c.get(ctx, keys, dst, nil)
+}
+
+func (c *Client) get(ctx context.Context, keys []*Key, dst interface{}, opts *pb.ReadOptions) error {
+	v := reflect.ValueOf(dst)
+	multiArgType, _ := checkMultiArg(v)
+
+	// Sanity checks
+	if multiArgType == multiArgTypeInvalid {
+		return errors.New("datastore: dst has invalid type")
+	}
+	if len(keys) != v.Len() {
+		return errors.New("datastore: keys and dst slices have different length")
+	}
+	if len(keys) == 0 {
+		return nil
+	}
+
+	// Go through keys, validate them, serialize then, and create a dict mapping them to their index
+	multiErr, any := make(MultiError, len(keys)), false
+	keyMap := make(map[string]int)
+	pbKeys := make([]*pb.Key, len(keys))
+	for i, k := range keys {
+		if !k.valid() {
+			multiErr[i] = ErrInvalidKey
+			any = true
+		} else {
+			keyMap[k.String()] = i
+			pbKeys[i] = keyToProto(k)
+		}
+	}
+	if any {
+		return multiErr
+	}
+	req := &pb.LookupRequest{
+		ProjectId:   c.dataset,
+		Keys:        pbKeys,
+		ReadOptions: opts,
+	}
+	resp, err := c.client.Lookup(ctx, req)
+	if err != nil {
+		return err
+	}
+	if len(resp.Deferred) > 0 {
+		// TODO(jbd): Assess whether we should retry the deferred keys.
+		return errors.New("datastore: some entities temporarily unavailable")
+	}
+	if len(keys) != len(resp.Found)+len(resp.Missing) {
+		return errors.New("datastore: internal error: server returned the wrong number of entities")
+	}
+	for _, e := range resp.Found {
+		k, err := protoToKey(e.Entity.Key)
+		if err != nil {
+			return errors.New("datastore: internal error: server returned an invalid key")
+		}
+		index := keyMap[k.String()]
+		elem := v.Index(index)
+		if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
+			elem = elem.Addr()
+		}
+		if multiArgType == multiArgTypeStructPtr && elem.IsNil() {
+			elem.Set(reflect.New(elem.Type().Elem()))
+		}
+		if err := loadEntity(elem.Interface(), e.Entity); err != nil {
+			multiErr[index] = err
+			any = true
+		}
+	}
+	for _, e := range resp.Missing {
+		k, err := protoToKey(e.Entity.Key)
+		if err != nil {
+			return errors.New("datastore: internal error: server returned an invalid key")
+		}
+		multiErr[keyMap[k.String()]] = ErrNoSuchEntity
+		any = true
+	}
+	if any {
+		return multiErr
+	}
+	return nil
+}
+
+// Put saves the entity src into the datastore with key k. src must be a struct
+// pointer or implement PropertyLoadSaver; if a struct pointer then any
+// unexported fields of that struct will be skipped. If k is an incomplete key,
+// the returned key will be a unique key generated by the datastore.
+func (c *Client) Put(ctx context.Context, key *Key, src interface{}) (*Key, error) {
+	k, err := c.PutMulti(ctx, []*Key{key}, []interface{}{src})
+	if err != nil {
+		if me, ok := err.(MultiError); ok {
+			return nil, me[0]
+		}
+		return nil, err
+	}
+	return k[0], nil
+}
+
+// PutMulti is a batch version of Put.
+//
+// src must satisfy the same conditions as the dst argument to GetMulti.
+func (c *Client) PutMulti(ctx context.Context, keys []*Key, src interface{}) ([]*Key, error) {
+	mutations, err := putMutations(keys, src)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make the request.
+	req := &pb.CommitRequest{
+		ProjectId: c.dataset,
+		Mutations: mutations,
+		Mode:      pb.CommitRequest_NON_TRANSACTIONAL,
+	}
+	resp, err := c.client.Commit(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	// Copy any newly minted keys into the returned keys.
+	ret := make([]*Key, len(keys))
+	for i, key := range keys {
+		if key.Incomplete() {
+			// This key is in the mutation results.
+			ret[i], err = protoToKey(resp.MutationResults[i].Key)
+			if err != nil {
+				return nil, errors.New("datastore: internal error: server returned an invalid key")
+			}
+		} else {
+			ret[i] = key
+		}
+	}
+	return ret, nil
+}
+
+func putMutations(keys []*Key, src interface{}) ([]*pb.Mutation, error) {
+	v := reflect.ValueOf(src)
+	multiArgType, _ := checkMultiArg(v)
+	if multiArgType == multiArgTypeInvalid {
+		return nil, errors.New("datastore: src has invalid type")
+	}
+	if len(keys) != v.Len() {
+		return nil, errors.New("datastore: key and src slices have different length")
+	}
+	if len(keys) == 0 {
+		return nil, nil
+	}
+	if err := multiValid(keys); err != nil {
+		return nil, err
+	}
+	mutations := make([]*pb.Mutation, 0, len(keys))
+	for i, k := range keys {
+		elem := v.Index(i)
+		// Two cases where we need to take the address:
+		// 1) multiArgTypePropertyLoadSaver => &elem implements PLS
+		// 2) multiArgTypeStruct => saveEntity needs *struct
+		if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
+			elem = elem.Addr()
+		}
+		p, err := saveEntity(k, elem.Interface())
+		if err != nil {
+			return nil, fmt.Errorf("datastore: Error while saving %v: %v", k.String(), err)
+		}
+		var mut *pb.Mutation
+		if k.Incomplete() {
+			mut = &pb.Mutation{Operation: &pb.Mutation_Insert{p}}
+		} else {
+			mut = &pb.Mutation{Operation: &pb.Mutation_Upsert{p}}
+		}
+		mutations = append(mutations, mut)
+	}
+	return mutations, nil
+}
+
+// Delete deletes the entity for the given key.
+func (c *Client) Delete(ctx context.Context, key *Key) error {
+	err := c.DeleteMulti(ctx, []*Key{key})
+	if me, ok := err.(MultiError); ok {
+		return me[0]
+	}
+	return err
+}
+
+// DeleteMulti is a batch version of Delete.
+func (c *Client) DeleteMulti(ctx context.Context, keys []*Key) error {
+	mutations, err := deleteMutations(keys)
+	if err != nil {
+		return err
+	}
+
+	req := &pb.CommitRequest{
+		ProjectId: c.dataset,
+		Mutations: mutations,
+		Mode:      pb.CommitRequest_NON_TRANSACTIONAL,
+	}
+	_, err = c.client.Commit(ctx, req)
+	return err
+}
+
+func deleteMutations(keys []*Key) ([]*pb.Mutation, error) {
+	mutations := make([]*pb.Mutation, 0, len(keys))
+	for _, k := range keys {
+		if k.Incomplete() {
+			return nil, fmt.Errorf("datastore: can't delete the incomplete key: %v", k)
+		}
+		mutations = append(mutations, &pb.Mutation{
+			Operation: &pb.Mutation_Delete{keyToProto(k)},
+		})
+	}
+	return mutations, nil
+}
--- a/vendor/cloud.google.com/go/datastore/datastore_test.go
+++ b/vendor/cloud.google.com/go/datastore/datastore_test.go
--- a/vendor/cloud.google.com/go/datastore/doc.go
+++ b/vendor/cloud.google.com/go/datastore/doc.go
@@ -0,0 +1,320 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*
+Package datastore provides a client for Google Cloud Datastore.
+
+
+Basic Operations
+
+Entities are the unit of storage and are associated with a key. A key
+consists of an optional parent key, a string application ID, a string kind
+(also known as an entity type), and either a StringID or an IntID. A
+StringID is also known as an entity name or key name.
+
+It is valid to create a key with a zero StringID and a zero IntID; this is
+called an incomplete key, and does not refer to any saved entity. Putting an
+entity into the datastore under an incomplete key will cause a unique key
+to be generated for that entity, with a non-zero IntID.
+
+An entity's contents are a mapping from case-sensitive field names to values.
+Valid value types are:
+  - signed integers (int, int8, int16, int32 and int64),
+  - bool,
+  - string,
+  - float32 and float64,
+  - []byte (up to 1 megabyte in length),
+  - any type whose underlying type is one of the above predeclared types,
+  - *Key,
+  - GeoPoint,
+  - time.Time (stored with microsecond precision),
+  - structs whose fields are all valid value types,
+  - slices of any of the above.
+
+Slices of structs are valid, as are structs that contain slices. However, if
+one struct contains another, then at most one of those can be repeated. This
+disqualifies recursively defined struct types: any struct T that (directly or
+indirectly) contains a []T.
+
+The Get and Put functions load and save an entity's contents. An entity's
+contents are typically represented by a struct pointer.
+
+Example code:
+
+	type Entity struct {
+		Value string
+	}
+
+	func main() {
+		ctx := context.Background()
+
+		// Create a datastore client. In a typical application, you would create
+		// a single client which is reused for every datastore operation.
+		dsClient, err := datastore.NewClient(ctx, "my-project")
+		if err != nil {
+			// Handle error.
+		}
+
+		k := datastore.NewKey(ctx, "Entity", "stringID", 0, nil)
+		e := new(Entity)
+		if err := dsClient.Get(ctx, k, e); err != nil {
+			// Handle error.
+		}
+
+		old := e.Value
+		e.Value = "Hello World!"
+
+		if _, err := dsClient.Put(ctx, k, e); err != nil {
+			// Handle error.
+		}
+
+		fmt.Printf("Updated value from %q to %q\n", old, e.Value)
+	}
+
+GetMulti, PutMulti and DeleteMulti are batch versions of the Get, Put and
+Delete functions. They take a []*Key instead of a *Key, and may return a
+datastore.MultiError when encountering partial failure.
+
+
+Properties
+
+An entity's contents can be represented by a variety of types. These are
+typically struct pointers, but can also be any type that implements the
+PropertyLoadSaver interface. If using a struct pointer, you do not have to
+explicitly implement the PropertyLoadSaver interface; the datastore will
+automatically convert via reflection. If a struct pointer does implement that
+interface then those methods will be used in preference to the default
+behavior for struct pointers. Struct pointers are more strongly typed and are
+easier to use; PropertyLoadSavers are more flexible.
+
+The actual types passed do not have to match between Get and Put calls or even
+across different calls to datastore. It is valid to put a *PropertyList and
+get that same entity as a *myStruct, or put a *myStruct0 and get a *myStruct1.
+Conceptually, any entity is saved as a sequence of properties, and is loaded
+into the destination value on a property-by-property basis. When loading into
+a struct pointer, an entity that cannot be completely represented (such as a
+missing field) will result in an ErrFieldMismatch error but it is up to the
+caller whether this error is fatal, recoverable or ignorable.
+
+By default, for struct pointers, all properties are potentially indexed, and
+the property name is the same as the field name (and hence must start with an
+upper case letter). Fields may have a `datastore:"name,options"` tag. The tag
+name is the property name, which must be one or more valid Go identifiers
+joined by ".", but may start with a lower case letter. An empty tag name means
+to just use the field name. A "-" tag name means that the datastore will
+ignore that field. If options is "noindex" then the field will not be indexed.
+If the options is "" then the comma may be omitted. There are no other
+recognized options.
+
+All fields are indexed by default. Strings or byte slices longer than 1500
+bytes cannot be indexed; fields used to store long strings and byte slices must
+be tagged with "noindex" or they will cause Put operations to fail.
+
+Example code:
+
+	// A and B are renamed to a and b.
+	// A, C and J are not indexed.
+	// D's tag is equivalent to having no tag at all (E).
+	// I is ignored entirely by the datastore.
+	// J has tag information for both the datastore and json packages.
+	type TaggedStruct struct {
+		A int `datastore:"a,noindex"`
+		B int `datastore:"b"`
+		C int `datastore:",noindex"`
+		D int `datastore:""`
+		E int
+		I int `datastore:"-"`
+		J int `datastore:",noindex" json:"j"`
+	}
+
+
+Structured Properties
+
+If the struct pointed to contains other structs, then the nested or embedded
+structs are flattened. For example, given these definitions:
+
+	type Inner1 struct {
+		W int32
+		X string
+	}
+
+	type Inner2 struct {
+		Y float64
+	}
+
+	type Inner3 struct {
+		Z bool
+	}
+
+	type Outer struct {
+		A int16
+		I []Inner1
+		J Inner2
+		Inner3
+	}
+
+then an Outer's properties would be equivalent to those of:
+
+	type OuterEquivalent struct {
+		A     int16
+		IDotW []int32  `datastore:"I.W"`
+		IDotX []string `datastore:"I.X"`
+		JDotY float64  `datastore:"J.Y"`
+		Z     bool
+	}
+
+If Outer's embedded Inner3 field was tagged as `datastore:"Foo"` then the
+equivalent field would instead be: FooDotZ bool `datastore:"Foo.Z"`.
+
+If an outer struct is tagged "noindex" then all of its implicit flattened
+fields are effectively "noindex".
+
+
+The PropertyLoadSaver Interface
+
+An entity's contents can also be represented by any type that implements the
+PropertyLoadSaver interface. This type may be a struct pointer, but it does
+not have to be. The datastore package will call Load when getting the entity's
+contents, and Save when putting the entity's contents.
+Possible uses include deriving non-stored fields, verifying fields, or indexing
+a field only if its value is positive.
+
+Example code:
+
+	type CustomPropsExample struct {
+		I, J int
+		// Sum is not stored, but should always be equal to I + J.
+		Sum int `datastore:"-"`
+	}
+
+	func (x *CustomPropsExample) Load(ps []datastore.Property) error {
+		// Load I and J as usual.
+		if err := datastore.LoadStruct(x, ps); err != nil {
+			return err
+		}
+		// Derive the Sum field.
+		x.Sum = x.I + x.J
+		return nil
+	}
+
+	func (x *CustomPropsExample) Save() ([]datastore.Property, error) {
+		// Validate the Sum field.
+		if x.Sum != x.I + x.J {
+			return errors.New("CustomPropsExample has inconsistent sum")
+		}
+		// Save I and J as usual. The code below is equivalent to calling
+		// "return datastore.SaveStruct(x)", but is done manually for
+		// demonstration purposes.
+		return []datastore.Property{
+			{
+				Name:  "I",
+				Value: int64(x.I),
+			},
+			{
+				Name:  "J",
+				Value: int64(x.J),
+			},
+		}
+	}
+
+The *PropertyList type implements PropertyLoadSaver, and can therefore hold an
+arbitrary entity's contents.
+
+
+Queries
+
+Queries retrieve entities based on their properties or key's ancestry. Running
+a query yields an iterator of results: either keys or (key, entity) pairs.
+Queries are re-usable and it is safe to call Query.Run from concurrent
+goroutines. Iterators are not safe for concurrent use.
+
+Queries are immutable, and are either created by calling NewQuery, or derived
+from an existing query by calling a method like Filter or Order that returns a
+new query value. A query is typically constructed by calling NewQuery followed
+by a chain of zero or more such methods. These methods are:
+  - Ancestor and Filter constrain the entities returned by running a query.
+  - Order affects the order in which they are returned.
+  - Project constrains the fields returned.
+  - Distinct de-duplicates projected entities.
+  - KeysOnly makes the iterator return only keys, not (key, entity) pairs.
+  - Start, End, Offset and Limit define which sub-sequence of matching entities
+    to return. Start and End take cursors, Offset and Limit take integers. Start
+    and Offset affect the first result, End and Limit affect the last result.
+    If both Start and Offset are set, then the offset is relative to Start.
+    If both End and Limit are set, then the earliest constraint wins. Limit is
+    relative to Start+Offset, not relative to End. As a special case, a
+    negative limit means unlimited.
+
+Example code:
+
+	type Widget struct {
+		Description string
+		Price       int
+	}
+
+	func printWidgets(ctx context.Context, client *datastore.Client) {
+		q := datastore.NewQuery("Widget").
+			Filter("Price <", 1000).
+			Order("-Price")
+		for t := dsClient.Run(ctx, q); ; {
+			var x Widget
+			key, err := t.Next(&x)
+			if err == datastore.Done {
+				break
+			}
+			if err != nil {
+				// Handle error.
+			}
+			fmt.Printf("Key=%v\nWidget=%#v\n\n", key, x)
+		}
+	}
+
+
+Transactions
+
+Client.RunInTransaction runs a function in a transaction.
+
+Example code:
+
+	type Counter struct {
+		Count int
+	}
+
+	func incCount(ctx context.Context, client *datastore.Client) {
+		var count int
+		key := datastore.NewKey(ctx, "Counter", "singleton", 0, nil)
+		err := dsClient.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
+			var x Counter
+			if err := tx.Get(key, &x); err != nil && err != datastore.ErrNoSuchEntity {
+				return err
+			}
+			x.Count++
+			if _, err := tx.Put(key, &x); err != nil {
+				return err
+			}
+			count = x.Count
+		}, nil)
+		if err != nil {
+			// Handle error.
+		}
+		// The value of count is only valid once the transaction is successful
+		// (RunInTransaction has returned nil).
+		fmt.Printf("Count=%d\n", count)
+	}
+*/
+package datastore // import "cloud.google.com/go/datastore"
+
+// resourcePrefixHeader is the name of the metadata header used to indicate
+// the resource being operated on.
+const resourcePrefixHeader = "google-cloud-resource-prefix"
--- a/vendor/cloud.google.com/go/datastore/errors.go
+++ b/vendor/cloud.google.com/go/datastore/errors.go
@@ -0,0 +1,47 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file provides error functions for common API failure modes.
+
+package datastore
+
+import (
+	"fmt"
+)
+
+// MultiError is returned by batch operations when there are errors with
+// particular elements. Errors will be in a one-to-one correspondence with
+// the input elements; successful elements will have a nil entry.
+type MultiError []error
+
+func (m MultiError) Error() string {
+	s, n := "", 0
+	for _, e := range m {
+		if e != nil {
+			if n == 0 {
+				s = e.Error()
+			}
+			n++
+		}
+	}
+	switch n {
+	case 0:
+		return "(0 errors)"
+	case 1:
+		return s
+	case 2:
+		return s + " (and 1 other error)"
+	}
+	return fmt.Sprintf("%s (and %d other errors)", s, n-1)
+}
--- a/vendor/cloud.google.com/go/datastore/example_test.go
+++ b/vendor/cloud.google.com/go/datastore/example_test.go
@@ -0,0 +1,235 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datastore_test
+
+import (
+	"log"
+	"time"
+
+	"cloud.google.com/go/datastore"
+	"golang.org/x/net/context"
+)
+
+// TODO(jbd): Document other authorization methods and refer to them here.
+func Example_auth() *datastore.Client {
+	ctx := context.Background()
+	// Use Google Application Default Credentials to authorize and authenticate the client.
+	// More information about Application Default Credentials and how to enable is at
+	// https://developers.google.com/identity/protocols/application-default-credentials.
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Use the client (see other examples).
+	return client
+}
+
+func ExampleGet() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	type Article struct {
+		Title       string
+		Description string
+		Body        string `datastore:",noindex"`
+		Author      *datastore.Key
+		PublishedAt time.Time
+	}
+	key := datastore.NewKey(ctx, "Article", "articled1", 0, nil)
+	article := &Article{}
+	if err := client.Get(ctx, key, article); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func ExamplePut() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	type Article struct {
+		Title       string
+		Description string
+		Body        string `datastore:",noindex"`
+		Author      *datastore.Key
+		PublishedAt time.Time
+	}
+	newKey := datastore.NewIncompleteKey(ctx, "Article", nil)
+	_, err = client.Put(ctx, newKey, &Article{
+		Title:       "The title of the article",
+		Description: "The description of the article...",
+		Body:        "...",
+		Author:      datastore.NewKey(ctx, "Author", "jbd", 0, nil),
+		PublishedAt: time.Now(),
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func ExampleDelete() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	key := datastore.NewKey(ctx, "Article", "articled1", 0, nil)
+	if err := client.Delete(ctx, key); err != nil {
+		log.Fatal(err)
+	}
+}
+
+type Post struct {
+	Title       string
+	PublishedAt time.Time
+	Comments    int
+}
+
+func ExampleGetMulti() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	keys := []*datastore.Key{
+		datastore.NewKey(ctx, "Post", "post1", 0, nil),
+		datastore.NewKey(ctx, "Post", "post2", 0, nil),
+		datastore.NewKey(ctx, "Post", "post3", 0, nil),
+	}
+	posts := make([]Post, 3)
+	if err := client.GetMulti(ctx, keys, posts); err != nil {
+		log.Println(err)
+	}
+}
+
+func ExamplePutMulti_slice() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	keys := []*datastore.Key{
+		datastore.NewKey(ctx, "Post", "post1", 0, nil),
+		datastore.NewKey(ctx, "Post", "post2", 0, nil),
+	}
+
+	// PutMulti with a Post slice.
+	posts := []*Post{
+		{Title: "Post 1", PublishedAt: time.Now()},
+		{Title: "Post 2", PublishedAt: time.Now()},
+	}
+	if _, err := client.PutMulti(ctx, keys, posts); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func ExamplePutMulti_interfaceSlice() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	keys := []*datastore.Key{
+		datastore.NewKey(ctx, "Post", "post1", 0, nil),
+		datastore.NewKey(ctx, "Post", "post2", 0, nil),
+	}
+
+	// PutMulti with an empty interface slice.
+	posts := []interface{}{
+		&Post{Title: "Post 1", PublishedAt: time.Now()},
+		&Post{Title: "Post 2", PublishedAt: time.Now()},
+	}
+	if _, err := client.PutMulti(ctx, keys, posts); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func ExampleQuery() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Count the number of the post entities.
+	q := datastore.NewQuery("Post")
+	n, err := client.Count(ctx, q)
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Printf("There are %d posts.", n)
+
+	// List the posts published since yesterday.
+	yesterday := time.Now().Add(-24 * time.Hour)
+	q = datastore.NewQuery("Post").Filter("PublishedAt >", yesterday)
+	it := client.Run(ctx, q)
+	// Use the iterator.
+	_ = it
+
+	// Order the posts by the number of comments they have recieved.
+	datastore.NewQuery("Post").Order("-Comments")
+
+	// Start listing from an offset and limit the results.
+	datastore.NewQuery("Post").Offset(20).Limit(10)
+}
+
+func ExampleTransaction() {
+	ctx := context.Background()
+	client, err := datastore.NewClient(ctx, "project-id")
+	if err != nil {
+		log.Fatal(err)
+	}
+	const retries = 3
+
+	// Increment a counter.
+	// See https://cloud.google.com/appengine/articles/sharding_counters for
+	// a more scalable solution.
+	type Counter struct {
+		Count int
+	}
+
+	key := datastore.NewKey(ctx, "counter", "CounterA", 0, nil)
+
+	for i := 0; i < retries; i++ {
+		tx, err := client.NewTransaction(ctx)
+		if err != nil {
+			break
+		}
+
+		var c Counter
+		if err := tx.Get(key, &c); err != nil && err != datastore.ErrNoSuchEntity {
+			break
+		}
+		c.Count++
+		if _, err := tx.Put(key, &c); err != nil {
+			break
+		}
+
+		// Attempt to commit the transaction. If there's a conflict, try again.
+		if _, err := tx.Commit(); err != datastore.ErrConcurrentTransaction {
+			break
+		}
+	}
+
+}
--- a/vendor/cloud.google.com/go/datastore/examples_test.go
+++ b/vendor/cloud.google.com/go/datastore/examples_test.go
@@ -0,0 +1,731 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datastore_test
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"cloud.google.com/go/datastore"
+	"golang.org/x/net/context"
+)
+
+type Task struct {
+	Category        string
+	Done            bool
+	Priority        int
+	Description     string `datastore:",noindex"`
+	PercentComplete float64
+	Created         time.Time
+	Tags            []string
+	Collaborators   []string
+}
+
+func ExampleNewIncompleteKey() {
+	ctx := context.Background()
+	// [START incomplete_key]
+	taskKey := datastore.NewIncompleteKey(ctx, "Task", nil)
+	// [END incomplete_key]
+	_ = taskKey // Use the task key for datastore operations.
+}
+
+func ExampleNewKey() {
+	ctx := context.Background()
+	// [START named_key]
+	taskKey := datastore.NewKey(ctx, "Task", "sampletask", 0, nil)
+	// [END named_key]
+	_ = taskKey // Use the task key for datastore operations.
+}
+
+func ExampleNewKey_withParent() {
+	ctx := context.Background()
+	// [START key_with_parent]
+	parentKey := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
+	taskKey := datastore.NewKey(ctx, "Task", "sampleTask", 0, parentKey)
+	// [END key_with_parent]
+	_ = taskKey // Use the task key for datastore operations.
+}
+
+func ExampleNewKey_withMultipleParents() {
+	ctx := context.Background()
+	// [START key_with_multilevel_parent]
+	userKey := datastore.NewKey(ctx, "User", "alice", 0, nil)
+	parentKey := datastore.NewKey(ctx, "TaskList", "default", 0, userKey)
+	taskKey := datastore.NewKey(ctx, "Task", "sampleTask", 0, parentKey)
+	// [END key_with_multilevel_parent]
+	_ = taskKey // Use the task key for datastore operations.
+}
+
+func ExampleClient_Put() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START entity_with_parent]
+	parentKey := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
+	key := datastore.NewIncompleteKey(ctx, "Task", parentKey)
+
+	task := Task{
+		Category:    "Personal",
+		Done:        false,
+		Priority:    4,
+		Description: "Learn Cloud Datastore",
+	}
+
+	// A complete key is assigned to the entity when it is Put.
+	var err error
+	key, err = client.Put(ctx, key, &task)
+	// [END entity_with_parent]
+	_ = err // Make sure you check err.
+}
+
+func Example_properties() {
+	// [START properties]
+	type Task struct {
+		Category        string
+		Done            bool
+		Priority        int
+		Description     string `datastore:",noindex"`
+		PercentComplete float64
+		Created         time.Time
+	}
+	task := &Task{
+		Category:        "Personal",
+		Done:            false,
+		Priority:        4,
+		Description:     "Learn Cloud Datastore",
+		PercentComplete: 10.0,
+		Created:         time.Now(),
+	}
+	// [END properties]
+	_ = task // Use the task in a datastore Put operation.
+}
+
+func Example_sliceProperties() {
+	// [START array_value]
+	type Task struct {
+		Tags          []string
+		Collaborators []string
+	}
+	task := &Task{
+		Tags:          []string{"fun", "programming"},
+		Collaborators: []string{"alice", "bob"},
+	}
+	// [END array_value]
+	_ = task // Use the task in a datastore Put operation.
+}
+
+func Example_basicEntity() {
+	// [START basic_entity]
+	type Task struct {
+		Category        string
+		Done            bool
+		Priority        float64
+		Description     string `datastore:",noindex"`
+		PercentComplete float64
+		Created         time.Time
+	}
+	task := &Task{
+		Category:        "Personal",
+		Done:            false,
+		Priority:        4,
+		Description:     "Learn Cloud Datastore",
+		PercentComplete: 10.0,
+		Created:         time.Now(),
+	}
+	// [END basic_entity]
+	_ = task // Use the task in a datastore Put operation.
+}
+
+func ExampleClient_Put_upsert() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	task := &Task{} // Populated with appropriate data.
+	key := datastore.NewIncompleteKey(ctx, "Task", nil)
+	// [START upsert]
+	key, err := client.Put(ctx, key, task)
+	// [END upsert]
+	_ = err // Make sure you check err.
+	_ = key // key is the complete key for the newly stored task
+}
+
+func ExampleTransaction_insert() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	task := Task{} // Populated with appropriate data.
+	taskKey := datastore.NewKey(ctx, "Task", "sampleTask", 0, nil)
+	// [START insert]
+	_, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
+		// We first check that there is no entity stored with the given key.
+		var empty Task
+		if err := tx.Get(taskKey, &empty); err != datastore.ErrNoSuchEntity {
+			return err
+		}
+		// If there was no matching entity, store it now.
+		_, err := tx.Put(taskKey, &task)
+		return err
+	})
+	// [END insert]
+	_ = err // Make sure you check err.
+}
+
+func ExampleClient_Get() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	taskKey := datastore.NewKey(ctx, "Task", "sampleTask", 0, nil)
+	// [START lookup]
+	var task Task
+	err := client.Get(ctx, taskKey, &task)
+	// [END lookup]
+	_ = err // Make sure you check err.
+}
+
+func ExampleTransaction_update() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	taskKey := datastore.NewKey(ctx, "Task", "sampleTask", 0, nil)
+	// [START update]
+	tx, err := client.NewTransaction(ctx)
+	if err != nil {
+		log.Fatalf("client.NewTransaction: %v", err)
+	}
+	var task Task
+	if err := tx.Get(taskKey, &task); err != nil {
+		log.Fatalf("tx.Get: %v", err)
+	}
+	task.Priority = 5
+	if _, err := tx.Put(taskKey, task); err != nil {
+		log.Fatalf("tx.Put: %v", err)
+	}
+	if _, err := tx.Commit(); err != nil {
+		log.Fatalf("tx.Commit: %v", err)
+	}
+	// [END update]
+}
+
+func ExampleClient_Delete() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	key := datastore.NewKey(ctx, "Task", "sampletask", 0, nil)
+	// [START delete]
+	err := client.Delete(ctx, key)
+	// [END delete]
+	_ = err // Make sure you check err.
+}
+
+func ExampleClient_PutMulti() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START batch_upsert]
+	tasks := []*Task{
+		{
+			Category:    "Personal",
+			Done:        false,
+			Priority:    4,
+			Description: "Learn Cloud Datastore",
+		},
+		{
+			Category:    "Personal",
+			Done:        false,
+			Priority:    5,
+			Description: "Integrate Cloud Datastore",
+		},
+	}
+	keys := []*datastore.Key{
+		datastore.NewIncompleteKey(ctx, "Task", nil),
+		datastore.NewIncompleteKey(ctx, "Task", nil),
+	}
+
+	keys, err := client.PutMulti(ctx, keys, tasks)
+	// [END batch_upsert]
+	_ = err  // Make sure you check err.
+	_ = keys // keys now has the complete keys for the newly stored tasks.
+}
+
+func ExampleClient_GetMulti() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	var taskKeys []*datastore.Key // Populated with incomplete keys.
+	// [START batch_lookup]
+	var tasks []*Task
+	err := client.GetMulti(ctx, taskKeys, &tasks)
+	// [END batch_lookup]
+	_ = err // Make sure you check err.
+}
+
+func ExampleClient_DeleteMulti() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	var taskKeys []*datastore.Key // Populated with incomplete keys.
+	// [START batch_delete]
+	err := client.DeleteMulti(ctx, taskKeys)
+	// [END batch_delete]
+	_ = err // Make sure you check err.
+}
+
+func ExampleQuery_basic() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START basic_query]
+	query := datastore.NewQuery("Task").
+		Filter("Done =", false).
+		Filter("Priority >=", 4).
+		Order("-Priority")
+	// [END basic_query]
+	// [START run_query]
+	it := client.Run(ctx, query)
+	for {
+		var task Task
+		_, err := it.Next(&task)
+		if err == datastore.Done {
+			break
+		}
+		if err != nil {
+			log.Fatalf("Error fetching next task: %v", err)
+		}
+		fmt.Printf("Task %q, Priority %d\n", task.Description, task.Priority)
+	}
+	// [END run_query]
+}
+
+func ExampleQuery_propertyFilter() {
+	// [START property_filter]
+	query := datastore.NewQuery("Task").Filter("Done =", false)
+	// [END property_filter]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_compositeFilter() {
+	// [START composite_filter]
+	query := datastore.NewQuery("Task").Filter("Done =", false).Filter("Priority =", 4)
+	// [END composite_filter]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_keyFilter() {
+	ctx := context.Background()
+	// [START key_filter]
+	key := datastore.NewKey(ctx, "Task", "someTask", 0, nil)
+	query := datastore.NewQuery("Task").Filter("__key__ >", key)
+	// [END key_filter]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_sortAscending() {
+	// [START ascending_sort]
+	query := datastore.NewQuery("Task").Order("created")
+	// [END ascending_sort]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_sortDescending() {
+	// [START descending_sort]
+	query := datastore.NewQuery("Task").Order("-created")
+	// [END descending_sort]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_sortMulti() {
+	// [START multi_sort]
+	query := datastore.NewQuery("Task").Order("-priority").Order("created")
+	// [END multi_sort]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_kindless() {
+	var lastSeenKey *datastore.Key
+	// [START kindless_query]
+	query := datastore.NewQuery("").Filter("__key__ >", lastSeenKey)
+	// [END kindless_query]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_Ancestor() {
+	ctx := context.Background()
+	// [START ancestor_query]
+	ancestor := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
+	query := datastore.NewQuery("Task").Ancestor(ancestor)
+	// [END ancestor_query]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_Project() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START projection_query]
+	query := datastore.NewQuery("Task").Project("Priority", "PercentComplete")
+	// [END projection_query]
+	// [START run_query_projection]
+	var priorities []int
+	var percents []float64
+	it := client.Run(ctx, query)
+	for {
+		var task Task
+		if _, err := it.Next(&task); err == datastore.Done {
+			break
+		} else if err != nil {
+			log.Fatal(err)
+		}
+		priorities = append(priorities, task.Priority)
+		percents = append(percents, task.PercentComplete)
+	}
+	// [END run_query_projection]
+}
+
+func ExampleQuery_KeysOnly() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START keys_only_query]
+	query := datastore.NewQuery("Task").KeysOnly()
+	// [END keys_only_query]
+	// [START run_keys_only_query]
+	keys, err := client.GetAll(ctx, query, nil)
+	// [END run_keys_only_query]
+	_ = err  // Make sure you check err.
+	_ = keys // Keys contains keys for all stored tasks.
+}
+
+func ExampleQuery_Distinct() {
+	// [START distinct_query]
+	query := datastore.NewQuery("Task").
+		Project("Priority", "PercentComplete").
+		Distinct().
+		Order("Category").Order("Priority")
+	// [END distinct_query]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+
+	// [START distinct_on_query]
+	// DISTINCT ON not supported in Go API
+	// [END distinct_on_query]
+}
+
+func ExampleQuery_Filter_arrayInequality() {
+	// [START array_value_inequality_range]
+	query := datastore.NewQuery("Task").
+		Filter("Tag >", "learn").
+		Filter("Tag <", "math")
+	// [END array_value_inequality_range]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_Filter_arrayEquality() {
+	// [START array_value_equality]
+	query := datastore.NewQuery("Task").
+		Filter("Tag =", "fun").
+		Filter("Tag =", "programming")
+	// [END array_value_equality]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_Filter_inequality() {
+	// [START inequality_range]
+	query := datastore.NewQuery("Task").
+		Filter("Created >", time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)).
+		Filter("Created <", time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC))
+	// [END inequality_range]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_Filter_invalidInequality() {
+	// [START inequality_invalid]
+	query := datastore.NewQuery("Task").
+		Filter("Created >", time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)).
+		Filter("Priority >", 3)
+	// [END inequality_invalid]
+	_ = query // The query is invalid.
+}
+
+func ExampleQuery_Filter_mixed() {
+	// [START equal_and_inequality_range]
+	query := datastore.NewQuery("Task").
+		Filter("Priority =", 4).
+		Filter("Done =", false).
+		Filter("Created >", time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)).
+		Filter("Created <", time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC))
+	// [END equal_and_inequality_range]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_inequalitySort() {
+	// [START inequality_sort]
+	query := datastore.NewQuery("Task").
+		Filter("Priority >", 3).
+		Order("Priority").
+		Order("Created")
+	// [END inequality_sort]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_invalidInequalitySortA() {
+	// [START inequality_sort_invalid_not_same]
+	query := datastore.NewQuery("Task").
+		Filter("Priority >", 3).
+		Order("Created")
+	// [END inequality_sort_invalid_not_same]
+	_ = query // The query is invalid.
+}
+
+func ExampleQuery_invalidInequalitySortB() {
+	// [START inequality_sort_invalid_not_first]
+	query := datastore.NewQuery("Task").
+		Filter("Priority >", 3).
+		Order("Created").
+		Order("Priority")
+	// [END inequality_sort_invalid_not_first]
+	_ = query // The query is invalid.
+}
+
+func ExampleQuery_Limit() {
+	// [START limit]
+	query := datastore.NewQuery("Task").Limit(5)
+	// [END limit]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleIterator_Cursor() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	cursorStr := ""
+	// [START cursor_paging]
+	const pageSize = 5
+	query := datastore.NewQuery("Tasks").Limit(pageSize)
+	if cursorStr != "" {
+		cursor, err := datastore.DecodeCursor(cursorStr)
+		if err != nil {
+			log.Fatalf("Bad cursor %q: %v", cursorStr, err)
+		}
+		query = query.Start(cursor)
+	}
+
+	// Read the tasks.
+	var tasks []Task
+	var task Task
+	it := client.Run(ctx, query)
+	_, err := it.Next(&task)
+	for err == nil {
+		tasks = append(tasks, task)
+		_, err = it.Next(&task)
+	}
+	if err != datastore.Done {
+		log.Fatalf("Failed fetching results: %v", err)
+	}
+
+	// Get the cursor for the next page of results.
+	nextCursor, err := it.Cursor()
+	// [END cursor_paging]
+	_ = err        // Check the error.
+	_ = nextCursor // Use nextCursor.String as the next page's token.
+}
+
+func ExampleQuery_EventualConsistency() {
+	ctx := context.Background()
+	// [START eventual_consistent_query]
+	ancestor := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
+	query := datastore.NewQuery("Task").Ancestor(ancestor).EventualConsistency()
+	// [END eventual_consistent_query]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func ExampleQuery_unindexed() {
+	// [START unindexed_property_query]
+	query := datastore.NewQuery("Tasks").Filter("Description =", "A task description")
+	// [END unindexed_property_query]
+	_ = query // Use client.Run or client.GetAll to execute the query.
+}
+
+func Example_explodingProperties() {
+	// [START exploding_properties]
+	task := &Task{
+		Tags:          []string{"fun", "programming", "learn"},
+		Collaborators: []string{"alice", "bob", "charlie"},
+		Created:       time.Now(),
+	}
+	// [END exploding_properties]
+	_ = task // Use the task in a datastore Put operation.
+}
+
+func Example_Transaction() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	var to, from *datastore.Key
+	// [START transactional_update]
+	type BankAccount struct {
+		Balance int
+	}
+
+	const amount = 50
+	keys := []*datastore.Key{to, from}
+	tx, err := client.NewTransaction(ctx)
+	if err != nil {
+		log.Fatalf("client.NewTransaction: %v", err)
+	}
+	accs := make([]BankAccount, 2)
+	if err := tx.GetMulti(keys, accs); err != nil {
+		tx.Rollback()
+		log.Fatalf("tx.GetMulti: %v", err)
+	}
+	accs[0].Balance += amount
+	accs[1].Balance -= amount
+	if _, err := tx.PutMulti(keys, accs); err != nil {
+		tx.Rollback()
+		log.Fatalf("tx.PutMulti: %v", err)
+	}
+	if _, err = tx.Commit(); err != nil {
+		log.Fatalf("tx.Commit: %v", err)
+	}
+	// [END transactional_update]
+}
+
+func Example_Client_RunInTransaction() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	var to, from *datastore.Key
+	// [START transactional_retry]
+	type BankAccount struct {
+		Balance int
+	}
+
+	const amount = 50
+	_, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
+		keys := []*datastore.Key{to, from}
+		accs := make([]BankAccount, 2)
+		if err := tx.GetMulti(keys, accs); err != nil {
+			return err
+		}
+		accs[0].Balance += amount
+		accs[1].Balance -= amount
+		_, err := tx.PutMulti(keys, accs)
+		return err
+	})
+	// [END transactional_retry]
+	_ = err // Check error.
+}
+
+func ExampleTransaction_getOrCreate() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	key := datastore.NewKey(ctx, "Task", "sampletask", 0, nil)
+	// [START transactional_get_or_create]
+	_, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
+		var task Task
+		if err := tx.Get(key, &task); err != datastore.ErrNoSuchEntity {
+			return err
+		}
+		_, err := tx.Put(key, &Task{
+			Category:    "Personal",
+			Done:        false,
+			Priority:    4,
+			Description: "Learn Cloud Datastore",
+		})
+		return err
+	})
+	// [END transactional_get_or_create]
+	_ = err // Check error.
+}
+
+func ExampleTransaction_runQuery() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START transactional_single_entity_group_read_only]
+	tx, err := client.NewTransaction(ctx)
+	if err != nil {
+		log.Fatalf("client.NewTransaction: %v", err)
+	}
+	defer tx.Rollback() // Transaction only used for read.
+
+	ancestor := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
+	query := datastore.NewQuery("Task").Ancestor(ancestor).Transaction(tx)
+	var tasks []Task
+	_, err = client.GetAll(ctx, query, &tasks)
+	// [END transactional_single_entity_group_read_only]
+	_ = err // Check error.
+}
+
+func Example_metadataNamespaces() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START namespace_run_query]
+	const (
+		startNamespace = "g"
+		endNamespace   = "h"
+	)
+	query := datastore.NewQuery("__namespace__").
+		Filter("__key__ >=", startNamespace).
+		Filter("__key__ <", endNamespace).
+		KeysOnly()
+	keys, err := client.GetAll(ctx, query, nil)
+	if err != nil {
+		log.Fatalf("client.GetAll: %v", err)
+	}
+
+	namespaces := make([]string, 0, len(keys))
+	for _, k := range keys {
+		namespaces = append(namespaces, k.Name())
+	}
+	// [END namespace_run_query]
+}
+
+func Example_metadataKinds() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START kind_run_query]
+	query := datastore.NewQuery("__kind__").KeysOnly()
+	keys, err := client.GetAll(ctx, query, nil)
+	if err != nil {
+		log.Fatalf("client.GetAll: %v", err)
+	}
+
+	kinds := make([]string, 0, len(keys))
+	for _, k := range keys {
+		kinds = append(kinds, k.Name())
+	}
+	// [END kind_run_query]
+}
+
+func Example_metadataProperties() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START property_run_query]
+	query := datastore.NewQuery("__property__").KeysOnly()
+	keys, err := client.GetAll(ctx, query, nil)
+	if err != nil {
+		log.Fatalf("client.GetAll: %v", err)
+	}
+
+	props := make(map[string][]string) // Map from kind to slice of properties.
+	for _, k := range keys {
+		prop := k.Name()
+		kind := k.Parent().Name()
+		props[kind] = append(props[kind], prop)
+	}
+	// [END property_run_query]
+}
+
+func Example_metadataPropertiesForKind() {
+	ctx := context.Background()
+	client, _ := datastore.NewClient(ctx, "my-proj")
+	// [START property_by_kind_run_query]
+	kindKey := datastore.NewKey(ctx, "__kind__", "Task", 0, nil)
+	query := datastore.NewQuery("__property__").Ancestor(kindKey)
+
+	type Prop struct {
+		Repr []string `datastore:"property_representation"`
+	}
+
+	var props []Prop
+	keys, err := client.GetAll(ctx, query, &props)
+	// [END property_by_kind_run_query]
+	_ = err  // Check error.
+	_ = keys // Use keys to find property names, and props for their representations.
+}
--- a/vendor/cloud.google.com/go/datastore/integration_test.go
+++ b/vendor/cloud.google.com/go/datastore/integration_test.go
@@ -0,0 +1,993 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datastore
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/internal/testutil"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+)
+
+// TODO(djd): Make test entity clean up more robust: some test entities may
+// be left behind if tests are aborted, the transport fails, etc.
+
+// suffix is a timestamp-based suffix which is appended to key names,
+// particularly for the root keys of entity groups. This reduces flakiness
+// when the tests are run in parallel.
+var suffix = fmt.Sprintf("-t%d", time.Now().UnixNano())
+
+func newClient(ctx context.Context, t *testing.T) *Client {
+	ts := testutil.TokenSource(ctx, ScopeDatastore)
+	if ts == nil {
+		t.Skip("Integration tests skipped. See CONTRIBUTING.md for details")
+	}
+	client, err := NewClient(ctx, testutil.ProjID(), option.WithTokenSource(ts))
+	if err != nil {
+		t.Fatalf("NewClient: %v", err)
+	}
+	return client
+}
+
+func TestBasics(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx, _ := context.WithTimeout(context.Background(), time.Second*20)
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type X struct {
+		I int
+		S string
+		T time.Time
+	}
+
+	x0 := X{66, "99", time.Now().Truncate(time.Millisecond)}
+	k, err := client.Put(ctx, NewIncompleteKey(ctx, "BasicsX", nil), &x0)
+	if err != nil {
+		t.Fatalf("client.Put: %v", err)
+	}
+	x1 := X{}
+	err = client.Get(ctx, k, &x1)
+	if err != nil {
+		t.Errorf("client.Get: %v", err)
+	}
+	err = client.Delete(ctx, k)
+	if err != nil {
+		t.Errorf("client.Delete: %v", err)
+	}
+	if !reflect.DeepEqual(x0, x1) {
+		t.Errorf("compare: x0=%v, x1=%v", x0, x1)
+	}
+}
+
+func TestListValues(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	p0 := PropertyList{
+		{Name: "L", Value: []interface{}{int64(12), "string", true}},
+	}
+	k, err := client.Put(ctx, NewIncompleteKey(ctx, "ListValue", nil), &p0)
+	if err != nil {
+		t.Fatalf("client.Put: %v", err)
+	}
+	var p1 PropertyList
+	if err := client.Get(ctx, k, &p1); err != nil {
+		t.Errorf("client.Get: %v", err)
+	}
+	if !reflect.DeepEqual(p0, p1) {
+		t.Errorf("compare:\np0=%v\np1=%#v", p0, p1)
+	}
+	if err = client.Delete(ctx, k); err != nil {
+		t.Errorf("client.Delete: %v", err)
+	}
+}
+
+func TestGetMulti(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type X struct {
+		I int
+	}
+	p := NewKey(ctx, "X", "x"+suffix, 0, nil)
+
+	cases := []struct {
+		key *Key
+		put bool
+	}{
+		{key: NewKey(ctx, "X", "item1", 0, p), put: true},
+		{key: NewKey(ctx, "X", "item2", 0, p), put: false},
+		{key: NewKey(ctx, "X", "item3", 0, p), put: false},
+		{key: NewKey(ctx, "X", "item4", 0, p), put: true},
+	}
+
+	var src, dst []*X
+	var srcKeys, dstKeys []*Key
+	for _, c := range cases {
+		dst = append(dst, &X{})
+		dstKeys = append(dstKeys, c.key)
+		if c.put {
+			src = append(src, &X{})
+			srcKeys = append(srcKeys, c.key)
+		}
+	}
+	if _, err := client.PutMulti(ctx, srcKeys, src); err != nil {
+		t.Error(err)
+	}
+	err := client.GetMulti(ctx, dstKeys, dst)
+	if err == nil {
+		t.Errorf("client.GetMulti got %v, expected error", err)
+	}
+	e, ok := err.(MultiError)
+	if !ok {
+		t.Errorf("client.GetMulti got %T, expected MultiError", err)
+	}
+	for i, err := range e {
+		got, want := err, (error)(nil)
+		if !cases[i].put {
+			got, want = err, ErrNoSuchEntity
+		}
+		if got != want {
+			t.Errorf("MultiError[%d] == %v, want %v", i, got, want)
+		}
+	}
+}
+
+type Z struct {
+	S string
+	T string `datastore:",noindex"`
+	P []byte
+	K []byte `datastore:",noindex"`
+}
+
+func (z Z) String() string {
+	var lens []string
+	v := reflect.ValueOf(z)
+	for i := 0; i < v.NumField(); i++ {
+		if l := v.Field(i).Len(); l > 0 {
+			lens = append(lens, fmt.Sprintf("len(%s)=%d", v.Type().Field(i).Name, l))
+		}
+	}
+	return fmt.Sprintf("Z{ %s }", strings.Join(lens, ","))
+}
+
+func TestUnindexableValues(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	x1500 := strings.Repeat("x", 1500)
+	x1501 := strings.Repeat("x", 1501)
+	testCases := []struct {
+		in      Z
+		wantErr bool
+	}{
+		{in: Z{S: x1500}, wantErr: false},
+		{in: Z{S: x1501}, wantErr: true},
+		{in: Z{T: x1500}, wantErr: false},
+		{in: Z{T: x1501}, wantErr: false},
+		{in: Z{P: []byte(x1500)}, wantErr: false},
+		{in: Z{P: []byte(x1501)}, wantErr: true},
+		{in: Z{K: []byte(x1500)}, wantErr: false},
+		{in: Z{K: []byte(x1501)}, wantErr: false},
+	}
+	for _, tt := range testCases {
+		_, err := client.Put(ctx, NewIncompleteKey(ctx, "BasicsZ", nil), &tt.in)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("client.Put %s got err %v, want err %t", tt.in, err, tt.wantErr)
+		}
+	}
+}
+
+func TestNilKey(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	testCases := []struct {
+		in      K0
+		wantErr bool
+	}{
+		{in: K0{K: testKey0}, wantErr: false},
+		{in: K0{}, wantErr: false},
+	}
+	for _, tt := range testCases {
+		_, err := client.Put(ctx, NewIncompleteKey(ctx, "NilKey", nil), &tt.in)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("client.Put %s got err %v, want err %t", tt.in, err, tt.wantErr)
+		}
+	}
+}
+
+type SQChild struct {
+	I, J int
+	T, U int64
+}
+
+type SQTestCase struct {
+	desc      string
+	q         *Query
+	wantCount int
+	wantSum   int
+}
+
+func testSmallQueries(t *testing.T, ctx context.Context, client *Client, parent *Key, children []*SQChild,
+	testCases []SQTestCase, extraTests ...func()) {
+	keys := make([]*Key, len(children))
+	for i := range keys {
+		keys[i] = NewIncompleteKey(ctx, "SQChild", parent)
+	}
+	keys, err := client.PutMulti(ctx, keys, children)
+	if err != nil {
+		t.Fatalf("client.PutMulti: %v", err)
+	}
+	defer func() {
+		err := client.DeleteMulti(ctx, keys)
+		if err != nil {
+			t.Errorf("client.DeleteMulti: %v", err)
+		}
+	}()
+
+	for _, tc := range testCases {
+		count, err := client.Count(ctx, tc.q)
+		if err != nil {
+			t.Errorf("Count %q: %v", tc.desc, err)
+			continue
+		}
+		if count != tc.wantCount {
+			t.Errorf("Count %q: got %d want %d", tc.desc, count, tc.wantCount)
+			continue
+		}
+	}
+
+	for _, tc := range testCases {
+		var got []SQChild
+		_, err := client.GetAll(ctx, tc.q, &got)
+		if err != nil {
+			t.Errorf("client.GetAll %q: %v", tc.desc, err)
+			continue
+		}
+		sum := 0
+		for _, c := range got {
+			sum += c.I + c.J
+		}
+		if sum != tc.wantSum {
+			t.Errorf("sum %q: got %d want %d", tc.desc, sum, tc.wantSum)
+			continue
+		}
+	}
+	for _, x := range extraTests {
+		x()
+	}
+}
+
+func TestFilters(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	parent := NewKey(ctx, "SQParent", "TestFilters"+suffix, 0, nil)
+	now := time.Now().Truncate(time.Millisecond).Unix()
+	children := []*SQChild{
+		{I: 0, T: now, U: now},
+		{I: 1, T: now, U: now},
+		{I: 2, T: now, U: now},
+		{I: 3, T: now, U: now},
+		{I: 4, T: now, U: now},
+		{I: 5, T: now, U: now},
+		{I: 6, T: now, U: now},
+		{I: 7, T: now, U: now},
+	}
+	baseQuery := NewQuery("SQChild").Ancestor(parent).Filter("T=", now)
+	testSmallQueries(t, ctx, client, parent, children, []SQTestCase{
+		{
+			"I>1",
+			baseQuery.Filter("I>", 1),
+			6,
+			2 + 3 + 4 + 5 + 6 + 7,
+		},
+		{
+			"I>2 AND I<=5",
+			baseQuery.Filter("I>", 2).Filter("I<=", 5),
+			3,
+			3 + 4 + 5,
+		},
+		{
+			"I>=3 AND I<3",
+			baseQuery.Filter("I>=", 3).Filter("I<", 3),
+			0,
+			0,
+		},
+		{
+			"I=4",
+			baseQuery.Filter("I=", 4),
+			1,
+			4,
+		},
+	}, func() {
+		got := []*SQChild{}
+		want := []*SQChild{
+			{I: 0, T: now, U: now},
+			{I: 1, T: now, U: now},
+			{I: 2, T: now, U: now},
+			{I: 3, T: now, U: now},
+			{I: 4, T: now, U: now},
+			{I: 5, T: now, U: now},
+			{I: 6, T: now, U: now},
+			{I: 7, T: now, U: now},
+		}
+		_, err := client.GetAll(ctx, baseQuery.Order("I"), &got)
+		if err != nil {
+			t.Errorf("client.GetAll: %v", err)
+		}
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("compare: got=%v, want=%v", got, want)
+		}
+	}, func() {
+		got := []*SQChild{}
+		want := []*SQChild{
+			{I: 7, T: now, U: now},
+			{I: 6, T: now, U: now},
+			{I: 5, T: now, U: now},
+			{I: 4, T: now, U: now},
+			{I: 3, T: now, U: now},
+			{I: 2, T: now, U: now},
+			{I: 1, T: now, U: now},
+			{I: 0, T: now, U: now},
+		}
+		_, err := client.GetAll(ctx, baseQuery.Order("-I"), &got)
+		if err != nil {
+			t.Errorf("client.GetAll: %v", err)
+		}
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("compare: got=%v, want=%v", got, want)
+		}
+	})
+}
+
+func TestLargeQuery(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	parent := NewKey(ctx, "LQParent", "TestFilters"+suffix, 0, nil)
+	now := time.Now().Truncate(time.Millisecond).Unix()
+
+	// Make a large number of children entities.
+	const n = 800
+	children := make([]*SQChild, 0, n)
+	keys := make([]*Key, 0, n)
+	for i := 0; i < n; i++ {
+		children = append(children, &SQChild{I: i, T: now, U: now})
+		keys = append(keys, NewIncompleteKey(ctx, "SQChild", parent))
+	}
+
+	// Store using PutMulti in batches.
+	const batchSize = 500
+	for i := 0; i < n; i = i + 500 {
+		j := i + batchSize
+		if j > n {
+			j = n
+		}
+		fullKeys, err := client.PutMulti(ctx, keys[i:j], children[i:j])
+		if err != nil {
+			t.Fatalf("PutMulti(%d, %d): %v", i, j, err)
+		}
+		defer func() {
+			err := client.DeleteMulti(ctx, fullKeys)
+			if err != nil {
+				t.Errorf("client.DeleteMulti: %v", err)
+			}
+		}()
+	}
+
+	q := NewQuery("SQChild").Ancestor(parent).Filter("T=", now).Order("I")
+
+	// Wait group to allow us to run query tests in parallel below.
+	var wg sync.WaitGroup
+
+	// Check we get the expected count and results for various limits/offsets.
+	queryTests := []struct {
+		limit, offset, want int
+	}{
+		// Just limit.
+		{limit: 0, want: 0},
+		{limit: 100, want: 100},
+		{limit: 501, want: 501},
+		{limit: n, want: n},
+		{limit: n * 2, want: n},
+		{limit: -1, want: n},
+		// Just offset.
+		{limit: -1, offset: 100, want: n - 100},
+		{limit: -1, offset: 500, want: n - 500},
+		{limit: -1, offset: n, want: 0},
+		// Limit and offset.
+		{limit: 100, offset: 100, want: 100},
+		{limit: 1000, offset: 100, want: n - 100},
+		{limit: 500, offset: 500, want: n - 500},
+	}
+	for _, tt := range queryTests {
+		q := q.Limit(tt.limit).Offset(tt.offset)
+		wg.Add(1)
+
+		go func(limit, offset, want int) {
+			defer wg.Done()
+			// Check Count returns the expected number of results.
+			count, err := client.Count(ctx, q)
+			if err != nil {
+				t.Errorf("client.Count(limit=%d offset=%d): %v", limit, offset, err)
+				return
+			}
+			if count != want {
+				t.Errorf("Count(limit=%d offset=%d) returned %d, want %d", limit, offset, count, want)
+			}
+
+			var got []SQChild
+			_, err = client.GetAll(ctx, q, &got)
+			if err != nil {
+				t.Errorf("client.GetAll(limit=%d offset=%d): %v", limit, offset, err)
+				return
+			}
+			if len(got) != want {
+				t.Errorf("GetAll(limit=%d offset=%d) returned %d, want %d", limit, offset, len(got), want)
+			}
+			for i, child := range got {
+				if got, want := child.I, i+offset; got != want {
+					t.Errorf("GetAll(limit=%d offset=%d) got[%d].I == %d; want %d", limit, offset, i, got, want)
+					break
+				}
+			}
+		}(tt.limit, tt.offset, tt.want)
+	}
+
+	// Also check iterator cursor behaviour.
+	cursorTests := []struct {
+		limit, offset int // Query limit and offset.
+		count         int // The number of times to call "next"
+		want          int // The I value of the desired element, -1 for "Done".
+	}{
+		// No limits.
+		{count: 0, limit: -1, want: 0},
+		{count: 5, limit: -1, want: 5},
+		{count: 500, limit: -1, want: 500},
+		{count: 1000, limit: -1, want: -1}, // No more results.
+		// Limits.
+		{count: 5, limit: 5, want: 5},
+		{count: 500, limit: 5, want: 5},
+		{count: 1000, limit: 1000, want: -1}, // No more results.
+		// Offsets.
+		{count: 0, offset: 5, limit: -1, want: 5},
+		{count: 5, offset: 5, limit: -1, want: 10},
+		{count: 200, offset: 500, limit: -1, want: 700},
+		{count: 200, offset: 1000, limit: -1, want: -1}, // No more results.
+	}
+	for _, tt := range cursorTests {
+		wg.Add(1)
+
+		go func(count, limit, offset, want int) {
+			defer wg.Done()
+
+			// Run iterator through count calls to Next.
+			it := client.Run(ctx, q.Limit(limit).Offset(offset).KeysOnly())
+			for i := 0; i < count; i++ {
+				_, err := it.Next(nil)
+				if err == Done {
+					break
+				}
+				if err != nil {
+					t.Errorf("count=%d, limit=%d, offset=%d: it.Next failed at i=%d", count, limit, offset, i)
+					return
+				}
+			}
+
+			// Grab the cursor.
+			cursor, err := it.Cursor()
+			if err != nil {
+				t.Errorf("count=%d, limit=%d, offset=%d: it.Cursor: %v", count, limit, offset, err)
+				return
+			}
+
+			// Make a request for the next element.
+			it = client.Run(ctx, q.Limit(1).Start(cursor))
+			var entity SQChild
+			_, err = it.Next(&entity)
+			switch {
+			case want == -1:
+				if err != Done {
+					t.Errorf("count=%d, limit=%d, offset=%d: it.Next from cursor %v, want Done", count, limit, offset, err)
+				}
+			case err != nil:
+				t.Errorf("count=%d, limit=%d, offset=%d: it.Next from cursor: %v, want nil", count, limit, offset, err)
+			case entity.I != want:
+				t.Errorf("count=%d, limit=%d, offset=%d: got.I = %d, want %d", count, limit, offset, entity.I, want)
+			}
+		}(tt.count, tt.limit, tt.offset, tt.want)
+	}
+
+	wg.Wait()
+}
+
+func TestEventualConsistency(t *testing.T) {
+	// TODO(jba): either make this actually test eventual consistency, or
+	// delete it. Currently it behaves the same with or without the
+	// EventualConsistency call.
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	parent := NewKey(ctx, "SQParent", "TestEventualConsistency"+suffix, 0, nil)
+	now := time.Now().Truncate(time.Millisecond).Unix()
+	children := []*SQChild{
+		{I: 0, T: now, U: now},
+		{I: 1, T: now, U: now},
+		{I: 2, T: now, U: now},
+	}
+	query := NewQuery("SQChild").Ancestor(parent).Filter("T =", now).EventualConsistency()
+	testSmallQueries(t, ctx, client, parent, children, nil, func() {
+		got, err := client.Count(ctx, query)
+		if err != nil {
+			t.Fatalf("Count: %v", err)
+		}
+		if got < 0 || 3 < got {
+			t.Errorf("Count: got %d, want [0,3]", got)
+		}
+	})
+}
+
+func TestProjection(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	parent := NewKey(ctx, "SQParent", "TestProjection"+suffix, 0, nil)
+	now := time.Now().Truncate(time.Millisecond).Unix()
+	children := []*SQChild{
+		{I: 1 << 0, J: 100, T: now, U: now},
+		{I: 1 << 1, J: 100, T: now, U: now},
+		{I: 1 << 2, J: 200, T: now, U: now},
+		{I: 1 << 3, J: 300, T: now, U: now},
+		{I: 1 << 4, J: 300, T: now, U: now},
+	}
+	baseQuery := NewQuery("SQChild").Ancestor(parent).Filter("T=", now).Filter("J>", 150)
+	testSmallQueries(t, ctx, client, parent, children, []SQTestCase{
+		{
+			"project",
+			baseQuery.Project("J"),
+			3,
+			200 + 300 + 300,
+		},
+		{
+			"distinct",
+			baseQuery.Project("J").Distinct(),
+			2,
+			200 + 300,
+		},
+		{
+			"project on meaningful (GD_WHEN) field",
+			baseQuery.Project("U"),
+			3,
+			0,
+		},
+	})
+}
+
+func TestAllocateIDs(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	keys := make([]*Key, 5)
+	for i := range keys {
+		keys[i] = NewIncompleteKey(ctx, "AllocID", nil)
+	}
+	keys, err := client.AllocateIDs(ctx, keys)
+	if err != nil {
+		t.Errorf("AllocID #0 failed: %v", err)
+	}
+	if want := len(keys); want != 5 {
+		t.Errorf("Expected to allocate 5 keys, %d keys are found", want)
+	}
+	for _, k := range keys {
+		if k.Incomplete() {
+			t.Errorf("Unexpeceted incomplete key found: %v", k)
+		}
+	}
+}
+
+func TestGetAllWithFieldMismatch(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type Fat struct {
+		X, Y int
+	}
+	type Thin struct {
+		X int
+	}
+
+	// Ancestor queries (those within an entity group) are strongly consistent
+	// by default, which prevents a test from being flaky.
+	// See https://cloud.google.com/appengine/docs/go/datastore/queries#Go_Data_consistency
+	// for more information.
+	parent := NewKey(ctx, "SQParent", "TestGetAllWithFieldMismatch"+suffix, 0, nil)
+	putKeys := make([]*Key, 3)
+	for i := range putKeys {
+		putKeys[i] = NewKey(ctx, "GetAllThing", "", int64(10+i), parent)
+		_, err := client.Put(ctx, putKeys[i], &Fat{X: 20 + i, Y: 30 + i})
+		if err != nil {
+			t.Fatalf("client.Put: %v", err)
+		}
+	}
+
+	var got []Thin
+	want := []Thin{
+		{X: 20},
+		{X: 21},
+		{X: 22},
+	}
+	getKeys, err := client.GetAll(ctx, NewQuery("GetAllThing").Ancestor(parent), &got)
+	if len(getKeys) != 3 && !reflect.DeepEqual(getKeys, putKeys) {
+		t.Errorf("client.GetAll: keys differ\ngetKeys=%v\nputKeys=%v", getKeys, putKeys)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("client.GetAll: entities differ\ngot =%v\nwant=%v", got, want)
+	}
+	if _, ok := err.(*ErrFieldMismatch); !ok {
+		t.Errorf("client.GetAll: got err=%v, want ErrFieldMismatch", err)
+	}
+}
+
+func TestKindlessQueries(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type Dee struct {
+		I   int
+		Why string
+	}
+	type Dum struct {
+		I     int
+		Pling string
+	}
+
+	parent := NewKey(ctx, "Tweedle", "tweedle"+suffix, 0, nil)
+
+	keys := []*Key{
+		NewKey(ctx, "Dee", "dee0", 0, parent),
+		NewKey(ctx, "Dum", "dum1", 0, parent),
+		NewKey(ctx, "Dum", "dum2", 0, parent),
+		NewKey(ctx, "Dum", "dum3", 0, parent),
+	}
+	src := []interface{}{
+		&Dee{1, "binary0001"},
+		&Dum{2, "binary0010"},
+		&Dum{4, "binary0100"},
+		&Dum{8, "binary1000"},
+	}
+	keys, err := client.PutMulti(ctx, keys, src)
+	if err != nil {
+		t.Fatalf("put: %v", err)
+	}
+
+	testCases := []struct {
+		desc    string
+		query   *Query
+		want    []int
+		wantErr string
+	}{
+		{
+			desc:  "Dee",
+			query: NewQuery("Dee"),
+			want:  []int{1},
+		},
+		{
+			desc:  "Doh",
+			query: NewQuery("Doh"),
+			want:  nil},
+		{
+			desc:  "Dum",
+			query: NewQuery("Dum"),
+			want:  []int{2, 4, 8},
+		},
+		{
+			desc:  "",
+			query: NewQuery(""),
+			want:  []int{1, 2, 4, 8},
+		},
+		{
+			desc:  "Kindless filter",
+			query: NewQuery("").Filter("__key__ =", keys[2]),
+			want:  []int{4},
+		},
+		{
+			desc:  "Kindless order",
+			query: NewQuery("").Order("__key__"),
+			want:  []int{1, 2, 4, 8},
+		},
+		{
+			desc:    "Kindless bad filter",
+			query:   NewQuery("").Filter("I =", 4),
+			wantErr: "kind is required",
+		},
+		{
+			desc:    "Kindless bad order",
+			query:   NewQuery("").Order("-__key__"),
+			wantErr: "kind is required for all orders except __key__ ascending",
+		},
+	}
+loop:
+	for _, tc := range testCases {
+		q := tc.query.Ancestor(parent)
+		gotCount, err := client.Count(ctx, q)
+		if err != nil {
+			if tc.wantErr == "" || !strings.Contains(err.Error(), tc.wantErr) {
+				t.Errorf("count %q: err %v, want err %q", tc.desc, err, tc.wantErr)
+			}
+			continue
+		}
+		if tc.wantErr != "" {
+			t.Errorf("count %q: want err %q", tc.desc, tc.wantErr)
+			continue
+		}
+		if gotCount != len(tc.want) {
+			t.Errorf("count %q: got %d want %d", tc.desc, gotCount, len(tc.want))
+			continue
+		}
+		var got []int
+		for iter := client.Run(ctx, q); ; {
+			var dst struct {
+				I          int
+				Why, Pling string
+			}
+			_, err := iter.Next(&dst)
+			if err == Done {
+				break
+			}
+			if err != nil {
+				t.Errorf("iter.Next %q: %v", tc.desc, err)
+				continue loop
+			}
+			got = append(got, dst.I)
+		}
+		sort.Ints(got)
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("elems %q: got %+v want %+v", tc.desc, got, tc.want)
+			continue
+		}
+	}
+}
+
+func TestTransaction(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type Counter struct {
+		N int
+		T time.Time
+	}
+
+	bangErr := errors.New("bang")
+	tests := []struct {
+		desc          string
+		causeConflict []bool
+		retErr        []error
+		want          int
+		wantErr       error
+	}{
+		{
+			desc:          "3 attempts, no conflicts",
+			causeConflict: []bool{false},
+			retErr:        []error{nil},
+			want:          11,
+		},
+		{
+			desc:          "1 attempt, user error",
+			causeConflict: []bool{false},
+			retErr:        []error{bangErr},
+			wantErr:       bangErr,
+		},
+		{
+			desc:          "2 attempts, 1 conflict",
+			causeConflict: []bool{true, false},
+			retErr:        []error{nil, nil},
+			want:          13, // Each conflict increments by 2.
+		},
+		{
+			desc:          "3 attempts, 3 conflicts",
+			causeConflict: []bool{true, true, true},
+			retErr:        []error{nil, nil, nil},
+			wantErr:       ErrConcurrentTransaction,
+		},
+	}
+
+	for i, tt := range tests {
+		// Put a new counter.
+		c := &Counter{N: 10, T: time.Now()}
+		key, err := client.Put(ctx, NewIncompleteKey(ctx, "TransCounter", nil), c)
+		if err != nil {
+			t.Errorf("%s: client.Put: %v", tt.desc, err)
+			continue
+		}
+		defer client.Delete(ctx, key)
+
+		// Increment the counter in a transaction.
+		// The test case can manually cause a conflict or return an
+		// error at each attempt.
+		var attempts int
+		_, err = client.RunInTransaction(ctx, func(tx *Transaction) error {
+			attempts++
+			if attempts > len(tt.causeConflict) {
+				return fmt.Errorf("too many attempts. Got %d, max %d", attempts, len(tt.causeConflict))
+			}
+
+			var c Counter
+			if err := tx.Get(key, &c); err != nil {
+				return err
+			}
+			c.N++
+			if _, err := tx.Put(key, &c); err != nil {
+				return err
+			}
+
+			if tt.causeConflict[attempts-1] {
+				c.N += 1
+				if _, err := client.Put(ctx, key, &c); err != nil {
+					return err
+				}
+			}
+
+			return tt.retErr[attempts-1]
+		}, MaxAttempts(i))
+
+		// Check the error returned by RunInTransaction.
+		if err != tt.wantErr {
+			t.Errorf("%s: got err %v, want %v", tt.desc, err, tt.wantErr)
+			continue
+		}
+		if err != nil {
+			continue
+		}
+
+		// Check the final value of the counter.
+		if err := client.Get(ctx, key, c); err != nil {
+			t.Errorf("%s: client.Get: %v", tt.desc, err)
+			continue
+		}
+		if c.N != tt.want {
+			t.Errorf("%s: counter N=%d, want N=%d", tt.desc, c.N, tt.want)
+		}
+	}
+}
+
+func TestNilPointers(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type X struct {
+		S string
+	}
+
+	src := []*X{{"zero"}, {"one"}}
+	keys := []*Key{NewIncompleteKey(ctx, "NilX", nil), NewIncompleteKey(ctx, "NilX", nil)}
+	keys, err := client.PutMulti(ctx, keys, src)
+	if err != nil {
+		t.Fatalf("PutMulti: %v", err)
+	}
+
+	// It's okay to store into a slice of nil *X.
+	xs := make([]*X, 2)
+	if err := client.GetMulti(ctx, keys, xs); err != nil {
+		t.Errorf("GetMulti: %v", err)
+	} else if !reflect.DeepEqual(xs, src) {
+		t.Errorf("GetMulti fetched %v, want %v", xs, src)
+	}
+
+	// It isn't okay to store into a single nil *X.
+	var x0 *X
+	if err, want := client.Get(ctx, keys[0], x0), ErrInvalidEntityType; err != want {
+		t.Errorf("Get: err %v; want %v", err, want)
+	}
+
+	if err := client.DeleteMulti(ctx, keys); err != nil {
+		t.Errorf("Delete: %v", err)
+	}
+}
+
+func TestNestedRepeatedElementNoIndex(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Integration tests skipped in short mode")
+	}
+	ctx := context.Background()
+	client := newClient(ctx, t)
+	defer client.Close()
+
+	type Inner struct {
+		Name  string
+		Value string `datastore:",noindex"`
+	}
+	type Outer struct {
+		Config []Inner
+	}
+	m := &Outer{
+		Config: []Inner{
+			{Name: "short", Value: "a"},
+			{Name: "long", Value: strings.Repeat("a", 2000)},
+		},
+	}
+
+	key := NewKey(ctx, "Nested", "Nested"+suffix, 0, nil)
+	if _, err := client.Put(ctx, key, m); err != nil {
+		t.Fatalf("client.Put: %v", err)
+	}
+	if err := client.Delete(ctx, key); err != nil {
+		t.Fatalf("client.Delete: %v", err)
+	}
+}
--- a/vendor/cloud.google.com/go/datastore/key.go
+++ b/vendor/cloud.google.com/go/datastore/key.go
@@ -0,0 +1,279 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datastore
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/gob"
+	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/golang/protobuf/proto"
+	"golang.org/x/net/context"
+	pb "google.golang.org/genproto/googleapis/datastore/v1"
+)
+
+// Key represents the datastore key for a stored entity, and is immutable.
+type Key struct {
+	kind   string
+	id     int64
+	name   string
+	parent *Key
+
+	namespace string
+}
+
+func (k *Key) Kind() string {
+	return k.kind
+}
+
+func (k *Key) ID() int64 {
+	return k.id
+}
+
+func (k *Key) Name() string {
+	return k.name
+}
+
+func (k *Key) Parent() *Key {
+	return k.parent
+}
+
+func (k *Key) SetParent(v *Key) {
+	if v.Incomplete() {
+		panic("can't set an incomplete key as parent")
+	}
+	k.parent = v
+}
+
+func (k *Key) Namespace() string {
+	return k.namespace
+}
+
+// Complete returns whether the key does not refer to a stored entity.
+func (k *Key) Incomplete() bool {
+	return k.name == "" && k.id == 0
+}
+
+// valid returns whether the key is valid.
+func (k *Key) valid() bool {
+	if k == nil {
+		return false
+	}
+	for ; k != nil; k = k.parent {
+		if k.kind == "" {
+			return false
+		}
+		if k.name != "" && k.id != 0 {
+			return false
+		}
+		if k.parent != nil {
+			if k.parent.Incomplete() {
+				return false
+			}
+			if k.parent.namespace != k.namespace {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func (k *Key) Equal(o *Key) bool {
+	for {
+		if k == nil || o == nil {
+			return k == o // if either is nil, both must be nil
+		}
+		if k.namespace != o.namespace || k.name != o.name || k.id != o.id || k.kind != o.kind {
+			return false
+		}
+		if k.parent == nil && o.parent == nil {
+			return true
+		}
+		k = k.parent
+		o = o.parent
+	}
+}
+
+// marshal marshals the key's string representation to the buffer.
+func (k *Key) marshal(b *bytes.Buffer) {
+	if k.parent != nil {
+		k.parent.marshal(b)
+	}
+	b.WriteByte('/')
+	b.WriteString(k.kind)
+	b.WriteByte(',')
+	if k.name != "" {
+		b.WriteString(k.name)
+	} else {
+		b.WriteString(strconv.FormatInt(k.id, 10))
+	}
+}
+
+// String returns a string representation of the key.
+func (k *Key) String() string {
+	if k == nil {
+		return ""
+	}
+	b := bytes.NewBuffer(make([]byte, 0, 512))
+	k.marshal(b)
+	return b.String()
+}
+
+// Note: Fields not renamed compared to appengine gobKey struct
+// This ensures gobs created by appengine can be read here, and vice/versa
+type gobKey struct {
+	Kind      string
+	StringID  string
+	IntID     int64
+	Parent    *gobKey
+	AppID     string
+	Namespace string
+}
+
+func keyToGobKey(k *Key) *gobKey {
+	if k == nil {
+		return nil
+	}
+	return &gobKey{
+		Kind:      k.kind,
+		StringID:  k.name,
+		IntID:     k.id,
+		Parent:    keyToGobKey(k.parent),
+		Namespace: k.namespace,
+	}
+}
+
+func gobKeyToKey(gk *gobKey) *Key {
+	if gk == nil {
+		return nil
+	}
+	return &Key{
+		kind:      gk.Kind,
+		name:      gk.StringID,
+		id:        gk.IntID,
+		parent:    gobKeyToKey(gk.Parent),
+		namespace: gk.Namespace,
+	}
+}
+
+func (k *Key) GobEncode() ([]byte, error) {
+	buf := new(bytes.Buffer)
+	if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (k *Key) GobDecode(buf []byte) error {
+	gk := new(gobKey)
+	if err := gob.NewDecoder(bytes.NewBuffer(buf)).Decode(gk); err != nil {
+		return err
+	}
+	*k = *gobKeyToKey(gk)
+	return nil
+}
+
+func (k *Key) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + k.Encode() + `"`), nil
+}
+
+func (k *Key) UnmarshalJSON(buf []byte) error {
+	if len(buf) < 2 || buf[0] != '"' || buf[len(buf)-1] != '"' {
+		return errors.New("datastore: bad JSON key")
+	}
+	k2, err := DecodeKey(string(buf[1 : len(buf)-1]))
+	if err != nil {
+		return err
+	}
+	*k = *k2
+	return nil
+}
+
+// Encode returns an opaque representation of the key
+// suitable for use in HTML and URLs.
+// This is compatible with the Python and Java runtimes.
+func (k *Key) Encode() string {
+	pKey := keyToProto(k)
+
+	b, err := proto.Marshal(pKey)
+	if err != nil {
+		panic(err)
+	}
+
+	// Trailing padding is stripped.
+	return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
+}
+
+// DecodeKey decodes a key from the opaque representation returned by Encode.
+func DecodeKey(encoded string) (*Key, error) {
+	// Re-add padding.
+	if m := len(encoded) % 4; m != 0 {
+		encoded += strings.Repeat("=", 4-m)
+	}
+
+	b, err := base64.URLEncoding.DecodeString(encoded)
+	if err != nil {
+		return nil, err
+	}
+
+	pKey := new(pb.Key)
+	if err := proto.Unmarshal(b, pKey); err != nil {
+		return nil, err
+	}
+	return protoToKey(pKey)
+}
+
+// NewIncompleteKey creates a new incomplete key.
+// kind cannot be empty.
+func NewIncompleteKey(ctx context.Context, kind string, parent *Key) *Key {
+	return NewKey(ctx, kind, "", 0, parent)
+}
+
+// NewKey creates a new key.
+// kind cannot be empty.
+// At least one of name and id must be zero. If both are zero, the key returned
+// is incomplete.
+// parent must either be a complete key or nil.
+func NewKey(ctx context.Context, kind, name string, id int64, parent *Key) *Key {
+	return &Key{
+		kind:      kind,
+		name:      name,
+		id:        id,
+		parent:    parent,
+		namespace: ctxNamespace(ctx),
+	}
+}
+
+// AllocateIDs accepts a slice of incomplete keys and returns a
+// slice of complete keys that are guaranteed to be valid in the datastore
+func (c *Client) AllocateIDs(ctx context.Context, keys []*Key) ([]*Key, error) {
+	if keys == nil {
+		return nil, nil
+	}
+
+	req := &pb.AllocateIdsRequest{
+		ProjectId: c.dataset,
+		Keys:      multiKeyToProto(keys),
+	}
+	resp, err := c.client.AllocateIds(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return multiProtoToKey(resp.Keys)
+}
--- a/vendor/cloud.google.com/go/datastore/key_test.go
+++ b/vendor/cloud.google.com/go/datastore/key_test.go
@@ -0,0 +1,242 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datastore
+
+import (
+	"bytes"
+	"encoding/gob"
+	"encoding/json"
+	"testing"
+
+	"golang.org/x/net/context"
+)
+
+func TestNamespace(t *testing.T) {
+	c := context.Background()
+	k := NewIncompleteKey(c, "foo", nil)
+	if got, want := k.Namespace(), ""; got != want {
+		t.Errorf("No namespace, k.Namespace() = %q, want %q", got, want)
+	}
+
+	c = WithNamespace(c, "gopherspace")
+	k = NewIncompleteKey(c, "foo", nil)
+	if got, want := k.Namespace(), "gopherspace"; got != want {
+		t.Errorf("No namespace, k.Namespace() = %q, want %q", got, want)
+	}
+}
+
+func TestParent(t *testing.T) {
+	c := context.Background()
+	k := NewIncompleteKey(c, "foo", nil)
+	par := NewKey(c, "foomum", "", 1248, nil)
+	k.SetParent(par)
+	if got := k.Parent(); got != par {
+		t.Errorf("k.Parent() = %v; want %v", got, par)
+	}
+}
+
+func TestEqual(t *testing.T) {
+	c := context.Background()
+	cN := WithNamespace(c, "gopherspace")
+
+	testCases := []struct {
+		x, y  *Key
+		equal bool
+	}{
+		{
+			x:     nil,
+			y:     nil,
+			equal: true,
+		},
+		{
+			x:     NewKey(c, "kindA", "", 0, nil),
+			y:     NewIncompleteKey(c, "kindA", nil),
+			equal: true,
+		},
+		{
+			x:     NewKey(c, "kindA", "nameA", 0, nil),
+			y:     NewKey(c, "kindA", "nameA", 0, nil),
+			equal: true,
+		},
+		{
+			x:     NewKey(cN, "kindA", "nameA", 0, nil),
+			y:     NewKey(cN, "kindA", "nameA", 0, nil),
+			equal: true,
+		},
+		{
+			x:     NewKey(c, "kindA", "", 1337, NewKey(c, "kindX", "nameX", 0, nil)),
+			y:     NewKey(c, "kindA", "", 1337, NewKey(c, "kindX", "nameX", 0, nil)),
+			equal: true,
+		},
+		{
+			x:     NewKey(c, "kindA", "nameA", 0, nil),
+			y:     NewKey(c, "kindB", "nameA", 0, nil),
+			equal: false,
+		},
+		{
+			x:     NewKey(c, "kindA", "nameA", 0, nil),
+			y:     NewKey(c, "kindA", "nameB", 0, nil),
+			equal: false,
+		},
+		{
+			x:     NewKey(c, "kindA", "nameA", 0, nil),
+			y:     NewKey(c, "kindA", "", 1337, nil),
+			equal: false,
+		},
+		{
+			x:     NewKey(c, "kindA", "nameA", 0, nil),
+			y:     NewKey(cN, "kindA", "nameA", 0, nil),
+			equal: false,
+		},
+		{
+			x:     NewKey(c, "kindA", "", 1337, NewKey(c, "kindX", "nameX", 0, nil)),
+			y:     NewKey(c, "kindA", "", 1337, NewKey(c, "kindY", "nameX", 0, nil)),
+			equal: false,
+		},
+		{
+			x:     NewKey(c, "kindA", "", 1337, NewKey(c, "kindX", "nameX", 0, nil)),
+			y:     NewKey(c, "kindA", "", 1337, nil),
+			equal: false,
+		},
+	}
+
+	for _, tt := range testCases {
+		if got := tt.x.Equal(tt.y); got != tt.equal {
+			t.Errorf("Equal(%v, %v) = %t; want %t", tt.x, tt.y, got, tt.equal)
+		}
+		if got := tt.y.Equal(tt.x); got != tt.equal {
+			t.Errorf("Equal(%v, %v) = %t; want %t", tt.y, tt.x, got, tt.equal)
+		}
+	}
+}
+
+func TestEncoding(t *testing.T) {
+	c := context.Background()
+	cN := WithNamespace(c, "gopherspace")
+
+	testCases := []struct {
+		k     *Key
+		valid bool
+	}{
+		{
+			k:     nil,
+			valid: false,
+		},
+		{
+			k:     NewKey(c, "", "", 0, nil),
+			valid: false,
+		},
+		{
+			k:     NewKey(c, "kindA", "", 0, nil),
+			valid: true,
+		},
+		{
+			k:     NewKey(cN, "kindA", "", 0, nil),
+			valid: true,
+		},
+		{
+			k:     NewKey(c, "kindA", "nameA", 0, nil),
+			valid: true,
+		},
+		{
+			k:     NewKey(c, "kindA", "", 1337, nil),
+			valid: true,
+		},
+		{
+			k:     NewKey(c, "kindA", "nameA", 1337, nil),
+			valid: false,
+		},
+		{
+			k:     NewKey(c, "kindA", "", 0, NewKey(c, "kindB", "nameB", 0, nil)),
+			valid: true,
+		},
+		{
+			k:     NewKey(c, "kindA", "", 0, NewKey(c, "kindB", "", 0, nil)),
+			valid: false,
+		},
+		{
+			k:     NewKey(c, "kindA", "", 0, NewKey(cN, "kindB", "nameB", 0, nil)),
+			valid: false,
+		},
+	}
+
+	for _, tt := range testCases {
+		if got := tt.k.valid(); got != tt.valid {
+			t.Errorf("valid(%v) = %t; want %t", tt.k, got, tt.valid)
+		}
+
+		// Check encoding/decoding for valid keys.
+		if !tt.valid {
+			continue
+		}
+		enc := tt.k.Encode()
+		dec, err := DecodeKey(enc)
+		if err != nil {
+			t.Errorf("DecodeKey(%q) from %v: %v", enc, tt.k, err)
+			continue
+		}
+		if !tt.k.Equal(dec) {
+			t.Logf("Proto: %s", keyToProto(tt.k))
+			t.Errorf("Decoded key %v not equal to %v", dec, tt.k)
+		}
+
+		b, err := json.Marshal(tt.k)
+		if err != nil {
+			t.Errorf("json.Marshal(%v): %v", tt.k, err)
+			continue
+		}
+		key := &Key{}
+		if err := json.Unmarshal(b, key); err != nil {
+			t.Errorf("json.Unmarshal(%s) for key %v: %v", b, tt.k, err)
+			continue
+		}
+		if !tt.k.Equal(key) {
+			t.Errorf("JSON decoded key %v not equal to %v", dec, tt.k)
+		}
+
+		buf := &bytes.Buffer{}
+		gobEnc := gob.NewEncoder(buf)
+		if err := gobEnc.Encode(tt.k); err != nil {
+			t.Errorf("gobEnc.Encode(%v): %v", tt.k, err)
+			continue
+		}
+		gobDec := gob.NewDecoder(buf)
+		key = &Key{}
+		if err := gobDec.Decode(key); err != nil {
+			t.Errorf("gobDec.Decode() for key %v: %v", tt.k, err)
+		}
+		if !tt.k.Equal(key) {
+			t.Errorf("gob decoded key %v not equal to %v", dec, tt.k)
+		}
+	}
+}
+
+func TestInvalidKeyDecode(t *testing.T) {
+	// Check that decoding an invalid key returns an err and doesn't panic.
+	enc := NewKey(context.Background(), "Kind", "Foo", 0, nil).Encode()
+
+	invalid := []string{
+		"",
+		"Laboratorio",
+		enc + "Junk",
+		enc[:len(enc)-4],
+	}
+	for _, enc := range invalid {
+		key, err := DecodeKey(enc)
+		if err == nil || key != nil {
+			t.Errorf("DecodeKey(%q) = %v, %v; want nil, error", enc, key, err)
+		}
+	}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
RaviSantosh Gudimetla	468e138070	Merge pull request #114 from nikhita/contributing.md Add CONTRIBUTING.md	2018-09-03 09:15:37 -04:00
Nikhita Raghunath	db13b2ac73	Add CONTRIBUTING.md	2018-09-01 19:29:24 +05:30
Avesh Agarwal	40ca53e0a5	Merge pull request #113 from sanity-io/master Yaml files for kubernetes	2018-08-24 08:50:41 -04:00
nicholas.klem	35d8367fe5	rbac.authorization.k8s.io/v1 - not v1beta1	2018-08-24 14:44:19 +02:00
nicholas.klem	345dd9cf27	add kubernetes yaml files	2018-08-24 14:34:38 +02:00
RaviSantosh Gudimetla	81f471fe05	Merge pull request #111 from kubernetes-incubator/ravisantoshgudimetla-patch-2 Remove production usage warning	2018-08-23 15:57:09 -04:00
RaviSantosh Gudimetla	aa5e8770f5	Remove production usage warning Removing production usage warning to encourage more users to try using descheduler and since descheduler has been stable so far.	2018-08-23 15:44:17 -04:00
RaviSantosh Gudimetla	2690d139c5	Merge pull request #110 from kubernetes-incubator/ravisantoshgudimetla-patch-1 Update the compatibility matrix	2018-08-22 16:31:09 -04:00
RaviSantosh Gudimetla	cd192ce5fc	Update the compatibility matrix Descheduler 0.4+ should work with kube 1.9+.	2018-08-22 16:09:18 -04:00
RaviSantosh Gudimetla	048f3fd1e5	Merge pull request #109 from ravisantoshgudimetla/test-cases-cleanup Remove the unnecessary print statements in test file	2018-08-22 12:20:27 -04:00
ravisantoshgudimetla	a079fd2757	Remove the unnecessary print statements	2018-08-22 11:27:40 -04:00
RaviSantosh Gudimetla	ae0a9ed525	Merge pull request #108 from ravisantoshgudimetla/fix-warnings-ci Fix deprecated warning in CI	2018-08-21 15:10:40 -04:00
ravisantoshgudimetla	0a815e8786	Fix deprecated warning in CI	2018-08-21 14:45:14 -04:00
RaviSantosh Gudimetla	0115748fe8	Merge pull request #105 from ravisantoshgudimetla/priority-low-node Low node utilization to respect priority while evicting pods	2018-08-21 14:33:50 -04:00
ravisantoshgudimetla	d0305dac3f	Low node utilization to respect priority while evicting pods	2018-08-21 14:14:26 -04:00
RaviSantosh Gudimetla	72d6a8aa33	Merge pull request #106 from ravisantoshgudimetla/fix-e2e Fix broken e2e tests	2018-08-06 10:53:13 -04:00
ravisantoshgudimetla	654fdbba94	Fix broken e2e tests	2018-08-05 13:16:47 -04:00
Avesh Agarwal	d73471327b	Merge pull request #99 from aveshagarwal/master-fix-1 Add SECURITY_CONTACTS file.	2018-05-31 12:05:58 -04:00
Avesh Agarwal	1294c8a2c2	Add SECURITY_CONTACTS file.	2018-05-31 11:46:54 -04:00
Avesh Agarwal	ddd3dd6f19	Merge pull request #95 from betabrand/auth-providers Allow other auth providers (GCP, OIDC, Azure, OpenStack)	2018-05-23 13:01:27 -04:00
Hugues Alary	fad9e8dc39	Running `glide update -v` to pulldown all the required depedencies	2018-05-22 19:14:00 -07:00
Hugues Alary	450a5c290b	Allow other auth providers (GCP, OIDC, Azure, OpenStack)	2018-05-22 19:13:47 -07:00
RaviSantosh Gudimetla	af2198428e	Merge pull request #94 from ingvagabund/travis-bump-go-to-1.10 Bump Travis go version to 1.9.1	2018-05-22 09:39:29 -04:00
Jan Chaloupka	bc7be54e2e	Bump Travis go version to 1.9.1	2018-05-22 14:50:20 +02:00
Avesh Agarwal	ccb61fc800	Merge pull request #91 from aveshagarwal/master-critical-pod Fix readme to have empty value for critical pod annotation as required.	2018-05-10 17:22:53 -04:00
Avesh Agarwal	61819e3fec	Fix readme to have empty value for critical pod annotation as required.	2018-05-10 16:44:40 -04:00
Avesh Agarwal	a7ceb67109	Merge pull request #88 from aveshagarwal/master-issues Fix dryRun issue and avoid unnecessary log msg when node affinity strategy is disabled.	2018-04-24 09:48:05 -04:00
Avesh Agarwal	57a28e9a8f	Fix dryRun issue and avoid unnecessary log msg when node affinity strategy is disabled.	2018-04-23 17:13:19 -04:00
Avesh Agarwal	c1d87dd93c	Merge pull request #87 from aveshagarwal/master-pod-max-issue Fix max pods to evict per node.	2018-04-13 14:38:02 -04:00
Avesh Agarwal	34fb602101	Fix max pods to evict per node.	2018-04-12 15:28:24 -04:00