_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25100 | GetAliasRequest | train | func (m *MockLambdaAPI) GetAliasRequest(arg0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "GetAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | go | {
"resource": ""
} |
q25101 | GetEventSourceMapping | train | func (m *MockLambdaAPI) GetEventSourceMapping(arg0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "GetEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25102 | GetEventSourceMappingRequest | train | func (m *MockLambdaAPI) GetEventSourceMappingRequest(arg0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "GetEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
ret... | go | {
"resource": ""
} |
q25103 | GetFunction | train | func (m *MockLambdaAPI) GetFunction(arg0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
ret := m.ctrl.Call(m, "GetFunction", arg0)
ret0, _ := ret[0].(*lambda.GetFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25104 | GetFunctionConfiguration | train | func (m *MockLambdaAPI) GetFunctionConfiguration(arg0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "GetFunctionConfiguration", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25105 | GetFunctionConfigurationRequest | train | func (m *MockLambdaAPI) GetFunctionConfigurationRequest(arg0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "GetFunctionConfigurationRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, r... | go | {
"resource": ""
} |
q25106 | GetFunctionConfigurationWithContext | train | func (m *MockLambdaAPI) GetFunctionConfigurationWithContext(arg0 aws.Context, arg1 *lambda.GetFunctionConfigurationInput, arg2 ...request.Option) (*lambda.FunctionConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetFunction... | go | {
"resource": ""
} |
q25107 | GetFunctionRequest | train | func (m *MockLambdaAPI) GetFunctionRequest(arg0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
ret := m.ctrl.Call(m, "GetFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetFunctionOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25108 | GetFunctionWithContext | train | func (m *MockLambdaAPI) GetFunctionWithContext(arg0 aws.Context, arg1 *lambda.GetFunctionInput, arg2 ...request.Option) (*lambda.GetFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetFunctionWithContext", varargs...)
ret... | go | {
"resource": ""
} |
q25109 | GetPolicy | train | func (m *MockLambdaAPI) GetPolicy(arg0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
ret := m.ctrl.Call(m, "GetPolicy", arg0)
ret0, _ := ret[0].(*lambda.GetPolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25110 | GetPolicyRequest | train | func (m *MockLambdaAPI) GetPolicyRequest(arg0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
ret := m.ctrl.Call(m, "GetPolicyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetPolicyOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25111 | GetPolicyWithContext | train | func (m *MockLambdaAPI) GetPolicyWithContext(arg0 aws.Context, arg1 *lambda.GetPolicyInput, arg2 ...request.Option) (*lambda.GetPolicyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPolicyWithContext", varargs...)
ret0, _ := ... | go | {
"resource": ""
} |
q25112 | Invoke | train | func (m *MockLambdaAPI) Invoke(arg0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
ret := m.ctrl.Call(m, "Invoke", arg0)
ret0, _ := ret[0].(*lambda.InvokeOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25113 | InvokeAsync | train | func (m *MockLambdaAPI) InvokeAsync(arg0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
ret := m.ctrl.Call(m, "InvokeAsync", arg0)
ret0, _ := ret[0].(*lambda.InvokeAsyncOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25114 | InvokeAsyncRequest | train | func (m *MockLambdaAPI) InvokeAsyncRequest(arg0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
ret := m.ctrl.Call(m, "InvokeAsyncRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.InvokeAsyncOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25115 | InvokeAsyncWithContext | train | func (m *MockLambdaAPI) InvokeAsyncWithContext(arg0 aws.Context, arg1 *lambda.InvokeAsyncInput, arg2 ...request.Option) (*lambda.InvokeAsyncOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "InvokeAsyncWithContext", varargs...)
ret... | go | {
"resource": ""
} |
q25116 | InvokeRequest | train | func (m *MockLambdaAPI) InvokeRequest(arg0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
ret := m.ctrl.Call(m, "InvokeRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.InvokeOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25117 | InvokeWithContext | train | func (m *MockLambdaAPI) InvokeWithContext(arg0 aws.Context, arg1 *lambda.InvokeInput, arg2 ...request.Option) (*lambda.InvokeOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "InvokeWithContext", varargs...)
ret0, _ := ret[0].(*lam... | go | {
"resource": ""
} |
q25118 | ListAliases | train | func (m *MockLambdaAPI) ListAliases(arg0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
ret := m.ctrl.Call(m, "ListAliases", arg0)
ret0, _ := ret[0].(*lambda.ListAliasesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25119 | ListAliasesRequest | train | func (m *MockLambdaAPI) ListAliasesRequest(arg0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListAliasesOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25120 | ListAliasesRequest | train | func (mr *MockLambdaAPIMockRecorder) ListAliasesRequest(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockLambdaAPI)(nil).ListAliasesRequest), arg0)
} | go | {
"resource": ""
} |
q25121 | ListAliasesWithContext | train | func (m *MockLambdaAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *lambda.ListAliasesInput, arg2 ...request.Option) (*lambda.ListAliasesOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...)
ret... | go | {
"resource": ""
} |
q25122 | ListAliasesWithContext | train | func (mr *MockLambdaAPIMockRecorder) ListAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockLambdaAPI)(nil).ListAliasesWithContext), va... | go | {
"resource": ""
} |
q25123 | ListEventSourceMappings | train | func (m *MockLambdaAPI) ListEventSourceMappings(arg0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
ret := m.ctrl.Call(m, "ListEventSourceMappings", arg0)
ret0, _ := ret[0].(*lambda.ListEventSourceMappingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25124 | ListEventSourceMappingsPages | train | func (m *MockLambdaAPI) ListEventSourceMappingsPages(arg0 *lambda.ListEventSourceMappingsInput, arg1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
ret := m.ctrl.Call(m, "ListEventSourceMappingsPages", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q25125 | ListEventSourceMappingsRequest | train | func (m *MockLambdaAPI) ListEventSourceMappingsRequest(arg0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
ret := m.ctrl.Call(m, "ListEventSourceMappingsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListEventSourceMappingsOutput)
r... | go | {
"resource": ""
} |
q25126 | ListEventSourceMappingsWithContext | train | func (m *MockLambdaAPI) ListEventSourceMappingsWithContext(arg0 aws.Context, arg1 *lambda.ListEventSourceMappingsInput, arg2 ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListE... | go | {
"resource": ""
} |
q25127 | ListFunctions | train | func (m *MockLambdaAPI) ListFunctions(arg0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
ret := m.ctrl.Call(m, "ListFunctions", arg0)
ret0, _ := ret[0].(*lambda.ListFunctionsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25128 | ListFunctionsPages | train | func (m *MockLambdaAPI) ListFunctionsPages(arg0 *lambda.ListFunctionsInput, arg1 func(*lambda.ListFunctionsOutput, bool) bool) error {
ret := m.ctrl.Call(m, "ListFunctionsPages", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q25129 | ListFunctionsPagesWithContext | train | func (m *MockLambdaAPI) ListFunctionsPagesWithContext(arg0 aws.Context, arg1 *lambda.ListFunctionsInput, arg2 func(*lambda.ListFunctionsOutput, bool) bool, arg3 ...request.Option) error {
varargs := []interface{}{arg0, arg1, arg2}
for _, a := range arg3 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "List... | go | {
"resource": ""
} |
q25130 | ListFunctionsRequest | train | func (m *MockLambdaAPI) ListFunctionsRequest(arg0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
ret := m.ctrl.Call(m, "ListFunctionsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListFunctionsOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25131 | ListTags | train | func (m *MockLambdaAPI) ListTags(arg0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
ret := m.ctrl.Call(m, "ListTags", arg0)
ret0, _ := ret[0].(*lambda.ListTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25132 | ListTagsRequest | train | func (m *MockLambdaAPI) ListTagsRequest(arg0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
ret := m.ctrl.Call(m, "ListTagsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListTagsOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25133 | ListTagsWithContext | train | func (m *MockLambdaAPI) ListTagsWithContext(arg0 aws.Context, arg1 *lambda.ListTagsInput, arg2 ...request.Option) (*lambda.ListTagsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListTagsWithContext", varargs...)
ret0, _ := ret[... | go | {
"resource": ""
} |
q25134 | ListVersionsByFunction | train | func (m *MockLambdaAPI) ListVersionsByFunction(arg0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
ret := m.ctrl.Call(m, "ListVersionsByFunction", arg0)
ret0, _ := ret[0].(*lambda.ListVersionsByFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25135 | ListVersionsByFunctionRequest | train | func (m *MockLambdaAPI) ListVersionsByFunctionRequest(arg0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
ret := m.ctrl.Call(m, "ListVersionsByFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListVersionsByFunctionOutput)
return... | go | {
"resource": ""
} |
q25136 | ListVersionsByFunctionWithContext | train | func (m *MockLambdaAPI) ListVersionsByFunctionWithContext(arg0 aws.Context, arg1 *lambda.ListVersionsByFunctionInput, arg2 ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListVers... | go | {
"resource": ""
} |
q25137 | PublishVersion | train | func (m *MockLambdaAPI) PublishVersion(arg0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "PublishVersion", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25138 | PublishVersionRequest | train | func (m *MockLambdaAPI) PublishVersionRequest(arg0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "PublishVersionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | {
"resource": ""
} |
q25139 | PutFunctionConcurrency | train | func (m *MockLambdaAPI) PutFunctionConcurrency(arg0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
ret := m.ctrl.Call(m, "PutFunctionConcurrency", arg0)
ret0, _ := ret[0].(*lambda.PutFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25140 | PutFunctionConcurrencyRequest | train | func (m *MockLambdaAPI) PutFunctionConcurrencyRequest(arg0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
ret := m.ctrl.Call(m, "PutFunctionConcurrencyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.PutFunctionConcurrencyOutput)
return... | go | {
"resource": ""
} |
q25141 | PutFunctionConcurrencyWithContext | train | func (m *MockLambdaAPI) PutFunctionConcurrencyWithContext(arg0 aws.Context, arg1 *lambda.PutFunctionConcurrencyInput, arg2 ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PutFunct... | go | {
"resource": ""
} |
q25142 | RemovePermission | train | func (m *MockLambdaAPI) RemovePermission(arg0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
ret := m.ctrl.Call(m, "RemovePermission", arg0)
ret0, _ := ret[0].(*lambda.RemovePermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25143 | RemovePermissionRequest | train | func (m *MockLambdaAPI) RemovePermissionRequest(arg0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.RemovePermissionOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25144 | RemovePermissionWithContext | train | func (m *MockLambdaAPI) RemovePermissionWithContext(arg0 aws.Context, arg1 *lambda.RemovePermissionInput, arg2 ...request.Option) (*lambda.RemovePermissionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "RemovePermissionWithContex... | go | {
"resource": ""
} |
q25145 | TagResource | train | func (m *MockLambdaAPI) TagResource(arg0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
ret := m.ctrl.Call(m, "TagResource", arg0)
ret0, _ := ret[0].(*lambda.TagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25146 | TagResourceRequest | train | func (m *MockLambdaAPI) TagResourceRequest(arg0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.TagResourceOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25147 | TagResourceWithContext | train | func (m *MockLambdaAPI) TagResourceWithContext(arg0 aws.Context, arg1 *lambda.TagResourceInput, arg2 ...request.Option) (*lambda.TagResourceOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
ret... | go | {
"resource": ""
} |
q25148 | UntagResource | train | func (m *MockLambdaAPI) UntagResource(arg0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
ret := m.ctrl.Call(m, "UntagResource", arg0)
ret0, _ := ret[0].(*lambda.UntagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25149 | UntagResourceRequest | train | func (m *MockLambdaAPI) UntagResourceRequest(arg0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.UntagResourceOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25150 | UpdateAlias | train | func (m *MockLambdaAPI) UpdateAlias(arg0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25151 | UpdateAliasRequest | train | func (m *MockLambdaAPI) UpdateAliasRequest(arg0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | go | {
"resource": ""
} |
q25152 | UpdateEventSourceMapping | train | func (m *MockLambdaAPI) UpdateEventSourceMapping(arg0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25153 | UpdateEventSourceMappingRequest | train | func (m *MockLambdaAPI) UpdateEventSourceMappingRequest(arg0 *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "UpdateEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfigurat... | go | {
"resource": ""
} |
q25154 | UpdateEventSourceMappingWithContext | train | func (m *MockLambdaAPI) UpdateEventSourceMappingWithContext(arg0 aws.Context, arg1 *lambda.UpdateEventSourceMappingInput, arg2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "U... | go | {
"resource": ""
} |
q25155 | UpdateFunctionCode | train | func (m *MockLambdaAPI) UpdateFunctionCode(arg0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateFunctionCode", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25156 | UpdateFunctionCodeRequest | train | func (m *MockLambdaAPI) UpdateFunctionCodeRequest(arg0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "UpdateFunctionCodeRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | {
"resource": ""
} |
q25157 | UpdateFunctionConfiguration | train | func (m *MockLambdaAPI) UpdateFunctionConfiguration(arg0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateFunctionConfiguration", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25158 | UpdateFunctionConfigurationRequest | train | func (m *MockLambdaAPI) UpdateFunctionConfigurationRequest(arg0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "UpdateFunctionConfigurationRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
retur... | go | {
"resource": ""
} |
q25159 | Upgrade | train | func Upgrade(version string) error {
term.HideCursor()
defer term.ShowCursor()
p := &update.Manager{
Command: "apex",
Store: &github.Store{
Owner: "apex",
Repo: "apex",
Version: version,
},
}
// fetch releases
releases, err := p.LatestReleases()
if err != nil {
return errors.Wrap(err, "fe... | go | {
"resource": ""
} |
q25160 | Boot | train | func (b *Bootstrapper) Boot() error {
fmt.Println(logo)
if b.isProject() {
help("I've detected a ./project.json file, this seems to already be a project!")
return nil
}
help("Enter the name of your project. It should be machine-friendly, as this\nis used to prefix your functions in Lambda.")
b.name = prompt.... | go | {
"resource": ""
} |
q25161 | isProject | train | func (b *Bootstrapper) isProject() bool {
_, err := os.Stat("project.json")
return err == nil
} | go | {
"resource": ""
} |
q25162 | bootVanilla | train | func (b *Bootstrapper) bootVanilla() error {
iamRole, err := b.createRole()
if err != nil {
return err
}
if err := b.initProjectFiles(iamRole); err != nil {
return err
}
fmt.Println(setupCompleteVanilla)
return nil
} | go | {
"resource": ""
} |
q25163 | createRole | train | func (b *Bootstrapper) createRole() (string, error) {
roleName := fmt.Sprintf("%s_lambda_function", b.name)
policyName := fmt.Sprintf("%s_lambda_logs", b.name)
logf("creating IAM %s role", roleName)
role, err := b.IAM.CreateRole(&iam.CreateRoleInput{
RoleName: &roleName,
AssumeRolePolicyDocumen... | go | {
"resource": ""
} |
q25164 | help | train | func help(s string) {
os.Stdout.WriteString("\n")
os.Stdout.WriteString(indent(s))
os.Stdout.WriteString("\n\n")
} | go | {
"resource": ""
} |
q25165 | indent | train | func indent(s string) (out string) {
for _, l := range strings.SplitAfter(s, "\n") {
out += fmt.Sprintf(" %s", l)
}
return
} | go | {
"resource": ""
} |
q25166 | logf | train | func logf(s string, v ...interface{}) {
fmt.Printf(" \033[34m[+]\033[0m %s\n", fmt.Sprintf(s, v...))
} | go | {
"resource": ""
} |
q25167 | wait | train | func (l *Logs) wait(done <-chan error) {
for range l.GroupNames {
if err := <-done; err != nil {
l.err = err
return
}
}
} | go | {
"resource": ""
} |
q25168 | consume | train | func (l *Logs) consume(name string, ch chan *Event, done chan error) {
log := Log{
Config: l.Config,
GroupName: name,
Log: log.WithField("group", name),
}
for event := range log.Start() {
ch <- event
}
done <- log.Err()
} | go | {
"resource": ""
} |
q25169 | preRun | train | func preRun(c *cobra.Command, args []string) error {
err := Prepare(c, args)
if err != nil {
return err
}
return Project.Open()
} | go | {
"resource": ""
} |
q25170 | Sha256 | train | func Sha256(b []byte) string {
h := sha256.New()
h.Write(b)
return base64.StdEncoding.EncodeToString(h.Sum(nil))
} | go | {
"resource": ""
} |
q25171 | LoadFiles | train | func LoadFiles(root string, ignoreFile []byte) (files []string, err error) {
err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
mode := info.Mode()
if !(mode.IsDir() || mode.IsRegular() || mode&os.ModeSymlink == os.ModeSymlink) {
return nil
}
... | go | {
"resource": ""
} |
q25172 | ReadIgnoreFile | train | func ReadIgnoreFile(dir string) ([]byte, error) {
path := filepath.Join(dir, ".apexignore")
b, err := ioutil.ReadFile(path)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
return b, nil
} | go | {
"resource": ""
} |
q25173 | ContainsString | train | func ContainsString(array []string, element string) bool {
for _, e := range array {
if element == e {
return true
}
}
return false
} | go | {
"resource": ""
} |
q25174 | ParseEnv | train | func ParseEnv(env []string) (map[string]string, error) {
m := make(map[string]string)
for _, s := range env {
parts := strings.SplitN(s, "=", 2)
if len(parts) == 2 {
m[parts[0]] = parts[1]
} else {
return nil, fmt.Errorf("environment variable %q is missing a value", parts[0])
}
}
return m, nil
} | go | {
"resource": ""
} |
q25175 | ProfileAndRegionFromConfig | train | func ProfileAndRegionFromConfig(environment string) (string, string, error) {
configFile := "project.json"
if environment != "" {
configFile = fmt.Sprintf("project.%s.json", environment)
}
f, err := os.Open(configFile)
if err != nil {
return "", "", err
}
defer f.Close()
var v struct {
Profile string `... | go | {
"resource": ""
} |
q25176 | AssumeRole | train | func AssumeRole(role string, config *aws.Config) (*aws.Config, error) {
stscreds := sts.New(session.New(config))
params := &sts.AssumeRoleInput{
RoleArn: &role,
RoleSessionName: aws.String("apex"),
DurationSeconds: aws.Int64(1800),
}
res, err := stscreds.AssumeRole(params)
if err != nil {
return ... | go | {
"resource": ""
} |
q25177 | Open | train | func (p *Project) Open() error {
p.defaults()
configFile := "project.json"
if p.Environment != "" {
configFile = fmt.Sprintf("project.%s.json", p.Environment)
}
f, err := os.Open(filepath.Join(p.Path, configFile))
if err != nil {
return err
}
if err := json.NewDecoder(f).Decode(&p.Config); err != nil {
... | go | {
"resource": ""
} |
q25178 | DeployAndClean | train | func (p *Project) DeployAndClean() error {
if err := p.Deploy(); err != nil {
return err
}
return p.Clean()
} | go | {
"resource": ""
} |
q25179 | Deploy | train | func (p *Project) Deploy() error {
p.Log.Debugf("deploying %d functions", len(p.Functions))
sem := make(semaphore.Semaphore, p.Concurrency)
errs := make(chan error)
go func() {
for _, fn := range p.Functions {
fn := fn
sem.Acquire()
go func() {
defer sem.Release()
err := fn.Deploy()
if er... | go | {
"resource": ""
} |
q25180 | Clean | train | func (p *Project) Clean() error {
p.Log.Debugf("cleaning %d functions", len(p.Functions))
for _, fn := range p.Functions {
if err := fn.Clean(); err != nil {
return fmt.Errorf("function %s: %s", fn.Name, err)
}
}
return nil
} | go | {
"resource": ""
} |
q25181 | Delete | train | func (p *Project) Delete() error {
p.Log.Debugf("deleting %d functions", len(p.Functions))
for _, fn := range p.Functions {
if _, err := fn.GetConfig(); err != nil {
if awserr, ok := err.(awserr.Error); ok && awserr.Code() == "ResourceNotFoundException" {
p.Log.Infof("function %q hasn't been deployed yet or... | go | {
"resource": ""
} |
q25182 | RollbackVersion | train | func (p *Project) RollbackVersion(version string) error {
p.Log.Debugf("rolling back %d functions to version %s", len(p.Functions), version)
for _, fn := range p.Functions {
if err := fn.RollbackVersion(version); err != nil {
return fmt.Errorf("function %s: %s", fn.Name, err)
}
}
return nil
} | go | {
"resource": ""
} |
q25183 | FunctionDirNames | train | func (p *Project) FunctionDirNames() (list []string, err error) {
dir := filepath.Join(p.Path, functionsDir)
files, err := ioutil.ReadDir(dir)
if err != nil {
return nil, err
}
for _, file := range files {
if file.IsDir() {
list = append(list, file.Name())
}
}
return list, nil
} | go | {
"resource": ""
} |
q25184 | LoadEnvFromFile | train | func (p *Project) LoadEnvFromFile(path string) error {
p.Log.Debugf("load env from file %q", path)
var env map[string]string
f, err := os.Open(path)
if err != nil {
return err
}
defer f.Close()
if err := json.NewDecoder(f).Decode(&env); err != nil {
return err
}
for k, v := range env {
p.Setenv(k, v)
... | go | {
"resource": ""
} |
q25185 | Setenv | train | func (p *Project) Setenv(name, value string) {
for _, fn := range p.Functions {
fn.Setenv(name, value)
}
} | go | {
"resource": ""
} |
q25186 | LoadFunctionByPath | train | func (p *Project) LoadFunctionByPath(name, path string) (*function.Function, error) {
fn := &function.Function{
Config: function.Config{
Runtime: p.Runtime,
Memory: p.Memory,
Timeout: p.Timeout,
Role: p.Role,
Handler: p.Handler,
Shim: p.S... | go | {
"resource": ""
} |
q25187 | CreateOrUpdateAlias | train | func (p *Project) CreateOrUpdateAlias(alias, version string) error {
p.Log.Debugf("updating %d functions", len(p.Functions))
sem := make(semaphore.Semaphore, p.Concurrency)
errs := make(chan error)
go func() {
for _, fn := range p.Functions {
fn := fn
sem.Acquire()
go func() {
defer sem.Release()
... | go | {
"resource": ""
} |
q25188 | name | train | func (p *Project) name(fn *function.Function) (string, error) {
data := struct {
Project *Project
Function *function.Function
}{
Project: p,
Function: fn,
}
name, err := render(p.nameTemplate, data)
if err != nil {
return "", err
}
return name, nil
} | go | {
"resource": ""
} |
q25189 | readInfraRole | train | func (p *Project) readInfraRole() string {
role, err := infra.Output(p.InfraEnvironment, "lambda_function_role_id")
if err != nil {
p.Log.Debugf("couldn't read role from infrastructure: %s", err)
return ""
}
return role
} | go | {
"resource": ""
} |
q25190 | render | train | func render(t *template.Template, v interface{}) (string, error) {
buf := new(bytes.Buffer)
if err := t.Execute(buf, v); err != nil {
return "", err
}
return buf.String(), nil
} | go | {
"resource": ""
} |
q25191 | copyVPC | train | func copyVPC(in vpc.VPC) vpc.VPC {
securityGroups := make([]string, len(in.SecurityGroups))
copy(securityGroups, in.SecurityGroups)
subnets := make([]string, len(in.Subnets))
copy(subnets, in.Subnets)
return vpc.VPC{
SecurityGroups: securityGroups,
Subnets: subnets,
}
} | go | {
"resource": ""
} |
q25192 | matches | train | func matches(name string, patterns []string) (bool, error) {
if len(patterns) == 0 {
return true, nil
}
for _, pattern := range patterns {
match, err := filepath.Match(pattern, name)
if err != nil {
return false, err
}
if match {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q25193 | Read | train | func (r *reader) Read(b []byte) (int, error) {
r.Do(term.ClearAll)
n, err := r.ReadCloser.Read(b)
r.written += n
r.p.ValueInt(r.written)
r.render(term.CenterLine(r.p.String()))
return n, err
} | go | {
"resource": ""
} |
q25194 | New | train | func New(size int, r io.ReadCloser) io.ReadCloser {
return &reader{
ReadCloser: r,
p: util.NewProgressInt(size),
render: term.Renderer(),
}
} | go | {
"resource": ""
} |
q25195 | Collect | train | func (m *Metric) Collect() (a AggregatedMetrics) {
for n := range m.collect(m.gen()) {
value := aggregate(n.Value)
switch n.Name {
case "Duration":
a.Duration = value
case "Errors":
a.Errors = value
case "Invocations":
a.Invocations = value
case "Throttles":
a.Throttles = value
}
}
return... | go | {
"resource": ""
} |
q25196 | stats | train | func (m *Metric) stats(name string) (*cloudwatch.GetMetricStatisticsOutput, error) {
return m.Service.GetMetricStatistics(&cloudwatch.GetMetricStatisticsInput{
StartTime: &m.StartDate,
EndTime: &m.EndDate,
MetricName: &name,
Namespace: aws.String("AWS/Lambda"),
Period: aws.Int64(int64(period(m.Start... | go | {
"resource": ""
} |
q25197 | collect | train | func (m *Metric) collect(in <-chan string) <-chan cloudWatchMetric {
var wg sync.WaitGroup
out := make(chan cloudWatchMetric)
for name := range in {
wg.Add(1)
name := name
go func() {
defer wg.Done()
res, err := m.stats(name)
if err != nil {
// TODO: refactor so that errors are reported in cmd
... | go | {
"resource": ""
} |
q25198 | gen | train | func (m *Metric) gen() <-chan string {
out := make(chan string, len(metricsNames))
for _, n := range metricsNames {
out <- n
}
close(out)
return out
} | go | {
"resource": ""
} |
q25199 | period | train | func period(start, end time.Time) time.Duration {
switch n := end.Sub(start).Hours(); {
case n > 24:
return time.Hour * 24
default:
return time.Hour
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.