Datasets:

CM

/

codexglue_code2text_go

like 1

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

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

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

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

[ "func", "NewParallelState", "(", "parallelStateName", "string", ",", "states", "StateMachine", ")", "*", "ParallelState", "{", "return", "&", "ParallelState", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "parallelStateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "States", ":", "states", ",", "}", "\n", "}" ]

[ "NewParallelState", "returns", "a", "ParallelState", "with", "the", "supplied", "information" ]

[ "func", "(", "sm", "*", "StateMachine", ")", "Comment", "(", "comment", "string", ")", "*", "StateMachine", "{", "sm", ".", "comment", "=", "comment", "\n", "return", "sm", "\n", "}" ]

[ "Comment", "sets", "the", "StateMachine", "comment" ]

[ "func", "(", "sm", "*", "StateMachine", ")", "WithRoleArn", "(", "roleArn", "gocf", ".", "Stringable", ")", "*", "StateMachine", "{", "sm", ".", "roleArn", "=", "roleArn", "\n", "return", "sm", "\n", "}" ]

[ "WithRoleArn", "sets", "the", "state", "machine", "roleArn" ]

[ "func", "(", "sm", "*", "StateMachine", ")", "validate", "(", ")", "[", "]", "error", "{", "validationErrors", ":=", "make", "(", "[", "]", "error", ",", "0", ")", "\n", "if", "sm", ".", "stateDefinitionError", "!=", "nil", "{", "validationErrors", "=", "append", "(", "validationErrors", ",", "sm", ".", "stateDefinitionError", ")", "\n", "}", "\n\n", "// TODO - add Catcher validator", "/*\n\t\tEach Catcher MUST contain a field named “ErrorEquals”, specified exactly as with the Retrier “ErrorEquals” field, and a field named “Next” whose value MUST be a string exactly matching a State Name.\n\n\t\tWhen a state reports an error and either there is no Retry field, or retries have failed to resolve the error, the interpreter scans through the Catchers in array order, and when the Error Name appears in the value of a Catcher’s “ErrorEquals” field, transitions the machine to the state named in the value of the “Next” field.\n\n\t\tThe reserved name “States.ALL” appearing in a Retrier’s “ErrorEquals” field is a wild-card and matches any Error Name. Such a value MUST appear alone in the “ErrorEquals” array and MUST appear in the last Catcher in the “Catch” array.\n\t*/", "return", "validationErrors", "\n", "}" ]

[ "validate", "performs", "any", "validation", "against", "the", "state", "machine", "prior", "to", "marshaling" ]

[ "func", "(", "sm", "*", "StateMachine", ")", "StateMachineDecorator", "(", ")", "sparta", ".", "ServiceDecoratorHookFunc", "{", "cfName", ":=", "sparta", ".", "CloudFormationResourceName", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "sm", ".", "StateMachineNamedDecorator", "(", "cfName", ")", "\n", "}" ]

[ "StateMachineDecorator", "is", "a", "decorator", "that", "returns", "a", "default", "CloudFormationResource", "named", "decorator" ]

[ "func", "NewStateMachine", "(", "stateMachineName", "string", ",", "startState", "TransitionState", ")", "*", "StateMachine", "{", "uniqueStates", ":=", "make", "(", "map", "[", "string", "]", "MachineState", ")", "\n", "pendingStates", ":=", "[", "]", "MachineState", "{", "startState", "}", "\n", "duplicateStateNames", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n\n", "nodeVisited", ":=", "func", "(", "node", "MachineState", ")", "bool", "{", "if", "node", "==", "nil", "{", "return", "true", "\n", "}", "\n", "_", ",", "visited", ":=", "uniqueStates", "[", "node", ".", "Name", "(", ")", "]", "\n", "return", "visited", "\n", "}", "\n\n", "for", "len", "(", "pendingStates", ")", "!=", "0", "{", "headState", ",", "tailStates", ":=", "pendingStates", "[", "0", "]", ",", "pendingStates", "[", "1", ":", "]", "\n", "uniqueStates", "[", "headState", ".", "Name", "(", ")", "]", "=", "headState", "\n\n", "switch", "stateNode", ":=", "headState", ".", "(", "type", ")", "{", "case", "*", "ChoiceState", ":", "for", "_", ",", "eachChoice", ":=", "range", "stateNode", ".", "Choices", "{", "if", "!", "nodeVisited", "(", "eachChoice", ".", "nextState", "(", ")", ")", "{", "tailStates", "=", "append", "(", "tailStates", ",", "eachChoice", ".", "nextState", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "!", "nodeVisited", "(", "stateNode", ".", "Default", ")", "{", "tailStates", "=", "append", "(", "tailStates", ",", "stateNode", ".", "Default", ")", "\n", "}", "\n\n", "case", "TransitionState", ":", "for", "_", ",", "eachAdjacentState", ":=", "range", "stateNode", ".", "AdjacentStates", "(", ")", "{", "if", "!", "nodeVisited", "(", "eachAdjacentState", ")", "{", "tailStates", "=", "append", "(", "tailStates", ",", "eachAdjacentState", ")", "\n", "}", "\n", "}", "\n", "// Are there any Catchers in here?", "}", "\n", "pendingStates", "=", "tailStates", "\n", "}", "\n\n", "// Walk all the states and assemble them into the states slice", "sm", ":=", "&", "StateMachine", "{", "name", ":", "stateMachineName", ",", "startAt", ":", "startState", ",", "uniqueStates", ":", "uniqueStates", ",", "}", "\n", "// Store duplicate state names", "if", "len", "(", "duplicateStateNames", ")", "!=", "0", "{", "sm", ".", "stateDefinitionError", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "duplicateStateNames", ")", "\n", "}", "\n", "return", "sm", "\n", "}" ]

[ "NewStateMachine", "returns", "a", "new", "StateMachine", "instance" ]

[ "func", "Log", "(", "formatSpecifier", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "mg", ".", "Verbose", "(", ")", "{", "if", "len", "(", "args", ")", "!=", "0", "{", "log", ".", "Printf", "(", "formatSpecifier", ",", "args", "...", ")", "\n", "}", "else", "{", "log", ".", "Print", "(", "formatSpecifier", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Log", "is", "a", "mage", "verbose", "aware", "log", "function" ]

[ "func", "Script", "(", "commands", "[", "]", "[", "]", "string", ")", "error", "{", "for", "_", ",", "eachCommand", ":=", "range", "commands", "{", "var", "commandErr", "error", "\n", "if", "len", "(", "eachCommand", ")", "<=", "1", "{", "commandErr", "=", "sh", ".", "Run", "(", "eachCommand", "[", "0", "]", ")", "\n", "}", "else", "{", "commandErr", "=", "sh", ".", "Run", "(", "eachCommand", "[", "0", "]", ",", "eachCommand", "[", "1", ":", "]", "...", ")", "\n", "}", "\n", "if", "commandErr", "!=", "nil", "{", "return", "commandErr", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Script", "is", "a", "2d", "array", "of", "commands", "to", "run", "as", "a", "script" ]

[ "func", "ApplyToSource", "(", "fileExtension", "string", ",", "ignoredSubdirectories", "[", "]", "string", ",", "commandParts", "...", "string", ")", "error", "{", "if", "len", "(", "commandParts", ")", "<=", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "eligibleSourceFiles", ",", "eligibleSourceFilesErr", ":=", "sourceFilesOfType", "(", "fileExtension", ",", "ignoredSubdirectories", ")", "\n", "if", "eligibleSourceFilesErr", "!=", "nil", "{", "return", "eligibleSourceFilesErr", "\n", "}", "\n\n", "Log", "(", "header", ")", "\n", "Log", "(", "\"", "\"", ",", "commandParts", "[", "0", "]", ",", "len", "(", "eligibleSourceFiles", ")", ",", "fileExtension", ")", "\n", "Log", "(", "header", ")", "\n\n", "commandArgs", ":=", "[", "]", "string", "{", "}", "\n", "if", "len", "(", "commandParts", ")", ">", "1", "{", "commandArgs", "=", "append", "(", "commandArgs", ",", "commandParts", "[", "1", ":", "]", "...", ")", "\n", "}", "\n", "for", "_", ",", "eachFile", ":=", "range", "eligibleSourceFiles", "{", "applyArgs", ":=", "append", "(", "commandArgs", ",", "eachFile", ")", "\n", "applyErr", ":=", "sh", ".", "Run", "(", "commandParts", "[", "0", "]", ",", "applyArgs", "...", ")", "\n", "if", "applyErr", "!=", "nil", "{", "return", "applyErr", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ApplyToSource", "is", "a", "mage", "compatible", "function", "that", "applies", "a", "command", "to", "your", "source", "tree" ]

[ "func", "SpartaCommand", "(", "commandParts", "...", "string", ")", "error", "{", "noopValue", ":=", "\"", "\"", "\n", "parsedBool", ",", "parsedBoolErr", ":=", "strconv", ".", "ParseBool", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "if", "parsedBoolErr", "==", "nil", "&&", "parsedBool", "{", "noopValue", "=", "\"", "\"", "\n", "}", "\n", "curDir", ",", "curDirErr", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "curDirErr", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "curDirErr", ".", "Error", "(", ")", ")", "\n", "}", "\n", "setenvErr", ":=", "os", ".", "Setenv", "(", "mg", ".", "VerboseEnv", ",", "\"", "\"", ")", "\n", "if", "setenvErr", "!=", "nil", "{", "return", "setenvErr", "\n", "}", "\n", "commandArgs", ":=", "[", "]", "string", "{", "\"", "\"", ",", "curDir", ",", "}", "\n", "commandArgs", "=", "append", "(", "commandArgs", ",", "commandParts", "...", ")", "\n", "if", "noopValue", "!=", "\"", "\"", "{", "commandArgs", "=", "append", "(", "commandArgs", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "sh", ".", "Run", "(", "\"", "\"", ",", "commandArgs", "...", ")", "\n", "}" ]

[ "SpartaCommand", "issues", "a", "go", "run", "command", "that", "encapsulates", "resolving", "global", "env", "vars", "that", "can", "be", "translated", "into", "Sparta", "command", "line", "options" ]

[ "func", "Provision", "(", ")", "error", "{", "// Get the bucketName", "bucketName", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "bucketName", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "SpartaCommand", "(", "\"", "\"", ",", "\"", "\"", ",", "bucketName", ")", "\n", "}" ]

[ "Provision", "deploys", "the", "given", "service" ]

[ "func", "Describe", "(", ")", "error", "{", "// Get the bucketName", "bucketName", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "bucketName", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "SpartaCommand", "(", "\"", "\"", ",", "\"", "\"", ",", "bucketName", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "Describe", "deploys", "the", "given", "service" ]

[ "func", "describeInfoValue", "(", "dynamicValue", "interface", "{", "}", ")", "string", "{", "switch", "typedArn", ":=", "dynamicValue", ".", "(", "type", ")", "{", "case", "string", ":", "return", "typedArn", "\n", "case", "gocf", ".", "Stringable", ":", "data", ",", "dataErr", ":=", "json", ".", "Marshal", "(", "typedArn", ")", "\n", "if", "dataErr", "!=", "nil", "{", "data", "=", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typedArn", ")", ")", "\n", "}", "\n", "return", "string", "(", "data", ")", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typedArn", ")", ")", "\n", "}", "\n", "}" ]

[ "describeInfoValue", "is", "a", "utility", "function", "that", "accepts", "some", "type", "of", "dynamic", "gocf", "value", "and", "transforms", "it", "into", "something", "that", "is", "describe", "output", "compatible" ]

[ "func", "relativePath", "(", "logPath", "string", ")", "string", "{", "cwd", ",", "cwdErr", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "cwdErr", "==", "nil", "{", "relPath", ":=", "strings", ".", "TrimPrefix", "(", "logPath", ",", "cwd", ")", "\n", "if", "relPath", "!=", "logPath", "{", "logPath", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "relPath", ")", "\n", "}", "\n", "}", "\n", "return", "logPath", "\n", "}" ]

[ "relativePath", "returns", "the", "relative", "path", "of", "logPath", "if", "it", "s", "relative", "to", "the", "current", "workint", "directory" ]

[ "func", "(", "t", "*", "workTask", ")", "Run", "(", "wg", "*", "sync", ".", "WaitGroup", ")", "{", "t", ".", "Result", "=", "t", ".", "task", "(", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}" ]

[ "Run", "runs", "a", "Task", "and", "does", "appropriate", "accounting", "via", "a", "given", "sync", ".", "WorkGroup", "." ]

[ "func", "newWorkerPool", "(", "tasks", "[", "]", "*", "workTask", ",", "concurrency", "int", ")", "*", "workerPool", "{", "return", "&", "workerPool", "{", "Tasks", ":", "tasks", ",", "concurrency", ":", "concurrency", ",", "tasksChan", ":", "make", "(", "chan", "*", "workTask", ")", ",", "}", "\n", "}" ]

[ "newWorkerPool", "initializes", "a", "new", "pool", "with", "the", "given", "tasks", "and", "at", "the", "given", "concurrency", "." ]

[ "func", "(", "p", "*", "workerPool", ")", "workResults", "(", ")", "(", "[", "]", "interface", "{", "}", ",", "[", "]", "error", ")", "{", "result", ":=", "[", "]", "interface", "{", "}", "{", "}", "\n", "errors", ":=", "[", "]", "error", "{", "}", "\n\n", "for", "_", ",", "eachResult", ":=", "range", "p", ".", "Tasks", "{", "if", "eachResult", ".", "Result", ".", "Error", "(", ")", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "eachResult", ".", "Result", ".", "Error", "(", ")", ")", "\n", "}", "else", "{", "result", "=", "append", "(", "result", ",", "eachResult", ".", "Result", ".", "Result", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "result", ",", "errors", "\n", "}" ]

[ "HasErrors", "indicates", "whether", "there", "were", "any", "errors", "from", "tasks", "run", ".", "Its", "result", "is", "only", "meaningful", "after", "Run", "has", "been", "called", "." ]

[ "func", "(", "p", "*", "workerPool", ")", "Run", "(", ")", "(", "[", "]", "interface", "{", "}", ",", "[", "]", "error", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "p", ".", "concurrency", ";", "i", "++", "{", "go", "p", ".", "work", "(", ")", "\n", "}", "\n\n", "p", ".", "wg", ".", "Add", "(", "len", "(", "p", ".", "Tasks", ")", ")", "\n", "for", "_", ",", "task", ":=", "range", "p", ".", "Tasks", "{", "p", ".", "tasksChan", "<-", "task", "\n", "}", "\n\n", "// all workers return", "close", "(", "p", ".", "tasksChan", ")", "\n\n", "p", ".", "wg", ".", "Wait", "(", ")", "\n", "return", "p", ".", "workResults", "(", ")", "\n", "}" ]

[ "Run", "runs", "all", "work", "within", "the", "pool", "and", "blocks", "until", "it", "s", "finished", "." ]

[ "func", "(", "p", "*", "workerPool", ")", "work", "(", ")", "{", "for", "task", ":=", "range", "p", ".", "tasksChan", "{", "task", ".", "Run", "(", "&", "p", ".", "wg", ")", "\n", "}", "\n", "}" ]

[ "The", "work", "loop", "for", "any", "single", "goroutine", "." ]

[ "func", "(", "reactorFunc", "CloudWatchReactorFunc", ")", "OnCloudWatchMessage", "(", "ctx", "context", ".", "Context", ",", "cwLogs", "awsLambdaEvents", ".", "CloudwatchLogsEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactorFunc", "(", "ctx", ",", "cwLogs", ")", "\n", "}" ]

[ "OnCloudWatchMessage", "satisfies", "the", "CloudWatchReactor", "interface" ]

[ "func", "NewCloudWatchReactor", "(", "reactor", "CloudWatchReactor", ",", "subscriptions", "map", "[", "string", "]", "sparta", ".", "CloudWatchEventsRule", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "if", "len", "(", "subscriptions", ")", "<=", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "reactorLambda", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "cwLogs", "awsLambdaEvents", ".", "CloudwatchLogsEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactor", ".", "OnCloudWatchMessage", "(", "ctx", ",", "cwLogs", ")", "\n", "}", "\n", "lambdaFn", ",", "lambdaFnErr", ":=", "sparta", ".", "NewAWSLambda", "(", "reactorName", "(", "reactor", ")", ",", "reactorLambda", ",", "sparta", ".", "IAMRoleDefinition", "{", "}", ")", "\n", "if", "lambdaFnErr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "lambdaFnErr", ",", "\"", "\"", ")", "\n", "}", "\n", "cloudWatchEventsPermission", ":=", "sparta", ".", "CloudWatchEventsPermission", "{", "}", "\n", "cloudWatchEventsPermission", ".", "Rules", "=", "make", "(", "map", "[", "string", "]", "sparta", ".", "CloudWatchEventsRule", ")", "\n", "for", "eachRuleName", ",", "eachRule", ":=", "range", "subscriptions", "{", "cloudWatchEventsPermission", ".", "Rules", "[", "eachRuleName", "]", "=", "eachRule", "\n", "}", "\n", "lambdaFn", ".", "Permissions", "=", "append", "(", "lambdaFn", ".", "Permissions", ",", "cloudWatchEventsPermission", ")", "\n\n", "if", "len", "(", "additionalLambdaPermissions", ")", "!=", "0", "{", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "=", "additionalLambdaPermissions", "\n", "}", "\n", "return", "lambdaFn", ",", "nil", "\n", "}" ]

[ "NewCloudWatchReactor", "returns", "a", "CloudWatch", "logs", "reactor", "lambda", "function" ]

[ "func", "(", "lei", "*", "LambdaEventInterceptors", ")", "Register", "(", "provider", "LambdaInterceptorProvider", ")", "*", "LambdaEventInterceptors", "{", "namedInterceptor", ":=", "func", "(", "interceptor", "Interceptor", ")", "*", "NamedInterceptor", "{", "return", "&", "NamedInterceptor", "{", "Name", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "provider", ")", ",", "Interceptor", ":", "interceptor", ",", "}", "\n", "}", "\n", "if", "lei", ".", "Begin", "==", "nil", "{", "lei", ".", "Begin", "=", "make", "(", "InterceptorList", ",", "0", ")", "\n", "}", "\n", "lei", ".", "Begin", "=", "append", "(", "lei", ".", "Begin", ",", "namedInterceptor", "(", "provider", ".", "Begin", ")", ")", "\n\n", "if", "lei", ".", "BeforeSetup", "==", "nil", "{", "lei", ".", "BeforeSetup", "=", "make", "(", "InterceptorList", ",", "0", ")", "\n", "}", "\n", "lei", ".", "BeforeSetup", "=", "append", "(", "lei", ".", "BeforeSetup", ",", "namedInterceptor", "(", "provider", ".", "BeforeSetup", ")", ")", "\n\n", "if", "lei", ".", "AfterSetup", "==", "nil", "{", "lei", ".", "AfterSetup", "=", "make", "(", "InterceptorList", ",", "0", ")", "\n", "}", "\n", "lei", ".", "AfterSetup", "=", "append", "(", "lei", ".", "AfterSetup", ",", "namedInterceptor", "(", "provider", ".", "AfterSetup", ")", ")", "\n\n", "if", "lei", ".", "BeforeDispatch", "==", "nil", "{", "lei", ".", "BeforeDispatch", "=", "make", "(", "InterceptorList", ",", "0", ")", "\n", "}", "\n", "lei", ".", "BeforeDispatch", "=", "append", "(", "lei", ".", "BeforeDispatch", ",", "namedInterceptor", "(", "provider", ".", "BeforeDispatch", ")", ")", "\n\n", "if", "lei", ".", "AfterDispatch", "==", "nil", "{", "lei", ".", "AfterDispatch", "=", "make", "(", "InterceptorList", ",", "0", ")", "\n", "}", "\n", "lei", ".", "AfterDispatch", "=", "append", "(", "lei", ".", "AfterDispatch", ",", "namedInterceptor", "(", "provider", ".", "AfterDispatch", ")", ")", "\n\n", "if", "lei", ".", "Complete", "==", "nil", "{", "lei", ".", "Complete", "=", "make", "(", "InterceptorList", ",", "0", ")", "\n", "}", "\n", "lei", ".", "Complete", "=", "append", "(", "lei", ".", "Complete", ",", "namedInterceptor", "(", "provider", ".", "Complete", ")", ")", "\n", "return", "lei", "\n", "}" ]

[ "Register", "is", "a", "convenience", "function", "to", "register", "a", "struct", "that", "implements", "the", "LambdaInterceptorProvider", "interface" ]

[ "func", "(", "info", "*", "LambdaAWSInfo", ")", "lambdaFunctionName", "(", ")", "string", "{", "if", "info", ".", "cachedLambdaFunctionName", "!=", "\"", "\"", "{", "return", "info", ".", "cachedLambdaFunctionName", "\n", "}", "\n", "var", "lambdaFuncName", "string", "\n\n", "if", "info", ".", "Options", "!=", "nil", "&&", "info", ".", "Options", ".", "SpartaOptions", "!=", "nil", "&&", "info", ".", "Options", ".", "SpartaOptions", ".", "Name", "!=", "\"", "\"", "{", "lambdaFuncName", "=", "info", ".", "Options", ".", "SpartaOptions", ".", "Name", "\n", "}", "else", "if", "info", ".", "userSuppliedFunctionName", "!=", "\"", "\"", "{", "lambdaFuncName", "=", "info", ".", "userSuppliedFunctionName", "\n", "}", "else", "{", "// Using the default name, let's at least remove the", "// first prefix, since that's the SCM provider and", "// doesn't provide a lot of value...", "if", "info", ".", "handlerSymbol", "!=", "nil", "{", "lambdaPtr", ":=", "runtime", ".", "FuncForPC", "(", "reflect", ".", "ValueOf", "(", "info", ".", "handlerSymbol", ")", ".", "Pointer", "(", ")", ")", "\n", "lambdaFuncName", "=", "lambdaPtr", ".", "Name", "(", ")", "\n", "}", "\n\n", "// Split", "// cwd: /Users/mweagle/Documents/gopath/src/github.com/mweagle/SpartaHelloWorld", "// anonymous: github.com/mweagle/Sparta.(*StructHandler1).(github.com/mweagle/Sparta.handler)-fm", "//\tRE==> var reSplit = regexp.MustCompile(\"[\\\\(\\\\)\\\\.\\\\*]+\")", "// \tRESULT ==> Hello,[github com/mweagle/Sparta StructHandler1 github com/mweagle/Sparta handler -fm]", "// Same package: main.helloWorld", "// Other package, free function: github.com/mweagle/SpartaPython.HelloWorld", "// Grab the name of the function...", "structDefined", ":=", "strings", ".", "Contains", "(", "lambdaFuncName", ",", "\"", "\"", ")", "||", "strings", ".", "Contains", "(", "lambdaFuncName", ",", "\"", "\"", ")", "\n", "otherPackage", ":=", "strings", ".", "Contains", "(", "lambdaFuncName", ",", "\"", "\"", ")", "\n", "canonicalName", ":=", "lambdaFuncName", "\n", "if", "structDefined", "{", "var", "reSplit", "=", "regexp", ".", "MustCompile", "(", "`[*\\(\\)\\[\\]]+`", ")", "\n", "// Function name:", "// github.com/mweagle/Sparta.(*StructHandler1).handler-fm", "parts", ":=", "reSplit", ".", "Split", "(", "lambdaFuncName", ",", "-", "1", ")", "\n", "lastPart", ":=", "parts", "[", "len", "(", "parts", ")", "-", "1", "]", "\n", "penultimatePart", ":=", "lastPart", "\n", "if", "len", "(", "parts", ")", ">", "1", "{", "penultimatePart", "=", "parts", "[", "len", "(", "parts", ")", "-", "2", "]", "\n", "}", "\n", "intermediateName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "penultimatePart", ",", "lastPart", ")", "\n", "reClean", ":=", "regexp", ".", "MustCompile", "(", "`[\\*\\(\\)]+`", ")", "\n", "canonicalName", "=", "reClean", ".", "ReplaceAllString", "(", "intermediateName", ",", "\"", "\"", ")", "\n", "}", "else", "if", "otherPackage", "{", "parts", ":=", "strings", ".", "Split", "(", "lambdaFuncName", ",", "\"", "\"", ")", "\n", "canonicalName", "=", "parts", "[", "len", "(", "parts", ")", "-", "1", "]", "\n", "}", "\n", "// Final sanitization", "// Issue: https://github.com/mweagle/Sparta/issues/63", "lambdaFuncName", "=", "sanitizedName", "(", "canonicalName", ")", "\n", "}", "\n", "// Cache it so we only do this once", "info", ".", "cachedLambdaFunctionName", "=", "lambdaFuncName", "\n", "return", "info", ".", "cachedLambdaFunctionName", "\n", "}" ]

[ "lambdaFunctionName", "returns", "the", "internal", "function", "name", "for", "lambda", "export", "binding" ]

[ "func", "(", "info", "*", "LambdaAWSInfo", ")", "LogicalResourceName", "(", ")", "string", "{", "// Per http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resources-section-structure.html,", "// we can only use alphanumeric, so we'll take the sanitized name and", "// remove all underscores", "// Prefer the user-supplied stable name to the internal one.", "baseName", ":=", "info", ".", "lambdaFunctionName", "(", ")", "\n", "resourceName", ":=", "strings", ".", "Replace", "(", "sanitizedName", "(", "baseName", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "prefix", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "resourceName", ")", "\n", "return", "CloudFormationResourceName", "(", "prefix", ",", "info", ".", "lambdaFunctionName", "(", ")", ")", "\n", "}" ]

[ "LogicalResourceName", "returns", "the", "stable", "content", "-", "addressable", "logical", "name", "for", "this", "LambdaAWSInfo", "value", ".", "This", "is", "the", "CloudFormation", "resource", "name" ]

[ "func", "LambdaName", "(", "handlerSymbol", "interface", "{", "}", ")", "string", "{", "funcPtr", ":=", "runtime", ".", "FuncForPC", "(", "reflect", ".", "ValueOf", "(", "handlerSymbol", ")", ".", "Pointer", "(", ")", ")", "\n", "return", "funcPtr", ".", "Name", "(", ")", "\n", "}" ]

[ "LambdaName", "returns", "the", "Go", "-", "reflection", "discovered", "name", "for", "a", "given", "function" ]

[ "func", "(", "storage", "*", "MessageBodyStorage", ")", "BucketArn", "(", ")", "*", "gocf", ".", "StringExpr", "{", "return", "gocf", ".", "Join", "(", "\"", "\"", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "storage", ".", "bucketNameExpr", ")", "\n", "}" ]

[ "BucketArn", "returns", "an", "Arn", "value", "that", "can", "be", "used", "as", "an", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "Resource", "value", "." ]

[ "func", "(", "perm", "*", "SESPermission", ")", "NewMessageBodyStorageResource", "(", "bucketLogicalName", "string", ")", "(", "*", "MessageBodyStorage", ",", "error", ")", "{", "if", "len", "(", "bucketLogicalName", ")", "<=", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "store", ":=", "&", "MessageBodyStorage", "{", "logicalBucketName", ":", "bucketLogicalName", ",", "}", "\n", "store", ".", "cloudFormationS3BucketResourceName", "=", "CloudFormationResourceName", "(", "\"", "\"", ",", "bucketLogicalName", ")", "\n", "store", ".", "bucketNameExpr", "=", "gocf", ".", "Ref", "(", "store", ".", "cloudFormationS3BucketResourceName", ")", ".", "String", "(", ")", "\n", "return", "store", ",", "nil", "\n", "}" ]

[ "NewMessageBodyStorageResource", "provisions", "a", "new", "S3", "bucket", "to", "store", "message", "body", "content", "." ]

[ "func", "(", "rule", "CloudWatchEventsRule", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "ruleJSON", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n\n", "if", "rule", ".", "Description", "!=", "\"", "\"", "{", "ruleJSON", "[", "\"", "\"", "]", "=", "rule", ".", "Description", "\n", "}", "\n", "if", "nil", "!=", "rule", ".", "EventPattern", "{", "eventPatternString", ",", "err", ":=", "json", ".", "Marshal", "(", "rule", ".", "EventPattern", ")", "\n", "if", "nil", "!=", "err", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ruleJSON", "[", "\"", "\"", "]", "=", "string", "(", "eventPatternString", ")", "\n", "}", "\n", "if", "rule", ".", "ScheduleExpression", "!=", "\"", "\"", "{", "ruleJSON", "[", "\"", "\"", "]", "=", "rule", ".", "ScheduleExpression", "\n", "}", "\n", "if", "nil", "!=", "rule", ".", "RuleTarget", "{", "ruleJSON", "[", "\"", "\"", "]", "=", "rule", ".", "RuleTarget", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "ruleJSON", ")", "\n", "}" ]

[ "MarshalJSON", "customizes", "the", "JSON", "representation", "used", "when", "serializing", "to", "the", "CloudFormation", "template", "representation", "." ]

[ "func", "(", "apigError", "*", "Error", ")", "Error", "(", ")", "string", "{", "bytes", ",", "bytesErr", ":=", "json", ".", "Marshal", "(", "apigError", ")", "\n", "if", "bytesErr", "!=", "nil", "{", "bytes", "=", "[", "]", "byte", "(", "http", ".", "StatusText", "(", "http", ".", "StatusInternalServerError", ")", ")", "\n", "}", "\n", "return", "string", "(", "bytes", ")", "\n", "}" ]

[ "Error", "returns", "the", "JSONified", "version", "of", "this", "error", "which", "will", "trigger", "the", "appropriate", "integration", "mapping", "." ]

[ "func", "NewErrorResponse", "(", "statusCode", "int", ",", "messages", "...", "interface", "{", "}", ")", "*", "Error", "{", "additionalMessages", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "messages", ")", ")", "\n", "for", "eachIndex", ",", "eachMessage", ":=", "range", "messages", "{", "switch", "typedValue", ":=", "eachMessage", ".", "(", "type", ")", "{", "case", "error", ":", "additionalMessages", "[", "eachIndex", "]", "=", "typedValue", ".", "Error", "(", ")", "\n", "default", ":", "additionalMessages", "[", "eachIndex", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typedValue", ")", "\n", "}", "\n", "}", "\n\n", "err", ":=", "&", "Error", "{", "Code", ":", "statusCode", ",", "Err", ":", "http", ".", "StatusText", "(", "statusCode", ")", ",", "Message", ":", "strings", ".", "Join", "(", "additionalMessages", ",", "\"", "\"", ")", ",", "Context", ":", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ",", "}", "\n", "if", "len", "(", "err", ".", "Err", ")", "<=", "0", "{", "err", ".", "Code", "=", "http", ".", "StatusInternalServerError", "\n", "err", ".", "Err", "=", "http", ".", "StatusText", "(", "http", ".", "StatusInternalServerError", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "NewErrorResponse", "returns", "a", "response", "that", "satisfies", "the", "regular", "expression", "used", "to", "determine", "integration", "mappings", "via", "the", "API", "Gateway", ".", "messages", "is", "a", "stringable", "type", ".", "Error", "interface", "instances", "will", "be", "properly", "typecast", "." ]

[ "func", "(", "resp", "*", "Response", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "canonicalResponse", ":=", "canonicalResponse", "{", "Code", ":", "resp", ".", "Code", ",", "Body", ":", "resp", ".", "Body", ",", "}", "\n", "if", "len", "(", "resp", ".", "Headers", ")", "!=", "0", "{", "canonicalResponse", ".", "Headers", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "eachKey", ",", "eachValue", ":=", "range", "resp", ".", "Headers", "{", "canonicalResponse", ".", "Headers", "[", "strings", ".", "ToLower", "(", "eachKey", ")", "]", "=", "eachValue", "\n", "}", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "&", "canonicalResponse", ")", "\n", "}" ]

[ "MarshalJSON", "is", "a", "custom", "marshaller", "to", "ensure", "that", "the", "marshalled", "headers", "are", "always", "lowercase" ]

[ "func", "NewResponse", "(", "code", "int", ",", "body", "interface", "{", "}", ",", "headers", "...", "map", "[", "string", "]", "string", ")", "*", "Response", "{", "response", ":=", "&", "Response", "{", "Code", ":", "code", ",", "Body", ":", "body", ",", "}", "\n", "if", "len", "(", "headers", ")", "!=", "0", "{", "response", ".", "Headers", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "eachHeaderMap", ":=", "range", "headers", "{", "for", "eachKey", ",", "eachValue", ":=", "range", "eachHeaderMap", "{", "response", ".", "Headers", "[", "eachKey", "]", "=", "eachValue", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "response", "\n", "}" ]

[ "NewResponse", "returns", "an", "API", "Gateway", "response", "object" ]

[ "func", "NewDynamoDBGetItemState", "(", "stateName", "string", ",", "parameters", "DynamoDBGetItemParameters", ")", "*", "DynamoDBGetItemState", "{", "dgis", ":=", "&", "DynamoDBGetItemState", "{", "BaseTask", ":", "BaseTask", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "}", ",", "parameters", ":", "parameters", ",", "}", "\n", "return", "dgis", "\n", "}" ]

[ "NewDynamoDBGetItemState", "returns", "an", "initialized", "DynamoDB", "GetItem", "state" ]

[ "func", "NewDynamoDBPutItemState", "(", "stateName", "string", ",", "parameters", "DynamoDBPutItemParameters", ")", "*", "DynamoDBPutItemState", "{", "dpis", ":=", "&", "DynamoDBPutItemState", "{", "BaseTask", ":", "BaseTask", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "}", ",", "parameters", ":", "parameters", ",", "}", "\n", "return", "dpis", "\n", "}" ]

[ "NewDynamoDBPutItemState", "returns", "an", "initialized", "DynamoDB", "PutItem", "state" ]

[ "func", "xrayInit", "(", "awsClient", "*", "client", ".", "Client", ")", "{", "if", "os", ".", "Getenv", "(", "\"", "\"", ")", "!=", "\"", "\"", "&&", "os", ".", "Getenv", "(", "\"", "\"", ")", "!=", "\"", "\"", "{", "xray", ".", "AWS", "(", "awsClient", ")", "\n", "}", "\n", "}" ]

[ "Conditionally", "attach", "XRay", "if", "it", "seems", "like", "the", "right", "thing", "to", "do" ]

[ "func", "(", "reactorFunc", "CodeCommitReactorFunc", ")", "OnCodeCommitEvent", "(", "ctx", "context", ".", "Context", ",", "codeCommitEvent", "awsLambdaEvents", ".", "CodeCommitEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactorFunc", "(", "ctx", ",", "codeCommitEvent", ")", "\n", "}" ]

[ "OnCodeCommitEvent", "satisfies", "the", "CodeCommitReactor", "interface" ]

[ "func", "NewCodeCommitReactor", "(", "reactor", "CodeCommitReactor", ",", "repositoryName", "gocf", ".", "Stringable", ",", "branches", "[", "]", "string", ",", "events", "[", "]", "string", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "reactorLambda", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "codeCommitEvent", "awsLambdaEvents", ".", "CodeCommitEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactor", ".", "OnCodeCommitEvent", "(", "ctx", ",", "codeCommitEvent", ")", "\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", ".", "CodeCommitPermission", "{", "BasePermission", ":", "sparta", ".", "BasePermission", "{", "SourceArn", ":", "repositoryName", ",", "}", ",", "RepositoryName", ":", "repositoryName", ".", "String", "(", ")", ",", "Branches", ":", "branches", ",", "Events", ":", "events", ",", "}", ")", "\n", "if", "len", "(", "additionalLambdaPermissions", ")", "!=", "0", "{", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "=", "additionalLambdaPermissions", "\n", "}", "\n", "return", "lambdaFn", ",", "nil", "\n", "}" ]

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

[ "func", "(", "svc", "*", "S3Accessor", ")", "BucketPrivilege", "(", "bucketPrivs", "...", "string", ")", "sparta", ".", "IAMRolePrivilege", "{", "return", "sparta", ".", "IAMRolePrivilege", "{", "Actions", ":", "bucketPrivs", ",", "Resource", ":", "spartaCF", ".", "S3ArnForBucket", "(", "gocf", ".", "Ref", "(", "svc", ".", "S3BucketResourceName", ")", ")", ",", "}", "\n", "}" ]

[ "BucketPrivilege", "returns", "a", "privilege", "that", "targets", "the", "Bucket" ]

[ "func", "(", "svc", "*", "S3Accessor", ")", "KeysPrivilege", "(", "keyPrivileges", "...", "string", ")", "sparta", ".", "IAMRolePrivilege", "{", "return", "sparta", ".", "IAMRolePrivilege", "{", "Actions", ":", "keyPrivileges", ",", "Resource", ":", "spartaCF", ".", "S3AllKeysArnForBucket", "(", "gocf", ".", "Ref", "(", "svc", ".", "S3BucketResourceName", ")", ")", ",", "}", "\n", "}" ]

[ "KeysPrivilege", "returns", "a", "privilege", "that", "targets", "the", "Bucket", "objects" ]

[ "func", "awsLambdaFunctionName", "(", "internalFunctionName", "string", ")", "gocf", ".", "Stringable", "{", "sanitizedName", ":=", "awsLambdaInternalName", "(", "internalFunctionName", ")", "\n", "// When we build, we return a gocf.Join that", "// will use the stack name and the internal name. When we run, we're going", "// to use the name discovered from the environment.", "return", "gocf", ".", "Join", "(", "\"", "\"", ",", "gocf", ".", "Ref", "(", "\"", "\"", ")", ",", "gocf", ".", "String", "(", "functionNameDelimiter", ")", ",", "gocf", ".", "String", "(", "sanitizedName", ")", ")", "\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", ".", "The", "function", "name", "is", "dependent", "on", "the", "CloudFormation", "stack", "name", "so", "that", "CodePipeline", "based", "builds", "can", "properly", "create", "unique", "FunctionNAmes", "within", "an", "account" ]

[ "func", "(", "reactorFunc", "DynamoDBReactorFunc", ")", "OnDynamoEvent", "(", "ctx", "context", ".", "Context", ",", "dynamoEvent", "awsLambdaEvents", ".", "DynamoDBEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactorFunc", "(", "ctx", ",", "dynamoEvent", ")", "\n", "}" ]

[ "OnDynamoEvent", "satisfies", "the", "DynamoDBReactor", "interface" ]

[ "func", "(", "reactorFunc", "DynamoDBReactorFunc", ")", "ReactorName", "(", ")", "string", "{", "return", "runtime", ".", "FuncForPC", "(", "reflect", ".", "ValueOf", "(", "reactorFunc", ")", ".", "Pointer", "(", ")", ")", ".", "Name", "(", ")", "\n", "}" ]

[ "ReactorName", "provides", "the", "name", "of", "the", "reactor", "func" ]

[ "func", "NewDynamoDBReactor", "(", "reactor", "DynamoDBReactor", ",", "dynamoDBARN", "gocf", ".", "Stringable", ",", "startingPosition", "string", ",", "batchSize", "int64", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "reactorLambda", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "dynamoEvent", "awsLambdaEvents", ".", "DynamoDBEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactor", ".", "OnDynamoEvent", "(", "ctx", ",", "dynamoEvent", ")", "\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", ".", "EventSourceMappings", "=", "append", "(", "lambdaFn", ".", "EventSourceMappings", ",", "&", "sparta", ".", "EventSourceMapping", "{", "EventSourceArn", ":", "dynamoDBARN", ",", "StartingPosition", ":", "startingPosition", ",", "BatchSize", ":", "batchSize", ",", "}", ")", "\n", "if", "len", "(", "additionalLambdaPermissions", ")", "!=", "0", "{", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "=", "additionalLambdaPermissions", "\n", "}", "\n", "return", "lambdaFn", ",", "nil", "\n", "}" ]

[ "NewDynamoDBReactor", "returns", "an", "Kinesis", "reactor", "lambda", "function" ]

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

[ "NewBatchTaskState", "returns", "an", "initialized", "BatchTaskState" ]

[ "func", "resolveResourceRef", "(", "expr", "interface", "{", "}", ")", "(", "*", "resourceRef", ",", "error", ")", "{", "// Is there any chance it's just a string?", "typedString", ",", "typedStringOk", ":=", "expr", ".", "(", "string", ")", "\n", "if", "typedStringOk", "{", "return", "&", "resourceRef", "{", "RefType", ":", "resourceLiteral", ",", "ResourceName", ":", "typedString", ",", "}", ",", "nil", "\n", "}", "\n", "// Some type of intrinsic function?", "marshalled", ",", "marshalledErr", ":=", "json", ".", "Marshal", "(", "expr", ")", "\n", "if", "marshalledErr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "expr", ")", "\n", "}", "\n", "var", "refFunc", "gocf", ".", "RefFunc", "\n", "if", "json", ".", "Unmarshal", "(", "marshalled", ",", "&", "refFunc", ")", "==", "nil", "&&", "len", "(", "refFunc", ".", "Name", ")", "!=", "0", "{", "return", "&", "resourceRef", "{", "RefType", ":", "resourceRefFunc", ",", "ResourceName", ":", "refFunc", ".", "Name", ",", "}", ",", "nil", "\n", "}", "\n\n", "var", "getAttFunc", "gocf", ".", "GetAttFunc", "\n", "if", "json", ".", "Unmarshal", "(", "marshalled", ",", "&", "getAttFunc", ")", "==", "nil", "&&", "len", "(", "getAttFunc", ".", "Resource", ")", "!=", "0", "{", "return", "&", "resourceRef", "{", "RefType", ":", "resourceGetAttrFunc", ",", "ResourceName", ":", "getAttFunc", ".", "Resource", ",", "}", ",", "nil", "\n", "}", "\n", "// Any chance it's a string?", "var", "stringExprFunc", "gocf", ".", "StringExpr", "\n", "if", "json", ".", "Unmarshal", "(", "marshalled", ",", "&", "stringExprFunc", ")", "==", "nil", "&&", "len", "(", "stringExprFunc", ".", "Literal", ")", "!=", "0", "{", "return", "&", "resourceRef", "{", "RefType", ":", "resourceStringFunc", ",", "ResourceName", ":", "stringExprFunc", ".", "Literal", ",", "}", ",", "nil", "\n", "}", "\n\n", "// Nope", "return", "nil", ",", "nil", "\n", "}" ]

[ "resolveResourceRef", "takes", "an", "interface", "representing", "a", "dynamic", "ARN", "and", "tries", "to", "determine", "the", "CloudFormation", "resource", "name", "it", "resolves", "to" ]

[ "func", "visitResolvedEventSourceMapping", "(", "visitor", "resolvedResourceVisitor", ",", "lambdaAWSInfos", "[", "]", "*", "LambdaAWSInfo", ",", "template", "*", "gocf", ".", "Template", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "//", "// BEGIN", "// Inline closure to wrap the visitor function so that we can provide", "// specific error messages", "visitEventSourceMappingRef", ":=", "func", "(", "lambdaAWSInfo", "*", "LambdaAWSInfo", ",", "eventSourceMapping", "*", "EventSourceMapping", ",", "mappingIndex", "int", ",", "resource", "*", "resourceRef", ")", "error", "{", "annotateStatementsErr", ":=", "visitor", "(", "lambdaAWSInfo", ",", "eventSourceMapping", ",", "mappingIndex", ",", "resource", ")", "\n\n", "// Early exit?", "if", "annotateStatementsErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "annotateStatementsErr", ",", "\"", "\"", ",", "eventSourceMapping", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "//", "// END", "// Iterate through every lambda function. If there is an EventSourceMapping", "// that points to a piece of infastructure provisioned by this stack,", "// find the referred resource and supply it to the visitor", "for", "_", ",", "eachLambda", ":=", "range", "lambdaAWSInfos", "{", "for", "eachIndex", ",", "eachEventSource", ":=", "range", "eachLambda", ".", "EventSourceMappings", "{", "resourceRef", ",", "resourceRefErr", ":=", "resolveResourceRef", "(", "eachEventSource", ".", "EventSourceArn", ")", "\n", "if", "resourceRefErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "resourceRefErr", ",", "\"", "\"", ",", "eachEventSource", ")", "\n", "}", "\n\n", "// At this point everything is a string, so we need to unmarshall", "// and see if the Arn is supplied by either a Ref or a GetAttr", "// function. In those cases, we need to look around in the template", "// to go from: EventMapping -> Type -> Lambda -> LambdaIAMRole", "// so that we can add the permissions", "if", "resourceRef", "!=", "nil", "{", "annotationErr", ":=", "visitEventSourceMappingRef", "(", "eachLambda", ",", "eachEventSource", ",", "eachIndex", ",", "resourceRef", ")", "\n", "// Anything go wrong?", "if", "annotationErr", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "annotationErr", ",", "\"", "\"", ",", "eachEventSource", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "visitResolvedEventSourceMapping", "is", "a", "utility", "function", "that", "visits", "all", "the", "EventSourceMapping", "entries", "for", "the", "given", "lambdaAWSInfo", "struct" ]

[ "func", "eventSourceMappingPoliciesForResource", "(", "resource", "*", "resourceRef", ",", "template", "*", "gocf", ".", "Template", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "[", "]", "spartaIAM", ".", "PolicyStatement", ",", "error", ")", "{", "policyStatements", ":=", "[", "]", "spartaIAM", ".", "PolicyStatement", "{", "}", "\n\n", "if", "isResolvedResourceType", "(", "resource", ",", "template", ",", "\"", "\"", ",", "&", "gocf", ".", "DynamoDBTable", "{", "}", ")", "{", "policyStatements", "=", "append", "(", "policyStatements", ",", "CommonIAMStatements", ".", "DynamoDB", "...", ")", "\n", "}", "else", "if", "isResolvedResourceType", "(", "resource", ",", "template", ",", "\"", "\"", ",", "&", "gocf", ".", "KinesisStream", "{", "}", ")", "{", "policyStatements", "=", "append", "(", "policyStatements", ",", "CommonIAMStatements", ".", "Kinesis", "...", ")", "\n", "}", "else", "if", "isResolvedResourceType", "(", "resource", ",", "template", ",", "\"", "\"", ",", "&", "gocf", ".", "SQSQueue", "{", "}", ")", "{", "policyStatements", "=", "append", "(", "policyStatements", ",", "CommonIAMStatements", ".", "SQS", "...", ")", "\n", "}", "else", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "resource", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "policyStatements", ",", "nil", "\n", "}" ]

[ "eventSourceMappingPoliciesForResource", "returns", "the", "IAM", "specific", "privileges", "for", "each", "type", "of", "supported", "AWS", "Lambda", "EventSourceMapping" ]

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

[ "NewSNSTaskState", "returns", "an", "initialized", "SNSTaskState" ]

[ "func", "PublishRefOutputDecorator", "(", "keyName", "string", ",", "description", "string", ")", "sparta", ".", "TemplateDecoratorHookFunc", "{", "attrDecorator", ":=", "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", "{", "// Add the function ARN as a stack output", "template", ".", "Outputs", "[", "sanitizedKeyName", "(", "keyName", ")", "]", "=", "&", "gocf", ".", "Output", "{", "Description", ":", "description", ",", "Value", ":", "gocf", ".", "Ref", "(", "lambdaResourceName", ")", ",", "}", "\n", "return", "nil", "\n", "}", "\n\n", "return", "sparta", ".", "TemplateDecoratorHookFunc", "(", "attrDecorator", ")", "\n", "}" ]

[ "PublishRefOutputDecorator", "returns", "an", "TemplateDecoratorHookFunc", "that", "publishes", "the", "Ref", "value", "for", "a", "given", "lambda" ]

[ "func", "NewSessionWithConfig", "(", "awsConfig", "*", "aws", ".", "Config", ",", "logger", "*", "logrus", ".", "Logger", ")", "*", "session", ".", "Session", "{", "return", "NewSessionWithConfigLevel", "(", "awsConfig", ",", "aws", ".", "LogDebugWithRequestErrors", ",", "logger", ")", "\n", "}" ]

[ "NewSessionWithConfig", "returns", "an", "awsSession", "that", "includes", "the", "user", "supplied", "configuration", "information" ]

[ "func", "NewSession", "(", "logger", "*", "logrus", ".", "Logger", ")", "*", "session", ".", "Session", "{", "return", "NewSessionWithLevel", "(", "aws", ".", "LogDebugWithRequestErrors", ",", "logger", ")", "\n", "}" ]

[ "NewSession", "that", "attaches", "a", "debug", "level", "handler", "to", "all", "AWS", "requests", "from", "services", "sharing", "the", "session", "value", "." ]

[ "func", "S3ArtifactPublisherDecorator", "(", "bucket", "gocf", ".", "Stringable", ",", "key", "gocf", ".", "Stringable", ",", "data", "map", "[", "string", "]", "interface", "{", "}", ")", "sparta", ".", "ServiceDecoratorHookHandler", "{", "// Setup the CF distro", "artifactDecorator", ":=", "func", "(", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "serviceName", "string", ",", "template", "*", "gocf", ".", "Template", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "buildID", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "noop", "bool", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "// Ensure the custom action handler...", "sourceArnExpr", ":=", "gocf", ".", "Join", "(", "\"", "\"", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "bucket", ".", "String", "(", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ")", "\n\n", "configuratorResName", ",", "err", ":=", "sparta", ".", "EnsureCustomResourceHandler", "(", "serviceName", ",", "cfCustomResources", ".", "S3ArtifactPublisher", ",", "sourceArnExpr", ",", "[", "]", "string", "{", "}", ",", "template", ",", "S3Bucket", ",", "S3Key", ",", "logger", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Create the invocation of the custom action...", "s3PublishResource", ":=", "&", "cfCustomResources", ".", "S3ArtifactPublisherResource", "{", "}", "\n", "s3PublishResource", ".", "ServiceToken", "=", "gocf", ".", "GetAtt", "(", "configuratorResName", ",", "\"", "\"", ")", "\n", "s3PublishResource", ".", "Bucket", "=", "bucket", ".", "String", "(", ")", "\n", "s3PublishResource", ".", "Key", "=", "key", ".", "String", "(", ")", "\n", "s3PublishResource", ".", "Body", "=", "data", "\n\n", "// Name?", "resourceInvokerName", ":=", "sparta", ".", "CloudFormationResourceName", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "bucket", ".", "String", "(", ")", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ".", "String", "(", ")", ")", ")", "\n\n", "// Add it", "template", ".", "AddResource", "(", "resourceInvokerName", ",", "s3PublishResource", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "sparta", ".", "ServiceDecoratorHookFunc", "(", "artifactDecorator", ")", "\n", "}" ]

[ "S3ArtifactPublisherDecorator", "returns", "a", "ServiceDecoratorHookHandler", "function", "that", "publishes", "the", "given", "data", "to", "an", "S3", "Bucket", "using", "the", "given", "bucket", "and", "key", "." ]

[ "func", "NewLoggerWithFormatter", "(", "level", "string", ",", "formatter", "logrus", ".", "Formatter", ")", "(", "*", "logrus", ".", "Logger", ",", "error", ")", "{", "logger", ":=", "logrus", ".", "New", "(", ")", "\n", "// If there is an environment override, use that", "envLogLevel", ":=", "os", ".", "Getenv", "(", "envVarLogLevel", ")", "\n", "if", "envLogLevel", "!=", "\"", "\"", "{", "level", "=", "envLogLevel", "\n", "}", "\n\n", "logLevel", ",", "err", ":=", "logrus", ".", "ParseLevel", "(", "level", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "logger", ".", "Level", "=", "logLevel", "\n", "if", "nil", "!=", "formatter", "{", "logger", ".", "Formatter", "=", "formatter", "\n", "}", "\n", "logger", ".", "Out", "=", "os", ".", "Stdout", "\n", "return", "logger", ",", "nil", "\n", "}" ]

[ "NewLoggerWithFormatter", "returns", "a", "logger", "with", "the", "given", "formatter", ".", "If", "formatter", "is", "nil", "a", "TTY", "-", "aware", "formatter", "is", "used" ]

[ "func", "Delete", "(", "serviceName", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "session", ":=", "spartaAWS", ".", "NewSession", "(", "logger", ")", "\n", "awsCloudFormation", ":=", "cloudformation", ".", "New", "(", "session", ")", "\n\n", "exists", ",", "err", ":=", "spartaCF", ".", "StackExists", "(", "serviceName", ",", "session", ",", "logger", ")", "\n", "if", "nil", "!=", "err", "{", "return", "err", "\n", "}", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "exists", ",", "\"", "\"", ":", "serviceName", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "if", "exists", "{", "params", ":=", "&", "cloudformation", ".", "DeleteStackInput", "{", "StackName", ":", "aws", ".", "String", "(", "serviceName", ")", ",", "}", "\n", "resp", ",", "err", ":=", "awsCloudFormation", ".", "DeleteStack", "(", "params", ")", "\n", "if", "nil", "!=", "resp", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "resp", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "logger", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "Delete", "ensures", "that", "the", "provided", "serviceName", "is", "deleted", ".", "Failing", "to", "delete", "a", "non", "-", "existent", "service", "is", "considered", "a", "success", "." ]

[ "func", "(", "reactorFunc", "KinesisReactorFunc", ")", "OnKinesisMessage", "(", "ctx", "context", ".", "Context", ",", "kinesisEvent", "awsLambdaEvents", ".", "KinesisEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactorFunc", "(", "ctx", ",", "kinesisEvent", ")", "\n", "}" ]

[ "OnKinesisMessage", "satisfies", "the", "KinesisReactor", "interface" ]

[ "func", "NewKinesisReactor", "(", "reactor", "KinesisReactor", ",", "kinesisStream", "gocf", ".", "Stringable", ",", "startingPosition", "string", ",", "batchSize", "int64", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "reactorLambda", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "kinesisEvent", "awsLambdaEvents", ".", "KinesisEvent", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactor", ".", "OnKinesisMessage", "(", "ctx", ",", "kinesisEvent", ")", "\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", ".", "EventSourceMappings", "=", "append", "(", "lambdaFn", ".", "EventSourceMappings", ",", "&", "sparta", ".", "EventSourceMapping", "{", "EventSourceArn", ":", "kinesisStream", ",", "StartingPosition", ":", "startingPosition", ",", "BatchSize", ":", "batchSize", ",", "}", ")", "\n", "if", "len", "(", "additionalLambdaPermissions", ")", "!=", "0", "{", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "=", "additionalLambdaPermissions", "\n", "}", "\n", "return", "lambdaFn", ",", "nil", "\n", "}" ]

[ "NewKinesisReactor", "returns", "an", "Kinesis", "reactor", "lambda", "function" ]

[ "func", "(", "reactorFunc", "S3ReactorFunc", ")", "OnS3Event", "(", "ctx", "context", ".", "Context", ",", "event", "awsLambdaEvents", ".", "S3Event", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactorFunc", "(", "ctx", ",", "event", ")", "\n", "}" ]

[ "OnS3Event", "satisfies", "the", "S3Reactor", "interface" ]

[ "func", "s3NotificationPrefixBasedPermission", "(", "bucketName", "gocf", ".", "Stringable", ",", "keyPathPrefix", "string", ")", "sparta", ".", "S3Permission", "{", "permission", ":=", "sparta", ".", "S3Permission", "{", "BasePermission", ":", "sparta", ".", "BasePermission", "{", "SourceArn", ":", "bucketName", ".", "String", "(", ")", ",", "}", ",", "Events", ":", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "}", "\n\n", "if", "keyPathPrefix", "!=", "\"", "\"", "{", "permission", ".", "Filter", "=", "s3", ".", "NotificationConfigurationFilter", "{", "Key", ":", "&", "s3", ".", "KeyFilter", "{", "FilterRules", ":", "[", "]", "*", "s3", ".", "FilterRule", "{", "{", "Name", ":", "aws", ".", "String", "(", "\"", "\"", ")", ",", "Value", ":", "aws", ".", "String", "(", "keyPathPrefix", ")", ",", "}", "}", ",", "}", ",", "}", "\n", "}", "\n", "return", "permission", "\n", "}" ]

[ "s3NotificationPrefixFilter", "is", "a", "DRY", "spec", "for", "setting", "up", "a", "notification", "configuration", "filter" ]

[ "func", "NewS3Reactor", "(", "reactor", "S3Reactor", ",", "s3Bucket", "gocf", ".", "Stringable", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "return", "NewS3ScopedReactor", "(", "reactor", ",", "s3Bucket", ",", "\"", "\"", ",", "additionalLambdaPermissions", ")", "\n", "}" ]

[ "NewS3Reactor", "returns", "an", "S3", "reactor", "lambda", "function" ]

[ "func", "NewS3ScopedReactor", "(", "reactor", "S3Reactor", ",", "s3Bucket", "gocf", ".", "Stringable", ",", "keyPathPrefix", "string", ",", "additionalLambdaPermissions", "[", "]", "sparta", ".", "IAMRolePrivilege", ")", "(", "*", "sparta", ".", "LambdaAWSInfo", ",", "error", ")", "{", "reactorLambda", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "event", "awsLambdaEvents", ".", "S3Event", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "reactor", ".", "OnS3Event", "(", "ctx", ",", "event", ")", "\n", "}", "\n\n", "// Privilege must include access to the S3 bucket for GetObjectRequest", "lambdaFn", ",", "lambdaFnErr", ":=", "sparta", ".", "NewAWSLambda", "(", "reactorName", "(", "reactor", ")", ",", "reactorLambda", ",", "sparta", ".", "IAMRoleDefinition", "{", "}", ")", "\n", "if", "lambdaFnErr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "lambdaFnErr", ",", "\"", "\"", ")", "\n", "}", "\n\n", "privileges", ":=", "[", "]", "sparta", ".", "IAMRolePrivilege", "{", "{", "Actions", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "Resource", ":", "spartaCF", ".", "S3AllKeysArnForBucket", "(", "s3Bucket", ")", ",", "}", "}", "\n", "if", "len", "(", "additionalLambdaPermissions", ")", "!=", "0", "{", "privileges", "=", "append", "(", "privileges", ",", "additionalLambdaPermissions", "...", ")", "\n", "}", "\n\n", "// IAM Role privileges", "lambdaFn", ".", "RoleDefinition", ".", "Privileges", "=", "privileges", "\n\n", "// Event Triggers", "lambdaFn", ".", "Permissions", "=", "append", "(", "lambdaFn", ".", "Permissions", ",", "s3NotificationPrefixBasedPermission", "(", "s3Bucket", ",", "keyPathPrefix", ")", ")", "\n\n", "return", "lambdaFn", ",", "nil", "\n", "}" ]

[ "NewS3ScopedReactor", "returns", "an", "S3", "reactor", "lambda", "function", "scoped", "to", "the", "given", "S3", "key", "prefix" ]

[ "func", "init", "(", ")", "{", "cloudFormationStackTemplateMap", "=", "make", "(", "map", "[", "string", "]", "*", "gocf", ".", "Template", ")", "\n", "rand", ".", "Seed", "(", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ")", "\n", "}" ]

[ "var", "cacheLock", "sync", ".", "Mutex" ]

[ "func", "StackEvents", "(", "stackID", "string", ",", "eventFilterLowerBoundInclusive", "time", ".", "Time", ",", "awsSession", "*", "session", ".", "Session", ")", "(", "[", "]", "*", "cloudformation", ".", "StackEvent", ",", "error", ")", "{", "cfService", ":=", "cloudformation", ".", "New", "(", "awsSession", ")", "\n", "var", "events", "[", "]", "*", "cloudformation", ".", "StackEvent", "\n\n", "nextToken", ":=", "\"", "\"", "\n", "for", "{", "params", ":=", "&", "cloudformation", ".", "DescribeStackEventsInput", "{", "StackName", ":", "aws", ".", "String", "(", "stackID", ")", ",", "}", "\n", "if", "len", "(", "nextToken", ")", ">", "0", "{", "params", ".", "NextToken", "=", "aws", ".", "String", "(", "nextToken", ")", "\n", "}", "\n\n", "resp", ",", "err", ":=", "cfService", ".", "DescribeStackEvents", "(", "params", ")", "\n", "if", "nil", "!=", "err", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "eachEvent", ":=", "range", "resp", ".", "StackEvents", "{", "if", "eachEvent", ".", "Timestamp", ".", "Equal", "(", "eventFilterLowerBoundInclusive", ")", "||", "eachEvent", ".", "Timestamp", ".", "After", "(", "eventFilterLowerBoundInclusive", ")", "{", "events", "=", "append", "(", "events", ",", "eachEvent", ")", "\n", "}", "\n", "}", "\n", "if", "nil", "==", "resp", ".", "NextToken", "{", "break", "\n", "}", "else", "{", "nextToken", "=", "*", "resp", ".", "NextToken", "\n", "}", "\n", "}", "\n", "return", "events", ",", "nil", "\n", "}" ]

[ "StackEvents", "returns", "the", "slice", "of", "cloudformation", ".", "StackEvents", "for", "the", "given", "stackID", "or", "stackName" ]

[ "func", "WaitForStackOperationComplete", "(", "stackID", "string", ",", "pollingMessage", "string", ",", "awsCloudFormation", "*", "cloudformation", ".", "CloudFormation", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "*", "WaitForStackOperationCompleteResult", ",", "error", ")", "{", "result", ":=", "&", "WaitForStackOperationCompleteResult", "{", "}", "\n\n", "startTime", ":=", "time", ".", "Now", "(", ")", "\n\n", "// Startup a spinner...", "charSetIndex", ":=", "7", "\n", "cliSpinner", ":=", "spinner", ".", "New", "(", "spinner", ".", "CharSets", "[", "charSetIndex", "]", ",", "333", "*", "time", ".", "Millisecond", ")", "\n", "cliSpinnerStarted", ":=", "false", "\n\n", "// Poll for the current stackID state, and", "describeStacksInput", ":=", "&", "cloudformation", ".", "DescribeStacksInput", "{", "StackName", ":", "aws", ".", "String", "(", "stackID", ")", ",", "}", "\n", "for", "waitComplete", ":=", "false", ";", "!", "waitComplete", ";", "{", "// Startup the spinner if needed...", "switch", "logger", ".", "Formatter", ".", "(", "type", ")", "{", "case", "*", "logrus", ".", "JSONFormatter", ":", "{", "logger", ".", "Info", "(", "pollingMessage", ")", "\n", "}", "\n", "default", ":", "if", "!", "cliSpinnerStarted", "{", "cliSpinner", ".", "Start", "(", ")", "\n", "defer", "cliSpinner", ".", "Stop", "(", ")", "\n", "cliSpinnerStarted", "=", "true", "\n", "}", "\n", "spinnerText", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pollingMessage", ",", "humanize", ".", "Time", "(", "startTime", ")", ")", "\n", "cliSpinner", ".", "Suffix", "=", "spinnerText", "\n", "}", "\n\n", "// Then sleep and figure out if things are done...", "sleepDuration", ":=", "time", ".", "Duration", "(", "11", "+", "rand", ".", "Int31n", "(", "13", ")", ")", "*", "time", ".", "Second", "\n", "time", ".", "Sleep", "(", "sleepDuration", ")", "\n\n", "describeStacksOutput", ",", "err", ":=", "awsCloudFormation", ".", "DescribeStacks", "(", "describeStacksInput", ")", "\n", "if", "nil", "!=", "err", "{", "// TODO - add retry iff we're RateExceeded due to collective access", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "describeStacksOutput", ".", "Stacks", ")", "<=", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "describeStacksInput", ".", "StackName", ")", "\n", "}", "\n", "result", ".", "stackInfo", "=", "describeStacksOutput", ".", "Stacks", "[", "0", "]", "\n", "switch", "*", "(", "result", ".", "stackInfo", ")", ".", "StackStatus", "{", "case", "cloudformation", ".", "StackStatusCreateComplete", ",", "cloudformation", ".", "StackStatusUpdateComplete", ":", "result", ".", "operationSuccessful", "=", "true", "\n", "waitComplete", "=", "true", "\n", "case", "// Include DeleteComplete as new provisions will automatically rollback", "cloudformation", ".", "StackStatusDeleteComplete", ",", "cloudformation", ".", "StackStatusCreateFailed", ",", "cloudformation", ".", "StackStatusDeleteFailed", ",", "cloudformation", ".", "StackStatusRollbackFailed", ",", "cloudformation", ".", "StackStatusRollbackComplete", ",", "cloudformation", ".", "StackStatusUpdateRollbackComplete", ":", "result", ".", "operationSuccessful", "=", "false", "\n", "waitComplete", "=", "true", "\n", "default", ":", "// If this is JSON output, just do the normal thing", "// NOP", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "WaitForStackOperationComplete", "is", "a", "blocking", "polling", "based", "call", "that", "periodically", "fetches", "the", "stackID", "set", "of", "events", "and", "uses", "the", "state", "value", "to", "determine", "if", "an", "operation", "is", "complete" ]

[ "func", "UploadTemplate", "(", "serviceName", "string", ",", "cfTemplate", "*", "gocf", ".", "Template", ",", "s3Bucket", "string", ",", "s3KeyName", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "s3KeyName", ",", "\"", "\"", ":", "s3Bucket", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "s3Uploader", ":=", "s3manager", ".", "NewUploader", "(", "awsSession", ")", "\n\n", "// Serialize the template and upload it", "cfTemplateJSON", ",", "err", ":=", "json", ".", "Marshal", "(", "cfTemplate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Upload the actual CloudFormation template to S3 to maximize the template", "// size limit", "// Ref: http://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html", "contentBody", ":=", "string", "(", "cfTemplateJSON", ")", "\n", "uploadInput", ":=", "&", "s3manager", ".", "UploadInput", "{", "Bucket", ":", "&", "s3Bucket", ",", "Key", ":", "&", "s3KeyName", ",", "ContentType", ":", "aws", ".", "String", "(", "\"", "\"", ")", ",", "Body", ":", "strings", ".", "NewReader", "(", "contentBody", ")", ",", "}", "\n", "templateUploadResult", ",", "templateUploadResultErr", ":=", "s3Uploader", ".", "Upload", "(", "uploadInput", ")", "\n", "if", "nil", "!=", "templateUploadResultErr", "{", "return", "\"", "\"", ",", "templateUploadResultErr", "\n", "}", "\n\n", "// Be transparent", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "templateUploadResult", ".", "Location", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "templateUploadResult", ".", "Location", ",", "nil", "\n", "}" ]

[ "UploadTemplate", "marshals", "the", "given", "cfTemplate", "and", "uploads", "it", "to", "the", "supplied", "bucket", "using", "the", "given", "KeyName" ]

[ "func", "StackExists", "(", "stackNameOrID", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "bool", ",", "error", ")", "{", "cf", ":=", "cloudformation", ".", "New", "(", "awsSession", ")", "\n\n", "describeStacksInput", ":=", "&", "cloudformation", ".", "DescribeStacksInput", "{", "StackName", ":", "aws", ".", "String", "(", "stackNameOrID", ")", ",", "}", "\n", "describeStacksOutput", ",", "err", ":=", "cf", ".", "DescribeStacks", "(", "describeStacksInput", ")", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "describeStacksOutput", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "exists", ":=", "false", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "err", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// If the stack doesn't exist, then no worries", "if", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "exists", "=", "false", "\n", "}", "else", "{", "return", "false", ",", "err", "\n", "}", "\n", "}", "else", "{", "exists", "=", "true", "\n", "}", "\n", "return", "exists", ",", "nil", "\n", "}" ]

[ "StackExists", "returns", "whether", "the", "given", "stackName", "or", "stackID", "currently", "exists" ]

[ "func", "CreateStackChangeSet", "(", "changeSetRequestName", "string", ",", "serviceName", "string", ",", "cfTemplate", "*", "gocf", ".", "Template", ",", "templateURL", "string", ",", "awsTags", "[", "]", "*", "cloudformation", ".", "Tag", ",", "awsCloudFormation", "*", "cloudformation", ".", "CloudFormation", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "*", "cloudformation", ".", "DescribeChangeSetOutput", ",", "error", ")", "{", "capabilities", ":=", "stackCapabilities", "(", "cfTemplate", ")", "\n", "changeSetInput", ":=", "&", "cloudformation", ".", "CreateChangeSetInput", "{", "Capabilities", ":", "capabilities", ",", "ChangeSetName", ":", "aws", ".", "String", "(", "changeSetRequestName", ")", ",", "ClientToken", ":", "aws", ".", "String", "(", "changeSetRequestName", ")", ",", "Description", ":", "aws", ".", "String", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "serviceName", ")", ")", ",", "StackName", ":", "aws", ".", "String", "(", "serviceName", ")", ",", "TemplateURL", ":", "aws", ".", "String", "(", "templateURL", ")", ",", "}", "\n", "if", "len", "(", "awsTags", ")", "!=", "0", "{", "changeSetInput", ".", "Tags", "=", "awsTags", "\n", "}", "\n", "_", ",", "changeSetError", ":=", "awsCloudFormation", ".", "CreateChangeSet", "(", "changeSetInput", ")", "\n", "if", "nil", "!=", "changeSetError", "{", "return", "nil", ",", "changeSetError", "\n", "}", "\n\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "serviceName", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "describeChangeSetInput", ":=", "cloudformation", ".", "DescribeChangeSetInput", "{", "ChangeSetName", ":", "aws", ".", "String", "(", "changeSetRequestName", ")", ",", "StackName", ":", "aws", ".", "String", "(", "serviceName", ")", ",", "}", "\n\n", "var", "describeChangeSetOutput", "*", "cloudformation", ".", "DescribeChangeSetOutput", "\n\n", "// Loop, with a total timeout of 3 minutes", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "changeSetStabilized", ":=", "false", "\n", "for", "!", "changeSetStabilized", "{", "sleepDuration", ":=", "cloudformationPollingDelay", "(", ")", "\n", "time", ".", "Sleep", "(", "sleepDuration", ")", "\n\n", "changeSetOutput", ",", "describeChangeSetError", ":=", "awsCloudFormation", ".", "DescribeChangeSet", "(", "&", "describeChangeSetInput", ")", "\n\n", "if", "nil", "!=", "describeChangeSetError", "{", "return", "nil", ",", "describeChangeSetError", "\n", "}", "\n", "describeChangeSetOutput", "=", "changeSetOutput", "\n", "// The current status of the change set, such as CREATE_IN_PROGRESS, CREATE_COMPLETE,", "// or FAILED.", "if", "nil", "!=", "describeChangeSetOutput", "{", "switch", "*", "describeChangeSetOutput", ".", "Status", "{", "case", "\"", "\"", ":", "// If this has taken more than 3 minutes, then that's an error", "elapsedTime", ":=", "time", ".", "Since", "(", "startTime", ")", "\n", "if", "elapsedTime", ">", "cloudformationPollingTimeout", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "elapsedTime", ".", "String", "(", ")", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "changeSetStabilized", "=", "true", "\n", "case", "\"", "\"", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "describeChangeSetOutput", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "describeChangeSetOutput", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "//////////////////////////////////////////////////////////////////////////////", "// If there aren't any changes, then skip it...", "if", "len", "(", "describeChangeSetOutput", ".", "Changes", ")", "<=", "0", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "serviceName", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "// Delete it...", "_", ",", "deleteChangeSetResultErr", ":=", "DeleteChangeSet", "(", "serviceName", ",", "changeSetRequestName", ",", "awsCloudFormation", ")", "\n", "return", "nil", ",", "deleteChangeSetResultErr", "\n", "}", "\n", "return", "describeChangeSetOutput", ",", "nil", "\n", "}" ]

[ "CreateStackChangeSet", "returns", "the", "DescribeChangeSetOutput", "for", "a", "given", "stack", "transformation" ]

[ "func", "DeleteChangeSet", "(", "stackName", "string", ",", "changeSetRequestName", "string", ",", "awsCloudFormation", "*", "cloudformation", ".", "CloudFormation", ")", "(", "*", "cloudformation", ".", "DeleteChangeSetOutput", ",", "error", ")", "{", "// Delete request...", "deleteChangeSetInput", ":=", "cloudformation", ".", "DeleteChangeSetInput", "{", "ChangeSetName", ":", "aws", ".", "String", "(", "changeSetRequestName", ")", ",", "StackName", ":", "aws", ".", "String", "(", "stackName", ")", ",", "}", "\n\n", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "for", "{", "elapsedTime", ":=", "time", ".", "Since", "(", "startTime", ")", "\n\n", "deleteChangeSetResults", ",", "deleteChangeSetResultErr", ":=", "awsCloudFormation", ".", "DeleteChangeSet", "(", "&", "deleteChangeSetInput", ")", "\n", "if", "nil", "==", "deleteChangeSetResultErr", "{", "return", "deleteChangeSetResults", ",", "nil", "\n", "}", "else", "if", "strings", ".", "Contains", "(", "deleteChangeSetResultErr", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "if", "elapsedTime", ">", "cloudformationPollingTimeout", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "elapsedTime", ".", "String", "(", ")", ")", "\n", "}", "\n", "sleepDuration", ":=", "cloudformationPollingDelay", "(", ")", "\n", "time", ".", "Sleep", "(", "sleepDuration", ")", "\n", "}", "else", "{", "return", "nil", ",", "deleteChangeSetResultErr", "\n", "}", "\n", "}", "\n", "}" ]

[ "DeleteChangeSet", "is", "a", "utility", "function", "that", "attempts", "to", "delete", "an", "existing", "CloudFormation", "change", "set", "with", "a", "bit", "of", "retry", "logic", "in", "case", "of", "EC" ]

[ "func", "ListStacks", "(", "session", "*", "session", ".", "Session", ",", "maxReturned", "int", ",", "stackFilters", "...", "string", ")", "(", "[", "]", "*", "cloudformation", ".", "StackSummary", ",", "error", ")", "{", "listStackInput", ":=", "&", "cloudformation", ".", "ListStacksInput", "{", "StackStatusFilter", ":", "[", "]", "*", "string", "{", "}", ",", "}", "\n", "for", "_", ",", "eachFilter", ":=", "range", "stackFilters", "{", "listStackInput", ".", "StackStatusFilter", "=", "append", "(", "listStackInput", ".", "StackStatusFilter", ",", "aws", ".", "String", "(", "eachFilter", ")", ")", "\n", "}", "\n", "cloudformationSvc", ":=", "cloudformation", ".", "New", "(", "session", ")", "\n", "accumulator", ":=", "[", "]", "*", "cloudformation", ".", "StackSummary", "{", "}", "\n", "for", "{", "listResult", ",", "listResultErr", ":=", "cloudformationSvc", ".", "ListStacks", "(", "listStackInput", ")", "\n", "if", "listResultErr", "!=", "nil", "{", "return", "nil", ",", "listResultErr", "\n", "}", "\n", "accumulator", "=", "append", "(", "accumulator", ",", "listResult", ".", "StackSummaries", "...", ")", "\n", "if", "len", "(", "accumulator", ")", ">=", "maxReturned", "||", "listResult", ".", "NextToken", "==", "nil", "{", "return", "accumulator", ",", "nil", "\n", "}", "\n", "listStackInput", ".", "NextToken", "=", "listResult", ".", "NextToken", "\n", "}", "\n", "}" ]

[ "ListStacks", "returns", "a", "slice", "of", "stacks", "that", "meet", "the", "given", "filter", "." ]

[ "func", "EnsureCustomResourceHandler", "(", "serviceName", "string", ",", "customResourceCloudFormationTypeName", "string", ",", "sourceArn", "*", "gocf", ".", "StringExpr", ",", "dependsOn", "[", "]", "string", ",", "template", "*", "gocf", ".", "Template", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "// Ok, we need a way to round trip this type as the AWS lambda function name.", "// The problem with this is that the full CustomResource::Type value isn't an", "// AWS Lambda friendly name. We want to do this so that in the AWS lambda handler", "// we can attempt to instantiate a new CustomAction resource, typecast it to a", "// CustomResourceCommand type and then apply the workflow. Doing this means", "// we can decouple the lookup logic for custom resource...", "resource", ":=", "gocf", ".", "NewResourceByType", "(", "customResourceCloudFormationTypeName", ")", "\n", "if", "resource", "==", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "customResourceCloudFormationTypeName", ")", "\n", "}", "\n", "command", ",", "commandOk", ":=", "resource", ".", "(", "cfCustomResources", ".", "CustomResourceCommand", ")", "\n", "if", "!", "commandOk", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "customResourceCloudFormationTypeName", ")", "\n", "}", "\n\n", "// Prefix", "commandType", ":=", "reflect", ".", "TypeOf", "(", "command", ")", "\n", "customResourceTypeName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "command", ")", "\n", "prefixName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "serviceName", ")", "\n", "subscriberHandlerName", ":=", "CloudFormationResourceName", "(", "prefixName", ",", "customResourceTypeName", ")", "\n\n", "//////////////////////////////////////////////////////////////////////////////", "// IAM Role definition", "iamResourceName", ",", "err", ":=", "ensureIAMRoleForCustomResource", "(", "command", ",", "sourceArn", ",", "template", ",", "logger", ")", "\n", "if", "nil", "!=", "err", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "command", ")", "\n", "}", "\n", "iamRoleRef", ":=", "gocf", ".", "GetAtt", "(", "iamResourceName", ",", "\"", "\"", ")", "\n", "_", ",", "exists", ":=", "template", ".", "Resources", "[", "subscriberHandlerName", "]", "\n", "if", "exists", "{", "return", "subscriberHandlerName", ",", "nil", "\n", "}", "\n\n", "// Encode the resourceType...", "configuratorDescription", ":=", "customResourceDescription", "(", "serviceName", ",", "customResourceTypeName", ")", "\n\n", "//////////////////////////////////////////////////////////////////////////////", "// Custom Resource Lambda Handler", "// Insert it into the template resources...", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "customResourceCloudFormationTypeName", ",", "\"", "\"", ":", "customResourceTypeName", ",", "\"", "\"", ":", "commandType", ".", "String", "(", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "// Don't forget the discovery info...", "userDispatchMap", ":=", "map", "[", "string", "]", "*", "gocf", ".", "StringExpr", "{", "EnvVarCustomResourceTypeName", ":", "gocf", ".", "String", "(", "customResourceCloudFormationTypeName", ")", ",", "}", "\n", "lambdaEnv", ",", "lambdaEnvErr", ":=", "lambdaFunctionEnvironment", "(", "userDispatchMap", ",", "customResourceTypeName", ",", "nil", ",", "logger", ")", "\n", "if", "lambdaEnvErr", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "lambdaEnvErr", ",", "\"", "\"", ")", "\n", "}", "\n", "// Add the special key that's the custom resource type name", "customResourceHandlerDef", ":=", "gocf", ".", "LambdaFunction", "{", "Code", ":", "&", "gocf", ".", "LambdaFunctionCode", "{", "S3Bucket", ":", "gocf", ".", "String", "(", "S3Bucket", ")", ",", "S3Key", ":", "gocf", ".", "String", "(", "S3Key", ")", ",", "}", ",", "Runtime", ":", "gocf", ".", "String", "(", "GoLambdaVersion", ")", ",", "Description", ":", "gocf", ".", "String", "(", "configuratorDescription", ")", ",", "Handler", ":", "gocf", ".", "String", "(", "SpartaBinaryName", ")", ",", "Role", ":", "iamRoleRef", ",", "Timeout", ":", "gocf", ".", "Integer", "(", "30", ")", ",", "// Let AWS assign a name here...", "//\t\tFunctionName: lambdaFunctionName.String(),", "// DISPATCH INFORMATION", "Environment", ":", "lambdaEnv", ",", "}", "\n\n", "cfResource", ":=", "template", ".", "AddResource", "(", "subscriberHandlerName", ",", "customResourceHandlerDef", ")", "\n", "if", "nil", "!=", "dependsOn", "&&", "(", "len", "(", "dependsOn", ")", ">", "0", ")", "{", "cfResource", ".", "DependsOn", "=", "append", "(", "cfResource", ".", "DependsOn", ",", "dependsOn", "...", ")", "\n", "}", "\n", "return", "subscriberHandlerName", ",", "nil", "\n", "}" ]

[ "EnsureCustomResourceHandler", "handles", "ensuring", "that", "the", "custom", "resource", "responsible", "for", "supporting", "the", "operation", "is", "actually", "part", "of", "this", "stack", ".", "The", "returned", "string", "value", "is", "the", "CloudFormation", "resource", "name", "that", "implements", "this", "resource", ".", "The", "customResourceCloudFormationTypeName", "must", "have", "already", "been", "registered", "with", "gocf", "and", "implement", "the", "resources", ".", "CustomResourceCommand", "interface" ]

[ "func", "RunOSCommand", "(", "cmd", "*", "exec", ".", "Cmd", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "cmd", ".", "Args", ",", "\"", "\"", ":", "cmd", ".", "Dir", ",", "\"", "\"", ":", "cmd", ".", "Path", ",", "\"", "\"", ":", "cmd", ".", "Env", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "outputWriter", ":=", "logger", ".", "Writer", "(", ")", "\n", "cmdErr", ":=", "RunAndCaptureOSCommand", "(", "cmd", ",", "outputWriter", ",", "outputWriter", ",", "logger", ")", "\n", "closeErr", ":=", "outputWriter", ".", "Close", "(", ")", "\n", "if", "closeErr", "!=", "nil", "{", "logger", ".", "WithField", "(", "\"", "\"", ",", "closeErr", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "cmdErr", "\n", "}" ]

[ "RunOSCommand", "properly", "executes", "a", "system", "command", "and", "writes", "the", "output", "to", "the", "provided", "logger" ]

[ "func", "RunAndCaptureOSCommand", "(", "cmd", "*", "exec", ".", "Cmd", ",", "stdoutWriter", "io", ".", "Writer", ",", "stderrWriter", "io", ".", "Writer", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "cmd", ".", "Args", ",", "\"", "\"", ":", "cmd", ".", "Dir", ",", "\"", "\"", ":", "cmd", ".", "Path", ",", "\"", "\"", ":", "cmd", ".", "Env", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "cmd", ".", "Stdout", "=", "stdoutWriter", "\n", "cmd", ".", "Stderr", "=", "stderrWriter", "\n", "return", "cmd", ".", "Run", "(", ")", "\n\n", "}" ]

[ "RunAndCaptureOSCommand", "runs", "the", "given", "command", "and", "captures", "the", "stdout", "and", "stderr" ]

[ "func", "DashboardDecorator", "(", "lambdaAWSInfo", "[", "]", "*", "sparta", ".", "LambdaAWSInfo", ",", "timeSeriesPeriod", "int", ")", "sparta", ".", "ServiceDecoratorHookFunc", "{", "return", "func", "(", "context", "map", "[", "string", "]", "interface", "{", "}", ",", "serviceName", "string", ",", "cfTemplate", "*", "gocf", ".", "Template", ",", "S3Bucket", "string", ",", "S3Key", "string", ",", "buildID", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "noop", "bool", ",", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "lambdaFunctions", ":=", "make", "(", "[", "]", "*", "LambdaTemplateData", ",", "len", "(", "lambdaAWSInfo", ")", ")", "\n", "for", "index", ",", "eachLambda", ":=", "range", "lambdaAWSInfo", "{", "lambdaFunctions", "[", "index", "]", "=", "&", "LambdaTemplateData", "{", "LambdaAWSInfo", ":", "eachLambda", ",", "ResourceName", ":", "eachLambda", ".", "LogicalResourceName", "(", ")", ",", "}", "\n", "}", "\n", "dashboardTemplateData", ":=", "&", "DashboardTemplateData", "{", "SpartaVersion", ":", "sparta", ".", "SpartaVersion", ",", "SpartaGitHash", ":", "sparta", ".", "SpartaGitHash", ",", "LambdaFunctions", ":", "lambdaFunctions", ",", "TimeSeriesPeriod", ":", "timeSeriesPeriod", ",", "Extents", ":", "widgetExtents", "{", "HeaderWidthUnits", ":", "headerWidthUnits", ",", "HeaderHeightUnits", ":", "headerHeightUnits", ",", "MetricWidthUnits", ":", "metricWidthUnits", ",", "MetricHeightUnits", ":", "metricHeightUnits", ",", "MetricsPerRow", ":", "metricsPerRow", ",", "}", ",", "}", "\n\n", "dashboardTmpl", ",", "dashboardTmplErr", ":=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Delims", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Funcs", "(", "templateFuncMap", ")", ".", "Parse", "(", "dashboardTemplate", ")", "\n", "if", "nil", "!=", "dashboardTmplErr", "{", "return", "dashboardTmplErr", "\n", "}", "\n", "var", "templateResults", "bytes", ".", "Buffer", "\n", "evalResultErr", ":=", "dashboardTmpl", ".", "Execute", "(", "&", "templateResults", ",", "dashboardTemplateData", ")", "\n", "if", "nil", "!=", "evalResultErr", "{", "return", "evalResultErr", "\n", "}", "\n\n", "// Raw template output", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "templateResults", ".", "String", "(", ")", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Replace any multiline backtick newlines with nothing, since otherwise", "// the Fn::Joined JSON will be malformed", "reReplace", ",", "reReplaceErr", ":=", "regexp", ".", "Compile", "(", "\"", "\\n", "\"", ")", "\n", "if", "nil", "!=", "reReplaceErr", "{", "return", "reReplaceErr", "\n", "}", "\n", "escapedBytes", ":=", "reReplace", ".", "ReplaceAll", "(", "templateResults", ".", "Bytes", "(", ")", ",", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "string", "(", "escapedBytes", ")", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Super, now parse this into an Fn::Join representation", "// so that we can get inline expansion of the AWS pseudo params", "templateReader", ":=", "bytes", ".", "NewReader", "(", "escapedBytes", ")", "\n", "templateExpr", ",", "templateExprErr", ":=", "spartaCF", ".", "ConvertToTemplateExpression", "(", "templateReader", ",", "nil", ")", "\n", "if", "nil", "!=", "templateExprErr", "{", "return", "templateExprErr", "\n", "}", "\n\n", "dashboardResource", ":=", "gocf", ".", "CloudWatchDashboard", "{", "}", "\n", "dashboardResource", ".", "DashboardBody", "=", "templateExpr", "\n", "dashboardResource", ".", "DashboardName", "=", "gocf", ".", "String", "(", "serviceName", ")", "\n", "dashboardName", ":=", "sparta", ".", "CloudFormationResourceName", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "cfTemplate", ".", "AddResource", "(", "dashboardName", ",", "&", "dashboardResource", ")", "\n\n", "// Add the output", "cfTemplate", ".", "Outputs", "[", "OutputDashboardURL", "]", "=", "&", "gocf", ".", "Output", "{", "Description", ":", "\"", "\"", ",", "Value", ":", "gocf", ".", "Join", "(", "\"", "\"", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "Ref", "(", "\"", "\"", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "Ref", "(", "\"", "\"", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "Ref", "(", "dashboardName", ")", ")", ",", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "DashboardDecorator", "returns", "a", "ServiceDecoratorHook", "function", "that", "can", "be", "attached", "the", "workflow", "to", "create", "a", "dashboard" ]

[ "func", "(", "command", "S3ArtifactPublisherResource", ")", "Create", "(", "awsSession", "*", "session", ".", "Session", ",", "event", "*", "CloudFormationLambdaEvent", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "unmarshalErr", ":=", "json", ".", "Unmarshal", "(", "event", ".", "ResourceProperties", ",", "&", "command", ")", "\n", "if", "unmarshalErr", "!=", "nil", "{", "return", "nil", ",", "unmarshalErr", "\n", "}", "\n", "mapData", ",", "mapDataErr", ":=", "json", ".", "Marshal", "(", "command", ".", "Body", ")", "\n", "if", "mapDataErr", "!=", "nil", "{", "return", "nil", ",", "mapDataErr", "\n", "}", "\n", "itemInput", ":=", "bytes", ".", "NewReader", "(", "mapData", ")", "\n", "s3PutObjectParams", ":=", "&", "s3", ".", "PutObjectInput", "{", "Body", ":", "itemInput", ",", "Bucket", ":", "aws", ".", "String", "(", "command", ".", "Bucket", ".", "Literal", ")", ",", "Key", ":", "aws", ".", "String", "(", "command", ".", "Key", ".", "Literal", ")", ",", "}", "\n", "s3Svc", ":=", "s3", ".", "New", "(", "awsSession", ")", "\n", "s3Response", ",", "s3ResponseErr", ":=", "s3Svc", ".", "PutObject", "(", "s3PutObjectParams", ")", "\n", "if", "s3ResponseErr", "!=", "nil", "{", "return", "nil", ",", "s3ResponseErr", "\n", "}", "\n", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "s3Response", ".", "VersionId", ",", "}", ",", "nil", "\n", "}" ]

[ "Create", "implements", "the", "S3", "create", "operation" ]

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

[ "Update", "implements", "the", "S3", "update", "operation" ]

[ "func", "(", "command", "S3ArtifactPublisherResource", ")", "Delete", "(", "awsSession", "*", "session", ".", "Session", ",", "event", "*", "CloudFormationLambdaEvent", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "unmarshalErr", ":=", "json", ".", "Unmarshal", "(", "event", ".", "ResourceProperties", ",", "&", "command", ")", "\n", "if", "unmarshalErr", "!=", "nil", "{", "return", "nil", ",", "unmarshalErr", "\n", "}", "\n", "s3DeleteObjectParams", ":=", "&", "s3", ".", "DeleteObjectInput", "{", "Bucket", ":", "aws", ".", "String", "(", "command", ".", "Bucket", ".", "Literal", ")", ",", "Key", ":", "aws", ".", "String", "(", "command", ".", "Key", ".", "Literal", ")", ",", "}", "\n", "s3Svc", ":=", "s3", ".", "New", "(", "awsSession", ")", "\n", "_", ",", "s3ResponseErr", ":=", "s3Svc", ".", "DeleteObject", "(", "s3DeleteObjectParams", ")", "\n", "if", "s3ResponseErr", "!=", "nil", "{", "return", "nil", ",", "s3ResponseErr", "\n", "}", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "command", ".", "Bucket", ".", "Literal", ",", "\"", "\"", ":", "command", ".", "Key", ".", "Literal", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Delete", "implements", "the", "S3", "delete", "operation" ]

[ "func", "CreateS3RollbackFunc", "(", "awsSession", "*", "session", ".", "Session", ",", "s3ArtifactURL", "string", ")", "RollbackFunction", "{", "return", "func", "(", "logger", "*", "logrus", ".", "Logger", ")", "error", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "s3ArtifactURL", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "artifactURLParts", ",", "artifactURLPartsErr", ":=", "url", ".", "Parse", "(", "s3ArtifactURL", ")", "\n", "if", "nil", "!=", "artifactURLPartsErr", "{", "return", "artifactURLPartsErr", "\n", "}", "\n", "// Bucket is the first component", "s3Bucket", ":=", "strings", ".", "Split", "(", "artifactURLParts", ".", "Host", ",", "\"", "\"", ")", "[", "0", "]", "\n", "s3Client", ":=", "s3", ".", "New", "(", "awsSession", ")", "\n", "params", ":=", "&", "s3", ".", "DeleteObjectInput", "{", "Bucket", ":", "aws", ".", "String", "(", "s3Bucket", ")", ",", "Key", ":", "aws", ".", "String", "(", "artifactURLParts", ".", "Path", ")", ",", "}", "\n", "versionID", ":=", "artifactURLParts", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "versionID", "!=", "\"", "\"", "{", "params", ".", "VersionId", "=", "aws", ".", "String", "(", "versionID", ")", "\n", "}", "\n", "_", ",", "err", ":=", "s3Client", ".", "DeleteObject", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "err", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}" ]

[ "CreateS3RollbackFunc", "creates", "an", "S3", "rollback", "function", "that", "attempts", "to", "delete", "a", "previously", "uploaded", "item", ".", "Note", "that", "s3ArtifactURL", "may", "include", "a", "versionId", "query", "arg", "to", "denote", "the", "specific", "version", "to", "delete", "." ]

[ "func", "UploadLocalFileToS3", "(", "localPath", "string", ",", "awsSession", "*", "session", ".", "Session", ",", "S3Bucket", "string", ",", "S3KeyName", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "// Then do the actual work", "/* #nosec */", "reader", ",", "err", ":=", "os", ".", "Open", "(", "localPath", ")", "\n", "if", "nil", "!=", "err", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "uploadInput", ":=", "&", "s3manager", ".", "UploadInput", "{", "Bucket", ":", "&", "S3Bucket", ",", "Key", ":", "&", "S3KeyName", ",", "ContentType", ":", "aws", ".", "String", "(", "mime", ".", "TypeByExtension", "(", "path", ".", "Ext", "(", "localPath", ")", ")", ")", ",", "Body", ":", "reader", ",", "}", "\n", "// If we can get the current working directory, let's try and strip", "// it from the path just to keep the log statement a bit shorter", "logPath", ":=", "localPath", "\n", "cwd", ",", "cwdErr", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "cwdErr", "==", "nil", "{", "logPath", "=", "strings", ".", "TrimPrefix", "(", "logPath", ",", "cwd", ")", "\n", "if", "logPath", "!=", "localPath", "{", "logPath", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "logPath", ")", "\n", "}", "\n", "}", "\n", "// Binary size", "stat", ",", "err", ":=", "os", ".", "Stat", "(", "localPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "localPath", ")", "\n", "}", "\n", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "logPath", ",", "\"", "\"", ":", "S3Bucket", ",", "\"", "\"", ":", "S3KeyName", ",", "\"", "\"", ":", "humanize", ".", "Bytes", "(", "uint64", "(", "stat", ".", "Size", "(", ")", ")", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "uploader", ":=", "s3manager", ".", "NewUploader", "(", "awsSession", ")", "\n", "result", ",", "err", ":=", "uploader", ".", "Upload", "(", "uploadInput", ")", "\n", "if", "nil", "!=", "err", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "result", ".", "VersionID", "!=", "nil", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "result", ".", "Location", ",", "\"", "\"", ":", "string", "(", "*", "result", ".", "VersionID", ")", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "else", "{", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "result", ".", "Location", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "locationURL", ":=", "result", ".", "Location", "\n", "if", "nil", "!=", "result", ".", "VersionID", "{", "// http://docs.aws.amazon.com/AmazonS3/latest/dev/RetrievingObjectVersions.html", "locationURL", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "locationURL", ",", "string", "(", "*", "result", ".", "VersionID", ")", ")", "\n", "}", "\n", "return", "locationURL", ",", "nil", "\n", "}" ]

[ "UploadLocalFileToS3", "takes", "a", "local", "path", "and", "uploads", "the", "content", "at", "localPath", "to", "the", "given", "S3Bucket", "and", "KeyPrefix", ".", "The", "final", "S3", "keyname", "is", "the", "S3KeyPrefix", "+", "the", "basename", "of", "the", "localPath", "." ]

[ "func", "BucketVersioningEnabled", "(", "awsSession", "*", "session", ".", "Session", ",", "S3Bucket", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "bool", ",", "error", ")", "{", "s3Svc", ":=", "s3", ".", "New", "(", "awsSession", ")", "\n", "params", ":=", "&", "s3", ".", "GetBucketVersioningInput", "{", "Bucket", ":", "aws", ".", "String", "(", "S3Bucket", ")", ",", "// Required", "}", "\n", "versioningEnabled", ":=", "false", "\n", "resp", ",", "err", ":=", "s3Svc", ".", "GetBucketVersioning", "(", "params", ")", "\n", "if", "err", "==", "nil", "&&", "resp", "!=", "nil", "&&", "resp", ".", "Status", "!=", "nil", "{", "// What's the versioning policy?", "logger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "*", "resp", ",", "\"", "\"", ":", "S3Bucket", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "versioningEnabled", "=", "(", "strings", ".", "ToLower", "(", "*", "resp", ".", "Status", ")", "==", "\"", "\"", ")", "\n", "}", "\n", "return", "versioningEnabled", ",", "err", "\n", "}" ]

[ "BucketVersioningEnabled", "determines", "if", "a", "given", "S3", "bucket", "has", "object", "versioning", "enabled", "." ]

[ "func", "BucketRegion", "(", "awsSession", "*", "session", ".", "Session", ",", "S3Bucket", "string", ",", "logger", "*", "logrus", ".", "Logger", ")", "(", "string", ",", "error", ")", "{", "regionHint", ":=", "\"", "\"", "\n", "if", "awsSession", ".", "Config", ".", "Region", "!=", "nil", "{", "regionHint", "=", "*", "awsSession", ".", "Config", ".", "Region", "\n", "}", "\n", "awsContext", ":=", "aws", ".", "BackgroundContext", "(", ")", "\n", "return", "s3manager", ".", "GetBucketRegion", "(", "awsContext", ",", "awsSession", ",", "S3Bucket", ",", "regionHint", ")", "\n", "}" ]

[ "BucketRegion", "returns", "the", "AWS", "region", "that", "hosts", "the", "bucket" ]

[ "func", "NewSageMakerTrainingJob", "(", "stateName", "string", ",", "parameters", "SageMakerTrainingJobParameters", ")", "*", "SageMakerTrainingJob", "{", "smtj", ":=", "&", "SageMakerTrainingJob", "{", "BaseTask", ":", "BaseTask", "{", "baseInnerState", ":", "baseInnerState", "{", "name", ":", "stateName", ",", "id", ":", "rand", ".", "Int63", "(", ")", ",", "}", ",", "}", ",", "parameters", ":", "parameters", ",", "}", "\n", "return", "smtj", "\n", "}" ]

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

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

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

[ "func", "codeDeployLambdaUpdateDecorator", "(", "updateType", "string", ",", "codeDeployApplicationName", "string", ",", "codeDeployRoleName", "string", ")", "sparta", ".", "TemplateDecorator", "{", "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", "{", "safeDeployResourceName", ":=", "func", "(", "resType", "string", ")", "string", "{", "return", "sparta", ".", "CloudFormationResourceName", "(", "serviceName", ",", "lambdaResourceName", ",", "resType", ")", "\n", "}", "\n", "// Create the AWS::Lambda::Version, with DeletionPolicy=Retain", "versionResourceName", ":=", "safeDeployResourceName", "(", "\"", "\"", "+", "buildID", ")", "\n", "versionResource", ":=", "&", "gocf", ".", "LambdaVersion", "{", "FunctionName", ":", "gocf", ".", "Ref", "(", "lambdaResourceName", ")", ".", "String", "(", ")", ",", "}", "\n", "entry", ":=", "template", ".", "AddResource", "(", "versionResourceName", ",", "versionResource", ")", "\n", "entry", ".", "DeletionPolicy", "=", "\"", "\"", "\n\n", "// Create the AWS::CodeDeploy::DeploymentGroup entry that includes a reference", "// to the IAM role", "codeDeploymentGroupResourceName", ":=", "safeDeployResourceName", "(", "\"", "\"", ")", "\n", "codeDeploymentGroup", ":=", "&", "gocf", ".", "CodeDeployDeploymentGroup", "{", "ApplicationName", ":", "gocf", ".", "Ref", "(", "codeDeployApplicationName", ")", ".", "String", "(", ")", ",", "AutoRollbackConfiguration", ":", "&", "gocf", ".", "CodeDeployDeploymentGroupAutoRollbackConfiguration", "{", "Enabled", ":", "gocf", ".", "Bool", "(", "true", ")", ",", "Events", ":", "gocf", ".", "StringList", "(", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "gocf", ".", "String", "(", "\"", "\"", ")", ")", ",", "}", ",", "ServiceRoleArn", ":", "gocf", ".", "GetAtt", "(", "codeDeployRoleName", ",", "\"", "\"", ")", ",", "DeploymentConfigName", ":", "gocf", ".", "String", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "updateType", ")", ")", ",", "DeploymentStyle", ":", "&", "gocf", ".", "CodeDeployDeploymentGroupDeploymentStyle", "{", "DeploymentType", ":", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "DeploymentOption", ":", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "}", ",", "}", "\n", "template", ".", "AddResource", "(", "codeDeploymentGroupResourceName", ",", "codeDeploymentGroup", ")", "\n", "// Create the Alias entry...", "aliasResourceName", ":=", "safeDeployResourceName", "(", "\"", "\"", ")", "\n", "aliasResource", ":=", "&", "gocf", ".", "LambdaAlias", "{", "FunctionVersion", ":", "gocf", ".", "GetAtt", "(", "versionResourceName", ",", "\"", "\"", ")", ".", "String", "(", ")", ",", "FunctionName", ":", "gocf", ".", "Ref", "(", "lambdaResourceName", ")", ".", "String", "(", ")", ",", "Name", ":", "gocf", ".", "String", "(", "\"", "\"", ")", ",", "}", "\n", "aliasEntry", ":=", "template", ".", "AddResource", "(", "aliasResourceName", ",", "aliasResource", ")", "\n", "aliasEntry", ".", "UpdatePolicy", "=", "&", "gocf", ".", "UpdatePolicy", "{", "CodeDeployLambdaAliasUpdate", ":", "&", "gocf", ".", "UpdatePolicyCodeDeployLambdaAliasUpdate", "{", "ApplicationName", ":", "gocf", ".", "Ref", "(", "codeDeployApplicationName", ")", ".", "String", "(", ")", ",", "DeploymentGroupName", ":", "gocf", ".", "Ref", "(", "codeDeploymentGroupResourceName", ")", ".", "String", "(", ")", ",", "}", ",", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "codeDeployLambdaUpdateDecorator", "is", "the", "per", "-", "function", "decorator", "that", "adds", "the", "necessary", "information", "for", "CodeDeploy" ]

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

[ "NewGlueState", "returns", "an", "initialized", "GlueState" ]

[ "func", "TrackWithTcpKeepAlive", "(", "keepalive", "time", ".", "Duration", ")", "listenerOpt", "{", "return", "func", "(", "opts", "*", "listenerOpts", ")", "{", "opts", ".", "tcpKeepAlive", "=", "keepalive", "\n", "}", "\n", "}" ]

[ "TrackWithTcpKeepAlive", "makes", "sure", "that", "any", "net", ".", "TCPConn", "that", "get", "accepted", "have", "a", "keep", "-", "alive", ".", "This", "is", "useful", "for", "HTTP", "servers", "in", "order", "for", "for", "example", "laptops", "to", "not", "use", "up", "resources", "on", "the", "server", "while", "they", "don", "t", "utilise", "their", "connection", ".", "A", "value", "of", "0", "disables", "it", "." ]

[ "func", "NewListener", "(", "inner", "net", ".", "Listener", ",", "optFuncs", "...", "listenerOpt", ")", "net", ".", "Listener", "{", "opts", ":=", "&", "listenerOpts", "{", "name", ":", "defaultName", ",", "monitoring", ":", "true", ",", "tracing", ":", "false", ",", "}", "\n", "for", "_", ",", "f", ":=", "range", "optFuncs", "{", "f", "(", "opts", ")", "\n", "}", "\n", "if", "opts", ".", "monitoring", "{", "preRegisterListenerMetrics", "(", "opts", ".", "name", ")", "\n", "}", "\n", "return", "&", "connTrackListener", "{", "Listener", ":", "inner", ",", "opts", ":", "opts", ",", "}", "\n", "}" ]

[ "NewListener", "returns", "the", "given", "listener", "wrapped", "in", "connection", "tracking", "listener", "." ]

[ "func", "TlsConfigWithHttp2Enabled", "(", "config", "*", "tls", ".", "Config", ")", "(", "*", "tls", ".", "Config", ",", "error", ")", "{", "// mostly based on http2 code in the standards library.", "if", "config", ".", "CipherSuites", "!=", "nil", "{", "// If they already provided a CipherSuite list, return", "// an error if it has a bad order or is missing", "// ECDHE_RSA_WITH_AES_128_GCM_SHA256.", "const", "requiredCipher", "=", "tls", ".", "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", "\n", "haveRequired", ":=", "false", "\n", "for", "_", ",", "cs", ":=", "range", "config", ".", "CipherSuites", "{", "if", "cs", "==", "requiredCipher", "{", "haveRequired", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "haveRequired", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "config", ".", "PreferServerCipherSuites", "=", "true", "\n\n", "haveNPN", ":=", "false", "\n", "for", "_", ",", "p", ":=", "range", "config", ".", "NextProtos", "{", "if", "p", "==", "\"", "\"", "{", "haveNPN", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "haveNPN", "{", "config", ".", "NextProtos", "=", "append", "(", "config", ".", "NextProtos", ",", "\"", "\"", ")", "\n", "}", "\n", "config", ".", "NextProtos", "=", "append", "(", "config", ".", "NextProtos", ",", "\"", "\"", ")", "\n", "// make sure http 1.1 is *after* all of the other ones.", "config", ".", "NextProtos", "=", "append", "(", "config", ".", "NextProtos", ",", "\"", "\"", ")", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "TlsConfigWithHttp2Enabled", "makes", "it", "easy", "to", "configure", "the", "given", "tls", ".", "Config", "to", "prefer", "H2", "connections", ".", "This", "is", "useful", "if", "you", "can", "t", "use", "http", ".", "ListenAndServerTLS", "when", "using", "a", "custom", "net", ".", "Listener", "." ]

[ "func", "PreRegisterDialerMetrics", "(", "dialerName", "string", ")", "{", "dialerAttemptedTotal", ".", "WithLabelValues", "(", "dialerName", ")", "\n", "dialerConnEstablishedTotal", ".", "WithLabelValues", "(", "dialerName", ")", "\n", "for", "_", ",", "reason", ":=", "range", "[", "]", "failureReason", "{", "failedTimeout", ",", "failedResolution", ",", "failedConnRefused", ",", "failedUnknown", "}", "{", "dialerConnFailedTotal", ".", "WithLabelValues", "(", "dialerName", ",", "string", "(", "reason", ")", ")", "\n", "}", "\n", "dialerConnClosedTotal", ".", "WithLabelValues", "(", "dialerName", ")", "\n", "}" ]

[ "preRegisterDialerMetrics", "pre", "-", "populates", "Prometheus", "labels", "for", "the", "given", "dialer", "name", "to", "avoid", "Prometheus", "missing", "labels", "issue", "." ]

[ "func", "DialNameFromContext", "(", "ctx", "context", ".", "Context", ")", "string", "{", "val", ",", "ok", ":=", "ctx", ".", "Value", "(", "dialerNameKey", ")", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "val", "\n", "}" ]

[ "DialNameFromContext", "returns", "the", "name", "of", "the", "dialer", "from", "the", "context", "of", "the", "DialContext", "func", "if", "any", "." ]

[ "func", "DialNameToContext", "(", "ctx", "context", ".", "Context", ",", "dialerName", "string", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "dialerNameKey", ",", "dialerName", ")", "\n", "}" ]

[ "DialNameToContext", "returns", "a", "context", "that", "will", "contain", "a", "dialer", "name", "override", "." ]

[ "func", "NewDialContextFunc", "(", "optFuncs", "...", "dialerOpt", ")", "func", "(", "context", ".", "Context", ",", "string", ",", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "opts", ":=", "&", "dialerOpts", "{", "name", ":", "defaultName", ",", "monitoring", ":", "true", ",", "parentDialContextFunc", ":", "(", "&", "net", ".", "Dialer", "{", "}", ")", ".", "DialContext", "}", "\n", "for", "_", ",", "f", ":=", "range", "optFuncs", "{", "f", "(", "opts", ")", "\n", "}", "\n", "if", "opts", ".", "monitoring", "{", "PreRegisterDialerMetrics", "(", "opts", ".", "name", ")", "\n", "}", "\n", "return", "func", "(", "ctx", "context", ".", "Context", ",", "network", "string", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "name", ":=", "opts", ".", "name", "\n", "if", "ctxName", ":=", "DialNameFromContext", "(", "ctx", ")", ";", "ctxName", "!=", "\"", "\"", "{", "name", "=", "ctxName", "\n", "}", "\n", "return", "dialClientConnTracker", "(", "ctx", ",", "network", ",", "addr", ",", "name", ",", "opts", ")", "\n", "}", "\n", "}" ]

[ "NewDialContextFunc", "returns", "a", "DialContext", "function", "that", "tracks", "outbound", "connections", ".", "The", "signature", "is", "compatible", "with", "http", ".", "Tranport", ".", "DialContext", "and", "is", "meant", "to", "be", "used", "there", "." ]

[ "func", "NewDialFunc", "(", "optFuncs", "...", "dialerOpt", ")", "func", "(", "string", ",", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "dialContextFunc", ":=", "NewDialContextFunc", "(", "optFuncs", "...", ")", "\n", "return", "func", "(", "network", "string", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "return", "dialContextFunc", "(", "context", ".", "TODO", "(", ")", ",", "network", ",", "addr", ")", "\n", "}", "\n", "}" ]

[ "NewDialFunc", "returns", "a", "Dial", "function", "that", "tracks", "outbound", "connections", ".", "The", "signature", "is", "compatible", "with", "http", ".", "Tranport", ".", "Dial", "and", "is", "meant", "to", "be", "used", "there", "for", "Go", "<", "1", ".", "7", "." ]

[ "func", "NewVFSCache", "(", "fs", "vfs", ".", "VFS", ")", "Cache", "{", "return", "&", "cache", "{", "fs", ":", "fs", ",", "stale", ":", "map", "[", "string", "]", "time", ".", "Time", "{", "}", "}", "\n", "}" ]

[ "NewCache", "returns", "a", "cache", "backend", "off", "the", "provided", "VFS" ]

[ "func", "NewDiskCache", "(", "dir", "string", ")", "(", "Cache", ",", "error", ")", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "dir", ",", "0777", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "fs", ",", "err", ":=", "vfs", ".", "FS", "(", "dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "chfs", ",", "err", ":=", "vfs", ".", "Chroot", "(", "\"", "\"", ",", "fs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "NewVFSCache", "(", "chfs", ")", ",", "nil", "\n", "}" ]

[ "NewDiskCache", "returns", "a", "disk", "-", "backed", "cache" ]

[ "func", "(", "c", "*", "cache", ")", "Header", "(", "key", "string", ")", "(", "Header", ",", "error", ")", "{", "path", ":=", "headerPrefix", "+", "formatPrefix", "+", "hashKey", "(", "key", ")", "\n", "f", ",", "err", ":=", "c", ".", "fs", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "if", "vfs", ".", "IsNotExist", "(", "err", ")", "{", "return", "Header", "{", "}", ",", "ErrNotFoundInCache", "\n", "}", "\n", "return", "Header", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "readHeaders", "(", "bufio", ".", "NewReader", "(", "f", ")", ")", "\n", "}" ]

[ "Retrieve", "the", "Status", "and", "Headers", "for", "a", "given", "key", "path" ]

[ "func", "(", "c", "*", "cache", ")", "Store", "(", "res", "*", "Resource", ",", "keys", "...", "string", ")", "error", "{", "var", "buf", "=", "&", "bytes", ".", "Buffer", "{", "}", "\n\n", "if", "length", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "res", ".", "Header", "(", ")", ".", "Get", "(", "\"", "\"", ")", ",", "10", ",", "64", ")", ";", "err", "==", "nil", "{", "if", "_", ",", "err", "=", "io", ".", "CopyN", "(", "buf", ",", "res", ",", "length", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "if", "_", ",", "err", "=", "io", ".", "Copy", "(", "buf", ",", "res", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "delete", "(", "c", ".", "stale", ",", "key", ")", "\n\n", "if", "err", ":=", "c", ".", "storeBody", "(", "buf", ",", "key", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "storeHeader", "(", "res", ".", "Status", "(", ")", ",", "res", ".", "Header", "(", ")", ",", "key", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Store", "a", "resource", "against", "a", "number", "of", "keys" ]

[ "func", "(", "c", "*", "cache", ")", "Retrieve", "(", "key", "string", ")", "(", "*", "Resource", ",", "error", ")", "{", "f", ",", "err", ":=", "c", ".", "fs", ".", "Open", "(", "bodyPrefix", "+", "formatPrefix", "+", "hashKey", "(", "key", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "vfs", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "ErrNotFoundInCache", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "h", ",", "err", ":=", "c", ".", "Header", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "if", "vfs", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "ErrNotFoundInCache", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "res", ":=", "NewResource", "(", "h", ".", "StatusCode", ",", "f", ",", "h", ".", "Header", ")", "\n", "if", "staleTime", ",", "exists", ":=", "c", ".", "stale", "[", "key", "]", ";", "exists", "{", "if", "!", "res", ".", "DateAfter", "(", "staleTime", ")", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "staleTime", ")", "\n", "res", ".", "MarkStale", "(", ")", "\n", "}", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "Retrieve", "returns", "a", "cached", "Resource", "for", "the", "given", "key" ]

[ "func", "(", "h", "*", "Handler", ")", "freshness", "(", "res", "*", "Resource", ",", "r", "*", "cacheRequest", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "maxAge", ",", "err", ":=", "res", ".", "MaxAge", "(", "h", ".", "Shared", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Duration", "(", "0", ")", ",", "err", "\n", "}", "\n\n", "if", "r", ".", "CacheControl", ".", "Has", "(", "\"", "\"", ")", "{", "reqMaxAge", ",", "err", ":=", "r", ".", "CacheControl", ".", "Duration", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Duration", "(", "0", ")", ",", "err", "\n", "}", "\n\n", "if", "reqMaxAge", "<", "maxAge", "{", "debugf", "(", "\"", "\"", ",", "reqMaxAge", ".", "String", "(", ")", ")", "\n", "maxAge", "=", "reqMaxAge", "\n", "}", "\n", "}", "\n\n", "age", ",", "err", ":=", "res", ".", "Age", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Duration", "(", "0", ")", ",", "err", "\n", "}", "\n\n", "if", "res", ".", "IsStale", "(", ")", "{", "return", "time", ".", "Duration", "(", "0", ")", ",", "nil", "\n", "}", "\n\n", "if", "hFresh", ":=", "res", ".", "HeuristicFreshness", "(", ")", ";", "hFresh", ">", "maxAge", "{", "debugf", "(", "\"", "\"", ",", "hFresh", ")", "\n", "maxAge", "=", "hFresh", "\n", "}", "\n\n", "return", "maxAge", "-", "age", ",", "nil", "\n", "}" ]

[ "freshness", "returns", "the", "duration", "that", "a", "requested", "resource", "will", "be", "fresh", "for" ]

[ "func", "(", "h", "*", "Handler", ")", "pipeUpstream", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "cacheRequest", ")", "{", "rw", ":=", "newResponseStreamer", "(", "w", ")", "\n", "rdr", ",", "err", ":=", "rw", ".", "Stream", ".", "NextReader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "debugf", "(", "\"", "\"", ",", "err", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "CacheHeader", ",", "\"", "\"", ")", "\n", "h", ".", "upstream", ".", "ServeHTTP", "(", "w", ",", "r", ".", "Request", ")", "\n", "return", "\n", "}", "\n", "defer", "rdr", ".", "Close", "(", ")", "\n\n", "debugf", "(", "\"", "\"", ")", "\n", "go", "func", "(", ")", "{", "h", ".", "upstream", ".", "ServeHTTP", "(", "rw", ",", "r", ".", "Request", ")", "\n", "rw", ".", "Stream", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "rw", ".", "WaitHeaders", "(", ")", "\n\n", "if", "r", ".", "Method", "!=", "\"", "\"", "&&", "!", "r", ".", "isStateChanging", "(", ")", "{", "return", "\n", "}", "\n\n", "res", ":=", "rw", ".", "Resource", "(", ")", "\n", "defer", "res", ".", "Close", "(", ")", "\n\n", "if", "r", ".", "Method", "==", "\"", "\"", "{", "h", ".", "cache", ".", "Freshen", "(", "res", ",", "r", ".", "Key", ".", "ForMethod", "(", "\"", "\"", ")", ".", "String", "(", ")", ")", "\n", "}", "else", "if", "res", ".", "IsNonErrorStatus", "(", ")", "{", "h", ".", "invalidateResource", "(", "res", ",", "r", ")", "\n", "}", "\n", "}" ]

[ "pipeUpstream", "makes", "the", "request", "via", "the", "upstream", "handler", "the", "response", "is", "not", "stored", "or", "modified" ]