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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | 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
No community queries yet
The top public SQL queries from the community will appear here once available.