Documentation
¶
Overview ¶
Package sprintwire is how a worker talks to the sprint's server: the run loop on the coordinator's machine, the one writer of the sprint, which runs a worker's verbs for it, one at a time, beside the store. The server is single threaded and runs each request's batch in order, a plain client/server pair carries the verbs rather than a shared store, and both ends are Go. A request is the worker's verbs, each the argument list it would give nova-sprint, in the order to run them; the reply is each verb's exit code and what it printed. One request is one exchange whatever it carries, from beside the server or from 100 ms away.
Index ¶
Constants ¶
const ( MaxRequest = 1 << 20 MaxVerbs = 256 )
MaxRequest bounds a request's body, and MaxVerbs the verbs of one batch.
const Path = "/verbs"
Path is the server's one endpoint.
const Timeout = 2 * time.Minute
Timeout is how long a client waits for the server's answer by default.
const Tries = 3
Tries is how many times a verb is sent when the server does not answer. A write carries one operation id through them, so one that ran and whose answer was lost returns its recorded result and changes nothing twice.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Answer ¶ added in v1.2.14
type Answer int
Answer is what a verb's run says became of its write, beside its exit code.
const ( // Accepted is exit 0: the server answered and the verb did what it named. Accepted Answer = iota // Refused is a non-zero exit the server answered for a write that did not // happen: a card refused (stepExit 1), a usage or epoch refusal before the // store was touched (refuse(), exit 2, "nova-sprint <verb> REFUSED:"), a // worker verb the server will not serve, a pending operation, a cleared // epoch that changed nothing. Refused // Unknown is a write whose outcome is not known: no try reached the server // (the 2 is this worker's own), or the server answered that the store did not // confirm it (ErrUnknown, changed=unknown), that its operation was cut after // an earlier manifest applied (CutError, fenced for nova-sprint repair), or // that it finished at an epoch a clear closed. Unknown )
type Client ¶
type Client struct {
Addr string // host:port
HTTP *http.Client // nil is a client that waits Timeout for an answer
}
Client sends verbs to a sprint server.
type Request ¶
type Request struct {
Verbs [][]string `json:"verbs"`
}
Request is a worker's verbs, in the order to run them.
type Response ¶
type Response struct {
Results []Result `json:"results"`
}
Response is the answers, one a verb, in the request's order.
type Result ¶
type Result struct {
Code int `json:"code"`
Stdout string `json:"stdout"`
Stderr string `json:"stderr"`
Outcome string `json:"outcome,omitempty"` // accepted | refused | unknown
Changed string `json:"changed,omitempty"` // yes | no | unknown
}
Result is one verb's answer: nova-sprint's exit code, and what it printed. Outcome tells the member what the verb did, apart from its exit code, which does not separate a definite refusal from an unknown outcome: "accepted" when the verb ran and its work is in the table, "refused" when it was refused (usage, or before any write), "unknown" when it is not known whether it happened (a cut, a store that did not confirm, or a clear that closed the step as it finished). Changed says whether the verb wrote: "yes", "no", or "unknown".
type Worker ¶
type Worker struct {
// Send delivers verbs to the server in one request: Client.Do in
// production, the server's own step in a test (no connection).
Send func(ctx context.Context, verbs ...[]string) ([]Result, error)
// Failed shapes what a verb that did not exit 0 printed, for the member's
// log; nil is its stderr, then its stdout.
Failed func(stdout, stderr []byte) []byte
// Budget bounds one verb, its tries together; 0 is Timeout.
Budget time.Duration
// contains filtered or unexported fields
}
Worker runs a worker's sprint verbs on the sprint's server: each verb's arguments are sent and its exit code and what it printed come back, as when the worker ran nova-sprint itself, so a member is the same loop over either. The worker's machine reads and writes nothing of the store.
func (*Worker) Run ¶
Run sends one verb and returns its exit code and output; 2, with why, when the server did not answer. The server's own refusals may exit 2 as well (nova-sprint's refuse() returns 2, and serve passes the code through), so the code alone does not say what became of the write: RunAnswer does.
Source Files