common

Documentation

Overview

Package common contains common shared types, variables and constants used throughout the project

Index

• Constants
• Variables
• func EncodeMessage(typ MessageType, msg interface{}) ([]byte, error)
• func PrependMessageType(typ MessageType, data []byte) []byte
• type Board
  • func (b Board) Len() int
  • func (b Board) Less(i, j int) bool
  • func (b Board) Swap(i, j int)
• type Client
• type Command
  • func (c Command) MarshalEasyJSON(w *jwriter.Writer)
  • func (c Command) MarshalJSON() ([]byte, error)
  • func (c *Command) UnmarshalJSON(data []byte) error
• type CommandType
• type ErrInvalidPostID
  • func (e ErrInvalidPostID) Error() string
• type ErrTooLong
  • func (e ErrTooLong) Error() string
• type Image
• type ImageCommon
• type MessageType
• type Post
• type StandalonePost
• type Thread

Constants

const (
	JPEG uint8 = iota
	PNG
	GIF
	WEBM
	PDF
	SVG
	MP4
	MP3
	OGG
	ZIP
	SevenZip
	TGZ
	TXZ
	FLAC
	NoFile
	TXT
)

Supported file formats

const (
	MaxLenName         = 50
	MaxLenAuth         = 50
	MaxLenPostPassword = 100
	MaxLenSubject      = 100
	MaxLenBody         = 2000
	MaxLinesBody       = 100
	MaxLenPassword     = 50
	MaxLenUserID       = 20
	MaxLenBoardID      = 10
	MaxLenBoardTitle   = 100
	MaxLenNotice       = 500
	MaxLenRules        = 5000
	MaxLenEightball    = 2000
	MaxLenReason       = 100
	MaxNumBanners      = 20
	MaxAssetSize       = 100 << 10
)

Maximum lengths of various input fields

const (
	LenSession    = 171
	LenImageToken = 86
)

Various cryptographic token exact lengths

Variables

var (
	ErrNameTooLong         = ErrTooLong("name")
	ErrSubjectTooLong      = ErrTooLong("subject")
	ErrPostPasswordTooLong = ErrTooLong("post password")
	ErrBodyTooLong         = ErrTooLong("post body")
	ErrInvalidCreds        = errors.New("invalid login credentials")
	ErrContainsNull        = errors.New("null byte in non-concatenated message")
)

Commonly used errors

var (
	Langs = []string{
		"en_GB", "es_ES", "pl_PL", "pt_BR", "sk_SK", "tr_TR", "uk_UA", "ya_AR",
		"ru_RU",
	}
	Themes = []string{
		"ashita", "console", "gar", "glass", "higan", "inumi", "mawaru", "moe",
		"moon", "ocean", "rave", "tea",
	}
)

Available language packs and themes. Change this, when adding any new ones.

var (
	CommandRegexp = regexp.MustCompile(`^#(flip|\d*d\d+|8ball|pyu|pcount|sw(?:\d+:)?\d+:\d+(?:[+-]\d+)?)$`)
	DiceRegexp    = regexp.MustCompile(`(\d*)d(\d+)`)
)

Common Regex expressions

var (
	// GetByIPAndBoard retrieves all Clients that match the passed IP on a board
	GetByIPAndBoard func(ip, board string) []Client

	// SendTo sends a message to a feed, if it exists
	SendTo func(id uint64, msg []byte)

	// ClosePost closes a post in a feed, if it exists
	ClosePost func(id, op uint64, msg []byte)

	// Propagate a message about a post being banned
	BanPost func(id, op uint64) error

	// Propagate a message about a post being deleted
	DeletePost func(id, op uint64) error

	// Propagate a message about an image being deleted from a post
	DeleteImage func(id, op uint64) error

	// Propagate a message about an image being spoilered
	SpoilerImage func(id, op uint64) error
)

Forwarded functions from "meguca/websockets/feeds" to avoid circular imports

var Extensions = map[uint8]string{
	JPEG:     "jpg",
	PNG:      "png",
	GIF:      "gif",
	MP3:      "mp3",
	MP4:      "mp4",
	WEBM:     "webm",
	OGG:      "ogg",
	PDF:      "pdf",
	ZIP:      "zip",
	SevenZip: "7z",
	TGZ:      "tar.gz",
	TXZ:      "tar.xz",
	FLAC:     "flac",
	TXT:      "txt",
}

Extensions maps internal file types to their canonical file extensions

var ParseBody func([]byte, string) ([][2]uint64, []Command, error)

ParseBody forwards parser.ParseBody to avoid cyclic imports in db/upkeep

Functions

func EncodeMessage

func EncodeMessage(typ MessageType, msg interface{}) ([]byte, error)

EncodeMessage encodes a message for sending through websockets or writing to the replication log.

func PrependMessageType

func PrependMessageType(typ MessageType, data []byte) []byte

PrependMessageType prepends the encoded websocket message type to an already encoded message

Types

type Board

type Board []Thread

Board is defined to enable marshalling optimizations and sorting by sticky threads

func (Board) Len

func (b Board) Len() int

func (Board) Less

func (b Board) Less(i, j int) bool

func (Board) Swap

func (b Board) Swap(i, j int)

type Client

type Client interface {
	Send([]byte)
	Redirect(board string)
	IP() string
	Close(error)
}

Client exposes some globally accessible websocket client functionality without causing circular imports

type Command

type Command struct {
	Type      CommandType
	Flip      bool
	Pyu       uint64
	SyncWatch [5]uint64
	Eightball string
	Dice      []uint16
}

Command contains the type and value array of hash commands, such as dice rolls, #flip, #8ball, etc. The Val field depends on the Type field. Dice: []uint16 Flip: bool EightBall: string SyncWatch: [5]uint64 Pyu: uint64 Pcount: uint64

func (Command) MarshalEasyJSON

func (c Command) MarshalEasyJSON(w *jwriter.Writer)

MarshalEasyJSON implements easyjson.Marshaler. Defined manually to dynamically marshal the appropriate fields by struct type.

func (Command) MarshalJSON

func (c Command) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler

func (*Command) UnmarshalJSON

func (c *Command) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes a dynamically-typed JSON-encoded command into the statically-typed Command struct

type CommandType

type CommandType uint8

CommandType are the various struct types of hash commands and their responses, such as dice rolls, #flip, #8ball, etc.

const (
	// Dice is the dice roll command type
	Dice CommandType = iota

	// Flip is the coin flip command type
	Flip

	// EightBall is the the #8ball random answer dispenser command type
	EightBall

	// SyncWatch is the synchronized timer command type for synchronizing
	// episode time during group anime watching and such
	SyncWatch

	// Pyu - don't ask
	Pyu

	// Pcount - don't ask
	Pcount
)

type ErrInvalidPostID

type ErrInvalidPostID uint64

ErrInvalidPostID signifies that the post ID passed by the client is invalid in some way. In what way exactly should be evident from the API endpoint.

func (ErrInvalidPostID) Error

func (e ErrInvalidPostID) Error() string

type ErrTooLong

type ErrTooLong string

ErrTooLong is passed, when a field exceeds the maximum string length for that specific field

func (ErrTooLong) Error

func (e ErrTooLong) Error() string

type Image

type Image struct {
	Spoiler bool `json:"spoiler,omitempty"`
	ImageCommon
	Name string `json:"name"`
}

Image contains a post's image and thumbnail data

type ImageCommon

type ImageCommon struct {
	APNG  bool `json:"apng,omitempty"`
	Audio bool `json:"audio,omitempty"`
	// Only used for file formats like OGG and MP4 that may or may not contain
	// video
	Video     bool      `json:"video,omitempty"`
	FileType  uint8     `json:"fileType"`
	ThumbType uint8     `json:"thumbType"`
	Length    uint32    `json:"length,omitempty"`
	Dims      [4]uint16 `json:"dims"`
	Size      int       `json:"size"`
	Artist    string    `json:"artist,omitempty"`
	Title     string    `json:"title,omitempty"`
	MD5       string
	SHA1      string
}

ImageCommon contains the common data shared between multiple post referencing the same image

type MessageType

type MessageType uint8

MessageType is the identifier code for websocket message types

const (
	MessageInvalid MessageType = iota

	MessageInsertPost
	MessageAppend
	MessageBackspace
	MessageSplice
	MessageClosePost

	MessageInsertImage
	MessageSpoiler
	MessageDeletePost
	MessageBanned
	MessageDeleteImage
)

1 - 29 modify post model state

const (
	MessageSynchronise MessageType = 30 + iota
	MessageReclaim

	// Send new post ID to client
	MessagePostID

	// Concatenation of multiple websocket messages to reduce transport overhead
	MessageConcat

	// Message from the client meant to invoke no operation. Mostly used as a
	// one way ping, because the JS Websocket API does not provide access to
	// pinging.
	MessageNOOP

	// Transmit current synced IP count to client
	MessageSyncCount

	// Send current server Unix time to client
	MessageServerTime

	// Redirect the client to a specific board
	MessageRedirect

	// Send a notification to a client
	MessageNotification

	// Notify the client, he needs a captcha solved
	MessageCaptcha
)

>= 30 are miscellaneous and do not write to post models

type Post

type Post struct {
	Editing  bool        `json:"editing,omitempty"`
	Banned   bool        `json:"banned,omitempty"`
	Deleted  bool        `json:"deleted,omitempty"`
	Sage     bool        `json:"sage,omitempty"`
	ID       uint64      `json:"id"`
	Time     int64       `json:"time"`
	Body     string      `json:"body"`
	Flag     string      `json:"flag,omitempty"`
	Name     string      `json:"name,omitempty"`
	Trip     string      `json:"trip,omitempty"`
	Auth     string      `json:"auth,omitempty"`
	Links    [][2]uint64 `json:"links,omitempty"`
	Commands []Command   `json:"commands,omitempty"`
	Image    *Image      `json:"image,omitempty"`
}

Post is a generic post exposed publically through the JSON API. Either OP or reply.

type StandalonePost

type StandalonePost struct {
	Post
	OP    uint64 `json:"op"`
	Board string `json:"board"`
}

StandalonePost is a post view that includes the "op" and "board" fields, which are not exposed though Post, but are required for retrieving a post with unknown parenthood.

type Thread

type Thread struct {
	Abbrev    bool   `json:"abbrev,omitempty"`
	Sticky    bool   `json:"sticky,omitempty"`
	NonLive   bool   `json:"nonLive,omitempty"`
	PostCtr   uint32 `json:"postCtr"`
	ImageCtr  uint32 `json:"imageCtr"`
	ReplyTime int64  `json:"replyTime"`
	BumpTime  int64  `json:"bumpTime"`
	Subject   string `json:"subject"`
	Board     string `json:"board"`
	Post
	Posts []Post `json:"posts"`
}

Thread is a transport/export wrapper that stores both the thread metadata, its opening post data and its contained posts. The composite type itself is not stored in the database.