id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25000 | // remove metatable and metafield
return false
}
l.Remove(-2) // remove only metatable
return true
} | |
c25001 |
l.NewTable()
l.PushValue(-1)
l.SetField(RegistryIndex, name)
return true
} | |
c25002 | != t {
tagError(l, index, t)
}
} | |
c25003 | string) {
if !cond {
ArgumentError(l, index, extraMessage)
}
} | |
c25004 | tagError(l, index, TypeString)
panic("unreachable")
} | |
c25005 | {
if l.IsNoneOrNil(index) {
return def
}
return CheckString(l, index)
} | |
c25006 | fmt.Fprintf(os.Stderr, "PANIC: unprotected error in call to Lua API (%s)\n", s)
return 0
})
}
return l
} | |
c25007 | err
}
return l.ProtectedCall(0, MultipleReturns, 0)
} | |
c25008 |
}
return l.ProtectedCall(0, MultipleReturns, 0)
} | |
c25009 |
l.nonYieldableCallCount++
}
if !l.preCall(function, resultCount) { // is a Lua function?
l.execute() // call it
}
if !allowYield {
l.nonYieldableCallCount--
}
l.nestedGoCallCount--
} | |
c25010 |
return 1
}
l.Pop(1)
findLoader(l, name)
l.PushString(name)
l.Insert(-2)
l.Call(2, 1)
if !l.IsNil(-1) {
l.SetField(2, name)
}
l.Field(2, name)
if l.IsNil(-1) {
l.PushBoolean(true)
l.PushValue(-1)
l.SetField(2, name)
}
return 1
}}}, 1)
l.Pop(1)
return 1
} | |
c25011 | 0)
l.PushString(VersionString)
l.SetField(-2, "_VERSION")
return 1
} | |
c25012 | nextToken, start, err = l.fetch(nextToken, start, ch)
if err != nil {
l.err = fmt.Errorf("log %q: %s", l.GroupName, err)
break
}
if nextToken == nil && l.Follow {
time.Sleep(l.PollInterval)
l.Log.WithField("start", start).Debug("poll")
continue
}
if nextToken == nil {
break
}
}
} | |
c25013 | }
}
if err != nil {
return nil, 0, err
}
for _, event := range res.Events {
start = *event.Timestamp + 1
ch <- &Event{
GroupName: l.GroupName,
Message: *event.Message,
}
}
return res.NextToken, start, nil
} | |
c25014 | ignoreFile, err := utils.ReadIgnoreFile(f.Path)
if err != nil {
return errors.Wrap(err, "reading ignore file")
}
f.IgnoreFile = append(f.IgnoreFile, []byte("\n")...)
f.IgnoreFile = append(f.IgnoreFile, ignoreFile...)
return nil
} | |
c25015 | err = f.tryConfig("function.json")
if err != nil {
return err
}
if ok {
f.Log.WithField("config", "function.json").Debug("loaded config")
return nil
}
return nil
} | |
c25016 | f.Environment[name] = value
} | |
c25017 |
if f.configChanged(config) {
f.Log.Debug("config changed")
return f.DeployConfigAndCode(zip)
}
f.Log.Info("config unchanged")
return f.DeployCode(zip, config)
} | |
c25018 | := f.versions()
if err != nil {
return err
}
version = versions[len(versions)-1].Version
}
return f.CreateOrUpdateAlias(f.Alias, *version)
}
f.Log.WithFields(log.Fields{
"local": localHash,
"remote": remoteHash,
}).Debug("code changed")
return f.Update(zip)
} | |
c25019 | aws.StringSlice(f.VPC.Subnets),
},
}
if f.DeadLetterARN != "" {
params.DeadLetterConfig = &lambda.DeadLetterConfig{
TargetArn: &f.DeadLetterARN,
}
}
_, err := f.Service.UpdateFunctionConfiguration(params)
if err != nil {
return err
}
return f.Update(zip)
} | |
c25020 | err != nil {
return err
}
f.Log.Info("function deleted")
return nil
} | |
c25021 | config")
return f.Service.GetFunction(&lambda.GetFunctionInput{
FunctionName: &f.FunctionName,
})
} | |
c25022 | config")
return f.Service.GetFunction(&lambda.GetFunctionInput{
FunctionName: &f.FunctionName,
Qualifier: &s,
})
} | |
c25023 | error) {
return f.GetConfigQualifier(f.Alias)
} | |
c25024 | {
return err
}
f.Log.WithFields(log.Fields{
"version": *updated.Version,
"name": f.FunctionName,
}).Info("function updated")
return f.cleanup()
} | |
c25025 |
if f.DeadLetterARN != "" {
params.DeadLetterConfig = &lambda.DeadLetterConfig{
TargetArn: &f.DeadLetterARN,
}
}
created, err := f.Service.CreateFunction(params)
if err != nil {
return err
}
if err := f.CreateOrUpdateAlias(f.Alias, *created.Version); err != nil {
return err
}
f.Log.WithFields(log.... | |
c25026 | FunctionName: &f.FunctionName,
FunctionVersion: &version,
Name: &alias,
})
if err != nil {
return err
}
f.Log.WithField("version", version).Infof("updated alias %s", alias)
return nil
} | |
c25027 | aliases")
return f.Service.ListAliases(&lambda.ListAliasesInput{
FunctionName: &f.FunctionName,
})
} | |
c25028 | eventBytes,
})
if err != nil {
return nil, nil, err
}
logs = base64.NewDecoder(base64.StdEncoding, strings.NewReader(*res.LogResult))
if res.FunctionError != nil {
e := &InvokeError{
Handled: *res.FunctionError == "Handled",
}
if err := json.Unmarshal(res.Payload, e); err != nil {
return nil, l... | |
c25029 |
_, err = f.Service.UpdateAlias(&lambda.UpdateAliasInput{
FunctionName: &f.FunctionName,
Name: &f.Alias,
FunctionVersion: &rollback,
})
if err != nil {
return err
}
f.Log.WithField("current version", rollback).Info("function rolled back")
return nil
} | |
c25030 | _, err = f.Service.UpdateAlias(&lambda.UpdateAliasInput{
FunctionName: &f.FunctionName,
Name: &f.Alias,
FunctionVersion: &version,
})
if err != nil {
return err
}
f.Log.WithField("current version", version).Info("function rolled back")
return nil
} | |
c25031 | f.Log.Debugf("reading zip %q", f.Zip)
return ioutil.ReadFile(f.Zip)
} | |
c25032 | err
}
f.Log.Debugf("created build (%s)", humanize.Bytes(uint64(len(b))))
return b, nil
} | |
c25033 | if err != nil {
return nil, err
}
if err := zip.AddDir(linkPath, path); err != nil {
return nil, err
}
} else {
if err := zip.AddFile(path, fh); err != nil {
return nil, err
}
}
if err := fh.Close(); err != nil {
return nil, err
}
}
if err := zip.Close(); err != nil {
retur... | |
c25034 | {
if strings.Compare(version, *fnAlias.Name) == 0 {
version = *fnAlias.FunctionVersion
break
}
}
return version, nil
} | |
c25035 | err
}
return f.removeVersions(versionsToCleanup)
} | |
c25036 | for {
page, err := f.Service.ListVersionsByFunction(&request)
if err != nil {
return nil, err
}
list = append(list, page.Versions...)
if page.NextMarker == nil {
break
}
request.Marker = page.NextMarker
}
versions := list[1:] // remove $LATEST
return versions, nil
} | |
c25037 |
if len(versions) > *f.RetainedVersions {
return versions[:len(versions)-*f.RetainedVersions], nil
}
return nil, nil
} | |
c25038 |
FunctionName: &f.FunctionName,
Qualifier: v.Version,
})
if err != nil {
return err
}
}
return nil
} | |
c25039 | FunctionName: &f.FunctionName,
Name: &f.Alias,
})
} | |
c25040 | remoteConfig.DeadLetterConfig = lambda.DeadLetterConfig{
TargetArn: config.Configuration.DeadLetterConfig.TargetArn,
}
}
// SDK is inconsistent here. VpcConfig can be nil or empty struct.
remoteConfig.VPC = vpc.VPC{Subnets: []string{}, SecurityGroups: []string{}}
if config.Configuration.VpcConfig != nil {
... | |
c25041 | if err := p.Open(f); err != nil {
return err
}
}
}
return nil
} | |
c25042 |
if p, ok := plugins[name].(Builder); ok {
if err := p.Build(f, zip); err != nil {
return err
}
}
}
return nil
} | |
c25043 | err := p.Clean(f); err != nil {
return err
}
}
}
return nil
} | |
c25044 | err := p.Deploy(f); err != nil {
return err
}
}
}
return nil
} | |
c25045 | aws.String(v)
}
}
return &lambda.Environment{Variables: env}
} | |
c25046 | range keys {
pairs = append(pairs, fmt.Sprintf("%s=%s", k, *env[k]))
}
return pairs
} | |
c25047 |
region = "us-east-1"
}
if len(region) > 0 {
return aws.NewConfig().WithRegion(region)
}
return nil
} | |
c25048 | markdown.New(markdown.XHTMLOutput(true), markdown.Nofollow(true))
v := &renderer{}
s := v.visit(md.Parse(in.Bytes()))
return strings.NewReader(s)
} | |
c25049 | ", n)
return i + strings.Replace(s, "\n", "\n"+i, -1)
} | |
c25050 | {
s += r.visitToken(t)
}
return
} | |
c25051 |
case *markdown.StrongOpen:
return "\033[1m"
case *markdown.StrongClose:
return "\033[0m"
case *markdown.BulletListOpen:
r.inList = true
return "\n"
case *markdown.BulletListClose:
r.inList = false
return "\n"
case *markdown.ListItemOpen:
return " - "
case *markdown.LinkOpen:
r.inLink = t.(*markd... | |
c25052 |
// Support "python" for backwards compat.
if fn.Runtime == "python" {
fn.Runtime = "python2.7"
}
if fn.Handler == "" {
fn.Handler = "main.handle"
}
return nil
} | |
c25053 | < 1 {
return errors.New("Missing name argument")
}
name = args[0]
return nil
} | |
c25054 | strings.NewReader("{}")
}
return os.Stdin
} | |
c25055 | append(os.Environ(), fmt.Sprintf("AWS_REGION=%s", p.Region))
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = filepath.Join(Dir, p.Environment)
return cmd.Run()
} | |
c25056 | == "plan" || args[0] == "apply" || args[0] == "destroy" || args[0] == "refresh"
} | |
c25057 | out, err := cmd.CombinedOutput()
if err != nil {
return "", err
}
return strings.Trim(string(out), "\n"), nil
} | |
c25058 | path,
Method: zip.Deflate,
}
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = zippedFile.Write(contents)
return err
} | |
c25059 | files supported: " + path)
}
header, err := zip.FileInfoHeader(info)
if err != nil {
return err
}
header.Name = path
header.Method = zip.Deflate
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = io.Copy(zippedFile, file)
return ... | |
c25060 |
rel, err := filepath.Rel(root, path)
if err != nil {
return err
}
archivePath := filepath.Join(target, rel)
return z.AddFile(archivePath, file)
})
} | |
c25061 | Lambda: lambda.New(session),
}
} | |
c25062 | "runtime": *in.Runtime,
"memory": *in.MemorySize,
"timeout": *in.Timeout,
"handler": *in.Handler,
})
out := &lambda.FunctionConfiguration{
Version: aws.String("1"),
}
return out, nil
} | |
c25063 | l.create("function", *in.FunctionName, map[string]interface{}{
"size": fmt.Sprintf("%s -> %s", humanize.Bytes(remoteSize), humanize.Bytes(size)),
})
}
out := &lambda.FunctionConfiguration{
Version: aws.String("$LATEST"),
}
return out, nil
} | |
c25064 |
if *in.MemorySize != *res.MemorySize {
m["memory"] = fmt.Sprintf("%v -> %v", *res.MemorySize, *in.MemorySize)
}
if *in.Role != *res.Role {
m["role"] = fmt.Sprintf("%v -> %v", *res.Role, *in.Role)
}
if *in.Timeout != *res.Timeout {
m["timeout"] = fmt.Sprintf("%v -> %v", *res.Timeout, *in.Timeout)
}
if ... | |
c25065 | {
l.remove("function version", fmt.Sprintf("%s (version: %s)", *in.FunctionName, *in.Qualifier), nil)
}
return nil, nil
} | |
c25066 |
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | |
c25067 |
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | |
c25068 | l.log(kind, name, m, '+', green)
} | |
c25069 | l.log(kind, name, m, '~', yellow)
} | |
c25070 | l.log(kind, name, m, '-', red)
} | |
c25071 |
mock.recorder = &MockProviderifaceMockRecorder{mock}
return mock
} | |
c25072 |
ret := m.ctrl.Call(m, "NewService", arg0)
ret0, _ := ret[0].(lambdaiface.LambdaAPI)
return ret0
} | |
c25073 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewService", reflect.TypeOf((*MockProvideriface)(nil).NewService), arg0)
} | |
c25074 | mock.recorder = &MockLambdaAPIMockRecorder{mock}
return mock
} | |
c25075 | ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25076 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AddPermissionOutput)
return ret0, ret1
} | |
c25077 | }
ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25078 | _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25079 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | |
c25080 | }
ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25081 | ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25082 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | |
c25083 | ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25084 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | |
c25085 | _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25086 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteAliasOutput)
return ret0, ret1
} | |
c25087 | }
ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25088 | ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25089 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | |
c25090 | ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25091 | ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25092 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionConcurrencyOutput)
return ret0, ret1
} | |
c25093 | append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25094 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionOutput)
return ret0, ret1
} | |
c25095 | }
ret := m.ctrl.Call(m, "DeleteFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25096 | ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25097 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetAccountSettingsOutput)
return ret0, ret1
} | |
c25098 |
}
ret := m.ctrl.Call(m, "GetAccountSettingsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c25099 | _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.