handler

Documentation

Index

• Constants
• func ConfigHandler(w http.ResponseWriter, r *http.Request) (int, error)
• func CreateAttachHandler(path string) http.Handler
• func CreateHTTPAPIHandler(iManager integration.IntegrationManager, cManager clientapi.ClientManager, ...) (http.Handler, error)
• func InstallFilters(ws *restful.WebService, manager clientapi.ClientManager)
• func MakeGzipHandler(handler http.Handler) http.Handler
• func WaitForTerminal(k8sClient kubernetes.Interface, cfg *rest.Config, request *restful.Request, ...)
• type APIHandler
• type AppConfig
• type AppHandler
  • func (fn AppHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type LocaleHandler
  • func CreateLocaleHandler() *LocaleHandler
  • func (handler *LocaleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type Localization
• type PtyHandler
• type TerminalMessage
• type TerminalResponse
• type TerminalSession
  • func (t TerminalSession) Close(status uint32, reason string)
  • func (t TerminalSession) Next() *remotecommand.TerminalSize
  • func (t TerminalSession) Read(p []byte) (int, error)
  • func (t TerminalSession) Toast(p string) error
  • func (t TerminalSession) Write(p []byte) (int, error)
• type Translation

Constants

const (
	// RequestLogString is a template for request log message.
	RequestLogString = "[%s] Incoming %s %s %s request from %s: %s"

	// ResponseLogString is a template for response log message.
	ResponseLogString = "[%s] Outcoming response to %s with %d status code"
)

const (
	// ConfigTemplateName is a name of config template
	ConfigTemplateName string = "appConfig"
	// ConfigTemplate is a template of a config
	ConfigTemplate string = "var appConfig_DO_NOT_USE_DIRECTLY = {{.}}"
)

const END_OF_TRANSMISSION = "\u0004"

Functions

func ConfigHandler

func ConfigHandler(w http.ResponseWriter, r *http.Request) (int, error)

func CreateAttachHandler

func CreateAttachHandler(path string) http.Handler

CreateAttachHandler is called from main for /api/sockjs

func CreateHTTPAPIHandler

func CreateHTTPAPIHandler(iManager integration.IntegrationManager, cManager clientapi.ClientManager,
	authManager authApi.AuthManager, sManager settings.SettingsManager,
	sbManager systembanner.SystemBannerManager) (

	http.Handler, error)

CreateHTTPAPIHandler creates a new HTTP handler that handles all requests to the API of the backend.

func InstallFilters

func InstallFilters(ws *restful.WebService, manager clientapi.ClientManager)

InstallFilters installs defined filter for given web service

func MakeGzipHandler

func MakeGzipHandler(handler http.Handler) http.Handler

MakeGzipHandler adds support for gzip compression for given handler

func WaitForTerminal

func WaitForTerminal(k8sClient kubernetes.Interface, cfg *rest.Config, request *restful.Request, sessionId string)

WaitForTerminal is called from apihandler.handleAttach as a goroutine Waits for the SockJS connection to be opened by the client the session to be bound in handleTerminalSession

Types

type APIHandler

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

APIHandler is a representation of API handler. Structure contains clientapi, Heapster clientapi and clientapi configuration.

type AppConfig

type AppConfig struct {
	// ServerTime is current server time (milliseconds elapsed since 1 January 1970 00:00:00 UTC).
	ServerTime int64 `json:"serverTime"`
}

AppConfig is a global configuration of application.

type AppHandler

type AppHandler func(http.ResponseWriter, *http.Request) (int, error)

AppHandler is an application handler.

func (AppHandler) ServeHTTP

func (fn AppHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP serves HTTP endpoint with application configuration.

type LocaleHandler

type LocaleHandler struct {
	SupportedLocales []language.Tag
}

LocaleHandler serves different localized versions of the frontend application based on the Accept-Language header.

func CreateLocaleHandler

func CreateLocaleHandler() *LocaleHandler

CreateLocaleHandler loads the localization configuration and constructs a LocaleHandler.

func (*LocaleHandler) ServeHTTP

func (handler *LocaleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

LocaleHandler serves different html versions based on the Accept-Language header.

type Localization

type Localization struct {
	Translations []Translation `json:"translations"`
}

Localization is a spec for the localization configuration of dashboard.

type PtyHandler

type PtyHandler interface {
	io.Reader
	io.Writer
	remotecommand.TerminalSizeQueue
}

PtyHandler is what remotecommand expects from a pty

type TerminalMessage

type TerminalMessage struct {
	Op, Data, SessionID string
	Rows, Cols          uint16
}

TerminalMessage is the messaging protocol between ShellController and TerminalSession.

OP DIRECTION FIELD(S) USED DESCRIPTION --------------------------------------------------------------------- bind fe->be SessionID Id sent back from TerminalResponse stdin fe->be Data Keystrokes/paste buffer resize fe->be Rows, Cols New terminal size stdout be->fe Data Output from the process toast be->fe Data OOB message to be shown to the user

type TerminalResponse

type TerminalResponse struct {
	Id string `json:"id"`
}

TerminalResponse is sent by handleExecShell. The Id is a random session id that binds the original REST request and the SockJS connection. Any clientapi in possession of this Id can hijack the terminal session.

type TerminalSession

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

TerminalSession implements PtyHandler (using a SockJS connection)

func (TerminalSession) Close

func (t TerminalSession) Close(status uint32, reason string)

Close shuts down the SockJS connection and sends the status code and reason to the client Can happen if the process exits or if there is an error starting up the process For now the status code is unused and reason is shown to the user (unless "")

func (TerminalSession) Next

func (t TerminalSession) Next() *remotecommand.TerminalSize

TerminalSize handles pty->process resize events Called in a loop from remotecommand as long as the process is running

func (TerminalSession) Read

func (t TerminalSession) Read(p []byte) (int, error)

Read handles pty->process messages (stdin, resize) Called in a loop from remotecommand as long as the process is running

func (TerminalSession) Toast

func (t TerminalSession) Toast(p string) error

Toast can be used to send the user any OOB messages hterm puts these in the center of the terminal

func (TerminalSession) Write

func (t TerminalSession) Write(p []byte) (int, error)

Write handles process->pty stdout Called from remotecommand whenever there is any output

type Translation

type Translation struct {
	File string `json:"file"`
	Key  string `json:"key"`
}

Translation is a single translation definition spec.