common

type BaseInput struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type BroadcasterConfig struct {
	ChannelLength           int
	EventsPort              uint16
	FrontendURL             string
	PingPeriod              base.Duration
	Port                    uint16
	Proxied                 bool
	ScoreboardUpdateSecret  string
	ScoreboardUpdateTimeout base.Duration
	TLS                     TLSConfig // only used if Proxied == false
	WriteDeadline           base.Duration
}

type ByCaseName []CaseSettings

type ByGroupName []GroupSettings

type CacheOnlyInputFactoryForTesting struct {
}

type CachedInputFactory interface {
	InputFactory

	// GetInputHash returns both the hash of the input for the specified
	// os.FileInfo. It returns ok = false in case the os.FileInfo does not refer
	// to an Input.
	GetInputHash(dirname string, info os.FileInfo) (hash string, ok bool)
}

type CaseSettings struct {
	Name   string
	Weight *big.Rat
}

type CaseWeightMapping map[string]map[string]*big.Rat

type Config struct {
	Broadcaster  BroadcasterConfig
	InputManager InputManagerConfig
	Grader       GraderConfig
	Db           DbConfig
	Logging      LoggingConfig
	NewRelic     NewRelicConfig
	Metrics      MetricsConfig
	Runner       RunnerConfig
	TLS          TLSConfig
}

type Context struct {
	Context     context.Context
	Config      Config
	Log         logging.Logger
	Metrics     base.Metrics
	Tracing     tracing.Provider
	Transaction tracing.Transaction
	// contains filtered or unexported fields
}

type DbConfig struct {
	Driver         string
	DataSourceName string
}

type GraderCIConfig struct {
	CISizeLimit base.Byte
}

type GraderConfig struct {
	ChannelLength          int
	Port                   uint16
	RuntimePath            string
	MaxGradeRetries        int
	BroadcasterURL         string
	GitserverURL           string
	GitserverAuthorization string
	V1                     V1Config
	Ephemeral              GraderEphemeralConfig
	CI                     GraderCIConfig
	UseS3                  bool
}

type GraderEphemeralConfig struct {
	EphemeralSizeLimit   base.Byte
	CaseTimeLimit        base.Duration
	OverallWallTimeLimit base.Duration
	MemoryLimit          base.Byte
	PingPeriod           base.Duration
	Port                 uint16
	Proxied              bool
	TLS                  TLSConfig // only used if Proxied == false
	WriteDeadline        base.Duration
}

type GroupScorePolicy string

type GroupSettings struct {
	Cases []CaseSettings
	Name  string
}

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

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

type Input interface {
	base.SizedEntry

	// Path returns the path to the uncompressed representation of the Input
	// on-disk.
	Path() string

	// Hash is the identifier of the Input. It is typically the Git hash of the
	// tree that it represents.
	Hash() string

	// Commited returns true if the input has been verified and is committed into
	// its InputManager.
	Committed() bool

	// Verify ensures that the version of the Input stored in the filesystem
	// exists and is consistent, and commits it so that it can be added to the
	// InputManager. It is expected that Size() returns a valid size after
	// Verify() returns successfully.
	Verify() error

	// Persist stores the Input into the filesystem in a form that is
	// easily consumed and can be verified for consistency after restarting.
	// The files can be garbage collected later if there are no outstanding
	// references to the input and there is disk space pressure.
	Persist() error

	// Delete removes the filesystem version of the Input to free space.
	Delete() error

	// Settings returns the problem's settings for the Input. Problems can have
	// different ProblemSettings on different Inputs.
	Settings() *ProblemSettings
}

type InputFactory interface {
	NewInput(hash string, mgr *InputManager) Input
}

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

type InputManagerConfig struct {
	CacheSize base.Byte
}

type InputRef struct {
	Input Input
	// contains filtered or unexported fields
}

type InputsValidatorSettings struct {
	Filename string `json:"filename"`
	Language string `json:"language,omitempty"`
}

type InteractiveInterface struct {
	MakefileRules []struct {
		Targets    []string
		Requisites []string
		Compiler   string
		Params     string
		Debug      bool
	}
	ExecutableDescription struct {
		Args []string
		Env  map[string]string
	}
	Files map[string]string
}

type InteractiveSettings struct {
	Interfaces            map[string]map[string]*InteractiveInterface
	Templates             map[string]string
	Main                  string
	ModuleName            string
	ParentLang            string
	LibinteractiveVersion string
}

type LimitsSettings struct {
	ExtraWallTime        base.Duration
	MemoryLimit          base.Byte
	OutputLimit          base.Byte
	OverallWallTimeLimit base.Duration
	TimeLimit            base.Duration
}

type LiteralCaseSettings struct {
	Input                   string   `json:"in"`
	ExpectedOutput          string   `json:"out"`
	ExpectedValidatorStderr string   `json:"validator_stderr,omitempty"`
	Weight                  *big.Rat `json:"weight"`
}

type LiteralCustomValidatorSettings struct {
	Source   string          `json:"source"`
	Language string          `json:"language"`
	Limits   *LimitsSettings `json:"limits,omitempty"`
}

type LiteralInput struct {
	Cases       map[string]*LiteralCaseSettings `json:"cases"`
	Limits      *LimitsSettings                 `json:"limits,omitempty"`
	Validator   *LiteralValidatorSettings       `json:"validator,omitempty"`
	Interactive *LiteralInteractiveSettings     `json:"interactive,omitempty"`
}

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

type LiteralInteractiveSettings struct {
	IDLSource  string            `json:"idl"`
	ModuleName string            `json:"module_name"`
	ParentLang string            `json:"language"`
	MainSource string            `json:"main_source"`
	Templates  map[string]string `json:"templates"`
}

type LiteralPersistMode int

type LiteralRun struct {
	Source   string `json:"source"`
	Language string `json:"language"`
	Input    string `json:"input"`
}

type LiteralValidatorSettings struct {
	Name             ValidatorName                   `json:"name"`
	GroupScorePolicy GroupScorePolicy                `json:"group_score_policy,omitempty"`
	Tolerance        *float64                        `json:"tolerance,omitempty"`
	CustomValidator  *LiteralCustomValidatorSettings `json:"custom_validator,omitempty"`
}

type LoggingConfig struct {
	Level string
	JSON  bool
}

type MetricsConfig struct {
	Port uint16
}

type NewRelicConfig struct {
	AppName string
	License string
}

type ProblemFiles interface {
	// Stringer returns the name of the ProblemFiles.
	fmt.Stringer

	// Files returns the list of all files.
	Files() []string

	// GetContents returns the contents of a file as a []byte.
	GetContents(path string) ([]byte, error)

	// GetStringContents returns the contents of a file as string.
	GetStringContents(path string) (string, error)

	// Open returns the contents of a file as a ReadCloser.
	Open(path string) (io.ReadCloser, error)

	// Close frees all resources of the ProblemFiles.
	Close() error
}

type ProblemSettings struct {
	Cases       []GroupSettings      `json:"Cases"`
	Interactive *InteractiveSettings `json:"Interactive,omitempty"`
	Limits      LimitsSettings       `json:"Limits"`
	Slow        bool                 `json:"Slow"`
	Validator   ValidatorSettings    `json:"Validator"`
}

type Run struct {
	AttemptID   uint64   `json:"attempt_id"`
	Source      string   `json:"source"`
	Language    string   `json:"language"`
	ProblemName string   `json:"problem"`
	Commit      string   `json:"commit"`
	InputHash   string   `json:"input_hash"`
	MaxScore    *big.Rat `json:"max_score"`
	Debug       bool     `json:"debug"`
}

type RunnerConfig struct {
	Hostname           string
	PublicIP           string
	GraderURL          string
	RuntimePath        string
	CompileTimeLimit   base.Duration
	CompileOutputLimit base.Byte
	HardMemoryLimit    base.Byte
	OverallOutputLimit base.Byte
	OmegajailRoot      string
	PreserveFiles      bool
}

type ScoreRange struct {
	Min *big.Rat
	Max *big.Rat
}

type SolutionSettings struct {
	Filename                   string      `json:"filename"`
	ScoreRange                 *ScoreRange `json:"score_range,omitempty"`
	Verdict                    string      `json:"verdict,omitempty"`
	Language                   string      `json:"language,omitempty"`
	AllowFractionalPercentages bool        `json:"allow_fractional_percentages,omitempty"`
}

type TLSConfig struct {
	CertFile string
	KeyFile  string
}

type TestsSettings struct {
	Solutions        []SolutionSettings       `json:"solutions"`
	InputsValidator  *InputsValidatorSettings `json:"inputs,omitempty"`
	ExpectedMaxScore *base.Rat                `json:"max_score,omitempty"`
}

type TransmittableInput interface {
	Input

	// Transmit sends a serialized version of the Input over HTTP. It should be a
	// .tar.gz file with the Content-SHA1 header set to the hexadecimal
	// representation of the SHA-1 hash of the file.
	Transmit(http.ResponseWriter) error
}

type V1Config struct {
	Enabled          bool
	Port             uint16
	RuntimeGradePath string
	RuntimePath      string
	SendBroadcast    bool
	UpdateDatabase   bool
}

type ValidatorName string

type ValidatorSettings struct {
	Lang             *string          `json:"Lang,omitempty"`
	Name             ValidatorName    `json:"Name"`
	Tolerance        *float64         `json:"Tolerance,omitempty"`
	Limits           *LimitsSettings  `json:"Limits,omitempty"`
	GroupScorePolicy GroupScorePolicy `json:"GroupScorePolicy,omitempty"`
}