client

Documentation

Index

• Variables
• type Client
  • func New(url string, authType string, authToken string, certFile string) *Client
• type CloudAccounts
• type CloudAccountsInterface
• type Collection
  • func (c *Collection) Create(item model.Model) error
  • func (c *Collection) Delete(id interface{}, item model.Model) error
  • func (c *Collection) Get(id interface{}, item model.Model) error
  • func (c *Collection) GetWithIncludes(id interface{}, item model.Model, includes []string) error
  • func (c *Collection) List(list model.List) error
  • func (c *Collection) Update(id interface{}, item model.Model) error
• type CollectionInterface
• type EntrypointListeners
• type EntrypointListenersInterface
• type Entrypoints
• type EntrypointsInterface
• type KubeResources
  • func (c *KubeResources) Start(id *int64, m *model.KubeResource) error
  • func (c *KubeResources) Stop(id *int64, m *model.KubeResource) error
• type KubeResourcesInterface
• type Kubes
• type KubesInterface
• type Nodes
• type NodesInterface
• type Sessions
• type SessionsInterface
• type Users
  • func (c *Users) RegenerateAPIToken(id interface{}, m *model.User) error
• type UsersInterface
• type Volumes
• type VolumesInterface

Variables

var Log *logger

Types

type Client

type Client struct {
	Version string

	BaseURL   string
	AuthType  string // token, session
	AuthToken string

	Sessions            SessionsInterface
	Users               UsersInterface
	CloudAccounts       CloudAccountsInterface
	Kubes               KubesInterface
	KubeResources       KubeResourcesInterface
	Volumes             VolumesInterface
	Entrypoints         EntrypointsInterface
	EntrypointListeners EntrypointListenersInterface
	Nodes               NodesInterface
	// contains filtered or unexported fields
}

func New

func New(url string, authType string, authToken string, certFile string) *Client

type CloudAccounts

type CloudAccounts struct {
	Collection
}

type CloudAccountsInterface

type CloudAccountsInterface interface {
	CollectionInterface
}

type Collection

type Collection struct {
	// contains filtered or unexported fields
}

func (*Collection) Create

func (c *Collection) Create(item model.Model) error

func (*Collection) Delete

func (c *Collection) Delete(id interface{}, item model.Model) error

func (*Collection) Get

func (c *Collection) Get(id interface{}, item model.Model) error

func (*Collection) GetWithIncludes

func (c *Collection) GetWithIncludes(id interface{}, item model.Model, includes []string) error

func (*Collection) List

func (c *Collection) List(list model.List) error

func (*Collection) Update

func (c *Collection) Update(id interface{}, item model.Model) error

type CollectionInterface

type CollectionInterface interface {
	List(model.List) error
	Create(model.Model) error
	Get(interface{}, model.Model) error
	GetWithIncludes(interface{}, model.Model, []string) error
	Update(interface{}, model.Model) error
	Delete(interface{}, model.Model) error
}

We don't use this directly, but instead compose other fake collections with

type EntrypointListeners

type EntrypointListeners struct {
	Collection
}

type EntrypointListenersInterface

type EntrypointListenersInterface interface {
	CollectionInterface
}

type Entrypoints

type Entrypoints struct {
	Collection
}

type EntrypointsInterface

type EntrypointsInterface interface {
	CollectionInterface
}

type KubeResources

type KubeResources struct {
	Collection
}

func (*KubeResources) Start

func (c *KubeResources) Start(id *int64, m *model.KubeResource) error

func (*KubeResources) Stop

func (c *KubeResources) Stop(id *int64, m *model.KubeResource) error

type KubeResourcesInterface

type KubeResourcesInterface interface {
	CollectionInterface
	Start(*int64, *model.KubeResource) error
	Stop(*int64, *model.KubeResource) error
}

type Kubes

type Kubes struct {
	Collection
}

type KubesInterface

type KubesInterface interface {
	CollectionInterface
}

type Nodes

type Nodes struct {
	Collection
}

type NodesInterface

type NodesInterface interface {
	CollectionInterface
}

type Sessions

type Sessions struct {
	Collection
}

type SessionsInterface

type SessionsInterface interface {
	CollectionInterface
}

type Users

type Users struct {
	Collection
}

func (*Users) RegenerateAPIToken

func (c *Users) RegenerateAPIToken(id interface{}, m *model.User) error

type UsersInterface

type UsersInterface interface {
	CollectionInterface
	RegenerateAPIToken(interface{}, *model.User) error
}

type Volumes

type Volumes struct {
	Collection
}

type VolumesInterface

type VolumesInterface interface {
	CollectionInterface
}