lib

type Anarchy ¶

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

Anarchy - Most basic implementation of TokenAuthenticator, everyone has access to everything.

func (a *Anarchy) AuthoriseCreate(_, _ string) bool

func (a *Anarchy) AuthoriseJoin(_, _ string) bool

type Binder ¶

type Binder struct {
	ID string
	// contains filtered or unexported fields
}

Binder - Contains a single document and acts as a broker between multiple readers, writers and the storage strategy.

func NewBinder(
	id string,
	block DocumentStore,
	config BinderConfig,
	errorChan chan<- BinderError,
	log *log.Logger,
	stats *log.Stats,
) (*Binder, error)

func (b *Binder) Close()

func (b *Binder) Subscribe(token string) BinderPortal

type BinderClient ¶

type BinderClient struct {
	Token         string
	TransformChan chan<- OTransform
	MessageChan   chan<- ClientMessage
}

BinderClient - A struct containing information about a connected client and channels used by the binder to push transforms and user updates out.

type BinderConfig ¶

type BinderConfig struct {
	FlushPeriod           int64       `json:"flush_period_ms" yaml:"flush_period_ms"`
	RetentionPeriod       int64       `json:"retention_period_s" yaml:"retention_period_s"`
	ClientKickPeriod      int64       `json:"kick_period_ms" yaml:"kick_period_ms"`
	CloseInactivityPeriod int64       `json:"close_inactivity_period_s" yaml:"close_inactivity_period_s"`
	ModelConfig           ModelConfig `json:"transform_model" yaml:"transform_model"`
}

BinderConfig - Holds configuration options for a binder.

func DefaultBinderConfig() BinderConfig

type BinderError ¶

type BinderError struct {
	ID  string
	Err error
}

BinderError - A binder has encountered a problem and needs to close. In order for this to happen it needs to inform its owner that it should be shut down. BinderError is a structure used to carry our error message and our ID over an error channel. A BinderError with the Err set to nil can be used as a graceful shutdown request.

type BinderPortal ¶

type BinderPortal struct {
	Token            string
	Document         Document
	Version          int
	Error            error
	TransformRcvChan <-chan OTransform
	MessageRcvChan   <-chan ClientMessage
	TransformSndChan chan<- TransformSubmission
	MessageSndChan   chan<- MessageSubmission
	ExitChan         chan<- string
}

BinderPortal - A container that holds all data necessary to begin an open portal with the binder, allowing fresh transforms to be submitted and returned as they come. Also carries the token of the client.

func (p *BinderPortal) Exit(timeout time.Duration)

func (p *BinderPortal) SendMessage(message ClientMessage)

func (p *BinderPortal) SendTransform(ot OTransform, timeout time.Duration) (int, error)

type BinderSubscribeBundle ¶

type BinderSubscribeBundle struct {
	Token         string
	PortalRcvChan chan<- BinderPortal
}

BinderSubscribeBundle - A container that holds all data necessary to provide a binder that you wish to subscribe to. Contains a user token for identifying the client and a channel for receiving the resultant BinderPortal.

type ClientMessage ¶ added in v0.1.0

type ClientMessage struct {
	Message  string `json:"message,omitempty" yaml:"message,omitempty"`
	Position *int64 `json:"position,omitempty" yaml:"position,omitempty"`
	Active   bool   `json:"active" yaml:"active"`
	Token    string `json:"user_id" yaml:"user_id"`
}

ClientMessage - A struct containing various updates to a clients' state and an optional message to be distributed out to all other clients of a binder.

type Curator ¶

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

Curator - A structure designed to keep track of a live collection of Binders. Assists prospective clients in locating their target Binders, and when necessary creates new Binders.

The curator is fully in control of the binders, and manages their life cycles internally.

func NewCurator(
	config CuratorConfig,
	log *log.Logger,
	stats *log.Stats,
	auth TokenAuthenticator,
	store DocumentStore,
) (*Curator, error)

func (c *Curator) Close()

func (c *Curator) CreateDocument(token string, userID string, doc Document) (BinderPortal, error)

func (c *Curator) FindDocument(token, id string) (BinderPortal, error)

type CuratorConfig ¶

type CuratorConfig struct {
	BinderConfig BinderConfig `json:"binder" yaml:"binder"`
}

CuratorConfig - Holds configuration options for a curator.

func DefaultCuratorConfig() CuratorConfig

type Document ¶

type Document struct {
	ID      string `json:"id" yaml:"id"`
	Content string `json:"content" yaml:"content"`
}

Document - A representation of a leap document.

func NewDocument(content string) (*Document, error)

type DocumentStore ¶

type DocumentStore interface {
	Create(string, Document) error
	Store(string, Document) error
	Fetch(string) (Document, error)
}

DocumentStore - Implemented by types able to acquire and store documents. This is abstracted in order to accommodate for multiple storage strategies. These methods should be asynchronous if possible.

func DocumentStoreFactory(config DocumentStoreConfig) (DocumentStore, error)

func GetFileStore(config DocumentStoreConfig) (DocumentStore, error)

func GetMemoryStore(config DocumentStoreConfig) (DocumentStore, error)

func GetMockStore(config DocumentStoreConfig) (DocumentStore, error)

func GetSQLStore(config DocumentStoreConfig) (DocumentStore, error)

type DocumentStoreConfig ¶

type DocumentStoreConfig struct {
	Type           string    `json:"type" yaml:"type"`
	Name           string    `json:"name" yaml:"name"`
	StoreDirectory string    `json:"store_directory" yaml:"store_directory"`
	SQLConfig      SQLConfig `json:"sql" yaml:"sql"`
}

DocumentStoreConfig - Holds generic configuration options for a document storage solution.

func DefaultDocumentStoreConfig() DocumentStoreConfig

type FileAuthenticator ¶ added in v0.1.2

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

FileAuthenticator - A utility for using the filesystem as a way of validating that a document exists and is available to edit. This is intended to be used in tandem with the file based document store.

The FileAuthenticator takes a directory as a config option. When a client wishes to connect to a file the user token and document ID are given, where the document ID is the relative path to the target file.

The FileAuthenticator will then verify that this file exists within the configured directory. This is an attempt to isolate leaps, and avoid users connecting to paths such as ../../../etc/passwd.

func NewFileAuthenticator(config TokenAuthenticatorConfig, logger *log.Logger) *FileAuthenticator

func (f *FileAuthenticator) AuthoriseCreate(token, userID string) bool

func (f *FileAuthenticator) AuthoriseJoin(token, documentID string) bool

type FileAuthenticatorConfig ¶ added in v0.1.2

type FileAuthenticatorConfig struct {
	SharePath     string `json:"share_directory" yaml:"share_path"`
	Path          string `json:"path" yaml:"path"`
	ShowHidden    bool   `json:"show_hidden" yaml:"show_hidden"`
	RefreshPeriod int64  `json:"refresh_period_s" yaml:"refresh_period_s"`
}

FileAuthenticatorConfig - A config object for the file system authentication object.

func DefaultFileAuthenticatorConfig() FileAuthenticatorConfig

type FileStore ¶

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

FileStore - Most basic persistent implementation of DocumentStore. Simply stores each document into a file within a configured directory. The ID represents the filepath relative to the configured directory.

For example, with StoreDirectory set to /var/www, a document can be given the ID css/main.css to create and edit the file /var/www/css/main.css

func (s *FileStore) Create(id string, doc Document) error

func (s *FileStore) Fetch(id string) (Document, error)

func (s *FileStore) Store(id string, doc Document) error

type MemoryStore ¶

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

MemoryStore - Most basic implementation of DocumentStore, simply keeps the document in memory. Has zero persistence across sessions.

func (s *MemoryStore) Create(id string, doc Document) error

func (s *MemoryStore) Fetch(id string) (Document, error)

func (s *MemoryStore) Store(id string, doc Document) error

type MessageSubmission ¶ added in v0.1.0

type MessageSubmission struct {
	Token   string
	Message ClientMessage
}

MessageSubmission - A struct used to submit a message to a binder. The submission must contain the token of the client in order to avoid the message being sent back to the same client.

type Model ¶

type Model interface {
	/* PushTransform - Push a single transform to our model, and if successful, return the updated
	 * transform along with the new version of the document.
	 */
	PushTransform(ot OTransform) (OTransform, int, error)

	/* FlushTransforms - apply all unapplied transforms to content, and delete old applied
	 * in accordance with our retention period. Returns a bool indicating whether any changes
	 * were applied, and an error in case a fatal problem was encountered.
	 */
	FlushTransforms(content *string, secondsRetention int64) (bool, error)

	/* GetVersion - returns the current version of the document.
	 */
	GetVersion() int
}

Model - an interface that represents an internal operation transform model of a particular type. Initially text is the only supported transform model, however, the plan will eventually be to have different models for various types of document that should all be supported by our binder.

func CreateTextModel(config ModelConfig) Model

type ModelConfig ¶

type ModelConfig struct {
	MaxDocumentSize    uint64 `json:"max_document_size" yaml:"max_document_size"`
	MaxTransformLength uint64 `json:"max_transform_length" yaml:"max_transform_length"`
}

ModelConfig - Holds configuration options for a transform model.

func DefaultModelConfig() ModelConfig

type OModel ¶

type OModel struct {
	Version   int
	Applied   []OTransform
	Unapplied []OTransform
	// contains filtered or unexported fields
}

OModel - A representation of the transform model surrounding a document session. This keeps track of changes submitted and recently applied in order to distribute those changes to clients.

func (m *OModel) FlushTransforms(content *string, secondsRetention int64) (bool, error)

func (m *OModel) GetVersion() int

func (m *OModel) PushTransform(ot OTransform) (OTransform, int, error)

type OTransform ¶

type OTransform struct {
	Position  int    `json:"position" yaml:"position"`
	Delete    int    `json:"num_delete" yaml:"num_delete"`
	Insert    string `json:"insert" yaml:"insert"`
	Version   int    `json:"version" yaml:"version"`
	TReceived int64  `json:"received,omitempty" yaml:"received,omitempty"`
}

OTransform - A representation of a transformation relating to a leap document. This can either be a text addition, a text deletion, or both.

type RedisAuthenticator ¶

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

RedisAuthenticator - A wrapper around the Redis client that acts as an authenticator.

func NewRedisAuthenticator(config TokenAuthenticatorConfig, logger *log.Logger) *RedisAuthenticator

func (s *RedisAuthenticator) AuthoriseCreate(token, userID string) bool

func (s *RedisAuthenticator) AuthoriseJoin(token, documentID string) bool

func (s *RedisAuthenticator) DeleteKey(key string) error

func (s *RedisAuthenticator) ReadKey(key string) (string, error)

type RedisAuthenticatorConfig ¶

type RedisAuthenticatorConfig struct {
	URL          string `json:"url" yaml:"url"`
	Password     string `json:"password" yaml:"password"`
	PoolIdleTOut int64  `json:"pool_idle_s" yaml:"pool_idle_s"`
	PoolMaxIdle  int    `json:"pool_max_idle" yaml:"pool_max_idle"`
}

RedisAuthenticatorConfig - A config object for the redis authentication object.

func DefaultRedisAuthenticatorConfig() RedisAuthenticatorConfig

type SQLConfig ¶

type SQLConfig struct {
	DSN         string      `json:"dsn" yaml:"dsn"`
	TableConfig TableConfig `json:"db_table" yaml:"db_table"`
}

SQLConfig - The configuration fields for an SQL document store solution.

func DefaultSQLConfig() SQLConfig

type SQLStore ¶

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

SQLStore - A document store implementation for an SQL database.

func (m *SQLStore) Create(id string, doc Document) error

func (m *SQLStore) Fetch(id string) (Document, error)

func (m *SQLStore) Store(id string, doc Document) error

type TableConfig ¶

type TableConfig struct {
	Name       string `json:"table" yaml:"table"`
	IDCol      string `json:"id_column" yaml:"id_column"`
	ContentCol string `json:"content_column" yaml:"content_column"`
}

TableConfig - The configuration fields for specifying the table labels of the SQL database target.

func DefaultTableConfig() TableConfig

type TokenAuthenticator ¶

type TokenAuthenticator interface {
	AuthoriseCreate(token, userID string) bool
	AuthoriseJoin(token, documentID string) bool
}

TokenAuthenticator - Implemented by types able to validate tokens for editing or creating documents. This is abstracted in order to accommodate for multiple authentication strategies.

func GetAnarchy(config TokenAuthenticatorConfig) TokenAuthenticator

func TokenAuthenticatorFactory(config TokenAuthenticatorConfig, logger *log.Logger) (TokenAuthenticator, error)

type TokenAuthenticatorConfig ¶

type TokenAuthenticatorConfig struct {
	Type        string                   `json:"type" yaml:"type"`
	AllowCreate bool                     `json:"allow_creation" yaml:"allow_creation"`
	RedisConfig RedisAuthenticatorConfig `json:"redis_config" yaml:"redis_config"`
	FileConfig  FileAuthenticatorConfig  `json:"file_config" yaml:"file_config"`
}

TokenAuthenticatorConfig - Holds generic configuration options for a token based authentication solution.

func DefaultTokenAuthenticatorConfig() TokenAuthenticatorConfig

type TransformSubmission ¶ added in v0.1.0

type TransformSubmission struct {
	Token       string
	Transform   OTransform
	VersionChan chan<- int
	ErrorChan   chan<- error
}

TransformSubmission - A struct used to submit a transform to a binder. The submission must contain the token of the client, as well as two channels for returning either the corrected version of the transform if successful, or an error if the submit was unsuccessful.