Datasets:

CM

/

codexglue_code2text_go

like 0

[ "func", "(", "uuid", "UUID", ")", "Variant", "(", ")", "Variant", "{", "if", "len", "(", "uuid", ")", "!=", "16", "{", "return", "Invalid", "\n", "}", "\n", "switch", "{", "case", "(", "uuid", "[", "8", "]", "&", "0xc0", ")", "==", "0x80", ":", "return", "RFC4122", "\n", "case", "(", "uuid", "[", "8", "]", "&", "0xe0", ")", "==", "0xc0", ":", "return", "Microsoft", "\n", "case", "(", "uuid", "[", "8", "]", "&", "0xe0", ")", "==", "0xe0", ":", "return", "Future", "\n", "default", ":", "return", "Reserved", "\n", "}", "\n", "}" ]

[ "Variant", "returns", "the", "variant", "encoded", "in", "uuid", ".", "It", "returns", "Invalid", "if", "uuid", "is", "invalid", "." ]

[ "func", "(", "uuid", "UUID", ")", "Version", "(", ")", "(", "Version", ",", "bool", ")", "{", "if", "len", "(", "uuid", ")", "!=", "16", "{", "return", "0", ",", "false", "\n", "}", "\n", "return", "Version", "(", "uuid", "[", "6", "]", ">>", "4", ")", ",", "true", "\n", "}" ]

[ "Version", "returns", "the", "version", "of", "uuid", ".", "It", "returns", "false", "if", "uuid", "is", "not", "valid", "." ]

[ "func", "NewUUID", "(", ")", "UUID", "{", "gu", ",", "err", ":=", "guuid", ".", "NewUUID", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "UUID", "(", "gu", "[", ":", "]", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "NewUUID", "returns", "a", "Version", "1", "UUID", "based", "on", "the", "current", "NodeID", "and", "clock", "sequence", "and", "the", "current", "time", ".", "If", "the", "NodeID", "has", "not", "been", "set", "by", "SetNodeID", "or", "SetNodeInterface", "then", "it", "will", "be", "set", "automatically", ".", "If", "the", "NodeID", "cannot", "be", "set", "NewUUID", "returns", "nil", ".", "If", "clock", "sequence", "has", "not", "been", "set", "by", "SetClockSequence", "then", "it", "will", "be", "set", "automatically", ".", "If", "GetTime", "fails", "to", "return", "the", "current", "NewUUID", "returns", "nil", "." ]

[ "func", "OffsetToCursor", "(", "offset", "int", ")", "ConnectionCursor", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "PREFIX", ",", "offset", ")", "\n", "return", "ConnectionCursor", "(", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "[", "]", "byte", "(", "str", ")", ")", ")", "\n", "}" ]

[ "Creates", "the", "cursor", "string", "from", "an", "offset" ]

[ "func", "CursorToOffset", "(", "cursor", "ConnectionCursor", ")", "(", "int", ",", "error", ")", "{", "str", ":=", "\"", "\"", "\n", "b", ",", "err", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "string", "(", "cursor", ")", ")", "\n", "if", "err", "==", "nil", "{", "str", "=", "string", "(", "b", ")", "\n", "}", "\n", "str", "=", "strings", ".", "Replace", "(", "str", ",", "PREFIX", ",", "\"", "\"", ",", "-", "1", ")", "\n", "offset", ",", "err", ":=", "strconv", ".", "Atoi", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "offset", ",", "nil", "\n", "}" ]

[ "Re", "-", "derives", "the", "offset", "from", "the", "cursor", "string", "." ]

[ "func", "CursorForObjectInConnection", "(", "data", "[", "]", "interface", "{", "}", ",", "object", "interface", "{", "}", ")", "ConnectionCursor", "{", "offset", ":=", "-", "1", "\n", "for", "i", ",", "d", ":=", "range", "data", "{", "// TODO: better object comparison", "if", "reflect", ".", "DeepEqual", "(", "d", ",", "object", ")", "{", "offset", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "offset", "==", "-", "1", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "OffsetToCursor", "(", "offset", ")", "\n", "}" ]

[ "Return", "the", "cursor", "associated", "with", "an", "object", "in", "an", "array", "." ]

[ "func", "Run", "(", "r", "http", ".", "Handler", ",", "domain", "...", "string", ")", "error", "{", "return", "http", ".", "Serve", "(", "autocert", ".", "NewListener", "(", "domain", "...", ")", ",", "r", ")", "\n", "}" ]

[ "Run", "support", "1", "-", "line", "LetsEncrypt", "HTTPS", "servers" ]

[ "func", "RunWithManager", "(", "r", "http", ".", "Handler", ",", "m", "*", "autocert", ".", "Manager", ")", "error", "{", "s", ":=", "&", "http", ".", "Server", "{", "Addr", ":", "\"", "\"", ",", "TLSConfig", ":", "m", ".", "TLSConfig", "(", ")", ",", "Handler", ":", "r", ",", "}", "\n\n", "go", "http", ".", "ListenAndServe", "(", "\"", "\"", ",", "m", ".", "HTTPHandler", "(", "nil", ")", ")", "\n\n", "return", "s", ".", "ListenAndServeTLS", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "RunWithManager", "support", "custom", "autocert", "manager" ]

[ "func", "trackPanic", "(", "r", "io", ".", "Reader", ",", "w", "io", ".", "Writer", ",", "dur", "time", ".", "Duration", ",", "result", "chan", "<-", "string", ")", "{", "defer", "close", "(", "result", ")", "\n\n", "var", "panicTimer", "<-", "chan", "time", ".", "Time", "\n", "panicBuf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "panicHeaders", ":=", "[", "]", "[", "]", "byte", "{", "[", "]", "byte", "(", "\"", "\"", ")", ",", "[", "]", "byte", "(", "\"", "\"", ")", ",", "}", "\n", "panicType", ":=", "-", "1", "\n\n", "tempBuf", ":=", "make", "(", "[", "]", "byte", ",", "2048", ")", "\n", "for", "{", "var", "buf", "[", "]", "byte", "\n", "var", "n", "int", "\n\n", "if", "panicTimer", "==", "nil", "&&", "panicBuf", ".", "Len", "(", ")", ">", "0", "{", "// We're not tracking a panic but the buffer length is", "// greater than 0. We need to clear out that buffer, but", "// look for another panic along the way.", "// First, remove the previous panic header so we don't loop", "w", ".", "Write", "(", "panicBuf", ".", "Next", "(", "len", "(", "panicHeaders", "[", "panicType", "]", ")", ")", ")", "\n\n", "// Next, assume that this is our new buffer to inspect", "n", "=", "panicBuf", ".", "Len", "(", ")", "\n", "buf", "=", "make", "(", "[", "]", "byte", ",", "n", ")", "\n", "copy", "(", "buf", ",", "panicBuf", ".", "Bytes", "(", ")", ")", "\n", "panicBuf", ".", "Reset", "(", ")", "\n", "}", "else", "{", "var", "err", "error", "\n", "buf", "=", "tempBuf", "\n", "n", ",", "err", "=", "r", ".", "Read", "(", "buf", ")", "\n", "if", "n", "<=", "0", "&&", "err", "==", "io", ".", "EOF", "{", "if", "panicBuf", ".", "Len", "(", ")", ">", "0", "{", "// We were tracking a panic, assume it was a panic", "// and return that as the result.", "result", "<-", "panicBuf", ".", "String", "(", ")", "\n", "}", "\n\n", "return", "\n", "}", "\n", "}", "\n\n", "if", "panicTimer", "!=", "nil", "{", "// We're tracking what we think is a panic right now.", "// If the timer ended, then it is not a panic.", "isPanic", ":=", "true", "\n", "select", "{", "case", "<-", "panicTimer", ":", "isPanic", "=", "false", "\n", "default", ":", "}", "\n\n", "// No matter what, buffer the text some more.", "panicBuf", ".", "Write", "(", "buf", "[", "0", ":", "n", "]", ")", "\n\n", "if", "!", "isPanic", "{", "// It isn't a panic, stop tracking. Clean-up will happen", "// on the next iteration.", "panicTimer", "=", "nil", "\n", "}", "\n\n", "continue", "\n", "}", "\n\n", "panicType", "=", "-", "1", "\n", "flushIdx", ":=", "n", "\n", "for", "i", ",", "header", ":=", "range", "panicHeaders", "{", "idx", ":=", "bytes", ".", "Index", "(", "buf", "[", "0", ":", "n", "]", ",", "header", ")", "\n", "if", "idx", ">=", "0", "{", "panicType", "=", "i", "\n", "flushIdx", "=", "idx", "\n", "break", "\n", "}", "\n", "}", "\n\n", "// Flush to stderr what isn't a panic", "w", ".", "Write", "(", "buf", "[", "0", ":", "flushIdx", "]", ")", "\n\n", "if", "panicType", "==", "-", "1", "{", "// Not a panic so just continue along", "continue", "\n", "}", "\n\n", "// We have a panic header. Write we assume is a panic os far.", "panicBuf", ".", "Write", "(", "buf", "[", "flushIdx", ":", "n", "]", ")", "\n", "panicTimer", "=", "time", ".", "After", "(", "dur", ")", "\n", "}", "\n", "}" ]

[ "trackPanic", "monitors", "the", "given", "reader", "for", "a", "panic", ".", "If", "a", "panic", "is", "detected", "it", "is", "outputted", "on", "the", "result", "channel", ".", "This", "will", "close", "the", "channel", "once", "it", "is", "complete", "." ]

[ "func", "LambdaVersioningDecorator", "(", ")", "sparta", ".", "TemplateDecoratorHookFunc", "{", "return", "func", "(", "serviceName", "string", ",", "lambdaResourceName", "string", ",", "lambdaResource", "gocf", ".", "LambdaFunction", ",", "resourceMetadata", "map", "[", "string", "]", "interface", "{", "}", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "buildID", "string", ",", "template", "*", "gocf", ".", "Template", ",", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "lambdaResName", ":=", "sparta", ".", "CloudFormationResourceName", "(", "\"", "\"", ",", "buildID", ",", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "String", "(", ")", ")", "\n", "versionResource", ":=", "&", "gocf", ".", "LambdaVersion", "{", "FunctionName", ":", "gocf", ".", "GetAtt", "(", "lambdaResourceName", ",", "\"", "\"", ")", ".", "String", "(", ")", ",", "}", "\n", "lambdaVersionRes", ":=", "template", ".", "AddResource", "(", "lambdaResName", ",", "versionResource", ")", "\n", "lambdaVersionRes", ".", "DeletionPolicy", "=", "\"", "\"", "\n", "// That's it...", "return", "nil", "\n", "}", "\n", "}" ]

[ "LambdaVersioningDecorator", "returns", "a", "TemplateDecorator", "that", "is", "responsible", "for", "including", "a", "versioning", "resource", "with", "the", "given", "lambda", "function" ]

[ "func", "(", "iamRes", "*", "IAMResourceBuilder", ")", "Ref", "(", "resName", "string", ",", "delimiter", "...", "string", ")", "*", "IAMResourceBuilder", "{", "iamRes", ".", "resourceParts", "=", "append", "(", "iamRes", ".", "resourceParts", ",", "gocf", ".", "Ref", "(", "resName", ")", ")", "\n", "for", "_", ",", "eachDelimiter", ":=", "range", "delimiter", "{", "iamRes", ".", "resourceParts", "=", "append", "(", "iamRes", ".", "resourceParts", ",", "gocf", ".", "String", "(", "eachDelimiter", ")", ")", "\n", "}", "\n", "return", "iamRes", "\n", "}" ]

[ "Ref", "inserts", "a", "go", "-", "cloudformation", "Ref", "entry" ]

[ "func", "(", "iamRes", "*", "IAMResourceBuilder", ")", "Attr", "(", "resName", "string", ",", "propName", "string", ",", "delimiter", "...", "string", ")", "*", "IAMResourceBuilder", "{", "iamRes", ".", "resourceParts", "=", "append", "(", "iamRes", ".", "resourceParts", ",", "gocf", ".", "GetAtt", "(", "resName", ",", "propName", ")", ")", "\n", "for", "_", ",", "eachDelimiter", ":=", "range", "delimiter", "{", "iamRes", ".", "resourceParts", "=", "append", "(", "iamRes", ".", "resourceParts", ",", "gocf", ".", "String", "(", "eachDelimiter", ")", ")", "\n", "}", "\n", "return", "iamRes", "\n", "}" ]

[ "Attr", "inserts", "a", "go", "-", "cloudformation", "GetAtt", "entry" ]

[ "func", "(", "iamRes", "*", "IAMResourceBuilder", ")", "Literal", "(", "arnPart", "string", ")", "*", "IAMResourceBuilder", "{", "iamRes", ".", "resourceParts", "=", "append", "(", "iamRes", ".", "resourceParts", ",", "gocf", ".", "String", "(", "arnPart", ")", ")", "\n", "return", "iamRes", "\n", "}" ]

[ "Literal", "inserts", "a", "string", "literal", "into", "the", "ARN", "being", "constructed" ]

[ "func", "(", "iamRes", "*", "IAMResourceBuilder", ")", "ToPrivilege", "(", ")", "sparta", ".", "IAMRolePrivilege", "{", "return", "sparta", ".", "IAMRolePrivilege", "{", "Actions", ":", "iamRes", ".", "builder", ".", "apiCalls", ",", "Resource", ":", "gocf", ".", "Join", "(", "\"", "\"", ",", "iamRes", ".", "resourceParts", "...", ")", ",", "}", "\n", "}" ]

[ "ToPrivilege", "returns", "a", "legacy", "sparta", ".", "IAMRolePrivilege", "type", "for", "this", "entry" ]

[ "func", "(", "iamRes", "*", "IAMBuilder", ")", "ForResource", "(", ")", "*", "IAMResourceBuilder", "{", "return", "&", "IAMResourceBuilder", "{", "builder", ":", "iamRes", ",", "resourceParts", ":", "make", "(", "[", "]", "gocf", ".", "Stringable", ",", "0", ")", ",", "}", "\n", "}" ]

[ "ForResource", "returns", "the", "IAMPrivilegeBuilder", "instance", "which", "can", "be", "finalized", "into", "an", "IAMRolePrivilege" ]

[ "func", "(", "iamRes", "*", "IAMBuilder", ")", "ForFederatedPrincipals", "(", "principals", "...", "string", ")", "*", "IAMPrincipalBuilder", "{", "stringablePrincipals", ":=", "make", "(", "[", "]", "gocf", ".", "Stringable", ",", "len", "(", "principals", ")", ")", "\n", "for", "index", ",", "eachPrincipal", ":=", "range", "principals", "{", "stringablePrincipals", "[", "index", "]", "=", "gocf", ".", "String", "(", "eachPrincipal", ")", "\n", "}", "\n\n", "return", "&", "IAMPrincipalBuilder", "{", "builder", ":", "iamRes", ",", "principal", ":", "&", "gocf", ".", "IAMPrincipal", "{", "Federated", ":", "gocf", ".", "StringList", "(", "stringablePrincipals", "...", ")", ",", "}", ",", "}", "\n", "}" ]

[ "ForFederatedPrincipals", "returns", "the", "IAMPrincipalBuilder", "instance", "which", "can", "be", "finalized", "into", "an", "IAMRolePrivilege" ]

[ "func", "(", "iampb", "*", "IAMPrincipalBuilder", ")", "ToPrivilege", "(", ")", "sparta", ".", "IAMRolePrivilege", "{", "privilege", ":=", "sparta", ".", "IAMRolePrivilege", "{", "Actions", ":", "iampb", ".", "builder", ".", "apiCalls", ",", "Principal", ":", "iampb", ".", "principal", ",", "}", "\n", "if", "iampb", ".", "builder", ".", "condition", "!=", "nil", "{", "privilege", ".", "Condition", "=", "iampb", ".", "builder", ".", "condition", "\n", "}", "\n", "return", "privilege", "\n", "}" ]

[ "ToPrivilege", "returns", "a", "legacy", "sparta", ".", "IAMRolePrivilege", "type", "for", "this", "IAMPrincipalBuilder", "entry" ]

[ "func", "Deny", "(", "apiCalls", "...", "string", ")", "*", "IAMBuilder", "{", "builder", ":=", "IAMBuilder", "{", "apiCalls", ":", "apiCalls", ",", "effect", ":", "\"", "\"", ",", "}", "\n", "return", "&", "builder", "\n", "}" ]

[ "Deny", "creates", "a", "IAMPrivilegeBuilder", "instance", "Denying", "the", "supplied", "API", "calls" ]

[ "func", "resourceOutputs", "(", "resourceName", "string", ",", "resource", "gocf", ".", "ResourceProperties", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "[", "]", "string", ",", "error", ")", "{", "outputProps", ":=", "[", "]", "string", "{", "}", "\n", "switch", "typedResource", ":=", "resource", ".", "(", "type", ")", "{", "case", "gocf", ".", "IAMRole", ":", "// NOP", "case", "*", "gocf", ".", "DynamoDBTable", ":", "if", "typedResource", ".", "StreamSpecification", "!=", "nil", "{", "outputProps", "=", "append", "(", "outputProps", ",", "\"", "\"", ")", "\n", "}", "\n", "case", "gocf", ".", "DynamoDBTable", ":", "if", "typedResource", ".", "StreamSpecification", "!=", "nil", "{", "outputProps", "=", "append", "(", "outputProps", ",", "\"", "\"", ")", "\n", "}", "\n", "case", "gocf", ".", "KinesisStream", ",", "*", "gocf", ".", "KinesisStream", ":", "outputProps", "=", "append", "(", "outputProps", ",", "\"", "\"", ")", "\n", "case", "gocf", ".", "Route53RecordSet", ",", "*", "gocf", ".", "Route53RecordSet", ":", "// NOP", "case", "gocf", ".", "S3Bucket", ",", "*", "gocf", ".", "S3Bucket", ":", "outputProps", "=", "append", "(", "outputProps", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "case", "gocf", ".", "SNSTopic", ",", "*", "gocf", ".", "SNSTopic", ":", "outputProps", "=", "append", "(", "outputProps", ",", "\"", "\"", ")", "\n", "case", "gocf", ".", "SQSQueue", ",", "*", "gocf", ".", "SQSQueue", ":", "outputProps", "=", "append", "(", "outputProps", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "default", ":", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typedResource", ")", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "outputProps", ",", "nil", "\n", "}" ]

[ "resourceOutputs", "is", "responsible", "for", "returning", "the", "conditional", "set", "of", "CloudFormation", "outputs", "for", "a", "given", "resource", "type", "." ]

[ "func", "(", "command", "HelloWorldResource", ")", "Create", "(", "awsSession", "*", "session", ".", "Session", ",", "event", "*", "CloudFormationLambdaEvent", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "requestPropsErr", ":=", "json", ".", "Unmarshal", "(", "event", ".", "ResourceProperties", ",", "&", "command", ")", "\n", "if", "requestPropsErr", "!=", "nil", "{", "return", "nil", ",", "requestPropsErr", "\n", "}", "\n", "logger", ".", "Info", "(", "\"", "\"", ",", "command", ".", "Message", ".", "Literal", ")", "\n", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", "+", "command", ".", "Message", ".", "Literal", ",", "}", ",", "nil", "\n", "}" ]

[ "Create", "implements", "resource", "create" ]

[ "func", "NewS3Site", "(", "resources", "string", ")", "(", "*", "S3Site", ",", "error", ")", "{", "// We'll ensure its valid during the build step, since", "// there could be a go:generate command in the source that", "// actually builds it.", "site", ":=", "&", "S3Site", "{", "resources", ":", "resources", ",", "UserManifestData", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "}", ",", "}", "\n", "return", "site", ",", "nil", "\n", "}" ]

[ "NewS3Site", "returns", "a", "new", "S3Site", "pointer", "initialized", "with", "the", "static", "resources", "at", "the", "supplied", "path", ".", "If", "resources", "is", "a", "directory", "the", "contents", "will", "be", "recursively", "archived", "and", "used", "to", "populate", "the", "new", "S3", "bucket", "." ]

[ "func", "(", "lad", "*", "LogAggregatorDecorator", ")", "DecorateService", "(", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "serviceName", "string", ",", "template", "*", "gocf", ".", "Template", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "buildID", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "noop", "bool", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "// Create the Kinesis Stream", "template", ".", "AddResource", "(", "lad", ".", "kinesisStreamResourceName", ",", "lad", ".", "kinesisResource", ")", "\n\n", "// Create the IAM role", "putRecordPriv", ":=", "spartaIAMBuilder", ".", "Allow", "(", "\"", "\"", ")", ".", "ForResource", "(", ")", ".", "Attr", "(", "lad", ".", "kinesisStreamResourceName", ",", "\"", "\"", ")", ".", "ToPolicyStatement", "(", ")", "\n", "passRolePriv", ":=", "spartaIAMBuilder", ".", "Allow", "(", "\"", "\"", ")", ".", "ForResource", "(", ")", ".", "Literal", "(", "\"", "\"", ")", ".", "AccountID", "(", "\"", "\"", ")", ".", "Literal", "(", "\"", "\"", ")", ".", "Literal", "(", "lad", ".", "iamRoleNameResourceName", ")", ".", "ToPolicyStatement", "(", ")", "\n\n", "statements", ":=", "make", "(", "[", "]", "spartaIAM", ".", "PolicyStatement", ",", "0", ")", "\n", "statements", "=", "append", "(", "statements", ",", "putRecordPriv", ",", "passRolePriv", ",", ")", "\n", "iamPolicyList", ":=", "gocf", ".", "IAMRolePolicyList", "{", "}", "\n", "iamPolicyList", "=", "append", "(", "iamPolicyList", ",", "gocf", ".", "IAMRolePolicy", "{", "PolicyDocument", ":", "sparta", ".", "ArbitraryJSONObject", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "statements", ",", "}", ",", "PolicyName", ":", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "}", ",", ")", "\n", "iamLogAggregatorRole", ":=", "&", "gocf", ".", "IAMRole", "{", "RoleName", ":", "gocf", ".", "String", "(", "lad", ".", "iamRoleNameResourceName", ")", ",", "AssumeRolePolicyDocument", ":", "LogAggregatorAssumePolicyDocument", ",", "Policies", ":", "&", "iamPolicyList", ",", "}", "\n", "template", ".", "AddResource", "(", "lad", ".", "iamRoleNameResourceName", ",", "iamLogAggregatorRole", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "DecorateService", "annotates", "the", "service", "with", "the", "Kinesis", "hook" ]

[ "func", "(", "lad", "*", "LogAggregatorDecorator", ")", "DecorateTemplate", "(", "serviceName", "string", ",", "lambdaResourceName", "string", ",", "lambdaResource", "gocf", ".", "LambdaFunction", ",", "resourceMetadata", "map", "[", "string", "]", "interface", "{", "}", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "buildID", "string", ",", "template", "*", "gocf", ".", "Template", ",", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "// The relay function should consume the stream", "if", "lad", ".", "logRelay", ".", "LogicalResourceName", "(", ")", "==", "lambdaResourceName", "{", "// Need to add a Lambda EventSourceMapping", "eventSourceMappingResourceName", ":=", "sparta", ".", "CloudFormationResourceName", "(", "\"", "\"", ",", "\"", "\"", ",", "lambdaResourceName", ")", "\n\n", "template", ".", "AddResource", "(", "eventSourceMappingResourceName", ",", "&", "gocf", ".", "LambdaEventSourceMapping", "{", "StartingPosition", ":", "gocf", ".", "String", "(", "lad", ".", "kinesisMapping", ".", "StartingPosition", ")", ",", "BatchSize", ":", "gocf", ".", "Integer", "(", "lad", ".", "kinesisMapping", ".", "BatchSize", ")", ",", "EventSourceArn", ":", "gocf", ".", "GetAtt", "(", "lad", ".", "kinesisStreamResourceName", ",", "\"", "\"", ")", ",", "FunctionName", ":", "gocf", ".", "GetAtt", "(", "lambdaResourceName", ",", "\"", "\"", ")", ",", "}", ")", "\n", "}", "else", "{", "// The other functions should publish their logs to the stream", "subscriptionName", ":=", "logAggregatorResName", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "lambdaResourceName", ")", ")", "\n", "subscriptionFilterRes", ":=", "&", "gocf", ".", "LogsSubscriptionFilter", "{", "DestinationArn", ":", "gocf", ".", "GetAtt", "(", "lad", ".", "kinesisStreamResourceName", ",", "\"", "\"", ")", ",", "RoleArn", ":", "gocf", ".", "GetAtt", "(", "lad", ".", "iamRoleNameResourceName", ",", "\"", "\"", ")", ",", "LogGroupName", ":", "gocf", ".", "Join", "(", "\"", "\"", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "Ref", "(", "lambdaResourceName", ")", ")", ",", "FilterPattern", ":", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "}", "\n", "template", ".", "AddResource", "(", "subscriptionName", ",", "subscriptionFilterRes", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DecorateTemplate", "annotates", "the", "lambda", "with", "the", "log", "forwarding", "sink", "info" ]

[ "func", "NewLogAggregatorDecorator", "(", "kinesisResource", "*", "gocf", ".", "KinesisStream", ",", "kinesisMapping", "*", "sparta", ".", "EventSourceMapping", ",", "relay", "*", "sparta", ".", "LambdaAWSInfo", ")", "*", "LogAggregatorDecorator", "{", "return", "&", "LogAggregatorDecorator", "{", "kinesisStreamResourceName", ":", "logAggregatorResName", "(", "\"", "\"", ")", ",", "kinesisResource", ":", "kinesisResource", ",", "kinesisMapping", ":", "kinesisMapping", ",", "iamRoleNameResourceName", ":", "logAggregatorResName", "(", "\"", "\"", ")", ",", "logRelay", ":", "relay", ",", "}", "\n", "}" ]

[ "NewLogAggregatorDecorator", "returns", "a", "ServiceDecoratorHook", "that", "registers", "a", "Kinesis", "stream", "lambda", "log", "aggregator" ]

[ "func", "(", "mh", "*", "MethodHandler", ")", "StatusCodes", "(", "codes", "...", "int", ")", "*", "MethodHandler", "{", "if", "mh", ".", "statusCodes", "==", "nil", "{", "mh", ".", "statusCodes", "=", "make", "(", "[", "]", "int", ",", "0", ")", "\n", "}", "\n", "mh", ".", "statusCodes", "=", "append", "(", "mh", ".", "statusCodes", ",", "codes", "...", ")", "\n", "return", "mh", "\n", "}" ]

[ "StatusCodes", "is", "a", "fluent", "builder", "to", "append", "additional", "HTTP", "status", "codes", "for", "the", "given", "MethodHandler", ".", "It", "s", "primarily", "used", "to", "disamgiguate", "input", "from", "the", "NewMethodHandler", "constructor" ]

[ "func", "(", "mh", "*", "MethodHandler", ")", "Options", "(", "options", "*", "sparta", ".", "LambdaFunctionOptions", ")", "*", "MethodHandler", "{", "mh", ".", "options", "=", "options", "\n", "return", "mh", "\n", "}" ]

[ "Options", "is", "a", "fluent", "builder", "that", "allows", "customizing", "the", "lambda", "execution", "options", "for", "the", "given", "function" ]

[ "func", "(", "mh", "*", "MethodHandler", ")", "Privileges", "(", "privileges", "...", "sparta", ".", "IAMRolePrivilege", ")", "*", "MethodHandler", "{", "if", "mh", ".", "privileges", "==", "nil", "{", "mh", ".", "privileges", "=", "make", "(", "[", "]", "sparta", ".", "IAMRolePrivilege", ",", "0", ")", "\n", "}", "\n", "mh", ".", "privileges", "=", "append", "(", "mh", ".", "privileges", ",", "privileges", "...", ")", "\n", "return", "mh", "\n", "}" ]

[ "Privileges", "is", "the", "fluent", "builder", "to", "associated", "IAM", "privileges", "with", "this", "HTTP", "handler" ]

[ "func", "(", "mh", "*", "MethodHandler", ")", "Headers", "(", "headerNames", "...", "string", ")", "*", "MethodHandler", "{", "if", "mh", ".", "headers", "==", "nil", "{", "mh", ".", "headers", "=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "}", "\n", "mh", ".", "headers", "=", "append", "(", "mh", ".", "headers", ",", "headerNames", "...", ")", "\n", "return", "mh", "\n", "}" ]

[ "Headers", "is", "the", "fluent", "builder", "that", "defines", "what", "headers", "this", "method", "returns" ]

[ "func", "NewMethodHandler", "(", "handler", "interface", "{", "}", ",", "defaultCode", "int", ")", "*", "MethodHandler", "{", "return", "&", "MethodHandler", "{", "DefaultCode", ":", "defaultCode", ",", "Handler", ":", "handler", ",", "}", "\n", "}" ]

[ "NewMethodHandler", "is", "a", "constructor", "function", "to", "return", "a", "new", "MethodHandler", "pointer", "instance", "." ]

[ "func", "BuildDockerImageWithFlags", "(", "serviceName", "string", ",", "dockerFilepath", "string", ",", "dockerTags", "map", "[", "string", "]", "string", ",", "buildTags", "string", ",", "linkFlags", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "// BEGIN DOCKER PRECONDITIONS", "// Ensure that serviceName and tags are lowercase to make Docker happy", "var", "dockerErrors", "[", "]", "string", "\n", "for", "eachKey", ",", "eachValue", ":=", "range", "dockerTags", "{", "if", "eachKey", "!=", "strings", ".", "ToLower", "(", "eachKey", ")", "||", "eachValue", "!=", "strings", ".", "ToLower", "(", "eachValue", ")", "{", "dockerErrors", "=", "append", "(", "dockerErrors", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "eachKey", ",", "eachValue", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "dockerErrors", ")", ">", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "dockerErrors", "[", ":", "]", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "// BEGIN Informational - output the docker version...", "dockerVersionCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "dockerVersionCmdErr", ":=", "system", ".", "RunOSCommand", "(", "dockerVersionCmd", ",", "logger", ")", "\n", "if", "dockerVersionCmdErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "dockerVersionCmdErr", ",", "\"", "\"", ")", "\n", "}", "\n", "// END Informational - output the docker version...", "// END DOCKER PRECONDITIONS", "// Compile this binary for minimal Docker size", "// https://blog.codeship.com/building-minimal-docker-containers-for-go-applications/", "currentTime", ":=", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "\n", "executableOutput", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "serviceName", ",", "currentTime", ")", "\n", "buildErr", ":=", "system", ".", "BuildGoBinary", "(", "serviceName", ",", "executableOutput", ",", "false", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "currentTime", ")", ",", "buildTags", ",", "linkFlags", ",", "false", ",", "logger", ")", "\n", "if", "buildErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "buildErr", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "removeErr", ":=", "os", ".", "Remove", "(", "executableOutput", ")", "\n", "if", "removeErr", "!=", "nil", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "executableOutput", ",", "\"", "\"", ":", "removeErr", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// ARG SPARTA_DOCKER_BINARY reference s.t. we can supply the binary", "// name to the build..", "// We need to build the static binary s.t. we can add it to the Docker container...", "// Build the image...", "dockerArgs", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "BinaryNameArgument", ",", "executableOutput", ")", ",", "}", "\n\n", "if", "dockerFilepath", "!=", "\"", "\"", "{", "dockerArgs", "=", "append", "(", "dockerArgs", ",", "\"", "\"", ",", "dockerFilepath", ")", "\n", "}", "\n", "// Add the latest tag", "// dockerArgs = append(dockerArgs, \"--tag\", fmt.Sprintf(\"sparta/%s:latest\", serviceName))", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "dockerTags", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "for", "eachKey", ",", "eachValue", ":=", "range", "dockerTags", "{", "dockerArgs", "=", "append", "(", "dockerArgs", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "ToLower", "(", "eachKey", ")", ",", "strings", ".", "ToLower", "(", "eachValue", ")", ")", ")", "\n", "}", "\n\n", "dockerArgs", "=", "append", "(", "dockerArgs", ",", "\"", "\"", ")", "\n", "dockerCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "dockerArgs", "...", ")", "\n", "return", "system", ".", "RunOSCommand", "(", "dockerCmd", ",", "logger", ")", "\n", "}" ]

[ "BuildDockerImageWithFlags", "is", "an", "extended", "version", "of", "BuildDockerImage", "that", "includes", "support", "for", "build", "time", "tags" ]

[ "func", "BuildDockerImage", "(", "serviceName", "string", ",", "dockerFilepath", "string", ",", "tags", "map", "[", "string", "]", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "return", "BuildDockerImageWithFlags", "(", "serviceName", ",", "dockerFilepath", ",", "tags", ",", "\"", "\"", ",", "\"", "\"", ",", "logger", ")", "\n", "}" ]

[ "BuildDockerImage", "creates", "the", "smallest", "docker", "image", "for", "this", "Golang", "binary", "using", "the", "serviceName", "as", "the", "image", "name", "and", "including", "the", "supplied", "tags" ]

[ "func", "PushDockerImageToECR", "(", "localImageTag", "string", ",", "ecrRepoName", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "stsSvc", ":=", "sts", ".", "New", "(", "awsSession", ")", "\n", "ecrSvc", ":=", "ecr", ".", "New", "(", "awsSession", ")", "\n\n", "// 1. Get the caller identity s.t. we can get the ECR URL which includes the", "// account name", "stsIdentityOutput", ",", "stsIdentityErr", ":=", "stsSvc", ".", "GetCallerIdentity", "(", "&", "sts", ".", "GetCallerIdentityInput", "{", "}", ")", "\n", "if", "stsIdentityErr", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "stsIdentityErr", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// 2. Create the URL to which we're going to do the push", "localImageTagParts", ":=", "strings", ".", "Split", "(", "localImageTag", ",", "\"", "\"", ")", "\n", "ecrTagValue", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "stsIdentityOutput", ".", "Account", ",", "*", "awsSession", ".", "Config", ".", "Region", ",", "ecrRepoName", ",", "localImageTagParts", "[", "len", "(", "localImageTagParts", ")", "-", "1", "]", ")", "\n\n", "// 3. Tag the local image with the ECR tag", "dockerTagCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "localImageTag", ",", "ecrTagValue", ")", "\n", "dockerTagCmdErr", ":=", "system", ".", "RunOSCommand", "(", "dockerTagCmd", ",", "logger", ")", "\n", "if", "dockerTagCmdErr", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "dockerTagCmdErr", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// 4. Push the image - if that fails attempt to reauthorize with the docker", "// client and try again", "var", "pushError", "error", "\n", "dockerPushCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "ecrTagValue", ")", "\n", "pushError", "=", "system", ".", "RunOSCommand", "(", "dockerPushCmd", ",", "logger", ")", "\n", "if", "pushError", "!=", "nil", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "pushError", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "ecrAuthTokenResult", ",", "ecrAuthTokenResultErr", ":=", "ecrSvc", ".", "GetAuthorizationToken", "(", "&", "ecr", ".", "GetAuthorizationTokenInput", "{", "}", ")", "\n", "if", "ecrAuthTokenResultErr", "!=", "nil", "{", "pushError", "=", "ecrAuthTokenResultErr", "\n", "}", "else", "{", "authData", ":=", "ecrAuthTokenResult", ".", "AuthorizationData", "[", "0", "]", "\n", "authToken", ",", "authTokenErr", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "*", "authData", ".", "AuthorizationToken", ")", "\n", "if", "authTokenErr", "!=", "nil", "{", "pushError", "=", "authTokenErr", "\n", "}", "else", "{", "authTokenString", ":=", "string", "(", "authToken", ")", "\n", "authTokenParts", ":=", "strings", ".", "Split", "(", "authTokenString", ",", "\"", "\"", ")", "\n", "dockerURL", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "stsIdentityOutput", ".", "Account", ",", "*", "awsSession", ".", "Config", ".", "Region", ")", "\n", "dockerLoginCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "authTokenParts", "[", "0", "]", ",", "\"", "\"", ",", "dockerURL", ")", "\n", "dockerLoginCmd", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "dockerLoginCmd", ".", "Stdin", "=", "bytes", ".", "NewReader", "(", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "authTokenParts", "[", "1", "]", ")", ")", ")", "\n", "dockerLoginCmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n", "dockerLoginCmdErr", ":=", "system", ".", "RunOSCommand", "(", "dockerLoginCmd", ",", "logger", ")", "\n", "if", "dockerLoginCmdErr", "!=", "nil", "{", "pushError", "=", "dockerLoginCmdErr", "\n", "}", "else", "{", "// Try it again...", "dockerRetryPushCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "ecrTagValue", ")", "\n", "dockerRetryPushCmdErr", ":=", "system", ".", "RunOSCommand", "(", "dockerRetryPushCmd", ",", "logger", ")", "\n", "pushError", "=", "dockerRetryPushCmdErr", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "pushError", "!=", "nil", "{", "pushError", "=", "errors", ".", "Wrapf", "(", "pushError", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "ecrTagValue", ",", "pushError", "\n", "}" ]

[ "PushDockerImageToECR", "pushes", "a", "local", "Docker", "image", "to", "an", "ECR", "repository" ]

[ "func", "(", "reactorFunc", "SNSReactorFunc", ")", "OnSNSEvent", "(", "ctx", "context", ".", "Context", ",", "snsEvent", "awsLambdaEvents", ".", "SNSEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactorFunc", "(", "ctx", ",", "snsEvent", ")", "\n", "}" ]

[ "OnSNSEvent", "satisfies", "the", "SNSReactor", "interface" ]

[ "func", "NewSNSReactor", "(", "reactor", "SNSReactor", ",", "snsTopic", "gocf", ".", "Stringable", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "reactorLambda", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "snsEvent", "awsLambdaEvents", ".", "SNSEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactor", ".", "OnSNSEvent", "(", "ctx", ",", "snsEvent", ")", "\n", "}", "\n\n", "lambdaFn", ",", "lambdaFnErr", ":=", "sparta", ".", "NewAWSLambda", "(", "reactorName", "(", "reactor", ")", ",", "reactorLambda", ",", "sparta", ".", "IAMRoleDefinition", "{", "}", ")", "\n", "if", "lambdaFnErr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "lambdaFnErr", ",", "\"", "\"", ")", "\n", "}", "\n\n", "lambdaFn", ".", "Permissions", "=", "append", "(", "lambdaFn", ".", "Permissions", ",", "sparta", ".", "SNSPermission", "{", "BasePermission", ":", "sparta", ".", "BasePermission", "{", "SourceArn", ":", "snsTopic", ",", "}", ",", "}", ")", "\n", "if", "len", "(", "additionalLambdaPermissions", ")", "!=", "0", "{", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "=", "additionalLambdaPermissions", "\n", "}", "\n", "return", "lambdaFn", ",", "nil", "\n", "}" ]

[ "NewSNSReactor", "returns", "an", "SNS", "reactor", "lambda", "function" ]

[ "func", "GoVersion", "(", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "runtimeVersion", ":=", "runtime", ".", "Version", "(", ")", "\n", "// Get the golang version from the output:", "// Matts-MBP:Sparta mweagle$ go version", "// go version go1.8.1 darwin/amd64", "golangVersionRE", ":=", "regexp", ".", "MustCompile", "(", "`go(\\d+\\.\\d+(\\.\\d+)?)`", ")", "\n", "matches", ":=", "golangVersionRE", ".", "FindStringSubmatch", "(", "runtimeVersion", ")", "\n", "if", "len", "(", "matches", ")", ">", "2", "{", "return", "matches", "[", "1", "]", ",", "nil", "\n", "}", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "runtimeVersion", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "runtimeVersion", ",", "nil", "\n", "}" ]

[ "GoVersion", "returns", "the", "configured", "go", "version", "for", "this", "system" ]

[ "func", "TemporaryFile", "(", "scratchDir", "string", ",", "name", "string", ")", "(", "*", "os", ".", "File", ",", "error", ")", "{", "workingDir", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "nil", "!=", "err", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Use a stable temporary name", "temporaryPath", ":=", "filepath", ".", "Join", "(", "workingDir", ",", "scratchDir", ",", "name", ")", "\n", "buildDir", ":=", "filepath", ".", "Dir", "(", "temporaryPath", ")", "\n", "mkdirErr", ":=", "os", ".", "MkdirAll", "(", "buildDir", ",", "os", ".", "ModePerm", ")", "\n", "if", "nil", "!=", "mkdirErr", "{", "return", "nil", ",", "mkdirErr", "\n", "}", "\n\n", "tmpFile", ",", "err", ":=", "os", ".", "Create", "(", "temporaryPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "tmpFile", ",", "nil", "\n", "}" ]

[ "TemporaryFile", "creates", "a", "stable", "temporary", "filename", "in", "the", "current", "working", "directory" ]

[ "func", "(", "command", "S3LambdaEventSourceResource", ")", "Update", "(", "awsSession", "*", "session", ".", "Session", ",", "event", "*", "CloudFormationLambdaEvent", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "return", "command", ".", "updateNotification", "(", "true", ",", "awsSession", ",", "event", ",", "logger", ")", "\n", "}" ]

[ "Update", "implements", "the", "custom", "resource", "update", "operation" ]

[ "func", "TailWithContext", "(", "reqContext", "aws", ".", "Context", ",", "closeChan", "chan", "bool", ",", "awsSession", "*", "session", ".", "Session", ",", "logGroupName", "string", ",", "filter", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "<-", "chan", "*", "cloudwatchlogs", ".", "FilteredLogEvent", "{", "// Milliseconds...", "lastSeenTimestamp", ":=", "time", ".", "Now", "(", ")", ".", "Add", "(", "0", ")", ".", "Unix", "(", ")", "*", "1000", "\n", "logger", ".", "WithField", "(", "\"", "\"", ",", "lastSeenTimestamp", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "outputChannel", ":=", "make", "(", "chan", "*", "cloudwatchlogs", ".", "FilteredLogEvent", ")", "\n", "tailHandler", ":=", "func", "(", "res", "*", "cloudwatchlogs", ".", "FilterLogEventsOutput", ",", "lastPage", "bool", ")", "bool", "{", "maxTime", ":=", "int64", "(", "0", ")", "\n", "for", "_", ",", "eachEvent", ":=", "range", "res", ".", "Events", "{", "if", "maxTime", "<", "*", "eachEvent", ".", "Timestamp", "{", "maxTime", "=", "*", "eachEvent", ".", "Timestamp", "\n", "}", "\n", "logger", ".", "WithField", "(", "\"", "\"", ",", "*", "eachEvent", ".", "EventId", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "outputChannel", "<-", "eachEvent", "\n", "}", "\n", "if", "maxTime", "!=", "0", "{", "lastSeenTimestamp", "=", "maxTime", "+", "1", "\n", "}", "\n", "return", "!", "lastPage", "\n", "}", "\n\n", "cwlogsSvc", ":=", "cloudwatchlogs", ".", "New", "(", "awsSession", ")", "\n", "tickerChan", ":=", "time", ".", "NewTicker", "(", "time", ".", "Millisecond", "*", "333", ")", ".", "C", "//AWS cloudwatch logs limit is 5tx/sec", "\n", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "<-", "closeChan", ":", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "case", "<-", "tickerChan", ":", "logParam", ":=", "tailParams", "(", "logGroupName", ",", "filter", ",", "lastSeenTimestamp", ")", "\n", "error", ":=", "cwlogsSvc", ".", "FilterLogEventsPagesWithContext", "(", "reqContext", ",", "logParam", ",", "tailHandler", ")", "\n", "if", "error", "!=", "nil", "{", "// Just pump the thing back through the channel...", "errorEvent", ":=", "&", "cloudwatchlogs", ".", "FilteredLogEvent", "{", "EventId", ":", "aws", ".", "String", "(", "\"", "\"", ")", ",", "Message", ":", "aws", ".", "String", "(", "error", ".", "Error", "(", ")", ")", ",", "Timestamp", ":", "aws", ".", "Int64", "(", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "*", "1000", ")", ",", "}", "\n", "outputChannel", "<-", "errorEvent", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "outputChannel", "\n", "}" ]

[ "TailWithContext", "is", "a", "utility", "function", "that", "support", "tailing", "the", "given", "log", "stream", "name", "using", "the", "optional", "filter", ".", "It", "returns", "a", "channel", "for", "log", "messages" ]

[ "func", "DocsInstallRequirements", "(", ")", "error", "{", "mg", ".", "SerialDeps", "(", "ensureWorkDir", ")", "\n\n", "// Is hugo already installed?", "spartamage", ".", "Log", "(", "\"", "\"", ",", "hugoVersion", ")", "\n\n", "hugoOutput", ",", "hugoOutputErr", ":=", "sh", ".", "Output", "(", "hugoPath", ",", "\"", "\"", ")", "\n", "if", "hugoOutputErr", "==", "nil", "&&", "strings", ".", "Contains", "(", "hugoOutput", ",", "hugoVersion", ")", "{", "spartamage", ".", "Log", "(", "\"", "\"", ",", "hugoVersion", ",", "hugoPath", ")", "\n", "return", "nil", "\n", "}", "\n\n", "hugoArchiveName", ":=", "\"", "\"", "\n", "switch", "runtime", ".", "GOOS", "{", "case", "\"", "\"", ":", "hugoArchiveName", "=", "\"", "\"", "\n", "case", "\"", "\"", ":", "hugoArchiveName", "=", "\"", "\"", "\n", "default", ":", "hugoArchiveName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "runtime", ".", "GOOS", ")", "\n", "}", "\n\n", "hugoURL", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hugoVersion", ",", "hugoVersion", ",", "hugoArchiveName", ")", "\n\n", "spartamage", ".", "Log", "(", "\"", "\"", ",", "hugoURL", ")", "\n", "outputArchive", ":=", "filepath", ".", "Join", "(", "localWorkDir", ",", "\"", "\"", ")", "\n", "outputFile", ",", "outputErr", ":=", "os", ".", "Create", "(", "outputArchive", ")", "\n", "if", "outputErr", "!=", "nil", "{", "return", "outputErr", "\n", "}", "\n\n", "hugoResp", ",", "hugoRespErr", ":=", "http", ".", "Get", "(", "hugoURL", ")", "\n", "if", "hugoRespErr", "!=", "nil", "{", "return", "hugoRespErr", "\n", "}", "\n", "defer", "hugoResp", ".", "Body", ".", "Close", "(", ")", "\n\n", "_", ",", "copyBytesErr", ":=", "io", ".", "Copy", "(", "outputFile", ",", "hugoResp", ".", "Body", ")", "\n", "if", "copyBytesErr", "!=", "nil", "{", "return", "copyBytesErr", "\n", "}", "\n", "// Great, go heads and untar it...", "unarchiver", ":=", "archiver", ".", "NewTarGz", "(", ")", "\n", "unarchiver", ".", "OverwriteExisting", "=", "true", "\n", "untarErr", ":=", "unarchiver", ".", "Unarchive", "(", "outputArchive", ",", "localWorkDir", ")", "\n", "if", "untarErr", "!=", "nil", "{", "return", "untarErr", "\n", "}", "\n", "versionScript", ":=", "[", "]", "[", "]", "string", "{", "{", "hugoPath", ",", "\"", "\"", "}", ",", "}", "\n", "return", "spartamage", ".", "Script", "(", "versionScript", ")", "\n", "}" ]

[ "DocsInstallRequirements", "installs", "the", "required", "Hugo", "version" ]

[ "func", "DocsCommit", "(", ")", "error", "{", "mg", ".", "SerialDeps", "(", "DocsBuild", ")", "\n\n", "commitNoMessageScript", ":=", "make", "(", "[", "]", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "eachPath", ":=", "range", "hugoDocsPaths", "{", "commitNoMessageScript", "=", "append", "(", "commitNoMessageScript", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "eachPath", "}", ",", ")", "\n", "}", "\n", "commitNoMessageScript", "=", "append", "(", "commitNoMessageScript", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "`\"Documentation updates\"`", "}", ",", ")", "\n", "return", "spartamage", ".", "Script", "(", "commitNoMessageScript", ")", "\n", "}" ]

[ "DocsCommit", "builds", "and", "commits", "the", "current", "documentation", "with", "an", "autogenerated", "comment" ]

[ "func", "InstallBuildRequirements", "(", ")", "error", "{", "spartamage", ".", "Log", "(", "\"", "\"", ",", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n\n", "requirements", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "for", "_", ",", "eachDep", ":=", "range", "requirements", "{", "cmdErr", ":=", "sh", ".", "Run", "(", "\"", "\"", ",", "\"", "\"", ",", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "eachDep", ")", "\n", "if", "cmdErr", "!=", "nil", "{", "return", "cmdErr", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "InstallBuildRequirements", "installs", "or", "updates", "the", "dependent", "packages", "that", "aren", "t", "referenced", "by", "the", "source", "but", "are", "needed", "to", "build", "the", "Sparta", "source" ]

[ "func", "EnsureSpelling", "(", ")", "error", "{", "goSpelling", ":=", "func", "(", ")", "error", "{", "return", "goSourceApply", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "mg", ".", "SerialDeps", "(", "goSpelling", ",", "EnsureMarkdownSpelling", ")", "\n", "return", "nil", "\n", "}" ]

[ "EnsureSpelling", "ensures", "that", "there", "are", "no", "misspellings", "in", "the", "source" ]

[ "func", "EnsureFormatted", "(", ")", "error", "{", "cmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "cmd", ".", "Stdout", "=", "&", "stdout", "\n", "cmd", ".", "Stderr", "=", "&", "stderr", "\n", "err", ":=", "cmd", ".", "Run", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "stdout", ".", "String", "(", ")", "!=", "\"", "\"", "{", "if", "mg", ".", "Verbose", "(", ")", "{", "log", ".", "Print", "(", "stdout", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "EnsureFormatted", "ensures", "that", "the", "source", "code", "is", "formatted", "with", "goimports" ]

[ "func", "EnsureStaticChecks", "(", ")", "error", "{", "// https://staticcheck.io/", "staticCheckErr", ":=", "sh", ".", "Run", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "staticCheckErr", "!=", "nil", "{", "return", "staticCheckErr", "\n", "}", "\n", "// https://github.com/securego/gosec", "if", "mg", ".", "Verbose", "(", ")", "{", "return", "sh", ".", "Run", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "sh", ".", "Run", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "EnsureStaticChecks", "ensures", "that", "the", "source", "code", "passes", "static", "code", "checks" ]

[ "func", "EnsureTravisBuildEnvironment", "(", ")", "error", "{", "mg", ".", "SerialDeps", "(", "InstallBuildRequirements", ")", "\n\n", "// Super run some commands", "travisComands", ":=", "[", "]", "[", "]", "string", "{", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ",", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ",", "}", "\n", "return", "spartamage", ".", "Script", "(", "travisComands", ")", "\n", "}" ]

[ "EnsureTravisBuildEnvironment", "is", "the", "command", "that", "sets", "up", "the", "Travis", "environment", "to", "run", "the", "build", "." ]

[ "func", "Publish", "(", ")", "error", "{", "mg", ".", "SerialDeps", "(", "DocsBuild", ",", "DocsCommit", ",", "GenerateBuildInfo", ")", "\n\n", "describeCommands", ":=", "[", "]", "[", "]", "string", "{", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ",", "}", "\n", "return", "spartamage", ".", "Script", "(", "describeCommands", ")", "\n", "}" ]

[ "Publish", "the", "latest", "source" ]

[ "func", "CompareAgainstMasterBranch", "(", ")", "error", "{", "// Get the current branch, open a browser", "// to the change...", "// The first thing we need is the `git` branch", "cmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "cmd", ".", "Stdout", "=", "&", "stdout", "\n", "cmd", ".", "Stderr", "=", "&", "stderr", "\n", "err", ":=", "cmd", ".", "Run", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "stdOutResult", ":=", "strings", ".", "TrimSpace", "(", "string", "(", "stdout", ".", "Bytes", "(", ")", ")", ")", "\n", "githubURL", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "stdOutResult", ")", "\n", "return", "browser", ".", "OpenURL", "(", "githubURL", ")", "\n", "}" ]

[ "CompareAgainstMasterBranch", "is", "a", "convenience", "function", "to", "show", "the", "comparisons", "of", "the", "current", "pushed", "branch", "against", "the", "master", "branch" ]

[ "func", "awsLambdaInternalName", "(", "internalFunctionName", "string", ")", "string", "{", "var", "internalNameParts", "[", "]", "string", "\n\n", "// If this is something that implements something else, trim the", "// leading *", "internalFunctionName", "=", "strings", ".", "TrimPrefix", "(", "internalFunctionName", ",", "\"", "\"", ")", "\n", "customTypeParts", ":=", "reSplitCustomType", ".", "Split", "(", "internalFunctionName", ",", "-", "1", ")", "\n", "if", "len", "(", "customTypeParts", ")", ">", "1", "{", "internalNameParts", "=", "[", "]", "string", "{", "customTypeParts", "[", "len", "(", "customTypeParts", ")", "-", "1", "]", "}", "\n", "}", "else", "{", "internalNameParts", "=", "reSplitFunctionName", ".", "Split", "(", "internalFunctionName", ",", "-", "1", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "internalNameParts", ",", "functionNameDelimiter", ")", "\n", "}" ]

[ "awsLambdaFunctionName", "returns", "the", "name", "of", "the", "function", "which", "is", "set", "in", "the", "CloudFormation", "template", "that", "is", "published", "into", "the", "container", "as", "AWS_LAMBDA_FUNCTION_NAME", ".", "Rather", "than", "publish", "custom", "vars", "which", "are", "editable", "in", "the", "Console", "tunneling", "this", "value", "through", "allows", "Sparta", "to", "leverage", "the", "built", "in", "env", "vars", "." ]

[ "func", "Delete", "(", "serviceName", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "logger", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Delete", "is", "not", "available", "in", "the", "AWS", "Lambda", "binary" ]

[ "func", "Provision", "(", "noop", "bool", ",", "serviceName", "string", ",", "serviceDescription", "string", ",", "lambdaAWSInfos", "[", "]", "*", "LambdaAWSInfo", ",", "api", "*", "API", ",", "site", "*", "S3Site", ",", "s3Bucket", "string", ",", "useCGO", "bool", ",", "inplace", "bool", ",", "buildID", "string", ",", "codePipelineTrigger", "string", ",", "buildTags", "string", ",", "linkerFlags", "string", ",", "writer", "io", ".", "Writer", ",", "workflowHooks", "*", "WorkflowHooks", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "logger", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Provision", "is", "not", "available", "in", "the", "AWS", "Lambda", "binary" ]

[ "func", "Describe", "(", "serviceName", "string", ",", "serviceDescription", "string", ",", "lambdaAWSInfos", "[", "]", "*", "LambdaAWSInfo", ",", "api", "*", "API", ",", "site", "*", "S3Site", ",", "s3BucketName", "string", ",", "buildTags", "string", ",", "linkerFlags", "string", ",", "outputWriter", "io", ".", "Writer", ",", "workflowHooks", "*", "WorkflowHooks", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "logger", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Describe", "is", "not", "available", "in", "the", "AWS", "Lambda", "binary" ]

[ "func", "Explore", "(", "serviceName", "string", ",", "serviceDescription", "string", ",", "lambdaAWSInfos", "[", "]", "*", "LambdaAWSInfo", ",", "api", "*", "API", ",", "site", "*", "S3Site", ",", "s3BucketName", "string", ",", "buildTags", "string", ",", "linkerFlags", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Explore", "is", "an", "interactive", "command", "that", "brings", "up", "a", "GUI", "to", "test", "lambda", "functions", "previously", "deployed", "into", "AWS", "lambda", ".", "It", "s", "not", "supported", "in", "the", "AWS", "binary", "build" ]

[ "func", "Status", "(", "serviceName", "string", ",", "serviceDescription", "string", ",", "redact", "bool", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Status", "is", "the", "command", "that", "produces", "a", "simple", "status", "report", "for", "a", "given", "stack" ]

[ "func", "methodResponses", "(", "api", "*", "API", ",", "userResponses", "map", "[", "int", "]", "*", "Response", ",", "corsEnabled", "bool", ")", "*", "gocf", ".", "APIGatewayMethodMethodResponseList", "{", "var", "responses", "gocf", ".", "APIGatewayMethodMethodResponseList", "\n", "for", "eachHTTPStatusCode", ",", "eachResponse", ":=", "range", "userResponses", "{", "methodResponseParams", ":=", "eachResponse", ".", "Parameters", "\n", "if", "corsEnabled", "{", "for", "eachString", ",", "eachBool", ":=", "range", "corsMethodResponseParams", "(", "api", ")", "{", "methodResponseParams", "[", "eachString", "]", "=", "eachBool", "\n", "}", "\n", "}", "\n", "// Then transform them all to strings because internet", "methodResponseStringParams", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "methodResponseParams", ")", ")", "\n", "for", "eachKey", ",", "eachBool", ":=", "range", "methodResponseParams", "{", "methodResponseStringParams", "[", "eachKey", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "eachBool", ")", "\n", "}", "\n", "methodResponse", ":=", "gocf", ".", "APIGatewayMethodMethodResponse", "{", "StatusCode", ":", "gocf", ".", "String", "(", "strconv", ".", "Itoa", "(", "eachHTTPStatusCode", ")", ")", ",", "}", "\n", "if", "len", "(", "methodResponseStringParams", ")", "!=", "0", "{", "methodResponse", ".", "ResponseParameters", "=", "methodResponseStringParams", "\n", "}", "\n", "responses", "=", "append", "(", "responses", ",", "methodResponse", ")", "\n", "}", "\n", "return", "&", "responses", "\n", "}" ]

[ "DefaultMethodResponses", "returns", "the", "default", "set", "of", "Method", "HTTPStatus", "-", ">", "Response", "pass", "through", "responses", ".", "The", "successfulHTTPStatusCode", "param", "is", "the", "single", "2XX", "response", "code", "to", "use", "for", "the", "method", "." ]

[ "func", "(", "api", "*", "API", ")", "RestAPIURL", "(", ")", "*", "gocf", ".", "StringExpr", "{", "return", "gocf", ".", "Join", "(", "\"", "\"", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "Ref", "(", "api", ".", "LogicalResourceName", "(", ")", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "Ref", "(", "\"", "\"", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ")", "\n", "}" ]

[ "RestAPIURL", "returns", "the", "dynamically", "assigned", "Rest", "API", "URL", "including", "the", "scheme" ]

[ "func", "NewAPIGateway", "(", "name", "string", ",", "stage", "*", "Stage", ")", "*", "API", "{", "return", "&", "API", "{", "name", ":", "name", ",", "stage", ":", "stage", ",", "resources", ":", "make", "(", "map", "[", "string", "]", "*", "Resource", ")", ",", "CORSEnabled", ":", "false", ",", "CORSOptions", ":", "nil", ",", "}", "\n", "}" ]

[ "NewAPIGateway", "returns", "a", "new", "API", "Gateway", "structure", ".", "If", "stage", "is", "defined", "the", "API", "Gateway", "will", "also", "be", "deployed", "as", "part", "of", "stack", "creation", "." ]

[ "func", "(", "resource", "*", "Resource", ")", "NewAuthorizedMethod", "(", "httpMethod", "string", ",", "authorizerID", "gocf", ".", "Stringable", ",", "defaultHTTPStatusCode", "int", ",", "possibleHTTPStatusCodeResponses", "...", "int", ")", "(", "*", "Method", ",", "error", ")", "{", "if", "authorizerID", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "method", ",", "methodErr", ":=", "resource", ".", "NewMethod", "(", "httpMethod", ",", "defaultHTTPStatusCode", ",", "possibleHTTPStatusCodeResponses", "...", ")", "\n", "if", "methodErr", "==", "nil", "{", "method", ".", "authorizationID", "=", "authorizerID", "\n", "}", "\n", "return", "method", ",", "methodErr", "\n", "}" ]

[ "NewAuthorizedMethod", "associates", "the", "httpMethod", "name", "and", "authorizationID", "with", "the", "given", "Resource", ".", "The", "authorizerID", "param", "is", "a", "cloudformation", ".", "Strinable", "satisfying", "value" ]

[ "func", "NewSQSTaskState", "(", "stateName", "string", ",", "parameters", "SQSTaskParameters", ")", "*", "SQSTaskState", "{", "sns", ":=", "&", "SQSTaskState", "{", "BaseTask", ":", "BaseTask", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "}", ",", "parameters", ":", "parameters", ",", "}", "\n", "return", "sns", "\n", "}" ]

[ "NewSQSTaskState", "returns", "an", "initialized", "SQSTaskState" ]

[ "func", "CloudFormationLambdaCustomResourceHandler", "(", "command", "CustomResourceCommand", ",", "logger", "*", "logrus", ".", "Logger", ")", "interface", "{", "}", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "event", "CloudFormationLambdaEvent", ")", "error", "{", "lambdaCtx", ",", "lambdaCtxOk", ":=", "awsLambdaCtx", ".", "FromContext", "(", "ctx", ")", "\n", "if", "!", "lambdaCtxOk", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "customResourceSession", ":=", "awsSession", "(", "logger", ")", "\n", "var", "opResults", "map", "[", "string", "]", "interface", "{", "}", "\n", "var", "opErr", "error", "\n", "executeOperation", ":=", "false", "\n", "// If we're in cleanup mode, then skip it...", "// Don't forward to the CustomAction handler iff we're in CLEANUP mode", "describeStacksInput", ":=", "&", "cloudformation", ".", "DescribeStacksInput", "{", "StackName", ":", "aws", ".", "String", "(", "event", ".", "StackID", ")", ",", "}", "\n", "cfSvc", ":=", "cloudformation", ".", "New", "(", "customResourceSession", ")", "\n", "describeStacksOutput", ",", "describeStacksOutputErr", ":=", "cfSvc", ".", "DescribeStacks", "(", "describeStacksInput", ")", "\n", "if", "nil", "!=", "describeStacksOutputErr", "{", "opErr", "=", "describeStacksOutputErr", "\n", "}", "else", "{", "stackDesc", ":=", "describeStacksOutput", ".", "Stacks", "[", "0", "]", "\n", "if", "stackDesc", "==", "nil", "{", "opErr", "=", "errors", ".", "Errorf", "(", "\"", "\"", ",", "event", ".", "StackID", ")", "\n", "}", "else", "{", "executeOperation", "=", "(", "*", "stackDesc", ".", "StackStatus", "!=", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "event", ".", "LogicalResourceID", ",", "\"", "\"", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "describeStacksOutput", ")", ",", "\"", "\"", ":", "event", ".", "RequestType", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "if", "opErr", "==", "nil", "&&", "executeOperation", "{", "switch", "event", ".", "RequestType", "{", "case", "CreateOperation", ":", "opResults", ",", "opErr", "=", "command", ".", "Create", "(", "customResourceSession", ",", "&", "event", ",", "logger", ")", "\n", "case", "DeleteOperation", ":", "opResults", ",", "opErr", "=", "command", ".", "Delete", "(", "customResourceSession", ",", "&", "event", ",", "logger", ")", "\n", "case", "UpdateOperation", ":", "opResults", ",", "opErr", "=", "command", ".", "Update", "(", "customResourceSession", ",", "&", "event", ",", "logger", ")", "\n", "}", "\n", "}", "\n", "// Notify CloudFormation of the result", "if", "event", ".", "ResponseURL", "!=", "\"", "\"", "{", "sendErr", ":=", "SendCloudFormationResponse", "(", "lambdaCtx", ",", "&", "event", ",", "opResults", ",", "opErr", ",", "logger", ")", "\n", "if", "nil", "!=", "sendErr", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "sendErr", ".", "Error", "(", ")", ",", "\"", "\"", ":", "event", ".", "ResponseURL", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "else", "{", "// If the cloudformation notification was complete, then this", "// execution functioned properly and we can clear the Error", "opErr", "=", "nil", "\n", "}", "\n", "}", "\n", "return", "opErr", "\n", "}", "\n", "}" ]

[ "CloudFormationLambdaCustomResourceHandler", "is", "an", "adapter", "function", "that", "transforms", "an", "implementing", "CustomResourceCommand", "into", "something", "that", "that", "can", "respond", "to", "the", "lambda", "custom", "resource", "lifecycle" ]

[ "func", "NewCustomResourceLambdaHandler", "(", "resourceType", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "interface", "{", "}", "{", "// TODO - eliminate this factory stuff and just register", "// the custom resources as normal lambda handlers...", "var", "lambdaCmd", "CustomResourceCommand", "\n", "cfResource", ":=", "customTypeProvider", "(", "resourceType", ")", "\n", "if", "cfResource", "!=", "nil", "{", "cmd", ",", "cmdOK", ":=", "cfResource", ".", "(", "CustomResourceCommand", ")", "\n", "if", "cmdOK", "{", "lambdaCmd", "=", "cmd", "\n", "}", "\n", "}", "\n", "if", "lambdaCmd", "==", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "resourceType", ")", "\n", "}", "\n", "return", "CloudFormationLambdaCustomResourceHandler", "(", "lambdaCmd", ",", "logger", ")", "\n", "}" ]

[ "NewCustomResourceLambdaHandler", "returns", "a", "handler", "for", "the", "given", "type" ]

[ "func", "NewFargateTaskState", "(", "stateName", "string", ",", "parameters", "FargateTaskParameters", ")", "*", "FargateTaskState", "{", "ft", ":=", "&", "FargateTaskState", "{", "BaseTask", ":", "BaseTask", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "}", ",", "parameters", ":", "parameters", ",", "}", "\n", "return", "ft", "\n", "}" ]

[ "NewFargateTaskState", "returns", "an", "initialized", "FargateTaskState" ]

[ "func", "RegisterXRayInterceptor", "(", "handler", "*", "sparta", ".", "LambdaEventInterceptors", ",", "mode", "XRayInterceptorMode", ")", "*", "sparta", ".", "LambdaEventInterceptors", "{", "interceptor", ":=", "&", "xrayInterceptor", "{", "mode", ":", "mode", ",", "}", "\n", "if", "handler", "==", "nil", "{", "handler", "=", "&", "sparta", ".", "LambdaEventInterceptors", "{", "}", "\n", "}", "\n", "return", "handler", ".", "Register", "(", "interceptor", ")", "\n", "}" ]

[ "RegisterXRayInterceptor", "handles", "pushing", "the", "tracing", "information", "into", "XRay" ]

[ "func", "recordDuration", "(", "start", "time", ".", "Time", ",", "name", "string", ",", "ctx", "*", "workflowContext", ")", "{", "elapsed", ":=", "time", ".", "Since", "(", "start", ")", "\n", "ctx", ".", "transaction", ".", "stepDurations", "=", "append", "(", "ctx", ".", "transaction", ".", "stepDurations", ",", "&", "workflowStepDuration", "{", "name", ":", "name", ",", "duration", ":", "elapsed", ",", "}", ")", "\n", "}" ]

[ "recordDuration", "is", "a", "utility", "function", "to", "record", "how", "long" ]

[ "func", "(", "ctx", "*", "workflowContext", ")", "registerFileCleanupFinalizer", "(", "localPath", "string", ")", "{", "cleanup", ":=", "func", "(", "logger", "*", "logrus", ".", "Logger", ")", "{", "errRemove", ":=", "os", ".", "Remove", "(", "localPath", ")", "\n", "if", "nil", "!=", "errRemove", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "localPath", ",", "\"", "\"", ":", "errRemove", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "else", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "relativePath", "(", "localPath", ")", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "ctx", ".", "registerFinalizer", "(", "cleanup", ")", "\n", "}" ]

[ "Register", "a", "finalizer", "that", "cleans", "up", "local", "artifacts" ]

[ "func", "(", "ctx", "*", "workflowContext", ")", "rollback", "(", ")", "{", "defer", "recordDuration", "(", "time", ".", "Now", "(", ")", ",", "\"", "\"", ",", "ctx", ")", "\n\n", "// Run each cleanup function concurrently. If there's an error", "// all we're going to do is log it as a warning, since at this", "// point there's nothing to do...", "ctx", ".", "logger", ".", "Info", "(", "\"", "\"", ")", "\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "wg", ".", "Add", "(", "len", "(", "ctx", ".", "transaction", ".", "rollbackFunctions", ")", ")", "\n", "rollbackErr", ":=", "callRollbackHook", "(", "ctx", ",", "&", "wg", ")", "\n", "if", "rollbackErr", "!=", "nil", "{", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "rollbackErr", ",", "}", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "eachCleanup", ":=", "range", "ctx", ".", "transaction", ".", "rollbackFunctions", "{", "go", "func", "(", "cleanupFunc", "spartaS3", ".", "RollbackFunction", ",", "goLogger", "*", "logrus", ".", "Logger", ")", "{", "// Decrement the counter when the goroutine completes.", "defer", "wg", ".", "Done", "(", ")", "\n", "// Fetch the URL.", "err", ":=", "cleanupFunc", "(", "goLogger", ")", "\n", "if", "nil", "!=", "err", "{", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "err", ",", "}", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "(", "eachCleanup", ",", "ctx", ".", "logger", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n", "}" ]

[ "Run", "any", "provided", "rollback", "functions" ]

[ "func", "callRollbackHook", "(", "ctx", "*", "workflowContext", ",", "wg", "*", "sync", ".", "WaitGroup", ")", "error", "{", "if", "ctx", ".", "userdata", ".", "workflowHooks", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "rollbackHooks", ":=", "ctx", ".", "userdata", ".", "workflowHooks", ".", "Rollbacks", "\n", "if", "ctx", ".", "userdata", ".", "workflowHooks", ".", "Rollback", "!=", "nil", "{", "ctx", ".", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "rollbackHooks", "=", "append", "(", "rollbackHooks", ",", "RollbackHookFunc", "(", "ctx", ".", "userdata", ".", "workflowHooks", ".", "Rollback", ")", ")", "\n", "}", "\n", "for", "_", ",", "eachRollbackHook", ":=", "range", "rollbackHooks", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "handler", "RollbackHookHandler", ",", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "serviceName", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "noop", "bool", ",", "logger", "*", "logrus", ".", "Logger", ")", "{", "// Decrement the counter when the goroutine completes.", "defer", "wg", ".", "Done", "(", ")", "\n", "rollbackErr", ":=", "handler", ".", "Rollback", "(", "context", ",", "serviceName", ",", "awsSession", ",", "noop", ",", "logger", ")", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "rollbackErr", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "(", "eachRollbackHook", ",", "ctx", ".", "context", ".", "workflowHooksContext", ",", "ctx", ".", "userdata", ".", "serviceName", ",", "ctx", ".", "context", ".", "awsSession", ",", "ctx", ".", "userdata", ".", "noop", ",", "ctx", ".", "logger", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Encapsulate", "calling", "the", "rollback", "hooks" ]

[ "func", "callServiceDecoratorHook", "(", "ctx", "*", "workflowContext", ")", "error", "{", "if", "ctx", ".", "userdata", ".", "workflowHooks", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "serviceHooks", ":=", "ctx", ".", "userdata", ".", "workflowHooks", ".", "ServiceDecorators", "\n", "if", "ctx", ".", "userdata", ".", "workflowHooks", ".", "ServiceDecorator", "!=", "nil", "{", "ctx", ".", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "serviceHooks", "=", "append", "(", "serviceHooks", ",", "ServiceDecoratorHookFunc", "(", "ctx", ".", "userdata", ".", "workflowHooks", ".", "ServiceDecorator", ")", ")", "\n", "}", "\n", "// If there's an API gateway definition, include the resources that provision it.", "// Since this export will likely", "// generate outputs that the s3 site needs, we'll use a temporary outputs accumulator,", "// pass that to the S3Site", "// if it's defined, and then merge it with the normal output map.-", "for", "_", ",", "eachServiceHook", ":=", "range", "serviceHooks", "{", "hookName", ":=", "runtime", ".", "FuncForPC", "(", "reflect", ".", "ValueOf", "(", "eachServiceHook", ")", ".", "Pointer", "(", ")", ")", ".", "Name", "(", ")", "\n", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "hookName", ",", "\"", "\"", ":", "ctx", ".", "context", ".", "workflowHooksContext", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "serviceTemplate", ":=", "gocf", ".", "NewTemplate", "(", ")", "\n", "decoratorError", ":=", "eachServiceHook", ".", "DecorateService", "(", "ctx", ".", "context", ".", "workflowHooksContext", ",", "ctx", ".", "userdata", ".", "serviceName", ",", "serviceTemplate", ",", "ctx", ".", "userdata", ".", "s3Bucket", ",", "codeZipKey", "(", "ctx", ".", "context", ".", "s3CodeZipURL", ")", ",", "ctx", ".", "userdata", ".", "buildID", ",", "ctx", ".", "context", ".", "awsSession", ",", "ctx", ".", "userdata", ".", "noop", ",", "ctx", ".", "logger", ")", "\n", "if", "nil", "!=", "decoratorError", "{", "return", "decoratorError", "\n", "}", "\n", "safeMergeErrs", ":=", "gocc", ".", "SafeMerge", "(", "serviceTemplate", ",", "ctx", ".", "context", ".", "cfTemplate", ")", "\n", "if", "len", "(", "safeMergeErrs", ")", "!=", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "safeMergeErrs", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Encapsulate", "calling", "the", "service", "decorator", "hooks" ]

[ "func", "callArchiveHook", "(", "lambdaArchive", "*", "zip", ".", "Writer", ",", "ctx", "*", "workflowContext", ")", "error", "{", "if", "ctx", ".", "userdata", ".", "workflowHooks", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "archiveHooks", ":=", "ctx", ".", "userdata", ".", "workflowHooks", ".", "Archives", "\n", "if", "ctx", ".", "userdata", ".", "workflowHooks", ".", "Archive", "!=", "nil", "{", "ctx", ".", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "archiveHooks", "=", "append", "(", "archiveHooks", ",", "ArchiveHookFunc", "(", "ctx", ".", "userdata", ".", "workflowHooks", ".", "Archive", ")", ")", "\n", "}", "\n", "for", "_", ",", "eachArchiveHook", ":=", "range", "archiveHooks", "{", "// Run the hook", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "context", ".", "workflowHooksContext", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "hookErr", ":=", "eachArchiveHook", ".", "DecorateArchive", "(", "ctx", ".", "context", ".", "workflowHooksContext", ",", "ctx", ".", "userdata", ".", "serviceName", ",", "lambdaArchive", ",", "ctx", ".", "context", ".", "awsSession", ",", "ctx", ".", "userdata", ".", "noop", ",", "ctx", ".", "logger", ")", "\n", "if", "hookErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "hookErr", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Encapsulate", "calling", "the", "archive", "hooks" ]

[ "func", "callWorkflowHook", "(", "hookPhase", "string", ",", "hook", "WorkflowHook", ",", "hooks", "[", "]", "WorkflowHookHandler", ",", "ctx", "*", "workflowContext", ")", "error", "{", "if", "hook", "!=", "nil", "{", "ctx", ".", "logger", ".", "Warn", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hookPhase", ",", "hookPhase", ")", ")", "\n", "hooks", "=", "append", "(", "hooks", ",", "WorkflowHookFunc", "(", "hook", ")", ")", "\n", "}", "\n", "for", "_", ",", "eachHook", ":=", "range", "hooks", "{", "// Run the hook", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "hookPhase", ",", "\"", "\"", ":", "ctx", ".", "context", ".", "workflowHooksContext", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "hookErr", ":=", "eachHook", ".", "DecorateWorkflow", "(", "ctx", ".", "context", ".", "workflowHooksContext", ",", "ctx", ".", "userdata", ".", "serviceName", ",", "ctx", ".", "userdata", ".", "s3Bucket", ",", "ctx", ".", "userdata", ".", "buildID", ",", "ctx", ".", "context", ".", "awsSession", ",", "ctx", ".", "userdata", ".", "noop", ",", "ctx", ".", "logger", ")", "\n", "if", "hookErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "hookErr", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Encapsulate", "calling", "a", "workflow", "hook" ]

[ "func", "callValidationHooks", "(", "validationHooks", "[", "]", "ServiceValidationHookHandler", ",", "template", "*", "gocf", ".", "Template", ",", "ctx", "*", "workflowContext", ")", "error", "{", "var", "marshaledTemplate", "[", "]", "byte", "\n", "if", "len", "(", "validationHooks", ")", "!=", "0", "{", "jsonBytes", ",", "jsonBytesErr", ":=", "json", ".", "Marshal", "(", "template", ")", "\n", "if", "jsonBytesErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "jsonBytesErr", ",", "\"", "\"", ")", "\n", "}", "\n", "marshaledTemplate", "=", "jsonBytes", "\n", "}", "\n\n", "for", "_", ",", "eachHook", ":=", "range", "validationHooks", "{", "// Run the hook", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "ctx", ".", "context", ".", "workflowHooksContext", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "var", "loopTemplate", "gocf", ".", "Template", "\n", "unmarshalErr", ":=", "json", ".", "Unmarshal", "(", "marshaledTemplate", ",", "&", "loopTemplate", ")", "\n", "if", "unmarshalErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "unmarshalErr", ",", "\"", "\"", ")", "\n", "}", "\n\n", "hookErr", ":=", "eachHook", ".", "ValidateService", "(", "ctx", ".", "context", ".", "workflowHooksContext", ",", "ctx", ".", "userdata", ".", "serviceName", ",", "&", "loopTemplate", ",", "ctx", ".", "userdata", ".", "s3Bucket", ",", "codeZipKey", "(", "ctx", ".", "context", ".", "s3CodeZipURL", ")", ",", "ctx", ".", "userdata", ".", "buildID", ",", "ctx", ".", "context", ".", "awsSession", ",", "ctx", ".", "userdata", ".", "noop", ",", "ctx", ".", "logger", ")", "\n", "if", "hookErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "hookErr", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Encapsulate", "calling", "the", "validation", "hooks" ]

[ "func", "versionAwareS3KeyName", "(", "s3DefaultKey", "string", ",", "s3VersioningEnabled", "bool", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "versionKeyName", ":=", "s3DefaultKey", "\n", "if", "!", "s3VersioningEnabled", "{", "var", "extension", "=", "path", ".", "Ext", "(", "s3DefaultKey", ")", "\n", "var", "prefixString", "=", "strings", ".", "TrimSuffix", "(", "s3DefaultKey", ",", "extension", ")", "\n\n", "hash", ":=", "sha1", ".", "New", "(", ")", "\n", "salt", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s3DefaultKey", ",", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", "\n", "_", ",", "writeErr", ":=", "hash", ".", "Write", "(", "[", "]", "byte", "(", "salt", ")", ")", "\n", "if", "writeErr", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "writeErr", ",", "\"", "\"", ")", "\n", "}", "\n", "versionKeyName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "prefixString", ",", "hex", ".", "EncodeToString", "(", "hash", ".", "Sum", "(", "nil", ")", ")", ",", "extension", ")", "\n\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "s3DefaultKey", ",", "\"", "\"", ":", "extension", ",", "\"", "\"", ":", "prefixString", ",", "\"", "\"", ":", "versionKeyName", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "versionKeyName", ",", "nil", "\n", "}" ]

[ "versionAwareS3KeyName", "returns", "a", "keyname", "that", "provides", "the", "correct", "cache", "invalidation", "semantics", "based", "on", "whether", "the", "target", "bucket", "has", "versioning", "enabled" ]

[ "func", "uploadLocalFileToS3", "(", "localPath", "string", ",", "s3ObjectKey", "string", ",", "ctx", "*", "workflowContext", ")", "(", "string", ",", "error", ")", "{", "// If versioning is enabled, use a stable name, otherwise use a name", "// that's dynamically created. By default assume that the bucket is", "// enabled for versioning", "if", "s3ObjectKey", "==", "\"", "\"", "{", "defaultS3KeyName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ctx", ".", "userdata", ".", "serviceName", ",", "filepath", ".", "Base", "(", "localPath", ")", ")", "\n", "s3KeyName", ",", "s3KeyNameErr", ":=", "versionAwareS3KeyName", "(", "defaultS3KeyName", ",", "ctx", ".", "context", ".", "s3BucketVersioningEnabled", ",", "ctx", ".", "logger", ")", "\n", "if", "nil", "!=", "s3KeyNameErr", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "s3KeyNameErr", ",", "\"", "\"", ")", "\n", "}", "\n", "s3ObjectKey", "=", "s3KeyName", "\n", "}", "\n\n", "s3URL", ":=", "\"", "\"", "\n", "if", "ctx", ".", "userdata", ".", "noop", "{", "// Binary size", "filesize", ":=", "int64", "(", "0", ")", "\n", "stat", ",", "statErr", ":=", "os", ".", "Stat", "(", "localPath", ")", "\n", "if", "statErr", "==", "nil", "{", "filesize", "=", "stat", ".", "Size", "(", ")", "\n", "}", "\n", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "userdata", ".", "s3Bucket", ",", "\"", "\"", ":", "s3ObjectKey", ",", "\"", "\"", ":", "filepath", ".", "Base", "(", "localPath", ")", ",", "\"", "\"", ":", "humanize", ".", "Bytes", "(", "uint64", "(", "filesize", ")", ")", ",", "}", ")", ".", "Info", "(", "noopMessage", "(", "\"", "\"", ")", ")", "\n", "s3URL", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ctx", ".", "userdata", ".", "s3Bucket", ",", "s3ObjectKey", ")", "\n", "}", "else", "{", "// Make sure we mark things for cleanup in case there's a problem", "ctx", ".", "registerFileCleanupFinalizer", "(", "localPath", ")", "\n", "// Then upload it", "uploadLocation", ",", "uploadURLErr", ":=", "spartaS3", ".", "UploadLocalFileToS3", "(", "localPath", ",", "ctx", ".", "context", ".", "awsSession", ",", "ctx", ".", "userdata", ".", "s3Bucket", ",", "s3ObjectKey", ",", "ctx", ".", "logger", ")", "\n", "if", "nil", "!=", "uploadURLErr", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "uploadURLErr", ",", "\"", "\"", ")", "\n", "}", "\n", "s3URL", "=", "uploadLocation", "\n", "ctx", ".", "registerRollback", "(", "spartaS3", ".", "CreateS3RollbackFunc", "(", "ctx", ".", "context", ".", "awsSession", ",", "uploadLocation", ")", ")", "\n", "}", "\n", "return", "s3URL", ",", "nil", "\n", "}" ]

[ "Upload", "a", "local", "file", "to", "S3", ".", "Returns", "the", "full", "S3", "URL", "to", "the", "file", "that", "was", "uploaded", ".", "If", "the", "target", "bucket", "does", "not", "have", "versioning", "enabled", "this", "function", "will", "automatically", "make", "a", "new", "key", "to", "ensure", "uniqueness" ]

[ "func", "createPackageStep", "(", ")", "workflowStep", "{", "return", "func", "(", "ctx", "*", "workflowContext", ")", "(", "workflowStep", ",", "error", ")", "{", "defer", "recordDuration", "(", "time", ".", "Now", "(", ")", ",", "\"", "\"", ",", "ctx", ")", "\n\n", "// PreBuild Hook", "if", "ctx", ".", "userdata", ".", "workflowHooks", "!=", "nil", "{", "preBuildErr", ":=", "callWorkflowHook", "(", "\"", "\"", ",", "ctx", ".", "userdata", ".", "workflowHooks", ".", "PreBuild", ",", "ctx", ".", "userdata", ".", "workflowHooks", ".", "PreBuilds", ",", "ctx", ")", "\n", "if", "nil", "!=", "preBuildErr", "{", "return", "nil", ",", "preBuildErr", "\n", "}", "\n", "}", "\n", "sanitizedServiceName", ":=", "sanitizedName", "(", "ctx", ".", "userdata", ".", "serviceName", ")", "\n", "buildErr", ":=", "system", ".", "BuildGoBinary", "(", "ctx", ".", "userdata", ".", "serviceName", ",", "ctx", ".", "context", ".", "binaryName", ",", "ctx", ".", "userdata", ".", "useCGO", ",", "ctx", ".", "userdata", ".", "buildID", ",", "ctx", ".", "userdata", ".", "buildTags", ",", "ctx", ".", "userdata", ".", "linkFlags", ",", "ctx", ".", "userdata", ".", "noop", ",", "ctx", ".", "logger", ")", "\n", "if", "nil", "!=", "buildErr", "{", "return", "nil", ",", "buildErr", "\n", "}", "\n", "// Cleanup the temporary binary", "defer", "func", "(", ")", "{", "errRemove", ":=", "os", ".", "Remove", "(", "ctx", ".", "context", ".", "binaryName", ")", "\n", "if", "nil", "!=", "errRemove", "{", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "context", ".", "binaryName", ",", "\"", "\"", ":", "errRemove", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// PostBuild Hook", "if", "ctx", ".", "userdata", ".", "workflowHooks", "!=", "nil", "{", "postBuildErr", ":=", "callWorkflowHook", "(", "\"", "\"", ",", "ctx", ".", "userdata", ".", "workflowHooks", ".", "PostBuild", ",", "ctx", ".", "userdata", ".", "workflowHooks", ".", "PostBuilds", ",", "ctx", ")", "\n", "if", "nil", "!=", "postBuildErr", "{", "return", "nil", ",", "postBuildErr", "\n", "}", "\n", "}", "\n", "tmpFile", ",", "err", ":=", "system", ".", "TemporaryFile", "(", "ScratchDirectory", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sanitizedServiceName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Strip the local directory in case it's in there...", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "relativePath", "(", "tmpFile", ".", "Name", "(", ")", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "lambdaArchive", ":=", "zip", ".", "NewWriter", "(", "tmpFile", ")", "\n\n", "// Archive Hook", "archiveErr", ":=", "callArchiveHook", "(", "lambdaArchive", ",", "ctx", ")", "\n", "if", "nil", "!=", "archiveErr", "{", "return", "nil", ",", "archiveErr", "\n", "}", "\n", "// Issue: https://github.com/mweagle/Sparta/issues/103. If the executable", "// bit isn't set, then AWS Lambda won't be able to fork the binary", "var", "fileHeaderAnnotator", "spartaZip", ".", "FileHeaderAnnotator", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "fileHeaderAnnotator", "=", "func", "(", "header", "*", "zip", ".", "FileHeader", ")", "(", "*", "zip", ".", "FileHeader", ",", "error", ")", "{", "// Make the binary executable", "// Ref: https://github.com/aws/aws-lambda-go/blob/master/cmd/build-lambda-zip/main.go#L51", "header", ".", "CreatorVersion", "=", "3", "<<", "8", "\n", "header", ".", "ExternalAttrs", "=", "0777", "<<", "16", "\n", "return", "header", ",", "nil", "\n", "}", "\n", "}", "\n", "// File info for the binary executable", "readerErr", ":=", "spartaZip", ".", "AnnotateAddToZip", "(", "lambdaArchive", ",", "ctx", ".", "context", ".", "binaryName", ",", "\"", "\"", ",", "fileHeaderAnnotator", ",", "ctx", ".", "logger", ")", "\n", "if", "nil", "!=", "readerErr", "{", "return", "nil", ",", "readerErr", "\n", "}", "\n", "archiveCloseErr", ":=", "lambdaArchive", ".", "Close", "(", ")", "\n", "if", "nil", "!=", "archiveCloseErr", "{", "return", "nil", ",", "archiveCloseErr", "\n", "}", "\n", "tempfileCloseErr", ":=", "tmpFile", ".", "Close", "(", ")", "\n", "if", "nil", "!=", "tempfileCloseErr", "{", "return", "nil", ",", "tempfileCloseErr", "\n", "}", "\n", "return", "createUploadStep", "(", "tmpFile", ".", "Name", "(", ")", ")", ",", "nil", "\n", "}", "\n", "}" ]

[ "Build", "and", "package", "the", "application" ]

[ "func", "maximumStackOperationTimeout", "(", "template", "*", "gocf", ".", "Template", ",", "logger", "*", "logrus", ".", "Logger", ")", "time", ".", "Duration", "{", "stackOperationTimeout", ":=", "20", "*", "time", ".", "Minute", "\n", "// If there is a CloudFront distributon in there then", "// let's give that a bit more time to settle down...In general", "// the initial CloudFront distribution takes ~30 minutes", "for", "_", ",", "eachResource", ":=", "range", "template", ".", "Resources", "{", "if", "eachResource", ".", "Properties", ".", "CfnResourceType", "(", ")", "==", "\"", "\"", "{", "stackOperationTimeout", "=", "60", "*", "time", ".", "Minute", "\n", "break", "\n", "}", "\n", "}", "\n", "logger", ".", "WithField", "(", "\"", "\"", ",", "stackOperationTimeout", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "stackOperationTimeout", "\n", "}" ]

[ "maximumStackOperationTimeout", "returns", "the", "timeout", "value", "to", "use", "for", "a", "stack", "operation", "based", "on", "the", "type", "of", "resources", "that", "it", "provisions", ".", "In", "general", "the", "timeout", "is", "short", "with", "an", "exception", "made", "for", "CloudFront", "distributions" ]

[ "func", "createCodePipelineTriggerPackage", "(", "cfTemplateJSON", "[", "]", "byte", ",", "ctx", "*", "workflowContext", ")", "(", "string", ",", "error", ")", "{", "tmpFile", ",", "err", ":=", "system", ".", "TemporaryFile", "(", "ScratchDirectory", ",", "ctx", ".", "userdata", ".", "codePipelineTrigger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "tmpFile", ".", "Name", "(", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "templateArchive", ":=", "zip", ".", "NewWriter", "(", "tmpFile", ")", "\n", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "tmpFile", ".", "Name", "(", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "// File info for the binary executable", "zipEntryName", ":=", "\"", "\"", "\n", "bytesWriter", ",", "bytesWriterErr", ":=", "templateArchive", ".", "Create", "(", "zipEntryName", ")", "\n", "if", "bytesWriterErr", "!=", "nil", "{", "return", "\"", "\"", ",", "bytesWriterErr", "\n", "}", "\n\n", "bytesReader", ":=", "bytes", ".", "NewReader", "(", "cfTemplateJSON", ")", "\n", "written", ",", "writtenErr", ":=", "io", ".", "Copy", "(", "bytesWriter", ",", "bytesReader", ")", "\n", "if", "nil", "!=", "writtenErr", "{", "return", "\"", "\"", ",", "writtenErr", "\n", "}", "\n", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "written", ",", "\"", "\"", ":", "zipEntryName", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// If there is a codePipelineEnvironments defined, then we'll need to get all the", "// maps, marshal them to JSON, then add the JSON to the ZIP archive.", "if", "nil", "!=", "codePipelineEnvironments", "{", "for", "eachEnvironment", ",", "eachMap", ":=", "range", "codePipelineEnvironments", "{", "codePipelineParameters", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "eachMap", ",", "}", "\n", "environmentJSON", ",", "environmentJSONErr", ":=", "json", ".", "Marshal", "(", "codePipelineParameters", ")", "\n", "if", "nil", "!=", "environmentJSONErr", "{", "ctx", ".", "logger", ".", "Error", "(", "\"", "\"", "+", "eachEnvironment", ")", "\n", "return", "\"", "\"", ",", "environmentJSONErr", "\n", "}", "\n", "var", "envVarName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "eachEnvironment", ")", "\n\n", "// File info for the binary executable", "binaryWriter", ",", "binaryWriterErr", ":=", "templateArchive", ".", "Create", "(", "envVarName", ")", "\n", "if", "binaryWriterErr", "!=", "nil", "{", "return", "\"", "\"", ",", "binaryWriterErr", "\n", "}", "\n", "_", ",", "writeErr", ":=", "binaryWriter", ".", "Write", "(", "environmentJSON", ")", "\n", "if", "writeErr", "!=", "nil", "{", "return", "\"", "\"", ",", "writeErr", "\n", "}", "\n", "}", "\n", "}", "\n", "archiveCloseErr", ":=", "templateArchive", ".", "Close", "(", ")", "\n", "if", "nil", "!=", "archiveCloseErr", "{", "return", "\"", "\"", ",", "archiveCloseErr", "\n", "}", "\n", "tempfileCloseErr", ":=", "tmpFile", ".", "Close", "(", ")", "\n", "if", "nil", "!=", "tempfileCloseErr", "{", "return", "\"", "\"", ",", "tempfileCloseErr", "\n", "}", "\n", "// Leave it here...", "ctx", ".", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "filepath", ".", "Base", "(", "tmpFile", ".", "Name", "(", ")", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "// The key is the name + the pipeline name", "return", "tmpFile", ".", "Name", "(", ")", ",", "nil", "\n", "}" ]

[ "createCodePipelineTriggerPackage", "handles", "marshaling", "the", "template", "zipping", "the", "config", "files", "in", "the", "package", "and", "the" ]

[ "func", "(", "bis", "*", "baseInnerState", ")", "marshalStateJSON", "(", "stateType", "string", ",", "additionalData", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "additionalData", "==", "nil", "{", "additionalData", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n", "additionalData", "[", "\"", "\"", "]", "=", "stateType", "\n", "if", "bis", ".", "next", "!=", "nil", "{", "additionalData", "[", "\"", "\"", "]", "=", "bis", ".", "next", ".", "Name", "(", ")", "\n", "}", "\n", "if", "bis", ".", "comment", "!=", "\"", "\"", "{", "additionalData", "[", "\"", "\"", "]", "=", "bis", ".", "comment", "\n", "}", "\n", "if", "bis", ".", "inputPath", "!=", "\"", "\"", "{", "additionalData", "[", "\"", "\"", "]", "=", "bis", ".", "inputPath", "\n", "}", "\n", "if", "bis", ".", "outputPath", "!=", "\"", "\"", "{", "additionalData", "[", "\"", "\"", "]", "=", "bis", ".", "outputPath", "\n", "}", "\n", "if", "!", "bis", ".", "isEndStateInvalid", "&&", "bis", ".", "next", "==", "nil", "{", "additionalData", "[", "\"", "\"", "]", "=", "true", "\n", "}", "\n", "// Output the pretty version", "return", "json", ".", "Marshal", "(", "additionalData", ")", "\n", "}" ]

[ "marshalStateJSON", "for", "subclass", "marshalling", "of", "state", "information" ]

[ "func", "NewPassState", "(", "name", "string", ",", "resultData", "interface", "{", "}", ")", "*", "PassState", "{", "return", "&", "PassState", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "name", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "Result", ":", "resultData", ",", "}", "\n", "}" ]

[ "NewPassState", "returns", "a", "new", "PassState", "instance" ]

[ "func", "(", "cs", "*", "ChoiceState", ")", "WithDefault", "(", "defaultState", "TransitionState", ")", "*", "ChoiceState", "{", "cs", ".", "Default", "=", "defaultState", "\n", "return", "cs", "\n", "}" ]

[ "WithDefault", "is", "the", "fluent", "builder", "for", "the", "default", "state" ]

[ "func", "NewChoiceState", "(", "choiceStateName", "string", ",", "choices", "...", "ChoiceBranch", ")", "*", "ChoiceState", "{", "return", "&", "ChoiceState", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "choiceStateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "isEndStateInvalid", ":", "true", ",", "}", ",", "Choices", ":", "append", "(", "[", "]", "ChoiceBranch", "{", "}", ",", "choices", "...", ")", ",", "}", "\n", "}" ]

[ "NewChoiceState", "returns", "a", "ChoiceState", "with", "the", "supplied", "information" ]

[ "func", "(", "tr", "*", "TaskRetry", ")", "WithErrors", "(", "errors", "...", "StateError", ")", "*", "TaskRetry", "{", "if", "tr", ".", "ErrorEquals", "==", "nil", "{", "tr", ".", "ErrorEquals", "=", "make", "(", "[", "]", "StateError", ",", "0", ")", "\n", "}", "\n", "tr", ".", "ErrorEquals", "=", "append", "(", "tr", ".", "ErrorEquals", ",", "errors", "...", ")", "\n", "return", "tr", "\n", "}" ]

[ "WithErrors", "is", "the", "fluent", "builder" ]

[ "func", "(", "tr", "*", "TaskRetry", ")", "WithInterval", "(", "interval", "time", ".", "Duration", ")", "*", "TaskRetry", "{", "tr", ".", "IntervalSeconds", "=", "interval", "\n", "return", "tr", "\n", "}" ]

[ "WithInterval", "is", "the", "fluent", "builder" ]

[ "func", "(", "tr", "*", "TaskRetry", ")", "WithMaxAttempts", "(", "maxAttempts", "int", ")", "*", "TaskRetry", "{", "tr", ".", "MaxAttempts", "=", "maxAttempts", "\n", "return", "tr", "\n", "}" ]

[ "WithMaxAttempts", "is", "the", "fluent", "builder" ]

[ "func", "(", "tr", "*", "TaskRetry", ")", "WithBackoffRate", "(", "backoffRate", "float32", ")", "*", "TaskRetry", "{", "tr", ".", "BackoffRate", "=", "backoffRate", "\n", "return", "tr", "\n", "}" ]

[ "WithBackoffRate", "is", "the", "fluent", "builder" ]

[ "func", "(", "tc", "*", "TaskCatch", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "catchJSON", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "tc", ".", "errorEquals", ",", "\"", "\"", ":", "tc", ".", "next", ",", "}", "\n", "return", "json", ".", "Marshal", "(", "catchJSON", ")", "\n", "}" ]

[ "MarshalJSON", "to", "prevent", "inadvertent", "composition" ]

[ "func", "NewTaskCatch", "(", "nextState", "TransitionState", ",", "errors", "...", "StateError", ")", "*", "TaskCatch", "{", "return", "&", "TaskCatch", "{", "errorEquals", ":", "errors", ",", "next", ":", "nextState", ",", "}", "\n", "}" ]

[ "NewTaskCatch", "returns", "a", "new", "TaskCatch", "instance" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "additionalParams", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "additionalParams", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "if", "bt", ".", "TimeoutSeconds", ".", "Seconds", "(", ")", "!=", "0", "{", "additionalParams", "[", "\"", "\"", "]", "=", "bt", ".", "TimeoutSeconds", ".", "Seconds", "(", ")", "\n", "}", "\n", "if", "bt", ".", "HeartbeatSeconds", ".", "Seconds", "(", ")", "!=", "0", "{", "additionalParams", "[", "\"", "\"", "]", "=", "bt", ".", "HeartbeatSeconds", ".", "Seconds", "(", ")", "\n", "}", "\n", "if", "bt", ".", "ResultPath", "!=", "\"", "\"", "{", "additionalParams", "[", "\"", "\"", "]", "=", "bt", ".", "ResultPath", "\n", "}", "\n", "if", "len", "(", "bt", ".", "Retriers", ")", "!=", "0", "{", "additionalParams", "[", "\"", "\"", "]", "=", "make", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "0", ")", "\n", "}", "\n", "if", "bt", ".", "Catchers", "!=", "nil", "{", "catcherMap", ":=", "make", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "bt", ".", "Catchers", ")", ")", "\n", "for", "index", ",", "eachCatcher", ":=", "range", "bt", ".", "Catchers", "{", "catcherMap", "[", "index", "]", "=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "eachCatcher", ".", "errorEquals", ",", "\"", "\"", ":", "eachCatcher", ".", "next", ".", "Name", "(", ")", ",", "}", "\n", "}", "\n", "additionalParams", "[", "\"", "\"", "]", "=", "catcherMap", "\n", "}", "\n", "return", "additionalParams", "\n", "}" ]

[ "attributeMap", "returns", "the", "map", "of", "attributes", "necessary", "for", "JSON", "serialization" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithTimeout", "(", "timeout", "time", ".", "Duration", ")", "*", "BaseTask", "{", "bt", ".", "TimeoutSeconds", "=", "timeout", "\n", "return", "bt", "\n", "}" ]

[ "WithTimeout", "is", "the", "fluent", "builder", "for", "BaseTask" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithHeartbeat", "(", "pulse", "time", ".", "Duration", ")", "*", "BaseTask", "{", "bt", ".", "HeartbeatSeconds", "=", "pulse", "\n", "return", "bt", "\n", "}" ]

[ "WithHeartbeat", "is", "the", "fluent", "builder", "for", "BaseTask" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithRetriers", "(", "retries", "...", "*", "TaskRetry", ")", "*", "BaseTask", "{", "if", "bt", ".", "Retriers", "==", "nil", "{", "bt", ".", "Retriers", "=", "make", "(", "[", "]", "*", "TaskRetry", ",", "0", ")", "\n", "}", "\n", "bt", ".", "Retriers", "=", "append", "(", "bt", ".", "Retriers", ",", "retries", "...", ")", "\n", "return", "bt", "\n", "}" ]

[ "WithRetriers", "is", "the", "fluent", "builder", "for", "BaseTask" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithCatchers", "(", "catch", "...", "*", "TaskCatch", ")", "*", "BaseTask", "{", "if", "bt", ".", "Catchers", "==", "nil", "{", "bt", ".", "Catchers", "=", "make", "(", "[", "]", "*", "TaskCatch", ",", "0", ")", "\n", "}", "\n", "bt", ".", "Catchers", "=", "append", "(", "bt", ".", "Catchers", ",", "catch", "...", ")", "\n", "return", "bt", "\n", "}" ]

[ "WithCatchers", "is", "the", "fluent", "builder", "for", "BaseTask" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithComment", "(", "comment", "string", ")", "TransitionState", "{", "bt", ".", "comment", "=", "comment", "\n", "return", "bt", "\n", "}" ]

[ "WithComment", "returns", "the", "BaseTask", "comment" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithInputPath", "(", "inputPath", "string", ")", "TransitionState", "{", "bt", ".", "inputPath", "=", "inputPath", "\n", "return", "bt", "\n", "}" ]

[ "WithInputPath", "returns", "the", "BaseTask", "input", "data", "selector" ]

[ "func", "(", "bt", "*", "BaseTask", ")", "WithOutputPath", "(", "outputPath", "string", ")", "TransitionState", "{", "bt", ".", "outputPath", "=", "outputPath", "\n", "return", "bt", "\n", "}" ]

[ "WithOutputPath", "returns", "the", "BaseTask", "output", "data", "selector" ]

[ "func", "NewLambdaTaskState", "(", "stateName", "string", ",", "lambdaFn", "*", "sparta", ".", "LambdaAWSInfo", ")", "*", "LambdaTaskState", "{", "ts", ":=", "&", "LambdaTaskState", "{", "BaseTask", ":", "BaseTask", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "}", ",", "lambdaFn", ":", "lambdaFn", ",", "}", "\n", "ts", ".", "LambdaDecorator", "=", "func", "(", "serviceName", "string", ",", "lambdaResourceName", "string", ",", "lambdaResource", "gocf", ".", "LambdaFunction", ",", "resourceMetadata", "map", "[", "string", "]", "interface", "{", "}", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "buildID", "string", ",", "cfTemplate", "*", "gocf", ".", "Template", ",", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "if", "ts", ".", "preexistingDecorator", "!=", "nil", "{", "preexistingLambdaDecoratorErr", ":=", "ts", ".", "preexistingDecorator", "(", "serviceName", ",", "lambdaResourceName", ",", "lambdaResource", ",", "resourceMetadata", ",", "S3Bucket", ",", "S3Key", ",", "buildID", ",", "cfTemplate", ",", "context", ",", "logger", ")", "\n", "if", "preexistingLambdaDecoratorErr", "!=", "nil", "{", "return", "preexistingLambdaDecoratorErr", "\n", "}", "\n", "}", "\n", "// Save the lambda name s.t. we can create the {\"Ref\"::\"lambdaName\"} entry...", "ts", ".", "lambdaLogicalResourceName", "=", "lambdaResourceName", "\n", "return", "nil", "\n", "}", "\n", "// Make sure this Lambda decorator is included in the list of existing decorators", "// If there already is a decorator, then save it...", "ts", ".", "preexistingDecorator", "=", "lambdaFn", ".", "Decorator", "\n", "ts", ".", "lambdaFn", ".", "Decorators", "=", "append", "(", "ts", ".", "lambdaFn", ".", "Decorators", ",", "sparta", ".", "TemplateDecoratorHookFunc", "(", "ts", ".", "LambdaDecorator", ")", ")", "\n", "return", "ts", "\n", "}" ]

[ "NewLambdaTaskState", "returns", "a", "LambdaTaskState", "instance", "properly", "initialized" ]

[ "func", "NewWaitDelayState", "(", "stateName", "string", ",", "delay", "time", ".", "Duration", ")", "*", "WaitDelay", "{", "return", "&", "WaitDelay", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "delay", ":", "delay", ",", "}", "\n", "}" ]

[ "NewWaitDelayState", "returns", "a", "new", "WaitDelay", "pointer", "instance" ]

[ "func", "NewWaitUntilState", "(", "stateName", "string", ",", "waitUntil", "time", ".", "Time", ")", "*", "WaitUntil", "{", "return", "&", "WaitUntil", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "Timestamp", ":", "waitUntil", ",", "}", "\n", "}" ]

[ "NewWaitUntilState", "returns", "a", "new", "WaitDelay", "pointer", "instance" ]

[ "func", "NewWaitDynamicUntilState", "(", "stateName", "string", ",", "timestampPath", "string", ")", "*", "WaitDynamicUntil", "{", "return", "&", "WaitDynamicUntil", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "TimestampPath", ":", "timestampPath", ",", "}", "\n", "}" ]

[ "NewWaitDynamicUntilState", "returns", "a", "new", "WaitDynamicUntil", "pointer", "instance" ]

[ "func", "NewSuccessState", "(", "name", "string", ")", "*", "SuccessState", "{", "return", "&", "SuccessState", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "name", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "isEndStateInvalid", ":", "true", ",", "}", ",", "}", "\n", "}" ]

[ "NewSuccessState", "returns", "a", "SuccessState", "with", "the", "supplied", "name" ]

[ "func", "(", "fs", "*", "FailState", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "additionalParams", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "additionalParams", "[", "\"", "\"", "]", "=", "fs", ".", "ErrorName", "\n", "if", "fs", ".", "Cause", "!=", "nil", "{", "additionalParams", "[", "\"", "\"", "]", "=", "fs", ".", "Cause", ".", "Error", "(", ")", "\n", "}", "\n", "return", "fs", ".", "marshalStateJSON", "(", "\"", "\"", ",", "additionalParams", ")", "\n", "}" ]

[ "MarshalJSON", "for", "custom", "marshaling" ]

[ "func", "NewFailState", "(", "failStateName", "string", ",", "errorName", "string", ",", "cause", "error", ")", "*", "FailState", "{", "return", "&", "FailState", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "failStateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "isEndStateInvalid", ":", "true", ",", "}", ",", "ErrorName", ":", "errorName", ",", "Cause", ":", "cause", ",", "}", "\n", "}" ]

[ "NewFailState", "returns", "a", "FailState", "with", "the", "supplied", "information" ]