mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-10-31 05:40:42 +00:00
104 lines
2.6 KiB
Go
104 lines
2.6 KiB
Go
package storageos
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/storageos/go-api/types"
|
|
"net/http"
|
|
"net/url"
|
|
)
|
|
|
|
var (
|
|
|
|
// PolicyAPIPrefix is a partial path to the HTTP endpoint.
|
|
PolicyAPIPrefix = "policies"
|
|
|
|
// ErrNoSuchPolicy is the error returned when the policy does not exist.
|
|
ErrNoSuchPolicy = errors.New("no such policy")
|
|
)
|
|
|
|
// nopMarshaler is an alias to a []byte that implements json.Marshaler
|
|
// it bypasses the base64 encoded string representation that json will give byte slices.
|
|
// It should only be used to wrap []byte types containing pre-rendered valid json that will later
|
|
// (out of the caller's control) be run through json.Marshal
|
|
type nopMarshaler []byte
|
|
|
|
func (n *nopMarshaler) MarshalJSON() ([]byte, error) {
|
|
return *n, nil
|
|
}
|
|
|
|
// PolicyCreate creates a policy on the server.
|
|
func (c *Client) PolicyCreate(jsonl []byte, ctx context.Context) error {
|
|
nopm := nopMarshaler(jsonl)
|
|
_, err := c.do("POST", PolicyAPIPrefix, doOptions{
|
|
data: &nopm,
|
|
context: ctx,
|
|
headers: map[string]string{"Content-Type": "application/x-jsonlines"},
|
|
})
|
|
return err
|
|
}
|
|
|
|
// Policy returns a policy on the server by ID.
|
|
func (c *Client) Policy(id string) (*types.Policy, error) {
|
|
path := fmt.Sprintf("%s/%s", PolicyAPIPrefix, id)
|
|
resp, err := c.do("GET", path, doOptions{})
|
|
if err != nil {
|
|
if e, ok := err.(*Error); ok && e.Status == http.StatusNotFound {
|
|
return nil, ErrNoSuchPolicy
|
|
}
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var policy *types.Policy
|
|
if err := json.NewDecoder(resp.Body).Decode(&policy); err != nil {
|
|
return nil, err
|
|
}
|
|
return policy, nil
|
|
}
|
|
|
|
// PolicyList returns the list of policies on the server.
|
|
func (c *Client) PolicyList(opts types.ListOptions) (types.PolicySet, error) {
|
|
listOpts := doOptions{
|
|
fieldSelector: opts.FieldSelector,
|
|
labelSelector: opts.LabelSelector,
|
|
namespace: opts.Namespace,
|
|
context: opts.Context,
|
|
}
|
|
|
|
if opts.LabelSelector != "" {
|
|
query := url.Values{}
|
|
query.Add("labelSelector", opts.LabelSelector)
|
|
listOpts.values = query
|
|
}
|
|
|
|
resp, err := c.do("GET", PolicyAPIPrefix, listOpts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var policies types.PolicySet
|
|
if err := json.NewDecoder(resp.Body).Decode(&policies); err != nil {
|
|
return nil, err
|
|
}
|
|
return policies, nil
|
|
}
|
|
|
|
// PolicyDelete deletes a policy on the server by ID.
|
|
func (c *Client) PolicyDelete(opts types.DeleteOptions) error {
|
|
resp, err := c.do("DELETE", PolicyAPIPrefix+"/"+opts.Name, doOptions{})
|
|
if err != nil {
|
|
if e, ok := err.(*Error); ok {
|
|
if e.Status == http.StatusNotFound {
|
|
return ErrNoSuchPolicy
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
return nil
|
|
}
|