24.knowtypes

PR #196

这使每个人都不必考虑“种类”字段：使用 api。编码和 api。Decode[Into] 而不是 json|yaml

还记得我们之前有pr提到过，在返回给client端的资源时，我们都会手动赋值资源类型，这种操作完全可以通过反射来自动化。

func Encode(obj interface{}) (data []byte, err error) {
    // 检查 obj 是否为指针
    obj = checkPtr(obj)
    // 检查 ojb 是否为系统注册了的资源
    jsonBase, err := prepareEncode(obj)
    if err != nil {
        return nil, err
    }
    data, err = json.MarshalIndent(obj, "", "   ")
    jsonBase.Kind = ""
    return data, err
}

func DecodeInto(data []byte, obj interface{}) error {
    err := yaml.Unmarshal(data, obj)
    if err != nil {
        return err
    }
    name, jsonBase, err := nameAndJSONBase(obj)
    if err != nil {
        return err
    }
    if jsonBase.Kind != "" && jsonBase.Kind != name {
        return fmt.Errorf("data had kind %v, but passed object was of type %v", jsonBase.Kind, name)
    }
    // Don't leave these set. Track type with go's type.
    jsonBase.Kind = ""
    return nil
}


func AddKnownTypes(types ...interface{}) {
    for _, obj := range types {
        t := reflect.TypeOf(obj)
        knownTypes[t.Name()] = t
    }
}

通过使用反射，我们不用再手动设置，下面为代码截图：

PR #203

cloundcfg api improvements

在本pr中，我们首先来了解下设计模式之链式调用，这种设计模式一般应用在 http 请求库中，方便我们发送http请求，我们来看下面一段代码：

// Server contains info locating a kubernetes api server.
// Example usage:
// auth, err := LoadAuth(filename)
// s := New(url, auth)
// resp, err := s.Verb("GET").
//  Path("api/v1beta1").
//  Path("pods").
//  Selector("area=staging").
//  Timeout(10*time.Second).
//  Do()
// list, ok := resp.(api.PodList)
type Server struct {
    auth   *client.AuthInfo
    rawUrl string
}

// Create a new server object.
func New(serverUrl string, auth *client.AuthInfo) *Server {
    return &Server{
        auth:   auth,
        rawUrl: serverUrl,
    }
}

// Begin a request with a verb (GET, POST, PUT, DELETE)
func (s *Server) Verb(verb string) *Request {
    return &Request{
        verb: verb,
        s:    s,
        path: "/",
    }
}

// Request allows for building up a request to a server in a chained fashion.
type Request struct {
    s        *Server
    err      error
    verb     string
    path     string
    body     interface{}
    selector labels.Selector
    timeout  time.Duration
}

// Append an item to the request path. You must call Path at least once.
func (r *Request) Path(item string) *Request {
    if r.err != nil {
        return r
    }
    r.path = path.Join(r.path, item)
    return r
}

// Use the given item as a resource label selector. Optional.
func (r *Request) Selector(item string) *Request {
    if r.err != nil {
        return r
    }
    r.selector, r.err = labels.ParseSelector(item)
    return r
}

// Use the given duration as a timeout. Optional.
func (r *Request) Timeout(d time.Duration) *Request {
    if r.err != nil {
        return r
    }
    r.timeout = d
    return r
}

// Use obj as the body of the request. Optional.
// If obj is a string, try to read a file of that name.
// If obj is a []byte, send it directly.
// Otherwise, assume obj is an api type and marshall it correctly.
func (r *Request) Body(obj interface{}) *Request {
    if r.err != nil {
        return r
    }
    r.body = obj
    return r
}

// Format and xecute the request. Returns the API object received, or an error.
func (r *Request) Do() (interface{}, error) {
    if r.err != nil {
        return nil, r.err
    }
    finalUrl := r.s.rawUrl + r.path
    query := url.Values{}
    if r.selector != nil {
        query.Add("labels", r.selector.String())
    }
    if r.timeout != 0 {
        query.Add("timeout", r.timeout.String())
    }
    finalUrl += "?" + query.Encode()
    var body io.Reader
    if r.body != nil {
        switch t := r.body.(type) {
        case string:
            data, err := ioutil.ReadFile(t)
            if err != nil {
                return nil, err
            }
            body = bytes.NewBuffer(data)
        case []byte:
            body = bytes.NewBuffer(t)
        default:
            data, err := api.Encode(r.body)
            if err != nil {
                return nil, err
            }
            body = bytes.NewBuffer(data)
        }
    }
    req, err := http.NewRequest(r.verb, finalUrl, body)
    if err != nil {
        return nil, err
    }
    str, err := doRequest(req, r.s.auth)
    if err != nil {
        return nil, err
    }
    return api.Decode([]byte(str))
}

通过引入链式调用，我们可以简化我们的cloudcfg发送http请求的代码：

这个pr 还给 ResourcePrinter 这个接口添加了一个函数签名 PrintObj，方便我们打印：

提示

作业：链式调用添加新的Request方法：

在Request类型中添加一个新的方法Header，该方法将允许用户向请求添加HTTP头部。此方法应能被连续调用，以便用户可以添加多个头部字段。首先，你需要在Request结构中添加一个新的字段，比如headers，用来存储头部信息。然后，实现Header方法，它接受两个参数，一个表示头部字段的名称，另一个表示字段的值。此方法应返回请求本身，以便可以进行链式调用。

在Do方法中，你需要修改请求创建的过程，以便它包含在headers字段中存储的所有头部信息。

PR #196​

PR #203​

PR #196

PR #203