config

type Config struct {
	Name string // Everyone has a name, stored in ${CONFIG}

	// Imports defines configuration file(s) to be loaded as template. It could be a single
	// string, or a string list([]string), each of which is a absolute or relative file path.
	// While relative path is used, it is relate to this config file.
	//
	// All the Hosts/Messages/Tests/Env/Options defined inside those template configurations
	// will be copied to this config except the same key already defined.
	//
	// If global template is specified by `-template <path>`, template will be imported before
	// this.
	Imports interface{}

	// Functions defines several functions, each one is stored inside a map, with a function name
	// as map key.
	// A function is a command line(a string) or a command group(a string list: []string) defined
	// by config and called by command `call`.
	// Command(s) inside function could visit arguments by $n. $0 is always the name of function,
	// and $1 is the first argument, $2 is the second argument, ...
	// Command `call` will pass function name and all required arguments, for example: `call add 3 5` will
	// execute function `add` with argument 1($1) is `3` and argument 2($2) is `5`.
	Functions map[string]interface{}

	// predefined hosts map that referred by a key string.
	// if key is "-", this host is applied to those Tests defined without an explicit Test.Host.
	Hosts map[string]*Host

	Messages map[string]*Request // predefined request map messages that referred by key string
	// predefined tests. key will be test name, and value will be test definition.
	// NOTE that there are some special names:
	//  - "^": executed before any schedule for just once, often used as global initialize
	//  - "$": executed after all schedules for just once, often used as global cleanup
	//  - "<": executed in each schedule as the first test for one time even schedule loops
	//  - ">": executed in each schedule as the last test for one time even schedule loops
	Tests map[string]*Test

	Mode      RunMode     // how to run schedules, default RunPipe
	Schedules []*Schedule // all test schedules, each one runs a series of tests

	Env     map[string]string // Env defines predefined global environment variables.
	Options map[Option]string // options globally
}

type FileServer struct {
	Port int    // TCP port to listen File server
	Path string // local file system path
}

type GOptions struct {
	Vars          map[string]string // "-e"
	Template      string            // "-t"
	Configs       []string          // "-config" or configuration list
	HTTPServerCfg string            // "-httpsrv"
	FileServer    string            // "-fs"
	Call          string            // "-call"
	Final         string            // "-f"
	GoMarkPort    int               // "-gm"
	Plugins       string
}

type Host struct {
	// format: http://domain[:port][/more[/more...]], https is not supported yet.
	Host string
	// Proxy defines a proxy used to access Host.
	// format: <protocol>://[user:password@]domain[:port], protocol could be http or socks5
	Proxy string
}

type HttpServer struct {
	Address string            // ":0" or ":port" or "ip:port"
	Routes  []*Route          // HTTP server routers
	Report  Report            // Optional reporter, may used in router processing
	Env     map[string]string // predefined global variables
}

type HttpServers struct {
	// Servers represented by a name
	Servers map[string]*HttpServer
}

type Option string

type Report struct {
	// Path defines file path where report will write to.
	//
	// If Path is a relative path like "a/b/c", it will be treated to be relative
	// to config file path. For example, config file path is: "/home/user/test/gmeter.json",
	// Path will be converted to "/home/user/test/a/b/c".
	//
	// If Path already exists, it will be truncated if Append is false.
	//
	// Any necessary parents in path will be created.
	//
	// [dynamic]
	Path string
	// if Append is true, instead of truncating exist file, report content will be appended in
	// that file.
	Append bool

	// Format defines a default format of report content. it's implicitly quoted as argument
	// if command `report` is used without given an argument `-f <format>`.
	//
	// For example, this will write response of every successful response body:
	// 		"$(RESPONSE)\n"
	// or this will create a json to save request body, response status, and response body.
	//		"{\"Request\": $(REQUEST), \"Status\": $(STATUS), \"Response\": $(RESPONSE)}\n"
	//
	// [dynamic]
	Format string

	// Templates is used to compose a complicate json reporting while Format is not good enough
	// for you.
	//
	// `report -t <key>` could refer the key of Templates to report a json formation content
	// by parsing `Templates[key]`.
	//
	// [dynamic]
	Templates map[string]json.RawMessage
}

type Request struct {
	Method  string            // default to be GET, could be GET/POST/PUT/DELETE
	Path    string            // [dynamic] /path/to/target, parameter is supported like /path?param1=1&param2=hello...
	Headers map[string]string // extra headers like "Content-Type: application/json"
	Body    json.RawMessage   // [dynamic] Json body to send, or "" if no body is required.
}

type RequestProcess struct {
	Check    interface{}     // [dynamic] segments called after server responds.
	Success  interface{}     // [dynamic] segments called if error is reported during http request and Check
	Failure  interface{}     // [dynamic] segments called if any error occurs.
	Template json.RawMessage // [dynamic] Template is a json compare template to compare with response.
}

type Response struct {
	Check    interface{}     // [dynamic] segments called after server responds.
	Success  interface{}     // [dynamic] segments called if error is reported during http request and Check
	Failure  interface{}     // [dynamic] segments called if any error occurs.
	Template json.RawMessage // [dynamic] Template is a json compare template to compare with response.
}

type Route struct {
	// HTTP request method this route will process, default for "GET"
	Method string
	// [dynamic] router path definition, it could take path variables like:
	//     "/var/js/{script}
	// and by accessing `$(script)` you'll get the path segment value, for example,
	// if request path is:
	//     "/var/js/query"
	// now `$(script)` will get value `query`
	//
	// And you can also specify request parameters taking by request path, for example:
	//     "/var/js/{script}?name=hello
	// and by accessing `$(name)` you'll get `hello`. Multiple parameter with same name will
	// be joined together separated by a space:
	//     "/var/js/{script}?name=hello&name=world
	// and by accessing `$(name)` you'll get `hello world`.
	Path string
	// [dynamic] required headers definition, if its value is a raw string like "application/json", it
	// requires request takes this header with value of "application/json"; or if it is a dynamic
	// segment(with embedded commands) like "`assert $$ == hello`", instead of string comparing, it
	// will be called.
	Headers  map[string]string
	Request  *RequestProcess            // HTTP request processing
	Response map[string]json.RawMessage // [dynamic] multiple responses template identified by key of map
	Env      map[string]string          // predefined local variables
}

type RunMode string

type Schedule struct {
	// Name defines name of schedule, and by read ${SCHEDULE} to get.
	Name string

	// PreProcess defines a group of segment which will be composed before tests runs.
	// Note that this preprocessing will be called only once.
	//
	// PreProcess should be a string list or a single string
	//
	// [dynamic]
	PreProcess interface{}
	// PreProcess defines a group of segment which will be composed after tests finishs.
	// Note that this postprocessing will be called only once.
	//
	// PostProcess should be a string list or a single string
	//
	// [dynamic]
	PostProcess interface{}

	// Tests defined a test pipeline composed of one or more tests by quoting name
	// of tests defined in Config.Tests concated by '|'. Specially a '*' indicates
	// any test defined in Config.Tests but not being explicitly defined in pipeline.
	// Please note that '*' could only be defined once at most.
	//
	// If tests are explicitly defined in pipeline like "test1|test2|test3|...", they will
	// be executed in the sequence they are defined. For tests defined by '*', the sequence
	// of executing is not defined.
	//
	// Here are some examples of how to define test pipeline.
	// Assuming we defined t1, t2, t3, t4, t5, t6, t7 in Config.Tests:
	//   1. "t1|t2|t4|t2" will execute t1, t2, t4, t2(again)
	//   2. "t2|t3|*|t5|t2" will execute t2, t3 first, and run t1, t4, t6, t7(defined by *) in random
	//      sequence, at last, t5, t2 will be executed
	//   3. "*" will execute t1 ~ t7 in random sequence once for each
	//   4. "*|t2|t3" will execute t1, t4~t7 in random sequence, and then execute t2, t3
	//   5. "t2|t3|*" will execute t2, t3, and then run t1, t4~t7 in random sequence
	//   6. "" is invalid(no case)
	Tests string

	// TestBase is a special test that behavior like a super class of Tests, this is how
	// it works:
	//
	// for all fields in TestBase and all it's sub fields:
	//    if it is a list, it will be inserted into Test's corresponding field in the head,
	//    otherwise if Test does not define this field, use TestBase's definition.
	//
	// This is used so that while massive cases sharing same test field, and saves developer
	// a lot to edit same content of Test.
	TestBase string

	// Reporter defines a template to write test report to a file.
	// Note that Reporter only defines how to write, not when to write. You need call
	// `report` command in Test.Response to actual write something.
	Reporter Report

	// Count defines how many this Tests should run.
	// 0 for infinite, or specified count, default 0.
	// if requests is iterable, this field will be ignored
	Count uint64

	// Concurrency defines how many routines should be created to run Tests.
	// 0 or 1 for one routine, or specified routines, default: 1 routine
	Concurrency int

	// QPS specifies max request at a single second.
	// Set to a value greater than 1 to enable it.
	QPS int

	// Max executing HTTP request. Effective only if Concurrency greater than 1.
	// Set to a value greater than Concurrency to enable it.
	Parallel int

	// Env defines predefined local environment variables.
	Env map[string]string
}

type Test struct {
	PreProcess interface{} // [dynamic] processing before each HTTP request
	// `key` to Config.Hosts, or : [<proxy>|]<host>
	// If Host is empty, gmeter will set it automatically following rules:
	//   - if only 1 hosts exist, set to name of that host
	//   - if more than 1 hosts exist, set to default, anonymous host name "-"
	Host           string
	Request        string    // `key` to Config.Messages
	RequestMessage *Request  // request message definition, preferred over Request
	Response       *Response // Optional entity used to process response or failure
	// HTTP request timeout, like "5s", "1m10s", "30ms"...
	// If Timeout is empty, try use  Schedule.Env["TIMEOUT"] as default value;
	// if it's still empty, it'll be set to "1m" as default value
	Timeout string
	// contains filtered or unexported fields
}