provision: github.com/digitalrebar/provision/frontend Index | Files

package frontend

import "github.com/digitalrebar/provision/frontend"

Frontend contains the frontend code for DigitalRebar Provision. It has the responsibility for providing the api interface to DigitalRebar Provision. Responses and routes are specified here.

Index

Package Files

bootenvs.go content.go doc.go events.go files.go frontend.go indexes.go info.go interfaces.go isos.go jobs.go leases.go machines.go params.go plugin_providers.go plugins.go prefs.go profiles.go reservations.go stages.go subnets.go tasks.go templates.go users.go websocket.go

type AuthSource Uses

type AuthSource interface {
    GetUser(username string) *backend.User
}

func NewDefaultAuthSource Uses

func NewDefaultAuthSource(dt *backend.DataTracker) (das AuthSource)

type BootEnvBodyParameter Uses

type BootEnvBodyParameter struct {
    // in: body
    // required: true
    Body *models.BootEnv
}

BootEnvBodyParameter used to inject a BootEnv swagger:parameters createBootEnv putBootEnv

type BootEnvListPathParameter Uses

type BootEnvListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    OnlyUnknown string
    // in: query
    Name string
}

BootEnvListPathParameter used to limit lists of BootEnv by path options swagger:parameters listBootEnvs listStatsBootEnvs

type BootEnvPatchBodyParameter Uses

type BootEnvPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

BootEnvPatchBodyParameter used to patch a BootEnv swagger:parameters patchBootEnv

type BootEnvPathParameter Uses

type BootEnvPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

BootEnvPathParameter used to name a BootEnv in the path swagger:parameters putBootEnvs getBootEnv putBootEnv patchBootEnv deleteBootEnv headBootEnv

type BootEnvResponse Uses

type BootEnvResponse struct {
    // in: body
    Body *models.BootEnv
}

BootEnvResponse returned on a successful GET, PUT, PATCH, or POST of a single bootenv swagger:response

type BootEnvsResponse Uses

type BootEnvsResponse struct {
    //in: body
    Body []*models.BootEnv
}

BootEnvsResponse returned on a successful GET of all the bootenvs swagger:response

type ContentBodyParameter Uses

type ContentBodyParameter struct {
    // in: body
    Body *models.Content
}

swagger:parameters uploadContent createContent

type ContentParameter Uses

type ContentParameter struct {
    // in: path
    Name string `json:"name"`
}

swagger:parameters getContent deleteContent uploadContent

type ContentResponse Uses

type ContentResponse struct {
    // in: body
    Body *models.Content
}

ContentsResponse returned on a successful GET of a contents swagger:response

type ContentSummaryResponse Uses

type ContentSummaryResponse struct {
    // in: body
    Body *models.ContentSummary
}

ContentSummaryResponse returned on a successful Post of a content swagger:response

type ContentsResponse Uses

type ContentsResponse struct {
    // in: body
    Body []*models.ContentSummary
}

ContentsResponse returned on a successful GET of all contents swagger:response

type DefaultAuthSource Uses

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

func (DefaultAuthSource) GetUser Uses

func (d DefaultAuthSource) GetUser(username string) *backend.User

type ErrorResponse Uses

type ErrorResponse struct {
    //in: body
    Body models.Error
}

ErrorResponse is returned whenever an error occurs swagger:response

type EventBodyParameter Uses

type EventBodyParameter struct {
    // in: body
    Body *models.Event
}

EventBodyParameter is used to create an Event swagger:parameters postEvent

type FileData Uses

type FileData struct {
    // in: body
    Body interface{}
}

FileData body of the upload swagger:parameters uploadFile

type FileInfoResponse Uses

type FileInfoResponse struct {
    // in: body
    Body *models.BlobInfo
}

FileInfoResponse returned on a successful upload of a file swagger:response

type FilePathPathParameter Uses

type FilePathPathParameter struct {
    // in: path
    Path string `json:"path"`
}

swagger:parameters uploadFile getFile deleteFile

type FilePaths Uses

type FilePaths []string

type FileResponse Uses

type FileResponse struct {
    // in: body
    Body string
}

This is a HACK - I can't figure out how to get swagger to render this a binary. So we lie. We also override this object from the server directory to have a binary format which turns it into a stream.

FileResponse returned on a successful GET of a file swagger:response

type FilesPathQueryParameter Uses

type FilesPathQueryParameter struct {
    // in: query
    Path string `json:"path"`
}

swagger:parameters listFiles

type FilesResponse Uses

type FilesResponse struct {
    // in: body
    Body FilePaths
}

FilesResponse returned on a successful GET of files swagger:response

type Frontend Uses

type Frontend struct {
    Logger   *log.Logger
    FileRoot string
    MgmtApi  *gin.Engine
    ApiGroup *gin.RouterGroup

    ApiPort  int
    ProvPort int
    NoDhcp   bool
    NoTftp   bool
    NoProv   bool
    SaasDir  string
    // contains filtered or unexported fields
}

func NewFrontend Uses

func NewFrontend(
    dt *backend.DataTracker,
    logger *log.Logger,
    address string,
    apiport, provport int,
    fileRoot, devUI, UIUrl string,
    authSource AuthSource,
    pubs *backend.Publishers,
    drpid string,
    pc *midlayer.PluginController,
    noDhcp, noTftp, noProv bool,
    saasDir string) (me *Frontend)

func (*Frontend) Create Uses

func (f *Frontend) Create(c *gin.Context, val store.KeySaver)

func (*Frontend) Exists Uses

func (f *Frontend) Exists(c *gin.Context, ref store.KeySaver, key string)

func (*Frontend) Fetch Uses

func (f *Frontend) Fetch(c *gin.Context, ref store.KeySaver, key string)

func (*Frontend) GetInfo Uses

func (f *Frontend) GetInfo(drpid string) (*models.Info, *models.Error)

func (*Frontend) InitBootEnvApi Uses

func (f *Frontend) InitBootEnvApi()

func (*Frontend) InitContentApi Uses

func (f *Frontend) InitContentApi()

func (*Frontend) InitEventApi Uses

func (f *Frontend) InitEventApi()

func (*Frontend) InitFileApi Uses

func (f *Frontend) InitFileApi()

func (*Frontend) InitIndexApi Uses

func (f *Frontend) InitIndexApi()

func (*Frontend) InitInfoApi Uses

func (f *Frontend) InitInfoApi(drpid string)

func (*Frontend) InitInterfaceApi Uses

func (f *Frontend) InitInterfaceApi()

func (*Frontend) InitIsoApi Uses

func (f *Frontend) InitIsoApi()

func (*Frontend) InitJobApi Uses

func (f *Frontend) InitJobApi()

func (*Frontend) InitLeaseApi Uses

func (f *Frontend) InitLeaseApi()

func (*Frontend) InitMachineApi Uses

func (f *Frontend) InitMachineApi()

func (*Frontend) InitParamApi Uses

func (f *Frontend) InitParamApi()

func (*Frontend) InitPluginApi Uses

func (f *Frontend) InitPluginApi()

func (*Frontend) InitPluginProviderApi Uses

func (f *Frontend) InitPluginProviderApi()

func (*Frontend) InitPrefApi Uses

func (f *Frontend) InitPrefApi()

func (*Frontend) InitProfileApi Uses

func (f *Frontend) InitProfileApi()

func (*Frontend) InitReservationApi Uses

func (f *Frontend) InitReservationApi()

func (*Frontend) InitStageApi Uses

func (f *Frontend) InitStageApi()

func (*Frontend) InitSubnetApi Uses

func (f *Frontend) InitSubnetApi()

func (*Frontend) InitTaskApi Uses

func (f *Frontend) InitTaskApi()

func (*Frontend) InitTemplateApi Uses

func (f *Frontend) InitTemplateApi()

func (*Frontend) InitUserApi Uses

func (f *Frontend) InitUserApi(drpid string)

func (*Frontend) InitWebSocket Uses

func (fe *Frontend) InitWebSocket()

func (*Frontend) List Uses

func (f *Frontend) List(c *gin.Context, ref store.KeySaver)

XXX: Auth enforce may need to limit return values based up access to get - one day.

func (*Frontend) ListStats Uses

func (f *Frontend) ListStats(c *gin.Context, ref store.KeySaver)

func (*Frontend) Patch Uses

func (f *Frontend) Patch(c *gin.Context, ref store.KeySaver, key string)

func (*Frontend) Publish Uses

func (f *Frontend) Publish(e *models.Event) error

func (*Frontend) Release Uses

func (f *Frontend) Release()

func (*Frontend) Remove Uses

func (f *Frontend) Remove(c *gin.Context, ref store.KeySaver, key string)

func (*Frontend) Reserve Uses

func (f *Frontend) Reserve() error

This never gets unloaded.

func (*Frontend) Unload Uses

func (f *Frontend) Unload()

func (*Frontend) Update Uses

func (f *Frontend) Update(c *gin.Context, ref store.KeySaver, key string)

type IndexParameter Uses

type IndexParameter struct {
    // in: path
    Prefix string `json:"prefix"`
}

swagger:parameters getIndex

type IndexResponse Uses

type IndexResponse struct {
    // in: body
    Body map[string]models.Index
}

IndexResponse lists all of the static indexes for a specific type of object swagger:response

type Indexer Uses

type Indexer interface {
    Indexes() map[string]index.Maker
}

type IndexesResponse Uses

type IndexesResponse struct {
    // in: body
    Body map[string]map[string]models.Index
}

IndexesResponse lists all the static indexes for all the object types swagger:response

type InfoResponse Uses

type InfoResponse struct {
    // in: body
    Body *models.Info
}

InfosResponse returned on a successful GET of an info swagger:response

type InterfaceParameter Uses

type InterfaceParameter struct {
    // in: path
    Name string `json:"name"`
}

swagger:parameters getInterface

type InterfaceResponse Uses

type InterfaceResponse struct {
    // in: body
    Body *models.Interface
}

InterfacesResponse returned on a successful GET of an interfaces swagger:response

type InterfacesResponse Uses

type InterfacesResponse struct {
    // in: body
    Body []*models.Interface
}

InterfacesResponse returned on a successful GET of all interfaces swagger:response

type IsoData Uses

type IsoData struct {
    // in: body
    Body interface{}
}

IsoData body of the upload swagger:parameters uploadIso

type IsoInfoResponse Uses

type IsoInfoResponse struct {
    // in: body
    Body *models.BlobInfo
}

IsoInfoResponse returned on a successful upload of an iso swagger:response

type IsoPathPathParameter Uses

type IsoPathPathParameter struct {
    // in: path
    Path string `json:"path"`
}

swagger:parameters uploadIso getIso deleteIso

type IsoPaths Uses

type IsoPaths []string

type IsoResponse Uses

type IsoResponse struct {
    // in: body
    Body interface{}
}

IsoResponse returned on a successful GET of an iso swagger:response

type IsosResponse Uses

type IsosResponse struct {
    // in: body
    Body IsoPaths
}

IsosResponse returned on a successful GET of isos swagger:response

type JobActionsResponse Uses

type JobActionsResponse struct {
    // in: body
    Body []*models.JobAction
}

JobActionsResponse return on a successful GET of a Job's actions swagger:response

type JobBodyParameter Uses

type JobBodyParameter struct {
    // in: body
    // required: true
    Body *models.Job
}

JobBodyParameter used to inject a Job swagger:parameters createJob putJob

type JobListPathParameter Uses

type JobListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Uuid string
    // in: query
    Stage string
    // in: query
    Task string
    // in: query
    State string
    // in: query
    Machine string
    // in: query
    Archived string
    // in: query
    StartTime string
    // in: query
    EndTime string
}

JobListPathParameter used to limit lists of Job by path options swagger:parameters listJobs listStatsJobs

type JobLogPutBodyParameter Uses

type JobLogPutBodyParameter struct {
    // in: body
    // required: true
    Body interface{}
}

JobLogBodyParameter used to append to a Job log swagger:parameters putJobLog

type JobLogResponse Uses

type JobLogResponse struct {
    // in: body
    // format: binary
    Body string
}

This is a HACK - I can't figure out how to get swagger to render this a binary. So we lie. We also override this object from the server directory to have a binary format which turns it into a stream.

JobLogResponse returned on a successful GET of a log swagger:response

type JobParamsBodyParameter Uses

type JobParamsBodyParameter struct {
    // in: body
    // required: true
    Body map[string]interface{}
}

JobParamsBodyParameter used to set Job Params swagger:parameters postJobParams

type JobParamsResponse Uses

type JobParamsResponse struct {
    // in: body
    Body map[string]interface{}
}

JobParamsResponse return on a successful GET of all Job's Params swagger:response

type JobPatchBodyParameter Uses

type JobPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

JobPatchBodyParameter used to patch a Job swagger:parameters patchJob

type JobPathParameter Uses

type JobPathParameter struct {
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
}

JobPathParameter used to find a Job in the path swagger:parameters putJobs getJob putJob patchJob deleteJob getJobParams postJobParams getJobActions getJobLog putJobLog headJob

type JobResponse Uses

type JobResponse struct {
    // in: body
    Body *models.Job
}

JobResponse return on a successful GET, PUT, PATCH or POST of a single Job swagger:response

type JobsResponse Uses

type JobsResponse struct {
    // in: body
    Body []*models.Job
}

JobsResponse return on a successful GET of all Jobs swagger:response

type LeaseBodyParameter Uses

type LeaseBodyParameter struct {
    // in: body
    // required: true
    Body *models.Lease
}

LeaseBodyParameter used to inject a Lease swagger:parameters createLease putLease

type LeaseListPathParameter Uses

type LeaseListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Addr string
    // in: query
    Token string
    // in: query
    Strategy string
    // in: query
    ExpireTime string
}

LeaseListPathParameter used to limit lists of Lease by path options swagger:parameters listLeases listStatsLeases

type LeasePatchBodyParameter Uses

type LeasePatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

LeasePatchBodyParameter used to patch a Lease swagger:parameters patchLease

type LeasePathParameter Uses

type LeasePathParameter struct {
    // in: path
    // required: true
    // swagger:strfmt ipv4
    Address string `json:"address"`
}

LeasePathParameter used to address a Lease in the path swagger:parameters putLeases getLease putLease patchLease deleteLease headLease

type LeaseResponse Uses

type LeaseResponse struct {
    // in: body
    Body *models.Lease
}

LeaseResponse returned on a successful GET, PUT, PATCH, or POST of a single lease swagger:response

type LeasesResponse Uses

type LeasesResponse struct {
    //in: body
    Body []*models.Lease
}

LeasesResponse returned on a successful GET of all the leases swagger:response

type Lockable Uses

type Lockable interface {
    Locks(string) []string
}

type MachineActionBodyParameter Uses

type MachineActionBodyParameter struct {
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
    // in: path
    // required: true
    Name string `json:"name"`
    // in: body
    // required: true
    Body map[string]interface{}
}

MachineActionBodyParameter used to post a Machine / Action in the path swagger:parameters postMachineAction

type MachineActionPathParameter Uses

type MachineActionPathParameter struct {
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
    // in: path
    // required: true
    Name string `json:"name"`
}

MachineActionPathParameter used to find a Machine / Action in the path swagger:parameters getMachineAction

type MachineActionPostResponse Uses

type MachineActionPostResponse struct {
    // in: body
    Body string
}

MachineActionPostResponse return on a successful POST of action swagger:response

type MachineActionResponse Uses

type MachineActionResponse struct {
    // in: body
    Body *models.AvailableAction
}

MachineActionResponse return on a successful GET of a single Machine Action swagger:response

type MachineActionsResponse Uses

type MachineActionsResponse struct {
    // in: body
    Body []*models.AvailableAction
}

MachineActionsResponse return on a successful GET of all Machine Actions swagger:response

type MachineBodyParameter Uses

type MachineBodyParameter struct {
    // in: query
    Force string `json:"force"`
    // in: body
    // required: true
    Body *models.Machine
}

MachineBodyParameter used to inject a Machine swagger:parameters createMachine putMachine

type MachineGetParamPathParemeter Uses

type MachineGetParamPathParemeter struct {
    // in: query
    Aggregate string `json:"aggregate"`
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
    // in: path
    //required: true
    Key string `json:"key"`
}
MachineGetParamPathParemeter used to get a single Parameter for a single Machine

swagger:parameters getMachineParam

type MachineGetParamsPathParameter Uses

type MachineGetParamsPathParameter struct {
    // in: query
    Aggregate string `json:"aggregate"`
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
}

MachineGetParamsPathParameter used to find a Machine in the path swagger:parameters getMachineParams

type MachineListPathParameter Uses

type MachineListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Uuid string
    // in: query
    Name string
    // in: query
    BootEnv string
    // in: query
    Address string
    // in: query
    Runnable string
}

MachineListPathParameter used to limit lists of Machine by path options swagger:parameters listMachines listStatsMachines

type MachineParamResponse Uses

type MachineParamResponse struct {
    // in: body
    Body interface{}
}

MachineParamResponse return on a successful GET of a single Machine param swagger:response

type MachineParamsResponse Uses

type MachineParamsResponse struct {
    // in: body
    Body map[string]interface{}
}

MachineParamsResponse return on a successful GET of all Machine's Params swagger:response

type MachinePatchBodyParameter Uses

type MachinePatchBodyParameter struct {
    // in: query
    Force string `json:"force"`
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

MachinePatchBodyParameter used to patch a Machine swagger:parameters patchMachine

type MachinePatchParamsParameter Uses

type MachinePatchParamsParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

MachinePatchBodyParameter used to patch a Machine swagger:parameters patchMachineParams

type MachinePathParameter Uses

type MachinePathParameter struct {
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
}

MachinePathParameter used to find a Machine in the path swagger:parameters putMachines getMachine putMachine patchMachine deleteMachine getMachineActions headMachine patchMachineParams postMachineParams

type MachinePostParamParameter Uses

type MachinePostParamParameter struct {
    // in: body
    // required: true
    Body interface{}
}

MachinePostParamParameter used to POST a machine parameter swagger:parameters postMachineParam

type MachinePostParamPathParemeter Uses

type MachinePostParamPathParemeter struct {
    // in: path
    // required: true
    // swagger:strfmt uuid
    Uuid uuid.UUID `json:"uuid"`
    // in: path
    //required: true
    Key string `json:"key"`
}

MachinePostParamPathParemeter used to get a single Parameter for a single Machine swagger:parameters postMachineParam

type MachinePostParamsParameter Uses

type MachinePostParamsParameter struct {
    // in: body
    // required: true
    Body map[string]interface{}
}

MachinePostParamsParameter used to POST machine parameters swagger:parameters postMachineParams

type MachineResponse Uses

type MachineResponse struct {
    // in: body
    Body *models.Machine
}

MachineResponse return on a successful GET, PUT, PATCH or POST of a single Machine swagger:response

type MachinesResponse Uses

type MachinesResponse struct {
    // in: body
    Body []*models.Machine
}

MachinesResponse return on a successful GET of all Machines swagger:response

type NoContentResponse Uses

type NoContentResponse struct {
}

NoContentResponse is returned for deletes and auth errors swagger:response

type ParamBodyParameter Uses

type ParamBodyParameter struct {
    // in: body
    // required: true
    Body *models.Param
}

ParamBodyParameter used to inject a Param swagger:parameters createParam putParam

type ParamListPathParameter Uses

type ParamListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Name string
}

ParamListPathParameter used to limit lists of Param by path options swagger:parameters listParams listStatsParams

type ParamParamsBodyParameter Uses

type ParamParamsBodyParameter struct {
    // in: body
    // required: true
    Body map[string]interface{}
}

ParamParamsBodyParameter used to set Param Params swagger:parameters postParamParams

type ParamParamsResponse Uses

type ParamParamsResponse struct {
    // in: body
    Body map[string]interface{}
}

ParamParamsResponse return on a successful GET of all Param's Params swagger:response

type ParamPatchBodyParameter Uses

type ParamPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

ParamPatchBodyParameter used to patch a Param swagger:parameters patchParam

type ParamPathParameter Uses

type ParamPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

ParamPathParameter used to name a Param in the path swagger:parameters putParams getParam putParam patchParam deleteParam getParamParams postParamParams headParam

type ParamResponse Uses

type ParamResponse struct {
    // in: body
    Body *models.Param
}

ParamResponse returned on a successful GET, PUT, PATCH, or POST of a single param swagger:response

type ParamsResponse Uses

type ParamsResponse struct {
    //in: body
    Body []*models.Param
}

ParamsResponse returned on a successful GET of all the params swagger:response

type PluginBodyParameter Uses

type PluginBodyParameter struct {
    // in: body
    // required: true
    Body *models.Plugin
}

PluginBodyParameter used to inject a Plugin swagger:parameters createPlugin putPlugin

type PluginListPathParameter Uses

type PluginListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Name string
    // in: query
    Provider string
}

PluginListPathParameter used to limit lists of Plugin by path options swagger:parameters listPlugins listStatsPlugins

type PluginParamBodyParameter Uses

type PluginParamBodyParameter struct {
    // in: body
    // required: true
    Body interface{}
}

PluginParamBodyParameter used to set Plugin Param swagger:parameters postPluginParam

type PluginParamResponse Uses

type PluginParamResponse struct {
    // in: body
    Body interface{}
}

PluginParamResponse return on a successful GET of one Plugin's Param swagger:response

type PluginParamsBodyParameter Uses

type PluginParamsBodyParameter struct {
    // in: body
    // required: true
    Body map[string]interface{}
}

PluginParamsBodyParameter used to set Plugin Params swagger:parameters postPluginParams

type PluginParamsPathParameter Uses

type PluginParamsPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
    // in: path
    // required: true
    Key string `json:"key"`
}

PluginParamsPathParameter used to find a Plugin in the path swagger:parameters getPluginParam postPluginParam

type PluginParamsResponse Uses

type PluginParamsResponse struct {
    // in: body
    Body map[string]interface{}
}

PluginParamsResponse return on a successful GET of all Plugin's Params swagger:response

type PluginPatchBodyParameter Uses

type PluginPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

PluginPatchBodyParameter used to patch a Plugin swagger:parameters patchPlugin

type PluginPathParameter Uses

type PluginPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

PluginPathParameter used to find a Plugin in the path swagger:parameters putPlugins getPlugin putPlugin patchPlugin deletePlugin getPluginParams postPluginParams headPlugin patchPluginParams

type PluginProviderData Uses

type PluginProviderData struct {
    // in: body
    Body interface{}
}

PluginProviderData body of the upload swagger:parameters uploadPluginProvider

type PluginProviderInfoResponse Uses

type PluginProviderInfoResponse struct {
    // in: body
    Body *models.PluginProviderUploadInfo
}

PluginProviderInfoResponse returned on a successful upload of an iso swagger:response

type PluginProviderParameter Uses

type PluginProviderParameter struct {
    // in: path
    Name string `json:"name"`
}

swagger:parameters getPluginProvider headPluginProviders uploadPluginProvider deletePluginProvider

type PluginProviderResponse Uses

type PluginProviderResponse struct {
    // in: body
    Body *models.PluginProvider
}

PluginProvidersResponse returned on a successful GET of an plugin_provider swagger:response

type PluginProvidersResponse Uses

type PluginProvidersResponse struct {
    // in: body
    Body []*models.PluginProvider
}

PluginProvidersResponse returned on a successful GET of all plugin_provider swagger:response

type PluginResponse Uses

type PluginResponse struct {
    // in: body
    Body *models.Plugin
}

PluginResponse return on a successful GET, PUT, PATCH or POST of a single Plugin swagger:response

type PluginsResponse Uses

type PluginsResponse struct {
    // in: body
    Body []*models.Plugin
}

PluginsResponse return on a successful GET of all Plugins swagger:response

type PrefBodyParameter Uses

type PrefBodyParameter struct {
    // in: body
    Body map[string]string
}

PrefBodyParameter is used to create or update a Pref swagger:parameters setPrefs

type PrefsResponse Uses

type PrefsResponse struct {
    // in: body
    Body map[string]string
}

PrefsResponse returned on a successful GET of all preferences swagger:response

type ProfileBodyParameter Uses

type ProfileBodyParameter struct {
    // in: body
    // required: true
    Body *models.Profile
}

ProfileBodyParameter used to inject a Profile swagger:parameters createProfile putProfile

type ProfileListPathParameter Uses

type ProfileListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Name string
}

ProfileListPathParameter used to limit lists of Profile by path options swagger:parameters listProfiles listStatsProfiles

type ProfileParamBodyParameter Uses

type ProfileParamBodyParameter struct {
    // in: body
    // required: true
    Body interface{}
}

ProfileParamBodyParameter used to set Profile Param swagger:parameters postProfileParam

type ProfileParamResponse Uses

type ProfileParamResponse struct {
    // in: body
    Body interface{}
}

ProfileParamResponse return on a successful GET of a single Param for a Profile swagger:response

type ProfileParamsBodyParameter Uses

type ProfileParamsBodyParameter struct {
    // in: body
    // required: true
    Body map[string]interface{}
}

ProfileParamsBodyParameter used to set Profile Params swagger:parameters postProfileParams

type ProfileParamsPathParameter Uses

type ProfileParamsPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
    // in: path
    // required: true
    Key string `json:"key"`
}

ProfileParamsPathParameter used to get or set a single Parameter in a Profile swagger:parameters getProfileParam postProfileParam

type ProfileParamsResponse Uses

type ProfileParamsResponse struct {
    // in: body
    Body map[string]interface{}
}

ProfileParamsResponse return on a successful GET of all Profile's Params swagger:response

type ProfilePatchBodyParameter Uses

type ProfilePatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

ProfilePatchBodyParameter used to patch a Profile swagger:parameters patchProfile patchProfileParams

type ProfilePathParameter Uses

type ProfilePathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

ProfilePathParameter used to name a Profile in the path swagger:parameters putProfiles getProfile putProfile patchProfile deleteProfile getProfileParams patchProfileParams headProfile postProfileParams

type ProfileResponse Uses

type ProfileResponse struct {
    // in: body
    Body *models.Profile
}

ProfileResponse returned on a successful GET, PUT, PATCH, or POST of a single profile swagger:response

type ProfilesResponse Uses

type ProfilesResponse struct {
    //in: body
    Body []*models.Profile
}

ProfilesResponse returned on a successful GET of all the profiles swagger:response

type ReservationBodyParameter Uses

type ReservationBodyParameter struct {
    // in: body
    // required: true
    Body *models.Reservation
}

ReservationBodyParameter used to inject a Reservation swagger:parameters createReservation putReservation

type ReservationListPathParameter Uses

type ReservationListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Addr string
    // in: query
    Token string
    // in: query
    Strategy string
    // in: query
    NextServer string
}

ReservationListPathParameter used to limit lists of Reservation by path options swagger:parameters listReservations listStatsReservations

type ReservationPatchBodyParameter Uses

type ReservationPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

ReservationPatchBodyParameter used to patch a Reservation swagger:parameters patchReservation

type ReservationPathParameter Uses

type ReservationPathParameter struct {
    // in: path
    // required: true
    // swagger:strfmt ipv4
    Address string `json:"address"`
}

ReservationPathParameter used to address a Reservation in the path swagger:parameters putReservations getReservation putReservation patchReservation deleteReservation headReservation

type ReservationResponse Uses

type ReservationResponse struct {
    // in: body
    Body *models.Reservation
}

ReservationResponse returned on a successful GET, PUT, PATCH, or POST of a single reservation swagger:response

type ReservationsResponse Uses

type ReservationsResponse struct {
    //in: body
    Body []*models.Reservation
}

ReservationsResponse returned on a successful GET of all the reservations swagger:response

type Sanitizable Uses

type Sanitizable interface {
    Sanitize() models.Model
}

type SingleIndexParameter Uses

type SingleIndexParameter struct {
    // in: path
    Prefix string `json:"prefix"`
    // in: path
    Param string `json:"param"`
}

swagger:parameters getSingleIndex

type SingleIndexResponse Uses

type SingleIndexResponse struct {
    // in: body
    Body models.Index
}

SingleIndexResponse tests to see if a single specific index exists. Unlike the other index API endpoints, you can probe for dynamic indexes this way. swagger:response

type StageBodyParameter Uses

type StageBodyParameter struct {
    // in: body
    // required: true
    Body *models.Stage
}

StageBodyParameter used to inject a Stage swagger:parameters createStage putStage

type StageListPathParameter Uses

type StageListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Name string
    // in: query
    Reboot string
    // in: query
    BootEnv string
}

StageListPathParameter used to limit lists of Stage by path options swagger:parameters listStages listStatsStages

type StagePatchBodyParameter Uses

type StagePatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

StagePatchBodyParameter used to patch a Stage swagger:parameters patchStage

type StagePathParameter Uses

type StagePathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

StagePathParameter used to name a Stage in the path swagger:parameters putStages getStage putStage patchStage deleteStage headStage

type StageResponse Uses

type StageResponse struct {
    // in: body
    Body *models.Stage
}

StageResponse returned on a successful GET, PUT, PATCH, or POST of a single stage swagger:response

type StagesResponse Uses

type StagesResponse struct {
    //in: body
    Body []*models.Stage
}

StagesResponse returned on a successful GET of all the stages swagger:response

type SubnetBodyParameter Uses

type SubnetBodyParameter struct {
    // in: body
    // required: true
    Body *models.Subnet
}

SubnetBodyParameter used to inject a Subnet swagger:parameters createSubnet putSubnet

type SubnetListPathParameter Uses

type SubnetListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Strategy string
    // in: query
    NextServer string
    // in: query
    Subnet string
    // in: query
    Name string
    // in: query
    Enabled string
    // in: query
    Proxy string
}

SubnetListPathParameter used to limit lists of Subnet by path options swagger:parameters listSubnets listStatsSubnets

type SubnetPatchBodyParameter Uses

type SubnetPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

SubnetPatchBodyParameter used to patch a Subnet swagger:parameters patchSubnet

type SubnetPathParameter Uses

type SubnetPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

SubnetPathParameter used to name a Subnet in the path swagger:parameters putSubnets getSubnet putSubnet patchSubnet deleteSubnet headSubnet

type SubnetResponse Uses

type SubnetResponse struct {
    // in: body
    Body *models.Subnet
}

SubnetResponse returned on a successful GET, PUT, PATCH, or POST of a single subnet swagger:response

type SubnetsResponse Uses

type SubnetsResponse struct {
    //in: body
    Body []*models.Subnet
}

SubnetsResponse returned on a successful GET of all the subnets swagger:response

type TaskBodyParameter Uses

type TaskBodyParameter struct {
    // in: body
    // required: true
    Body *models.Task
}

TaskBodyParameter used to inject a Task swagger:parameters createTask putTask

type TaskListPathParameter Uses

type TaskListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Name string
}

TaskListPathParameter used to limit lists of Task by path options swagger:parameters listTasks listStatsTasks

type TaskParamsBodyParameter Uses

type TaskParamsBodyParameter struct {
    // in: body
    // required: true
    Body map[string]interface{}
}

TaskParamsBodyParameter used to set Task Params swagger:parameters postTaskParams

type TaskParamsResponse Uses

type TaskParamsResponse struct {
    // in: body
    Body map[string]interface{}
}

TaskParamsResponse return on a successful GET of all Task's Params swagger:response

type TaskPatchBodyParameter Uses

type TaskPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

TaskPatchBodyParameter used to patch a Task swagger:parameters patchTask

type TaskPathParameter Uses

type TaskPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

TaskPathParameter used to find a Task in the path swagger:parameters putTasks getTask putTask patchTask deleteTask getTaskParams postTaskParams headTask

type TaskResponse Uses

type TaskResponse struct {
    // in: body
    Body *models.Task
}

TaskResponse return on a successful GET, PUT, PATCH or POST of a single Task swagger:response

type TasksResponse Uses

type TasksResponse struct {
    // in: body
    Body []*models.Task
}

TasksResponse return on a successful GET of all Tasks swagger:response

type TemplateBodyParameter Uses

type TemplateBodyParameter struct {
    // in: body
    // required: true
    Body *models.Template
}

TemplateBodyParameter used to inject a Template swagger:parameters createTemplate putTemplate

type TemplateListPathParameter Uses

type TemplateListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    ID  string
}

TemplateListPathParameter used to limit lists of Template by path options swagger:parameters listTemplates listStatsTemplates

type TemplatePatchBodyParameter Uses

type TemplatePatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

TemplatePatchBodyParameter used to patch a Template swagger:parameters patchTemplate

type TemplatePathParameter Uses

type TemplatePathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

TemplatePathParameter used to name a Template in the path swagger:parameters putTemplates getTemplate putTemplate patchTemplate deleteTemplate headTemplate

type TemplateResponse Uses

type TemplateResponse struct {
    //in: body
    Body *models.Template
}

TemplateResponse return on a successful GET, PUT, PATCH or POST of a single Template swagger:response

type TemplatesResponse Uses

type TemplatesResponse struct {
    //in: body
    Body []*models.Template
}

TemplatesResponse return on a successful GET of all templates swagger:response

type UserBodyParameter Uses

type UserBodyParameter struct {
    // in: body
    // required: true
    Body *models.User
}

UserBodyParameter used to inject a User swagger:parameters createUser putUser

type UserListPathParameter Uses

type UserListPathParameter struct {
    // in: query
    Offest int `json:"offset"`
    // in: query
    Limit int `json:"limit"`
    // in: query
    Available string
    // in: query
    Valid string
    // in: query
    ReadOnly string
    // in: query
    Name string
}

UserListPathParameter used to limit lists of User by path options swagger:parameters listUsers listStatsUsers

type UserPatchBodyParameter Uses

type UserPatchBodyParameter struct {
    // in: body
    // required: true
    Body jsonpatch2.Patch
}

UserPatchBodyParameter used to patch a User swagger:parameters patchUser

type UserPathParameter Uses

type UserPathParameter struct {
    // in: path
    // required: true
    Name string `json:"name"`
}

UserPathParameter used to name a User in the path swagger:parameters getUser putUser patchUser deleteUser getUserToken putUserPassword headUser

type UserPutPasswordParameter Uses

type UserPutPasswordParameter struct {
    // in: body
    // required: true
    Body models.UserPassword
}

UserPutPassword used to set the User's password swagger:parameters putUserPassword

type UserResponse Uses

type UserResponse struct {
    // in: body
    Body *models.User
}

UserResponse returned on a successful GET, PUT, PATCH, or POST of a single user swagger:response

type UserTokenQueryActionParameter Uses

type UserTokenQueryActionParameter struct {
    // in: query
    Action string `json:"action"`
}

swagger:parameters getUserToken

type UserTokenQueryScopeParameter Uses

type UserTokenQueryScopeParameter struct {
    // in: query
    Scope string `json:"scope"`
}

swagger:parameters getUserToken

type UserTokenQuerySpecificParameter Uses

type UserTokenQuerySpecificParameter struct {
    // in: query
    Specific string `json:"specific"`
}

swagger:parameters getUserToken

type UserTokenQueryTTLParameter Uses

type UserTokenQueryTTLParameter struct {
    // in: query
    TTL int `json:"ttl"`
}

swagger:parameters getUserToken

type UserTokenResponse Uses

type UserTokenResponse struct {
    //in: body
    Body models.UserToken
}

UserTokenResponse returned on a successful GET of user token swagger:response UserTokenResponse

type UsersResponse Uses

type UsersResponse struct {
    //in: body
    Body []*models.User
}

UsersResponse returned on a successful GET of all the users swagger:response

Package frontend imports 31 packages (graph) and is imported by 1 packages. Updated 2017-12-11. Refresh now. Tools for package owners.