climc: refactor k8s resource

cmd/climc/shell/k8s/clusters.go

@@ -188,6 +188,19 @@ func initKubeCluster() {
 		return nil
 	})
 
+	R(&o.ClusterSyncOptions{}, cmdN("sync"), "Sync cluster k8s resources", func(s *mcclient.ClientSession, args *o.ClusterSyncOptions) error {
+		param, err := args.Params()
+		if err != nil {
+			return err
+		}
+		ret, err := k8s.KubeClusters.PerformAction(s, args.ID, "sync", param)
+		if err != nil {
+			return err
+		}
+		printObject(ret)
+		return nil
+	})
+
 	R(&o.IdentOptions{}, cmdN("public"), "Make cluster public", func(s *mcclient.ClientSession, args *o.IdentOptions) error {
 		ret, err := k8s.KubeClusters.PerformAction(s, args.ID, "public", nil)
 		if err != nil {

cmd/climc/shell/k8s/k8s.go

@@ -43,7 +43,6 @@ func init() {
 	initRepo()
 	initChart()
 	initRelease()
-	initReleaseApps()
 
 	// kubernetes original resources
 	initRaw()

cmd/climc/shell/k8s/list.go

@@ -30,7 +30,7 @@ import (
 )
 
 func getPrinterRowValue(printer k8s.ListPrinter, obj jsonutils.JSONObject, col string) interface{} {
-	getFuncName := fmt.Sprintf("Get%s", strings.Title(col))
+	getFuncName := fmt.Sprintf("Get_%s", strings.Title(col))
 	manValue := reflect.ValueOf(printer)
 	funcValue := manValue.MethodByName(getFuncName)
 	if !funcValue.IsValid() || funcValue.IsNil() {

cmd/climc/shell/k8s/rbac.go

@@ -22,8 +22,10 @@ import (
 
 func initRbac() {
 	//cmdRole := initK8sNamespaceResource("rbacrole", k8s.RbacRoles)
-	initK8sNamespaceResource("rbacrole", k8s.RbacRoles)
-	initK8sNamespaceResource("rbacrolebinding", k8s.RbacRoleBindings)
+	initK8sNamespaceResource("rbac-role", k8s.RbacRoles)
+	initK8sNamespaceResource("rbac-rolebinding", k8s.RbacRoleBindings)
+	initK8sClusterResource("rbac-clusterrole", k8s.RbacClusterRoles)
+	initK8sClusterResource("rbac-clusterrolebinding", k8s.RbacClusterRoleBindings)
 	initK8sNamespaceResource("serviceaccount", k8s.ServiceAccounts)
 	//cmdRoleN := cmdRole.CommandNameFactory
 }

pkg/mcclient/modules/k8s/base.go

@@ -45,50 +45,50 @@ type IClusterResourceManager interface {
 	UpdateRaw(s *mcclient.ClientSession, id string, query, body *jsonutils.JSONDict) (jsonutils.JSONObject, error)
 }
 
-type ClusterResourceManager struct {
+type clusterResourceManager struct {
 	*ResourceManager
 }
 
-func NewClusterResourceManager(keyword, keywordPlural string, columns, adminColumns *Columns) *ClusterResourceManager {
+func newClusterResourceManager(keyword, keywordPlural string, columns, adminColumns *Columns) *clusterResourceManager {
 	newAdminCols := NewClusterCols(adminColumns.Array()...)
 	man := NewResourceManager(keyword, keywordPlural, columns, newAdminCols)
-	return &ClusterResourceManager{man}
+	return &clusterResourceManager{man}
 }
 
-func (man ClusterResourceManager) GetCluster(obj jsonutils.JSONObject) interface{} {
+func (man clusterResourceManager) Get_Cluster(obj jsonutils.JSONObject) interface{} {
 	cluster, _ := obj.GetString("cluster")
 	return cluster
 }
 
-func (man ClusterResourceManager) GetRaw(s *mcclient.ClientSession, id string, params *jsonutils.JSONDict) (jsonutils.JSONObject, error) {
+func (man clusterResourceManager) GetRaw(s *mcclient.ClientSession, id string, params *jsonutils.JSONDict) (jsonutils.JSONObject, error) {
 	return man.GetSpecific(s, id, "rawdata", params)
 }
 
-func (man ClusterResourceManager) UpdateRaw(s *mcclient.ClientSession, id string, query, rawdata *jsonutils.JSONDict) (jsonutils.JSONObject, error) {
+func (man clusterResourceManager) UpdateRaw(s *mcclient.ClientSession, id string, query, rawdata *jsonutils.JSONDict) (jsonutils.JSONObject, error) {
 	return man.PutSpecific(s, id, "rawdata", query, rawdata)
 }
 
-type MetaResourceManager struct {
-	*ClusterResourceManager
+type ClusterResourceManager struct {
+	*clusterResourceManager
 	nameGetter
 	ageGetter
 	labelGetter
 }
 
-func NewMetaResourceManager(kw, kwp string, columns, adminColumns *Columns) *MetaResourceManager {
+func NewClusterResourceManager(kw, kwp string, columns, adminColumns *Columns) *ClusterResourceManager {
 	newCols := NewMetaCols(columns.Array()...)
-	man := NewClusterResourceManager(kw, kwp, newCols, adminColumns)
-	return &MetaResourceManager{man, getName, getAge, getLabel}
+	man := newClusterResourceManager(kw, kwp, newCols, adminColumns)
+	return &ClusterResourceManager{man, getName, getAge, getLabel}
 }
 
 type NamespaceResourceManager struct {
-	*MetaResourceManager
+	*ClusterResourceManager
 	namespaceGetter
 }
 
 func NewNamespaceResourceManager(kw, kwp string, columns, adminColumns *Columns) *NamespaceResourceManager {
 	newCols := NewNamespaceCols(columns.Array()...)
-	man := NewMetaResourceManager(kw, kwp, newCols, adminColumns)
+	man := NewClusterResourceManager(kw, kwp, newCols, adminColumns)
 	return &NamespaceResourceManager{man, getNamespace}
 }
 
@@ -138,7 +138,7 @@ func NewClusterCols(col ...string) *Columns {
 }
 
 func NewResourceCols(col ...string) *Columns {
-	return NewNameCols("Id").Add(col...)
+	return NewNameCols("ID").Add(col...)
 }
 
 type ListPrinter interface {

pkg/mcclient/modules/k8s/cluster.go

@@ -25,6 +25,6 @@ var (
 func init() {
 	KubeClusters = NewResourceManager("kubecluster", "kubeclusters",
 		NewResourceCols("cluster_type", "resource_type", "cloud_type", "version", "status", "mode", "provider", "machines"),
-		NewColumns())
+		NewColumns("sync_status", "sync_message"))
 	modules.Register(KubeClusters)
 }

pkg/mcclient/modules/k8s/event.go

@@ -46,22 +46,22 @@ func init() {
 	modules.Register(Events)
 }
 
-func (m EventManager) GetSource(obj jsonutils.JSONObject) interface{} {
+func (m EventManager) Get_Source(obj jsonutils.JSONObject) interface{} {
 	src, _ := obj.GetString("source")
 	return src
 }
 
-func (m EventManager) GetType(obj jsonutils.JSONObject) interface{} {
+func (m EventManager) Get_Type(obj jsonutils.JSONObject) interface{} {
 	typ, _ := obj.GetString("type")
 	return typ
 }
 
-func (m EventManager) GetAction(obj jsonutils.JSONObject) interface{} {
+func (m EventManager) Get_Action(obj jsonutils.JSONObject) interface{} {
 	act, _ := obj.Get("action")
 	return act
 }
 
-func (m EventManager) GetObject(obj jsonutils.JSONObject) interface{} {
+func (m EventManager) Get_Object(obj jsonutils.JSONObject) interface{} {
 	refObj, _ := obj.Get("involvedObject")
 	if refObj == nil {
 		return ""
@@ -71,7 +71,7 @@ func (m EventManager) GetObject(obj jsonutils.JSONObject) interface{} {
 	return fmt.Sprintf("%s/%s", kind, name)
 }
 
-func (m EventManager) GetMessage(obj jsonutils.JSONObject) interface{} {
+func (m EventManager) Get_Message(obj jsonutils.JSONObject) interface{} {
 	msg, _ := obj.GetString("message")
 	return msg
 }

pkg/mcclient/modules/k8s/getter.go

@@ -35,21 +35,26 @@ var (
 
 type nameGetter struct{}
 
-func (g nameGetter) GetName(obj jsonutils.JSONObject) interface{} {
+func (g nameGetter) Get_Id(obj jsonutils.JSONObject) interface{} {
+	id, _ := obj.GetString("id")
+	return id
+}
+
+func (g nameGetter) Get_Name(obj jsonutils.JSONObject) interface{} {
 	name, _ := obj.GetString("name")
 	return name
 }
 
 type statusGetter struct{}
 
-func (g statusGetter) GetStatus(obj jsonutils.JSONObject) interface{} {
+func (g statusGetter) Get_Status(obj jsonutils.JSONObject) interface{} {
 	status, _ := obj.GetString("status")
 	return status
 }
 
 type ageGetter struct{}
 
-func (g ageGetter) GetAge(obj jsonutils.JSONObject) interface{} {
+func (g ageGetter) Get_Age(obj jsonutils.JSONObject) interface{} {
 	creationTimestamp, err := obj.GetString("creationTimestamp")
 	if err != nil {
 		log.Errorf("Get creationTimestamp error: %v", err)
@@ -62,14 +67,14 @@ func (g ageGetter) GetAge(obj jsonutils.JSONObject) interface{} {
 
 type namespaceGetter struct{}
 
-func (g namespaceGetter) GetNamespace(obj jsonutils.JSONObject) interface{} {
+func (g namespaceGetter) Get_Namespace(obj jsonutils.JSONObject) interface{} {
 	ns, _ := obj.GetString("namespace")
 	return ns
 }
 
 type labelGetter struct{}
 
-func (g labelGetter) GetLabels(obj jsonutils.JSONObject) interface{} {
+func (g labelGetter) Get_Labels(obj jsonutils.JSONObject) interface{} {
 	labels, _ := obj.GetMap("labels")
 	str := ""
 	ls := []string{}

pkg/mcclient/modules/k8s/helm_chart.go

@@ -37,18 +37,18 @@ func init() {
 	modules.Register(Charts)
 }
 
-func (m ChartManager) GetRepoWithName(obj jsonutils.JSONObject) interface{} {
+func (m ChartManager) Get_RepoWithName(obj jsonutils.JSONObject) interface{} {
 	repo, _ := obj.GetString("repo")
 	name, _ := obj.GetString("chart", "name")
 	return fmt.Sprintf("%s/%s", repo, name)
 }
 
-func (m ChartManager) GetVersion(obj jsonutils.JSONObject) interface{} {
+func (m ChartManager) Get_Version(obj jsonutils.JSONObject) interface{} {
 	version, _ := obj.GetString("chart", "version")
 	return version
 }
 
-func (m ChartManager) GetDescription(obj jsonutils.JSONObject) interface{} {
+func (m ChartManager) Get_Description(obj jsonutils.JSONObject) interface{} {
 	desc, _ := obj.GetString("chart", "description")
 	return desc
 }

pkg/mcclient/modules/k8s/helm_release.go

@@ -15,47 +15,19 @@
 package k8s
 
 import (
-	"yunion.io/x/jsonutils"
-
-	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modules"
 )
 
 var (
-	Releases               *ReleaseManager
-	MeterReleaseApps       *ReleaseAppManager
-	ServicetreeReleaseApps *ReleaseAppManager
-	NotifyReleaseApps      *ReleaseAppManager
-	dummyReleaseApps       *ReleaseAppManager
+	Releases *ReleaseManager
 )
 
 type ReleaseManager struct {
 	*NamespaceResourceManager
 }
 
-type ReleaseAppManager struct {
-	*NamespaceResourceManager
-}
-
-func NewReleaseAppManager(keyword, keywordPlural string) *ReleaseAppManager {
-	return &ReleaseAppManager{
-		NamespaceResourceManager: NewNamespaceResourceManager(keyword, keywordPlural, NewColumns(), NewColumns()),
-	}
-}
-
-func (m *ReleaseAppManager) Create(session *mcclient.ClientSession, params jsonutils.JSONObject) (jsonutils.JSONObject, error) {
-	return m.CreateInContext(session, params, dummyReleaseApps, "")
-}
-
 func init() {
 	Releases = &ReleaseManager{
 		NewNamespaceResourceManager("release", "releases", NewNamespaceCols("status", "type"), NewColumns())}
-	dummyReleaseApps = NewReleaseAppManager("releaseapp", "releaseapps")
-	MeterReleaseApps = NewReleaseAppManager("app_meter", "app_meters")
-	ServicetreeReleaseApps = NewReleaseAppManager("app_servicetree", "app_servicetrees")
-	NotifyReleaseApps = NewReleaseAppManager("app_notify", "app_notifies")
 	modules.Register(Releases)
-	modules.Register(MeterReleaseApps)
-	modules.Register(ServicetreeReleaseApps)
-	modules.Register(NotifyReleaseApps)
 }

pkg/mcclient/modules/k8s/k8s_node.go

@@ -23,12 +23,12 @@ var (
 )
 
 type K8sNodeManager struct {
-	*MetaResourceManager
+	*ClusterResourceManager
 }
 
 func init() {
 	K8sNodes = &K8sNodeManager{
-		MetaResourceManager: NewMetaResourceManager("k8s_node", "k8s_nodes", NewColumns(), NewColumns()),
+		ClusterResourceManager: NewClusterResourceManager("k8s_node", "k8s_nodes", NewColumns(), NewColumns()),
 	}
 
 	modules.Register(K8sNodes)

pkg/mcclient/modules/k8s/namespace.go

@@ -21,14 +21,14 @@ import (
 var Namespaces *NamespaceManager
 
 type NamespaceManager struct {
-	*MetaResourceManager
+	*ClusterResourceManager
 	statusGetter
 }
 
 func init() {
 	Namespaces = &NamespaceManager{
-		MetaResourceManager: NewMetaResourceManager("namespace", "namespaces", NewNameCols("Status"), NewClusterCols()),
-		statusGetter:        getStatus,
+		ClusterResourceManager: NewClusterResourceManager("namespace", "namespaces", NewNameCols("Status"), NewClusterCols()),
+		statusGetter:           getStatus,
 	}
 
 	modules.Register(Namespaces)