language

Documentation

Overview

Package language is used to compile and run untrusted code securely. The heavy lifting is done by the great isolate library. This library comes with a lot of built-in languages, and it's easy to implement your own languages.

Index

• Variables
• type Language
  • func ListExcept(s Store, except []string) []Language
• type ListStore
  • func NewListStore() *ListStore
  • func (m *ListStore) Get(id string) (Language, error)
  • func (m *ListStore) List() []Language
  • func (m *ListStore) Register(id string, l Language)
• type NotFoundError
  • func (n NotFoundError) Error() string
  • func (n NotFoundError) Is(err error) bool
• type Store
• type Test
  • func (test Test) Run(s sandbox.Sandbox) error
• type Testable
• type Wrapper
  • func (w Wrapper) ID() string

Variables

var ErrorLanguageNotFound = errors.New("language not found")

Types

type Language

type Language interface {
	ID() string
	DisplayName() string
	DefaultFilename() string
	Compile(ctx context.Context, s sandbox.Sandbox, f sandbox.File, stderr io.Writer, extras []sandbox.File) (*sandbox.File, error) //TODO remove extras?
	Run(ctx context.Context, s sandbox.Sandbox, binary sandbox.File, stdin io.Reader, stdout io.Writer, tl time.Duration, ml memory.Amount) (*sandbox.Status, error)
}

Language is the main building block of this package, it's used to compile a source file and then run the resulting binary.

func ListExcept

func ListExcept(s Store, except []string) []Language

ListExcept returns a slice of languages except some.

type ListStore

type ListStore struct {
	LanguageList []Language
}

ListStore is a basic implementation (and probably only realistic, so maybe an interface is not really necessary) of a Store.

func NewListStore

func NewListStore() *ListStore

func (*ListStore) Get

func (m *ListStore) Get(id string) (Language, error)

func (*ListStore) List

func (m *ListStore) List() []Language

func (*ListStore) Register

func (m *ListStore) Register(id string, l Language)

type NotFoundError

type NotFoundError struct {
	ID string
}

func (NotFoundError) Error

func (n NotFoundError) Error() string

func (NotFoundError) Is

func (n NotFoundError) Is(err error) bool

type Store

type Store interface {
	Register(id string, l Language)
	List() []Language
	Get(id string) (Language, error)
}

Store is an interface which is used to capture the notion of storing languages. Via it's Store.Register method it's possible to override the underlying ID of the language for the outside world.

var DefaultStore Store

DefaultStore is a store which all Language objects should register themselves in.

type Test

type Test struct {
	Name            string
	Language        Language
	Source          string
	Input           string
	ExpectedOutput  string
	ExpectedVerdict sandbox.Verdict
	TimeLimit       time.Duration
	MemoryLimit     memory.Amount
}

Test is a struct that holds a test for a language.

func (Test) Run

func (test Test) Run(s sandbox.Sandbox) error

Run the test given a sandbox.

type Testable

type Testable interface {
	Test(*testing.T, sandbox.Sandbox) error
}

Testable is an interface that can be used to test Languages by providing a sandbox.Sandbox This will probably run a bunch of tests (most likely via defining multiple Test objects and calling Test.Run).

type Wrapper

type Wrapper struct {
	IDWrapper string
	Language
}

Wrapper overrides a Language's ID.

func (Wrapper) ID

func (w Wrapper) ID() string