_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25000 | MetaField | train | func MetaField(l *State, index int, event string) bool {
if !l.MetaTable(index) {
return false
}
l.PushString(event)
l.RawGet(-2)
if l.IsNil(-1) {
l.Pop(2) // remove metatable and metafield
return false
}
l.Remove(-2) // remove only metatable
return true
} | go | {
"resource": ""
} |
q25001 | NewMetaTable | train | func NewMetaTable(l *State, name string) bool {
if MetaTableNamed(l, name); !l.IsNil(-1) {
return false
}
l.Pop(1)
l.NewTable()
l.PushValue(-1)
l.SetField(RegistryIndex, name)
return true
} | go | {
"resource": ""
} |
q25002 | CheckType | train | func CheckType(l *State, index int, t Type) {
if l.TypeOf(index) != t {
tagError(l, index, t)
}
} | go | {
"resource": ""
} |
q25003 | ArgumentCheck | train | func ArgumentCheck(l *State, cond bool, index int, extraMessage string) {
if !cond {
ArgumentError(l, index, extraMessage)
}
} | go | {
"resource": ""
} |
q25004 | CheckString | train | func CheckString(l *State, index int) string {
if s, ok := l.ToString(index); ok {
return s
}
tagError(l, index, TypeString)
panic("unreachable")
} | go | {
"resource": ""
} |
q25005 | OptString | train | func OptString(l *State, index int, def string) string {
if l.IsNoneOrNil(index) {
return def
}
return CheckString(l, index)
} | go | {
"resource": ""
} |
q25006 | NewStateEx | train | func NewStateEx() *State {
l := NewState()
if l != nil {
_ = AtPanic(l, func(l *State) int {
s, _ := l.ToString(-1)
fmt.Fprintf(os.Stderr, "PANIC: unprotected error in call to Lua API (%s)\n", s)
return 0
})
}
return l
} | go | {
"resource": ""
} |
q25007 | DoFile | train | func DoFile(l *State, fileName string) error {
if err := LoadFile(l, fileName, ""); err != nil {
return err
}
return l.ProtectedCall(0, MultipleReturns, 0)
} | go | {
"resource": ""
} |
q25008 | DoString | train | func DoString(l *State, s string) error {
if err := LoadString(l, s); err != nil {
return err
}
return l.ProtectedCall(0, MultipleReturns, 0)
} | go | {
"resource": ""
} |
q25009 | call | train | func (l *State) call(function int, resultCount int, allowYield bool) {
if l.nestedGoCallCount++; l.nestedGoCallCount == maxCallCount {
l.runtimeError("Go stack overflow")
} else if l.nestedGoCallCount >= maxCallCount+maxCallCount>>3 {
l.throw(ErrorError) // error while handling stack error
}
if !allowYield {
... | go | {
"resource": ""
} |
q25010 | PackageOpen | train | func PackageOpen(l *State) int {
NewLibrary(l, packageLibrary)
createSearchersTable(l)
l.SetField(-2, "searchers")
setPath(l, "path", "LUA_PATH", defaultPath)
l.PushString(fmt.Sprintf("%c\n%c\n?\n!\n-\n", filepath.Separator, pathListSeparator))
l.SetField(-2, "config")
SubTable(l, RegistryIndex, "_LOADED")
l.Se... | go | {
"resource": ""
} |
q25011 | BaseOpen | train | func BaseOpen(l *State) int {
l.PushGlobalTable()
l.PushGlobalTable()
l.SetField(-2, "_G")
SetFunctions(l, baseLibrary, 0)
l.PushString(VersionString)
l.SetField(-2, "_VERSION")
return 1
} | go | {
"resource": ""
} |
q25012 | start | train | func (l *Log) start(ch chan<- *Event) {
defer close(ch)
l.Log.Debug("enter")
defer l.Log.Debug("exit")
var start = l.StartTime.UnixNano() / int64(time.Millisecond)
var nextToken *string
var err error
for {
l.Log.WithField("start", start).Debug("request")
nextToken, start, err = l.fetch(nextToken, start, c... | go | {
"resource": ""
} |
q25013 | fetch | train | func (l *Log) fetch(nextToken *string, start int64, ch chan<- *Event) (*string, int64, error) {
res, err := l.Service.FilterLogEvents(&cloudwatchlogs.FilterLogEventsInput{
LogGroupName: &l.GroupName,
FilterPattern: &l.FilterPattern,
StartTime: &start,
NextToken: nextToken,
})
if e, ok := err.(awser... | go | {
"resource": ""
} |
q25014 | Open | train | func (f *Function) Open(environment string) error {
f.defaults()
f.Log = f.Log.WithFields(log.Fields{
"function": f.Name,
"env": environment,
})
f.Log.Debug("open")
if err := f.loadConfig(environment); err != nil {
return errors.Wrap(err, "loading config")
}
if err := f.hookOpen(); err != nil {
... | go | {
"resource": ""
} |
q25015 | loadConfig | train | func (f *Function) loadConfig(environment string) error {
path := fmt.Sprintf("function.%s.json", environment)
ok, err := f.tryConfig(path)
if err != nil {
return err
}
if ok {
f.Log.WithField("config", path).Debug("loaded config")
return nil
}
ok, err = f.tryConfig("function.json")
if err != nil {
r... | go | {
"resource": ""
} |
q25016 | Setenv | train | func (f *Function) Setenv(name, value string) {
f.Environment[name] = value
} | go | {
"resource": ""
} |
q25017 | Deploy | train | func (f *Function) Deploy() error {
f.Log.Debug("deploying")
zip, err := f.ZipBytes()
if err != nil {
return err
}
if err := f.hookDeploy(); err != nil {
return err
}
config, err := f.GetConfig()
if e, ok := err.(awserr.Error); ok {
if e.Code() == "ResourceNotFoundException" {
return f.Create(zip)
... | go | {
"resource": ""
} |
q25018 | DeployCode | train | func (f *Function) DeployCode(zip []byte, config *lambda.GetFunctionOutput) error {
remoteHash := *config.Configuration.CodeSha256
localHash := utils.Sha256(zip)
if localHash == remoteHash {
f.Log.Info("code unchanged")
version := config.Configuration.Version
// Creating an alias to $LATEST would mean its t... | go | {
"resource": ""
} |
q25019 | DeployConfigAndCode | train | func (f *Function) DeployConfigAndCode(zip []byte) error {
f.Log.Info("updating config")
params := &lambda.UpdateFunctionConfigurationInput{
FunctionName: &f.FunctionName,
MemorySize: &f.Memory,
Timeout: &f.Timeout,
Description: &f.Description,
Role: &f.Role,
Runtime: &f.Runtime,
H... | go | {
"resource": ""
} |
q25020 | Delete | train | func (f *Function) Delete() error {
f.Log.Info("deleting")
_, err := f.Service.DeleteFunction(&lambda.DeleteFunctionInput{
FunctionName: &f.FunctionName,
})
if err != nil {
return err
}
f.Log.Info("function deleted")
return nil
} | go | {
"resource": ""
} |
q25021 | GetConfig | train | func (f *Function) GetConfig() (*lambda.GetFunctionOutput, error) {
f.Log.Debug("fetching config")
return f.Service.GetFunction(&lambda.GetFunctionInput{
FunctionName: &f.FunctionName,
})
} | go | {
"resource": ""
} |
q25022 | GetConfigQualifier | train | func (f *Function) GetConfigQualifier(s string) (*lambda.GetFunctionOutput, error) {
f.Log.Debug("fetching config")
return f.Service.GetFunction(&lambda.GetFunctionInput{
FunctionName: &f.FunctionName,
Qualifier: &s,
})
} | go | {
"resource": ""
} |
q25023 | GetConfigCurrent | train | func (f *Function) GetConfigCurrent() (*lambda.GetFunctionOutput, error) {
return f.GetConfigQualifier(f.Alias)
} | go | {
"resource": ""
} |
q25024 | Update | train | func (f *Function) Update(zip []byte) error {
f.Log.Info("updating function")
updated, err := f.Service.UpdateFunctionCode(&lambda.UpdateFunctionCodeInput{
FunctionName: &f.FunctionName,
Publish: aws.Bool(true),
ZipFile: zip,
})
if err != nil {
return err
}
if err := f.CreateOrUpdateAlias(f.A... | go | {
"resource": ""
} |
q25025 | Create | train | func (f *Function) Create(zip []byte) error {
f.Log.Info("creating function")
params := &lambda.CreateFunctionInput{
FunctionName: &f.FunctionName,
Description: &f.Description,
MemorySize: &f.Memory,
Timeout: &f.Timeout,
Runtime: &f.Runtime,
Handler: &f.Handler,
Role: &f.Role,... | go | {
"resource": ""
} |
q25026 | CreateOrUpdateAlias | train | func (f *Function) CreateOrUpdateAlias(alias, version string) error {
_, err := f.Service.CreateAlias(&lambda.CreateAliasInput{
FunctionName: &f.FunctionName,
FunctionVersion: &version,
Name: &alias,
})
if err == nil {
f.Log.WithField("version", version).Infof("created alias %s", alias)
retu... | go | {
"resource": ""
} |
q25027 | GetAliases | train | func (f *Function) GetAliases() (*lambda.ListAliasesOutput, error) {
f.Log.Debug("fetching aliases")
return f.Service.ListAliases(&lambda.ListAliasesInput{
FunctionName: &f.FunctionName,
})
} | go | {
"resource": ""
} |
q25028 | Invoke | train | func (f *Function) Invoke(event, context interface{}) (reply, logs io.Reader, err error) {
eventBytes, err := json.Marshal(event)
if err != nil {
return nil, nil, err
}
contextBytes, err := json.Marshal(context)
if err != nil {
return nil, nil, err
}
res, err := f.Service.Invoke(&lambda.InvokeInput{
Clie... | go | {
"resource": ""
} |
q25029 | Rollback | train | func (f *Function) Rollback() error {
f.Log.Info("rolling back")
alias, err := f.currentVersionAlias()
if err != nil {
return err
}
f.Log.Debugf("current version: %s", *alias.FunctionVersion)
versions, err := f.versions()
if err != nil {
return err
}
if len(versions) < 2 {
return errors.New("Can't ro... | go | {
"resource": ""
} |
q25030 | RollbackVersion | train | func (f *Function) RollbackVersion(version string) error {
f.Log.Info("rolling back")
alias, err := f.currentVersionAlias()
if err != nil {
return err
}
f.Log.Debugf("current version: %s", *alias.FunctionVersion)
if version == *alias.FunctionVersion {
return errors.New("Specified version currently deployed... | go | {
"resource": ""
} |
q25031 | ZipBytes | train | func (f *Function) ZipBytes() ([]byte, error) {
if f.Zip == "" {
f.Log.Debug("building zip")
return f.BuildBytes()
}
f.Log.Debugf("reading zip %q", f.Zip)
return ioutil.ReadFile(f.Zip)
} | go | {
"resource": ""
} |
q25032 | BuildBytes | train | func (f *Function) BuildBytes() ([]byte, error) {
r, err := f.Build()
if err != nil {
return nil, err
}
b, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
f.Log.Debugf("created build (%s)", humanize.Bytes(uint64(len(b))))
return b, nil
} | go | {
"resource": ""
} |
q25033 | Build | train | func (f *Function) Build() (io.Reader, error) {
f.Log.Debugf("creating build")
buf := new(bytes.Buffer)
zip := archive.NewZip(buf)
if err := f.hookBuild(zip); err != nil {
return nil, err
}
paths, err := utils.LoadFiles(f.Path, f.IgnoreFile)
if err != nil {
return nil, err
}
for _, path := range paths ... | go | {
"resource": ""
} |
q25034 | GetVersionFromAlias | train | func (f *Function) GetVersionFromAlias(alias string) (string, error) {
var version string = alias
aliases, err := f.GetAliases()
if err != nil {
return version, err
}
for _, fnAlias := range aliases.Aliases {
if strings.Compare(version, *fnAlias.Name) == 0 {
version = *fnAlias.FunctionVersion
break
}
... | go | {
"resource": ""
} |
q25035 | cleanup | train | func (f *Function) cleanup() error {
versionsToCleanup, err := f.versionsToCleanup()
if err != nil {
return err
}
return f.removeVersions(versionsToCleanup)
} | go | {
"resource": ""
} |
q25036 | versions | train | func (f *Function) versions() ([]*lambda.FunctionConfiguration, error) {
var list []*lambda.FunctionConfiguration
request := lambda.ListVersionsByFunctionInput{
FunctionName: &f.FunctionName,
}
for {
page, err := f.Service.ListVersionsByFunction(&request)
if err != nil {
return nil, err
}
list = app... | go | {
"resource": ""
} |
q25037 | versionsToCleanup | train | func (f *Function) versionsToCleanup() ([]*lambda.FunctionConfiguration, error) {
versions, err := f.versions()
if err != nil {
return nil, err
}
if *f.RetainedVersions == 0 {
return versions, nil
}
if len(versions) > *f.RetainedVersions {
return versions[:len(versions)-*f.RetainedVersions], nil
}
retu... | go | {
"resource": ""
} |
q25038 | removeVersions | train | func (f *Function) removeVersions(versions []*lambda.FunctionConfiguration) error {
for _, v := range versions {
f.Log.Debugf("cleaning up version: %s", *v.Version)
_, err := f.Service.DeleteFunction(&lambda.DeleteFunctionInput{
FunctionName: &f.FunctionName,
Qualifier: v.Version,
})
if err != nil {... | go | {
"resource": ""
} |
q25039 | currentVersionAlias | train | func (f *Function) currentVersionAlias() (*lambda.AliasConfiguration, error) {
return f.Service.GetAlias(&lambda.GetAliasInput{
FunctionName: &f.FunctionName,
Name: &f.Alias,
})
} | go | {
"resource": ""
} |
q25040 | configChanged | train | func (f *Function) configChanged(config *lambda.GetFunctionOutput) bool {
type diffConfig struct {
Description string
Memory int64
Timeout int64
Role string
Runtime string
Handler string
VPC vpc.VPC
Environment []string
KMSKeyArn... | go | {
"resource": ""
} |
q25041 | hookOpen | train | func (f *Function) hookOpen() error {
for _, name := range f.Plugins {
if p, ok := plugins[name].(Opener); ok {
if err := p.Open(f); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q25042 | hookBuild | train | func (f *Function) hookBuild(zip *archive.Zip) error {
for _, name := range f.Plugins {
if p, ok := plugins[name].(Builder); ok {
if err := p.Build(f, zip); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q25043 | hookClean | train | func (f *Function) hookClean() error {
for _, name := range f.Plugins {
if p, ok := plugins[name].(Cleaner); ok {
if err := p.Clean(f); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q25044 | hookDeploy | train | func (f *Function) hookDeploy() error {
for _, name := range f.Plugins {
if p, ok := plugins[name].(Deployer); ok {
if err := p.Deploy(f); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q25045 | environment | train | func (f *Function) environment() *lambda.Environment {
env := make(map[string]*string)
if !f.Edge {
for k, v := range f.Environment {
env[k] = aws.String(v)
}
}
return &lambda.Environment{Variables: env}
} | go | {
"resource": ""
} |
q25046 | environ | train | func environ(env map[string]*string) []string {
var keys []string
var pairs []string
for k := range env {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
pairs = append(pairs, fmt.Sprintf("%s=%s", k, *env[k]))
}
return pairs
} | go | {
"resource": ""
} |
q25047 | AWSConfig | train | func (f *Function) AWSConfig() *aws.Config {
region := f.Config.Region
if f.Config.Edge {
region = "us-east-1"
}
if len(region) > 0 {
return aws.NewConfig().WithRegion(region)
}
return nil
} | go | {
"resource": ""
} |
q25048 | Reader | train | func Reader() io.Reader {
var in bytes.Buffer
for _, page := range pages {
in.WriteString(fmt.Sprintf("\n# %s\n", page.Name))
in.Write(MustAsset(page.File))
}
md := markdown.New(markdown.XHTMLOutput(true), markdown.Nofollow(true))
v := &renderer{}
s := v.visit(md.Parse(in.Bytes()))
return strings.NewReader... | go | {
"resource": ""
} |
q25049 | indent | train | func indent(s string, n int) string {
i := strings.Repeat(" ", n)
return i + strings.Replace(s, "\n", "\n"+i, -1)
} | go | {
"resource": ""
} |
q25050 | visit | train | func (r *renderer) visit(tokens []markdown.Token) (s string) {
for _, t := range tokens {
s += r.visitToken(t)
}
return
} | go | {
"resource": ""
} |
q25051 | visitToken | train | func (r *renderer) visitToken(t markdown.Token) string {
switch t.(type) {
case *markdown.ParagraphOpen:
r.inParagraph = true
return ""
case *markdown.ParagraphClose:
r.inParagraph = false
return "\n"
case *markdown.CodeBlock:
return fmt.Sprintf("\n%s\n", indent(t.(*markdown.CodeBlock).Content, 2))
case ... | go | {
"resource": ""
} |
q25052 | Open | train | func (p *Plugin) Open(fn *function.Function) error {
if !strings.HasPrefix(fn.Runtime, "python") {
return nil
}
// Support "python" for backwards compat.
if fn.Runtime == "python" {
fn.Runtime = "python2.7"
}
if fn.Handler == "" {
fn.Handler = "main.handle"
}
return nil
} | go | {
"resource": ""
} |
q25053 | preRun | train | func preRun(c *cobra.Command, args []string) error {
if len(args) < 1 {
return errors.New("Missing name argument")
}
name = args[0]
return nil
} | go | {
"resource": ""
} |
q25054 | input | train | func input() io.Reader {
if isatty.IsTerminal(os.Stdin.Fd()) {
return strings.NewReader("{}")
}
return os.Stdin
} | go | {
"resource": ""
} |
q25055 | Run | train | func (p *Proxy) Run(args ...string) error {
if p.shouldInjectVars(args) {
args = append(args, p.functionVars()...)
}
log.WithFields(log.Fields{
"args": args,
}).Debug("terraform")
cmd := exec.Command("terraform", args...)
cmd.Env = append(os.Environ(), fmt.Sprintf("AWS_REGION=%s", p.Region))
cmd.Stdin = os... | go | {
"resource": ""
} |
q25056 | shouldInjectVars | train | func (p *Proxy) shouldInjectVars(args []string) bool {
if len(args) == 0 {
return false
}
return args[0] == "plan" || args[0] == "apply" || args[0] == "destroy" || args[0] == "refresh"
} | go | {
"resource": ""
} |
q25057 | Output | train | func Output(environment, name string) (string, error) {
cmd := exec.Command("sh", "-c", fmt.Sprintf("terraform output %s", name))
cmd.Dir = filepath.Join(Dir, environment)
out, err := cmd.CombinedOutput()
if err != nil {
return "", err
}
return strings.Trim(string(out), "\n"), nil
} | go | {
"resource": ""
} |
q25058 | AddBytes | train | func (z *Zip) AddBytes(path string, contents []byte) error {
z.lock.Lock()
defer z.lock.Unlock()
header := &zip.FileHeader{
Name: path,
Method: zip.Deflate,
}
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = zippedFile.Write(c... | go | {
"resource": ""
} |
q25059 | AddFile | train | func (z *Zip) AddFile(path string, file *os.File) error {
path = strings.Replace(path, "\\", "/", -1)
z.lock.Lock()
defer z.lock.Unlock()
info, err := file.Stat()
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return errors.New("Only regular files supported: " + path)
}
header, err := zip.F... | go | {
"resource": ""
} |
q25060 | AddDir | train | func (z *Zip) AddDir(root, target string) error {
return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return nil
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
rel, err :... | go | {
"resource": ""
} |
q25061 | New | train | func New(session *session.Session) *Lambda {
fmt.Printf("\n")
return &Lambda{
Lambda: lambda.New(session),
}
} | go | {
"resource": ""
} |
q25062 | CreateFunction | train | func (l *Lambda) CreateFunction(in *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
l.create("function", *in.FunctionName, map[string]interface{}{
"runtime": *in.Runtime,
"memory": *in.MemorySize,
"timeout": *in.Timeout,
"handler": *in.Handler,
})
out := &lambda.FunctionConfiguration{
... | go | {
"resource": ""
} |
q25063 | UpdateFunctionCode | train | func (l *Lambda) UpdateFunctionCode(in *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
res, err := l.GetFunction(&lambda.GetFunctionInput{
FunctionName: in.FunctionName,
})
if err != nil {
return nil, err
}
size := uint64(len(in.ZipFile))
checksum := utils.Sha256(in.ZipFile)
remot... | go | {
"resource": ""
} |
q25064 | UpdateFunctionConfiguration | train | func (l *Lambda) UpdateFunctionConfiguration(in *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
res, err := l.GetFunctionConfiguration(&lambda.GetFunctionConfigurationInput{
FunctionName: in.FunctionName,
})
if e, ok := err.(awserr.Error); ok {
if e.Code() == "ResourceNotFound... | go | {
"resource": ""
} |
q25065 | DeleteFunction | train | func (l *Lambda) DeleteFunction(in *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
if in.Qualifier == nil {
l.remove("function", *in.FunctionName, nil)
} else {
l.remove("function version", fmt.Sprintf("%s (version: %s)", *in.FunctionName, *in.Qualifier), nil)
}
return nil, nil
} | go | {
"resource": ""
} |
q25066 | CreateAlias | train | func (l *Lambda) CreateAlias(in *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
l.create("alias", *in.FunctionName, map[string]interface{}{
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | go | {
"resource": ""
} |
q25067 | UpdateAlias | train | func (l *Lambda) UpdateAlias(in *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
l.update("alias", *in.FunctionName, map[string]interface{}{
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | go | {
"resource": ""
} |
q25068 | create | train | func (l *Lambda) create(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '+', green)
} | go | {
"resource": ""
} |
q25069 | update | train | func (l *Lambda) update(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '~', yellow)
} | go | {
"resource": ""
} |
q25070 | remove | train | func (l *Lambda) remove(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '-', red)
} | go | {
"resource": ""
} |
q25071 | NewMockProvideriface | train | func NewMockProvideriface(ctrl *gomock.Controller) *MockProvideriface {
mock := &MockProvideriface{ctrl: ctrl}
mock.recorder = &MockProviderifaceMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q25072 | NewService | train | func (m *MockProvideriface) NewService(arg0 *aws.Config) lambdaiface.LambdaAPI {
if m.ctrl == nil {
return nil
}
ret := m.ctrl.Call(m, "NewService", arg0)
ret0, _ := ret[0].(lambdaiface.LambdaAPI)
return ret0
} | go | {
"resource": ""
} |
q25073 | NewService | train | func (mr *MockProviderifaceMockRecorder) NewService(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewService", reflect.TypeOf((*MockProvideriface)(nil).NewService), arg0)
} | go | {
"resource": ""
} |
q25074 | NewMockLambdaAPI | train | func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
mock := &MockLambdaAPI{ctrl: ctrl}
mock.recorder = &MockLambdaAPIMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q25075 | AddPermission | train | func (m *MockLambdaAPI) AddPermission(arg0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
ret := m.ctrl.Call(m, "AddPermission", arg0)
ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25076 | AddPermissionRequest | train | func (m *MockLambdaAPI) AddPermissionRequest(arg0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
ret := m.ctrl.Call(m, "AddPermissionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AddPermissionOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25077 | AddPermissionWithContext | train | func (m *MockLambdaAPI) AddPermissionWithContext(arg0 aws.Context, arg1 *lambda.AddPermissionInput, arg2 ...request.Option) (*lambda.AddPermissionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs.... | go | {
"resource": ""
} |
q25078 | CreateAlias | train | func (m *MockLambdaAPI) CreateAlias(arg0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "CreateAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25079 | CreateAliasRequest | train | func (m *MockLambdaAPI) CreateAliasRequest(arg0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "CreateAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | go | {
"resource": ""
} |
q25080 | CreateAliasWithContext | train | func (m *MockLambdaAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *lambda.CreateAliasInput, arg2 ...request.Option) (*lambda.AliasConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...)
re... | go | {
"resource": ""
} |
q25081 | CreateEventSourceMapping | train | func (m *MockLambdaAPI) CreateEventSourceMapping(arg0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "CreateEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25082 | CreateEventSourceMappingRequest | train | func (m *MockLambdaAPI) CreateEventSourceMappingRequest(arg0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "CreateEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfigurat... | go | {
"resource": ""
} |
q25083 | CreateFunction | train | func (m *MockLambdaAPI) CreateFunction(arg0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "CreateFunction", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25084 | CreateFunctionRequest | train | func (m *MockLambdaAPI) CreateFunctionRequest(arg0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "CreateFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | {
"resource": ""
} |
q25085 | DeleteAlias | train | func (m *MockLambdaAPI) DeleteAlias(arg0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
ret := m.ctrl.Call(m, "DeleteAlias", arg0)
ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25086 | DeleteAliasRequest | train | func (m *MockLambdaAPI) DeleteAliasRequest(arg0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteAliasOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25087 | DeleteAliasWithContext | train | func (m *MockLambdaAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *lambda.DeleteAliasInput, arg2 ...request.Option) (*lambda.DeleteAliasOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...)
ret... | go | {
"resource": ""
} |
q25088 | DeleteEventSourceMapping | train | func (m *MockLambdaAPI) DeleteEventSourceMapping(arg0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "DeleteEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25089 | DeleteEventSourceMappingRequest | train | func (m *MockLambdaAPI) DeleteEventSourceMappingRequest(arg0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "DeleteEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfigurat... | go | {
"resource": ""
} |
q25090 | DeleteFunction | train | func (m *MockLambdaAPI) DeleteFunction(arg0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
ret := m.ctrl.Call(m, "DeleteFunction", arg0)
ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25091 | DeleteFunctionConcurrency | train | func (m *MockLambdaAPI) DeleteFunctionConcurrency(arg0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
ret := m.ctrl.Call(m, "DeleteFunctionConcurrency", arg0)
ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25092 | DeleteFunctionConcurrencyRequest | train | func (m *MockLambdaAPI) DeleteFunctionConcurrencyRequest(arg0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionConcurrency... | go | {
"resource": ""
} |
q25093 | DeleteFunctionConcurrencyWithContext | train | func (m *MockLambdaAPI) DeleteFunctionConcurrencyWithContext(arg0 aws.Context, arg1 *lambda.DeleteFunctionConcurrencyInput, arg2 ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, ... | go | {
"resource": ""
} |
q25094 | DeleteFunctionRequest | train | func (m *MockLambdaAPI) DeleteFunctionRequest(arg0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
ret := m.ctrl.Call(m, "DeleteFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25095 | DeleteFunctionWithContext | train | func (m *MockLambdaAPI) DeleteFunctionWithContext(arg0 aws.Context, arg1 *lambda.DeleteFunctionInput, arg2 ...request.Option) (*lambda.DeleteFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteFunctionWithContext", vara... | go | {
"resource": ""
} |
q25096 | GetAccountSettings | train | func (m *MockLambdaAPI) GetAccountSettings(arg0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
ret := m.ctrl.Call(m, "GetAccountSettings", arg0)
ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q25097 | GetAccountSettingsRequest | train | func (m *MockLambdaAPI) GetAccountSettingsRequest(arg0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
ret := m.ctrl.Call(m, "GetAccountSettingsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetAccountSettingsOutput)
return ret0, ret1
} | go | {
"resource": ""
} |
q25098 | GetAccountSettingsWithContext | train | func (m *MockLambdaAPI) GetAccountSettingsWithContext(arg0 aws.Context, arg1 *lambda.GetAccountSettingsInput, arg2 ...request.Option) (*lambda.GetAccountSettingsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetAccountSettingsWi... | go | {
"resource": ""
} |
q25099 | GetAlias | train | func (m *MockLambdaAPI) GetAlias(arg0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "GetAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.