Skip to content

Commit

Permalink
refactor: duplicated package imported
Browse files Browse the repository at this point in the history 
Signed-off-by: Chin-Ya Huang <chin-ya.huang@suse.com>
  • Loading branch information
@c3y1huang
c3y1huang authored and David Ko committed Aug 21, 2023
1 parent acb922e commit 30776e5
Showing 1 changed file with 51 additions and 52 deletions.
103 changes: 51 additions & 52 deletions upgrade/util/util.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,7 +21,6 @@ import (
"k8s.io/apimachinery/pkg/labels"
clientset "k8s.io/client-go/kubernetes"

"github.com/longhorn/longhorn-manager/k8s/pkg/apis/longhorn/v1beta2"
longhorn "github.com/longhorn/longhorn-manager/k8s/pkg/apis/longhorn/v1beta2"
lhclientset "github.com/longhorn/longhorn-manager/k8s/pkg/client/clientset/versioned"
"github.com/longhorn/longhorn-manager/meta"
Expand Down Expand Up @@ -280,18 +279,18 @@ func removeFirstChar(v string) string {
}

// ListAndUpdateSettingsInProvidedCache list all settings and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateSettingsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Setting, error) {
func ListAndUpdateSettingsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Setting, error) {
if v, ok := resourceMaps[types.LonghornKindSetting]; ok {
return v.(map[string]*v1beta2.Setting), nil
return v.(map[string]*longhorn.Setting), nil
}

settings := map[string]*v1beta2.Setting{}
settings := map[string]*longhorn.Setting{}
settingList, err := lhClient.LonghornV1beta2().Settings(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
}
for _, setting := range settingList.Items {
settingCopy := v1beta2.Setting{}
settingCopy := longhorn.Setting{}
if err := copier.Copy(&settingCopy, setting); err != nil {
return nil, err
}
Expand All @@ -304,12 +303,12 @@ func ListAndUpdateSettingsInProvidedCache(namespace string, lhClient *lhclientse
}

// ListAndUpdateNodesInProvidedCache list all nodes and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateNodesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Node, error) {
func ListAndUpdateNodesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Node, error) {
if v, ok := resourceMaps[types.LonghornKindNode]; ok {
return v.(map[string]*v1beta2.Node), nil
return v.(map[string]*longhorn.Node), nil
}

nodes := map[string]*v1beta2.Node{}
nodes := map[string]*longhorn.Node{}
nodeList, err := lhClient.LonghornV1beta2().Nodes(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -324,12 +323,12 @@ func ListAndUpdateNodesInProvidedCache(namespace string, lhClient *lhclientset.C
}

// ListAndUpdateOrphansInProvidedCache list all orphans and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateOrphansInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Orphan, error) {
func ListAndUpdateOrphansInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Orphan, error) {
if v, ok := resourceMaps[types.LonghornKindOrphan]; ok {
return v.(map[string]*v1beta2.Orphan), nil
return v.(map[string]*longhorn.Orphan), nil
}

orphans := map[string]*v1beta2.Orphan{}
orphans := map[string]*longhorn.Orphan{}
orphanList, err := lhClient.LonghornV1beta2().Orphans(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -344,12 +343,12 @@ func ListAndUpdateOrphansInProvidedCache(namespace string, lhClient *lhclientset
}

// ListAndUpdateInstanceManagersInProvidedCache list all instanceManagers and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateInstanceManagersInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.InstanceManager, error) {
func ListAndUpdateInstanceManagersInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.InstanceManager, error) {
if v, ok := resourceMaps[types.LonghornKindInstanceManager]; ok {
return v.(map[string]*v1beta2.InstanceManager), nil
return v.(map[string]*longhorn.InstanceManager), nil
}

ims := map[string]*v1beta2.InstanceManager{}
ims := map[string]*longhorn.InstanceManager{}
imList, err := lhClient.LonghornV1beta2().InstanceManagers(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -364,12 +363,12 @@ func ListAndUpdateInstanceManagersInProvidedCache(namespace string, lhClient *lh
}

// ListAndUpdateVolumesInProvidedCache list all volumes and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateVolumesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Volume, error) {
func ListAndUpdateVolumesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Volume, error) {
if v, ok := resourceMaps[types.LonghornKindVolume]; ok {
return v.(map[string]*v1beta2.Volume), nil
return v.(map[string]*longhorn.Volume), nil
}

volumes := map[string]*v1beta2.Volume{}
volumes := map[string]*longhorn.Volume{}
volumeList, err := lhClient.LonghornV1beta2().Volumes(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -384,12 +383,12 @@ func ListAndUpdateVolumesInProvidedCache(namespace string, lhClient *lhclientset
}

// ListAndUpdateReplicasInProvidedCache list all replicas and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateReplicasInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Replica, error) {
func ListAndUpdateReplicasInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Replica, error) {
if v, ok := resourceMaps[types.LonghornKindReplica]; ok {
return v.(map[string]*v1beta2.Replica), nil
return v.(map[string]*longhorn.Replica), nil
}

replicas := map[string]*v1beta2.Replica{}
replicas := map[string]*longhorn.Replica{}
replicaList, err := lhClient.LonghornV1beta2().Replicas(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -404,12 +403,12 @@ func ListAndUpdateReplicasInProvidedCache(namespace string, lhClient *lhclientse
}

// ListAndUpdateEnginesInProvidedCache list all engines and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateEnginesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Engine, error) {
func ListAndUpdateEnginesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Engine, error) {
if v, ok := resourceMaps[types.LonghornKindEngine]; ok {
return v.(map[string]*v1beta2.Engine), nil
return v.(map[string]*longhorn.Engine), nil
}

engines := map[string]*v1beta2.Engine{}
engines := map[string]*longhorn.Engine{}
engineList, err := lhClient.LonghornV1beta2().Engines(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -424,12 +423,12 @@ func ListAndUpdateEnginesInProvidedCache(namespace string, lhClient *lhclientset
}

// ListAndUpdateBackupsInProvidedCache list all backups and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateBackupsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Backup, error) {
func ListAndUpdateBackupsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Backup, error) {
if v, ok := resourceMaps[types.LonghornKindBackup]; ok {
return v.(map[string]*v1beta2.Backup), nil
return v.(map[string]*longhorn.Backup), nil
}

backups := map[string]*v1beta2.Backup{}
backups := map[string]*longhorn.Backup{}
backupList, err := lhClient.LonghornV1beta2().Backups(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -444,12 +443,12 @@ func ListAndUpdateBackupsInProvidedCache(namespace string, lhClient *lhclientset
}

// ListAndUpdateSnapshotsInProvidedCache list all snapshots and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateSnapshotsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.Snapshot, error) {
func ListAndUpdateSnapshotsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.Snapshot, error) {
if v, ok := resourceMaps[types.LonghornKindSnapshot]; ok {
return v.(map[string]*v1beta2.Snapshot), nil
return v.(map[string]*longhorn.Snapshot), nil
}

snapshots := map[string]*v1beta2.Snapshot{}
snapshots := map[string]*longhorn.Snapshot{}
snapshotList, err := lhClient.LonghornV1beta2().Snapshots(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -464,12 +463,12 @@ func ListAndUpdateSnapshotsInProvidedCache(namespace string, lhClient *lhclients
}

// ListAndUpdateEngineImagesInProvidedCache list all engineImages and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateEngineImagesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.EngineImage, error) {
func ListAndUpdateEngineImagesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.EngineImage, error) {
if v, ok := resourceMaps[types.LonghornKindEngineImage]; ok {
return v.(map[string]*v1beta2.EngineImage), nil
return v.(map[string]*longhorn.EngineImage), nil
}

eis := map[string]*v1beta2.EngineImage{}
eis := map[string]*longhorn.EngineImage{}
eiList, err := lhClient.LonghornV1beta2().EngineImages(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -484,12 +483,12 @@ func ListAndUpdateEngineImagesInProvidedCache(namespace string, lhClient *lhclie
}

// ListAndUpdateShareManagersInProvidedCache list all shareManagers and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateShareManagersInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.ShareManager, error) {
func ListAndUpdateShareManagersInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.ShareManager, error) {
if v, ok := resourceMaps[types.LonghornKindShareManager]; ok {
return v.(map[string]*v1beta2.ShareManager), nil
return v.(map[string]*longhorn.ShareManager), nil
}

sms := map[string]*v1beta2.ShareManager{}
sms := map[string]*longhorn.ShareManager{}
smList, err := lhClient.LonghornV1beta2().ShareManagers(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -504,12 +503,12 @@ func ListAndUpdateShareManagersInProvidedCache(namespace string, lhClient *lhcli
}

// ListAndUpdateBackingImagesInProvidedCache list all backingImages and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateBackingImagesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.BackingImage, error) {
func ListAndUpdateBackingImagesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.BackingImage, error) {
if v, ok := resourceMaps[types.LonghornKindBackingImage]; ok {
return v.(map[string]*v1beta2.BackingImage), nil
return v.(map[string]*longhorn.BackingImage), nil
}

bis := map[string]*v1beta2.BackingImage{}
bis := map[string]*longhorn.BackingImage{}
biList, err := lhClient.LonghornV1beta2().BackingImages(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -524,12 +523,12 @@ func ListAndUpdateBackingImagesInProvidedCache(namespace string, lhClient *lhcli
}

// ListAndUpdateBackingImageDataSourcesInProvidedCache list all backingImageDataSources and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateBackingImageDataSourcesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.BackingImageDataSource, error) {
func ListAndUpdateBackingImageDataSourcesInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.BackingImageDataSource, error) {
if v, ok := resourceMaps[types.LonghornKindBackingImageDataSource]; ok {
return v.(map[string]*v1beta2.BackingImageDataSource), nil
return v.(map[string]*longhorn.BackingImageDataSource), nil
}

bidss := map[string]*v1beta2.BackingImageDataSource{}
bidss := map[string]*longhorn.BackingImageDataSource{}
bidsList, err := lhClient.LonghornV1beta2().BackingImageDataSources(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -544,12 +543,12 @@ func ListAndUpdateBackingImageDataSourcesInProvidedCache(namespace string, lhCli
}

// ListAndUpdateRecurringJobsInProvidedCache list all recurringJobs and save them into the provided cached `resourceMap`. This method is not thread-safe.
func ListAndUpdateRecurringJobsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*v1beta2.RecurringJob, error) {
func ListAndUpdateRecurringJobsInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}) (map[string]*longhorn.RecurringJob, error) {
if v, ok := resourceMaps[types.LonghornKindRecurringJob]; ok {
return v.(map[string]*v1beta2.RecurringJob), nil
return v.(map[string]*longhorn.RecurringJob), nil
}

recurringJobs := map[string]*v1beta2.RecurringJob{}
recurringJobs := map[string]*longhorn.RecurringJob{}
recurringJobList, err := lhClient.LonghornV1beta2().RecurringJobs(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
Expand All @@ -564,17 +563,17 @@ func ListAndUpdateRecurringJobsInProvidedCache(namespace string, lhClient *lhcli
}

// CreateAndUpdateRecurringJobInProvidedCache creates a recurringJob and saves it into the provided cached `resourceMap`. This method is not thread-safe.
func CreateAndUpdateRecurringJobInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}, job *longhorn.RecurringJob) (*v1beta2.RecurringJob, error) {
func CreateAndUpdateRecurringJobInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}, job *longhorn.RecurringJob) (*longhorn.RecurringJob, error) {
obj, err := lhClient.LonghornV1beta2().RecurringJobs(namespace).Create(context.TODO(), job, metav1.CreateOptions{})
if err != nil {
return obj, err
}

var recurringJobs map[string]*v1beta2.RecurringJob
var recurringJobs map[string]*longhorn.RecurringJob
if v, ok := resourceMaps[types.LonghornKindRecurringJob]; ok {
recurringJobs = v.(map[string]*v1beta2.RecurringJob)
recurringJobs = v.(map[string]*longhorn.RecurringJob)
} else {
recurringJobs = map[string]*v1beta2.RecurringJob{}
recurringJobs = map[string]*longhorn.RecurringJob{}
}
recurringJobs[job.Name] = obj

Expand All @@ -584,17 +583,17 @@ func CreateAndUpdateRecurringJobInProvidedCache(namespace string, lhClient *lhcl
}

// CreateAndUpdateBackingImageInProvidedCache creates a backingImage and saves it into the provided cached `resourceMap`. This method is not thread-safe.
func CreateAndUpdateBackingImageInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}, bid *longhorn.BackingImageDataSource) (*v1beta2.BackingImageDataSource, error) {
func CreateAndUpdateBackingImageInProvidedCache(namespace string, lhClient *lhclientset.Clientset, resourceMaps map[string]interface{}, bid *longhorn.BackingImageDataSource) (*longhorn.BackingImageDataSource, error) {
obj, err := lhClient.LonghornV1beta2().BackingImageDataSources(namespace).Create(context.TODO(), bid, metav1.CreateOptions{})
if err != nil {
return obj, err
}

var bids map[string]*v1beta2.BackingImageDataSource
var bids map[string]*longhorn.BackingImageDataSource
if v, ok := resourceMaps[types.LonghornKindBackingImageDataSource]; ok {
bids = v.(map[string]*v1beta2.BackingImageDataSource)
bids = v.(map[string]*longhorn.BackingImageDataSource)
} else {
bids = map[string]*v1beta2.BackingImageDataSource{}
bids = map[string]*longhorn.BackingImageDataSource{}
}
bids[bid.Name] = obj

Expand Down

0 comments on commit 30776e5

Please sign in to comment.