Repository: Azure/ARO-RP
Pull request #2284 (2022-07-27 16:08:55)

Adds hive logging support
### Which issue this PR addresses:

[WI 15033872](https://msazure.visualstudio.com/AzureRedHatOpenShift/_workitems/edit/15033872/)

### What this PR does / why we need it:

Changes required on the ARO-RP side to enable hive logging support as per design defined in [HIVE-1966](https://issues.redhat.com/browse/HIVE-1966) ([this comment](https://issues.redhat.com/browse/HIVE-1966?focusedCommentId=20676667&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-20676667)).

Work is still in progress on the Hive side. We will need to update Hive image once https://github.com/openshift/hive/pull/1828 merged.

### Test plan for issue:

This code path must be a no-op for now. E2E should catch any regression.


github-actions[bot]: Please rebase pull request.
github-actions[bot]: Please rebase pull request.

Patch:
diff --git a/pkg/cluster/hive.go b/pkg/cluster/hive.go
index 7d9b67c81..939e910b4 100644
--- a/pkg/cluster/hive.go
+++ b/pkg/cluster/hive.go
@@ -31,7 +31,6 @@ func (m *manager) hiveCreateNamespace(ctx context.Context) error {
 		doc.OpenShiftCluster.Properties.HiveProfile.Namespace = namespace.Name
 		return nil
 	})
-
 	return err
 }
 
@@ -46,6 +45,28 @@ func (m *manager) hiveEnsureResources(ctx context.Context) error {
 	return m.hiveClusterManager.CreateOrUpdate(ctx, m.subscriptionDoc, m.doc)
 }
 
+func (m *manager) hiveClusterDeploymentReady(ctx context.Context) (bool, error) {
+	m.log.Info("waiting for cluster deployment to become ready")
+	if m.hiveClusterManager == nil {
+		// TODO(hive): remove this if once we have Hive everywhere
+		m.log.Info("skipping: no hive cluster manager")
+		return true, nil
+	}
+
+	return m.hiveClusterManager.IsClusterDeploymentReady(ctx, m.doc.OpenShiftCluster.Properties.HiveProfile.Namespace)
+}
+
+func (m *manager) hiveResetCorrelationData(ctx context.Context) error {
+	m.log.Info("resetting correlation data for hive")
+	if m.hiveClusterManager == nil {
+		// TODO(hive): remove this if once we have Hive everywhere
+		m.log.Info("skipping: no hive cluster manager")
+		return nil
+	}
+
+	return m.hiveClusterManager.ResetCorrelationData(ctx, m.doc.OpenShiftCluster.Properties.HiveProfile.Namespace)
+}
+
 func (m *manager) hiveDeleteResources(ctx context.Context) error {
 	m.log.Info("deregistering cluster with hive")
 	if m.hiveClusterManager == nil {
diff --git a/pkg/cluster/install.go b/pkg/cluster/install.go
index 53ba14726..a74babd44 100644
--- a/pkg/cluster/install.go
+++ b/pkg/cluster/install.go
@@ -98,6 +98,8 @@ func (m *manager) adminUpdate() []steps.Step {
 		toRun = append(toRun,
 			steps.Action(m.hiveCreateNamespace),
 			steps.Action(m.hiveEnsureResources),
+			steps.Condition(m.hiveClusterDeploymentReady, 5*time.Minute, true),
+			steps.Action(m.hiveResetCorrelationData),
 		)
 	}
 
@@ -128,6 +130,8 @@ func (m *manager) Update(ctx context.Context) error {
 		// hive has the latest credentials after rotation.
 		steps.Action(m.hiveCreateNamespace),
 		steps.Action(m.hiveEnsureResources),
+		steps.Condition(m.hiveClusterDeploymentReady, 5*time.Minute, true),
+		steps.Action(m.hiveResetCorrelationData),
 	}
 
 	return m.runSteps(ctx, steps)
@@ -170,6 +174,8 @@ func (m *manager) Install(ctx context.Context) error {
 			steps.Action(m.callInstaller),
 			steps.Action(m.hiveCreateNamespace),
 			steps.Action(m.hiveEnsureResources),
+			steps.Condition(m.hiveClusterDeploymentReady, 5*time.Minute, true),
+			steps.Action(m.hiveResetCorrelationData),
 
 			steps.AuthorizationRefreshingAction(m.fpAuthorizer, steps.Action(m.generateKubeconfigs)),
 			steps.Action(m.ensureBillingRecord),
diff --git a/pkg/hive/manager.go b/pkg/hive/manager.go
index 094f59831..d5c43d35c 100644
--- a/pkg/hive/manager.go
+++ b/pkg/hive/manager.go
@@ -6,6 +6,7 @@ package hive
 import (
 	"context"
 
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
 	hiveclient "github.com/openshift/hive/pkg/client/clientset/versioned"
 	"github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
@@ -18,6 +19,7 @@ import (
 	"github.com/Azure/ARO-RP/pkg/api"
 	"github.com/Azure/ARO-RP/pkg/env"
 	"github.com/Azure/ARO-RP/pkg/util/dynamichelper"
+	utillog "github.com/Azure/ARO-RP/pkg/util/log"
 	"github.com/Azure/ARO-RP/pkg/util/uuid"
 )
 
@@ -25,6 +27,8 @@ type ClusterManager interface {
 	CreateNamespace(ctx context.Context) (*corev1.Namespace, error)
 	CreateOrUpdate(ctx context.Context, sub *api.SubscriptionDocument, doc *api.OpenShiftClusterDocument) error
 	Delete(ctx context.Context, namespace string) error
+	IsClusterDeploymentReady(ctx context.Context, namespace string) (bool, error)
+	ResetCorrelationData(ctx context.Context, namespace string) error
 }
 
 type clusterManager struct {
@@ -116,3 +120,32 @@ func (hr *clusterManager) Delete(ctx context.Context, namespace string) error {
 
 	return err
 }
+
+func (hr *clusterManager) IsClusterDeploymentReady(ctx context.Context, namespace string) (bool, error) {
+	cd, err := hr.hiveClientset.HiveV1().ClusterDeployments(namespace).Get(ctx, ClusterDeploymentName, metav1.GetOptions{})
+	if err == nil {
+		for _, cond := range cd.Status.Conditions {
+			if cond.Type == hivev1.ClusterReadyCondition && cond.Status == corev1.ConditionTrue {
+				return true, nil
+			}
+		}
+	}
+	return false, err
+}
+
+func (hr *clusterManager) ResetCorrelationData(ctx context.Context, namespace string) error {
+	return retry.RetryOnConflict(retry.DefaultRetry, func() error {
+		cd, err := hr.hiveClientset.HiveV1().ClusterDeployments(namespace).Get(ctx, ClusterDeploymentName, metav1.GetOptions{})
+		if err != nil {
+			return err
+		}
+
+		err = utillog.ResetHiveCorrelationData(cd)
+		if err != nil {
+			return err
+		}
+
+		_, err = hr.hiveClientset.HiveV1().ClusterDeployments(namespace).Update(ctx, cd, metav1.UpdateOptions{})
+		return err
+	})
+}
diff --git a/pkg/hive/resources.go b/pkg/hive/resources.go
index 75e0b6e68..9f3bfcb91 100644
--- a/pkg/hive/resources.go
+++ b/pkg/hive/resources.go
@@ -11,6 +11,7 @@ import (
 	kruntime "k8s.io/apimachinery/pkg/runtime"
 
 	"github.com/Azure/ARO-RP/pkg/api"
+	utillog "github.com/Azure/ARO-RP/pkg/util/log"
 )
 
 // Changing values of these constants most likely would require
@@ -36,6 +37,14 @@ func (hr *clusterManager) resources(sub *api.SubscriptionDocument, doc *api.Open
 		doc.OpenShiftCluster.Location,
 		doc.OpenShiftCluster.Properties.NetworkProfile.APIServerPrivateEndpointIP,
 	)
+	err = utillog.EnrichHiveWithCorrelationData(cd, doc.CorrelationData)
+	if err != nil {
+		return nil, err
+	}
+	err = utillog.EnrichHiveWithResourceID(cd, doc.OpenShiftCluster.ID)
+	if err != nil {
+		return nil, err
+	}
 
 	return []kruntime.Object{
 		aroServiceKubeconfigSecret(namespace, doc.OpenShiftCluster.Properties.AROServiceKubeconfig),
diff --git a/pkg/util/log/hive.go b/pkg/util/log/hive.go
new file mode 100644
index 000000000..4bc1616c3
--- /dev/null
+++ b/pkg/util/log/hive.go
@@ -0,0 +1,91 @@
+package log
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the Apache License 2.0.
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/Azure/go-autorest/autorest/azure"
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+
+	"github.com/Azure/ARO-RP/pkg/api"
+)
+
+const (
+	// additionalLogFieldsAnnotation is an annotation on a ClusterDeployment
+	// object which must contain a marshalled json object with additional
+	// log fields. We use it to make sure that Hive and installer add fields
+	// such as resource_id and correlation_id and into their logs.
+	// If the annotation is set, Hive will be adding these fields "as is" into
+	// its logs every time it logs something in relation to a
+	// given ClusterDeployment. Hive will also be passing these fields into
+	// the installer for cluster provisioning and deprovisioning.
+	// If the annotation is set, Hive will add component="hive"
+	// field into its logs and make installer add component="installer"
+	// into installer logs.
+	additionalLogFieldsAnnotation = "hive.openshift.io/additional-log-fields"
+)
+
+// EnrichHiveWithCorrelationData sets correlation log fields based on correlationData struct.
+func EnrichHiveWithCorrelationData(cd *hivev1.ClusterDeployment, correlationData *api.CorrelationData) error {
+	if correlationData == nil {
+		return nil
+	}
+
+	return patchClusterDeploymentLogFields(cd, func(logFields map[string]string) {
+		logFields["correlation_id"] = correlationData.CorrelationID
+		logFields["client_request_id"] = correlationData.ClientRequestID
+		logFields["request_id"] = correlationData.RequestID
+		logFields["client_principal_name"] = correlationData.ClientPrincipalName
+	})
+}
+
+// ResetHiveCorrelationData removes correlation log fields from ClusterDeployment, if present.
+func ResetHiveCorrelationData(cd *hivev1.ClusterDeployment) error {
+	return patchClusterDeploymentLogFields(cd, func(logFields map[string]string) {
+		delete(logFields, "correlation_id")
+		delete(logFields, "client_request_id")
+		delete(logFields, "request_id")
+		delete(logFields, "client_principal_name")
+	})
+}
+
+// EnrichHiveWithResourceID sets resource log fields based on a cluster resourceID.
+func EnrichHiveWithResourceID(cd *hivev1.ClusterDeployment, resourceID string) error {
+	r, err := azure.ParseResourceID(resourceID)
+	if err != nil {
+		return err
+	}
+
+	return patchClusterDeploymentLogFields(cd, func(logFields map[string]string) {
+		logFields["resource_id"] = strings.ToLower(resourceID)
+		logFields["subscription_id"] = strings.ToLower(r.SubscriptionID)
+		logFields["resource_group"] = strings.ToLower(r.ResourceGroup)
+		logFields["resource_name"] = strings.ToLower(r.ResourceName)
+	})
+}
+
+func patchClusterDeploymentLogFields(cd *hivev1.ClusterDeployment, mutator func(fields map[string]string)) error {
+	logFields := map[string]string{}
+	if val := cd.Annotations[additionalLogFieldsAnnotation]; val != "" {
+		err := json.Unmarshal([]byte(val), &logFields)
+		if err != nil {
+			return err
+		}
+	}
+
+	mutator(logFields)
+
+	b, err := json.Marshal(logFields)
+	if err != nil {
+		return err
+	}
+
+	if cd.Annotations == nil {
+		cd.Annotations = make(map[string]string)
+	}
+	cd.Annotations[additionalLogFieldsAnnotation] = string(b)
+	return nil
+}
diff --git a/pkg/util/mocks/hive/hive.go b/pkg/util/mocks/hive/hive.go
index 8fea75b30..75eb21cf0 100644
--- a/pkg/util/mocks/hive/hive.go
+++ b/pkg/util/mocks/hive/hive.go
@@ -79,3 +79,32 @@ func (mr *MockClusterManagerMockRecorder) Delete(arg0, arg1 interface{}) *gomock
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClusterManager)(nil).Delete), arg0, arg1)
 }
+
+// IsClusterDeploymentReady mocks base method.
+func (m *MockClusterManager) IsClusterDeploymentReady(arg0 context.Context, arg1 string) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsClusterDeploymentReady", arg0, arg1)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// IsClusterDeploymentReady indicates an expected call of IsClusterDeploymentReady.
+func (mr *MockClusterManagerMockRecorder) IsClusterDeploymentReady(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClusterDeploymentReady", reflect.TypeOf((*MockClusterManager)(nil).IsClusterDeploymentReady), arg0, arg1)
+}
+
+// ResetCorrelationData mocks base method.
+func (m *MockClusterManager) ResetCorrelationData(arg0 context.Context, arg1 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResetCorrelationData", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ResetCorrelationData indicates an expected call of ResetCorrelationData.
+func (mr *MockClusterManagerMockRecorder) ResetCorrelationData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCorrelationData", reflect.TypeOf((*MockClusterManager)(nil).ResetCorrelationData), arg0, arg1)
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/clientset_generated.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/clientset_generated.go
new file mode 100644
index 000000000..4b806e0fe
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/clientset_generated.go
@@ -0,0 +1,76 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	clientset "github.com/openshift/hive/pkg/client/clientset/versioned"
+	hivev1 "github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1"
+	fakehivev1 "github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake"
+	hiveinternalv1alpha1 "github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1"
+	fakehiveinternalv1alpha1 "github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/discovery"
+	fakediscovery "k8s.io/client-go/discovery/fake"
+	"k8s.io/client-go/testing"
+)
+
+// NewSimpleClientset returns a clientset that will respond with the provided objects.
+// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,
+// without applying any validations and/or defaults. It shouldn't be considered a replacement
+// for a real clientset and is mostly useful in simple unit tests.
+func NewSimpleClientset(objects ...runtime.Object) *Clientset {
+	o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())
+	for _, obj := range objects {
+		if err := o.Add(obj); err != nil {
+			panic(err)
+		}
+	}
+
+	cs := &Clientset{tracker: o}
+	cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}
+	cs.AddReactor("*", "*", testing.ObjectReaction(o))
+	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
+		gvr := action.GetResource()
+		ns := action.GetNamespace()
+		watch, err := o.Watch(gvr, ns)
+		if err != nil {
+			return false, nil, err
+		}
+		return true, watch, nil
+	})
+
+	return cs
+}
+
+// Clientset implements clientset.Interface. Meant to be embedded into a
+// struct to get a default implementation. This makes faking out just the method
+// you want to test easier.
+type Clientset struct {
+	testing.Fake
+	discovery *fakediscovery.FakeDiscovery
+	tracker   testing.ObjectTracker
+}
+
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	return c.discovery
+}
+
+func (c *Clientset) Tracker() testing.ObjectTracker {
+	return c.tracker
+}
+
+var (
+	_ clientset.Interface = &Clientset{}
+	_ testing.FakeClient  = &Clientset{}
+)
+
+// HiveV1 retrieves the HiveV1Client
+func (c *Clientset) HiveV1() hivev1.HiveV1Interface {
+	return &fakehivev1.FakeHiveV1{Fake: &c.Fake}
+}
+
+// HiveinternalV1alpha1 retrieves the HiveinternalV1alpha1Client
+func (c *Clientset) HiveinternalV1alpha1() hiveinternalv1alpha1.HiveinternalV1alpha1Interface {
+	return &fakehiveinternalv1alpha1.FakeHiveinternalV1alpha1{Fake: &c.Fake}
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/doc.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/doc.go
new file mode 100644
index 000000000..3630ed1cd
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/doc.go
@@ -0,0 +1,4 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated fake clientset.
+package fake
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/register.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/register.go
new file mode 100644
index 000000000..c4a506792
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/fake/register.go
@@ -0,0 +1,42 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	hiveinternalv1alpha1 "github.com/openshift/hive/apis/hiveinternal/v1alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+)
+
+var scheme = runtime.NewScheme()
+var codecs = serializer.NewCodecFactory(scheme)
+
+var localSchemeBuilder = runtime.SchemeBuilder{
+	hivev1.AddToScheme,
+	hiveinternalv1alpha1.AddToScheme,
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+//   import (
+//     "k8s.io/client-go/kubernetes"
+//     clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+//     aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+//   )
+//
+//   kclientset, _ := kubernetes.NewForConfig(c)
+//   _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+	v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})
+	utilruntime.Must(AddToScheme(scheme))
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/doc.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/doc.go
new file mode 100644
index 000000000..2b5ba4c8e
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/doc.go
@@ -0,0 +1,4 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_checkpoint.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_checkpoint.go
new file mode 100644
index 000000000..f7697de67
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_checkpoint.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeCheckpoints implements CheckpointInterface
+type FakeCheckpoints struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var checkpointsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "checkpoints"}
+
+var checkpointsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "Checkpoint"}
+
+// Get takes name of the checkpoint, and returns the corresponding checkpoint object, and an error if there is any.
+func (c *FakeCheckpoints) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.Checkpoint, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(checkpointsResource, c.ns, name), &hivev1.Checkpoint{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.Checkpoint), err
+}
+
+// List takes label and field selectors, and returns the list of Checkpoints that match those selectors.
+func (c *FakeCheckpoints) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.CheckpointList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(checkpointsResource, checkpointsKind, c.ns, opts), &hivev1.CheckpointList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.CheckpointList{ListMeta: obj.(*hivev1.CheckpointList).ListMeta}
+	for _, item := range obj.(*hivev1.CheckpointList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested checkpoints.
+func (c *FakeCheckpoints) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(checkpointsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a checkpoint and creates it.  Returns the server's representation of the checkpoint, and an error, if there is any.
+func (c *FakeCheckpoints) Create(ctx context.Context, checkpoint *hivev1.Checkpoint, opts v1.CreateOptions) (result *hivev1.Checkpoint, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(checkpointsResource, c.ns, checkpoint), &hivev1.Checkpoint{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.Checkpoint), err
+}
+
+// Update takes the representation of a checkpoint and updates it. Returns the server's representation of the checkpoint, and an error, if there is any.
+func (c *FakeCheckpoints) Update(ctx context.Context, checkpoint *hivev1.Checkpoint, opts v1.UpdateOptions) (result *hivev1.Checkpoint, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(checkpointsResource, c.ns, checkpoint), &hivev1.Checkpoint{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.Checkpoint), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeCheckpoints) UpdateStatus(ctx context.Context, checkpoint *hivev1.Checkpoint, opts v1.UpdateOptions) (*hivev1.Checkpoint, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(checkpointsResource, "status", c.ns, checkpoint), &hivev1.Checkpoint{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.Checkpoint), err
+}
+
+// Delete takes name of the checkpoint and deletes it. Returns an error if one occurs.
+func (c *FakeCheckpoints) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(checkpointsResource, c.ns, name, opts), &hivev1.Checkpoint{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeCheckpoints) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(checkpointsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.CheckpointList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched checkpoint.
+func (c *FakeCheckpoints) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.Checkpoint, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(checkpointsResource, c.ns, name, pt, data, subresources...), &hivev1.Checkpoint{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.Checkpoint), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterclaim.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterclaim.go
new file mode 100644
index 000000000..1e861f25d
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterclaim.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterClaims implements ClusterClaimInterface
+type FakeClusterClaims struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var clusterclaimsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterclaims"}
+
+var clusterclaimsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterClaim"}
+
+// Get takes name of the clusterClaim, and returns the corresponding clusterClaim object, and an error if there is any.
+func (c *FakeClusterClaims) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterClaim, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clusterclaimsResource, c.ns, name), &hivev1.ClusterClaim{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterClaim), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterClaims that match those selectors.
+func (c *FakeClusterClaims) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterClaimList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clusterclaimsResource, clusterclaimsKind, c.ns, opts), &hivev1.ClusterClaimList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterClaimList{ListMeta: obj.(*hivev1.ClusterClaimList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterClaimList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterClaims.
+func (c *FakeClusterClaims) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clusterclaimsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterClaim and creates it.  Returns the server's representation of the clusterClaim, and an error, if there is any.
+func (c *FakeClusterClaims) Create(ctx context.Context, clusterClaim *hivev1.ClusterClaim, opts v1.CreateOptions) (result *hivev1.ClusterClaim, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clusterclaimsResource, c.ns, clusterClaim), &hivev1.ClusterClaim{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterClaim), err
+}
+
+// Update takes the representation of a clusterClaim and updates it. Returns the server's representation of the clusterClaim, and an error, if there is any.
+func (c *FakeClusterClaims) Update(ctx context.Context, clusterClaim *hivev1.ClusterClaim, opts v1.UpdateOptions) (result *hivev1.ClusterClaim, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clusterclaimsResource, c.ns, clusterClaim), &hivev1.ClusterClaim{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterClaim), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterClaims) UpdateStatus(ctx context.Context, clusterClaim *hivev1.ClusterClaim, opts v1.UpdateOptions) (*hivev1.ClusterClaim, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clusterclaimsResource, "status", c.ns, clusterClaim), &hivev1.ClusterClaim{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterClaim), err
+}
+
+// Delete takes name of the clusterClaim and deletes it. Returns an error if one occurs.
+func (c *FakeClusterClaims) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clusterclaimsResource, c.ns, name, opts), &hivev1.ClusterClaim{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterClaims) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clusterclaimsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterClaimList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterClaim.
+func (c *FakeClusterClaims) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterClaim, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clusterclaimsResource, c.ns, name, pt, data, subresources...), &hivev1.ClusterClaim{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterClaim), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterdeployment.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterdeployment.go
new file mode 100644
index 000000000..41c6e4356
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterdeployment.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterDeployments implements ClusterDeploymentInterface
+type FakeClusterDeployments struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var clusterdeploymentsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterdeployments"}
+
+var clusterdeploymentsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterDeployment"}
+
+// Get takes name of the clusterDeployment, and returns the corresponding clusterDeployment object, and an error if there is any.
+func (c *FakeClusterDeployments) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterDeployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clusterdeploymentsResource, c.ns, name), &hivev1.ClusterDeployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeployment), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterDeployments that match those selectors.
+func (c *FakeClusterDeployments) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterDeploymentList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clusterdeploymentsResource, clusterdeploymentsKind, c.ns, opts), &hivev1.ClusterDeploymentList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterDeploymentList{ListMeta: obj.(*hivev1.ClusterDeploymentList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterDeploymentList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterDeployments.
+func (c *FakeClusterDeployments) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clusterdeploymentsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterDeployment and creates it.  Returns the server's representation of the clusterDeployment, and an error, if there is any.
+func (c *FakeClusterDeployments) Create(ctx context.Context, clusterDeployment *hivev1.ClusterDeployment, opts v1.CreateOptions) (result *hivev1.ClusterDeployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clusterdeploymentsResource, c.ns, clusterDeployment), &hivev1.ClusterDeployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeployment), err
+}
+
+// Update takes the representation of a clusterDeployment and updates it. Returns the server's representation of the clusterDeployment, and an error, if there is any.
+func (c *FakeClusterDeployments) Update(ctx context.Context, clusterDeployment *hivev1.ClusterDeployment, opts v1.UpdateOptions) (result *hivev1.ClusterDeployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clusterdeploymentsResource, c.ns, clusterDeployment), &hivev1.ClusterDeployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeployment), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterDeployments) UpdateStatus(ctx context.Context, clusterDeployment *hivev1.ClusterDeployment, opts v1.UpdateOptions) (*hivev1.ClusterDeployment, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clusterdeploymentsResource, "status", c.ns, clusterDeployment), &hivev1.ClusterDeployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeployment), err
+}
+
+// Delete takes name of the clusterDeployment and deletes it. Returns an error if one occurs.
+func (c *FakeClusterDeployments) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clusterdeploymentsResource, c.ns, name, opts), &hivev1.ClusterDeployment{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterDeployments) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clusterdeploymentsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterDeploymentList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterDeployment.
+func (c *FakeClusterDeployments) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterDeployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clusterdeploymentsResource, c.ns, name, pt, data, subresources...), &hivev1.ClusterDeployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeployment), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterdeprovision.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterdeprovision.go
new file mode 100644
index 000000000..5523f3062
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterdeprovision.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterDeprovisions implements ClusterDeprovisionInterface
+type FakeClusterDeprovisions struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var clusterdeprovisionsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterdeprovisions"}
+
+var clusterdeprovisionsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterDeprovision"}
+
+// Get takes name of the clusterDeprovision, and returns the corresponding clusterDeprovision object, and an error if there is any.
+func (c *FakeClusterDeprovisions) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterDeprovision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clusterdeprovisionsResource, c.ns, name), &hivev1.ClusterDeprovision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeprovision), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterDeprovisions that match those selectors.
+func (c *FakeClusterDeprovisions) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterDeprovisionList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clusterdeprovisionsResource, clusterdeprovisionsKind, c.ns, opts), &hivev1.ClusterDeprovisionList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterDeprovisionList{ListMeta: obj.(*hivev1.ClusterDeprovisionList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterDeprovisionList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterDeprovisions.
+func (c *FakeClusterDeprovisions) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clusterdeprovisionsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterDeprovision and creates it.  Returns the server's representation of the clusterDeprovision, and an error, if there is any.
+func (c *FakeClusterDeprovisions) Create(ctx context.Context, clusterDeprovision *hivev1.ClusterDeprovision, opts v1.CreateOptions) (result *hivev1.ClusterDeprovision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clusterdeprovisionsResource, c.ns, clusterDeprovision), &hivev1.ClusterDeprovision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeprovision), err
+}
+
+// Update takes the representation of a clusterDeprovision and updates it. Returns the server's representation of the clusterDeprovision, and an error, if there is any.
+func (c *FakeClusterDeprovisions) Update(ctx context.Context, clusterDeprovision *hivev1.ClusterDeprovision, opts v1.UpdateOptions) (result *hivev1.ClusterDeprovision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clusterdeprovisionsResource, c.ns, clusterDeprovision), &hivev1.ClusterDeprovision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeprovision), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterDeprovisions) UpdateStatus(ctx context.Context, clusterDeprovision *hivev1.ClusterDeprovision, opts v1.UpdateOptions) (*hivev1.ClusterDeprovision, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clusterdeprovisionsResource, "status", c.ns, clusterDeprovision), &hivev1.ClusterDeprovision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeprovision), err
+}
+
+// Delete takes name of the clusterDeprovision and deletes it. Returns an error if one occurs.
+func (c *FakeClusterDeprovisions) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clusterdeprovisionsResource, c.ns, name, opts), &hivev1.ClusterDeprovision{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterDeprovisions) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clusterdeprovisionsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterDeprovisionList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterDeprovision.
+func (c *FakeClusterDeprovisions) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterDeprovision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clusterdeprovisionsResource, c.ns, name, pt, data, subresources...), &hivev1.ClusterDeprovision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterDeprovision), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterimageset.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterimageset.go
new file mode 100644
index 000000000..5129bda65
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterimageset.go
@@ -0,0 +1,117 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterImageSets implements ClusterImageSetInterface
+type FakeClusterImageSets struct {
+	Fake *FakeHiveV1
+}
+
+var clusterimagesetsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterimagesets"}
+
+var clusterimagesetsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterImageSet"}
+
+// Get takes name of the clusterImageSet, and returns the corresponding clusterImageSet object, and an error if there is any.
+func (c *FakeClusterImageSets) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterImageSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(clusterimagesetsResource, name), &hivev1.ClusterImageSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterImageSet), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterImageSets that match those selectors.
+func (c *FakeClusterImageSets) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterImageSetList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(clusterimagesetsResource, clusterimagesetsKind, opts), &hivev1.ClusterImageSetList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterImageSetList{ListMeta: obj.(*hivev1.ClusterImageSetList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterImageSetList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterImageSets.
+func (c *FakeClusterImageSets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(clusterimagesetsResource, opts))
+}
+
+// Create takes the representation of a clusterImageSet and creates it.  Returns the server's representation of the clusterImageSet, and an error, if there is any.
+func (c *FakeClusterImageSets) Create(ctx context.Context, clusterImageSet *hivev1.ClusterImageSet, opts v1.CreateOptions) (result *hivev1.ClusterImageSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(clusterimagesetsResource, clusterImageSet), &hivev1.ClusterImageSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterImageSet), err
+}
+
+// Update takes the representation of a clusterImageSet and updates it. Returns the server's representation of the clusterImageSet, and an error, if there is any.
+func (c *FakeClusterImageSets) Update(ctx context.Context, clusterImageSet *hivev1.ClusterImageSet, opts v1.UpdateOptions) (result *hivev1.ClusterImageSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(clusterimagesetsResource, clusterImageSet), &hivev1.ClusterImageSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterImageSet), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterImageSets) UpdateStatus(ctx context.Context, clusterImageSet *hivev1.ClusterImageSet, opts v1.UpdateOptions) (*hivev1.ClusterImageSet, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(clusterimagesetsResource, "status", clusterImageSet), &hivev1.ClusterImageSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterImageSet), err
+}
+
+// Delete takes name of the clusterImageSet and deletes it. Returns an error if one occurs.
+func (c *FakeClusterImageSets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteActionWithOptions(clusterimagesetsResource, name, opts), &hivev1.ClusterImageSet{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterImageSets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(clusterimagesetsResource, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterImageSetList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterImageSet.
+func (c *FakeClusterImageSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterImageSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(clusterimagesetsResource, name, pt, data, subresources...), &hivev1.ClusterImageSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterImageSet), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterpool.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterpool.go
new file mode 100644
index 000000000..9058f04f2
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterpool.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterPools implements ClusterPoolInterface
+type FakeClusterPools struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var clusterpoolsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterpools"}
+
+var clusterpoolsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterPool"}
+
+// Get takes name of the clusterPool, and returns the corresponding clusterPool object, and an error if there is any.
+func (c *FakeClusterPools) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clusterpoolsResource, c.ns, name), &hivev1.ClusterPool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterPool), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterPools that match those selectors.
+func (c *FakeClusterPools) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterPoolList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clusterpoolsResource, clusterpoolsKind, c.ns, opts), &hivev1.ClusterPoolList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterPoolList{ListMeta: obj.(*hivev1.ClusterPoolList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterPoolList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterPools.
+func (c *FakeClusterPools) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clusterpoolsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterPool and creates it.  Returns the server's representation of the clusterPool, and an error, if there is any.
+func (c *FakeClusterPools) Create(ctx context.Context, clusterPool *hivev1.ClusterPool, opts v1.CreateOptions) (result *hivev1.ClusterPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clusterpoolsResource, c.ns, clusterPool), &hivev1.ClusterPool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterPool), err
+}
+
+// Update takes the representation of a clusterPool and updates it. Returns the server's representation of the clusterPool, and an error, if there is any.
+func (c *FakeClusterPools) Update(ctx context.Context, clusterPool *hivev1.ClusterPool, opts v1.UpdateOptions) (result *hivev1.ClusterPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clusterpoolsResource, c.ns, clusterPool), &hivev1.ClusterPool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterPool), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterPools) UpdateStatus(ctx context.Context, clusterPool *hivev1.ClusterPool, opts v1.UpdateOptions) (*hivev1.ClusterPool, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clusterpoolsResource, "status", c.ns, clusterPool), &hivev1.ClusterPool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterPool), err
+}
+
+// Delete takes name of the clusterPool and deletes it. Returns an error if one occurs.
+func (c *FakeClusterPools) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clusterpoolsResource, c.ns, name, opts), &hivev1.ClusterPool{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterPools) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clusterpoolsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterPoolList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterPool.
+func (c *FakeClusterPools) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clusterpoolsResource, c.ns, name, pt, data, subresources...), &hivev1.ClusterPool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterPool), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterprovision.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterprovision.go
new file mode 100644
index 000000000..d50dc5a8c
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterprovision.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterProvisions implements ClusterProvisionInterface
+type FakeClusterProvisions struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var clusterprovisionsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterprovisions"}
+
+var clusterprovisionsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterProvision"}
+
+// Get takes name of the clusterProvision, and returns the corresponding clusterProvision object, and an error if there is any.
+func (c *FakeClusterProvisions) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterProvision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clusterprovisionsResource, c.ns, name), &hivev1.ClusterProvision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterProvision), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterProvisions that match those selectors.
+func (c *FakeClusterProvisions) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterProvisionList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clusterprovisionsResource, clusterprovisionsKind, c.ns, opts), &hivev1.ClusterProvisionList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterProvisionList{ListMeta: obj.(*hivev1.ClusterProvisionList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterProvisionList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterProvisions.
+func (c *FakeClusterProvisions) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clusterprovisionsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterProvision and creates it.  Returns the server's representation of the clusterProvision, and an error, if there is any.
+func (c *FakeClusterProvisions) Create(ctx context.Context, clusterProvision *hivev1.ClusterProvision, opts v1.CreateOptions) (result *hivev1.ClusterProvision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clusterprovisionsResource, c.ns, clusterProvision), &hivev1.ClusterProvision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterProvision), err
+}
+
+// Update takes the representation of a clusterProvision and updates it. Returns the server's representation of the clusterProvision, and an error, if there is any.
+func (c *FakeClusterProvisions) Update(ctx context.Context, clusterProvision *hivev1.ClusterProvision, opts v1.UpdateOptions) (result *hivev1.ClusterProvision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clusterprovisionsResource, c.ns, clusterProvision), &hivev1.ClusterProvision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterProvision), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterProvisions) UpdateStatus(ctx context.Context, clusterProvision *hivev1.ClusterProvision, opts v1.UpdateOptions) (*hivev1.ClusterProvision, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clusterprovisionsResource, "status", c.ns, clusterProvision), &hivev1.ClusterProvision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterProvision), err
+}
+
+// Delete takes name of the clusterProvision and deletes it. Returns an error if one occurs.
+func (c *FakeClusterProvisions) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clusterprovisionsResource, c.ns, name, opts), &hivev1.ClusterProvision{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterProvisions) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clusterprovisionsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterProvisionList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterProvision.
+func (c *FakeClusterProvisions) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterProvision, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clusterprovisionsResource, c.ns, name, pt, data, subresources...), &hivev1.ClusterProvision{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterProvision), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterrelocate.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterrelocate.go
new file mode 100644
index 000000000..e18ad2deb
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterrelocate.go
@@ -0,0 +1,117 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterRelocates implements ClusterRelocateInterface
+type FakeClusterRelocates struct {
+	Fake *FakeHiveV1
+}
+
+var clusterrelocatesResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterrelocates"}
+
+var clusterrelocatesKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterRelocate"}
+
+// Get takes name of the clusterRelocate, and returns the corresponding clusterRelocate object, and an error if there is any.
+func (c *FakeClusterRelocates) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterRelocate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(clusterrelocatesResource, name), &hivev1.ClusterRelocate{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterRelocate), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterRelocates that match those selectors.
+func (c *FakeClusterRelocates) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterRelocateList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(clusterrelocatesResource, clusterrelocatesKind, opts), &hivev1.ClusterRelocateList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterRelocateList{ListMeta: obj.(*hivev1.ClusterRelocateList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterRelocateList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterRelocates.
+func (c *FakeClusterRelocates) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(clusterrelocatesResource, opts))
+}
+
+// Create takes the representation of a clusterRelocate and creates it.  Returns the server's representation of the clusterRelocate, and an error, if there is any.
+func (c *FakeClusterRelocates) Create(ctx context.Context, clusterRelocate *hivev1.ClusterRelocate, opts v1.CreateOptions) (result *hivev1.ClusterRelocate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(clusterrelocatesResource, clusterRelocate), &hivev1.ClusterRelocate{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterRelocate), err
+}
+
+// Update takes the representation of a clusterRelocate and updates it. Returns the server's representation of the clusterRelocate, and an error, if there is any.
+func (c *FakeClusterRelocates) Update(ctx context.Context, clusterRelocate *hivev1.ClusterRelocate, opts v1.UpdateOptions) (result *hivev1.ClusterRelocate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(clusterrelocatesResource, clusterRelocate), &hivev1.ClusterRelocate{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterRelocate), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterRelocates) UpdateStatus(ctx context.Context, clusterRelocate *hivev1.ClusterRelocate, opts v1.UpdateOptions) (*hivev1.ClusterRelocate, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(clusterrelocatesResource, "status", clusterRelocate), &hivev1.ClusterRelocate{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterRelocate), err
+}
+
+// Delete takes name of the clusterRelocate and deletes it. Returns an error if one occurs.
+func (c *FakeClusterRelocates) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteActionWithOptions(clusterrelocatesResource, name, opts), &hivev1.ClusterRelocate{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterRelocates) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(clusterrelocatesResource, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterRelocateList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterRelocate.
+func (c *FakeClusterRelocates) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterRelocate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrelocatesResource, name, pt, data, subresources...), &hivev1.ClusterRelocate{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterRelocate), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterstate.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterstate.go
new file mode 100644
index 000000000..d4578e946
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_clusterstate.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterStates implements ClusterStateInterface
+type FakeClusterStates struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var clusterstatesResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "clusterstates"}
+
+var clusterstatesKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "ClusterState"}
+
+// Get takes name of the clusterState, and returns the corresponding clusterState object, and an error if there is any.
+func (c *FakeClusterStates) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.ClusterState, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clusterstatesResource, c.ns, name), &hivev1.ClusterState{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterState), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterStates that match those selectors.
+func (c *FakeClusterStates) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.ClusterStateList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clusterstatesResource, clusterstatesKind, c.ns, opts), &hivev1.ClusterStateList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.ClusterStateList{ListMeta: obj.(*hivev1.ClusterStateList).ListMeta}
+	for _, item := range obj.(*hivev1.ClusterStateList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterStates.
+func (c *FakeClusterStates) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clusterstatesResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterState and creates it.  Returns the server's representation of the clusterState, and an error, if there is any.
+func (c *FakeClusterStates) Create(ctx context.Context, clusterState *hivev1.ClusterState, opts v1.CreateOptions) (result *hivev1.ClusterState, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clusterstatesResource, c.ns, clusterState), &hivev1.ClusterState{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterState), err
+}
+
+// Update takes the representation of a clusterState and updates it. Returns the server's representation of the clusterState, and an error, if there is any.
+func (c *FakeClusterStates) Update(ctx context.Context, clusterState *hivev1.ClusterState, opts v1.UpdateOptions) (result *hivev1.ClusterState, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clusterstatesResource, c.ns, clusterState), &hivev1.ClusterState{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterState), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterStates) UpdateStatus(ctx context.Context, clusterState *hivev1.ClusterState, opts v1.UpdateOptions) (*hivev1.ClusterState, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clusterstatesResource, "status", c.ns, clusterState), &hivev1.ClusterState{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterState), err
+}
+
+// Delete takes name of the clusterState and deletes it. Returns an error if one occurs.
+func (c *FakeClusterStates) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clusterstatesResource, c.ns, name, opts), &hivev1.ClusterState{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterStates) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clusterstatesResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.ClusterStateList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterState.
+func (c *FakeClusterStates) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.ClusterState, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clusterstatesResource, c.ns, name, pt, data, subresources...), &hivev1.ClusterState{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.ClusterState), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_dnszone.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_dnszone.go
new file mode 100644
index 000000000..5f86ce742
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_dnszone.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeDNSZones implements DNSZoneInterface
+type FakeDNSZones struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var dnszonesResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "dnszones"}
+
+var dnszonesKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "DNSZone"}
+
+// Get takes name of the dNSZone, and returns the corresponding dNSZone object, and an error if there is any.
+func (c *FakeDNSZones) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.DNSZone, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(dnszonesResource, c.ns, name), &hivev1.DNSZone{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.DNSZone), err
+}
+
+// List takes label and field selectors, and returns the list of DNSZones that match those selectors.
+func (c *FakeDNSZones) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.DNSZoneList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(dnszonesResource, dnszonesKind, c.ns, opts), &hivev1.DNSZoneList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.DNSZoneList{ListMeta: obj.(*hivev1.DNSZoneList).ListMeta}
+	for _, item := range obj.(*hivev1.DNSZoneList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested dNSZones.
+func (c *FakeDNSZones) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(dnszonesResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a dNSZone and creates it.  Returns the server's representation of the dNSZone, and an error, if there is any.
+func (c *FakeDNSZones) Create(ctx context.Context, dNSZone *hivev1.DNSZone, opts v1.CreateOptions) (result *hivev1.DNSZone, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(dnszonesResource, c.ns, dNSZone), &hivev1.DNSZone{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.DNSZone), err
+}
+
+// Update takes the representation of a dNSZone and updates it. Returns the server's representation of the dNSZone, and an error, if there is any.
+func (c *FakeDNSZones) Update(ctx context.Context, dNSZone *hivev1.DNSZone, opts v1.UpdateOptions) (result *hivev1.DNSZone, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(dnszonesResource, c.ns, dNSZone), &hivev1.DNSZone{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.DNSZone), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeDNSZones) UpdateStatus(ctx context.Context, dNSZone *hivev1.DNSZone, opts v1.UpdateOptions) (*hivev1.DNSZone, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(dnszonesResource, "status", c.ns, dNSZone), &hivev1.DNSZone{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.DNSZone), err
+}
+
+// Delete takes name of the dNSZone and deletes it. Returns an error if one occurs.
+func (c *FakeDNSZones) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(dnszonesResource, c.ns, name, opts), &hivev1.DNSZone{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeDNSZones) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(dnszonesResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.DNSZoneList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched dNSZone.
+func (c *FakeDNSZones) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.DNSZone, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(dnszonesResource, c.ns, name, pt, data, subresources...), &hivev1.DNSZone{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.DNSZone), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_hive_client.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_hive_client.go
new file mode 100644
index 000000000..d52a518c1
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_hive_client.go
@@ -0,0 +1,88 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeHiveV1 struct {
+	*testing.Fake
+}
+
+func (c *FakeHiveV1) Checkpoints(namespace string) v1.CheckpointInterface {
+	return &FakeCheckpoints{c, namespace}
+}
+
+func (c *FakeHiveV1) ClusterClaims(namespace string) v1.ClusterClaimInterface {
+	return &FakeClusterClaims{c, namespace}
+}
+
+func (c *FakeHiveV1) ClusterDeployments(namespace string) v1.ClusterDeploymentInterface {
+	return &FakeClusterDeployments{c, namespace}
+}
+
+func (c *FakeHiveV1) ClusterDeprovisions(namespace string) v1.ClusterDeprovisionInterface {
+	return &FakeClusterDeprovisions{c, namespace}
+}
+
+func (c *FakeHiveV1) ClusterImageSets() v1.ClusterImageSetInterface {
+	return &FakeClusterImageSets{c}
+}
+
+func (c *FakeHiveV1) ClusterPools(namespace string) v1.ClusterPoolInterface {
+	return &FakeClusterPools{c, namespace}
+}
+
+func (c *FakeHiveV1) ClusterProvisions(namespace string) v1.ClusterProvisionInterface {
+	return &FakeClusterProvisions{c, namespace}
+}
+
+func (c *FakeHiveV1) ClusterRelocates() v1.ClusterRelocateInterface {
+	return &FakeClusterRelocates{c}
+}
+
+func (c *FakeHiveV1) ClusterStates(namespace string) v1.ClusterStateInterface {
+	return &FakeClusterStates{c, namespace}
+}
+
+func (c *FakeHiveV1) DNSZones(namespace string) v1.DNSZoneInterface {
+	return &FakeDNSZones{c, namespace}
+}
+
+func (c *FakeHiveV1) HiveConfigs() v1.HiveConfigInterface {
+	return &FakeHiveConfigs{c}
+}
+
+func (c *FakeHiveV1) MachinePools(namespace string) v1.MachinePoolInterface {
+	return &FakeMachinePools{c, namespace}
+}
+
+func (c *FakeHiveV1) MachinePoolNameLeases(namespace string) v1.MachinePoolNameLeaseInterface {
+	return &FakeMachinePoolNameLeases{c, namespace}
+}
+
+func (c *FakeHiveV1) SelectorSyncIdentityProviders() v1.SelectorSyncIdentityProviderInterface {
+	return &FakeSelectorSyncIdentityProviders{c}
+}
+
+func (c *FakeHiveV1) SelectorSyncSets() v1.SelectorSyncSetInterface {
+	return &FakeSelectorSyncSets{c}
+}
+
+func (c *FakeHiveV1) SyncIdentityProviders(namespace string) v1.SyncIdentityProviderInterface {
+	return &FakeSyncIdentityProviders{c, namespace}
+}
+
+func (c *FakeHiveV1) SyncSets(namespace string) v1.SyncSetInterface {
+	return &FakeSyncSets{c, namespace}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeHiveV1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_hiveconfig.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_hiveconfig.go
new file mode 100644
index 000000000..9ace7ae44
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_hiveconfig.go
@@ -0,0 +1,117 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeHiveConfigs implements HiveConfigInterface
+type FakeHiveConfigs struct {
+	Fake *FakeHiveV1
+}
+
+var hiveconfigsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "hiveconfigs"}
+
+var hiveconfigsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "HiveConfig"}
+
+// Get takes name of the hiveConfig, and returns the corresponding hiveConfig object, and an error if there is any.
+func (c *FakeHiveConfigs) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.HiveConfig, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(hiveconfigsResource, name), &hivev1.HiveConfig{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.HiveConfig), err
+}
+
+// List takes label and field selectors, and returns the list of HiveConfigs that match those selectors.
+func (c *FakeHiveConfigs) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.HiveConfigList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(hiveconfigsResource, hiveconfigsKind, opts), &hivev1.HiveConfigList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.HiveConfigList{ListMeta: obj.(*hivev1.HiveConfigList).ListMeta}
+	for _, item := range obj.(*hivev1.HiveConfigList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested hiveConfigs.
+func (c *FakeHiveConfigs) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(hiveconfigsResource, opts))
+}
+
+// Create takes the representation of a hiveConfig and creates it.  Returns the server's representation of the hiveConfig, and an error, if there is any.
+func (c *FakeHiveConfigs) Create(ctx context.Context, hiveConfig *hivev1.HiveConfig, opts v1.CreateOptions) (result *hivev1.HiveConfig, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(hiveconfigsResource, hiveConfig), &hivev1.HiveConfig{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.HiveConfig), err
+}
+
+// Update takes the representation of a hiveConfig and updates it. Returns the server's representation of the hiveConfig, and an error, if there is any.
+func (c *FakeHiveConfigs) Update(ctx context.Context, hiveConfig *hivev1.HiveConfig, opts v1.UpdateOptions) (result *hivev1.HiveConfig, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(hiveconfigsResource, hiveConfig), &hivev1.HiveConfig{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.HiveConfig), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeHiveConfigs) UpdateStatus(ctx context.Context, hiveConfig *hivev1.HiveConfig, opts v1.UpdateOptions) (*hivev1.HiveConfig, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(hiveconfigsResource, "status", hiveConfig), &hivev1.HiveConfig{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.HiveConfig), err
+}
+
+// Delete takes name of the hiveConfig and deletes it. Returns an error if one occurs.
+func (c *FakeHiveConfigs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteActionWithOptions(hiveconfigsResource, name, opts), &hivev1.HiveConfig{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeHiveConfigs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(hiveconfigsResource, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.HiveConfigList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched hiveConfig.
+func (c *FakeHiveConfigs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.HiveConfig, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(hiveconfigsResource, name, pt, data, subresources...), &hivev1.HiveConfig{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.HiveConfig), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_machinepool.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_machinepool.go
new file mode 100644
index 000000000..f559cccc5
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_machinepool.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeMachinePools implements MachinePoolInterface
+type FakeMachinePools struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var machinepoolsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "machinepools"}
+
+var machinepoolsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "MachinePool"}
+
+// Get takes name of the machinePool, and returns the corresponding machinePool object, and an error if there is any.
+func (c *FakeMachinePools) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.MachinePool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(machinepoolsResource, c.ns, name), &hivev1.MachinePool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePool), err
+}
+
+// List takes label and field selectors, and returns the list of MachinePools that match those selectors.
+func (c *FakeMachinePools) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.MachinePoolList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(machinepoolsResource, machinepoolsKind, c.ns, opts), &hivev1.MachinePoolList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.MachinePoolList{ListMeta: obj.(*hivev1.MachinePoolList).ListMeta}
+	for _, item := range obj.(*hivev1.MachinePoolList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested machinePools.
+func (c *FakeMachinePools) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(machinepoolsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a machinePool and creates it.  Returns the server's representation of the machinePool, and an error, if there is any.
+func (c *FakeMachinePools) Create(ctx context.Context, machinePool *hivev1.MachinePool, opts v1.CreateOptions) (result *hivev1.MachinePool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(machinepoolsResource, c.ns, machinePool), &hivev1.MachinePool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePool), err
+}
+
+// Update takes the representation of a machinePool and updates it. Returns the server's representation of the machinePool, and an error, if there is any.
+func (c *FakeMachinePools) Update(ctx context.Context, machinePool *hivev1.MachinePool, opts v1.UpdateOptions) (result *hivev1.MachinePool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(machinepoolsResource, c.ns, machinePool), &hivev1.MachinePool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePool), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeMachinePools) UpdateStatus(ctx context.Context, machinePool *hivev1.MachinePool, opts v1.UpdateOptions) (*hivev1.MachinePool, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(machinepoolsResource, "status", c.ns, machinePool), &hivev1.MachinePool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePool), err
+}
+
+// Delete takes name of the machinePool and deletes it. Returns an error if one occurs.
+func (c *FakeMachinePools) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(machinepoolsResource, c.ns, name, opts), &hivev1.MachinePool{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeMachinePools) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(machinepoolsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.MachinePoolList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched machinePool.
+func (c *FakeMachinePools) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.MachinePool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(machinepoolsResource, c.ns, name, pt, data, subresources...), &hivev1.MachinePool{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePool), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_machinepoolnamelease.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_machinepoolnamelease.go
new file mode 100644
index 000000000..c6d4648a6
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_machinepoolnamelease.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeMachinePoolNameLeases implements MachinePoolNameLeaseInterface
+type FakeMachinePoolNameLeases struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var machinepoolnameleasesResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "machinepoolnameleases"}
+
+var machinepoolnameleasesKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "MachinePoolNameLease"}
+
+// Get takes name of the machinePoolNameLease, and returns the corresponding machinePoolNameLease object, and an error if there is any.
+func (c *FakeMachinePoolNameLeases) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.MachinePoolNameLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(machinepoolnameleasesResource, c.ns, name), &hivev1.MachinePoolNameLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePoolNameLease), err
+}
+
+// List takes label and field selectors, and returns the list of MachinePoolNameLeases that match those selectors.
+func (c *FakeMachinePoolNameLeases) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.MachinePoolNameLeaseList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(machinepoolnameleasesResource, machinepoolnameleasesKind, c.ns, opts), &hivev1.MachinePoolNameLeaseList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.MachinePoolNameLeaseList{ListMeta: obj.(*hivev1.MachinePoolNameLeaseList).ListMeta}
+	for _, item := range obj.(*hivev1.MachinePoolNameLeaseList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested machinePoolNameLeases.
+func (c *FakeMachinePoolNameLeases) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(machinepoolnameleasesResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a machinePoolNameLease and creates it.  Returns the server's representation of the machinePoolNameLease, and an error, if there is any.
+func (c *FakeMachinePoolNameLeases) Create(ctx context.Context, machinePoolNameLease *hivev1.MachinePoolNameLease, opts v1.CreateOptions) (result *hivev1.MachinePoolNameLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(machinepoolnameleasesResource, c.ns, machinePoolNameLease), &hivev1.MachinePoolNameLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePoolNameLease), err
+}
+
+// Update takes the representation of a machinePoolNameLease and updates it. Returns the server's representation of the machinePoolNameLease, and an error, if there is any.
+func (c *FakeMachinePoolNameLeases) Update(ctx context.Context, machinePoolNameLease *hivev1.MachinePoolNameLease, opts v1.UpdateOptions) (result *hivev1.MachinePoolNameLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(machinepoolnameleasesResource, c.ns, machinePoolNameLease), &hivev1.MachinePoolNameLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePoolNameLease), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeMachinePoolNameLeases) UpdateStatus(ctx context.Context, machinePoolNameLease *hivev1.MachinePoolNameLease, opts v1.UpdateOptions) (*hivev1.MachinePoolNameLease, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(machinepoolnameleasesResource, "status", c.ns, machinePoolNameLease), &hivev1.MachinePoolNameLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePoolNameLease), err
+}
+
+// Delete takes name of the machinePoolNameLease and deletes it. Returns an error if one occurs.
+func (c *FakeMachinePoolNameLeases) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(machinepoolnameleasesResource, c.ns, name, opts), &hivev1.MachinePoolNameLease{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeMachinePoolNameLeases) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(machinepoolnameleasesResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.MachinePoolNameLeaseList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched machinePoolNameLease.
+func (c *FakeMachinePoolNameLeases) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.MachinePoolNameLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(machinepoolnameleasesResource, c.ns, name, pt, data, subresources...), &hivev1.MachinePoolNameLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.MachinePoolNameLease), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_selectorsyncidentityprovider.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_selectorsyncidentityprovider.go
new file mode 100644
index 000000000..ab5927ab6
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_selectorsyncidentityprovider.go
@@ -0,0 +1,117 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeSelectorSyncIdentityProviders implements SelectorSyncIdentityProviderInterface
+type FakeSelectorSyncIdentityProviders struct {
+	Fake *FakeHiveV1
+}
+
+var selectorsyncidentityprovidersResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "selectorsyncidentityproviders"}
+
+var selectorsyncidentityprovidersKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "SelectorSyncIdentityProvider"}
+
+// Get takes name of the selectorSyncIdentityProvider, and returns the corresponding selectorSyncIdentityProvider object, and an error if there is any.
+func (c *FakeSelectorSyncIdentityProviders) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.SelectorSyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(selectorsyncidentityprovidersResource, name), &hivev1.SelectorSyncIdentityProvider{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncIdentityProvider), err
+}
+
+// List takes label and field selectors, and returns the list of SelectorSyncIdentityProviders that match those selectors.
+func (c *FakeSelectorSyncIdentityProviders) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.SelectorSyncIdentityProviderList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(selectorsyncidentityprovidersResource, selectorsyncidentityprovidersKind, opts), &hivev1.SelectorSyncIdentityProviderList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.SelectorSyncIdentityProviderList{ListMeta: obj.(*hivev1.SelectorSyncIdentityProviderList).ListMeta}
+	for _, item := range obj.(*hivev1.SelectorSyncIdentityProviderList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested selectorSyncIdentityProviders.
+func (c *FakeSelectorSyncIdentityProviders) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(selectorsyncidentityprovidersResource, opts))
+}
+
+// Create takes the representation of a selectorSyncIdentityProvider and creates it.  Returns the server's representation of the selectorSyncIdentityProvider, and an error, if there is any.
+func (c *FakeSelectorSyncIdentityProviders) Create(ctx context.Context, selectorSyncIdentityProvider *hivev1.SelectorSyncIdentityProvider, opts v1.CreateOptions) (result *hivev1.SelectorSyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(selectorsyncidentityprovidersResource, selectorSyncIdentityProvider), &hivev1.SelectorSyncIdentityProvider{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncIdentityProvider), err
+}
+
+// Update takes the representation of a selectorSyncIdentityProvider and updates it. Returns the server's representation of the selectorSyncIdentityProvider, and an error, if there is any.
+func (c *FakeSelectorSyncIdentityProviders) Update(ctx context.Context, selectorSyncIdentityProvider *hivev1.SelectorSyncIdentityProvider, opts v1.UpdateOptions) (result *hivev1.SelectorSyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(selectorsyncidentityprovidersResource, selectorSyncIdentityProvider), &hivev1.SelectorSyncIdentityProvider{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncIdentityProvider), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeSelectorSyncIdentityProviders) UpdateStatus(ctx context.Context, selectorSyncIdentityProvider *hivev1.SelectorSyncIdentityProvider, opts v1.UpdateOptions) (*hivev1.SelectorSyncIdentityProvider, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(selectorsyncidentityprovidersResource, "status", selectorSyncIdentityProvider), &hivev1.SelectorSyncIdentityProvider{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncIdentityProvider), err
+}
+
+// Delete takes name of the selectorSyncIdentityProvider and deletes it. Returns an error if one occurs.
+func (c *FakeSelectorSyncIdentityProviders) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteActionWithOptions(selectorsyncidentityprovidersResource, name, opts), &hivev1.SelectorSyncIdentityProvider{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeSelectorSyncIdentityProviders) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(selectorsyncidentityprovidersResource, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.SelectorSyncIdentityProviderList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched selectorSyncIdentityProvider.
+func (c *FakeSelectorSyncIdentityProviders) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.SelectorSyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(selectorsyncidentityprovidersResource, name, pt, data, subresources...), &hivev1.SelectorSyncIdentityProvider{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncIdentityProvider), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_selectorsyncset.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_selectorsyncset.go
new file mode 100644
index 000000000..db1b7fea2
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_selectorsyncset.go
@@ -0,0 +1,117 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeSelectorSyncSets implements SelectorSyncSetInterface
+type FakeSelectorSyncSets struct {
+	Fake *FakeHiveV1
+}
+
+var selectorsyncsetsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "selectorsyncsets"}
+
+var selectorsyncsetsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "SelectorSyncSet"}
+
+// Get takes name of the selectorSyncSet, and returns the corresponding selectorSyncSet object, and an error if there is any.
+func (c *FakeSelectorSyncSets) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.SelectorSyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(selectorsyncsetsResource, name), &hivev1.SelectorSyncSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncSet), err
+}
+
+// List takes label and field selectors, and returns the list of SelectorSyncSets that match those selectors.
+func (c *FakeSelectorSyncSets) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.SelectorSyncSetList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(selectorsyncsetsResource, selectorsyncsetsKind, opts), &hivev1.SelectorSyncSetList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.SelectorSyncSetList{ListMeta: obj.(*hivev1.SelectorSyncSetList).ListMeta}
+	for _, item := range obj.(*hivev1.SelectorSyncSetList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested selectorSyncSets.
+func (c *FakeSelectorSyncSets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(selectorsyncsetsResource, opts))
+}
+
+// Create takes the representation of a selectorSyncSet and creates it.  Returns the server's representation of the selectorSyncSet, and an error, if there is any.
+func (c *FakeSelectorSyncSets) Create(ctx context.Context, selectorSyncSet *hivev1.SelectorSyncSet, opts v1.CreateOptions) (result *hivev1.SelectorSyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(selectorsyncsetsResource, selectorSyncSet), &hivev1.SelectorSyncSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncSet), err
+}
+
+// Update takes the representation of a selectorSyncSet and updates it. Returns the server's representation of the selectorSyncSet, and an error, if there is any.
+func (c *FakeSelectorSyncSets) Update(ctx context.Context, selectorSyncSet *hivev1.SelectorSyncSet, opts v1.UpdateOptions) (result *hivev1.SelectorSyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(selectorsyncsetsResource, selectorSyncSet), &hivev1.SelectorSyncSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncSet), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeSelectorSyncSets) UpdateStatus(ctx context.Context, selectorSyncSet *hivev1.SelectorSyncSet, opts v1.UpdateOptions) (*hivev1.SelectorSyncSet, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(selectorsyncsetsResource, "status", selectorSyncSet), &hivev1.SelectorSyncSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncSet), err
+}
+
+// Delete takes name of the selectorSyncSet and deletes it. Returns an error if one occurs.
+func (c *FakeSelectorSyncSets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteActionWithOptions(selectorsyncsetsResource, name, opts), &hivev1.SelectorSyncSet{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeSelectorSyncSets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(selectorsyncsetsResource, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.SelectorSyncSetList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched selectorSyncSet.
+func (c *FakeSelectorSyncSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.SelectorSyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(selectorsyncsetsResource, name, pt, data, subresources...), &hivev1.SelectorSyncSet{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SelectorSyncSet), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_syncidentityprovider.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_syncidentityprovider.go
new file mode 100644
index 000000000..102e3f8f8
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_syncidentityprovider.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeSyncIdentityProviders implements SyncIdentityProviderInterface
+type FakeSyncIdentityProviders struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var syncidentityprovidersResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "syncidentityproviders"}
+
+var syncidentityprovidersKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "SyncIdentityProvider"}
+
+// Get takes name of the syncIdentityProvider, and returns the corresponding syncIdentityProvider object, and an error if there is any.
+func (c *FakeSyncIdentityProviders) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.SyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(syncidentityprovidersResource, c.ns, name), &hivev1.SyncIdentityProvider{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncIdentityProvider), err
+}
+
+// List takes label and field selectors, and returns the list of SyncIdentityProviders that match those selectors.
+func (c *FakeSyncIdentityProviders) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.SyncIdentityProviderList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(syncidentityprovidersResource, syncidentityprovidersKind, c.ns, opts), &hivev1.SyncIdentityProviderList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.SyncIdentityProviderList{ListMeta: obj.(*hivev1.SyncIdentityProviderList).ListMeta}
+	for _, item := range obj.(*hivev1.SyncIdentityProviderList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested syncIdentityProviders.
+func (c *FakeSyncIdentityProviders) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(syncidentityprovidersResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a syncIdentityProvider and creates it.  Returns the server's representation of the syncIdentityProvider, and an error, if there is any.
+func (c *FakeSyncIdentityProviders) Create(ctx context.Context, syncIdentityProvider *hivev1.SyncIdentityProvider, opts v1.CreateOptions) (result *hivev1.SyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(syncidentityprovidersResource, c.ns, syncIdentityProvider), &hivev1.SyncIdentityProvider{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncIdentityProvider), err
+}
+
+// Update takes the representation of a syncIdentityProvider and updates it. Returns the server's representation of the syncIdentityProvider, and an error, if there is any.
+func (c *FakeSyncIdentityProviders) Update(ctx context.Context, syncIdentityProvider *hivev1.SyncIdentityProvider, opts v1.UpdateOptions) (result *hivev1.SyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(syncidentityprovidersResource, c.ns, syncIdentityProvider), &hivev1.SyncIdentityProvider{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncIdentityProvider), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeSyncIdentityProviders) UpdateStatus(ctx context.Context, syncIdentityProvider *hivev1.SyncIdentityProvider, opts v1.UpdateOptions) (*hivev1.SyncIdentityProvider, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(syncidentityprovidersResource, "status", c.ns, syncIdentityProvider), &hivev1.SyncIdentityProvider{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncIdentityProvider), err
+}
+
+// Delete takes name of the syncIdentityProvider and deletes it. Returns an error if one occurs.
+func (c *FakeSyncIdentityProviders) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(syncidentityprovidersResource, c.ns, name, opts), &hivev1.SyncIdentityProvider{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeSyncIdentityProviders) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(syncidentityprovidersResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.SyncIdentityProviderList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched syncIdentityProvider.
+func (c *FakeSyncIdentityProviders) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.SyncIdentityProvider, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(syncidentityprovidersResource, c.ns, name, pt, data, subresources...), &hivev1.SyncIdentityProvider{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncIdentityProvider), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_syncset.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_syncset.go
new file mode 100644
index 000000000..a8c92ce3e
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake/fake_syncset.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeSyncSets implements SyncSetInterface
+type FakeSyncSets struct {
+	Fake *FakeHiveV1
+	ns   string
+}
+
+var syncsetsResource = schema.GroupVersionResource{Group: "hive.openshift.io", Version: "v1", Resource: "syncsets"}
+
+var syncsetsKind = schema.GroupVersionKind{Group: "hive.openshift.io", Version: "v1", Kind: "SyncSet"}
+
+// Get takes name of the syncSet, and returns the corresponding syncSet object, and an error if there is any.
+func (c *FakeSyncSets) Get(ctx context.Context, name string, options v1.GetOptions) (result *hivev1.SyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(syncsetsResource, c.ns, name), &hivev1.SyncSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncSet), err
+}
+
+// List takes label and field selectors, and returns the list of SyncSets that match those selectors.
+func (c *FakeSyncSets) List(ctx context.Context, opts v1.ListOptions) (result *hivev1.SyncSetList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(syncsetsResource, syncsetsKind, c.ns, opts), &hivev1.SyncSetList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &hivev1.SyncSetList{ListMeta: obj.(*hivev1.SyncSetList).ListMeta}
+	for _, item := range obj.(*hivev1.SyncSetList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested syncSets.
+func (c *FakeSyncSets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(syncsetsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a syncSet and creates it.  Returns the server's representation of the syncSet, and an error, if there is any.
+func (c *FakeSyncSets) Create(ctx context.Context, syncSet *hivev1.SyncSet, opts v1.CreateOptions) (result *hivev1.SyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(syncsetsResource, c.ns, syncSet), &hivev1.SyncSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncSet), err
+}
+
+// Update takes the representation of a syncSet and updates it. Returns the server's representation of the syncSet, and an error, if there is any.
+func (c *FakeSyncSets) Update(ctx context.Context, syncSet *hivev1.SyncSet, opts v1.UpdateOptions) (result *hivev1.SyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(syncsetsResource, c.ns, syncSet), &hivev1.SyncSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncSet), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeSyncSets) UpdateStatus(ctx context.Context, syncSet *hivev1.SyncSet, opts v1.UpdateOptions) (*hivev1.SyncSet, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(syncsetsResource, "status", c.ns, syncSet), &hivev1.SyncSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncSet), err
+}
+
+// Delete takes name of the syncSet and deletes it. Returns an error if one occurs.
+func (c *FakeSyncSets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(syncsetsResource, c.ns, name, opts), &hivev1.SyncSet{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeSyncSets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(syncsetsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &hivev1.SyncSetList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched syncSet.
+func (c *FakeSyncSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *hivev1.SyncSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(syncsetsResource, c.ns, name, pt, data, subresources...), &hivev1.SyncSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*hivev1.SyncSet), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/doc.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/doc.go
new file mode 100644
index 000000000..2b5ba4c8e
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/doc.go
@@ -0,0 +1,4 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_clustersync.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_clustersync.go
new file mode 100644
index 000000000..5b17d1015
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_clustersync.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	v1alpha1 "github.com/openshift/hive/apis/hiveinternal/v1alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterSyncs implements ClusterSyncInterface
+type FakeClusterSyncs struct {
+	Fake *FakeHiveinternalV1alpha1
+	ns   string
+}
+
+var clustersyncsResource = schema.GroupVersionResource{Group: "hiveinternal.openshift.io", Version: "v1alpha1", Resource: "clustersyncs"}
+
+var clustersyncsKind = schema.GroupVersionKind{Group: "hiveinternal.openshift.io", Version: "v1alpha1", Kind: "ClusterSync"}
+
+// Get takes name of the clusterSync, and returns the corresponding clusterSync object, and an error if there is any.
+func (c *FakeClusterSyncs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.ClusterSync, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clustersyncsResource, c.ns, name), &v1alpha1.ClusterSync{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSync), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterSyncs that match those selectors.
+func (c *FakeClusterSyncs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.ClusterSyncList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clustersyncsResource, clustersyncsKind, c.ns, opts), &v1alpha1.ClusterSyncList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1alpha1.ClusterSyncList{ListMeta: obj.(*v1alpha1.ClusterSyncList).ListMeta}
+	for _, item := range obj.(*v1alpha1.ClusterSyncList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterSyncs.
+func (c *FakeClusterSyncs) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clustersyncsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterSync and creates it.  Returns the server's representation of the clusterSync, and an error, if there is any.
+func (c *FakeClusterSyncs) Create(ctx context.Context, clusterSync *v1alpha1.ClusterSync, opts v1.CreateOptions) (result *v1alpha1.ClusterSync, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clustersyncsResource, c.ns, clusterSync), &v1alpha1.ClusterSync{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSync), err
+}
+
+// Update takes the representation of a clusterSync and updates it. Returns the server's representation of the clusterSync, and an error, if there is any.
+func (c *FakeClusterSyncs) Update(ctx context.Context, clusterSync *v1alpha1.ClusterSync, opts v1.UpdateOptions) (result *v1alpha1.ClusterSync, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clustersyncsResource, c.ns, clusterSync), &v1alpha1.ClusterSync{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSync), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeClusterSyncs) UpdateStatus(ctx context.Context, clusterSync *v1alpha1.ClusterSync, opts v1.UpdateOptions) (*v1alpha1.ClusterSync, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(clustersyncsResource, "status", c.ns, clusterSync), &v1alpha1.ClusterSync{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSync), err
+}
+
+// Delete takes name of the clusterSync and deletes it. Returns an error if one occurs.
+func (c *FakeClusterSyncs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clustersyncsResource, c.ns, name, opts), &v1alpha1.ClusterSync{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterSyncs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clustersyncsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &v1alpha1.ClusterSyncList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterSync.
+func (c *FakeClusterSyncs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ClusterSync, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clustersyncsResource, c.ns, name, pt, data, subresources...), &v1alpha1.ClusterSync{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSync), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_clustersynclease.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_clustersynclease.go
new file mode 100644
index 000000000..997f5c3e3
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_clustersynclease.go
@@ -0,0 +1,114 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	v1alpha1 "github.com/openshift/hive/apis/hiveinternal/v1alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeClusterSyncLeases implements ClusterSyncLeaseInterface
+type FakeClusterSyncLeases struct {
+	Fake *FakeHiveinternalV1alpha1
+	ns   string
+}
+
+var clustersyncleasesResource = schema.GroupVersionResource{Group: "hiveinternal.openshift.io", Version: "v1alpha1", Resource: "clustersyncleases"}
+
+var clustersyncleasesKind = schema.GroupVersionKind{Group: "hiveinternal.openshift.io", Version: "v1alpha1", Kind: "ClusterSyncLease"}
+
+// Get takes name of the clusterSyncLease, and returns the corresponding clusterSyncLease object, and an error if there is any.
+func (c *FakeClusterSyncLeases) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.ClusterSyncLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(clustersyncleasesResource, c.ns, name), &v1alpha1.ClusterSyncLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSyncLease), err
+}
+
+// List takes label and field selectors, and returns the list of ClusterSyncLeases that match those selectors.
+func (c *FakeClusterSyncLeases) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.ClusterSyncLeaseList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(clustersyncleasesResource, clustersyncleasesKind, c.ns, opts), &v1alpha1.ClusterSyncLeaseList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1alpha1.ClusterSyncLeaseList{ListMeta: obj.(*v1alpha1.ClusterSyncLeaseList).ListMeta}
+	for _, item := range obj.(*v1alpha1.ClusterSyncLeaseList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested clusterSyncLeases.
+func (c *FakeClusterSyncLeases) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(clustersyncleasesResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a clusterSyncLease and creates it.  Returns the server's representation of the clusterSyncLease, and an error, if there is any.
+func (c *FakeClusterSyncLeases) Create(ctx context.Context, clusterSyncLease *v1alpha1.ClusterSyncLease, opts v1.CreateOptions) (result *v1alpha1.ClusterSyncLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(clustersyncleasesResource, c.ns, clusterSyncLease), &v1alpha1.ClusterSyncLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSyncLease), err
+}
+
+// Update takes the representation of a clusterSyncLease and updates it. Returns the server's representation of the clusterSyncLease, and an error, if there is any.
+func (c *FakeClusterSyncLeases) Update(ctx context.Context, clusterSyncLease *v1alpha1.ClusterSyncLease, opts v1.UpdateOptions) (result *v1alpha1.ClusterSyncLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(clustersyncleasesResource, c.ns, clusterSyncLease), &v1alpha1.ClusterSyncLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSyncLease), err
+}
+
+// Delete takes name of the clusterSyncLease and deletes it. Returns an error if one occurs.
+func (c *FakeClusterSyncLeases) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(clustersyncleasesResource, c.ns, name, opts), &v1alpha1.ClusterSyncLease{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeClusterSyncLeases) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(clustersyncleasesResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &v1alpha1.ClusterSyncLeaseList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched clusterSyncLease.
+func (c *FakeClusterSyncLeases) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ClusterSyncLease, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(clustersyncleasesResource, c.ns, name, pt, data, subresources...), &v1alpha1.ClusterSyncLease{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.ClusterSyncLease), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_fakeclusterinstall.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_fakeclusterinstall.go
new file mode 100644
index 000000000..6a31b1a25
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_fakeclusterinstall.go
@@ -0,0 +1,126 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	v1alpha1 "github.com/openshift/hive/apis/hiveinternal/v1alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeFakeClusterInstalls implements FakeClusterInstallInterface
+type FakeFakeClusterInstalls struct {
+	Fake *FakeHiveinternalV1alpha1
+	ns   string
+}
+
+var fakeclusterinstallsResource = schema.GroupVersionResource{Group: "hiveinternal.openshift.io", Version: "v1alpha1", Resource: "fakeclusterinstalls"}
+
+var fakeclusterinstallsKind = schema.GroupVersionKind{Group: "hiveinternal.openshift.io", Version: "v1alpha1", Kind: "FakeClusterInstall"}
+
+// Get takes name of the fakeClusterInstall, and returns the corresponding fakeClusterInstall object, and an error if there is any.
+func (c *FakeFakeClusterInstalls) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.FakeClusterInstall, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(fakeclusterinstallsResource, c.ns, name), &v1alpha1.FakeClusterInstall{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.FakeClusterInstall), err
+}
+
+// List takes label and field selectors, and returns the list of FakeClusterInstalls that match those selectors.
+func (c *FakeFakeClusterInstalls) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.FakeClusterInstallList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(fakeclusterinstallsResource, fakeclusterinstallsKind, c.ns, opts), &v1alpha1.FakeClusterInstallList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1alpha1.FakeClusterInstallList{ListMeta: obj.(*v1alpha1.FakeClusterInstallList).ListMeta}
+	for _, item := range obj.(*v1alpha1.FakeClusterInstallList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested fakeClusterInstalls.
+func (c *FakeFakeClusterInstalls) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(fakeclusterinstallsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a fakeClusterInstall and creates it.  Returns the server's representation of the fakeClusterInstall, and an error, if there is any.
+func (c *FakeFakeClusterInstalls) Create(ctx context.Context, fakeClusterInstall *v1alpha1.FakeClusterInstall, opts v1.CreateOptions) (result *v1alpha1.FakeClusterInstall, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(fakeclusterinstallsResource, c.ns, fakeClusterInstall), &v1alpha1.FakeClusterInstall{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.FakeClusterInstall), err
+}
+
+// Update takes the representation of a fakeClusterInstall and updates it. Returns the server's representation of the fakeClusterInstall, and an error, if there is any.
+func (c *FakeFakeClusterInstalls) Update(ctx context.Context, fakeClusterInstall *v1alpha1.FakeClusterInstall, opts v1.UpdateOptions) (result *v1alpha1.FakeClusterInstall, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(fakeclusterinstallsResource, c.ns, fakeClusterInstall), &v1alpha1.FakeClusterInstall{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.FakeClusterInstall), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeFakeClusterInstalls) UpdateStatus(ctx context.Context, fakeClusterInstall *v1alpha1.FakeClusterInstall, opts v1.UpdateOptions) (*v1alpha1.FakeClusterInstall, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(fakeclusterinstallsResource, "status", c.ns, fakeClusterInstall), &v1alpha1.FakeClusterInstall{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.FakeClusterInstall), err
+}
+
+// Delete takes name of the fakeClusterInstall and deletes it. Returns an error if one occurs.
+func (c *FakeFakeClusterInstalls) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(fakeclusterinstallsResource, c.ns, name, opts), &v1alpha1.FakeClusterInstall{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeFakeClusterInstalls) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(fakeclusterinstallsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &v1alpha1.FakeClusterInstallList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched fakeClusterInstall.
+func (c *FakeFakeClusterInstalls) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.FakeClusterInstall, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(fakeclusterinstallsResource, c.ns, name, pt, data, subresources...), &v1alpha1.FakeClusterInstall{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.FakeClusterInstall), err
+}
diff --git a/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_hiveinternal_client.go b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_hiveinternal_client.go
new file mode 100644
index 000000000..44a719ec1
--- /dev/null
+++ b/vendor/github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake/fake_hiveinternal_client.go
@@ -0,0 +1,32 @@
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1alpha1 "github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeHiveinternalV1alpha1 struct {
+	*testing.Fake
+}
+
+func (c *FakeHiveinternalV1alpha1) ClusterSyncs(namespace string) v1alpha1.ClusterSyncInterface {
+	return &FakeClusterSyncs{c, namespace}
+}
+
+func (c *FakeHiveinternalV1alpha1) ClusterSyncLeases(namespace string) v1alpha1.ClusterSyncLeaseInterface {
+	return &FakeClusterSyncLeases{c, namespace}
+}
+
+func (c *FakeHiveinternalV1alpha1) FakeClusterInstalls(namespace string) v1alpha1.FakeClusterInstallInterface {
+	return &FakeFakeClusterInstalls{c, namespace}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeHiveinternalV1alpha1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index c38b1b401..dee8ec1b7 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1090,9 +1090,12 @@ github.com/openshift/console-operator/pkg/api
 # github.com/openshift/hive v1.1.16 => github.com/openshift/hive v1.1.17-0.20220719141355-c63c9b0281d8
 ## explicit; go 1.18
 github.com/openshift/hive/pkg/client/clientset/versioned
+github.com/openshift/hive/pkg/client/clientset/versioned/fake
 github.com/openshift/hive/pkg/client/clientset/versioned/scheme
 github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1
+github.com/openshift/hive/pkg/client/clientset/versioned/typed/hive/v1/fake
 github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1
+github.com/openshift/hive/pkg/client/clientset/versioned/typed/hiveinternal/v1alpha1/fake
 # github.com/openshift/hive/apis v0.0.0 => github.com/openshift/hive/apis v0.0.0-20220719141355-c63c9b0281d8
 ## explicit; go 1.18
 github.com/openshift/hive/apis/hive/v1


Test patch:
diff --git a/pkg/cluster/adminupdate_test.go b/pkg/cluster/adminupdate_test.go
index 70ca3fee7..4956dcfb0 100644
--- a/pkg/cluster/adminupdate_test.go
+++ b/pkg/cluster/adminupdate_test.go
@@ -92,6 +92,8 @@ func TestAdminUpdateSteps(t *testing.T) {
 				"[Action ensureAROOperatorRunningDesiredVersion-fm]",
 				"[Action hiveCreateNamespace-fm]",
 				"[Action hiveEnsureResources-fm]",
+				"[Condition hiveClusterDeploymentReady-fm, timeout 5m0s]",
+				"[Action hiveResetCorrelationData-fm]",
 				"[Action updateProvisionedBy-fm]",
 			},
 		},
@@ -134,6 +136,8 @@ func TestAdminUpdateSteps(t *testing.T) {
 				"[Action ensureAROOperatorRunningDesiredVersion-fm]",
 				"[Action hiveCreateNamespace-fm]",
 				"[Action hiveEnsureResources-fm]",
+				"[Condition hiveClusterDeploymentReady-fm, timeout 5m0s]",
+				"[Action hiveResetCorrelationData-fm]",
 				"[Action updateProvisionedBy-fm]",
 			},
 		},
diff --git a/pkg/cluster/hive_test.go b/pkg/cluster/hive_test.go
new file mode 100644
index 000000000..a870472f1
--- /dev/null
+++ b/pkg/cluster/hive_test.go
@@ -0,0 +1,160 @@
+package cluster
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the Apache License 2.0.
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/sirupsen/logrus"
+
+	"github.com/Azure/ARO-RP/pkg/api"
+	"github.com/Azure/ARO-RP/pkg/hive"
+	mock_hive "github.com/Azure/ARO-RP/pkg/util/mocks/hive"
+)
+
+func TestHiveClusterDeploymentReady(t *testing.T) {
+	fakeNamespace := "fake-namespace"
+
+	for _, tt := range []struct {
+		name  string
+		mocks func(hiveMock *mock_hive.MockClusterManager)
+		// TODO(hive): remove wantSkip and all test cases with wantSkip=True once we have Hive everywhere
+		wantSkip   bool
+		wantResult bool
+		wantErr    string
+	}{
+		{
+			name: "ready",
+			mocks: func(hiveMock *mock_hive.MockClusterManager) {
+				hiveMock.EXPECT().IsClusterDeploymentReady(gomock.Any(), fakeNamespace).Return(true, nil)
+			},
+			wantResult: true,
+		},
+		{
+			name: "not ready",
+			mocks: func(hiveMock *mock_hive.MockClusterManager) {
+				hiveMock.EXPECT().IsClusterDeploymentReady(gomock.Any(), fakeNamespace).Return(false, nil)
+			},
+			wantResult: false,
+		},
+		{
+			name: "error",
+			mocks: func(hiveMock *mock_hive.MockClusterManager) {
+				hiveMock.EXPECT().IsClusterDeploymentReady(gomock.Any(), fakeNamespace).Return(false, errors.New("fake err"))
+			},
+			wantResult: false,
+			wantErr:    "fake err",
+		},
+		{
+			name:       "skip",
+			wantSkip:   true,
+			wantResult: true,
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			controller := gomock.NewController(t)
+			defer controller.Finish()
+
+			var hiveClusterManager hive.ClusterManager
+			if !tt.wantSkip {
+				hiveMock := mock_hive.NewMockClusterManager(controller)
+				hiveClusterManager = hiveMock
+				if tt.mocks != nil {
+					tt.mocks(hiveMock)
+				}
+			}
+
+			m := &manager{
+				log: logrus.NewEntry(logrus.StandardLogger()),
+				doc: &api.OpenShiftClusterDocument{
+					OpenShiftCluster: &api.OpenShiftCluster{
+						Properties: api.OpenShiftClusterProperties{
+							HiveProfile: api.HiveProfile{
+								Namespace: fakeNamespace,
+							},
+						},
+					},
+				},
+				hiveClusterManager: hiveClusterManager,
+			}
+
+			result, err := m.hiveClusterDeploymentReady(context.Background())
+			if err != nil && err.Error() != tt.wantErr ||
+				err == nil && tt.wantErr != "" {
+				t.Error(err)
+			}
+
+			if tt.wantResult != result {
+				t.Error(result)
+			}
+		})
+	}
+}
+
+func TestHiveResetCorrelationData(t *testing.T) {
+	fakeNamespace := "fake-namespace"
+
+	for _, tt := range []struct {
+		name  string
+		mocks func(hiveMock *mock_hive.MockClusterManager)
+		// TODO(hive): remove wantSkip and all test cases with wantSkip=True once we have Hive everywhere
+		wantSkip bool
+		wantErr  string
+	}{
+		{
+			name: "success",
+			mocks: func(hiveMock *mock_hive.MockClusterManager) {
+				hiveMock.EXPECT().ResetCorrelationData(gomock.Any(), fakeNamespace).Return(nil)
+			},
+		},
+		{
+			name: "error",
+			mocks: func(hiveMock *mock_hive.MockClusterManager) {
+				hiveMock.EXPECT().ResetCorrelationData(gomock.Any(), fakeNamespace).Return(errors.New("fake err"))
+			},
+			wantErr: "fake err",
+		},
+		{
+			name:     "skip",
+			wantSkip: true,
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			controller := gomock.NewController(t)
+			defer controller.Finish()
+
+			var hiveClusterManager hive.ClusterManager
+			if !tt.wantSkip {
+				hiveMock := mock_hive.NewMockClusterManager(controller)
+				hiveClusterManager = hiveMock
+				if tt.mocks != nil {
+					tt.mocks(hiveMock)
+				}
+			}
+
+			m := &manager{
+				log: logrus.NewEntry(logrus.StandardLogger()),
+				doc: &api.OpenShiftClusterDocument{
+					OpenShiftCluster: &api.OpenShiftCluster{
+						Properties: api.OpenShiftClusterProperties{
+							HiveProfile: api.HiveProfile{
+								Namespace: fakeNamespace,
+							},
+						},
+					},
+				},
+				hiveClusterManager: hiveClusterManager,
+			}
+
+			err := m.hiveResetCorrelationData(context.Background())
+			if err != nil && err.Error() != tt.wantErr ||
+				err == nil && tt.wantErr != "" {
+				t.Error(err)
+			}
+		})
+	}
+}
diff --git a/pkg/hive/manager_test.go b/pkg/hive/manager_test.go
new file mode 100644
index 000000000..6a93d8c9d
--- /dev/null
+++ b/pkg/hive/manager_test.go
@@ -0,0 +1,160 @@
+package hive
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the Apache License 2.0.
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+	hivefake "github.com/openshift/hive/pkg/client/clientset/versioned/fake"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	kruntime "k8s.io/apimachinery/pkg/runtime"
+
+	"github.com/Azure/ARO-RP/pkg/util/cmp"
+)
+
+func TestIsClusterDeploymentReady(t *testing.T) {
+	fakeNamespace := "fake-namespace"
+
+	for _, tt := range []struct {
+		name       string
+		cd         kruntime.Object
+		wantResult bool
+		wantErr    string
+	}{
+		{
+			name: "is ready",
+			cd: &hivev1.ClusterDeployment{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      ClusterDeploymentName,
+					Namespace: fakeNamespace,
+				},
+				Status: hivev1.ClusterDeploymentStatus{
+					Conditions: []hivev1.ClusterDeploymentCondition{
+						{
+							Type:   hivev1.ClusterReadyCondition,
+							Status: corev1.ConditionTrue,
+						},
+					},
+				},
+			},
+			wantResult: true,
+		},
+		{
+			name: "is not ready",
+			cd: &hivev1.ClusterDeployment{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      ClusterDeploymentName,
+					Namespace: fakeNamespace,
+				},
+				Status: hivev1.ClusterDeploymentStatus{
+					Conditions: []hivev1.ClusterDeploymentCondition{
+						{
+							Type:   hivev1.ClusterReadyCondition,
+							Status: corev1.ConditionFalse,
+						},
+					},
+				},
+			},
+			wantResult: false,
+		},
+		{
+			name: "is not ready - condition is missing",
+			cd: &hivev1.ClusterDeployment{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      ClusterDeploymentName,
+					Namespace: fakeNamespace,
+				},
+			},
+			wantResult: false,
+		},
+		{
+			name:       "error - ClusterDeployment is missing",
+			wantResult: false,
+			wantErr:    "clusterdeployments.hive.openshift.io \"cluster\" not found",
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			fakeClientset := hivefake.NewSimpleClientset()
+			if tt.cd != nil {
+				fakeClientset.Tracker().Add(tt.cd)
+			}
+			c := clusterManager{
+				hiveClientset: fakeClientset,
+			}
+
+			result, err := c.IsClusterDeploymentReady(context.Background(), fakeNamespace)
+			if err != nil && err.Error() != tt.wantErr ||
+				err == nil && tt.wantErr != "" {
+				t.Error(err)
+			}
+
+			if tt.wantResult != result {
+				t.Error(result)
+			}
+		})
+	}
+}
+
+func TestResetCorrelationData(t *testing.T) {
+	fakeNamespace := "fake-namespace"
+
+	for _, tt := range []struct {
+		name            string
+		cd              kruntime.Object
+		wantAnnotations map[string]string
+		wantErr         string
+	}{
+		{
+			name: "success",
+			cd: &hivev1.ClusterDeployment{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      ClusterDeploymentName,
+					Namespace: fakeNamespace,
+					Annotations: map[string]string{
+						"hive.openshift.io/additional-log-fields": `{
+							"correlation_id": "existing-fake-correlation-id"
+						}`,
+					},
+				},
+			},
+			wantAnnotations: map[string]string{
+				"hive.openshift.io/additional-log-fields": "{}",
+			},
+		},
+		{
+			name:    "error - ClusterDeployment is missing",
+			wantErr: "clusterdeployments.hive.openshift.io \"cluster\" not found",
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			fakeClientset := hivefake.NewSimpleClientset()
+			if tt.cd != nil {
+				fakeClientset.Tracker().Add(tt.cd)
+			}
+			c := clusterManager{
+				hiveClientset: fakeClientset,
+			}
+
+			err := c.ResetCorrelationData(context.Background(), fakeNamespace)
+			if err != nil && err.Error() != tt.wantErr ||
+				err == nil && tt.wantErr != "" {
+				t.Error(err)
+			}
+
+			if err == nil {
+				cd, err := c.hiveClientset.HiveV1().ClusterDeployments(fakeNamespace).Get(context.Background(), ClusterDeploymentName, metav1.GetOptions{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !reflect.DeepEqual(tt.wantAnnotations, cd.Annotations) {
+					t.Error(cmp.Diff(tt.wantAnnotations, cd.Annotations))
+				}
+			}
+		})
+	}
+}
diff --git a/pkg/util/log/hive_test.go b/pkg/util/log/hive_test.go
new file mode 100644
index 000000000..17c383d04
--- /dev/null
+++ b/pkg/util/log/hive_test.go
@@ -0,0 +1,220 @@
+package log
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the Apache License 2.0.
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+
+	hivev1 "github.com/openshift/hive/apis/hive/v1"
+
+	"github.com/Azure/ARO-RP/pkg/api"
+	"github.com/Azure/ARO-RP/pkg/util/cmp"
+)
+
+func TestEnrichHiveWithCorrelationData(t *testing.T) {
+	for _, tt := range []struct {
+		name            string
+		correlationData *api.CorrelationData
+		existingFields  bool
+		wantLogFields   map[string]string
+	}{
+		{
+			name: "correlation data provided, no existing fields on ClusterDeployment",
+			correlationData: &api.CorrelationData{
+				CorrelationID:       "fake-correlation-id",
+				ClientRequestID:     "fake-client-request-id",
+				RequestID:           "fake-request-id",
+				ClientPrincipalName: "fake-client-principal-name",
+				RequestTime:         time.Now(),
+			},
+			wantLogFields: map[string]string{
+				"correlation_id":        "fake-correlation-id",
+				"client_request_id":     "fake-client-request-id",
+				"request_id":            "fake-request-id",
+				"client_principal_name": "fake-client-principal-name",
+			},
+		},
+		{
+			name:           "correlation data provided, existing fields are on ClusterDeployment - override",
+			existingFields: true,
+			correlationData: &api.CorrelationData{
+				CorrelationID:       "fake-correlation-id",
+				ClientRequestID:     "fake-client-request-id",
+				RequestID:           "fake-request-id",
+				ClientPrincipalName: "fake-client-principal-name",
+				RequestTime:         time.Now(),
+			},
+			wantLogFields: map[string]string{
+				"correlation_id":        "fake-correlation-id",
+				"client_request_id":     "fake-client-request-id",
+				"request_id":            "fake-request-id",
+				"client_principal_name": "fake-client-principal-name",
+				"fake_existing_field":   "existing-fake-value",
+			},
+		},
+		{
+			name:           "correlation data was not provided, existing fields are on ClusterDeployment",
+			existingFields: true,
+			wantLogFields: map[string]string{
+				"correlation_id":      "existing-fake-correlation-id",
+				"fake_existing_field": "existing-fake-value",
+			},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			cd := &hivev1.ClusterDeployment{}
+			if tt.existingFields {
+				cd.Annotations = map[string]string{
+					additionalLogFieldsAnnotation: `{
+						"fake_existing_field": "existing-fake-value",
+						"correlation_id": "existing-fake-correlation-id"
+					}`,
+				}
+			}
+
+			err := EnrichHiveWithCorrelationData(cd, tt.correlationData)
+			if err != nil {
+				t.Error(err)
+			}
+
+			var actualLogFields map[string]string
+			if val := cd.Annotations[additionalLogFieldsAnnotation]; val != "" {
+				err := json.Unmarshal([]byte(val), &actualLogFields)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if !reflect.DeepEqual(actualLogFields, tt.wantLogFields) {
+				t.Error(cmp.Diff(actualLogFields, tt.wantLogFields))
+			}
+		})
+	}
+}
+
+func TestResetHiveCorrelationData(t *testing.T) {
+	for _, tt := range []struct {
+		name           string
+		existingFields bool
+		wantLogFields  map[string]string
+		wantErr        string
+	}{
+		{
+			name:           "removes existing fields",
+			existingFields: true,
+			wantLogFields: map[string]string{
+				"fake_field_1": "existing-fake-field-1-value",
+			},
+		},
+		{
+			name:          "removes non-existing fields",
+			wantLogFields: map[string]string{},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			cd := &hivev1.ClusterDeployment{}
+			if tt.existingFields {
+				cd.Annotations = map[string]string{
+					additionalLogFieldsAnnotation: `{
+						"correlation_id":        "existing-fake-correlation-id",
+						"client_request_id":     "existing-fake-client-request-id",
+						"request_id":            "existing-fake-request-id",
+						"client_principal_name": "existing-fake-client-principal-name",
+						"fake_field_1":          "existing-fake-field-1-value"
+					}`,
+				}
+			}
+
+			err := ResetHiveCorrelationData(cd)
+			if err != nil && err.Error() != tt.wantErr ||
+				err == nil && tt.wantErr != "" {
+				t.Error(err)
+			}
+
+			var actualLogFields map[string]string
+			if val := cd.Annotations[additionalLogFieldsAnnotation]; val != "" {
+				err := json.Unmarshal([]byte(val), &actualLogFields)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if !reflect.DeepEqual(actualLogFields, tt.wantLogFields) {
+				t.Error(cmp.Diff(actualLogFields, tt.wantLogFields))
+			}
+		})
+	}
+}
+
+func TestEnrichHiveWithResourceID(t *testing.T) {
+	fakeResourceIDWithMixedCaps := "/subscriptions/0000000F-000f-0000-0000-000000000000/resoUrCegroups/resOurceGroup/providers/microsoft.redhatopenshift/openshiftclusters/rESourceName"
+
+	for _, tt := range []struct {
+		name           string
+		resourceID     string
+		existingFields bool
+		wantLogFields  map[string]string
+		wantErr        string
+	}{
+		{
+			name:       "resource id provided, no existing fields on ClusterDeployment",
+			resourceID: fakeResourceIDWithMixedCaps,
+			wantLogFields: map[string]string{
+				"resource_group":  "resourcegroup",
+				"resource_id":     "/subscriptions/0000000f-000f-0000-0000-000000000000/resourcegroups/resourcegroup/providers/microsoft.redhatopenshift/openshiftclusters/resourcename",
+				"resource_name":   "resourcename",
+				"subscription_id": "0000000f-000f-0000-0000-000000000000",
+			},
+		},
+		{
+			name:           "resource id provided, existing fields are on ClusterDeployment - override",
+			existingFields: true,
+			resourceID:     fakeResourceIDWithMixedCaps,
+			wantLogFields: map[string]string{
+				"resource_group":      "resourcegroup",
+				"resource_id":         "/subscriptions/0000000f-000f-0000-0000-000000000000/resourcegroups/resourcegroup/providers/microsoft.redhatopenshift/openshiftclusters/resourcename",
+				"resource_name":       "resourcename",
+				"subscription_id":     "0000000f-000f-0000-0000-000000000000",
+				"fake_existing_field": "existing-fake-value",
+			},
+		},
+		{
+			name:    "invalid resource id was provided",
+			wantErr: "parsing failed for . Invalid resource Id format",
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			cd := &hivev1.ClusterDeployment{}
+			if tt.existingFields {
+				cd.Annotations = map[string]string{
+					additionalLogFieldsAnnotation: `{
+						"fake_existing_field": "existing-fake-value",
+						"resource_id":         "existing-fake-resource-id"
+					}`,
+				}
+			}
+
+			err := EnrichHiveWithResourceID(cd, tt.resourceID)
+			if err != nil && err.Error() != tt.wantErr ||
+				err == nil && tt.wantErr != "" {
+				t.Error(err)
+			}
+
+			var actualLogFields map[string]string
+			if val := cd.Annotations[additionalLogFieldsAnnotation]; val != "" {
+				err := json.Unmarshal([]byte(val), &actualLogFields)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if !reflect.DeepEqual(actualLogFields, tt.wantLogFields) {
+				t.Error(cmp.Diff(actualLogFields, tt.wantLogFields))
+			}
+		})
+	}
+}