执行器设计 about fist HOT 2 OPEN

package client

import (
	"fmt"

	"git.xfyun.cn/container/genesis/modules/authentication"
	"git.xfyun.cn/container/genesis/utils"

	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"
	"github.com/pkg/errors"
)

//KubeClientFromInClusterConfig is
func KubeClientFromInClusterConfig() (clientSet *kubernetes.Clientset, err error) {
	config, err := rest.InClusterConfig()
	if err != nil {
		return clientSet, err
	}
	// creates the clientset
	clientSet, err = kubernetes.NewForConfig(config)
	if err != nil {
		return clientSet, err
	}
	return clientSet, nil
}

//KubeClientFromKubeconfigPath is
func KubeClientFromKubeconfigPath(path string) (clientSet *kubernetes.Clientset, err error) {

	cfg, err := clientcmd.BuildConfigFromFlags("", path)
	if err != nil {
		return nil, fmt.Errorf("new kube config error: %s", err)
	}

	if clientSet, err = kubernetes.NewForConfig(cfg); err != nil {
		return nil, fmt.Errorf("new kube config error: %s", err)
	}
	return clientSet, nil
}

//KubeClientFromKubeconfigStringBody is
func KubeClientFromKubeconfigStringBody(body string) (*kubernetes.Clientset, error) {
	b, err := utils.Base64Decode(body)
	if err != nil {
		return nil, err
	}

	clientConfig, err := clientcmd.NewClientConfigFromBytes(b)
	if err != nil {
		return nil, fmt.Errorf("new client config from body error: %s", err)
	}
	cfg, err := clientConfig.ClientConfig()
	if err != nil {
		return nil, fmt.Errorf("new kube config from body error: %s", err)
	}

	clientSet, err := kubernetes.NewForConfig(cfg)
	if err != nil {
		return nil, fmt.Errorf("new kube config from body error: %s", err)
	}
	return clientSet, nil
}

package utils

import (
	"bytes"
	"fmt"
	"io"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/util/yaml"
	"k8s.io/kubernetes/pkg/kubectl/genericclioptions/resource"
	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"

	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
)

var bs = []byte(`
kind: Namespace
metadata:
   name: test
---

kind: bbb
name: aaa`)

/* Out put
{"kind":"Namespace","metadata":{"name":"test"}}
{"kind":"bbb","name":"aaa"}
*/
func example() {
	reader := bytes.NewReader(bs)
	ext := runtime.RawExtension{}
	d := yaml.NewYAMLOrJSONDecoder(reader, 4096)
	for {
		if err := d.Decode(&ext); err != nil {
			if err == io.EOF {
				return
			}
			return
		}
		fmt.Println(string(ext.Raw))
	}
}

//YamlCallback is
type YamlCallback func([]byte) error

//YamlHandler is
func YamlHandler(rawBytes []byte, fn YamlCallback) (err error) {
	reader := bytes.NewReader(rawBytes)

	d := yaml.NewYAMLOrJSONDecoder(reader, 4096)
	for {
		ext := runtime.RawExtension{}
		if err = d.Decode(&ext); err != nil {
			if err == io.EOF {
				return nil
			}
			return fmt.Errorf("decode yaml json failed: %v", err)
		}

		// TODO: This needs to be able to handle object in other encodings and schemas.
		ext.Raw = bytes.TrimSpace(ext.Raw)
		if len(ext.Raw) == 0 || bytes.Equal(ext.Raw, []byte("null")) {
			continue
		}

		kubeConfigFlags := genericclioptions.NewConfigFlags()
		matchVersionKubeConfigFlags := cmdutil.NewMatchVersionFlags(kubeConfigFlags)
		f := cmdutil.NewFactory(matchVersionKubeConfigFlags)

		schema, err := f.Validator(true)
		if err != nil {
			return err
		}

		//if err := resource.ValidateSchema(ext.Raw, validation.NullSchema{}); err != nil {
		if err := resource.ValidateSchema(ext.Raw, schema); err != nil {
			return fmt.Errorf("error validating yaml: %v", err)
		}

		//Raw is already to json
		if err = fn(ext.Raw); err != nil {
			return fmt.Errorf("handler yaml callback fn failed: %v", err)
		}
	}
}