lobster

type APIHandlerFunc func(http.ResponseWriter, *http.Request, int, []byte)

type AccountCreatedEmail struct {
	UserId   int
	Username string
	Email    string
}

type AccountPasswordForm struct {
	OldPassword        string `schema:"old_password"`
	NewPassword        string `schema:"new_password"`
	NewPasswordConfirm string `schema:"new_password_confirm"`
}

type AdminFormParams struct {
	Frame FrameParams
	Token string
}

type AdminHandlerFunc func(http.ResponseWriter, *http.Request, *Session, FrameParams)

type AdminImagesAddForm struct {
	Name           string `schema:"name"`
	Region         string `schema:"region"`
	Identification string `schema:"identification"`
}

type AdminImagesParams struct {
	Frame   FrameParams
	Images  []*Image
	Regions []string
	Token   string
}

type AdminPlanParams struct {
	Frame   FrameParams
	Plan    *Plan
	Regions []string
	Token   string
}

type AdminPlansAddForm struct {
	Name      string  `schema:"name"`
	Price     float64 `schema:"price"`
	Ram       int     `schema:"ram"`
	Cpu       int     `schema:"cpu"`
	Storage   int     `schema:"storage"`
	Bandwidth int     `schema:"bandwidth"`
	Global    string  `schema:"global"`
}

type AdminPlansParams struct {
	Frame   FrameParams
	Plans   []*Plan
	Regions []string
	Token   string
}

type AdminRegionsParams struct {
	Frame   FrameParams
	Regions []Region
	Token   string
}

type AdminUserCreditForm struct {
	Credit      float64 `schema:"credit"`
	Description string  `schema:"description"`
}

type AdminUserParams struct {
	Frame           FrameParams
	User            *User
	StatusAction    string // action that admin can take on this user, either "disable" or "enable" depending on current user status
	VirtualMachines []*VirtualMachine
	Token           string
}

type AdminUserProcessFunc func(w http.ResponseWriter, r *http.Request, session *Session, frameParams FrameParams, user *User)

type AdminUsersParams struct {
	Frame FrameParams
	Users []*User
}

type AdminVirtualMachinesParams struct {
	Frame           FrameParams
	VirtualMachines []*VirtualMachine
}

type ApiActionRestriction struct {
	Path   string `json:"path"`
	Method string `json:"method"`
}

type ApiAddForm struct {
	Label          string `schema:"label"`
	RestrictAction string `schema:"restrict_action"`
	RestrictIp     string `schema:"restrict_ip"`
}

type ApiKey struct {
	Id          int
	Label       string
	UserId      int
	ApiId       string
	CreatedTime time.Time
	Nonce       int64

	// only set on apiCreate
	ApiKey string
}

type AuthCreateForm struct {
	Username    string `schema:"username"`
	Password    string `schema:"password"`
	Email       string `schema:"email"`
	AcceptTerms string `schema:"acceptTermsOfService"`
}

type AuthLoginForm struct {
	Username string `schema:"username"`
	Password string `schema:"password"`
}

type AuthPwresetParams struct {
	Title         string
	Message       string
	Token         string
	PwresetUserId string
	PwresetToken  string
}

type AuthPwresetRequestForm struct {
	Username string `schema:"username"`
	Email    string `schema:"email"`
}

type AuthPwresetSubmitForm struct {
	UserId          int    `schema:"pwreset_user_id"`
	Token           string `schema:"pwreset_token"`
	Password        string `schema:"password"`
	PasswordConfirm string `schema:"password_confirm"`
}

type BandwidthSummary struct {
	Used            int64
	Allocated       int64
	Billed          int64
	NotifiedPercent int
	ActualPercent   float64
}

type BandwidthUsageEmail struct {
	UtilPercent int
	Region      string
	Fee         int64
}

type Charge struct {
	Id     int
	UserId int
	Name   string
	Detail string
	Key    string
	Time   time.Time
	Amount int64
}

type Config struct {
	Default              ConfigDefault
	Vm                   ConfigVm
	Billing              ConfigBilling
	BillingNotifications ConfigBillingNotifications
	BillingTermination   ConfigBillingTermination
	Session              ConfigSession
	Database             ConfigDatabase
	Http                 ConfigHttp
	Email                ConfigEmail
	Novnc                ConfigNovnc
	Wssh                 ConfigWssh
}

type ConfigBilling struct {
	BandwidthOverageFee float64
	StorageFee          float64
	Currency            string
	BillingInterval     int
	BillingVmMinimum    int
	DepositMinimum      float64
	DepositMaximum      float64
}

type ConfigBillingNotifications struct {
	LowBalanceIntervals int
	Frequency           int
}

type ConfigBillingTermination struct {
	TerminateBalanceIntervals int
	TerminateMinNotifications int
	SuspendBalanceIntervals   int
	SuspendMinNotifications   int
}

type ConfigDatabase struct {
	Host     string
	Username string
	Password string
	Name     string
}

type ConfigDefault struct {
	UrlBase     string
	AdminEmail  string
	FromEmail   string
	ProxyHeader string
	Debug       bool
	Language    string
}

type ConfigEmail struct {
	Host     string
	Port     int
	NoTLS    bool
	Username string
	Password string
}

type ConfigHttp struct {
	Addr string
}

type ConfigNovnc struct {
	Url    string
	Listen string
}

type ConfigSession struct {
	Domain string
	Secure bool
}

type ConfigVm struct {
	MaximumIps int
}

type ConfigWssh struct {
	Url    string
	Listen string
}

type CreditSummary struct {
	Credit        int64
	Hourly        int64
	Daily         int64
	Monthly       int64
	DaysRemaining string
	Status        string
}

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

type EmailParams struct {
	UserId   int
	Username string
	Email    string
	UrlBase  string
	Params   interface{}
}

type ErrorEmail struct {
	Error       string
	Description string
	Detail      string
}

type FrameParams struct {
	Message    utils.Message
	Error      bool
	UserId     int
	Admin      bool
	OriginalId int      // non-zero only if admin is logged in as another user
	Styles     []string // additional CSS
	Scripts    []string // additional JS
}

type Image struct {
	Id             int
	UserId         int
	Region         string
	Name           string
	Identification string
	Status         string
	SourceVm       int

	Info *ImageInfo
}

type ImageAddForm struct {
	Region   string `schema:"region"`
	Name     string `schema:"name"`
	Location string `schema:"location"`
	Format   string `schema:"format"`
}

type ImageInfo struct {
	Size    int64
	Status  ImageStatus
	Details map[string]string
}

type ImageStatus int

type IpAddress struct {
	Ip        string
	PrivateIp string // blank means N/A

	CanRdns  bool
	Hostname string // current rDNS setting, always blank if CanRdns is false
}

type KeyAddForm struct {
	Name string `schema:"name"`
	Key  string `schema:"key"`
}

type LowCreditEmail struct {
	Credit         int64
	Hourly         int64
	RemainingHours int
}

type NewVMRegionForm struct {
	Name    string `schema:"name"`
	PlanId  int    `schema:"plan_id"`
	ImageId int    `schema:"image_id"`
	KeyId   int    `schema:"key_id"`
}

type PanelAccountParams struct {
	Frame FrameParams
	User  *User
	Keys  []*ApiKey
	Token string
}

type PanelBillingParams struct {
	Frame          FrameParams
	CreditSummary  *CreditSummary
	PaymentMethods []string
}

type PanelChargesParams struct {
	Frame   FrameParams
	Year    int
	Month   time.Month
	Charges []*Charge

	Previous time.Time
	Next     time.Time
}

type PanelDashboardParams struct {
	Frame            FrameParams
	VirtualMachines  []*VirtualMachine
	CreditSummary    *CreditSummary
	BandwidthSummary map[string]*BandwidthSummary
	WidgetData       map[string]interface{}
}

type PanelFormParams struct {
	Frame FrameParams
	Token string
}

type PanelHandlerFunc func(http.ResponseWriter, *http.Request, *Session, FrameParams)

type PanelImageDetailsParams struct {
	Frame FrameParams
	Image *Image
}

type PanelImagesParams struct {
	Frame   FrameParams
	Images  []*Image
	Regions []string
	Token   string
}

type PanelKeysParams struct {
	Frame FrameParams
	Keys  []*SSHKey
	Token string
}

type PanelNewVMParams struct {
	Frame   FrameParams
	Regions []string
}

type PanelNewVMRegionParams struct {
	Frame        FrameParams
	Region       string
	PublicImages []*Image
	UserImages   []*Image
	Plans        []*Plan
	Keys         []*SSHKey
	Token        string
}

type PanelVMParams struct {
	Frame  FrameParams
	Vm     *VirtualMachine
	Images []*Image
	Plans  []*Plan
	Token  string
}

type PanelVirtualMachinesParams struct {
	Frame           FrameParams
	VirtualMachines []*VirtualMachine
}

type PanelWidget interface {
	// returns struct that will be passed to the panel dashboard template
	Prepare(session *Session) interface{}
}

type PanelWidgetFunc func(*Session) interface{}

type PayForm struct {
	Gateway string  `schema:"gateway"`
	Amount  float64 `schema:"amount"`
}

type PaymentInterface interface {
	Payment(w http.ResponseWriter, r *http.Request, frameParams FrameParams, userId int, username string, amount float64)
}

type PaymentProcessedEmail *Transaction

type Plan struct {
	Id        int
	Name      string
	Price     int64
	Ram       int
	Cpu       int
	Storage   int
	Bandwidth int
	Global    bool
	Enabled   bool

	// region-specific identification from planGet
	Identification string

	// loadable region bindings, if not global
	// maps from region to identification
	RegionPlans map[string]string

	// loadable metadata (key-value pairs)
	Metadata map[string]string
}

type PwresetRequestEmail string

type Region struct {
	Region  string
	Enabled bool
}

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

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

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

type SSHKey struct {
	ID     int
	UserID int
	Name   string
	Key    string
}

type Session struct {
	Id         string
	UserId     int
	Admin      bool
	OriginalId int // user id prior to logging in as another user
	Regenerate bool
}

type SplashTemplateParams struct {
	Title   string
	Message string
	Token   string
}

type Transaction struct {
	Id                int
	UserId            int
	Gateway           string
	GatewayIdentifier string
	Notes             string
	Amount            int64
	Fee               int64
	Time              time.Time
}

type User struct {
	Id                int
	Username          string
	Email             string
	CreateTime        time.Time
	Credit            int64
	VmLimit           int
	LastBillingNotify time.Time
	Status            string
	Admin             bool
}

type VMIAddresses interface {
	VmAddresses(vm *VirtualMachine) ([]*IpAddress, error)
	VmAddAddress(vm *VirtualMachine) error
	VmRemoveAddress(vm *VirtualMachine, ip string, privateip string) error
	VmSetRdns(vm *VirtualMachine, ip string, hostname string) error
}

type VMIImages interface {
	// Download an image from an external URL.
	// Format is currently either 'template' or 'iso' in the form, although user may provide arbitrary format string.
	ImageFetch(url string, format string) (string, error)

	ImageInfo(imageIdentification string) (*ImageInfo, error)
	ImageDelete(imageIdentification string) error

	// List public images in backend.
	// Only Name, Identification should be set.
	ImageList() ([]*Image, error)
}

type VMIPlans interface {
	PlanList() ([]*Plan, error)
}

type VMIReimage interface {
	VmReimage(vm *VirtualMachine, imageIdentification string) error
}

type VMIRename interface {
	VmRename(vm *VirtualMachine, name string) error
}

type VMIResize interface {
	VmResize(vm *VirtualMachine, plan *Plan) error
}

type VMISnapshot interface {
	// On success, should return image identification of a created snapshot.
	// (if backend store images and snapshots separately, the interface can tag the identification, e.g. "snapshot:XYZ" and "image:ABC")
	VmSnapshot(vm *VirtualMachine) (string, error)
}

type VMIVmCreateOptions struct {
	ImageIdentification string
	SSHKey              SSHKey
}

type VMIVnc interface {
	// On success, url is a link that we should redirect to.
	VmVnc(vm *VirtualMachine) (string, error)
}

type VMReimageForm struct {
	Image int `schema:"image"`
}

type VMResizeForm struct {
	PlanId int `schema:"plan_id"`
}

type VirtualMachine struct {
	Id             int
	UserId         int
	Region         string
	Name           string
	Identification string
	Status         string
	TaskPending    bool
	ExternalIP     string
	PrivateIP      string
	CreatedTime    time.Time
	Suspended      string
	Plan           Plan
	User           User

	Info      *VmInfo
	Addresses []*IpAddress
}

type VmActionDescriptor struct {
	Action      string
	Name        string            // used for button text
	Options     map[string]string // if non-nil, set of options to offer in modal / dropdown menu; not used for sanitization!
	Description string            // if non-empty, will be displayed in a modal
	Dangerous   bool              // if true, we will have confirmation window
}

type VmCreateEmail struct {
	Id   int
	Name string
}

type VmCreateErrorEmail struct {
	Id   int
	Name string
}

type VmCreateOptions struct {
	KeyID int
}

type VmDeletedEmail struct {
	Id   int
	Name string
}

type VmInfo struct {
	Ip            string
	PrivateIp     string
	Status        string
	Hostname      string
	BandwidthUsed int64 // in bytes
	LoginDetails  string
	Details       map[string]string
	Actions       []*VmActionDescriptor

	// these fields are filled in by lobster, so VM interface should generally not set
	// occassionally it may be useful for interface to override though
	//   these are autodetected from whether we can cast the interface, so if
	//    interface discovers that some capabilities aren't supported on some
	//    virtual machines, it may want to override that
	//   in that event it should set OverrideCapabilities
	CanVnc               bool
	CanReimage           bool
	CanSnapshot          bool
	CanResize            bool
	CanAddresses         bool
	OverrideCapabilities bool
	PendingSnapshots     []*Image
}

type VmInterface interface {
	// Creates a virtual machine with the given name and plan (specified in vm object), and image.
	// Returns vmIdentification string and optional error.
	// Should return vmIdentification != "" only if err == nil.
	VmCreate(vm *VirtualMachine, options *VMIVmCreateOptions) (string, error)

	// Deletes the specified virtual machine.
	VmDelete(vm *VirtualMachine) error

	VmInfo(vm *VirtualMachine) (*VmInfo, error)

	VmStart(vm *VirtualMachine) error
	VmStop(vm *VirtualMachine) error
	VmReboot(vm *VirtualMachine) error

	// action is an element of VmInfo.Actions (although this is not guaranteed)
	VmAction(vm *VirtualMachine, action string, value string) error

	// returns the number of bytes transferred by the given VM since the last call
	// if this is the first call, then BandwidthAccounting must return zero
	BandwidthAccounting(vm *VirtualMachine) int64
}

type VmUnsuspendEmail struct {
	Name string
}