repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
rqlite/rqlite
|
auth/credential_store.go
|
HasPerm
|
func (c *CredentialsStore) HasPerm(username string, perm string) bool {
m, ok := c.perms[username]
if !ok {
return false
}
if _, ok := m[perm]; !ok {
return false
}
return true
}
|
go
|
func (c *CredentialsStore) HasPerm(username string, perm string) bool {
m, ok := c.perms[username]
if !ok {
return false
}
if _, ok := m[perm]; !ok {
return false
}
return true
}
|
[
"func",
"(",
"c",
"*",
"CredentialsStore",
")",
"HasPerm",
"(",
"username",
"string",
",",
"perm",
"string",
")",
"bool",
"{",
"m",
",",
"ok",
":=",
"c",
".",
"perms",
"[",
"username",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"m",
"[",
"perm",
"]",
";",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// HasPerm returns true if username has the given perm. It does not
// perform any password checking.
|
[
"HasPerm",
"returns",
"true",
"if",
"username",
"has",
"the",
"given",
"perm",
".",
"It",
"does",
"not",
"perform",
"any",
"password",
"checking",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/auth/credential_store.go#L90-L100
|
train
|
rqlite/rqlite
|
auth/credential_store.go
|
HasAnyPerm
|
func (c *CredentialsStore) HasAnyPerm(username string, perm ...string) bool {
return func(p []string) bool {
for i := range p {
if c.HasPerm(username, p[i]) {
return true
}
}
return false
}(perm)
}
|
go
|
func (c *CredentialsStore) HasAnyPerm(username string, perm ...string) bool {
return func(p []string) bool {
for i := range p {
if c.HasPerm(username, p[i]) {
return true
}
}
return false
}(perm)
}
|
[
"func",
"(",
"c",
"*",
"CredentialsStore",
")",
"HasAnyPerm",
"(",
"username",
"string",
",",
"perm",
"...",
"string",
")",
"bool",
"{",
"return",
"func",
"(",
"p",
"[",
"]",
"string",
")",
"bool",
"{",
"for",
"i",
":=",
"range",
"p",
"{",
"if",
"c",
".",
"HasPerm",
"(",
"username",
",",
"p",
"[",
"i",
"]",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"(",
"perm",
")",
"\n",
"}"
] |
// HasAnyPerm returns true if username has at least one of the given perms.
// It does not perform any password checking.
|
[
"HasAnyPerm",
"returns",
"true",
"if",
"username",
"has",
"at",
"least",
"one",
"of",
"the",
"given",
"perms",
".",
"It",
"does",
"not",
"perform",
"any",
"password",
"checking",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/auth/credential_store.go#L104-L113
|
train
|
rqlite/rqlite
|
auth/credential_store.go
|
HasPermRequest
|
func (c *CredentialsStore) HasPermRequest(b BasicAuther, perm string) bool {
username, _, ok := b.BasicAuth()
if !ok {
return false
}
return c.HasPerm(username, perm)
}
|
go
|
func (c *CredentialsStore) HasPermRequest(b BasicAuther, perm string) bool {
username, _, ok := b.BasicAuth()
if !ok {
return false
}
return c.HasPerm(username, perm)
}
|
[
"func",
"(",
"c",
"*",
"CredentialsStore",
")",
"HasPermRequest",
"(",
"b",
"BasicAuther",
",",
"perm",
"string",
")",
"bool",
"{",
"username",
",",
"_",
",",
"ok",
":=",
"b",
".",
"BasicAuth",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"c",
".",
"HasPerm",
"(",
"username",
",",
"perm",
")",
"\n",
"}"
] |
// HasPermRequest returns true if the username returned by b has the givem perm.
// It does not perform any password checking, but if there is no username
// in the request, it returns false.
|
[
"HasPermRequest",
"returns",
"true",
"if",
"the",
"username",
"returned",
"by",
"b",
"has",
"the",
"givem",
"perm",
".",
"It",
"does",
"not",
"perform",
"any",
"password",
"checking",
"but",
"if",
"there",
"is",
"no",
"username",
"in",
"the",
"request",
"it",
"returns",
"false",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/auth/credential_store.go#L118-L124
|
train
|
rqlite/rqlite
|
store/connection.go
|
NewConnection
|
func NewConnection(c *sdb.Conn, s *Store, id uint64, it, tt time.Duration) *Connection {
now := time.Now()
conn := Connection{
db: c,
store: s,
ID: id,
CreatedAt: now,
LastUsedAt: now,
IdleTimeout: it,
TxTimeout: tt,
logger: log.New(os.Stderr, connectionLogPrefix(id), log.LstdFlags),
}
return &conn
}
|
go
|
func NewConnection(c *sdb.Conn, s *Store, id uint64, it, tt time.Duration) *Connection {
now := time.Now()
conn := Connection{
db: c,
store: s,
ID: id,
CreatedAt: now,
LastUsedAt: now,
IdleTimeout: it,
TxTimeout: tt,
logger: log.New(os.Stderr, connectionLogPrefix(id), log.LstdFlags),
}
return &conn
}
|
[
"func",
"NewConnection",
"(",
"c",
"*",
"sdb",
".",
"Conn",
",",
"s",
"*",
"Store",
",",
"id",
"uint64",
",",
"it",
",",
"tt",
"time",
".",
"Duration",
")",
"*",
"Connection",
"{",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"conn",
":=",
"Connection",
"{",
"db",
":",
"c",
",",
"store",
":",
"s",
",",
"ID",
":",
"id",
",",
"CreatedAt",
":",
"now",
",",
"LastUsedAt",
":",
"now",
",",
"IdleTimeout",
":",
"it",
",",
"TxTimeout",
":",
"tt",
",",
"logger",
":",
"log",
".",
"New",
"(",
"os",
".",
"Stderr",
",",
"connectionLogPrefix",
"(",
"id",
")",
",",
"log",
".",
"LstdFlags",
")",
",",
"}",
"\n",
"return",
"&",
"conn",
"\n",
"}"
] |
// NewConnection returns a connection to the database.
|
[
"NewConnection",
"returns",
"a",
"connection",
"to",
"the",
"database",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L41-L54
|
train
|
rqlite/rqlite
|
store/connection.go
|
Restore
|
func (c *Connection) Restore(dbConn *sdb.Conn, s *Store) {
c.dbMu.Lock()
defer c.dbMu.Unlock()
c.db = dbConn
c.store = s
c.logger = log.New(os.Stderr, connectionLogPrefix(c.ID), log.LstdFlags)
}
|
go
|
func (c *Connection) Restore(dbConn *sdb.Conn, s *Store) {
c.dbMu.Lock()
defer c.dbMu.Unlock()
c.db = dbConn
c.store = s
c.logger = log.New(os.Stderr, connectionLogPrefix(c.ID), log.LstdFlags)
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"Restore",
"(",
"dbConn",
"*",
"sdb",
".",
"Conn",
",",
"s",
"*",
"Store",
")",
"{",
"c",
".",
"dbMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"db",
"=",
"dbConn",
"\n",
"c",
".",
"store",
"=",
"s",
"\n",
"c",
".",
"logger",
"=",
"log",
".",
"New",
"(",
"os",
".",
"Stderr",
",",
"connectionLogPrefix",
"(",
"c",
".",
"ID",
")",
",",
"log",
".",
"LstdFlags",
")",
"\n",
"}"
] |
// Restore prepares a partially ready connection.
|
[
"Restore",
"prepares",
"a",
"partially",
"ready",
"connection",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L57-L63
|
train
|
rqlite/rqlite
|
store/connection.go
|
SetLastUsedNow
|
func (c *Connection) SetLastUsedNow() {
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.LastUsedAt = time.Now()
}
|
go
|
func (c *Connection) SetLastUsedNow() {
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.LastUsedAt = time.Now()
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"SetLastUsedNow",
"(",
")",
"{",
"c",
".",
"timeMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"timeMu",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"LastUsedAt",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}"
] |
// SetLastUsedNow marks the connection as being used now.
|
[
"SetLastUsedNow",
"marks",
"the",
"connection",
"as",
"being",
"used",
"now",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L66-L70
|
train
|
rqlite/rqlite
|
store/connection.go
|
TransactionActive
|
func (c *Connection) TransactionActive() bool {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return false
}
return c.db.TransactionActive()
}
|
go
|
func (c *Connection) TransactionActive() bool {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return false
}
return c.db.TransactionActive()
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"TransactionActive",
"(",
")",
"bool",
"{",
"c",
".",
"dbMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"c",
".",
"db",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"c",
".",
"db",
".",
"TransactionActive",
"(",
")",
"\n",
"}"
] |
// TransactionActive returns whether a transaction is active on the connection.
|
[
"TransactionActive",
"returns",
"whether",
"a",
"transaction",
"is",
"active",
"on",
"the",
"connection",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L78-L85
|
train
|
rqlite/rqlite
|
store/connection.go
|
Execute
|
func (c *Connection) Execute(ex *ExecuteRequest) (*ExecuteResponse, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.execute(c, ex)
}
|
go
|
func (c *Connection) Execute(ex *ExecuteRequest) (*ExecuteResponse, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.execute(c, ex)
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"Execute",
"(",
"ex",
"*",
"ExecuteRequest",
")",
"(",
"*",
"ExecuteResponse",
",",
"error",
")",
"{",
"c",
".",
"dbMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"c",
".",
"db",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrConnectionDoesNotExist",
"\n",
"}",
"\n",
"return",
"c",
".",
"store",
".",
"execute",
"(",
"c",
",",
"ex",
")",
"\n",
"}"
] |
// Execute executes queries that return no rows, but do modify the database.
|
[
"Execute",
"executes",
"queries",
"that",
"return",
"no",
"rows",
"but",
"do",
"modify",
"the",
"database",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L88-L95
|
train
|
rqlite/rqlite
|
store/connection.go
|
ExecuteOrAbort
|
func (c *Connection) ExecuteOrAbort(ex *ExecuteRequest) (resp *ExecuteResponse, retErr error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.executeOrAbort(c, ex)
}
|
go
|
func (c *Connection) ExecuteOrAbort(ex *ExecuteRequest) (resp *ExecuteResponse, retErr error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.executeOrAbort(c, ex)
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"ExecuteOrAbort",
"(",
"ex",
"*",
"ExecuteRequest",
")",
"(",
"resp",
"*",
"ExecuteResponse",
",",
"retErr",
"error",
")",
"{",
"c",
".",
"dbMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"c",
".",
"db",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrConnectionDoesNotExist",
"\n",
"}",
"\n",
"return",
"c",
".",
"store",
".",
"executeOrAbort",
"(",
"c",
",",
"ex",
")",
"\n",
"}"
] |
// ExecuteOrAbort executes the requests, but aborts any active transaction
// on the underlying database in the case of any error.
|
[
"ExecuteOrAbort",
"executes",
"the",
"requests",
"but",
"aborts",
"any",
"active",
"transaction",
"on",
"the",
"underlying",
"database",
"in",
"the",
"case",
"of",
"any",
"error",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L99-L106
|
train
|
rqlite/rqlite
|
store/connection.go
|
Query
|
func (c *Connection) Query(qr *QueryRequest) (*QueryResponse, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.query(c, qr)
}
|
go
|
func (c *Connection) Query(qr *QueryRequest) (*QueryResponse, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.query(c, qr)
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"Query",
"(",
"qr",
"*",
"QueryRequest",
")",
"(",
"*",
"QueryResponse",
",",
"error",
")",
"{",
"c",
".",
"dbMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"c",
".",
"db",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrConnectionDoesNotExist",
"\n",
"}",
"\n",
"return",
"c",
".",
"store",
".",
"query",
"(",
"c",
",",
"qr",
")",
"\n",
"}"
] |
// Query executes queries that return rows, and do not modify the database.
|
[
"Query",
"executes",
"queries",
"that",
"return",
"rows",
"and",
"do",
"not",
"modify",
"the",
"database",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L109-L116
|
train
|
rqlite/rqlite
|
store/connection.go
|
Close
|
func (c *Connection) Close() error {
c.dbMu.Lock()
defer c.dbMu.Unlock()
if c.store != nil {
if err := c.store.disconnect(c); err != nil {
return err
}
}
if c.db == nil {
return nil
}
if err := c.db.Close(); err != nil {
return err
}
c.db = nil
return nil
}
|
go
|
func (c *Connection) Close() error {
c.dbMu.Lock()
defer c.dbMu.Unlock()
if c.store != nil {
if err := c.store.disconnect(c); err != nil {
return err
}
}
if c.db == nil {
return nil
}
if err := c.db.Close(); err != nil {
return err
}
c.db = nil
return nil
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"Close",
"(",
")",
"error",
"{",
"c",
".",
"dbMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"c",
".",
"store",
"!=",
"nil",
"{",
"if",
"err",
":=",
"c",
".",
"store",
".",
"disconnect",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"db",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"c",
".",
"db",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close closes the connection via consensus.
|
[
"Close",
"closes",
"the",
"connection",
"via",
"consensus",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L133-L151
|
train
|
rqlite/rqlite
|
store/connection.go
|
Stats
|
func (c *Connection) Stats() (interface{}, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.txStateMu.Lock()
defer c.txStateMu.Unlock()
fkEnabled, err := c.db.FKConstraints()
if err != nil {
return nil, err
}
m := make(map[string]interface{})
m["last_used_at"] = c.LastUsedAt
m["created_at"] = c.CreatedAt
m["idle_timeout"] = c.IdleTimeout.String()
m["tx_timeout"] = c.TxTimeout.String()
m["id"] = c.ID
m["fk_constraints"] = enabledFromBool(fkEnabled)
if !c.TxStartedAt.IsZero() {
m["tx_started_at"] = c.TxStartedAt.String()
}
return m, nil
}
|
go
|
func (c *Connection) Stats() (interface{}, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.txStateMu.Lock()
defer c.txStateMu.Unlock()
fkEnabled, err := c.db.FKConstraints()
if err != nil {
return nil, err
}
m := make(map[string]interface{})
m["last_used_at"] = c.LastUsedAt
m["created_at"] = c.CreatedAt
m["idle_timeout"] = c.IdleTimeout.String()
m["tx_timeout"] = c.TxTimeout.String()
m["id"] = c.ID
m["fk_constraints"] = enabledFromBool(fkEnabled)
if !c.TxStartedAt.IsZero() {
m["tx_started_at"] = c.TxStartedAt.String()
}
return m, nil
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"Stats",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"c",
".",
"dbMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"dbMu",
".",
"RUnlock",
"(",
")",
"\n",
"c",
".",
"timeMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"timeMu",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"txStateMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"txStateMu",
".",
"Unlock",
"(",
")",
"\n\n",
"fkEnabled",
",",
"err",
":=",
"c",
".",
"db",
".",
"FKConstraints",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"LastUsedAt",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"CreatedAt",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"IdleTimeout",
".",
"String",
"(",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"TxTimeout",
".",
"String",
"(",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"ID",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"enabledFromBool",
"(",
"fkEnabled",
")",
"\n",
"if",
"!",
"c",
".",
"TxStartedAt",
".",
"IsZero",
"(",
")",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"TxStartedAt",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// Stats returns the status of the connection.
|
[
"Stats",
"returns",
"the",
"status",
"of",
"the",
"connection",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L154-L178
|
train
|
rqlite/rqlite
|
store/connection.go
|
IdleTimedOut
|
func (c *Connection) IdleTimedOut() bool {
c.timeMu.Lock()
defer c.timeMu.Unlock()
return time.Since(c.LastUsedAt) > c.IdleTimeout && c.IdleTimeout != 0
}
|
go
|
func (c *Connection) IdleTimedOut() bool {
c.timeMu.Lock()
defer c.timeMu.Unlock()
return time.Since(c.LastUsedAt) > c.IdleTimeout && c.IdleTimeout != 0
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"IdleTimedOut",
"(",
")",
"bool",
"{",
"c",
".",
"timeMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"timeMu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"time",
".",
"Since",
"(",
"c",
".",
"LastUsedAt",
")",
">",
"c",
".",
"IdleTimeout",
"&&",
"c",
".",
"IdleTimeout",
"!=",
"0",
"\n",
"}"
] |
// IdleTimedOut returns if the connection has not been active in the idle time.
|
[
"IdleTimedOut",
"returns",
"if",
"the",
"connection",
"has",
"not",
"been",
"active",
"in",
"the",
"idle",
"time",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L181-L185
|
train
|
rqlite/rqlite
|
store/connection.go
|
TxTimedOut
|
func (c *Connection) TxTimedOut() bool {
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.txStateMu.Lock()
defer c.txStateMu.Unlock()
lau := c.LastUsedAt
return !c.TxStartedAt.IsZero() && time.Since(lau) > c.TxTimeout && c.TxTimeout != 0
}
|
go
|
func (c *Connection) TxTimedOut() bool {
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.txStateMu.Lock()
defer c.txStateMu.Unlock()
lau := c.LastUsedAt
return !c.TxStartedAt.IsZero() && time.Since(lau) > c.TxTimeout && c.TxTimeout != 0
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"TxTimedOut",
"(",
")",
"bool",
"{",
"c",
".",
"timeMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"timeMu",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"txStateMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"txStateMu",
".",
"Unlock",
"(",
")",
"\n",
"lau",
":=",
"c",
".",
"LastUsedAt",
"\n",
"return",
"!",
"c",
".",
"TxStartedAt",
".",
"IsZero",
"(",
")",
"&&",
"time",
".",
"Since",
"(",
"lau",
")",
">",
"c",
".",
"TxTimeout",
"&&",
"c",
".",
"TxTimeout",
"!=",
"0",
"\n",
"}"
] |
// TxTimedOut returns if the transaction has been open, without activity in
// transaction-idle time.
|
[
"TxTimedOut",
"returns",
"if",
"the",
"transaction",
"has",
"been",
"open",
"without",
"activity",
"in",
"transaction",
"-",
"idle",
"time",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L189-L196
|
train
|
rqlite/rqlite
|
store/connection.go
|
NewTxStateChange
|
func NewTxStateChange(c *Connection) *TxStateChange {
return &TxStateChange{
c: c,
tx: c.TransactionActive(),
}
}
|
go
|
func NewTxStateChange(c *Connection) *TxStateChange {
return &TxStateChange{
c: c,
tx: c.TransactionActive(),
}
}
|
[
"func",
"NewTxStateChange",
"(",
"c",
"*",
"Connection",
")",
"*",
"TxStateChange",
"{",
"return",
"&",
"TxStateChange",
"{",
"c",
":",
"c",
",",
"tx",
":",
"c",
".",
"TransactionActive",
"(",
")",
",",
"}",
"\n",
"}"
] |
// NewTxStateChange returns an initialized TxStateChange
|
[
"NewTxStateChange",
"returns",
"an",
"initialized",
"TxStateChange"
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L211-L216
|
train
|
rqlite/rqlite
|
store/connection.go
|
CheckAndSet
|
func (t *TxStateChange) CheckAndSet() {
t.c.txStateMu.Lock()
defer t.c.txStateMu.Unlock()
defer func() { t.done = true }()
if t.done {
panic("CheckAndSet should only be called once")
}
if !t.tx && t.c.TransactionActive() && t.c.TxStartedAt.IsZero() {
t.c.TxStartedAt = time.Now()
} else if t.tx && !t.c.TransactionActive() && !t.c.TxStartedAt.IsZero() {
t.c.TxStartedAt = time.Time{}
}
}
|
go
|
func (t *TxStateChange) CheckAndSet() {
t.c.txStateMu.Lock()
defer t.c.txStateMu.Unlock()
defer func() { t.done = true }()
if t.done {
panic("CheckAndSet should only be called once")
}
if !t.tx && t.c.TransactionActive() && t.c.TxStartedAt.IsZero() {
t.c.TxStartedAt = time.Now()
} else if t.tx && !t.c.TransactionActive() && !t.c.TxStartedAt.IsZero() {
t.c.TxStartedAt = time.Time{}
}
}
|
[
"func",
"(",
"t",
"*",
"TxStateChange",
")",
"CheckAndSet",
"(",
")",
"{",
"t",
".",
"c",
".",
"txStateMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"c",
".",
"txStateMu",
".",
"Unlock",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"t",
".",
"done",
"=",
"true",
"}",
"(",
")",
"\n\n",
"if",
"t",
".",
"done",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"t",
".",
"tx",
"&&",
"t",
".",
"c",
".",
"TransactionActive",
"(",
")",
"&&",
"t",
".",
"c",
".",
"TxStartedAt",
".",
"IsZero",
"(",
")",
"{",
"t",
".",
"c",
".",
"TxStartedAt",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"else",
"if",
"t",
".",
"tx",
"&&",
"!",
"t",
".",
"c",
".",
"TransactionActive",
"(",
")",
"&&",
"!",
"t",
".",
"c",
".",
"TxStartedAt",
".",
"IsZero",
"(",
")",
"{",
"t",
".",
"c",
".",
"TxStartedAt",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n",
"}"
] |
// CheckAndSet sets whether a transaction has begun or ended on the
// connection since the TxStateChange was created. Once CheckAndSet
// has been called, this function will panic if called a second time.
|
[
"CheckAndSet",
"sets",
"whether",
"a",
"transaction",
"has",
"begun",
"or",
"ended",
"on",
"the",
"connection",
"since",
"the",
"TxStateChange",
"was",
"created",
".",
"Once",
"CheckAndSet",
"has",
"been",
"called",
"this",
"function",
"will",
"panic",
"if",
"called",
"a",
"second",
"time",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/connection.go#L221-L235
|
train
|
rqlite/rqlite
|
store/db_config.go
|
NewDBConfig
|
func NewDBConfig(dsn string, memory bool) *DBConfig {
return &DBConfig{DSN: dsn, Memory: memory}
}
|
go
|
func NewDBConfig(dsn string, memory bool) *DBConfig {
return &DBConfig{DSN: dsn, Memory: memory}
}
|
[
"func",
"NewDBConfig",
"(",
"dsn",
"string",
",",
"memory",
"bool",
")",
"*",
"DBConfig",
"{",
"return",
"&",
"DBConfig",
"{",
"DSN",
":",
"dsn",
",",
"Memory",
":",
"memory",
"}",
"\n",
"}"
] |
// NewDBConfig returns a new DB config instance.
|
[
"NewDBConfig",
"returns",
"a",
"new",
"DB",
"config",
"instance",
"."
] |
12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3
|
https://github.com/rqlite/rqlite/blob/12a954c7ef29a9060870c0b5c6c4d8a9e8c35ce3/store/db_config.go#L10-L12
|
train
|
Shopify/go-lua
|
string.go
|
StringOpen
|
func StringOpen(l *State) int {
NewLibrary(l, stringLibrary)
l.CreateTable(0, 1)
l.PushString("")
l.PushValue(-2)
l.SetMetaTable(-2)
l.Pop(1)
l.PushValue(-2)
l.SetField(-2, "__index")
l.Pop(1)
return 1
}
|
go
|
func StringOpen(l *State) int {
NewLibrary(l, stringLibrary)
l.CreateTable(0, 1)
l.PushString("")
l.PushValue(-2)
l.SetMetaTable(-2)
l.Pop(1)
l.PushValue(-2)
l.SetField(-2, "__index")
l.Pop(1)
return 1
}
|
[
"func",
"StringOpen",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"NewLibrary",
"(",
"l",
",",
"stringLibrary",
")",
"\n",
"l",
".",
"CreateTable",
"(",
"0",
",",
"1",
")",
"\n",
"l",
".",
"PushString",
"(",
"\"",
"\"",
")",
"\n",
"l",
".",
"PushValue",
"(",
"-",
"2",
")",
"\n",
"l",
".",
"SetMetaTable",
"(",
"-",
"2",
")",
"\n",
"l",
".",
"Pop",
"(",
"1",
")",
"\n",
"l",
".",
"PushValue",
"(",
"-",
"2",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"l",
".",
"Pop",
"(",
"1",
")",
"\n",
"return",
"1",
"\n",
"}"
] |
// StringOpen opens the string library. Usually passed to Require.
|
[
"StringOpen",
"opens",
"the",
"string",
"library",
".",
"Usually",
"passed",
"to",
"Require",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/string.go#L235-L246
|
train
|
Shopify/go-lua
|
lua.go
|
AtPanic
|
func AtPanic(l *State, panicFunction Function) Function {
panicFunction, l.global.panicFunction = l.global.panicFunction, panicFunction
return panicFunction
}
|
go
|
func AtPanic(l *State, panicFunction Function) Function {
panicFunction, l.global.panicFunction = l.global.panicFunction, panicFunction
return panicFunction
}
|
[
"func",
"AtPanic",
"(",
"l",
"*",
"State",
",",
"panicFunction",
"Function",
")",
"Function",
"{",
"panicFunction",
",",
"l",
".",
"global",
".",
"panicFunction",
"=",
"l",
".",
"global",
".",
"panicFunction",
",",
"panicFunction",
"\n",
"return",
"panicFunction",
"\n",
"}"
] |
// AtPanic sets a new panic function and returns the old one.
|
[
"AtPanic",
"sets",
"a",
"new",
"panic",
"function",
"and",
"returns",
"the",
"old",
"one",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/lua.go#L628-L631
|
train
|
Shopify/go-lua
|
lua.go
|
UpValue
|
func UpValue(l *State, function, index int) (name string, ok bool) {
if c, isClosure := l.indexToValue(function).(closure); isClosure {
if ok = 1 <= index && index <= c.upValueCount(); ok {
if c, isLua := c.(*luaClosure); isLua {
name = c.prototype.upValues[index-1].name
}
l.apiPush(c.upValue(index - 1))
}
}
return
}
|
go
|
func UpValue(l *State, function, index int) (name string, ok bool) {
if c, isClosure := l.indexToValue(function).(closure); isClosure {
if ok = 1 <= index && index <= c.upValueCount(); ok {
if c, isLua := c.(*luaClosure); isLua {
name = c.prototype.upValues[index-1].name
}
l.apiPush(c.upValue(index - 1))
}
}
return
}
|
[
"func",
"UpValue",
"(",
"l",
"*",
"State",
",",
"function",
",",
"index",
"int",
")",
"(",
"name",
"string",
",",
"ok",
"bool",
")",
"{",
"if",
"c",
",",
"isClosure",
":=",
"l",
".",
"indexToValue",
"(",
"function",
")",
".",
"(",
"closure",
")",
";",
"isClosure",
"{",
"if",
"ok",
"=",
"1",
"<=",
"index",
"&&",
"index",
"<=",
"c",
".",
"upValueCount",
"(",
")",
";",
"ok",
"{",
"if",
"c",
",",
"isLua",
":=",
"c",
".",
"(",
"*",
"luaClosure",
")",
";",
"isLua",
"{",
"name",
"=",
"c",
".",
"prototype",
".",
"upValues",
"[",
"index",
"-",
"1",
"]",
".",
"name",
"\n",
"}",
"\n",
"l",
".",
"apiPush",
"(",
"c",
".",
"upValue",
"(",
"index",
"-",
"1",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// UpValue returns the name of the upvalue at index away from function,
// where index cannot be greater than the number of upvalues.
//
// Returns an empty string and false if the index is greater than the number
// of upvalues.
|
[
"UpValue",
"returns",
"the",
"name",
"of",
"the",
"upvalue",
"at",
"index",
"away",
"from",
"function",
"where",
"index",
"cannot",
"be",
"greater",
"than",
"the",
"number",
"of",
"upvalues",
".",
"Returns",
"an",
"empty",
"string",
"and",
"false",
"if",
"the",
"index",
"is",
"greater",
"than",
"the",
"number",
"of",
"upvalues",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/lua.go#L1258-L1268
|
train
|
Shopify/go-lua
|
lua.go
|
UpValueJoin
|
func UpValueJoin(l *State, f1, n1, f2, n2 int) {
u1 := l.upValue(f1, n1)
u2 := l.upValue(f2, n2)
*u1 = *u2
}
|
go
|
func UpValueJoin(l *State, f1, n1, f2, n2 int) {
u1 := l.upValue(f1, n1)
u2 := l.upValue(f2, n2)
*u1 = *u2
}
|
[
"func",
"UpValueJoin",
"(",
"l",
"*",
"State",
",",
"f1",
",",
"n1",
",",
"f2",
",",
"n2",
"int",
")",
"{",
"u1",
":=",
"l",
".",
"upValue",
"(",
"f1",
",",
"n1",
")",
"\n",
"u2",
":=",
"l",
".",
"upValue",
"(",
"f2",
",",
"n2",
")",
"\n",
"*",
"u1",
"=",
"*",
"u2",
"\n",
"}"
] |
// UpValueJoin makes the n1-th upvalue of the Lua closure at index f1 refer to
// the n2-th upvalue of the Lua closure at index f2.
|
[
"UpValueJoin",
"makes",
"the",
"n1",
"-",
"th",
"upvalue",
"of",
"the",
"Lua",
"closure",
"at",
"index",
"f1",
"refer",
"to",
"the",
"n2",
"-",
"th",
"upvalue",
"of",
"the",
"Lua",
"closure",
"at",
"index",
"f2",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/lua.go#L1315-L1319
|
train
|
Shopify/go-lua
|
math.go
|
MathOpen
|
func MathOpen(l *State) int {
NewLibrary(l, mathLibrary)
l.PushNumber(3.1415926535897932384626433832795) // TODO use math.Pi instead? Values differ.
l.SetField(-2, "pi")
l.PushNumber(math.MaxFloat64)
l.SetField(-2, "huge")
return 1
}
|
go
|
func MathOpen(l *State) int {
NewLibrary(l, mathLibrary)
l.PushNumber(3.1415926535897932384626433832795) // TODO use math.Pi instead? Values differ.
l.SetField(-2, "pi")
l.PushNumber(math.MaxFloat64)
l.SetField(-2, "huge")
return 1
}
|
[
"func",
"MathOpen",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"NewLibrary",
"(",
"l",
",",
"mathLibrary",
")",
"\n",
"l",
".",
"PushNumber",
"(",
"3.1415926535897932384626433832795",
")",
"// TODO use math.Pi instead? Values differ.",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"l",
".",
"PushNumber",
"(",
"math",
".",
"MaxFloat64",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"return",
"1",
"\n",
"}"
] |
// MathOpen opens the math library. Usually passed to Require.
|
[
"MathOpen",
"opens",
"the",
"math",
"library",
".",
"Usually",
"passed",
"to",
"Require",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/math.go#L112-L119
|
train
|
Shopify/go-lua
|
io.go
|
IOOpen
|
func IOOpen(l *State) int {
NewLibrary(l, ioLibrary)
NewMetaTable(l, fileHandle)
l.PushValue(-1)
l.SetField(-2, "__index")
SetFunctions(l, fileHandleMethods, 0)
l.Pop(1)
registerStdFile(l, os.Stdin, input, "stdin")
registerStdFile(l, os.Stdout, output, "stdout")
registerStdFile(l, os.Stderr, "", "stderr")
return 1
}
|
go
|
func IOOpen(l *State) int {
NewLibrary(l, ioLibrary)
NewMetaTable(l, fileHandle)
l.PushValue(-1)
l.SetField(-2, "__index")
SetFunctions(l, fileHandleMethods, 0)
l.Pop(1)
registerStdFile(l, os.Stdin, input, "stdin")
registerStdFile(l, os.Stdout, output, "stdout")
registerStdFile(l, os.Stderr, "", "stderr")
return 1
}
|
[
"func",
"IOOpen",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"NewLibrary",
"(",
"l",
",",
"ioLibrary",
")",
"\n\n",
"NewMetaTable",
"(",
"l",
",",
"fileHandle",
")",
"\n",
"l",
".",
"PushValue",
"(",
"-",
"1",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"SetFunctions",
"(",
"l",
",",
"fileHandleMethods",
",",
"0",
")",
"\n",
"l",
".",
"Pop",
"(",
"1",
")",
"\n\n",
"registerStdFile",
"(",
"l",
",",
"os",
".",
"Stdin",
",",
"input",
",",
"\"",
"\"",
")",
"\n",
"registerStdFile",
"(",
"l",
",",
"os",
".",
"Stdout",
",",
"output",
",",
"\"",
"\"",
")",
"\n",
"registerStdFile",
"(",
"l",
",",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"return",
"1",
"\n",
"}"
] |
// IOOpen opens the io library. Usually passed to Require.
|
[
"IOOpen",
"opens",
"the",
"io",
"library",
".",
"Usually",
"passed",
"to",
"Require",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/io.go#L310-L324
|
train
|
Shopify/go-lua
|
auxiliary.go
|
Traceback
|
func Traceback(l, l1 *State, message string, level int) {
const levels1, levels2 = 12, 10
levels := countLevels(l1)
mark := 0
if levels > levels1+levels2 {
mark = levels1
}
buf := message
if buf != "" {
buf += "\n"
}
buf += "stack traceback:"
for f, ok := Stack(l1, level); ok; f, ok = Stack(l1, level) {
if level++; level == mark {
buf += "\n\t..."
level = levels - levels2
} else {
d, _ := Info(l1, "Slnt", f)
buf += "\n\t" + d.ShortSource + ":"
if d.CurrentLine > 0 {
buf += fmt.Sprintf("%d:", d.CurrentLine)
}
buf += " in " + functionName(l, d)
if d.IsTailCall {
buf += "\n\t(...tail calls...)"
}
}
}
l.PushString(buf)
}
|
go
|
func Traceback(l, l1 *State, message string, level int) {
const levels1, levels2 = 12, 10
levels := countLevels(l1)
mark := 0
if levels > levels1+levels2 {
mark = levels1
}
buf := message
if buf != "" {
buf += "\n"
}
buf += "stack traceback:"
for f, ok := Stack(l1, level); ok; f, ok = Stack(l1, level) {
if level++; level == mark {
buf += "\n\t..."
level = levels - levels2
} else {
d, _ := Info(l1, "Slnt", f)
buf += "\n\t" + d.ShortSource + ":"
if d.CurrentLine > 0 {
buf += fmt.Sprintf("%d:", d.CurrentLine)
}
buf += " in " + functionName(l, d)
if d.IsTailCall {
buf += "\n\t(...tail calls...)"
}
}
}
l.PushString(buf)
}
|
[
"func",
"Traceback",
"(",
"l",
",",
"l1",
"*",
"State",
",",
"message",
"string",
",",
"level",
"int",
")",
"{",
"const",
"levels1",
",",
"levels2",
"=",
"12",
",",
"10",
"\n",
"levels",
":=",
"countLevels",
"(",
"l1",
")",
"\n",
"mark",
":=",
"0",
"\n",
"if",
"levels",
">",
"levels1",
"+",
"levels2",
"{",
"mark",
"=",
"levels1",
"\n",
"}",
"\n",
"buf",
":=",
"message",
"\n",
"if",
"buf",
"!=",
"\"",
"\"",
"{",
"buf",
"+=",
"\"",
"\\n",
"\"",
"\n",
"}",
"\n",
"buf",
"+=",
"\"",
"\"",
"\n",
"for",
"f",
",",
"ok",
":=",
"Stack",
"(",
"l1",
",",
"level",
")",
";",
"ok",
";",
"f",
",",
"ok",
"=",
"Stack",
"(",
"l1",
",",
"level",
")",
"{",
"if",
"level",
"++",
";",
"level",
"==",
"mark",
"{",
"buf",
"+=",
"\"",
"\\n",
"\\t",
"\"",
"\n",
"level",
"=",
"levels",
"-",
"levels2",
"\n",
"}",
"else",
"{",
"d",
",",
"_",
":=",
"Info",
"(",
"l1",
",",
"\"",
"\"",
",",
"f",
")",
"\n",
"buf",
"+=",
"\"",
"\\n",
"\\t",
"\"",
"+",
"d",
".",
"ShortSource",
"+",
"\"",
"\"",
"\n",
"if",
"d",
".",
"CurrentLine",
">",
"0",
"{",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
".",
"CurrentLine",
")",
"\n",
"}",
"\n",
"buf",
"+=",
"\"",
"\"",
"+",
"functionName",
"(",
"l",
",",
"d",
")",
"\n",
"if",
"d",
".",
"IsTailCall",
"{",
"buf",
"+=",
"\"",
"\\n",
"\\t",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"l",
".",
"PushString",
"(",
"buf",
")",
"\n",
"}"
] |
// Traceback creates and pushes a traceback of the stack l1. If message is not
// nil it is appended at the beginning of the traceback. The level parameter
// tells at which level to start the traceback.
|
[
"Traceback",
"creates",
"and",
"pushes",
"a",
"traceback",
"of",
"the",
"stack",
"l1",
".",
"If",
"message",
"is",
"not",
"nil",
"it",
"is",
"appended",
"at",
"the",
"beginning",
"of",
"the",
"traceback",
".",
"The",
"level",
"parameter",
"tells",
"at",
"which",
"level",
"to",
"start",
"the",
"traceback",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L48-L77
|
train
|
Shopify/go-lua
|
auxiliary.go
|
MetaField
|
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
|
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
}
|
[
"func",
"MetaField",
"(",
"l",
"*",
"State",
",",
"index",
"int",
",",
"event",
"string",
")",
"bool",
"{",
"if",
"!",
"l",
".",
"MetaTable",
"(",
"index",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"l",
".",
"PushString",
"(",
"event",
")",
"\n",
"l",
".",
"RawGet",
"(",
"-",
"2",
")",
"\n",
"if",
"l",
".",
"IsNil",
"(",
"-",
"1",
")",
"{",
"l",
".",
"Pop",
"(",
"2",
")",
"// remove metatable and metafield",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"l",
".",
"Remove",
"(",
"-",
"2",
")",
"// remove only metatable",
"\n",
"return",
"true",
"\n",
"}"
] |
// MetaField pushes onto the stack the field event from the metatable of the
// object at index. If the object does not have a metatable, or if the
// metatable does not have this field, returns false and pushes nothing.
|
[
"MetaField",
"pushes",
"onto",
"the",
"stack",
"the",
"field",
"event",
"from",
"the",
"metatable",
"of",
"the",
"object",
"at",
"index",
".",
"If",
"the",
"object",
"does",
"not",
"have",
"a",
"metatable",
"or",
"if",
"the",
"metatable",
"does",
"not",
"have",
"this",
"field",
"returns",
"false",
"and",
"pushes",
"nothing",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L82-L94
|
train
|
Shopify/go-lua
|
auxiliary.go
|
NewMetaTable
|
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
|
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
}
|
[
"func",
"NewMetaTable",
"(",
"l",
"*",
"State",
",",
"name",
"string",
")",
"bool",
"{",
"if",
"MetaTableNamed",
"(",
"l",
",",
"name",
")",
";",
"!",
"l",
".",
"IsNil",
"(",
"-",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"l",
".",
"Pop",
"(",
"1",
")",
"\n",
"l",
".",
"NewTable",
"(",
")",
"\n",
"l",
".",
"PushValue",
"(",
"-",
"1",
")",
"\n",
"l",
".",
"SetField",
"(",
"RegistryIndex",
",",
"name",
")",
"\n",
"return",
"true",
"\n",
"}"
] |
// NewMetaTable returns false if the registry already has the key name. Otherwise,
// creates a new table to be used as a metatable for userdata, adds it to the
// registry with key name, and returns true.
//
// In both cases it pushes onto the stack the final value associated with name in
// the registry.
|
[
"NewMetaTable",
"returns",
"false",
"if",
"the",
"registry",
"already",
"has",
"the",
"key",
"name",
".",
"Otherwise",
"creates",
"a",
"new",
"table",
"to",
"be",
"used",
"as",
"a",
"metatable",
"for",
"userdata",
"adds",
"it",
"to",
"the",
"registry",
"with",
"key",
"name",
"and",
"returns",
"true",
".",
"In",
"both",
"cases",
"it",
"pushes",
"onto",
"the",
"stack",
"the",
"final",
"value",
"associated",
"with",
"name",
"in",
"the",
"registry",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L249-L258
|
train
|
Shopify/go-lua
|
auxiliary.go
|
CheckType
|
func CheckType(l *State, index int, t Type) {
if l.TypeOf(index) != t {
tagError(l, index, t)
}
}
|
go
|
func CheckType(l *State, index int, t Type) {
if l.TypeOf(index) != t {
tagError(l, index, t)
}
}
|
[
"func",
"CheckType",
"(",
"l",
"*",
"State",
",",
"index",
"int",
",",
"t",
"Type",
")",
"{",
"if",
"l",
".",
"TypeOf",
"(",
"index",
")",
"!=",
"t",
"{",
"tagError",
"(",
"l",
",",
"index",
",",
"t",
")",
"\n",
"}",
"\n",
"}"
] |
// CheckType checks whether the function argument at index has type t. See Type for the encoding of types for t.
|
[
"CheckType",
"checks",
"whether",
"the",
"function",
"argument",
"at",
"index",
"has",
"type",
"t",
".",
"See",
"Type",
"for",
"the",
"encoding",
"of",
"types",
"for",
"t",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L294-L298
|
train
|
Shopify/go-lua
|
auxiliary.go
|
ArgumentCheck
|
func ArgumentCheck(l *State, cond bool, index int, extraMessage string) {
if !cond {
ArgumentError(l, index, extraMessage)
}
}
|
go
|
func ArgumentCheck(l *State, cond bool, index int, extraMessage string) {
if !cond {
ArgumentError(l, index, extraMessage)
}
}
|
[
"func",
"ArgumentCheck",
"(",
"l",
"*",
"State",
",",
"cond",
"bool",
",",
"index",
"int",
",",
"extraMessage",
"string",
")",
"{",
"if",
"!",
"cond",
"{",
"ArgumentError",
"(",
"l",
",",
"index",
",",
"extraMessage",
")",
"\n",
"}",
"\n",
"}"
] |
// ArgumentCheck checks whether cond is true. If not, raises an error with a standard message.
|
[
"ArgumentCheck",
"checks",
"whether",
"cond",
"is",
"true",
".",
"If",
"not",
"raises",
"an",
"error",
"with",
"a",
"standard",
"message",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L308-L312
|
train
|
Shopify/go-lua
|
auxiliary.go
|
CheckString
|
func CheckString(l *State, index int) string {
if s, ok := l.ToString(index); ok {
return s
}
tagError(l, index, TypeString)
panic("unreachable")
}
|
go
|
func CheckString(l *State, index int) string {
if s, ok := l.ToString(index); ok {
return s
}
tagError(l, index, TypeString)
panic("unreachable")
}
|
[
"func",
"CheckString",
"(",
"l",
"*",
"State",
",",
"index",
"int",
")",
"string",
"{",
"if",
"s",
",",
"ok",
":=",
"l",
".",
"ToString",
"(",
"index",
")",
";",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n",
"tagError",
"(",
"l",
",",
"index",
",",
"TypeString",
")",
"\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// CheckString checks whether the function argument at index is a string and returns this string.
//
// This function uses ToString to get its result, so all conversions and caveats of that function apply here.
|
[
"CheckString",
"checks",
"whether",
"the",
"function",
"argument",
"at",
"index",
"is",
"a",
"string",
"and",
"returns",
"this",
"string",
".",
"This",
"function",
"uses",
"ToString",
"to",
"get",
"its",
"result",
"so",
"all",
"conversions",
"and",
"caveats",
"of",
"that",
"function",
"apply",
"here",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L317-L323
|
train
|
Shopify/go-lua
|
auxiliary.go
|
OptString
|
func OptString(l *State, index int, def string) string {
if l.IsNoneOrNil(index) {
return def
}
return CheckString(l, index)
}
|
go
|
func OptString(l *State, index int, def string) string {
if l.IsNoneOrNil(index) {
return def
}
return CheckString(l, index)
}
|
[
"func",
"OptString",
"(",
"l",
"*",
"State",
",",
"index",
"int",
",",
"def",
"string",
")",
"string",
"{",
"if",
"l",
".",
"IsNoneOrNil",
"(",
"index",
")",
"{",
"return",
"def",
"\n",
"}",
"\n",
"return",
"CheckString",
"(",
"l",
",",
"index",
")",
"\n",
"}"
] |
// OptString returns the string at index if it is a string. If this argument is
// absent or is nil, returns def. Otherwise, raises an error.
|
[
"OptString",
"returns",
"the",
"string",
"at",
"index",
"if",
"it",
"is",
"a",
"string",
".",
"If",
"this",
"argument",
"is",
"absent",
"or",
"is",
"nil",
"returns",
"def",
".",
"Otherwise",
"raises",
"an",
"error",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L327-L332
|
train
|
Shopify/go-lua
|
auxiliary.go
|
NewStateEx
|
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
|
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
}
|
[
"func",
"NewStateEx",
"(",
")",
"*",
"State",
"{",
"l",
":=",
"NewState",
"(",
")",
"\n",
"if",
"l",
"!=",
"nil",
"{",
"_",
"=",
"AtPanic",
"(",
"l",
",",
"func",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"s",
",",
"_",
":=",
"l",
".",
"ToString",
"(",
"-",
"1",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"s",
")",
"\n",
"return",
"0",
"\n",
"}",
")",
"\n",
"}",
"\n",
"return",
"l",
"\n",
"}"
] |
// NewStateEx creates a new Lua state. It calls NewState and then sets a panic
// function that prints an error message to the standard error output in case
// of fatal errors.
//
// Returns the new state.
|
[
"NewStateEx",
"creates",
"a",
"new",
"Lua",
"state",
".",
"It",
"calls",
"NewState",
"and",
"then",
"sets",
"a",
"panic",
"function",
"that",
"prints",
"an",
"error",
"message",
"to",
"the",
"standard",
"error",
"output",
"in",
"case",
"of",
"fatal",
"errors",
".",
"Returns",
"the",
"new",
"state",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L536-L546
|
train
|
Shopify/go-lua
|
auxiliary.go
|
DoFile
|
func DoFile(l *State, fileName string) error {
if err := LoadFile(l, fileName, ""); err != nil {
return err
}
return l.ProtectedCall(0, MultipleReturns, 0)
}
|
go
|
func DoFile(l *State, fileName string) error {
if err := LoadFile(l, fileName, ""); err != nil {
return err
}
return l.ProtectedCall(0, MultipleReturns, 0)
}
|
[
"func",
"DoFile",
"(",
"l",
"*",
"State",
",",
"fileName",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"LoadFile",
"(",
"l",
",",
"fileName",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"l",
".",
"ProtectedCall",
"(",
"0",
",",
"MultipleReturns",
",",
"0",
")",
"\n",
"}"
] |
// DoFile loads and runs the given file.
|
[
"DoFile",
"loads",
"and",
"runs",
"the",
"given",
"file",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L576-L581
|
train
|
Shopify/go-lua
|
auxiliary.go
|
DoString
|
func DoString(l *State, s string) error {
if err := LoadString(l, s); err != nil {
return err
}
return l.ProtectedCall(0, MultipleReturns, 0)
}
|
go
|
func DoString(l *State, s string) error {
if err := LoadString(l, s); err != nil {
return err
}
return l.ProtectedCall(0, MultipleReturns, 0)
}
|
[
"func",
"DoString",
"(",
"l",
"*",
"State",
",",
"s",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"LoadString",
"(",
"l",
",",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"l",
".",
"ProtectedCall",
"(",
"0",
",",
"MultipleReturns",
",",
"0",
")",
"\n",
"}"
] |
// DoString loads and runs the given string.
|
[
"DoString",
"loads",
"and",
"runs",
"the",
"given",
"string",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/auxiliary.go#L584-L589
|
train
|
Shopify/go-lua
|
stack.go
|
call
|
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 {
l.nonYieldableCallCount++
}
if !l.preCall(function, resultCount) { // is a Lua function?
l.execute() // call it
}
if !allowYield {
l.nonYieldableCallCount--
}
l.nestedGoCallCount--
}
|
go
|
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 {
l.nonYieldableCallCount++
}
if !l.preCall(function, resultCount) { // is a Lua function?
l.execute() // call it
}
if !allowYield {
l.nonYieldableCallCount--
}
l.nestedGoCallCount--
}
|
[
"func",
"(",
"l",
"*",
"State",
")",
"call",
"(",
"function",
"int",
",",
"resultCount",
"int",
",",
"allowYield",
"bool",
")",
"{",
"if",
"l",
".",
"nestedGoCallCount",
"++",
";",
"l",
".",
"nestedGoCallCount",
"==",
"maxCallCount",
"{",
"l",
".",
"runtimeError",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"l",
".",
"nestedGoCallCount",
">=",
"maxCallCount",
"+",
"maxCallCount",
">>",
"3",
"{",
"l",
".",
"throw",
"(",
"ErrorError",
")",
"// error while handling stack error",
"\n",
"}",
"\n",
"if",
"!",
"allowYield",
"{",
"l",
".",
"nonYieldableCallCount",
"++",
"\n",
"}",
"\n",
"if",
"!",
"l",
".",
"preCall",
"(",
"function",
",",
"resultCount",
")",
"{",
"// is a Lua function?",
"l",
".",
"execute",
"(",
")",
"// call it",
"\n",
"}",
"\n",
"if",
"!",
"allowYield",
"{",
"l",
".",
"nonYieldableCallCount",
"--",
"\n",
"}",
"\n",
"l",
".",
"nestedGoCallCount",
"--",
"\n",
"}"
] |
// Call a Go or Lua function. The function to be called is at function.
// The arguments are on the stack, right after the function. On return, all the
// results are on the stack, starting at the original function position.
|
[
"Call",
"a",
"Go",
"or",
"Lua",
"function",
".",
"The",
"function",
"to",
"be",
"called",
"is",
"at",
"function",
".",
"The",
"arguments",
"are",
"on",
"the",
"stack",
"right",
"after",
"the",
"function",
".",
"On",
"return",
"all",
"the",
"results",
"are",
"on",
"the",
"stack",
"starting",
"at",
"the",
"original",
"function",
"position",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/stack.go#L371-L387
|
train
|
Shopify/go-lua
|
load.go
|
PackageOpen
|
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.SetField(-2, "loaded")
SubTable(l, RegistryIndex, "_PRELOAD")
l.SetField(-2, "preload")
l.PushGlobalTable()
l.PushValue(-2)
SetFunctions(l, []RegistryFunction{{"require", func(l *State) int {
name := CheckString(l, 1)
l.SetTop(1)
l.Field(RegistryIndex, "_LOADED")
l.Field(2, name)
if l.ToBoolean(-1) {
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
}
|
go
|
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.SetField(-2, "loaded")
SubTable(l, RegistryIndex, "_PRELOAD")
l.SetField(-2, "preload")
l.PushGlobalTable()
l.PushValue(-2)
SetFunctions(l, []RegistryFunction{{"require", func(l *State) int {
name := CheckString(l, 1)
l.SetTop(1)
l.Field(RegistryIndex, "_LOADED")
l.Field(2, name)
if l.ToBoolean(-1) {
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
}
|
[
"func",
"PackageOpen",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"NewLibrary",
"(",
"l",
",",
"packageLibrary",
")",
"\n",
"createSearchersTable",
"(",
"l",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"setPath",
"(",
"l",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"defaultPath",
")",
"\n",
"l",
".",
"PushString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"filepath",
".",
"Separator",
",",
"pathListSeparator",
")",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"SubTable",
"(",
"l",
",",
"RegistryIndex",
",",
"\"",
"\"",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"SubTable",
"(",
"l",
",",
"RegistryIndex",
",",
"\"",
"\"",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"l",
".",
"PushGlobalTable",
"(",
")",
"\n",
"l",
".",
"PushValue",
"(",
"-",
"2",
")",
"\n",
"SetFunctions",
"(",
"l",
",",
"[",
"]",
"RegistryFunction",
"{",
"{",
"\"",
"\"",
",",
"func",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"name",
":=",
"CheckString",
"(",
"l",
",",
"1",
")",
"\n",
"l",
".",
"SetTop",
"(",
"1",
")",
"\n",
"l",
".",
"Field",
"(",
"RegistryIndex",
",",
"\"",
"\"",
")",
"\n",
"l",
".",
"Field",
"(",
"2",
",",
"name",
")",
"\n",
"if",
"l",
".",
"ToBoolean",
"(",
"-",
"1",
")",
"{",
"return",
"1",
"\n",
"}",
"\n",
"l",
".",
"Pop",
"(",
"1",
")",
"\n",
"findLoader",
"(",
"l",
",",
"name",
")",
"\n",
"l",
".",
"PushString",
"(",
"name",
")",
"\n",
"l",
".",
"Insert",
"(",
"-",
"2",
")",
"\n",
"l",
".",
"Call",
"(",
"2",
",",
"1",
")",
"\n",
"if",
"!",
"l",
".",
"IsNil",
"(",
"-",
"1",
")",
"{",
"l",
".",
"SetField",
"(",
"2",
",",
"name",
")",
"\n",
"}",
"\n",
"l",
".",
"Field",
"(",
"2",
",",
"name",
")",
"\n",
"if",
"l",
".",
"IsNil",
"(",
"-",
"1",
")",
"{",
"l",
".",
"PushBoolean",
"(",
"true",
")",
"\n",
"l",
".",
"PushValue",
"(",
"-",
"1",
")",
"\n",
"l",
".",
"SetField",
"(",
"2",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"1",
"\n",
"}",
"}",
"}",
",",
"1",
")",
"\n",
"l",
".",
"Pop",
"(",
"1",
")",
"\n",
"return",
"1",
"\n",
"}"
] |
// PackageOpen opens the package library. Usually passed to Require.
|
[
"PackageOpen",
"opens",
"the",
"package",
"library",
".",
"Usually",
"passed",
"to",
"Require",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/load.go#L152-L191
|
train
|
Shopify/go-lua
|
base.go
|
BaseOpen
|
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
|
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
}
|
[
"func",
"BaseOpen",
"(",
"l",
"*",
"State",
")",
"int",
"{",
"l",
".",
"PushGlobalTable",
"(",
")",
"\n",
"l",
".",
"PushGlobalTable",
"(",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"SetFunctions",
"(",
"l",
",",
"baseLibrary",
",",
"0",
")",
"\n",
"l",
".",
"PushString",
"(",
"VersionString",
")",
"\n",
"l",
".",
"SetField",
"(",
"-",
"2",
",",
"\"",
"\"",
")",
"\n",
"return",
"1",
"\n",
"}"
] |
// BaseOpen opens the basic library. Usually passed to Require.
|
[
"BaseOpen",
"opens",
"the",
"basic",
"library",
".",
"Usually",
"passed",
"to",
"Require",
"."
] |
48449c60c0a91cdc83cf554aa0931380393b9b02
|
https://github.com/Shopify/go-lua/blob/48449c60c0a91cdc83cf554aa0931380393b9b02/base.go#L322-L330
|
train
|
apex/apex
|
logs/log.go
|
start
|
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, 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
}
}
}
|
go
|
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, 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
}
}
}
|
[
"func",
"(",
"l",
"*",
"Log",
")",
"start",
"(",
"ch",
"chan",
"<-",
"*",
"Event",
")",
"{",
"defer",
"close",
"(",
"ch",
")",
"\n\n",
"l",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"l",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"var",
"start",
"=",
"l",
".",
"StartTime",
".",
"UnixNano",
"(",
")",
"/",
"int64",
"(",
"time",
".",
"Millisecond",
")",
"\n",
"var",
"nextToken",
"*",
"string",
"\n",
"var",
"err",
"error",
"\n\n",
"for",
"{",
"l",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"start",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"nextToken",
",",
"start",
",",
"err",
"=",
"l",
".",
"fetch",
"(",
"nextToken",
",",
"start",
",",
"ch",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"l",
".",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l",
".",
"GroupName",
",",
"err",
")",
"\n",
"break",
"\n",
"}",
"\n\n",
"if",
"nextToken",
"==",
"nil",
"&&",
"l",
".",
"Follow",
"{",
"time",
".",
"Sleep",
"(",
"l",
".",
"PollInterval",
")",
"\n",
"l",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"start",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"nextToken",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// start consuming and exit after pagination if Follow is not enabled.
|
[
"start",
"consuming",
"and",
"exit",
"after",
"pagination",
"if",
"Follow",
"is",
"not",
"enabled",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/logs/log.go#L29-L58
|
train
|
apex/apex
|
logs/log.go
|
fetch
|
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.(awserr.Error); ok {
if e.Code() == "ResourceNotFoundException" {
l.Log.Debug("not found")
return nil, 0, nil
}
}
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
}
|
go
|
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.(awserr.Error); ok {
if e.Code() == "ResourceNotFoundException" {
l.Log.Debug("not found")
return nil, 0, nil
}
}
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
}
|
[
"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",
",",
"}",
")",
"\n\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"if",
"e",
".",
"Code",
"(",
")",
"==",
"\"",
"\"",
"{",
"l",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
",",
"0",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"event",
":=",
"range",
"res",
".",
"Events",
"{",
"start",
"=",
"*",
"event",
".",
"Timestamp",
"+",
"1",
"\n",
"ch",
"<-",
"&",
"Event",
"{",
"GroupName",
":",
"l",
".",
"GroupName",
",",
"Message",
":",
"*",
"event",
".",
"Message",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"res",
".",
"NextToken",
",",
"start",
",",
"nil",
"\n",
"}"
] |
// fetch logs relative to the given token and start time. We ignore when the log group is not found.
|
[
"fetch",
"logs",
"relative",
"to",
"the",
"given",
"token",
"and",
"start",
"time",
".",
"We",
"ignore",
"when",
"the",
"log",
"group",
"is",
"not",
"found",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/logs/log.go#L61-L89
|
train
|
apex/apex
|
function/function.go
|
Open
|
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 {
return errors.Wrap(err, "open hook")
}
if err := validator.Validate(&f.Config); err != nil {
return errors.Wrap(err, "validating")
}
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
}
|
go
|
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 {
return errors.Wrap(err, "open hook")
}
if err := validator.Validate(&f.Config); err != nil {
return errors.Wrap(err, "validating")
}
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
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Open",
"(",
"environment",
"string",
")",
"error",
"{",
"f",
".",
"defaults",
"(",
")",
"\n\n",
"f",
".",
"Log",
"=",
"f",
".",
"Log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"",
"\"",
":",
"f",
".",
"Name",
",",
"\"",
"\"",
":",
"environment",
",",
"}",
")",
"\n\n",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"f",
".",
"loadConfig",
"(",
"environment",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"f",
".",
"hookOpen",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validator",
".",
"Validate",
"(",
"&",
"f",
".",
"Config",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ignoreFile",
",",
"err",
":=",
"utils",
".",
"ReadIgnoreFile",
"(",
"f",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"f",
".",
"IgnoreFile",
"=",
"append",
"(",
"f",
".",
"IgnoreFile",
",",
"[",
"]",
"byte",
"(",
"\"",
"\\n",
"\"",
")",
"...",
")",
"\n",
"f",
".",
"IgnoreFile",
"=",
"append",
"(",
"f",
".",
"IgnoreFile",
",",
"ignoreFile",
"...",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Open the function.json file and prime the config.
|
[
"Open",
"the",
"function",
".",
"json",
"file",
"and",
"prime",
"the",
"config",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L122-L153
|
train
|
apex/apex
|
function/function.go
|
loadConfig
|
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 {
return err
}
if ok {
f.Log.WithField("config", "function.json").Debug("loaded config")
return nil
}
return nil
}
|
go
|
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 {
return err
}
if ok {
f.Log.WithField("config", "function.json").Debug("loaded config")
return nil
}
return nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"loadConfig",
"(",
"environment",
"string",
")",
"error",
"{",
"path",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"environment",
")",
"\n\n",
"ok",
",",
"err",
":=",
"f",
".",
"tryConfig",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"ok",
"{",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"path",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"ok",
",",
"err",
"=",
"f",
".",
"tryConfig",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"ok",
"{",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// loadConfig for `environment`, attempt function.ENV.js first, then
// fall back on function.json if it is available.
|
[
"loadConfig",
"for",
"environment",
"attempt",
"function",
".",
"ENV",
".",
"js",
"first",
"then",
"fall",
"back",
"on",
"function",
".",
"json",
"if",
"it",
"is",
"available",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L183-L207
|
train
|
apex/apex
|
function/function.go
|
Setenv
|
func (f *Function) Setenv(name, value string) {
f.Environment[name] = value
}
|
go
|
func (f *Function) Setenv(name, value string) {
f.Environment[name] = value
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Setenv",
"(",
"name",
",",
"value",
"string",
")",
"{",
"f",
".",
"Environment",
"[",
"name",
"]",
"=",
"value",
"\n",
"}"
] |
// Setenv sets environment variable `name` to `value`.
|
[
"Setenv",
"sets",
"environment",
"variable",
"name",
"to",
"value",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L228-L230
|
train
|
apex/apex
|
function/function.go
|
Deploy
|
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)
}
}
if err != nil {
return err
}
if f.configChanged(config) {
f.Log.Debug("config changed")
return f.DeployConfigAndCode(zip)
}
f.Log.Info("config unchanged")
return f.DeployCode(zip, config)
}
|
go
|
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)
}
}
if err != nil {
return err
}
if f.configChanged(config) {
f.Log.Debug("config changed")
return f.DeployConfigAndCode(zip)
}
f.Log.Info("config unchanged")
return f.DeployCode(zip, config)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Deploy",
"(",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"zip",
",",
"err",
":=",
"f",
".",
"ZipBytes",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"f",
".",
"hookDeploy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"config",
",",
"err",
":=",
"f",
".",
"GetConfig",
"(",
")",
"\n\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"if",
"e",
".",
"Code",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"f",
".",
"Create",
"(",
"zip",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"configChanged",
"(",
"config",
")",
"{",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"DeployConfigAndCode",
"(",
"zip",
")",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"DeployCode",
"(",
"zip",
",",
"config",
")",
"\n",
"}"
] |
// Deploy generates a zip and creates or deploy the function.
// If the configuration hasn't been changed it will deploy only code,
// otherwise it will deploy both configuration and code.
|
[
"Deploy",
"generates",
"a",
"zip",
"and",
"creates",
"or",
"deploy",
"the",
"function",
".",
"If",
"the",
"configuration",
"hasn",
"t",
"been",
"changed",
"it",
"will",
"deploy",
"only",
"code",
"otherwise",
"it",
"will",
"deploy",
"both",
"configuration",
"and",
"code",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L235-L266
|
train
|
apex/apex
|
function/function.go
|
DeployCode
|
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 tied to any future deploys.
// To correct this behaviour, we take the latest version at the time of deploy.
if *version == "$LATEST" {
versions, err := 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)
}
|
go
|
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 tied to any future deploys.
// To correct this behaviour, we take the latest version at the time of deploy.
if *version == "$LATEST" {
versions, err := 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)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"DeployCode",
"(",
"zip",
"[",
"]",
"byte",
",",
"config",
"*",
"lambda",
".",
"GetFunctionOutput",
")",
"error",
"{",
"remoteHash",
":=",
"*",
"config",
".",
"Configuration",
".",
"CodeSha256",
"\n",
"localHash",
":=",
"utils",
".",
"Sha256",
"(",
"zip",
")",
"\n\n",
"if",
"localHash",
"==",
"remoteHash",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"version",
":=",
"config",
".",
"Configuration",
".",
"Version",
"\n\n",
"// Creating an alias to $LATEST would mean its tied to any future deploys.",
"// To correct this behaviour, we take the latest version at the time of deploy.",
"if",
"*",
"version",
"==",
"\"",
"\"",
"{",
"versions",
",",
"err",
":=",
"f",
".",
"versions",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"version",
"=",
"versions",
"[",
"len",
"(",
"versions",
")",
"-",
"1",
"]",
".",
"Version",
"\n",
"}",
"\n\n",
"return",
"f",
".",
"CreateOrUpdateAlias",
"(",
"f",
".",
"Alias",
",",
"*",
"version",
")",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"",
"\"",
":",
"localHash",
",",
"\"",
"\"",
":",
"remoteHash",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"f",
".",
"Update",
"(",
"zip",
")",
"\n",
"}"
] |
// DeployCode deploys function code when changed.
|
[
"DeployCode",
"deploys",
"function",
"code",
"when",
"changed",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L269-L298
|
train
|
apex/apex
|
function/function.go
|
DeployConfigAndCode
|
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,
Handler: &f.Handler,
KMSKeyArn: &f.KMSKeyArn,
Environment: f.environment(),
VpcConfig: &lambda.VpcConfig{
SecurityGroupIds: aws.StringSlice(f.VPC.SecurityGroups),
SubnetIds: 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)
}
|
go
|
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,
Handler: &f.Handler,
KMSKeyArn: &f.KMSKeyArn,
Environment: f.environment(),
VpcConfig: &lambda.VpcConfig{
SecurityGroupIds: aws.StringSlice(f.VPC.SecurityGroups),
SubnetIds: 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)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"DeployConfigAndCode",
"(",
"zip",
"[",
"]",
"byte",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"params",
":=",
"&",
"lambda",
".",
"UpdateFunctionConfigurationInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"MemorySize",
":",
"&",
"f",
".",
"Memory",
",",
"Timeout",
":",
"&",
"f",
".",
"Timeout",
",",
"Description",
":",
"&",
"f",
".",
"Description",
",",
"Role",
":",
"&",
"f",
".",
"Role",
",",
"Runtime",
":",
"&",
"f",
".",
"Runtime",
",",
"Handler",
":",
"&",
"f",
".",
"Handler",
",",
"KMSKeyArn",
":",
"&",
"f",
".",
"KMSKeyArn",
",",
"Environment",
":",
"f",
".",
"environment",
"(",
")",
",",
"VpcConfig",
":",
"&",
"lambda",
".",
"VpcConfig",
"{",
"SecurityGroupIds",
":",
"aws",
".",
"StringSlice",
"(",
"f",
".",
"VPC",
".",
"SecurityGroups",
")",
",",
"SubnetIds",
":",
"aws",
".",
"StringSlice",
"(",
"f",
".",
"VPC",
".",
"Subnets",
")",
",",
"}",
",",
"}",
"\n\n",
"if",
"f",
".",
"DeadLetterARN",
"!=",
"\"",
"\"",
"{",
"params",
".",
"DeadLetterConfig",
"=",
"&",
"lambda",
".",
"DeadLetterConfig",
"{",
"TargetArn",
":",
"&",
"f",
".",
"DeadLetterARN",
",",
"}",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"f",
".",
"Service",
".",
"UpdateFunctionConfiguration",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"f",
".",
"Update",
"(",
"zip",
")",
"\n",
"}"
] |
// DeployConfigAndCode updates config and updates function code.
|
[
"DeployConfigAndCode",
"updates",
"config",
"and",
"updates",
"function",
"code",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L301-L332
|
train
|
apex/apex
|
function/function.go
|
Delete
|
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
|
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
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Delete",
"(",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
":=",
"f",
".",
"Service",
".",
"DeleteFunction",
"(",
"&",
"lambda",
".",
"DeleteFunctionInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Delete the function including all its versions
|
[
"Delete",
"the",
"function",
"including",
"all",
"its",
"versions"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L335-L348
|
train
|
apex/apex
|
function/function.go
|
GetConfig
|
func (f *Function) GetConfig() (*lambda.GetFunctionOutput, error) {
f.Log.Debug("fetching config")
return f.Service.GetFunction(&lambda.GetFunctionInput{
FunctionName: &f.FunctionName,
})
}
|
go
|
func (f *Function) GetConfig() (*lambda.GetFunctionOutput, error) {
f.Log.Debug("fetching config")
return f.Service.GetFunction(&lambda.GetFunctionInput{
FunctionName: &f.FunctionName,
})
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"GetConfig",
"(",
")",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
",",
"error",
")",
"{",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"Service",
".",
"GetFunction",
"(",
"&",
"lambda",
".",
"GetFunctionInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"}",
")",
"\n",
"}"
] |
// GetConfig returns the function configuration.
|
[
"GetConfig",
"returns",
"the",
"function",
"configuration",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L351-L356
|
train
|
apex/apex
|
function/function.go
|
GetConfigQualifier
|
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
|
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,
})
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"GetConfigQualifier",
"(",
"s",
"string",
")",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
",",
"error",
")",
"{",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"Service",
".",
"GetFunction",
"(",
"&",
"lambda",
".",
"GetFunctionInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Qualifier",
":",
"&",
"s",
",",
"}",
")",
"\n",
"}"
] |
// GetConfigQualifier returns the function configuration for the given qualifier.
|
[
"GetConfigQualifier",
"returns",
"the",
"function",
"configuration",
"for",
"the",
"given",
"qualifier",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L359-L365
|
train
|
apex/apex
|
function/function.go
|
GetConfigCurrent
|
func (f *Function) GetConfigCurrent() (*lambda.GetFunctionOutput, error) {
return f.GetConfigQualifier(f.Alias)
}
|
go
|
func (f *Function) GetConfigCurrent() (*lambda.GetFunctionOutput, error) {
return f.GetConfigQualifier(f.Alias)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"GetConfigCurrent",
"(",
")",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
",",
"error",
")",
"{",
"return",
"f",
".",
"GetConfigQualifier",
"(",
"f",
".",
"Alias",
")",
"\n",
"}"
] |
// GetConfigCurrent returns the function configuration for the current version.
|
[
"GetConfigCurrent",
"returns",
"the",
"function",
"configuration",
"for",
"the",
"current",
"version",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L368-L370
|
train
|
apex/apex
|
function/function.go
|
Update
|
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.Alias, *updated.Version); err != nil {
return err
}
f.Log.WithFields(log.Fields{
"version": *updated.Version,
"name": f.FunctionName,
}).Info("function updated")
return f.cleanup()
}
|
go
|
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.Alias, *updated.Version); err != nil {
return err
}
f.Log.WithFields(log.Fields{
"version": *updated.Version,
"name": f.FunctionName,
}).Info("function updated")
return f.cleanup()
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Update",
"(",
"zip",
"[",
"]",
"byte",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"updated",
",",
"err",
":=",
"f",
".",
"Service",
".",
"UpdateFunctionCode",
"(",
"&",
"lambda",
".",
"UpdateFunctionCodeInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Publish",
":",
"aws",
".",
"Bool",
"(",
"true",
")",
",",
"ZipFile",
":",
"zip",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"f",
".",
"CreateOrUpdateAlias",
"(",
"f",
".",
"Alias",
",",
"*",
"updated",
".",
"Version",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"",
"\"",
":",
"*",
"updated",
".",
"Version",
",",
"\"",
"\"",
":",
"f",
".",
"FunctionName",
",",
"}",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"f",
".",
"cleanup",
"(",
")",
"\n",
"}"
] |
// Update the function with the given `zip`.
|
[
"Update",
"the",
"function",
"with",
"the",
"given",
"zip",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L373-L396
|
train
|
apex/apex
|
function/function.go
|
Create
|
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,
KMSKeyArn: &f.KMSKeyArn,
Publish: aws.Bool(true),
Environment: f.environment(),
Code: &lambda.FunctionCode{
ZipFile: zip,
},
VpcConfig: &lambda.VpcConfig{
SecurityGroupIds: aws.StringSlice(f.VPC.SecurityGroups),
SubnetIds: aws.StringSlice(f.VPC.Subnets),
},
}
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.Fields{
"version": *created.Version,
"name": f.FunctionName,
}).Info("function created")
return nil
}
|
go
|
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,
KMSKeyArn: &f.KMSKeyArn,
Publish: aws.Bool(true),
Environment: f.environment(),
Code: &lambda.FunctionCode{
ZipFile: zip,
},
VpcConfig: &lambda.VpcConfig{
SecurityGroupIds: aws.StringSlice(f.VPC.SecurityGroups),
SubnetIds: aws.StringSlice(f.VPC.Subnets),
},
}
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.Fields{
"version": *created.Version,
"name": f.FunctionName,
}).Info("function created")
return nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Create",
"(",
"zip",
"[",
"]",
"byte",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"params",
":=",
"&",
"lambda",
".",
"CreateFunctionInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Description",
":",
"&",
"f",
".",
"Description",
",",
"MemorySize",
":",
"&",
"f",
".",
"Memory",
",",
"Timeout",
":",
"&",
"f",
".",
"Timeout",
",",
"Runtime",
":",
"&",
"f",
".",
"Runtime",
",",
"Handler",
":",
"&",
"f",
".",
"Handler",
",",
"Role",
":",
"&",
"f",
".",
"Role",
",",
"KMSKeyArn",
":",
"&",
"f",
".",
"KMSKeyArn",
",",
"Publish",
":",
"aws",
".",
"Bool",
"(",
"true",
")",
",",
"Environment",
":",
"f",
".",
"environment",
"(",
")",
",",
"Code",
":",
"&",
"lambda",
".",
"FunctionCode",
"{",
"ZipFile",
":",
"zip",
",",
"}",
",",
"VpcConfig",
":",
"&",
"lambda",
".",
"VpcConfig",
"{",
"SecurityGroupIds",
":",
"aws",
".",
"StringSlice",
"(",
"f",
".",
"VPC",
".",
"SecurityGroups",
")",
",",
"SubnetIds",
":",
"aws",
".",
"StringSlice",
"(",
"f",
".",
"VPC",
".",
"Subnets",
")",
",",
"}",
",",
"}",
"\n\n",
"if",
"f",
".",
"DeadLetterARN",
"!=",
"\"",
"\"",
"{",
"params",
".",
"DeadLetterConfig",
"=",
"&",
"lambda",
".",
"DeadLetterConfig",
"{",
"TargetArn",
":",
"&",
"f",
".",
"DeadLetterARN",
",",
"}",
"\n",
"}",
"\n\n",
"created",
",",
"err",
":=",
"f",
".",
"Service",
".",
"CreateFunction",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"f",
".",
"CreateOrUpdateAlias",
"(",
"f",
".",
"Alias",
",",
"*",
"created",
".",
"Version",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"",
"\"",
":",
"*",
"created",
".",
"Version",
",",
"\"",
"\"",
":",
"f",
".",
"FunctionName",
",",
"}",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Create the function with the given `zip`.
|
[
"Create",
"the",
"function",
"with",
"the",
"given",
"zip",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L399-L443
|
train
|
apex/apex
|
function/function.go
|
CreateOrUpdateAlias
|
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)
return nil
}
if e, ok := err.(awserr.Error); !ok || e.Code() != "ResourceConflictException" {
return err
}
_, err = f.Service.UpdateAlias(&lambda.UpdateAliasInput{
FunctionName: &f.FunctionName,
FunctionVersion: &version,
Name: &alias,
})
if err != nil {
return err
}
f.Log.WithField("version", version).Infof("updated alias %s", alias)
return nil
}
|
go
|
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)
return nil
}
if e, ok := err.(awserr.Error); !ok || e.Code() != "ResourceConflictException" {
return err
}
_, err = f.Service.UpdateAlias(&lambda.UpdateAliasInput{
FunctionName: &f.FunctionName,
FunctionVersion: &version,
Name: &alias,
})
if err != nil {
return err
}
f.Log.WithField("version", version).Infof("updated alias %s", alias)
return nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"CreateOrUpdateAlias",
"(",
"alias",
",",
"version",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"f",
".",
"Service",
".",
"CreateAlias",
"(",
"&",
"lambda",
".",
"CreateAliasInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"FunctionVersion",
":",
"&",
"version",
",",
"Name",
":",
"&",
"alias",
",",
"}",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"version",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"alias",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"!",
"ok",
"||",
"e",
".",
"Code",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"f",
".",
"Service",
".",
"UpdateAlias",
"(",
"&",
"lambda",
".",
"UpdateAliasInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"FunctionVersion",
":",
"&",
"version",
",",
"Name",
":",
"&",
"alias",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"version",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"alias",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CreateOrUpdateAlias attempts creating the alias, or updates if it already exists.
|
[
"CreateOrUpdateAlias",
"attempts",
"creating",
"the",
"alias",
"or",
"updates",
"if",
"it",
"already",
"exists",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L446-L474
|
train
|
apex/apex
|
function/function.go
|
GetAliases
|
func (f *Function) GetAliases() (*lambda.ListAliasesOutput, error) {
f.Log.Debug("fetching aliases")
return f.Service.ListAliases(&lambda.ListAliasesInput{
FunctionName: &f.FunctionName,
})
}
|
go
|
func (f *Function) GetAliases() (*lambda.ListAliasesOutput, error) {
f.Log.Debug("fetching aliases")
return f.Service.ListAliases(&lambda.ListAliasesInput{
FunctionName: &f.FunctionName,
})
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"GetAliases",
"(",
")",
"(",
"*",
"lambda",
".",
"ListAliasesOutput",
",",
"error",
")",
"{",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"Service",
".",
"ListAliases",
"(",
"&",
"lambda",
".",
"ListAliasesInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"}",
")",
"\n",
"}"
] |
// GetAliases fetches a list of aliases for the function.
|
[
"GetAliases",
"fetches",
"a",
"list",
"of",
"aliases",
"for",
"the",
"function",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L477-L482
|
train
|
apex/apex
|
function/function.go
|
Invoke
|
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{
ClientContext: aws.String(base64.StdEncoding.EncodeToString(contextBytes)),
FunctionName: &f.FunctionName,
InvocationType: aws.String(string(RequestResponse)),
LogType: aws.String("Tail"),
Qualifier: &f.Alias,
Payload: 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, logs, err
}
return nil, logs, e
}
reply = bytes.NewReader(res.Payload)
return reply, logs, nil
}
|
go
|
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{
ClientContext: aws.String(base64.StdEncoding.EncodeToString(contextBytes)),
FunctionName: &f.FunctionName,
InvocationType: aws.String(string(RequestResponse)),
LogType: aws.String("Tail"),
Qualifier: &f.Alias,
Payload: 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, logs, err
}
return nil, logs, e
}
reply = bytes.NewReader(res.Payload)
return reply, logs, nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Invoke",
"(",
"event",
",",
"context",
"interface",
"{",
"}",
")",
"(",
"reply",
",",
"logs",
"io",
".",
"Reader",
",",
"err",
"error",
")",
"{",
"eventBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"event",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"contextBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
",",
"err",
":=",
"f",
".",
"Service",
".",
"Invoke",
"(",
"&",
"lambda",
".",
"InvokeInput",
"{",
"ClientContext",
":",
"aws",
".",
"String",
"(",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"contextBytes",
")",
")",
",",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"InvocationType",
":",
"aws",
".",
"String",
"(",
"string",
"(",
"RequestResponse",
")",
")",
",",
"LogType",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"Qualifier",
":",
"&",
"f",
".",
"Alias",
",",
"Payload",
":",
"eventBytes",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"logs",
"=",
"base64",
".",
"NewDecoder",
"(",
"base64",
".",
"StdEncoding",
",",
"strings",
".",
"NewReader",
"(",
"*",
"res",
".",
"LogResult",
")",
")",
"\n\n",
"if",
"res",
".",
"FunctionError",
"!=",
"nil",
"{",
"e",
":=",
"&",
"InvokeError",
"{",
"Handled",
":",
"*",
"res",
".",
"FunctionError",
"==",
"\"",
"\"",
",",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"res",
".",
"Payload",
",",
"e",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"logs",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"logs",
",",
"e",
"\n",
"}",
"\n\n",
"reply",
"=",
"bytes",
".",
"NewReader",
"(",
"res",
".",
"Payload",
")",
"\n",
"return",
"reply",
",",
"logs",
",",
"nil",
"\n",
"}"
] |
// Invoke the remote Lambda function, returning the response and logs, if any.
|
[
"Invoke",
"the",
"remote",
"Lambda",
"function",
"returning",
"the",
"response",
"and",
"logs",
"if",
"any",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L485-L525
|
train
|
apex/apex
|
function/function.go
|
Rollback
|
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 rollback. Only one version deployed.")
}
latest := *versions[len(versions)-1].Version
prev := *versions[len(versions)-2].Version
rollback := latest
if *alias.FunctionVersion == latest {
rollback = prev
}
f.Log.Infof("rollback to version: %s", rollback)
_, 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
}
|
go
|
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 rollback. Only one version deployed.")
}
latest := *versions[len(versions)-1].Version
prev := *versions[len(versions)-2].Version
rollback := latest
if *alias.FunctionVersion == latest {
rollback = prev
}
f.Log.Infof("rollback to version: %s", rollback)
_, 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
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Rollback",
"(",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"alias",
",",
"err",
":=",
"f",
".",
"currentVersionAlias",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"*",
"alias",
".",
"FunctionVersion",
")",
"\n\n",
"versions",
",",
"err",
":=",
"f",
".",
"versions",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"versions",
")",
"<",
"2",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"latest",
":=",
"*",
"versions",
"[",
"len",
"(",
"versions",
")",
"-",
"1",
"]",
".",
"Version",
"\n",
"prev",
":=",
"*",
"versions",
"[",
"len",
"(",
"versions",
")",
"-",
"2",
"]",
".",
"Version",
"\n",
"rollback",
":=",
"latest",
"\n\n",
"if",
"*",
"alias",
".",
"FunctionVersion",
"==",
"latest",
"{",
"rollback",
"=",
"prev",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"rollback",
")",
"\n\n",
"_",
",",
"err",
"=",
"f",
".",
"Service",
".",
"UpdateAlias",
"(",
"&",
"lambda",
".",
"UpdateAliasInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Name",
":",
"&",
"f",
".",
"Alias",
",",
"FunctionVersion",
":",
"&",
"rollback",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"rollback",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Rollback the function to the previous.
|
[
"Rollback",
"the",
"function",
"to",
"the",
"previous",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L528-L570
|
train
|
apex/apex
|
function/function.go
|
RollbackVersion
|
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.")
}
f.Log.Infof("rollback to version: %s", version)
_, 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
}
|
go
|
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.")
}
f.Log.Infof("rollback to version: %s", version)
_, 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
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"RollbackVersion",
"(",
"version",
"string",
")",
"error",
"{",
"f",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"alias",
",",
"err",
":=",
"f",
".",
"currentVersionAlias",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"*",
"alias",
".",
"FunctionVersion",
")",
"\n\n",
"if",
"version",
"==",
"*",
"alias",
".",
"FunctionVersion",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"version",
")",
"\n\n",
"_",
",",
"err",
"=",
"f",
".",
"Service",
".",
"UpdateAlias",
"(",
"&",
"lambda",
".",
"UpdateAliasInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Name",
":",
"&",
"f",
".",
"Alias",
",",
"FunctionVersion",
":",
"&",
"version",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"version",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// RollbackVersion the function to the specified version.
|
[
"RollbackVersion",
"the",
"function",
"to",
"the",
"specified",
"version",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L573-L602
|
train
|
apex/apex
|
function/function.go
|
ZipBytes
|
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
|
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)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"ZipBytes",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"f",
".",
"Zip",
"==",
"\"",
"\"",
"{",
"f",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"BuildBytes",
"(",
")",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"f",
".",
"Zip",
")",
"\n",
"return",
"ioutil",
".",
"ReadFile",
"(",
"f",
".",
"Zip",
")",
"\n",
"}"
] |
// ZipBytes builds the in-memory zip, or reads
// the .Zip from disk if specified.
|
[
"ZipBytes",
"builds",
"the",
"in",
"-",
"memory",
"zip",
"or",
"reads",
"the",
".",
"Zip",
"from",
"disk",
"if",
"specified",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L606-L614
|
train
|
apex/apex
|
function/function.go
|
BuildBytes
|
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
|
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
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"BuildBytes",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"f",
".",
"Build",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"f",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"humanize",
".",
"Bytes",
"(",
"uint64",
"(",
"len",
"(",
"b",
")",
")",
")",
")",
"\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] |
// BuildBytes returns the generated zip as bytes.
|
[
"BuildBytes",
"returns",
"the",
"generated",
"zip",
"as",
"bytes",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L617-L630
|
train
|
apex/apex
|
function/function.go
|
Build
|
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 {
f.Log.WithField("file", path).Debug("add file to zip")
fullPath := filepath.Join(f.Path, path)
fh, err := os.Open(fullPath)
if err != nil {
return nil, err
}
info, err := fh.Stat()
if err != nil {
return nil, err
}
if info.IsDir() {
// It's a symlink, otherwise it shouldn't be returned by LoadFiles
linkPath, err := filepath.EvalSymlinks(fullPath)
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 {
return nil, err
}
return buf, nil
}
|
go
|
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 {
f.Log.WithField("file", path).Debug("add file to zip")
fullPath := filepath.Join(f.Path, path)
fh, err := os.Open(fullPath)
if err != nil {
return nil, err
}
info, err := fh.Stat()
if err != nil {
return nil, err
}
if info.IsDir() {
// It's a symlink, otherwise it shouldn't be returned by LoadFiles
linkPath, err := filepath.EvalSymlinks(fullPath)
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 {
return nil, err
}
return buf, nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"Build",
"(",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"f",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"zip",
":=",
"archive",
".",
"NewZip",
"(",
"buf",
")",
"\n\n",
"if",
"err",
":=",
"f",
".",
"hookBuild",
"(",
"zip",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"paths",
",",
"err",
":=",
"utils",
".",
"LoadFiles",
"(",
"f",
".",
"Path",
",",
"f",
".",
"IgnoreFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"f",
".",
"Log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"path",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"fullPath",
":=",
"filepath",
".",
"Join",
"(",
"f",
".",
"Path",
",",
"path",
")",
"\n\n",
"fh",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"fullPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"info",
",",
"err",
":=",
"fh",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"info",
".",
"IsDir",
"(",
")",
"{",
"// It's a symlink, otherwise it shouldn't be returned by LoadFiles",
"linkPath",
",",
"err",
":=",
"filepath",
".",
"EvalSymlinks",
"(",
"fullPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"zip",
".",
"AddDir",
"(",
"linkPath",
",",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"zip",
".",
"AddFile",
"(",
"path",
",",
"fh",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"fh",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"zip",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"buf",
",",
"nil",
"\n",
"}"
] |
// Build returns the zipped contents of the function.
|
[
"Build",
"returns",
"the",
"zipped",
"contents",
"of",
"the",
"function",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L633-L689
|
train
|
apex/apex
|
function/function.go
|
GetVersionFromAlias
|
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
}
}
return version, nil
}
|
go
|
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
}
}
return version, nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"GetVersionFromAlias",
"(",
"alias",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"version",
"string",
"=",
"alias",
"\n",
"aliases",
",",
"err",
":=",
"f",
".",
"GetAliases",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"version",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"fnAlias",
":=",
"range",
"aliases",
".",
"Aliases",
"{",
"if",
"strings",
".",
"Compare",
"(",
"version",
",",
"*",
"fnAlias",
".",
"Name",
")",
"==",
"0",
"{",
"version",
"=",
"*",
"fnAlias",
".",
"FunctionVersion",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"version",
",",
"nil",
"\n",
"}"
] |
// Return function version from alias name, if alias not found, return the input
|
[
"Return",
"function",
"version",
"from",
"alias",
"name",
"if",
"alias",
"not",
"found",
"return",
"the",
"input"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L702-L716
|
train
|
apex/apex
|
function/function.go
|
cleanup
|
func (f *Function) cleanup() error {
versionsToCleanup, err := f.versionsToCleanup()
if err != nil {
return err
}
return f.removeVersions(versionsToCleanup)
}
|
go
|
func (f *Function) cleanup() error {
versionsToCleanup, err := f.versionsToCleanup()
if err != nil {
return err
}
return f.removeVersions(versionsToCleanup)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"cleanup",
"(",
")",
"error",
"{",
"versionsToCleanup",
",",
"err",
":=",
"f",
".",
"versionsToCleanup",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"f",
".",
"removeVersions",
"(",
"versionsToCleanup",
")",
"\n",
"}"
] |
// cleanup removes any deployed functions beyond the configured `RetainedVersions` value
|
[
"cleanup",
"removes",
"any",
"deployed",
"functions",
"beyond",
"the",
"configured",
"RetainedVersions",
"value"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L719-L726
|
train
|
apex/apex
|
function/function.go
|
versions
|
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 = append(list, page.Versions...)
if page.NextMarker == nil {
break
}
request.Marker = page.NextMarker
}
versions := list[1:] // remove $LATEST
return versions, nil
}
|
go
|
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 = append(list, page.Versions...)
if page.NextMarker == nil {
break
}
request.Marker = page.NextMarker
}
versions := list[1:] // remove $LATEST
return versions, nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"versions",
"(",
")",
"(",
"[",
"]",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"var",
"list",
"[",
"]",
"*",
"lambda",
".",
"FunctionConfiguration",
"\n",
"request",
":=",
"lambda",
".",
"ListVersionsByFunctionInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"}",
"\n\n",
"for",
"{",
"page",
",",
"err",
":=",
"f",
".",
"Service",
".",
"ListVersionsByFunction",
"(",
"&",
"request",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"list",
"=",
"append",
"(",
"list",
",",
"page",
".",
"Versions",
"...",
")",
"\n\n",
"if",
"page",
".",
"NextMarker",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"request",
".",
"Marker",
"=",
"page",
".",
"NextMarker",
"\n",
"}",
"\n\n",
"versions",
":=",
"list",
"[",
"1",
":",
"]",
"// remove $LATEST",
"\n",
"return",
"versions",
",",
"nil",
"\n",
"}"
] |
// versions returns list of all versions deployed to AWS Lambda
|
[
"versions",
"returns",
"list",
"of",
"all",
"versions",
"deployed",
"to",
"AWS",
"Lambda"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L729-L753
|
train
|
apex/apex
|
function/function.go
|
versionsToCleanup
|
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
}
return nil, nil
}
|
go
|
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
}
return nil, nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"versionsToCleanup",
"(",
")",
"(",
"[",
"]",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"versions",
",",
"err",
":=",
"f",
".",
"versions",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"*",
"f",
".",
"RetainedVersions",
"==",
"0",
"{",
"return",
"versions",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"versions",
")",
">",
"*",
"f",
".",
"RetainedVersions",
"{",
"return",
"versions",
"[",
":",
"len",
"(",
"versions",
")",
"-",
"*",
"f",
".",
"RetainedVersions",
"]",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// versionsToCleanup returns list of versions to remove after updating function
|
[
"versionsToCleanup",
"returns",
"list",
"of",
"versions",
"to",
"remove",
"after",
"updating",
"function"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L756-L771
|
train
|
apex/apex
|
function/function.go
|
removeVersions
|
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 {
return err
}
}
return nil
}
|
go
|
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 {
return err
}
}
return nil
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"removeVersions",
"(",
"versions",
"[",
"]",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"error",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"versions",
"{",
"f",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"Version",
")",
"\n\n",
"_",
",",
"err",
":=",
"f",
".",
"Service",
".",
"DeleteFunction",
"(",
"&",
"lambda",
".",
"DeleteFunctionInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Qualifier",
":",
"v",
".",
"Version",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// removeVersions removes specifed function's versions
|
[
"removeVersions",
"removes",
"specifed",
"function",
"s",
"versions"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L774-L789
|
train
|
apex/apex
|
function/function.go
|
currentVersionAlias
|
func (f *Function) currentVersionAlias() (*lambda.AliasConfiguration, error) {
return f.Service.GetAlias(&lambda.GetAliasInput{
FunctionName: &f.FunctionName,
Name: &f.Alias,
})
}
|
go
|
func (f *Function) currentVersionAlias() (*lambda.AliasConfiguration, error) {
return f.Service.GetAlias(&lambda.GetAliasInput{
FunctionName: &f.FunctionName,
Name: &f.Alias,
})
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"currentVersionAlias",
"(",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"return",
"f",
".",
"Service",
".",
"GetAlias",
"(",
"&",
"lambda",
".",
"GetAliasInput",
"{",
"FunctionName",
":",
"&",
"f",
".",
"FunctionName",
",",
"Name",
":",
"&",
"f",
".",
"Alias",
",",
"}",
")",
"\n",
"}"
] |
// currentVersionAlias returns alias configuration for currently deployed function
|
[
"currentVersionAlias",
"returns",
"alias",
"configuration",
"for",
"currently",
"deployed",
"function"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L792-L797
|
train
|
apex/apex
|
function/function.go
|
configChanged
|
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 string
DeadLetterConfig lambda.DeadLetterConfig
}
localConfig := &diffConfig{
Description: f.Description,
Memory: f.Memory,
Timeout: f.Timeout,
Role: f.Role,
Runtime: f.Runtime,
Handler: f.Handler,
KMSKeyArn: f.KMSKeyArn,
Environment: environ(f.environment().Variables),
VPC: vpc.VPC{
Subnets: f.VPC.Subnets,
SecurityGroups: f.VPC.SecurityGroups,
},
}
if f.DeadLetterARN != "" {
localConfig.DeadLetterConfig = lambda.DeadLetterConfig{
TargetArn: &f.DeadLetterARN,
}
}
remoteConfig := &diffConfig{
Description: *config.Configuration.Description,
Memory: *config.Configuration.MemorySize,
Timeout: *config.Configuration.Timeout,
Role: *config.Configuration.Role,
Runtime: *config.Configuration.Runtime,
Handler: *config.Configuration.Handler,
}
if config.Configuration.KMSKeyArn != nil {
remoteConfig.KMSKeyArn = *config.Configuration.KMSKeyArn
}
if config.Configuration.Environment != nil {
remoteConfig.Environment = environ(config.Configuration.Environment.Variables)
}
if config.Configuration.DeadLetterConfig != nil {
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 {
remoteConfig.VPC = vpc.VPC{
Subnets: aws.StringValueSlice(config.Configuration.VpcConfig.SubnetIds),
SecurityGroups: aws.StringValueSlice(config.Configuration.VpcConfig.SecurityGroupIds),
}
}
// don't make any assumptions about the order AWS stores the subnets or security groups
sort.StringSlice(remoteConfig.VPC.Subnets).Sort()
sort.StringSlice(localConfig.VPC.Subnets).Sort()
sort.StringSlice(remoteConfig.VPC.SecurityGroups).Sort()
sort.StringSlice(localConfig.VPC.SecurityGroups).Sort()
localConfigJSON, _ := json.Marshal(localConfig)
remoteConfigJSON, _ := json.Marshal(remoteConfig)
return string(localConfigJSON) != string(remoteConfigJSON)
}
|
go
|
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 string
DeadLetterConfig lambda.DeadLetterConfig
}
localConfig := &diffConfig{
Description: f.Description,
Memory: f.Memory,
Timeout: f.Timeout,
Role: f.Role,
Runtime: f.Runtime,
Handler: f.Handler,
KMSKeyArn: f.KMSKeyArn,
Environment: environ(f.environment().Variables),
VPC: vpc.VPC{
Subnets: f.VPC.Subnets,
SecurityGroups: f.VPC.SecurityGroups,
},
}
if f.DeadLetterARN != "" {
localConfig.DeadLetterConfig = lambda.DeadLetterConfig{
TargetArn: &f.DeadLetterARN,
}
}
remoteConfig := &diffConfig{
Description: *config.Configuration.Description,
Memory: *config.Configuration.MemorySize,
Timeout: *config.Configuration.Timeout,
Role: *config.Configuration.Role,
Runtime: *config.Configuration.Runtime,
Handler: *config.Configuration.Handler,
}
if config.Configuration.KMSKeyArn != nil {
remoteConfig.KMSKeyArn = *config.Configuration.KMSKeyArn
}
if config.Configuration.Environment != nil {
remoteConfig.Environment = environ(config.Configuration.Environment.Variables)
}
if config.Configuration.DeadLetterConfig != nil {
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 {
remoteConfig.VPC = vpc.VPC{
Subnets: aws.StringValueSlice(config.Configuration.VpcConfig.SubnetIds),
SecurityGroups: aws.StringValueSlice(config.Configuration.VpcConfig.SecurityGroupIds),
}
}
// don't make any assumptions about the order AWS stores the subnets or security groups
sort.StringSlice(remoteConfig.VPC.Subnets).Sort()
sort.StringSlice(localConfig.VPC.Subnets).Sort()
sort.StringSlice(remoteConfig.VPC.SecurityGroups).Sort()
sort.StringSlice(localConfig.VPC.SecurityGroups).Sort()
localConfigJSON, _ := json.Marshal(localConfig)
remoteConfigJSON, _ := json.Marshal(remoteConfig)
return string(localConfigJSON) != string(remoteConfigJSON)
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"configChanged",
"(",
"config",
"*",
"lambda",
".",
"GetFunctionOutput",
")",
"bool",
"{",
"type",
"diffConfig",
"struct",
"{",
"Description",
"string",
"\n",
"Memory",
"int64",
"\n",
"Timeout",
"int64",
"\n",
"Role",
"string",
"\n",
"Runtime",
"string",
"\n",
"Handler",
"string",
"\n",
"VPC",
"vpc",
".",
"VPC",
"\n",
"Environment",
"[",
"]",
"string",
"\n",
"KMSKeyArn",
"string",
"\n",
"DeadLetterConfig",
"lambda",
".",
"DeadLetterConfig",
"\n",
"}",
"\n\n",
"localConfig",
":=",
"&",
"diffConfig",
"{",
"Description",
":",
"f",
".",
"Description",
",",
"Memory",
":",
"f",
".",
"Memory",
",",
"Timeout",
":",
"f",
".",
"Timeout",
",",
"Role",
":",
"f",
".",
"Role",
",",
"Runtime",
":",
"f",
".",
"Runtime",
",",
"Handler",
":",
"f",
".",
"Handler",
",",
"KMSKeyArn",
":",
"f",
".",
"KMSKeyArn",
",",
"Environment",
":",
"environ",
"(",
"f",
".",
"environment",
"(",
")",
".",
"Variables",
")",
",",
"VPC",
":",
"vpc",
".",
"VPC",
"{",
"Subnets",
":",
"f",
".",
"VPC",
".",
"Subnets",
",",
"SecurityGroups",
":",
"f",
".",
"VPC",
".",
"SecurityGroups",
",",
"}",
",",
"}",
"\n\n",
"if",
"f",
".",
"DeadLetterARN",
"!=",
"\"",
"\"",
"{",
"localConfig",
".",
"DeadLetterConfig",
"=",
"lambda",
".",
"DeadLetterConfig",
"{",
"TargetArn",
":",
"&",
"f",
".",
"DeadLetterARN",
",",
"}",
"\n",
"}",
"\n\n",
"remoteConfig",
":=",
"&",
"diffConfig",
"{",
"Description",
":",
"*",
"config",
".",
"Configuration",
".",
"Description",
",",
"Memory",
":",
"*",
"config",
".",
"Configuration",
".",
"MemorySize",
",",
"Timeout",
":",
"*",
"config",
".",
"Configuration",
".",
"Timeout",
",",
"Role",
":",
"*",
"config",
".",
"Configuration",
".",
"Role",
",",
"Runtime",
":",
"*",
"config",
".",
"Configuration",
".",
"Runtime",
",",
"Handler",
":",
"*",
"config",
".",
"Configuration",
".",
"Handler",
",",
"}",
"\n\n",
"if",
"config",
".",
"Configuration",
".",
"KMSKeyArn",
"!=",
"nil",
"{",
"remoteConfig",
".",
"KMSKeyArn",
"=",
"*",
"config",
".",
"Configuration",
".",
"KMSKeyArn",
"\n",
"}",
"\n\n",
"if",
"config",
".",
"Configuration",
".",
"Environment",
"!=",
"nil",
"{",
"remoteConfig",
".",
"Environment",
"=",
"environ",
"(",
"config",
".",
"Configuration",
".",
"Environment",
".",
"Variables",
")",
"\n",
"}",
"\n\n",
"if",
"config",
".",
"Configuration",
".",
"DeadLetterConfig",
"!=",
"nil",
"{",
"remoteConfig",
".",
"DeadLetterConfig",
"=",
"lambda",
".",
"DeadLetterConfig",
"{",
"TargetArn",
":",
"config",
".",
"Configuration",
".",
"DeadLetterConfig",
".",
"TargetArn",
",",
"}",
"\n",
"}",
"\n\n",
"// SDK is inconsistent here. VpcConfig can be nil or empty struct.",
"remoteConfig",
".",
"VPC",
"=",
"vpc",
".",
"VPC",
"{",
"Subnets",
":",
"[",
"]",
"string",
"{",
"}",
",",
"SecurityGroups",
":",
"[",
"]",
"string",
"{",
"}",
"}",
"\n",
"if",
"config",
".",
"Configuration",
".",
"VpcConfig",
"!=",
"nil",
"{",
"remoteConfig",
".",
"VPC",
"=",
"vpc",
".",
"VPC",
"{",
"Subnets",
":",
"aws",
".",
"StringValueSlice",
"(",
"config",
".",
"Configuration",
".",
"VpcConfig",
".",
"SubnetIds",
")",
",",
"SecurityGroups",
":",
"aws",
".",
"StringValueSlice",
"(",
"config",
".",
"Configuration",
".",
"VpcConfig",
".",
"SecurityGroupIds",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// don't make any assumptions about the order AWS stores the subnets or security groups",
"sort",
".",
"StringSlice",
"(",
"remoteConfig",
".",
"VPC",
".",
"Subnets",
")",
".",
"Sort",
"(",
")",
"\n",
"sort",
".",
"StringSlice",
"(",
"localConfig",
".",
"VPC",
".",
"Subnets",
")",
".",
"Sort",
"(",
")",
"\n",
"sort",
".",
"StringSlice",
"(",
"remoteConfig",
".",
"VPC",
".",
"SecurityGroups",
")",
".",
"Sort",
"(",
")",
"\n",
"sort",
".",
"StringSlice",
"(",
"localConfig",
".",
"VPC",
".",
"SecurityGroups",
")",
".",
"Sort",
"(",
")",
"\n\n",
"localConfigJSON",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"localConfig",
")",
"\n",
"remoteConfigJSON",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"remoteConfig",
")",
"\n",
"return",
"string",
"(",
"localConfigJSON",
")",
"!=",
"string",
"(",
"remoteConfigJSON",
")",
"\n",
"}"
] |
// configChanged checks if function configuration differs from configuration stored in AWS Lambda
|
[
"configChanged",
"checks",
"if",
"function",
"configuration",
"differs",
"from",
"configuration",
"stored",
"in",
"AWS",
"Lambda"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L800-L876
|
train
|
apex/apex
|
function/function.go
|
hookOpen
|
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
|
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
}
|
[
"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",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// hookOpen calls Openers.
|
[
"hookOpen",
"calls",
"Openers",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L879-L888
|
train
|
apex/apex
|
function/function.go
|
hookBuild
|
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
|
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
}
|
[
"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",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// hookBuild calls Builders.
|
[
"hookBuild",
"calls",
"Builders",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L891-L900
|
train
|
apex/apex
|
function/function.go
|
hookClean
|
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
|
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
}
|
[
"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",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// hookClean calls Cleaners.
|
[
"hookClean",
"calls",
"Cleaners",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L903-L912
|
train
|
apex/apex
|
function/function.go
|
hookDeploy
|
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
|
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
}
|
[
"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",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// hookDeploy calls Deployers.
|
[
"hookDeploy",
"calls",
"Deployers",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L915-L924
|
train
|
apex/apex
|
function/function.go
|
environment
|
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
|
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}
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"environment",
"(",
")",
"*",
"lambda",
".",
"Environment",
"{",
"env",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"string",
")",
"\n",
"if",
"!",
"f",
".",
"Edge",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"f",
".",
"Environment",
"{",
"env",
"[",
"k",
"]",
"=",
"aws",
".",
"String",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"lambda",
".",
"Environment",
"{",
"Variables",
":",
"env",
"}",
"\n",
"}"
] |
// environment for lambda calls.
|
[
"environment",
"for",
"lambda",
"calls",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L927-L935
|
train
|
apex/apex
|
function/function.go
|
environ
|
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
|
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
}
|
[
"func",
"environ",
"(",
"env",
"map",
"[",
"string",
"]",
"*",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"keys",
"[",
"]",
"string",
"\n",
"var",
"pairs",
"[",
"]",
"string",
"\n\n",
"for",
"k",
":=",
"range",
"env",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"k",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n\n",
"for",
"_",
",",
"k",
":=",
"range",
"keys",
"{",
"pairs",
"=",
"append",
"(",
"pairs",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"*",
"env",
"[",
"k",
"]",
")",
")",
"\n",
"}",
"\n\n",
"return",
"pairs",
"\n",
"}"
] |
// environment sorted and joined.
|
[
"environment",
"sorted",
"and",
"joined",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L938-L953
|
train
|
apex/apex
|
function/function.go
|
AWSConfig
|
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
|
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
}
|
[
"func",
"(",
"f",
"*",
"Function",
")",
"AWSConfig",
"(",
")",
"*",
"aws",
".",
"Config",
"{",
"region",
":=",
"f",
".",
"Config",
".",
"Region",
"\n",
"if",
"f",
".",
"Config",
".",
"Edge",
"{",
"region",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"region",
")",
">",
"0",
"{",
"return",
"aws",
".",
"NewConfig",
"(",
")",
".",
"WithRegion",
"(",
"region",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// AWSConfig returns AWS configuration if function has specified region.
|
[
"AWSConfig",
"returns",
"AWS",
"configuration",
"if",
"function",
"has",
"specified",
"region",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/function/function.go#L956-L966
|
train
|
apex/apex
|
docs/docs.go
|
Reader
|
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(s)
}
|
go
|
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(s)
}
|
[
"func",
"Reader",
"(",
")",
"io",
".",
"Reader",
"{",
"var",
"in",
"bytes",
".",
"Buffer",
"\n\n",
"for",
"_",
",",
"page",
":=",
"range",
"pages",
"{",
"in",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"page",
".",
"Name",
")",
")",
"\n",
"in",
".",
"Write",
"(",
"MustAsset",
"(",
"page",
".",
"File",
")",
")",
"\n",
"}",
"\n\n",
"md",
":=",
"markdown",
".",
"New",
"(",
"markdown",
".",
"XHTMLOutput",
"(",
"true",
")",
",",
"markdown",
".",
"Nofollow",
"(",
"true",
")",
")",
"\n",
"v",
":=",
"&",
"renderer",
"{",
"}",
"\n",
"s",
":=",
"v",
".",
"visit",
"(",
"md",
".",
"Parse",
"(",
"in",
".",
"Bytes",
"(",
")",
")",
")",
"\n",
"return",
"strings",
".",
"NewReader",
"(",
"s",
")",
"\n",
"}"
] |
// Reader returns all documentation as a single page.
|
[
"Reader",
"returns",
"all",
"documentation",
"as",
"a",
"single",
"page",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/docs/docs.go#L52-L64
|
train
|
apex/apex
|
docs/docs.go
|
indent
|
func indent(s string, n int) string {
i := strings.Repeat(" ", n)
return i + strings.Replace(s, "\n", "\n"+i, -1)
}
|
go
|
func indent(s string, n int) string {
i := strings.Repeat(" ", n)
return i + strings.Replace(s, "\n", "\n"+i, -1)
}
|
[
"func",
"indent",
"(",
"s",
"string",
",",
"n",
"int",
")",
"string",
"{",
"i",
":=",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"n",
")",
"\n",
"return",
"i",
"+",
"strings",
".",
"Replace",
"(",
"s",
",",
"\"",
"\\n",
"\"",
",",
"\"",
"\\n",
"\"",
"+",
"i",
",",
"-",
"1",
")",
"\n",
"}"
] |
// indent string N times.
|
[
"indent",
"string",
"N",
"times",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/docs/docs.go#L67-L70
|
train
|
apex/apex
|
docs/docs.go
|
visit
|
func (r *renderer) visit(tokens []markdown.Token) (s string) {
for _, t := range tokens {
s += r.visitToken(t)
}
return
}
|
go
|
func (r *renderer) visit(tokens []markdown.Token) (s string) {
for _, t := range tokens {
s += r.visitToken(t)
}
return
}
|
[
"func",
"(",
"r",
"*",
"renderer",
")",
"visit",
"(",
"tokens",
"[",
"]",
"markdown",
".",
"Token",
")",
"(",
"s",
"string",
")",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"tokens",
"{",
"s",
"+=",
"r",
".",
"visitToken",
"(",
"t",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// visit `tokens`.
|
[
"visit",
"tokens",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/docs/docs.go#L80-L85
|
train
|
apex/apex
|
docs/docs.go
|
visitToken
|
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 *markdown.Fence:
return fmt.Sprintf("\n%s\n", indent(t.(*markdown.Fence).Content, 2))
case *markdown.HeadingOpen:
n := t.(*markdown.HeadingOpen).HLevel
return fmt.Sprintf("\n %s \033[%dm", strings.Repeat("#", n), colors.Blue)
case *markdown.HeadingClose:
return "\n\033[0m\n"
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.(*markdown.LinkOpen).Href
return ""
case *markdown.CodeInline:
s := t.(*markdown.CodeInline).Content
return fmt.Sprintf("\033[%dm%s\033[0m", colors.Gray, s)
case *markdown.Text:
s := t.(*markdown.Text).Content
if r.inLink != "" {
s = fmt.Sprintf("%s (%s)", s, r.inLink)
r.inLink = ""
}
return s
case *markdown.Inline:
s := r.visit(t.(*markdown.Inline).Children)
if r.inParagraph && !r.inList {
s = indent(wordwrap.WrapString(s, 75), 1)
}
return s
default:
return ""
}
}
|
go
|
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 *markdown.Fence:
return fmt.Sprintf("\n%s\n", indent(t.(*markdown.Fence).Content, 2))
case *markdown.HeadingOpen:
n := t.(*markdown.HeadingOpen).HLevel
return fmt.Sprintf("\n %s \033[%dm", strings.Repeat("#", n), colors.Blue)
case *markdown.HeadingClose:
return "\n\033[0m\n"
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.(*markdown.LinkOpen).Href
return ""
case *markdown.CodeInline:
s := t.(*markdown.CodeInline).Content
return fmt.Sprintf("\033[%dm%s\033[0m", colors.Gray, s)
case *markdown.Text:
s := t.(*markdown.Text).Content
if r.inLink != "" {
s = fmt.Sprintf("%s (%s)", s, r.inLink)
r.inLink = ""
}
return s
case *markdown.Inline:
s := r.visit(t.(*markdown.Inline).Children)
if r.inParagraph && !r.inList {
s = indent(wordwrap.WrapString(s, 75), 1)
}
return s
default:
return ""
}
}
|
[
"func",
"(",
"r",
"*",
"renderer",
")",
"visitToken",
"(",
"t",
"markdown",
".",
"Token",
")",
"string",
"{",
"switch",
"t",
".",
"(",
"type",
")",
"{",
"case",
"*",
"markdown",
".",
"ParagraphOpen",
":",
"r",
".",
"inParagraph",
"=",
"true",
"\n",
"return",
"\"",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"ParagraphClose",
":",
"r",
".",
"inParagraph",
"=",
"false",
"\n",
"return",
"\"",
"\\n",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"CodeBlock",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"indent",
"(",
"t",
".",
"(",
"*",
"markdown",
".",
"CodeBlock",
")",
".",
"Content",
",",
"2",
")",
")",
"\n",
"case",
"*",
"markdown",
".",
"Fence",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"indent",
"(",
"t",
".",
"(",
"*",
"markdown",
".",
"Fence",
")",
".",
"Content",
",",
"2",
")",
")",
"\n",
"case",
"*",
"markdown",
".",
"HeadingOpen",
":",
"n",
":=",
"t",
".",
"(",
"*",
"markdown",
".",
"HeadingOpen",
")",
".",
"HLevel",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\033",
"\"",
",",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"n",
")",
",",
"colors",
".",
"Blue",
")",
"\n",
"case",
"*",
"markdown",
".",
"HeadingClose",
":",
"return",
"\"",
"\\n",
"\\033",
"\\n",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"StrongOpen",
":",
"return",
"\"",
"\\033",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"StrongClose",
":",
"return",
"\"",
"\\033",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"BulletListOpen",
":",
"r",
".",
"inList",
"=",
"true",
"\n",
"return",
"\"",
"\\n",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"BulletListClose",
":",
"r",
".",
"inList",
"=",
"false",
"\n",
"return",
"\"",
"\\n",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"ListItemOpen",
":",
"return",
"\"",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"LinkOpen",
":",
"r",
".",
"inLink",
"=",
"t",
".",
"(",
"*",
"markdown",
".",
"LinkOpen",
")",
".",
"Href",
"\n",
"return",
"\"",
"\"",
"\n",
"case",
"*",
"markdown",
".",
"CodeInline",
":",
"s",
":=",
"t",
".",
"(",
"*",
"markdown",
".",
"CodeInline",
")",
".",
"Content",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\033",
"\\033",
"\"",
",",
"colors",
".",
"Gray",
",",
"s",
")",
"\n",
"case",
"*",
"markdown",
".",
"Text",
":",
"s",
":=",
"t",
".",
"(",
"*",
"markdown",
".",
"Text",
")",
".",
"Content",
"\n\n",
"if",
"r",
".",
"inLink",
"!=",
"\"",
"\"",
"{",
"s",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
",",
"r",
".",
"inLink",
")",
"\n",
"r",
".",
"inLink",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"s",
"\n",
"case",
"*",
"markdown",
".",
"Inline",
":",
"s",
":=",
"r",
".",
"visit",
"(",
"t",
".",
"(",
"*",
"markdown",
".",
"Inline",
")",
".",
"Children",
")",
"\n\n",
"if",
"r",
".",
"inParagraph",
"&&",
"!",
"r",
".",
"inList",
"{",
"s",
"=",
"indent",
"(",
"wordwrap",
".",
"WrapString",
"(",
"s",
",",
"75",
")",
",",
"1",
")",
"\n",
"}",
"\n\n",
"return",
"s",
"\n",
"default",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"}"
] |
// vistToken `t`.
|
[
"vistToken",
"t",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/docs/docs.go#L88-L143
|
train
|
apex/apex
|
plugins/python/python.go
|
Open
|
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
|
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
}
|
[
"func",
"(",
"p",
"*",
"Plugin",
")",
"Open",
"(",
"fn",
"*",
"function",
".",
"Function",
")",
"error",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"fn",
".",
"Runtime",
",",
"\"",
"\"",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Support \"python\" for backwards compat.",
"if",
"fn",
".",
"Runtime",
"==",
"\"",
"\"",
"{",
"fn",
".",
"Runtime",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"fn",
".",
"Handler",
"==",
"\"",
"\"",
"{",
"fn",
".",
"Handler",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Open adds python defaults.
|
[
"Open",
"adds",
"python",
"defaults",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/plugins/python/python.go#L21-L36
|
train
|
apex/apex
|
cmd/apex/invoke/invoke.go
|
preRun
|
func preRun(c *cobra.Command, args []string) error {
if len(args) < 1 {
return errors.New("Missing name argument")
}
name = args[0]
return nil
}
|
go
|
func preRun(c *cobra.Command, args []string) error {
if len(args) < 1 {
return errors.New("Missing name argument")
}
name = args[0]
return nil
}
|
[
"func",
"preRun",
"(",
"c",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"<",
"1",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"name",
"=",
"args",
"[",
"0",
"]",
"\n",
"return",
"nil",
"\n",
"}"
] |
// PreRun errors if the name argument is missing.
|
[
"PreRun",
"errors",
"if",
"the",
"name",
"argument",
"is",
"missing",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/cmd/apex/invoke/invoke.go#L54-L61
|
train
|
apex/apex
|
cmd/apex/invoke/invoke.go
|
input
|
func input() io.Reader {
if isatty.IsTerminal(os.Stdin.Fd()) {
return strings.NewReader("{}")
}
return os.Stdin
}
|
go
|
func input() io.Reader {
if isatty.IsTerminal(os.Stdin.Fd()) {
return strings.NewReader("{}")
}
return os.Stdin
}
|
[
"func",
"input",
"(",
")",
"io",
".",
"Reader",
"{",
"if",
"isatty",
".",
"IsTerminal",
"(",
"os",
".",
"Stdin",
".",
"Fd",
"(",
")",
")",
"{",
"return",
"strings",
".",
"NewReader",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Stdin",
"\n",
"}"
] |
// input from stdin or empty object by default.
|
[
"input",
"from",
"stdin",
"or",
"empty",
"object",
"by",
"default",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/cmd/apex/invoke/invoke.go#L111-L117
|
train
|
apex/apex
|
infra/infra.go
|
Run
|
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.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = filepath.Join(Dir, p.Environment)
return cmd.Run()
}
|
go
|
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.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = filepath.Join(Dir, p.Environment)
return cmd.Run()
}
|
[
"func",
"(",
"p",
"*",
"Proxy",
")",
"Run",
"(",
"args",
"...",
"string",
")",
"error",
"{",
"if",
"p",
".",
"shouldInjectVars",
"(",
"args",
")",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"p",
".",
"functionVars",
"(",
")",
"...",
")",
"\n",
"}",
"\n\n",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"",
"\"",
":",
"args",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"args",
"...",
")",
"\n",
"cmd",
".",
"Env",
"=",
"append",
"(",
"os",
".",
"Environ",
"(",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"Region",
")",
")",
"\n",
"cmd",
".",
"Stdin",
"=",
"os",
".",
"Stdin",
"\n",
"cmd",
".",
"Stdout",
"=",
"os",
".",
"Stdout",
"\n",
"cmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"cmd",
".",
"Dir",
"=",
"filepath",
".",
"Join",
"(",
"Dir",
",",
"p",
".",
"Environment",
")",
"\n\n",
"return",
"cmd",
".",
"Run",
"(",
")",
"\n",
"}"
] |
// Run terraform command in infrastructure directory.
|
[
"Run",
"terraform",
"command",
"in",
"infrastructure",
"directory",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/infra/infra.go#L29-L46
|
train
|
apex/apex
|
infra/infra.go
|
shouldInjectVars
|
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
|
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"
}
|
[
"func",
"(",
"p",
"*",
"Proxy",
")",
"shouldInjectVars",
"(",
"args",
"[",
"]",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"args",
"[",
"0",
"]",
"==",
"\"",
"\"",
"||",
"args",
"[",
"0",
"]",
"==",
"\"",
"\"",
"||",
"args",
"[",
"0",
"]",
"==",
"\"",
"\"",
"||",
"args",
"[",
"0",
"]",
"==",
"\"",
"\"",
"\n",
"}"
] |
// shouldInjectVars checks if the command accepts -var flags.
|
[
"shouldInjectVars",
"checks",
"if",
"the",
"command",
"accepts",
"-",
"var",
"flags",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/infra/infra.go#L49-L55
|
train
|
apex/apex
|
infra/infra.go
|
Output
|
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
|
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
}
|
[
"func",
"Output",
"(",
"environment",
",",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
")",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"filepath",
".",
"Join",
"(",
"Dir",
",",
"environment",
")",
"\n\n",
"out",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Trim",
"(",
"string",
"(",
"out",
")",
",",
"\"",
"\\n",
"\"",
")",
",",
"nil",
"\n",
"}"
] |
// Output fetches output variable `name` from terraform.
|
[
"Output",
"fetches",
"output",
"variable",
"name",
"from",
"terraform",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/infra/infra.go#L58-L68
|
train
|
apex/apex
|
archive/zip.go
|
AddBytes
|
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(contents)
return err
}
|
go
|
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(contents)
return err
}
|
[
"func",
"(",
"z",
"*",
"Zip",
")",
"AddBytes",
"(",
"path",
"string",
",",
"contents",
"[",
"]",
"byte",
")",
"error",
"{",
"z",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"z",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"header",
":=",
"&",
"zip",
".",
"FileHeader",
"{",
"Name",
":",
"path",
",",
"Method",
":",
"zip",
".",
"Deflate",
",",
"}",
"\n\n",
"header",
".",
"SetModTime",
"(",
"time",
".",
"Unix",
"(",
"0",
",",
"0",
")",
")",
"\n\n",
"zippedFile",
",",
"err",
":=",
"z",
".",
"writer",
".",
"CreateHeader",
"(",
"header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"zippedFile",
".",
"Write",
"(",
"contents",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// AddBytes add bytes to archive.
|
[
"AddBytes",
"add",
"bytes",
"to",
"archive",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/archive/zip.go#L33-L51
|
train
|
apex/apex
|
archive/zip.go
|
AddFile
|
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.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 err
}
|
go
|
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.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 err
}
|
[
"func",
"(",
"z",
"*",
"Zip",
")",
"AddFile",
"(",
"path",
"string",
",",
"file",
"*",
"os",
".",
"File",
")",
"error",
"{",
"path",
"=",
"strings",
".",
"Replace",
"(",
"path",
",",
"\"",
"\\\\",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n\n",
"z",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"z",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"info",
",",
"err",
":=",
"file",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"info",
".",
"Mode",
"(",
")",
".",
"IsRegular",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"path",
")",
"\n",
"}",
"\n\n",
"header",
",",
"err",
":=",
"zip",
".",
"FileInfoHeader",
"(",
"info",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"header",
".",
"Name",
"=",
"path",
"\n",
"header",
".",
"Method",
"=",
"zip",
".",
"Deflate",
"\n",
"header",
".",
"SetModTime",
"(",
"time",
".",
"Unix",
"(",
"0",
",",
"0",
")",
")",
"\n\n",
"zippedFile",
",",
"err",
":=",
"z",
".",
"writer",
".",
"CreateHeader",
"(",
"header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"zippedFile",
",",
"file",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// AddFile adds a file to archive.
// AddFile resets mtime.
|
[
"AddFile",
"adds",
"a",
"file",
"to",
"archive",
".",
"AddFile",
"resets",
"mtime",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/archive/zip.go#L55-L85
|
train
|
apex/apex
|
archive/zip.go
|
AddDir
|
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 := filepath.Rel(root, path)
if err != nil {
return err
}
archivePath := filepath.Join(target, rel)
return z.AddFile(archivePath, file)
})
}
|
go
|
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 := filepath.Rel(root, path)
if err != nil {
return err
}
archivePath := filepath.Join(target, rel)
return z.AddFile(archivePath, file)
})
}
|
[
"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",
"\n",
"}",
"\n\n",
"if",
"!",
"info",
".",
"Mode",
"(",
")",
".",
"IsRegular",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n\n",
"rel",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"root",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"archivePath",
":=",
"filepath",
".",
"Join",
"(",
"target",
",",
"rel",
")",
"\n",
"return",
"z",
".",
"AddFile",
"(",
"archivePath",
",",
"file",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// AddDir to target path in archive. This function doesn't follow symlinks.
|
[
"AddDir",
"to",
"target",
"path",
"in",
"archive",
".",
"This",
"function",
"doesn",
"t",
"follow",
"symlinks",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/archive/zip.go#L88-L112
|
train
|
apex/apex
|
dryrun/dryrun.go
|
New
|
func New(session *session.Session) *Lambda {
fmt.Printf("\n")
return &Lambda{
Lambda: lambda.New(session),
}
}
|
go
|
func New(session *session.Session) *Lambda {
fmt.Printf("\n")
return &Lambda{
Lambda: lambda.New(session),
}
}
|
[
"func",
"New",
"(",
"session",
"*",
"session",
".",
"Session",
")",
"*",
"Lambda",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"return",
"&",
"Lambda",
"{",
"Lambda",
":",
"lambda",
".",
"New",
"(",
"session",
")",
",",
"}",
"\n",
"}"
] |
// New dry-run Lambda service for the given session.
|
[
"New",
"dry",
"-",
"run",
"Lambda",
"service",
"for",
"the",
"given",
"session",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L29-L34
|
train
|
apex/apex
|
dryrun/dryrun.go
|
CreateFunction
|
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{
Version: aws.String("1"),
}
return out, nil
}
|
go
|
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{
Version: aws.String("1"),
}
return out, nil
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"CreateFunction",
"(",
"in",
"*",
"lambda",
".",
"CreateFunctionInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"l",
".",
"create",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"*",
"in",
".",
"Runtime",
",",
"\"",
"\"",
":",
"*",
"in",
".",
"MemorySize",
",",
"\"",
"\"",
":",
"*",
"in",
".",
"Timeout",
",",
"\"",
"\"",
":",
"*",
"in",
".",
"Handler",
",",
"}",
")",
"\n\n",
"out",
":=",
"&",
"lambda",
".",
"FunctionConfiguration",
"{",
"Version",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"}",
"\n\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// CreateFunction stub.
|
[
"CreateFunction",
"stub",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L37-L50
|
train
|
apex/apex
|
dryrun/dryrun.go
|
UpdateFunctionCode
|
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)
remoteChecksum := *res.Configuration.CodeSha256
remoteSize := uint64(*res.Configuration.CodeSize)
if checksum != remoteChecksum {
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
}
|
go
|
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)
remoteChecksum := *res.Configuration.CodeSha256
remoteSize := uint64(*res.Configuration.CodeSize)
if checksum != remoteChecksum {
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
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"UpdateFunctionCode",
"(",
"in",
"*",
"lambda",
".",
"UpdateFunctionCodeInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"l",
".",
"GetFunction",
"(",
"&",
"lambda",
".",
"GetFunctionInput",
"{",
"FunctionName",
":",
"in",
".",
"FunctionName",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"size",
":=",
"uint64",
"(",
"len",
"(",
"in",
".",
"ZipFile",
")",
")",
"\n",
"checksum",
":=",
"utils",
".",
"Sha256",
"(",
"in",
".",
"ZipFile",
")",
"\n",
"remoteChecksum",
":=",
"*",
"res",
".",
"Configuration",
".",
"CodeSha256",
"\n",
"remoteSize",
":=",
"uint64",
"(",
"*",
"res",
".",
"Configuration",
".",
"CodeSize",
")",
"\n\n",
"if",
"checksum",
"!=",
"remoteChecksum",
"{",
"l",
".",
"create",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"humanize",
".",
"Bytes",
"(",
"remoteSize",
")",
",",
"humanize",
".",
"Bytes",
"(",
"size",
")",
")",
",",
"}",
")",
"\n",
"}",
"\n\n",
"out",
":=",
"&",
"lambda",
".",
"FunctionConfiguration",
"{",
"Version",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"}",
"\n\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// UpdateFunctionCode stub.
|
[
"UpdateFunctionCode",
"stub",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L53-L78
|
train
|
apex/apex
|
dryrun/dryrun.go
|
UpdateFunctionConfiguration
|
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() == "ResourceNotFoundException" {
return nil, nil
}
}
if err != nil {
return nil, err
}
m := make(map[string]interface{})
if *in.Description != *res.Description {
m["description"] = fmt.Sprintf("%q -> %q", *res.Description, *in.Description)
}
if *in.Handler != *res.Handler {
m["handler"] = fmt.Sprintf("%s -> %s", *res.Handler, *in.Handler)
}
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 len(m) > 0 {
l.update("config", *in.FunctionName, m)
}
return nil, nil
}
|
go
|
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() == "ResourceNotFoundException" {
return nil, nil
}
}
if err != nil {
return nil, err
}
m := make(map[string]interface{})
if *in.Description != *res.Description {
m["description"] = fmt.Sprintf("%q -> %q", *res.Description, *in.Description)
}
if *in.Handler != *res.Handler {
m["handler"] = fmt.Sprintf("%s -> %s", *res.Handler, *in.Handler)
}
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 len(m) > 0 {
l.update("config", *in.FunctionName, m)
}
return nil, nil
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"UpdateFunctionConfiguration",
"(",
"in",
"*",
"lambda",
".",
"UpdateFunctionConfigurationInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"l",
".",
"GetFunctionConfiguration",
"(",
"&",
"lambda",
".",
"GetFunctionConfigurationInput",
"{",
"FunctionName",
":",
"in",
".",
"FunctionName",
",",
"}",
")",
"\n\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"if",
"e",
".",
"Code",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n\n",
"if",
"*",
"in",
".",
"Description",
"!=",
"*",
"res",
".",
"Description",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"res",
".",
"Description",
",",
"*",
"in",
".",
"Description",
")",
"\n",
"}",
"\n\n",
"if",
"*",
"in",
".",
"Handler",
"!=",
"*",
"res",
".",
"Handler",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"res",
".",
"Handler",
",",
"*",
"in",
".",
"Handler",
")",
"\n",
"}",
"\n\n",
"if",
"*",
"in",
".",
"MemorySize",
"!=",
"*",
"res",
".",
"MemorySize",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"res",
".",
"MemorySize",
",",
"*",
"in",
".",
"MemorySize",
")",
"\n",
"}",
"\n\n",
"if",
"*",
"in",
".",
"Role",
"!=",
"*",
"res",
".",
"Role",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"res",
".",
"Role",
",",
"*",
"in",
".",
"Role",
")",
"\n",
"}",
"\n\n",
"if",
"*",
"in",
".",
"Timeout",
"!=",
"*",
"res",
".",
"Timeout",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"res",
".",
"Timeout",
",",
"*",
"in",
".",
"Timeout",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"m",
")",
">",
"0",
"{",
"l",
".",
"update",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"m",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// UpdateFunctionConfiguration stub.
|
[
"UpdateFunctionConfiguration",
"stub",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L81-L123
|
train
|
apex/apex
|
dryrun/dryrun.go
|
DeleteFunction
|
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
|
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
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"DeleteFunction",
"(",
"in",
"*",
"lambda",
".",
"DeleteFunctionInput",
")",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
",",
"error",
")",
"{",
"if",
"in",
".",
"Qualifier",
"==",
"nil",
"{",
"l",
".",
"remove",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"l",
".",
"remove",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"*",
"in",
".",
"Qualifier",
")",
",",
"nil",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// DeleteFunction stub.
|
[
"DeleteFunction",
"stub",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L126-L134
|
train
|
apex/apex
|
dryrun/dryrun.go
|
CreateAlias
|
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
|
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
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"CreateAlias",
"(",
"in",
"*",
"lambda",
".",
"CreateAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"l",
".",
"create",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"*",
"in",
".",
"Name",
",",
"\"",
"\"",
":",
"*",
"in",
".",
"FunctionVersion",
",",
"}",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// CreateAlias stub.
|
[
"CreateAlias",
"stub",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L137-L143
|
train
|
apex/apex
|
dryrun/dryrun.go
|
UpdateAlias
|
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
|
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
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"UpdateAlias",
"(",
"in",
"*",
"lambda",
".",
"UpdateAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"l",
".",
"update",
"(",
"\"",
"\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"*",
"in",
".",
"Name",
",",
"\"",
"\"",
":",
"*",
"in",
".",
"FunctionVersion",
",",
"}",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// UpdateAlias stub.
|
[
"UpdateAlias",
"stub",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L146-L152
|
train
|
apex/apex
|
dryrun/dryrun.go
|
create
|
func (l *Lambda) create(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '+', green)
}
|
go
|
func (l *Lambda) create(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '+', green)
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"create",
"(",
"kind",
",",
"name",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"log",
"(",
"kind",
",",
"name",
",",
"m",
",",
"'+'",
",",
"green",
")",
"\n",
"}"
] |
// create message.
|
[
"create",
"message",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L163-L165
|
train
|
apex/apex
|
dryrun/dryrun.go
|
update
|
func (l *Lambda) update(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '~', yellow)
}
|
go
|
func (l *Lambda) update(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '~', yellow)
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"update",
"(",
"kind",
",",
"name",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"log",
"(",
"kind",
",",
"name",
",",
"m",
",",
"'~'",
",",
"yellow",
")",
"\n",
"}"
] |
// update message.
|
[
"update",
"message",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L168-L170
|
train
|
apex/apex
|
dryrun/dryrun.go
|
remove
|
func (l *Lambda) remove(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '-', red)
}
|
go
|
func (l *Lambda) remove(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '-', red)
}
|
[
"func",
"(",
"l",
"*",
"Lambda",
")",
"remove",
"(",
"kind",
",",
"name",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"log",
"(",
"kind",
",",
"name",
",",
"m",
",",
"'-'",
",",
"red",
")",
"\n",
"}"
] |
// remove message.
|
[
"remove",
"message",
"."
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L173-L175
|
train
|
apex/apex
|
mock/service/provider.go
|
NewMockProvideriface
|
func NewMockProvideriface(ctrl *gomock.Controller) *MockProvideriface {
mock := &MockProvideriface{ctrl: ctrl}
mock.recorder = &MockProviderifaceMockRecorder{mock}
return mock
}
|
go
|
func NewMockProvideriface(ctrl *gomock.Controller) *MockProvideriface {
mock := &MockProvideriface{ctrl: ctrl}
mock.recorder = &MockProviderifaceMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockProvideriface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockProvideriface",
"{",
"mock",
":=",
"&",
"MockProvideriface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockProviderifaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockProvideriface creates a new mock instance
|
[
"NewMockProvideriface",
"creates",
"a",
"new",
"mock",
"instance"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/service/provider.go#L27-L31
|
train
|
apex/apex
|
mock/service/provider.go
|
NewService
|
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
|
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
}
|
[
"func",
"(",
"m",
"*",
"MockProvideriface",
")",
"NewService",
"(",
"arg0",
"*",
"aws",
".",
"Config",
")",
"lambdaiface",
".",
"LambdaAPI",
"{",
"if",
"m",
".",
"ctrl",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"lambdaiface",
".",
"LambdaAPI",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// NewService mocks base method
|
[
"NewService",
"mocks",
"base",
"method"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/service/provider.go#L39-L47
|
train
|
apex/apex
|
mock/service/provider.go
|
NewService
|
func (mr *MockProviderifaceMockRecorder) NewService(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewService", reflect.TypeOf((*MockProvideriface)(nil).NewService), arg0)
}
|
go
|
func (mr *MockProviderifaceMockRecorder) NewService(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewService", reflect.TypeOf((*MockProvideriface)(nil).NewService), arg0)
}
|
[
"func",
"(",
"mr",
"*",
"MockProviderifaceMockRecorder",
")",
"NewService",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockProvideriface",
")",
"(",
"nil",
")",
".",
"NewService",
")",
",",
"arg0",
")",
"\n",
"}"
] |
// NewService indicates an expected call of NewService
|
[
"NewService",
"indicates",
"an",
"expected",
"call",
"of",
"NewService"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/service/provider.go#L50-L52
|
train
|
apex/apex
|
mock/lambdaiface.go
|
NewMockLambdaAPI
|
func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
mock := &MockLambdaAPI{ctrl: ctrl}
mock.recorder = &MockLambdaAPIMockRecorder{mock}
return mock
}
|
go
|
func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
mock := &MockLambdaAPI{ctrl: ctrl}
mock.recorder = &MockLambdaAPIMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockLambdaAPI",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockLambdaAPI",
"{",
"mock",
":=",
"&",
"MockLambdaAPI",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockLambdaAPIMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockLambdaAPI creates a new mock instance
|
[
"NewMockLambdaAPI",
"creates",
"a",
"new",
"mock",
"instance"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L27-L31
|
train
|
apex/apex
|
mock/lambdaiface.go
|
AddPermission
|
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
|
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
}
|
[
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"AddPermission",
"(",
"arg0",
"*",
"lambda",
".",
"AddPermissionInput",
")",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// AddPermission mocks base method
|
[
"AddPermission",
"mocks",
"base",
"method"
] |
c31f0a78ce189a8328563fa6a6eb97d04ace4284
|
https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L39-L44
|
train
|
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.