Datasets:

---

semeru

/

code-text-go

like 2

Follow

Semeru Lab 7

[ "func", "(", "kr", "*", "GroupResolver", ")", "SelectKeys", "(", "req", "*", "http", ".", "Request", ")", "[", "]", "Key", "{", "keyName", ":=", "req", ".", "Header", ".", "Get", "(", "kr", ".", "keyHeader", ")", "\n", "kr", ".", "RLock", "(", ")", "\n", "defer", "kr", ".", "RUnlock", "(", ")", "\n", "if", "keyName", "!=", "\"", "\"", "{", "return", "kr", ".", "keyMap", "[", "keyName", "]", "\n", "}", "\n", "var", "keys", "[", "]", "Key", "\n", "for", "_", ",", "ks", ":=", "range", "kr", ".", "keyMap", "{", "keys", "=", "append", "(", "keys", ",", "ks", "...", ")", "\n", "}", "\n", "return", "keys", "\n", "}" ]

[ "SelectKeys", "returns", "the", "keys", "in", "the", "group", "with", "the", "name", "identified", "by", "the", "request", "key", "selection", "header", ".", "If", "the", "header", "does", "value", "does", "not", "match", "a", "specific", "group", "then", "all", "keys", "are", "returned", "." ]

[ "func", "newDupper", "(", ")", "*", "dupper", "{", "return", "&", "dupper", "{", "dts", ":", "make", "(", "map", "[", "string", "]", "*", "UserTypeDefinition", ")", ",", "dmts", ":", "make", "(", "map", "[", "string", "]", "*", "MediaTypeDefinition", ")", ",", "}", "\n", "}" ]

[ "newDupper", "returns", "a", "new", "initialized", "dupper", "." ]

[ "func", "(", "d", "*", "dupper", ")", "DupUserType", "(", "ut", "*", "UserTypeDefinition", ")", "*", "UserTypeDefinition", "{", "return", "&", "UserTypeDefinition", "{", "AttributeDefinition", ":", "d", ".", "DupAttribute", "(", "ut", ".", "AttributeDefinition", ")", ",", "TypeName", ":", "ut", ".", "TypeName", ",", "}", "\n", "}" ]

[ "DupUserType", "creates", "a", "copy", "of", "the", "given", "user", "type", "." ]

[ "func", "(", "d", "*", "dupper", ")", "DupAttribute", "(", "att", "*", "AttributeDefinition", ")", "*", "AttributeDefinition", "{", "var", "valDup", "*", "dslengine", ".", "ValidationDefinition", "\n", "if", "att", ".", "Validation", "!=", "nil", "{", "valDup", "=", "att", ".", "Validation", ".", "Dup", "(", ")", "\n", "}", "\n", "dup", ":=", "AttributeDefinition", "{", "Type", ":", "att", ".", "Type", ",", "Description", ":", "att", ".", "Description", ",", "Validation", ":", "valDup", ",", "Metadata", ":", "att", ".", "Metadata", ",", "DefaultValue", ":", "att", ".", "DefaultValue", ",", "NonZeroAttributes", ":", "att", ".", "NonZeroAttributes", ",", "View", ":", "att", ".", "View", ",", "DSLFunc", ":", "att", ".", "DSLFunc", ",", "Example", ":", "att", ".", "Example", ",", "}", "\n", "return", "&", "dup", "\n", "}" ]

[ "DupAttribute", "creates", "a", "copy", "of", "the", "given", "attribute", "." ]

[ "func", "(", "d", "*", "dupper", ")", "DupType", "(", "t", "DataType", ")", "DataType", "{", "switch", "actual", ":=", "t", ".", "(", "type", ")", "{", "case", "Primitive", ":", "return", "t", "\n", "case", "*", "Array", ":", "return", "&", "Array", "{", "ElemType", ":", "d", ".", "DupAttribute", "(", "actual", ".", "ElemType", ")", "}", "\n", "case", "Object", ":", "res", ":=", "make", "(", "Object", ",", "len", "(", "actual", ")", ")", "\n", "for", "n", ",", "att", ":=", "range", "actual", "{", "res", "[", "n", "]", "=", "d", ".", "DupAttribute", "(", "att", ")", "\n", "}", "\n", "return", "res", "\n", "case", "*", "Hash", ":", "return", "&", "Hash", "{", "KeyType", ":", "d", ".", "DupAttribute", "(", "actual", ".", "KeyType", ")", ",", "ElemType", ":", "d", ".", "DupAttribute", "(", "actual", ".", "ElemType", ")", ",", "}", "\n", "case", "*", "UserTypeDefinition", ":", "if", "u", ",", "ok", ":=", "d", ".", "dts", "[", "actual", ".", "TypeName", "]", ";", "ok", "{", "return", "u", "\n", "}", "\n", "u", ":=", "&", "UserTypeDefinition", "{", "TypeName", ":", "actual", ".", "TypeName", ",", "}", "\n", "d", ".", "dts", "[", "u", ".", "TypeName", "]", "=", "u", "\n", "u", ".", "AttributeDefinition", "=", "d", ".", "DupAttribute", "(", "actual", ".", "AttributeDefinition", ")", "\n", "return", "u", "\n", "case", "*", "MediaTypeDefinition", ":", "if", "m", ",", "ok", ":=", "d", ".", "dmts", "[", "actual", ".", "Identifier", "]", ";", "ok", "{", "return", "m", "\n", "}", "\n", "m", ":=", "&", "MediaTypeDefinition", "{", "Identifier", ":", "actual", ".", "Identifier", ",", "Links", ":", "actual", ".", "Links", ",", "Views", ":", "actual", ".", "Views", ",", "Resource", ":", "actual", ".", "Resource", ",", "}", "\n", "d", ".", "dmts", "[", "actual", ".", "Identifier", "]", "=", "m", "\n", "m", ".", "UserTypeDefinition", "=", "d", ".", "DupUserType", "(", "actual", ".", "UserTypeDefinition", ")", "\n", "return", "m", "\n", "}", "\n", "panic", "(", "\"", "\"", "+", "t", ".", "Name", "(", ")", ")", "\n", "}" ]

[ "DupType", "creates", "a", "copy", "of", "the", "given", "data", "type", "." ]

[ "func", "(", "i", "Info", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "marshalJSON", "(", "_Info", "(", "i", ")", ",", "i", ".", "Extensions", ")", "\n", "}" ]

[ "MarshalJSON", "returns", "the", "JSON", "encoding", "of", "i", "." ]

[ "func", "(", "o", "Operation", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "marshalJSON", "(", "_Operation", "(", "o", ")", ",", "o", ".", "Extensions", ")", "\n", "}" ]

[ "MarshalJSON", "returns", "the", "JSON", "encoding", "of", "o", "." ]

[ "func", "(", "r", "Response", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "marshalJSON", "(", "_Response", "(", "r", ")", ",", "r", ".", "Extensions", ")", "\n", "}" ]

[ "MarshalJSON", "returns", "the", "JSON", "encoding", "of", "r", "." ]

[ "func", "(", "s", "SecurityDefinition", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "marshalJSON", "(", "_SecurityDefinition", "(", "s", ")", ",", "s", ".", "Extensions", ")", "\n", "}" ]

[ "MarshalJSON", "returns", "the", "JSON", "encoding", "of", "s", "." ]

[ "func", "mustGenerate", "(", "meta", "dslengine", ".", "MetadataDefinition", ")", "bool", "{", "if", "m", ",", "ok", ":=", "meta", "[", "\"", "\"", "]", ";", "ok", "{", "if", "len", "(", "m", ")", ">", "0", "&&", "m", "[", "0", "]", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "mustGenerate", "returns", "true", "if", "the", "metadata", "indicates", "that", "a", "Swagger", "specification", "should", "be", "generated", "false", "otherwise", "." ]

[ "func", "toString", "(", "val", "interface", "{", "}", ")", "string", "{", "switch", "actual", ":=", "val", ".", "(", "type", ")", "{", "case", "string", ":", "return", "actual", "\n", "case", "int", ":", "return", "strconv", ".", "Itoa", "(", "actual", ")", "\n", "case", "float64", ":", "return", "strconv", ".", "FormatFloat", "(", "actual", ",", "'f'", ",", "-", "1", ",", "64", ")", "\n", "case", "bool", ":", "return", "strconv", ".", "FormatBool", "(", "actual", ")", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "toString", "returns", "the", "string", "representation", "of", "the", "given", "type", "." ]

[ "func", "init", "(", ")", "{", "var", "err", "error", "\n", "fm", ":=", "template", ".", "FuncMap", "{", "\"", "\"", ":", "Tabs", ",", "\"", "\"", ":", "toSlice", ",", "\"", "\"", ":", "oneof", ",", "\"", "\"", ":", "constant", ",", "\"", "\"", ":", "GoifyAtt", ",", "\"", "\"", ":", "Add", ",", "}", "\n", "if", "enumValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "enumValTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "formatValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "formatValTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "patternValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "patternValTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "minMaxValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "minMaxValTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "lengthValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "lengthValTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "requiredValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "requiredValTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "init", "instantiates", "the", "templates", "." ]

[ "func", "NewValidator", "(", ")", "*", "Validator", "{", "var", "(", "v", "=", "&", "Validator", "{", "seen", ":", "make", "(", "map", "[", "string", "]", "*", "bytes", ".", "Buffer", ")", "}", "\n", "err", "error", "\n", ")", "\n", "fm", ":=", "template", ".", "FuncMap", "{", "\"", "\"", ":", "Tabs", ",", "\"", "\"", ":", "toSlice", ",", "\"", "\"", ":", "oneof", ",", "\"", "\"", ":", "constant", ",", "\"", "\"", ":", "GoifyAtt", ",", "\"", "\"", ":", "Add", ",", "\"", "\"", ":", "v", ".", "recurseAttribute", ",", "}", "\n", "v", ".", "arrayValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "arrayValTmpl", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "v", ".", "hashValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "hashValTmpl", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "v", ".", "userValT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "userValTmpl", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "NewValidator", "instantiates", "a", "validate", "code", "generator", "." ]

[ "func", "(", "v", "*", "Validator", ")", "Code", "(", "att", "*", "design", ".", "AttributeDefinition", ",", "nonzero", ",", "required", ",", "hasDefault", "bool", ",", "target", ",", "context", "string", ",", "depth", "int", ",", "private", "bool", ")", "string", "{", "if", "_", ",", "ok", ":=", "att", ".", "Metadata", "[", "\"", "\"", "]", ";", "ok", "{", "// Skip validation generation for attributes with custom types", "return", "\"", "\"", "\n", "}", "\n", "buf", ":=", "v", ".", "recurse", "(", "att", ",", "nonzero", ",", "required", ",", "hasDefault", ",", "target", ",", "context", ",", "depth", ",", "private", ")", "\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "Code", "produces", "Go", "code", "that", "runs", "the", "validation", "checks", "recursively", "over", "the", "given", "attribute", "." ]

[ "func", "renderInteger", "(", "f", "float64", ")", "string", "{", "if", "f", ">", "math", ".", "Nextafter", "(", "float64", "(", "math", ".", "MaxInt64", ")", ",", "0", ")", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int64", "(", "math", ".", "MaxInt64", ")", ")", "\n", "}", "\n", "if", "f", "<", "math", ".", "Nextafter", "(", "float64", "(", "math", ".", "MinInt64", ")", ",", "0", ")", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int64", "(", "math", ".", "MinInt64", ")", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int64", "(", "f", ")", ")", "\n", "}" ]

[ "renderInteger", "renders", "a", "max", "or", "min", "value", "properly", "taking", "into", "account", "overflows", "due", "to", "casting", "from", "a", "float", "value", "." ]

[ "func", "NewMux", "(", ")", "ServeMux", "{", "r", ":=", "httptreemux", ".", "New", "(", ")", "\n", "r", ".", "EscapeAddedRoutes", "=", "true", "\n", "return", "&", "mux", "{", "router", ":", "r", ",", "handles", ":", "make", "(", "map", "[", "string", "]", "MuxHandler", ")", ",", "}", "\n", "}" ]

[ "NewMux", "returns", "a", "Mux", "." ]

[ "func", "(", "m", "*", "mux", ")", "Handle", "(", "method", ",", "path", "string", ",", "handle", "MuxHandler", ")", "{", "hthandle", ":=", "func", "(", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ",", "htparams", "map", "[", "string", "]", "string", ")", "{", "params", ":=", "req", ".", "URL", ".", "Query", "(", ")", "\n", "for", "n", ",", "p", ":=", "range", "htparams", "{", "params", ".", "Set", "(", "n", ",", "p", ")", "\n", "}", "\n", "handle", "(", "rw", ",", "req", ",", "params", ")", "\n", "}", "\n", "m", ".", "handles", "[", "method", "+", "path", "]", "=", "handle", "\n", "m", ".", "router", ".", "Handle", "(", "method", ",", "path", ",", "hthandle", ")", "\n", "}" ]

[ "Handle", "sets", "the", "handler", "for", "the", "given", "verb", "and", "path", "." ]

[ "func", "(", "m", "*", "mux", ")", "HandleNotFound", "(", "handle", "MuxHandler", ")", "{", "nfh", ":=", "func", "(", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "handle", "(", "rw", ",", "req", ",", "nil", ")", "\n", "}", "\n", "m", ".", "router", ".", "NotFoundHandler", "=", "nfh", "\n", "}" ]

[ "HandleNotFound", "sets", "the", "MuxHandler", "invoked", "for", "requests", "that", "don", "t", "match", "any", "handler", "registered", "with", "Handle", "." ]

[ "func", "(", "m", "*", "mux", ")", "HandleMethodNotAllowed", "(", "handle", "MethodNotAllowedHandler", ")", "{", "mna", ":=", "func", "(", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ",", "methods", "map", "[", "string", "]", "httptreemux", ".", "HandlerFunc", ")", "{", "handle", "(", "rw", ",", "req", ",", "nil", ",", "methods", ")", "\n", "}", "\n", "m", ".", "router", ".", "MethodNotAllowedHandler", "=", "mna", "\n", "}" ]

[ "HandleMethodNotAllowed", "sets", "the", "MuxHandler", "invoked", "for", "requests", "that", "match", "the", "path", "of", "a", "handler", "but", "not", "its", "HTTP", "method", "." ]

[ "func", "(", "m", "*", "mux", ")", "Lookup", "(", "method", ",", "path", "string", ")", "MuxHandler", "{", "return", "m", ".", "handles", "[", "method", "+", "path", "]", "\n", "}" ]

[ "Lookup", "returns", "the", "MuxHandler", "associated", "with", "the", "given", "method", "and", "path", "." ]

[ "func", "(", "m", "*", "mux", ")", "ServeHTTP", "(", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "m", ".", "router", ".", "ServeHTTP", "(", "rw", ",", "req", ")", "\n", "}" ]

[ "ServeHTTP", "is", "the", "function", "called", "back", "by", "the", "underlying", "HTTP", "server", "to", "handle", "incoming", "requests", "." ]

[ "func", "NewSegment", "(", "name", ",", "traceID", ",", "spanID", "string", ",", "conn", "net", ".", "Conn", ")", "*", "Segment", "{", "return", "&", "Segment", "{", "Mutex", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "Name", ":", "name", ",", "TraceID", ":", "traceID", ",", "ID", ":", "spanID", ",", "StartTime", ":", "now", "(", ")", ",", "InProgress", ":", "true", ",", "conn", ":", "conn", ",", "}", "\n", "}" ]

[ "NewSegment", "creates", "a", "new", "segment", "that", "gets", "written", "to", "the", "given", "connection", "on", "close", "." ]

[ "func", "(", "s", "*", "Segment", ")", "RecordResponse", "(", "resp", "*", "http", ".", "Response", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "if", "s", ".", "HTTP", "==", "nil", "{", "s", ".", "HTTP", "=", "&", "HTTP", "{", "}", "\n", "}", "\n\n", "s", ".", "recordStatusCode", "(", "resp", ".", "StatusCode", ")", "\n\n", "s", ".", "HTTP", ".", "Response", "=", "responseData", "(", "resp", ")", "\n", "}" ]

[ "RecordResponse", "traces", "a", "response", ".", "It", "sets", "Throttle", "Fault", "Error", "and", "HTTP", ".", "Response" ]

[ "func", "(", "s", "*", "Segment", ")", "RecordContextResponse", "(", "ctx", "context", ".", "Context", ")", "{", "resp", ":=", "goa", ".", "ContextResponse", "(", "ctx", ")", "\n", "if", "resp", "==", "nil", "{", "return", "\n", "}", "\n\n", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "if", "s", ".", "HTTP", "==", "nil", "{", "s", ".", "HTTP", "=", "&", "HTTP", "{", "}", "\n", "}", "\n\n", "s", ".", "recordStatusCode", "(", "resp", ".", "Status", ")", "\n", "s", ".", "HTTP", ".", "Response", "=", "&", "Response", "{", "resp", ".", "Status", ",", "int64", "(", "resp", ".", "Length", ")", "}", "\n", "}" ]

[ "RecordContextResponse", "traces", "a", "context", "response", "if", "present", "in", "the", "context", "It", "sets", "Throttle", "Fault", "Error", "and", "HTTP", ".", "Response" ]

[ "func", "(", "s", "*", "Segment", ")", "NewSubsegment", "(", "name", "string", ")", "*", "Segment", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "sub", ":=", "&", "Segment", "{", "Mutex", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "ID", ":", "NewID", "(", ")", ",", "TraceID", ":", "s", ".", "TraceID", ",", "ParentID", ":", "s", ".", "ID", ",", "Type", ":", "\"", "\"", ",", "Name", ":", "name", ",", "StartTime", ":", "now", "(", ")", ",", "InProgress", ":", "true", ",", "Parent", ":", "s", ",", "conn", ":", "s", ".", "conn", ",", "}", "\n", "s", ".", "Subsegments", "=", "append", "(", "s", ".", "Subsegments", ",", "sub", ")", "\n", "s", ".", "counter", "++", "\n", "return", "sub", "\n", "}" ]

[ "NewSubsegment", "creates", "a", "subsegment", "of", "s", "." ]

[ "func", "(", "s", "*", "Segment", ")", "AddAnnotation", "(", "key", "string", ",", "value", "string", ")", "{", "s", ".", "addAnnotation", "(", "key", ",", "value", ")", "\n", "}" ]

[ "AddAnnotation", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", "." ]

[ "func", "(", "s", "*", "Segment", ")", "AddInt64Annotation", "(", "key", "string", ",", "value", "int64", ")", "{", "s", ".", "addAnnotation", "(", "key", ",", "value", ")", "\n", "}" ]

[ "AddInt64Annotation", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", "." ]

[ "func", "(", "s", "*", "Segment", ")", "AddBoolAnnotation", "(", "key", "string", ",", "value", "bool", ")", "{", "s", ".", "addAnnotation", "(", "key", ",", "value", ")", "\n", "}" ]

[ "AddBoolAnnotation", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", "." ]

[ "func", "(", "s", "*", "Segment", ")", "addAnnotation", "(", "key", "string", ",", "value", "interface", "{", "}", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "if", "s", ".", "Annotations", "==", "nil", "{", "s", ".", "Annotations", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n", "s", ".", "Annotations", "[", "key", "]", "=", "value", "\n", "}" ]

[ "addAnnotation", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", ".", "AWS", "X", "-", "Ray", "only", "supports", "annotations", "of", "type", "string", "integer", "or", "boolean", "." ]

[ "func", "(", "s", "*", "Segment", ")", "AddMetadata", "(", "key", "string", ",", "value", "string", ")", "{", "s", ".", "addMetadata", "(", "key", ",", "value", ")", "\n", "}" ]

[ "AddMetadata", "adds", "a", "key", "-", "value", "pair", "to", "the", "metadata", ".", "default", "attribute", ".", "Metadata", "is", "not", "queryable", "but", "is", "recorded", "." ]

[ "func", "(", "s", "*", "Segment", ")", "AddInt64Metadata", "(", "key", "string", ",", "value", "int64", ")", "{", "s", ".", "addMetadata", "(", "key", ",", "value", ")", "\n", "}" ]

[ "AddInt64Metadata", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", "." ]

[ "func", "(", "s", "*", "Segment", ")", "AddBoolMetadata", "(", "key", "string", ",", "value", "bool", ")", "{", "s", ".", "addMetadata", "(", "key", ",", "value", ")", "\n", "}" ]

[ "AddBoolMetadata", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", "." ]

[ "func", "(", "s", "*", "Segment", ")", "addMetadata", "(", "key", "string", ",", "value", "interface", "{", "}", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "if", "s", ".", "Metadata", "==", "nil", "{", "s", ".", "Metadata", "=", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "s", ".", "Metadata", "[", "\"", "\"", "]", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n", "s", ".", "Metadata", "[", "\"", "\"", "]", "[", "key", "]", "=", "value", "\n", "}" ]

[ "addMetadata", "adds", "a", "key", "-", "value", "pair", "that", "can", "be", "queried", "by", "AWS", "X", "-", "Ray", ".", "AWS", "X", "-", "Ray", "only", "supports", "annotations", "of", "type", "string", "integer", "or", "boolean", "." ]

[ "func", "(", "s", "*", "Segment", ")", "Close", "(", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "s", ".", "EndTime", "=", "now", "(", ")", "\n", "s", ".", "InProgress", "=", "false", "\n", "if", "s", ".", "Parent", "!=", "nil", "{", "s", ".", "Parent", ".", "decrementCounter", "(", ")", "\n", "}", "\n", "if", "s", ".", "counter", "<=", "0", "{", "s", ".", "flush", "(", ")", "\n", "}", "\n", "}" ]

[ "Close", "closes", "the", "segment", "by", "setting", "its", "EndTime", "." ]

[ "func", "(", "s", "*", "Segment", ")", "flush", "(", ")", "{", "b", ",", "_", ":=", "json", ".", "Marshal", "(", "s", ")", "\n", "// append so we make only one call to Write to be goroutine-safe", "s", ".", "conn", ".", "Write", "(", "append", "(", "[", "]", "byte", "(", "udpHeader", ")", ",", "b", "...", ")", ")", "\n", "}" ]

[ "flush", "sends", "the", "segment", "to", "the", "AWS", "X", "-", "Ray", "daemon", "." ]

[ "func", "(", "s", "*", "Segment", ")", "recordStatusCode", "(", "statusCode", "int", ")", "{", "switch", "{", "case", "statusCode", "==", "http", ".", "StatusTooManyRequests", ":", "s", ".", "Throttle", "=", "true", "\n", "case", "statusCode", ">=", "400", "&&", "statusCode", "<", "500", ":", "s", ".", "Fault", "=", "true", "\n", "case", "statusCode", ">=", "500", ":", "s", ".", "Error", "=", "true", "\n", "}", "\n", "}" ]

[ "recordStatusCode", "sets", "Throttle", "Fault", "Error", "It", "is", "expected", "that", "the", "mutex", "has", "already", "been", "locked", "when", "calling", "this", "method", "." ]

[ "func", "(", "s", "*", "Segment", ")", "decrementCounter", "(", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "s", ".", "counter", "--", "\n", "if", "s", ".", "counter", "<=", "0", "&&", "s", ".", "EndTime", "!=", "0", "{", "// Segment is closed and last subsegment closed, flush it", "s", ".", "flush", "(", ")", "\n", "}", "\n", "}" ]

[ "decrementCounter", "decrements", "the", "segment", "counter", "and", "flushes", "it", "if", "it", "s", "0", "." ]

[ "func", "exceptionData", "(", "e", "error", ")", "*", "Exception", "{", "var", "xerr", "*", "Exception", "\n", "if", "c", ",", "ok", ":=", "e", ".", "(", "causer", ")", ";", "ok", "{", "xerr", "=", "&", "Exception", "{", "Message", ":", "c", ".", "Cause", "(", ")", ".", "Error", "(", ")", "}", "\n", "}", "else", "{", "xerr", "=", "&", "Exception", "{", "Message", ":", "e", ".", "Error", "(", ")", "}", "\n", "}", "\n", "if", "s", ",", "ok", ":=", "e", ".", "(", "stackTracer", ")", ";", "ok", "{", "st", ":=", "s", ".", "StackTrace", "(", ")", "\n", "ln", ":=", "len", "(", "st", ")", "\n", "if", "ln", ">", "maxStackDepth", "{", "ln", "=", "maxStackDepth", "\n", "}", "\n", "frames", ":=", "make", "(", "[", "]", "*", "StackEntry", ",", "ln", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "ln", ";", "i", "++", "{", "f", ":=", "st", "[", "i", "]", "\n", "line", ",", "_", ":=", "strconv", ".", "Atoi", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ")", ")", "\n", "frames", "[", "i", "]", "=", "&", "StackEntry", "{", "Path", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ")", ",", "Line", ":", "line", ",", "Label", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ")", ",", "}", "\n", "}", "\n", "xerr", ".", "Stack", "=", "frames", "\n", "}", "\n\n", "return", "xerr", "\n", "}" ]

[ "exceptionData", "creates", "an", "Exception", "from", "an", "error", "." ]

[ "func", "requestData", "(", "req", "*", "http", ".", "Request", ")", "*", "Request", "{", "var", "(", "scheme", "=", "\"", "\"", "\n", "host", "=", "req", ".", "Host", "\n", ")", "\n", "if", "len", "(", "req", ".", "URL", ".", "Scheme", ")", ">", "0", "{", "scheme", "=", "req", ".", "URL", ".", "Scheme", "\n", "}", "\n", "if", "len", "(", "req", ".", "URL", ".", "Host", ")", ">", "0", "{", "host", "=", "req", ".", "URL", ".", "Host", "\n", "}", "\n\n", "return", "&", "Request", "{", "Method", ":", "req", ".", "Method", ",", "URL", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scheme", ",", "host", ",", "req", ".", "URL", ".", "Path", ")", ",", "ClientIP", ":", "getIP", "(", "req", ")", ",", "UserAgent", ":", "req", ".", "UserAgent", "(", ")", ",", "ContentLength", ":", "req", ".", "ContentLength", ",", "}", "\n", "}" ]

[ "requestData", "creates", "a", "Request", "from", "a", "http", ".", "Request", "." ]

[ "func", "responseData", "(", "resp", "*", "http", ".", "Response", ")", "*", "Response", "{", "return", "&", "Response", "{", "Status", ":", "resp", ".", "StatusCode", ",", "ContentLength", ":", "resp", ".", "ContentLength", ",", "}", "\n", "}" ]

[ "responseData", "creates", "a", "Response", "from", "a", "http", ".", "Response", "." ]

[ "func", "defaultRouteParams", "(", "a", "*", "design", ".", "ActionDefinition", ")", "*", "design", ".", "AttributeDefinition", "{", "r", ":=", "a", ".", "Routes", "[", "0", "]", "\n", "params", ":=", "r", ".", "Params", "(", ")", "\n", "o", ":=", "make", "(", "design", ".", "Object", ",", "len", "(", "params", ")", ")", "\n", "nz", ":=", "make", "(", "map", "[", "string", "]", "bool", ",", "len", "(", "params", ")", ")", "\n", "pparams", ":=", "a", ".", "PathParams", "(", ")", "\n", "for", "_", ",", "p", ":=", "range", "params", "{", "o", "[", "p", "]", "=", "pparams", ".", "Type", ".", "ToObject", "(", ")", "[", "p", "]", "\n", "nz", "[", "p", "]", "=", "true", "\n", "}", "\n", "return", "&", "design", ".", "AttributeDefinition", "{", "Type", ":", "o", ",", "NonZeroAttributes", ":", "nz", "}", "\n", "}" ]

[ "defaultRouteParams", "returns", "the", "parameters", "needed", "to", "build", "the", "first", "route", "of", "the", "given", "action", "." ]

[ "func", "defaultRouteTemplate", "(", "a", "*", "design", ".", "ActionDefinition", ")", "string", "{", "return", "design", ".", "WildcardRegex", ".", "ReplaceAllLiteralString", "(", "a", ".", "Routes", "[", "0", "]", ".", "FullPath", "(", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "produces", "a", "fmt", "template", "to", "render", "the", "first", "route", "of", "action", "." ]

[ "func", "joinRouteParams", "(", "action", "*", "design", ".", "ActionDefinition", ",", "att", "*", "design", ".", "AttributeDefinition", ")", "string", "{", "var", "(", "params", "=", "action", ".", "Routes", "[", "0", "]", ".", "Params", "(", ")", "\n", "elems", "=", "make", "(", "[", "]", "string", ",", "len", "(", "params", ")", ")", "\n", ")", "\n", "for", "i", ",", "p", ":=", "range", "params", "{", "patt", ",", "ok", ":=", "att", ".", "Type", ".", "ToObject", "(", ")", "[", "p", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "pf", ":=", "\"", "\"", "\n", "if", "patt", ".", "Type", ".", "Kind", "(", ")", "==", "design", ".", "StringKind", "{", "pf", "=", "\"", "\"", "\n", "}", "\n", "field", ":=", "fmt", ".", "Sprintf", "(", "pf", ",", "codegen", ".", "Goify", "(", "p", ",", "true", ")", ")", "\n", "elems", "[", "i", "]", "=", "field", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "elems", ",", "\"", "\"", ")", "\n", "}" ]

[ "return", "a", "joined", "list", "of", "Params", "as", "a", "reference", "to", "cmd", ".", "XFieldName", "ordered", "by", "the", "required", "first", "rules", "." ]

[ "func", "routes", "(", "action", "*", "design", ".", "ActionDefinition", ")", "string", "{", "var", "buf", "bytes", ".", "Buffer", "\n", "routes", ":=", "action", ".", "Routes", "\n", "buf", ".", "WriteRune", "(", "'['", ")", "\n", "if", "len", "(", "routes", ")", ">", "1", "{", "buf", ".", "WriteRune", "(", "'('", ")", "\n", "}", "\n", "paths", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "routes", ")", ")", "\n", "for", "i", ",", "r", ":=", "range", "routes", "{", "path", ":=", "r", ".", "FullPath", "(", ")", "\n", "matches", ":=", "design", ".", "WildcardRegex", ".", "FindAllStringSubmatch", "(", "path", ",", "-", "1", ")", "\n", "for", "_", ",", "match", ":=", "range", "matches", "{", "paramName", ":=", "match", "[", "1", "]", "\n", "path", "=", "strings", ".", "Replace", "(", "path", ",", "\"", "\"", "+", "paramName", ",", "strings", ".", "ToUpper", "(", "paramName", ")", ",", "1", ")", "\n", "}", "\n", "paths", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "buf", ".", "WriteString", "(", "strings", ".", "Join", "(", "paths", ",", "\"", "\"", ")", ")", "\n", "if", "len", "(", "routes", ")", ">", "1", "{", "buf", ".", "WriteRune", "(", "')'", ")", "\n", "}", "\n", "buf", ".", "WriteRune", "(", "']'", ")", "\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "routes", "create", "the", "action", "command", "Use", "suffix", "." ]

[ "func", "CanonicalIdentifier", "(", "identifier", "string", ")", "string", "{", "base", ",", "params", ",", "err", ":=", "mime", ".", "ParseMediaType", "(", "identifier", ")", "\n", "if", "err", "!=", "nil", "{", "return", "identifier", "\n", "}", "\n", "id", ":=", "base", "\n", "if", "i", ":=", "strings", ".", "Index", "(", "id", ",", "\"", "\"", ")", ";", "i", "!=", "-", "1", "{", "id", "=", "id", "[", ":", "i", "]", "\n", "}", "\n", "return", "mime", ".", "FormatMediaType", "(", "id", ",", "params", ")", "\n", "}" ]

[ "CanonicalIdentifier", "returns", "the", "media", "type", "identifier", "sans", "suffix", "which", "is", "what", "the", "DSL", "uses", "to", "store", "and", "lookup", "media", "types", "." ]

[ "func", "ExtractWildcards", "(", "path", "string", ")", "[", "]", "string", "{", "matches", ":=", "WildcardRegex", ".", "FindAllStringSubmatch", "(", "path", ",", "-", "1", ")", "\n", "wcs", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "matches", ")", ")", "\n", "for", "i", ",", "m", ":=", "range", "matches", "{", "wcs", "[", "i", "]", "=", "m", "[", "1", "]", "\n", "}", "\n", "return", "wcs", "\n", "}" ]

[ "ExtractWildcards", "returns", "the", "names", "of", "the", "wildcards", "that", "appear", "in", "path", "." ]

[ "func", "(", "r", "MediaTypeRoot", ")", "IterateSets", "(", "iterator", "dslengine", ".", "SetIterator", ")", "{", "canonicalIDs", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "r", ")", ")", "\n", "i", ":=", "0", "\n", "for", "_", ",", "mt", ":=", "range", "r", "{", "canonicalID", ":=", "CanonicalIdentifier", "(", "mt", ".", "Identifier", ")", "\n", "Design", ".", "MediaTypes", "[", "canonicalID", "]", "=", "mt", "\n", "canonicalIDs", "[", "i", "]", "=", "canonicalID", "\n", "i", "++", "\n", "}", "\n", "sort", ".", "Strings", "(", "canonicalIDs", ")", "\n", "set", ":=", "make", "(", "[", "]", "dslengine", ".", "Definition", ",", "len", "(", "canonicalIDs", ")", ")", "\n", "for", "i", ",", "cid", ":=", "range", "canonicalIDs", "{", "set", "[", "i", "]", "=", "Design", ".", "MediaTypes", "[", "cid", "]", "\n", "}", "\n", "iterator", "(", "set", ")", "\n", "}" ]

[ "IterateSets", "iterates", "over", "the", "one", "generated", "media", "type", "definition", "set", "." ]

[ "func", "(", "verr", "*", "ValidationErrors", ")", "Merge", "(", "err", "*", "ValidationErrors", ")", "{", "if", "err", "==", "nil", "{", "return", "\n", "}", "\n", "verr", ".", "Errors", "=", "append", "(", "verr", ".", "Errors", ",", "err", ".", "Errors", "...", ")", "\n", "verr", ".", "Definitions", "=", "append", "(", "verr", ".", "Definitions", ",", "err", ".", "Definitions", "...", ")", "\n", "}" ]

[ "Merge", "merges", "validation", "errors", "into", "the", "target", "." ]

[ "func", "(", "verr", "*", "ValidationErrors", ")", "Add", "(", "def", "Definition", ",", "format", "string", ",", "vals", "...", "interface", "{", "}", ")", "{", "verr", ".", "AddError", "(", "def", ",", "fmt", ".", "Errorf", "(", "format", ",", "vals", "...", ")", ")", "\n", "}" ]

[ "Add", "adds", "a", "validation", "error", "to", "the", "target", "." ]

[ "func", "(", "verr", "*", "ValidationErrors", ")", "AddError", "(", "def", "Definition", ",", "err", "error", ")", "{", "if", "v", ",", "ok", ":=", "err", ".", "(", "*", "ValidationErrors", ")", ";", "ok", "{", "verr", ".", "Errors", "=", "append", "(", "verr", ".", "Errors", ",", "v", ".", "Errors", "...", ")", "\n", "verr", ".", "Definitions", "=", "append", "(", "verr", ".", "Definitions", ",", "v", ".", "Definitions", "...", ")", "\n", "return", "\n", "}", "\n", "verr", ".", "Errors", "=", "append", "(", "verr", ".", "Errors", ",", "err", ")", "\n", "verr", ".", "Definitions", "=", "append", "(", "verr", ".", "Definitions", ",", "def", ")", "\n", "}" ]

[ "AddError", "adds", "a", "validation", "error", "to", "the", "target", ".", "AddError", "flattens", "validation", "errors", "so", "that", "the", "recorded", "errors", "are", "never", "ValidationErrors", "themselves", "." ]

[ "func", "(", "r", "*", "wrapDoer", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "req", "*", "http", ".", "Request", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "s", ":=", "ContextSegment", "(", "ctx", ")", "\n", "if", "s", "==", "nil", "{", "// this request isn't traced", "return", "r", ".", "wrapped", ".", "Do", "(", "ctx", ",", "req", ")", "\n", "}", "\n\n", "sub", ":=", "s", ".", "NewSubsegment", "(", "req", ".", "URL", ".", "Host", ")", "\n", "defer", "sub", ".", "Close", "(", ")", "\n\n", "// update the context with the latest segment", "ctx", "=", "middleware", ".", "WithTrace", "(", "ctx", ",", "sub", ".", "TraceID", ",", "sub", ".", "ID", ",", "sub", ".", "ParentID", ")", "\n", "ctx", "=", "WithSegment", "(", "ctx", ",", "sub", ")", "\n\n", "sub", ".", "RecordRequest", "(", "req", ",", "\"", "\"", ")", "\n\n", "resp", ",", "err", ":=", "r", ".", "wrapped", ".", "Do", "(", "ctx", ",", "req", ")", "\n\n", "if", "err", "!=", "nil", "{", "sub", ".", "RecordError", "(", "err", ")", "\n", "}", "else", "{", "sub", ".", "RecordResponse", "(", "resp", ")", "\n", "}", "\n\n", "return", "resp", ",", "err", "\n", "}" ]

[ "Do", "calls", "through", "to", "the", "wrapped", "Doer", "creating", "subsegments", "as", "appropriate", "." ]

[ "func", "CanonicalActionName", "(", "a", "string", ")", "{", "if", "r", ",", "ok", ":=", "resourceDefinition", "(", ")", ";", "ok", "{", "r", ".", "CanonicalActionName", "=", "a", "\n", "}", "\n", "}" ]

[ "CanonicalActionName", "sets", "the", "name", "of", "the", "action", "used", "to", "compute", "the", "resource", "collection", "and", "resource", "collection", "items", "hrefs", ".", "See", "Resource", "." ]

[ "func", "multiComment", "(", "text", "string", ")", "string", "{", "lines", ":=", "strings", ".", "Split", "(", "text", ",", "\"", "\\n", "\"", ")", "\n", "nl", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "lines", ")", ")", "\n", "for", "i", ",", "l", ":=", "range", "lines", "{", "nl", "[", "i", "]", "=", "\"", "\"", "+", "strings", ".", "TrimSpace", "(", "l", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "nl", ",", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "multiComment", "produces", "a", "Go", "comment", "containing", "the", "given", "string", "taking", "into", "account", "newlines", "." ]

[ "func", "goTypeRefExt", "(", "t", "design", ".", "DataType", ",", "tabs", "int", ",", "pkg", "string", ")", "string", "{", "ref", ":=", "codegen", ".", "GoTypeRef", "(", "t", ",", "nil", ",", "tabs", ",", "false", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "ref", ",", "\"", "\"", ")", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pkg", ",", "ref", "[", "1", ":", "]", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pkg", ",", "ref", ")", "\n", "}" ]

[ "gotTypeRefExt", "computes", "the", "type", "reference", "for", "a", "type", "in", "a", "different", "package", "." ]

[ "func", "decodeGoTypeRef", "(", "t", "design", ".", "DataType", ",", "required", "[", "]", "string", ",", "tabs", "int", ",", "private", "bool", ")", "string", "{", "mt", ",", "ok", ":=", "t", ".", "(", "*", "design", ".", "MediaTypeDefinition", ")", "\n", "if", "ok", "&&", "mt", ".", "IsError", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "codegen", ".", "GoTypeRef", "(", "t", ",", "required", ",", "tabs", ",", "private", ")", "\n", "}" ]

[ "decodeGoTypeRef", "handles", "the", "case", "where", "the", "type", "being", "decoded", "is", "a", "error", "response", "media", "type", "." ]

[ "func", "decodeGoTypeName", "(", "t", "design", ".", "DataType", ",", "required", "[", "]", "string", ",", "tabs", "int", ",", "private", "bool", ")", "string", "{", "mt", ",", "ok", ":=", "t", ".", "(", "*", "design", ".", "MediaTypeDefinition", ")", "\n", "if", "ok", "&&", "mt", ".", "IsError", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "codegen", ".", "GoTypeName", "(", "t", ",", "required", ",", "tabs", ",", "private", ")", "\n", "}" ]

[ "decodeGoTypeName", "handles", "the", "case", "where", "the", "type", "being", "decoded", "is", "a", "error", "response", "media", "type", "." ]

[ "func", "cmdFieldType", "(", "t", "design", ".", "DataType", ",", "point", "bool", ")", "string", "{", "var", "pointer", ",", "suffix", "string", "\n", "if", "point", "&&", "!", "t", ".", "IsArray", "(", ")", "{", "pointer", "=", "\"", "\"", "\n", "}", "\n", "suffix", "=", "codegen", ".", "GoNativeType", "(", "t", ")", "\n", "return", "pointer", "+", "suffix", "\n", "}" ]

[ "cmdFieldType", "computes", "the", "Go", "type", "name", "used", "to", "store", "command", "flags", "of", "the", "given", "design", "type", "." ]

[ "func", "cmdFieldTypeString", "(", "t", "design", ".", "DataType", ",", "point", "bool", ")", "string", "{", "var", "pointer", ",", "suffix", "string", "\n", "if", "point", "&&", "!", "t", ".", "IsArray", "(", ")", "{", "pointer", "=", "\"", "\"", "\n", "}", "\n", "if", "t", ".", "Kind", "(", ")", "==", "design", ".", "UUIDKind", "||", "t", ".", "Kind", "(", ")", "==", "design", ".", "DateTimeKind", "||", "t", ".", "Kind", "(", ")", "==", "design", ".", "AnyKind", "||", "t", ".", "Kind", "(", ")", "==", "design", ".", "NumberKind", "||", "t", ".", "Kind", "(", ")", "==", "design", ".", "BooleanKind", "{", "suffix", "=", "\"", "\"", "\n", "}", "else", "if", "isArrayOfType", "(", "t", ",", "design", ".", "UUIDKind", ",", "design", ".", "DateTimeKind", ",", "design", ".", "AnyKind", ",", "design", ".", "NumberKind", ",", "design", ".", "BooleanKind", ")", "{", "suffix", "=", "\"", "\"", "\n", "}", "else", "{", "suffix", "=", "codegen", ".", "GoNativeType", "(", "t", ")", "\n", "}", "\n", "return", "pointer", "+", "suffix", "\n", "}" ]

[ "cmdFieldTypeString", "computes", "the", "Go", "type", "name", "used", "to", "store", "command", "flags", "of", "the", "given", "design", "type", ".", "Complex", "types", "are", "String" ]

[ "func", "toString", "(", "name", ",", "target", "string", ",", "att", "*", "design", ".", "AttributeDefinition", ")", "string", "{", "switch", "actual", ":=", "att", ".", "Type", ".", "(", "type", ")", "{", "case", "design", ".", "Primitive", ":", "switch", "actual", ".", "Kind", "(", ")", "{", "case", "design", ".", "IntegerKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ",", "name", ")", "\n", "case", "design", ".", "BooleanKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ",", "name", ")", "\n", "case", "design", ".", "NumberKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ",", "name", ")", "\n", "case", "design", ".", "StringKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ",", "name", ")", "\n", "case", "design", ".", "DateTimeKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ",", "strings", ".", "Replace", "(", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", ")", "// remove pointer if present", "\n", "case", "design", ".", "UUIDKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ",", "strings", ".", "Replace", "(", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", ")", "// remove pointer if present", "\n", "case", "design", ".", "AnyKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "target", ",", "name", ")", "\n", "case", "design", ".", "FileKind", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "target", ",", "name", ")", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "*", "design", ".", "Array", ":", "data", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "name", ",", "\"", "\"", ":", "target", ",", "\"", "\"", ":", "actual", ".", "ElemType", ",", "}", "\n", "return", "codegen", ".", "RunTemplate", "(", "arrayToStringTmpl", ",", "data", ")", "\n", "default", ":", "panic", "(", "\"", "\"", "+", "att", ".", "Type", ".", "Name", "(", ")", "+", "\"", "\"", ")", "// bug", "\n", "}", "\n", "}" ]

[ "toString", "generates", "Go", "code", "that", "converts", "the", "given", "simple", "type", "attribute", "into", "a", "string", "." ]

[ "func", "defaultPath", "(", "action", "*", "design", ".", "ActionDefinition", ")", "string", "{", "for", "_", ",", "r", ":=", "range", "action", ".", "Routes", "{", "candidate", ":=", "r", ".", "FullPath", "(", ")", "\n", "if", "!", "strings", ".", "ContainsRune", "(", "candidate", ",", "':'", ")", "{", "return", "candidate", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "defaultPath", "returns", "the", "first", "route", "path", "for", "the", "given", "action", "that", "does", "not", "take", "any", "wildcard", "empty", "string", "if", "none", "." ]

[ "func", "signerType", "(", "scheme", "*", "design", ".", "SecuritySchemeDefinition", ")", "string", "{", "switch", "scheme", ".", "Kind", "{", "case", "design", ".", "JWTSecurityKind", ":", "return", "\"", "\"", "// goa client package imported under goaclient", "\n", "case", "design", ".", "OAuth2SecurityKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "APIKeySecurityKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "BasicAuthSecurityKind", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "signerType", "returns", "the", "name", "of", "the", "client", "signer", "used", "for", "the", "defined", "security", "model", "on", "the", "Action" ]

[ "func", "pathTemplate", "(", "r", "*", "design", ".", "RouteDefinition", ")", "string", "{", "return", "design", ".", "WildcardRegex", ".", "ReplaceAllLiteralString", "(", "r", ".", "FullPath", "(", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "pathTemplate", "returns", "a", "fmt", "format", "suitable", "to", "build", "a", "request", "path", "to", "the", "route", "." ]

[ "func", "pathParams", "(", "r", "*", "design", ".", "RouteDefinition", ")", "string", "{", "pnames", ":=", "r", ".", "Params", "(", ")", "\n", "params", ":=", "make", "(", "design", ".", "Object", ",", "len", "(", "pnames", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "pnames", "{", "params", "[", "p", "]", "=", "r", ".", "Parent", ".", "Params", ".", "Type", ".", "ToObject", "(", ")", "[", "p", "]", "\n", "}", "\n", "return", "join", "(", "&", "design", ".", "AttributeDefinition", "{", "Type", ":", "params", "}", ",", "false", ",", "pnames", ")", "\n", "}" ]

[ "pathParams", "return", "the", "function", "signature", "of", "the", "path", "factory", "function", "for", "the", "given", "route", "." ]

[ "func", "typeName", "(", "mt", "*", "design", ".", "MediaTypeDefinition", ")", "string", "{", "if", "mt", ".", "IsError", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "codegen", ".", "GoTypeName", "(", "mt", ",", "mt", ".", "AllRequired", "(", ")", ",", "1", ",", "false", ")", "\n", "}" ]

[ "typeName", "returns", "Go", "type", "name", "of", "given", "MediaType", "definition", "." ]

[ "func", "initParams", "(", "att", "*", "design", ".", "AttributeDefinition", ")", "(", "[", "]", "*", "paramData", ",", "[", "]", "*", "paramData", ")", "{", "if", "att", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "obj", ":=", "att", ".", "Type", ".", "ToObject", "(", ")", "\n", "var", "reqParamData", "[", "]", "*", "paramData", "\n", "var", "optParamData", "[", "]", "*", "paramData", "\n", "for", "n", ",", "q", ":=", "range", "obj", "{", "varName", ":=", "codegen", ".", "Goify", "(", "n", ",", "false", ")", "\n", "param", ":=", "&", "paramData", "{", "Name", ":", "n", ",", "VarName", ":", "varName", ",", "Attribute", ":", "q", ",", "}", "\n", "if", "q", ".", "Type", ".", "IsPrimitive", "(", ")", "{", "param", ".", "MustToString", "=", "q", ".", "Type", ".", "Kind", "(", ")", "!=", "design", ".", "StringKind", "\n", "param", ".", "ValueName", "=", "toValueTypeName", "(", "varName", ",", "n", ",", "att", ")", "\n", "if", "att", ".", "IsRequired", "(", "n", ")", "{", "reqParamData", "=", "append", "(", "reqParamData", ",", "param", ")", "\n", "}", "else", "{", "param", ".", "CheckNil", "=", "true", "\n", "optParamData", "=", "append", "(", "optParamData", ",", "param", ")", "\n", "}", "\n", "}", "else", "{", "if", "q", ".", "Type", ".", "IsArray", "(", ")", "{", "param", ".", "IsArray", "=", "true", "\n", "param", ".", "ElemAttribute", "=", "q", ".", "Type", ".", "ToArray", "(", ")", ".", "ElemType", "\n", "}", "\n", "param", ".", "MustToString", "=", "true", "\n", "param", ".", "ValueName", "=", "varName", "\n", "param", ".", "CheckNil", "=", "true", "\n", "if", "att", ".", "IsRequired", "(", "n", ")", "{", "reqParamData", "=", "append", "(", "reqParamData", ",", "param", ")", "\n", "}", "else", "{", "optParamData", "=", "append", "(", "optParamData", ",", "param", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "reqParamData", ",", "optParamData", "\n", "}" ]

[ "initParams", "returns", "required", "and", "optional", "paramData", "extracted", "from", "given", "attribute", "definition", "." ]

[ "func", "WithJWT", "(", "ctx", "context", ".", "Context", ",", "t", "*", "jwt", ".", "Token", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "jwtKey", ",", "t", ")", "\n", "}" ]

[ "WithJWT", "creates", "a", "child", "context", "containing", "the", "given", "JWT", "." ]

[ "func", "ContextJWT", "(", "ctx", "context", ".", "Context", ")", "*", "jwt", ".", "Token", "{", "token", ",", "ok", ":=", "ctx", ".", "Value", "(", "jwtKey", ")", ".", "(", "*", "jwt", ".", "Token", ")", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "return", "token", "\n", "}" ]

[ "ContextJWT", "retrieves", "the", "JWT", "token", "from", "a", "context", "that", "went", "through", "our", "security", "middleware", "." ]

[ "func", "MatchOriginRegexp", "(", "origin", "string", ",", "spec", "*", "regexp", ".", "Regexp", ")", "bool", "{", "return", "spec", ".", "Match", "(", "[", "]", "byte", "(", "origin", ")", ")", "\n", "}" ]

[ "MatchOriginRegexp", "returns", "true", "if", "the", "given", "Origin", "header", "value", "matches", "the", "origin", "specification", ".", "Spec", "must", "be", "a", "valid", "regex" ]

[ "func", "HandlePreflight", "(", ")", "goa", ".", "Handler", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "rw", ".", "WriteHeader", "(", "200", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "HandlePreflight", "returns", "a", "simple", "200", "response", ".", "The", "middleware", "takes", "care", "of", "handling", "CORS", "." ]

[ "func", "buildEncodingDefinition", "(", "encoding", "bool", ",", "args", "...", "interface", "{", "}", ")", "*", "design", ".", "EncodingDefinition", "{", "var", "dsl", "func", "(", ")", "\n", "var", "ok", "bool", "\n", "funcName", ":=", "\"", "\"", "\n", "if", "encoding", "{", "funcName", "=", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "args", ")", "==", "0", "{", "dslengine", ".", "ReportError", "(", "\"", "\"", ",", "funcName", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "_", ",", "ok", "=", "args", "[", "0", "]", ".", "(", "string", ")", ";", "!", "ok", "{", "dslengine", ".", "ReportError", "(", "\"", "\"", ",", "funcName", ")", "\n", "return", "nil", "\n", "}", "\n", "last", ":=", "len", "(", "args", ")", "\n", "if", "dsl", ",", "ok", "=", "args", "[", "len", "(", "args", ")", "-", "1", "]", ".", "(", "func", "(", ")", ")", ";", "ok", "{", "last", "=", "len", "(", "args", ")", "-", "1", "\n", "}", "\n", "mimeTypes", ":=", "make", "(", "[", "]", "string", ",", "last", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "last", ";", "i", "++", "{", "var", "mimeType", "string", "\n", "if", "mimeType", ",", "ok", "=", "args", "[", "i", "]", ".", "(", "string", ")", ";", "!", "ok", "{", "dslengine", ".", "ReportError", "(", "\"", "\"", ",", "i", ",", "funcName", ")", "\n", "return", "nil", "\n", "}", "\n", "mimeTypes", "[", "i", "]", "=", "mimeType", "\n", "}", "\n", "d", ":=", "&", "design", ".", "EncodingDefinition", "{", "MIMETypes", ":", "mimeTypes", ",", "Encoder", ":", "encoding", "}", "\n", "if", "dsl", "!=", "nil", "{", "dslengine", ".", "Execute", "(", "dsl", ",", "d", ")", "\n", "}", "\n", "return", "d", "\n", "}" ]

[ "buildEncodingDefinition", "builds", "up", "an", "encoding", "definition", "." ]

[ "func", "NewGenerator", "(", "options", "...", "Option", ")", "*", "Generator", "{", "g", ":=", "&", "Generator", "{", "}", "\n", "g", ".", "validator", "=", "codegen", ".", "NewValidator", "(", ")", "\n\n", "for", "_", ",", "option", ":=", "range", "options", "{", "option", "(", "g", ")", "\n", "}", "\n\n", "return", "g", "\n", "}" ]

[ "NewGenerator", "returns", "an", "initialized", "instance", "of", "an", "Application", "Generator" ]

[ "func", "(", "g", "*", "Generator", ")", "Cleanup", "(", ")", "{", "if", "len", "(", "g", ".", "genfiles", ")", "==", "0", "{", "return", "\n", "}", "\n", "os", ".", "RemoveAll", "(", "g", ".", "OutDir", ")", "\n", "g", ".", "genfiles", "=", "nil", "\n", "}" ]

[ "Cleanup", "removes", "the", "entire", "app", "directory", "if", "it", "was", "created", "by", "this", "generator", "." ]

[ "func", "(", "g", "*", "Generator", ")", "generateHrefs", "(", ")", "(", "err", "error", ")", "{", "var", "(", "hrefFile", "string", "\n", "resWr", "*", "ResourcesWriter", "\n", ")", "\n", "{", "hrefFile", "=", "filepath", ".", "Join", "(", "g", ".", "OutDir", ",", "\"", "\"", ")", "\n", "resWr", ",", "err", "=", "NewResourcesWriter", "(", "hrefFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "defer", "func", "(", ")", "{", "resWr", ".", "Close", "(", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "resWr", ".", "FormatCode", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n", "title", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "g", ".", "API", ".", "Context", "(", ")", ")", "\n", "imports", ":=", "[", "]", "*", "codegen", ".", "ImportSpec", "{", "codegen", ".", "SimpleImport", "(", "\"", "\"", ")", ",", "codegen", ".", "SimpleImport", "(", "\"", "\"", ")", ",", "}", "\n", "if", "err", "=", "resWr", ".", "WriteHeader", "(", "title", ",", "g", ".", "Target", ",", "imports", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "g", ".", "genfiles", "=", "append", "(", "g", ".", "genfiles", ",", "hrefFile", ")", "\n", "err", "=", "g", ".", "API", ".", "IterateResources", "(", "func", "(", "r", "*", "design", ".", "ResourceDefinition", ")", "error", "{", "m", ":=", "g", ".", "API", ".", "MediaTypeWithIdentifier", "(", "r", ".", "MediaType", ")", "\n", "var", "identifier", "string", "\n", "if", "m", "!=", "nil", "{", "identifier", "=", "m", ".", "Identifier", "\n", "}", "else", "{", "identifier", "=", "\"", "\"", "\n", "}", "\n", "data", ":=", "ResourceData", "{", "Name", ":", "codegen", ".", "Goify", "(", "r", ".", "Name", ",", "true", ")", ",", "Identifier", ":", "identifier", ",", "Description", ":", "r", ".", "Description", ",", "Type", ":", "m", ",", "CanonicalTemplate", ":", "codegen", ".", "CanonicalTemplate", "(", "r", ")", ",", "CanonicalParams", ":", "codegen", ".", "CanonicalParams", "(", "r", ")", ",", "}", "\n", "return", "resWr", ".", "Execute", "(", "&", "data", ")", "\n", "}", ")", "\n", "return", "\n", "}" ]

[ "generateHrefs", "iterates", "through", "the", "API", "resources", "and", "generates", "the", "href", "factory", "methods", "." ]

[ "func", "(", "eg", "*", "exampleGenerator", ")", "Generate", "(", "seen", "[", "]", "string", ")", "interface", "{", "}", "{", "// Randomize array length first, since that's from higher level", "if", "eg", ".", "hasLengthValidation", "(", ")", "{", "return", "eg", ".", "generateValidatedLengthExample", "(", "seen", ")", "\n", "}", "\n", "// Enum should dominate, because the potential \"examples\" are fixed", "if", "eg", ".", "hasEnumValidation", "(", ")", "{", "return", "eg", ".", "generateValidatedEnumExample", "(", ")", "\n", "}", "\n", "// loop until a satisified example is generated", "hasFormat", ",", "hasPattern", ",", "hasMinMax", ":=", "eg", ".", "hasFormatValidation", "(", ")", ",", "eg", ".", "hasPatternValidation", "(", ")", ",", "eg", ".", "hasMinMaxValidation", "(", ")", "\n", "attempts", ":=", "0", "\n", "for", "attempts", "<", "maxAttempts", "{", "attempts", "++", "\n", "var", "example", "interface", "{", "}", "\n", "// Format comes first, since it initiates the example", "if", "hasFormat", "{", "example", "=", "eg", ".", "generateFormatExample", "(", ")", "\n", "}", "\n", "// now validate with the rest of matchers; if not satisified, redo", "if", "hasPattern", "{", "if", "example", "==", "nil", "{", "example", "=", "eg", ".", "generateValidatedPatternExample", "(", ")", "\n", "}", "else", "if", "!", "eg", ".", "checkPatternValidation", "(", "example", ")", "{", "continue", "\n", "}", "\n", "}", "\n", "if", "hasMinMax", "{", "if", "example", "==", "nil", "{", "example", "=", "eg", ".", "generateValidatedMinMaxValueExample", "(", ")", "\n", "}", "else", "if", "!", "eg", ".", "checkMinMaxValueValidation", "(", "example", ")", "{", "continue", "\n", "}", "\n", "}", "\n", "if", "example", "==", "nil", "{", "example", "=", "eg", ".", "a", ".", "Type", ".", "GenerateExample", "(", "eg", ".", "r", ",", "seen", ")", "\n", "}", "\n", "return", "example", "\n", "}", "\n", "return", "eg", ".", "a", ".", "Type", ".", "GenerateExample", "(", "eg", ".", "r", ",", "seen", ")", "\n", "}" ]

[ "Generate", "generates", "a", "random", "value", "based", "on", "the", "given", "validations", "." ]

[ "func", "(", "eg", "*", "exampleGenerator", ")", "generateValidatedLengthExample", "(", "seen", "[", "]", "string", ")", "interface", "{", "}", "{", "count", ":=", "eg", ".", "ExampleLength", "(", ")", "\n", "if", "!", "eg", ".", "a", ".", "Type", ".", "IsArray", "(", ")", "{", "return", "eg", ".", "r", ".", "faker", ".", "Characters", "(", "count", ")", "\n", "}", "\n", "res", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "count", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "count", ";", "i", "++", "{", "res", "[", "i", "]", "=", "eg", ".", "a", ".", "Type", ".", "ToArray", "(", ")", ".", "ElemType", ".", "GenerateExample", "(", "eg", ".", "r", ",", "seen", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "generateValidatedLengthExample", "generates", "a", "random", "size", "array", "of", "examples", "based", "on", "what", "s", "given", "." ]

[ "func", "(", "eg", "*", "exampleGenerator", ")", "generateValidatedEnumExample", "(", ")", "interface", "{", "}", "{", "if", "!", "eg", ".", "hasEnumValidation", "(", ")", "{", "return", "nil", "\n", "}", "\n", "values", ":=", "eg", ".", "a", ".", "Validation", ".", "Values", "\n", "count", ":=", "len", "(", "values", ")", "\n", "i", ":=", "eg", ".", "r", ".", "Int", "(", ")", "%", "count", "\n", "return", "values", "[", "i", "]", "\n", "}" ]

[ "generateValidatedEnumExample", "returns", "a", "random", "selected", "enum", "value", "." ]

[ "func", "(", "eg", "*", "exampleGenerator", ")", "generateFormatExample", "(", ")", "interface", "{", "}", "{", "if", "!", "eg", ".", "hasFormatValidation", "(", ")", "{", "return", "nil", "\n", "}", "\n", "format", ":=", "eg", ".", "a", ".", "Validation", ".", "Format", "\n", "if", "res", ",", "ok", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "Email", "(", ")", ",", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "DomainName", "(", ")", "+", "\"", "\"", "+", "eg", ".", "r", ".", "faker", ".", "DomainSuffix", "(", ")", ",", "\"", "\"", ":", "time", ".", "Unix", "(", "int64", "(", "eg", ".", "r", ".", "Int", "(", ")", ")", "%", "1454957045", ",", "0", ")", ".", "Format", "(", "\"", "\"", ")", ",", "// to obtain a \"fixed\" rand", "\"", "\"", ":", "time", ".", "Unix", "(", "int64", "(", "eg", ".", "r", ".", "Int", "(", ")", ")", "%", "1454957045", ",", "0", ")", ".", "Format", "(", "time", ".", "RFC3339", ")", ",", "// to obtain a \"fixed\" rand", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "IPv4Address", "(", ")", ".", "String", "(", ")", ",", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "IPv6Address", "(", ")", ".", "String", "(", ")", ",", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "IPv4Address", "(", ")", ".", "String", "(", ")", ",", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "URL", "(", ")", ",", "\"", "\"", ":", "func", "(", ")", "string", "{", "res", ",", "err", ":=", "regen", ".", "Generate", "(", "`([0-9A-F]{2}-){5}[0-9A-F]{2}`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "res", "\n", "}", "(", ")", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "eg", ".", "r", ".", "faker", ".", "Characters", "(", "3", ")", "+", "\"", "\"", ",", "\"", "\"", ":", "time", ".", "Unix", "(", "int64", "(", "eg", ".", "r", ".", "Int", "(", ")", ")", "%", "1454957045", ",", "0", ")", ".", "Format", "(", "time", ".", "RFC1123", ")", ",", "// to obtain a \"fixed\" rand", "}", "[", "format", "]", ";", "ok", "{", "return", "res", "\n", "}", "\n", "panic", "(", "\"", "\"", "+", "format", "+", "\"", "\"", ")", "// bug", "\n", "}" ]

[ "generateFormatExample", "returns", "a", "random", "example", "based", "on", "the", "format", "the", "user", "asks", "." ]

[ "func", "TraceIDFunc", "(", "f", "IDFunc", ")", "TracerOption", "{", "return", "func", "(", "o", "*", "tracerOptions", ")", "*", "tracerOptions", "{", "if", "f", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "o", ".", "traceIDFunc", "=", "f", "\n", "return", "o", "\n", "}", "\n", "}" ]

[ "TraceIDFunc", "is", "a", "constructor", "option", "that", "overrides", "the", "function", "used", "to", "compute", "trace", "IDs", "." ]

[ "func", "SpanIDFunc", "(", "f", "IDFunc", ")", "TracerOption", "{", "return", "func", "(", "o", "*", "tracerOptions", ")", "*", "tracerOptions", "{", "if", "f", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "o", ".", "spanIDFunc", "=", "f", "\n", "return", "o", "\n", "}", "\n", "}" ]

[ "SpanIDFunc", "is", "a", "constructor", "option", "that", "overrides", "the", "function", "used", "to", "compute", "span", "IDs", "." ]

[ "func", "SamplingPercent", "(", "p", "int", ")", "TracerOption", "{", "if", "p", "<", "0", "||", "p", ">", "100", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "func", "(", "o", "*", "tracerOptions", ")", "*", "tracerOptions", "{", "o", ".", "samplingPercent", "=", "p", "\n", "return", "o", "\n", "}", "\n", "}" ]

[ "SamplingPercent", "sets", "the", "tracing", "sampling", "rate", "as", "a", "percentage", "value", ".", "It", "panics", "if", "p", "is", "less", "than", "0", "or", "more", "than", "100", ".", "SamplingPercent", "and", "MaxSamplingRate", "are", "mutually", "exclusive", "." ]

[ "func", "MaxSamplingRate", "(", "r", "int", ")", "TracerOption", "{", "if", "r", "<=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "func", "(", "o", "*", "tracerOptions", ")", "*", "tracerOptions", "{", "o", ".", "maxSamplingRate", "=", "r", "\n", "return", "o", "\n", "}", "\n", "}" ]

[ "MaxSamplingRate", "sets", "a", "target", "sampling", "rate", "in", "requests", "per", "second", ".", "Setting", "a", "max", "sampling", "rate", "causes", "the", "middleware", "to", "adjust", "the", "sampling", "percent", "dynamically", ".", "SamplingPercent", "and", "MaxSamplingRate", "are", "mutually", "exclusive", "." ]

[ "func", "SampleSize", "(", "s", "int", ")", "TracerOption", "{", "if", "s", "<=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "func", "(", "o", "*", "tracerOptions", ")", "*", "tracerOptions", "{", "o", ".", "sampleSize", "=", "s", "\n", "return", "o", "\n", "}", "\n", "}" ]

[ "SampleSize", "sets", "the", "number", "of", "requests", "between", "two", "adjustments", "of", "the", "sampling", "rate", "when", "MaxSamplingRate", "is", "set", ".", "Defaults", "to", "1", "000", "." ]

[ "func", "NewTracer", "(", "opts", "...", "TracerOption", ")", "goa", ".", "Middleware", "{", "o", ":=", "&", "tracerOptions", "{", "traceIDFunc", ":", "shortID", ",", "spanIDFunc", ":", "shortID", ",", "samplingPercent", ":", "100", ",", "sampleSize", ":", "1000", ",", "// only applies if maxSamplingRate is set", "}", "\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "o", "=", "opt", "(", "o", ")", "\n", "}", "\n", "var", "sampler", "Sampler", "\n", "if", "o", ".", "maxSamplingRate", ">", "0", "{", "sampler", "=", "NewAdaptiveSampler", "(", "o", ".", "maxSamplingRate", ",", "o", ".", "sampleSize", ")", "\n", "}", "else", "{", "sampler", "=", "NewFixedSampler", "(", "o", ".", "samplingPercent", ")", "\n", "}", "\n", "return", "func", "(", "h", "goa", ".", "Handler", ")", "goa", ".", "Handler", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "// insert a new trace ID only if not already being traced.", "traceID", ":=", "req", ".", "Header", ".", "Get", "(", "TraceIDHeader", ")", "\n", "if", "traceID", "==", "\"", "\"", "{", "// insert tracing only within sample.", "if", "sampler", ".", "Sample", "(", ")", "{", "traceID", "=", "o", ".", "traceIDFunc", "(", ")", "\n", "}", "else", "{", "return", "h", "(", "ctx", ",", "rw", ",", "req", ")", "\n", "}", "\n", "}", "\n\n", "// insert IDs into context to enable tracing.", "spanID", ":=", "o", ".", "spanIDFunc", "(", ")", "\n", "parentID", ":=", "req", ".", "Header", ".", "Get", "(", "ParentSpanIDHeader", ")", "\n", "ctx", "=", "WithTrace", "(", "ctx", ",", "traceID", ",", "spanID", ",", "parentID", ")", "\n", "return", "h", "(", "ctx", ",", "rw", ",", "req", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "NewTracer", "returns", "a", "trace", "middleware", "that", "initializes", "the", "trace", "information", "in", "the", "request", "context", ".", "The", "information", "can", "be", "retrieved", "using", "any", "of", "the", "ContextXXX", "functions", ".", "samplingPercent", "must", "be", "a", "value", "between", "0", "and", "100", ".", "It", "represents", "the", "percentage", "of", "requests", "that", "should", "be", "traced", ".", "If", "the", "incoming", "request", "has", "a", "Trace", "ID", "header", "then", "the", "sampling", "rate", "is", "disregarded", "and", "the", "tracing", "is", "enabled", ".", "spanIDFunc", "and", "traceIDFunc", "are", "the", "functions", "used", "to", "create", "Span", "and", "Trace", "IDs", "respectively", ".", "This", "is", "configurable", "so", "that", "the", "created", "IDs", "are", "compatible", "with", "the", "various", "backend", "tracing", "systems", ".", "The", "xray", "package", "provides", "implementations", "that", "produce", "AWS", "X", "-", "Ray", "compatible", "IDs", "." ]

[ "func", "Tracer", "(", "sampleRate", "int", ",", "spanIDFunc", ",", "traceIDFunc", "IDFunc", ")", "goa", ".", "Middleware", "{", "return", "NewTracer", "(", "SamplingPercent", "(", "sampleRate", ")", ",", "SpanIDFunc", "(", "spanIDFunc", ")", ",", "TraceIDFunc", "(", "traceIDFunc", ")", ")", "\n", "}" ]

[ "Tracer", "is", "deprecated", "in", "favor", "of", "NewTracer", "." ]

[ "func", "ContextTraceID", "(", "ctx", "context", ".", "Context", ")", "string", "{", "if", "t", ":=", "ctx", ".", "Value", "(", "traceKey", ")", ";", "t", "!=", "nil", "{", "return", "t", ".", "(", "string", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "ContextTraceID", "returns", "the", "trace", "ID", "extracted", "from", "the", "given", "context", "if", "any", "the", "empty", "string", "otherwise", "." ]

[ "func", "ContextSpanID", "(", "ctx", "context", ".", "Context", ")", "string", "{", "if", "s", ":=", "ctx", ".", "Value", "(", "spanKey", ")", ";", "s", "!=", "nil", "{", "return", "s", ".", "(", "string", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "ContextSpanID", "returns", "the", "span", "ID", "extracted", "from", "the", "given", "context", "if", "any", "the", "empty", "string", "otherwise", "." ]

[ "func", "ContextParentSpanID", "(", "ctx", "context", ".", "Context", ")", "string", "{", "if", "p", ":=", "ctx", ".", "Value", "(", "parentSpanKey", ")", ";", "p", "!=", "nil", "{", "return", "p", ".", "(", "string", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "ContextParentSpanID", "returns", "the", "parent", "span", "ID", "extracted", "from", "the", "given", "context", "if", "any", "the", "empty", "string", "otherwise", "." ]

[ "func", "WithTrace", "(", "ctx", "context", ".", "Context", ",", "traceID", ",", "spanID", ",", "parentID", "string", ")", "context", ".", "Context", "{", "if", "parentID", "!=", "\"", "\"", "{", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "parentSpanKey", ",", "parentID", ")", "\n", "}", "\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "traceKey", ",", "traceID", ")", "\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "spanKey", ",", "spanID", ")", "\n", "return", "ctx", "\n", "}" ]

[ "WithTrace", "returns", "a", "context", "containing", "the", "given", "trace", "span", "and", "parent", "span", "IDs", "." ]

[ "func", "(", "d", "*", "tracedDoer", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "req", "*", "http", ".", "Request", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "var", "(", "traceID", "=", "ContextTraceID", "(", "ctx", ")", "\n", "spanID", "=", "ContextSpanID", "(", "ctx", ")", "\n", ")", "\n", "if", "traceID", "!=", "\"", "\"", "{", "req", ".", "Header", ".", "Set", "(", "TraceIDHeader", ",", "traceID", ")", "\n", "req", ".", "Header", ".", "Set", "(", "ParentSpanIDHeader", ",", "spanID", ")", "\n", "}", "\n\n", "return", "d", ".", "Doer", ".", "Do", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "Do", "adds", "the", "tracing", "headers", "to", "the", "requests", "before", "making", "it", "." ]

[ "func", "ValidatePattern", "(", "p", "string", ",", "val", "string", ")", "bool", "{", "knownPatternsLock", ".", "RLock", "(", ")", "\n", "r", ",", "ok", ":=", "knownPatterns", "[", "p", "]", "\n", "knownPatternsLock", ".", "RUnlock", "(", ")", "\n", "if", "!", "ok", "{", "r", "=", "regexp", ".", "MustCompile", "(", "p", ")", "// DSL validation makes sure regexp is valid", "\n", "knownPatternsLock", ".", "Lock", "(", ")", "\n", "knownPatterns", "[", "p", "]", "=", "r", "\n", "knownPatternsLock", ".", "Unlock", "(", ")", "\n", "}", "\n", "return", "r", ".", "MatchString", "(", "val", ")", "\n", "}" ]

[ "ValidatePattern", "returns", "an", "error", "if", "val", "does", "not", "match", "the", "regular", "expression", "p", ".", "It", "makes", "an", "effort", "to", "minimize", "the", "number", "of", "times", "the", "regular", "expression", "needs", "to", "be", "compiled", "." ]

[ "func", "New", "(", "c", "Doer", ")", "*", "Client", "{", "if", "c", "==", "nil", "{", "c", "=", "HTTPClientDoer", "(", "http", ".", "DefaultClient", ")", "\n", "}", "\n", "return", "&", "Client", "{", "Doer", ":", "c", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "API", "client", "that", "wraps", "c", ".", "If", "c", "is", "nil", "the", "returned", "client", "wraps", "http", ".", "DefaultClient", "." ]

[ "func", "(", "f", "doFunc", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "req", "*", "http", ".", "Request", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "return", "f", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "Do", "implements", "Doer", ".", "Do" ]

[ "func", "(", "c", "*", "Client", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "req", "*", "http", ".", "Request", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "// TODO: setting the request ID should be done via client middleware. For now only set it if the", "// caller provided one in the ctx.", "if", "ctxreqid", ":=", "ContextRequestID", "(", "ctx", ")", ";", "ctxreqid", "!=", "\"", "\"", "{", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "ctxreqid", ")", "\n", "}", "\n", "if", "c", ".", "UserAgent", "!=", "\"", "\"", "{", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "c", ".", "UserAgent", ")", "\n", "}", "\n", "startedAt", ":=", "time", ".", "Now", "(", ")", "\n", "ctx", ",", "id", ":=", "ContextWithRequestID", "(", "ctx", ")", "\n", "goa", ".", "LogInfo", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "id", ",", "req", ".", "Method", ",", "req", ".", "URL", ".", "String", "(", ")", ")", "\n", "if", "c", ".", "Dump", "{", "c", ".", "dumpRequest", "(", "ctx", ",", "req", ")", "\n", "}", "\n", "resp", ",", "err", ":=", "c", ".", "Doer", ".", "Do", "(", "ctx", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "goa", ".", "LogError", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "goa", ".", "LogInfo", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "id", ",", "\"", "\"", ",", "resp", ".", "StatusCode", ",", "\"", "\"", ",", "time", ".", "Since", "(", "startedAt", ")", ".", "String", "(", ")", ")", "\n", "if", "c", ".", "Dump", "{", "c", ".", "dumpResponse", "(", "ctx", ",", "resp", ")", "\n", "}", "\n", "return", "resp", ",", "err", "\n", "}" ]

[ "Do", "wraps", "the", "underlying", "http", "client", "Do", "method", "and", "adds", "logging", ".", "The", "logger", "should", "be", "in", "the", "context", "." ]

[ "func", "(", "c", "*", "Client", ")", "dumpRequest", "(", "ctx", "context", ".", "Context", ",", "req", "*", "http", ".", "Request", ")", "{", "reqBody", ",", "err", ":=", "dumpReqBody", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "goa", ".", "LogError", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "goa", ".", "LogInfo", "(", "ctx", ",", "\"", "\"", ",", "headersToSlice", "(", "req", ".", "Header", ")", "...", ")", "\n", "if", "reqBody", "!=", "nil", "{", "goa", ".", "LogInfo", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "string", "(", "reqBody", ")", ")", "\n", "}", "\n", "}" ]

[ "Dump", "request", "if", "needed", "." ]

[ "func", "(", "c", "*", "Client", ")", "dumpResponse", "(", "ctx", "context", ".", "Context", ",", "resp", "*", "http", ".", "Response", ")", "{", "respBody", ",", "_", ":=", "dumpRespBody", "(", "resp", ")", "\n", "goa", ".", "LogInfo", "(", "ctx", ",", "\"", "\"", ",", "headersToSlice", "(", "resp", ".", "Header", ")", "...", ")", "\n", "if", "respBody", "!=", "nil", "{", "goa", ".", "LogInfo", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "string", "(", "respBody", ")", ")", "\n", "}", "\n", "}" ]

[ "dumpResponse", "dumps", "the", "response", "and", "the", "request", "." ]

[ "func", "headersToSlice", "(", "header", "http", ".", "Header", ")", "[", "]", "interface", "{", "}", "{", "res", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "2", "*", "len", "(", "header", ")", ")", "\n", "i", ":=", "0", "\n", "for", "k", ",", "v", ":=", "range", "header", "{", "res", "[", "i", "]", "=", "k", "\n", "if", "len", "(", "v", ")", "==", "1", "{", "res", "[", "i", "+", "1", "]", "=", "v", "[", "0", "]", "\n", "}", "else", "{", "res", "[", "i", "+", "1", "]", "=", "v", "\n", "}", "\n", "i", "+=", "2", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "headersToSlice", "produces", "a", "loggable", "slice", "from", "a", "HTTP", "header", "." ]

[ "func", "dumpReqBody", "(", "req", "*", "http", ".", "Request", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "req", ".", "Body", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "var", "save", "io", ".", "ReadCloser", "\n", "var", "err", "error", "\n", "save", ",", "req", ".", "Body", ",", "err", "=", "drainBody", "(", "req", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "b", "bytes", ".", "Buffer", "\n", "var", "dest", "io", ".", "Writer", "=", "&", "b", "\n", "chunked", ":=", "len", "(", "req", ".", "TransferEncoding", ")", ">", "0", "&&", "req", ".", "TransferEncoding", "[", "0", "]", "==", "\"", "\"", "\n", "if", "chunked", "{", "dest", "=", "httputil", ".", "NewChunkedWriter", "(", "dest", ")", "\n", "}", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "dest", ",", "req", ".", "Body", ")", "\n", "if", "chunked", "{", "dest", ".", "(", "io", ".", "Closer", ")", ".", "Close", "(", ")", "\n", "io", ".", "WriteString", "(", "&", "b", ",", "\"", "\\r", "\\n", "\"", ")", "\n", "}", "\n", "req", ".", "Body", "=", "save", "\n", "return", "b", ".", "Bytes", "(", ")", ",", "err", "\n", "}" ]

[ "Dump", "request", "body", "strongly", "inspired", "from", "httputil", ".", "DumpRequest" ]

[ "func", "dumpRespBody", "(", "resp", "*", "http", ".", "Response", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "resp", ".", "Body", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "var", "b", "bytes", ".", "Buffer", "\n", "savecl", ":=", "resp", ".", "ContentLength", "\n", "var", "save", "io", ".", "ReadCloser", "\n", "var", "err", "error", "\n", "save", ",", "resp", ".", "Body", ",", "err", "=", "drainBody", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "&", "b", ",", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "resp", ".", "Body", "=", "save", "\n", "resp", ".", "ContentLength", "=", "savecl", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "b", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "Dump", "response", "body", "strongly", "inspired", "from", "httputil", ".", "DumpResponse" ]

[ "func", "ContextRequestID", "(", "ctx", "context", ".", "Context", ")", "string", "{", "var", "reqID", "string", "\n", "id", ":=", "ctx", ".", "Value", "(", "reqIDKey", ")", "\n", "if", "id", "!=", "nil", "{", "reqID", "=", "id", ".", "(", "string", ")", "\n", "}", "\n", "return", "reqID", "\n", "}" ]

[ "ContextRequestID", "extracts", "the", "Request", "ID", "from", "the", "context", "." ]

[ "func", "ContextWithRequestID", "(", "ctx", "context", ".", "Context", ")", "(", "context", ".", "Context", ",", "string", ")", "{", "reqID", ":=", "ContextRequestID", "(", "ctx", ")", "\n", "if", "reqID", "==", "\"", "\"", "{", "reqID", "=", "shortID", "(", ")", "\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "reqIDKey", ",", "reqID", ")", "\n", "}", "\n", "return", "ctx", ",", "reqID", "\n", "}" ]

[ "ContextWithRequestID", "returns", "ctx", "and", "the", "request", "ID", "if", "it", "already", "has", "one", "or", "creates", "and", "returns", "a", "new", "context", "with", "a", "new", "request", "ID", "." ]