wsupload

Documentation

Index

• Variables
• type DataError
  • func (e DataError) Error() string
• type DataServiceInterface
• type ErrorMessage
  • func NewErrorMessage(err error) ErrorMessage
• type Handler
  • func (h *Handler) Close(status websocket.StatusCode, reason string) error
  • func (h *Handler) Handle() error
  • func (h *Handler) Send(msg interface{}) error
• type Message
• type MsgType
• type StartMessage
• type StatusMessage
  • func NewStatusMessage(uploaded int) StatusMessage

Variables

var (
	ErrInvalidMessageType = errors.New("invalid message type")
	ErrInitUpload         = errors.New("could not initialize upload")
	ErrResumeUpload       = errors.New("could not resume upload")
)

var (
	ErrClosedByClient = errors.New("closed by client")
)

var OkMessage = Message{
	Type: MsgTypeOk,
}

Types

type DataError

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

func (DataError) Error

func (e DataError) Error() string

type DataServiceInterface

type DataServiceInterface interface {
	NewUpload(identifier string, contentLength int, r io.Reader) error
	ResumeUpload(identifier string, r io.Reader) error
	GetUploadedBytes(identifier string) (int, error)
}

DataServiceInterface is an interface the websocket handler is prepared to receive.

type ErrorMessage

type ErrorMessage struct {
	Message
	Error string
}

func NewErrorMessage

func NewErrorMessage(err error) ErrorMessage

type Handler

type Handler struct {
	W       http.ResponseWriter
	R       *http.Request
	FS      DataServiceInterface
	Timeout time.Duration
	ErrCH   chan error

	// Delay between reading of successive messages.
	// This gives time for the server to handle messages
	// that are already in the system. This will typically be
	// something like 10ms.
	MessageDelay time.Duration
	// contains filtered or unexported fields
}

Websocket handler.

func (*Handler) Close

func (h *Handler) Close(status websocket.StatusCode, reason string) error

func (*Handler) Handle

func (h *Handler) Handle() error

Handle will implement the upload protocol. If an uploadId is provided it will assume that the upload is a continuing upload. Otherwise, it is a new upload.

Calling functions should assume that errors are already handled and that the connection will be closed on error. HOWEVER, in the case of success, the connection will *not* be closed. This way, the calling function can continue to send messages through this same connection.

Input error channel is to handle errors from the file service. The calling function can continue to send messages

func (*Handler) Send

func (h *Handler) Send(msg interface{}) error

type Message

type Message struct {
	Type MsgType
}

type MsgType

type MsgType string

var (
	MsgTypeInit   MsgType = "INIT"
	MsgTypeResume MsgType = "RESUME"
	MsgTypeStatus MsgType = "STATUS"
	MsgTypeOk     MsgType = "OK"
	MsgTypeError  MsgType = "ERROR"
)

type StartMessage

type StartMessage struct {
	Message
	Identifier    string
	ContentLength int
}

type StatusMessage

type StatusMessage struct {
	Message
	Uploaded int
}

func NewStatusMessage

func NewStatusMessage(uploaded int) StatusMessage