models

Documentation

Index

• type AWSCPUConfig
• type AWSCost
• type AWSMemoryConfig
• type AWSMemorySize
• type AWSNetworkConfig
• type AWSNodeType
• type AWSRegionNodeTypeConfig
• type AWSStorageConfig
• type ApplicationConfig
• type ApplicationTask
• type Benchmark
• type BenchmarkConfig
• type BenchmarkController
• type BenchmarkResult
• type BenchmarkRunResults
• type CalibrationResults
• type CalibrationTestResult
• type Command
• type CommandParameter
• type DemoUiController
• type DiskUsage
• type IntensityArgument
• type LoadTester
• type LoadTesterCommand
• type LocustController
• type NetUsage
• type ResourceUsage
• type SLO
• type ServiceConfig
• type SizingResults
• type SlowCookerAppLoad
• type SlowCookerCalibrate
• type SlowCookerController
• type SlowCookerRunningPlan
• type SlowCookerRunningStep
• type TaskDefinitions

Types

type AWSCPUConfig

type AWSCPUConfig struct {
	VCPU       int     `bson:"vCPU" json:"vCPU", binding:"required"`
	CpuType    string  `bson:"cpuType" json:"cpuType", binding:"required"`
	ClockSpeed float32 `bson:"clockSpeed" json:"clockSpeed", binding:"required"`
}

type AWSCost

type AWSCost struct {
	LinuxOnDemand   float32 `bson:"linuxOnDemand" json:"linuxOnDemand", binding:"required"`
	LinuxReserved   float32 `bson:"linuxReserved" json:"linuxReserved", binding:"required"`
	WindowsOnDemand float32 `bson:"windowsOnDemand" json:"windowsOnDemand", binding:"required"`
	WindowsReserved float32 `bson:"windowsReserved" json:"windowsReserved", binding:"required"`
}

type AWSMemoryConfig

type AWSMemoryConfig struct {
	Size AWSMemorySize `bson:"size" json:"size", binding:"required"`
}

type AWSMemorySize

type AWSMemorySize struct {
	Value float32 `bson:"value" json:"value", binding:"required"`
	Unit  string  `bson:"unit" json:"unit", binding:"required"`
}

type AWSNetworkConfig

type AWSNetworkConfig struct {
	NetworkType       string  `bson:"networkType" json:"networkType", binding:"required"`
	Bandwidth         float32 `bson:"bandwidth" json:"bandwidth"`
	EnhanceNetworking bool    `bson:"enhancedNetworking" json:"enhancedNetworking"`
}

type AWSNodeType

type AWSNodeType struct {
	Name string `bson:"name" json:"name", binding:"required"`

	Category      string           `bson:"category" json:"category", binding:"required"`
	HourlyCost    AWSCost          `bson:"cost" json:"cost", binding:"required"`
	CpuConfig     AWSCPUConfig     `bson:"cpuConfig" json:"cpuConfig", binding:"required"`
	MemoryConfig  AWSMemoryConfig  `bson:"memoryConfig" json:"memoryConfig", binding:"required"`
	NetworkConfig AWSNetworkConfig `bson:"networkConfig" json:"networkConfig", binding:"required"`
	StorageConfig AWSStorageConfig `bson:"storageConfig" json:"storageConfig", binding:"required"`
	// contains filtered or unexported fields
}

type AWSRegionNodeTypeConfig

type AWSRegionNodeTypeConfig struct {
	Data   []AWSNodeType `bson:"data" json:"data"`
	Region string        `bson:"region" json:"region"`
}

type AWSStorageConfig

type AWSStorageConfig struct {
	Size        float32 `bson:"size" json:"size"`
	StorageType string  `bson:"storageType" json:"storageType", binding:"required"`
	Bandwidth   float32 `bson:"bandwidth" json:"bandwidth"`
}

type ApplicationConfig

type ApplicationConfig struct {
	Name               string            `bson:"name" json:"name"`
	DeploymentFile     string            `bson:"deploymentFile" json:"deploymentFile"`
	DeploymentTemplate string            `bson:"deploymentTemplate" json:"deploymentTemplate"`
	TaskDefinitions    []ApplicationTask `bson:"taskDefinitions" json:"taskDefinitions"`
	ServiceNames       []string          `bson:"serviceNames" json:"serviceNames"`
	LoadTester         LoadTester        `bson:"loadTester" json:"loadTester"`
	Type               string            `bson:"type" json:"type"`
	SLO                SLO               `bson:"slo" json:"slo"`
}

type ApplicationTask

type ApplicationTask struct {
	NodeMapping    interface{} `bson:"nodeMapping" json:"nodeMapping"`
	TaskDefinition interface{} `bson:"taskDefinition" json:"taskDefinition"`
}

type Benchmark

type Benchmark struct {
	Name         string            `bson:"name" json:"name"`
	ResourceType string            `bson:"resourceType" json:"resourceType"`
	Image        string            `bson:"image" json:"image"`
	Intensity    int               `bson:"intensity" json:"intensity"`
	Configs      []BenchmarkConfig `bson:"configs" json:"configs"`
}

type BenchmarkConfig

type BenchmarkConfig struct {
	Name           string                         `bson:"name" json:"name"`
	DurationConfig *benchmarkagent.DurationConfig `bson:"durationConfig" json:"durationConfig" binding:"required`
	CgroupConfig   *benchmarkagent.CgroupConfig   `bson:"cgroupConfig" json:"cgroupConfig"`
	HostConfig     *benchmarkagent.HostConfig     `bson:"hostConfig" json:"hostConfig"`
	NetConfig      *benchmarkagent.NetConfig      `bson:"netConfig" json:"netConfig"`
	IOConfig       *benchmarkagent.IOConfig       `bson:"ioConfig" json:"ioConfig"`
	Command        Command                        `bson:"command" json:"command" binding:"required"`
	PlacementHost  string                         `bson:"placementHost" json:"placementHost"`
}

type BenchmarkController

type BenchmarkController struct {
	InitializeType string            `bson:"initializeType" json:"initializeType"`
	Initialize     *Command          `bson:"initialize" json:"initialize"`
	Command        LoadTesterCommand `bson:"command" json:"command"`
	ParserUrl      *string           `bson:"parserUrl,omitempty" json:"parserUrl,omitempty"`
}

type BenchmarkResult

type BenchmarkResult struct {
	Benchmark string  `bson:"benchmark" json:"benchmark"`
	Intensity int     `bson:"intensity" json:"intensity"`
	QosValue  float64 `bson:"qosValue" json:"qosValue"`
	Failures  uint64  `bson:"failures" json:"failures"`
}

type BenchmarkRunResults

type BenchmarkRunResults struct {
	TestId                string             `bson:"testId" json:"testId"`
	AppName               string             `bson:"appName" json:"appName"`
	NumServices           int                `bson:"numServices" json:"numServices"`
	Services              []string           `bson:"services" json:"services"`
	ServiceInTest         string             `bson:"serviceInTest" json:"serviceInTest"`
	ServiceNode           string             `bson:"serviceNode" json:"serviceNode"`
	LoadTester            string             `bson:"loadTester" json:"loadTester"`
	AppCapacity           float64            `bson:"appCapacity" json:"appCapacity"`
	SloMetric             string             `bson:"sloMetric" json:"sloMetric"`
	SloTolerance          float64            `bson:"sloTolerance" json:"sloTolerance"`
	TestDuration          string             `bson:"testDuration" json:"testDuration"`
	Benchmarks            []string           `bson:"benchmarks" json:"benchmarks"`
	TestResult            []*BenchmarkResult `bson:"testResult" json:"testResult"`
	ToleratedInterference []struct {
		Benchmark string `bson:"benchmark" json:"benchmark"`
		Intensity int    `bson:"intensity" json:"intensity"`
	} `bson:"toleratedInterference" json: "toleratedInterference"`
}

type CalibrationResults

type CalibrationResults struct {
	TestId       string                  `bson:"testId" json:"testId"`
	AppName      string                  `bson:"appName" json:"appName"`
	LoadTester   string                  `bson:"loadTester" json:"loadTester"`
	QosMetrics   []string                `bson:"qosMetrics" json:"qosMetrics"`
	TestDuration string                  `bson:"testDuration" json:"testDuration"`
	TestResults  []CalibrationTestResult `bson:"testResult" json:"testResult"`
	FinalResult  *CalibrationTestResult  `bson:"finalResult" json:"finalResult"`
}

type CalibrationTestResult

type CalibrationTestResult struct {
	LoadIntensity float64 `bson:"loadIntensity" json:"loadIntensity"`
	QosValue      float64 `bson:"qosValue" json:"qosValue"`
	Failures      uint64  `bson:"failures" json:"failures"`
}

type Command

type Command struct {
	Image          string           `bson:"image" json:"image"`
	Path           string           `bson:"path" json:"path"`
	Args           []string         `bson:"args" json:"args"`
	ServiceConfigs *[]ServiceConfig `bson:"serviceConfigs,omitempty" json:"serviceConfigs,omitempty"`
}

type CommandParameter

type CommandParameter struct {
	Position    int    `bson:"pos" json:"pos"`
	Arg         string `bson:"arg" json:"arg"`
	Description string `bson:"description" json:"description"`
}

CommandParameter descripes a command line tool's parameter

type DemoUiController

type DemoUiController struct {
}

type DiskUsage

type DiskUsage struct {
	BytesReadPerSec  int `bson:"bytesReadPerSec" json:"bytesReadPerSec", binding:"required"`
	BytesWritePerSec int `bson:"bytesWritePerSec" json:"bytesWritePerSec", binding:"required"`
	OpsReadPerSec    int `bson:"OpsReadPerSec" json:"OpsReadPerSec", binding:"required"`
	OpsWritePerSec   int `bson:"OpsWritePerSec" json:"OpsWritePerSec", binding:"required"`
}

type IntensityArgument

type IntensityArgument struct {
	Name          string `bson:"name" json:"name"`
	Arg           string `bson:"arg" json:"arg"`
	StartingValue int    `bson:"startingValue" json:"startingValue"`
	Step          int    `bson:"step" json:"step"`
}

type LoadTester

type LoadTester struct {
	Name                 string                `bson:"name" json:"name"`
	Scenario             string                `bson:"scenario" json:"scenario"`
	BenchmarkController  *BenchmarkController  `bson:"benchmarkController" json:"benchmarkController"`
	LocustController     *LocustController     `bson:"locustController" json:"locustController"`
	SlowCookerController *SlowCookerController `bson:"slowCookerController" json:"slowCookerController"`
	DemoUiController     *DemoUiController     `bson:"demoUiController" json:"demoUiController"`
}

type LoadTesterCommand

type LoadTesterCommand struct {
	Image          string              `bson:"image" json:"image"`
	Path           string              `bson:"path" json:"path"`
	Args           []string            `bson:"args" json:"args"`
	ServiceConfigs *[]ServiceConfig    `bson:"serviceConfigs,omitempty" json:"serviceConfigs,omitempty"`
	IntensityArgs  []IntensityArgument `bson:"intensityArgs" json:"intensityArgs"`
}

type LocustController

type LocustController struct {
	StartCount   int    `bson:"startCount" json:"startCount"`
	EndCount     int    `bson:"endCount" json:"endCount"`
	StepCount    int    `bson:"stepCount" json:"stepCount"`
	StepDuration string `bson:"stepDuration" json:"stepDuration"`
}

type NetUsage

type NetUsage struct {
	BytesReceivedPerSec int `bson:"bytesReceivedPerSec" json:"bytesReceivedPerSec", binding:"required"`
	BytesSentPerSec     int `bson:"bytesSentPerSec" json:"bytesSentPerSec", binding:"required"`
}

type ResourceUsage

type ResourceUsage struct {
	CpuUtilization float64   `bson:"cpuUtilization" json:"cpuUtilization", binding:"required"`
	MemUsage       float64   `bson:"memUsage" json:"memUsage", binding:"required"`
	NetUsage       NetUsage  `bson:"netUsage" json:"netUsage", binding:"required"`
	DiskUsage      DiskUsage `bson:"diskUsage" json:"diskUsage", binding:"required"`
}

type SLO

type SLO struct {
	Metric string  `bson:"metric" json:"metric"`
	Value  float64 `bson:"value" json:"value"`
	Type   string  `bson:"type" json:"type"`
}

type ServiceConfig

type ServiceConfig struct {
	Name       string            `bson:"name" json:"name"`
	HostConfig *CommandParameter `bson:"hostConfig,omitempty" json:"hostConfig,omitempty"`
	PortConfig *CommandParameter `bson:"portConfig,omitempty" json:"portConfig,omitempty"`
}

ServiceConfig a struct that describes the address of the corresponding service

type SizingResults

type SizingResults struct {
	RunId     string `bson:"runID" json:"runId", binding:"required"`
	Duration  int    `bson:"duration" json:"duration", binding:"required"`
	AppName   string `bson:"appName" json:"appName", binding:"required"`
	SloResult SLO    `bson:"sloResult" json:"sloResult", binding:"required"`
}

type SlowCookerAppLoad

type SlowCookerAppLoad struct {
	Qps           int                   `bson:"qps" json:"qps"`
	Concurrency   int                   `bson:"concurrency" json:"concurrency"`
	Url           string                `bson:"url" json:"url"`
	Method        string                `bson:"method" json:"method"`
	TotalRequests int                   `bson:"totalRequests" json:"totalRequests"`
	Data          string                `bson:"data" json:"data"`
	Noreuse       bool                  `bson:"noreuse" json:"noreuse"`
	Plan          SlowCookerRunningPlan `bson:"plan" json:"plan"`
}

type SlowCookerCalibrate

type SlowCookerCalibrate struct {
	InitialConcurrency int `bson:"initialConcurrency" json:"initialConcurrency"`
	Step               int `bson:"step" json:"step"`
	RunsPerIntensity   int `bson:"runsPerIntensity" json:"runsPerIntensity"`
}

type SlowCookerController

type SlowCookerController struct {
	AppLoad   *SlowCookerAppLoad   `bson:"appLoad" json:"appLoad"`
	Calibrate *SlowCookerCalibrate `bson:"calibrate" json:"calibrate"`
	LoadTime  string               `bson:"loadTime" json:"loadTime"`
}

type SlowCookerRunningPlan

type SlowCookerRunningPlan struct {
	RunningSteps []*SlowCookerRunningStep `json:"runningSteps"`
}

type SlowCookerRunningStep

type SlowCookerRunningStep struct {
	Qps         int    `json:"qps" binding:"required"`
	Concurrency int    `json:"concurrency" binding:"required"`
	Duration    string `json:"duration" binding:"required"`
}

TODO: Import all slow cooker structs instead

type TaskDefinitions

type TaskDefinitions struct {
	LoadTests    []deployer.KubernetesTask `bson:"loadTests" json:"loadTests"`
	Applications []deployer.KubernetesTask `bson:"applications" json:"applications"`
}