id int32 0 167k | 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 listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
14,700 | kolide/osquery-go | client.go | Extensions | func (c *ExtensionManagerClient) Extensions() (osquery.InternalExtensionList, error) {
return c.Client.Extensions(context.Background())
} | go | func (c *ExtensionManagerClient) Extensions() (osquery.InternalExtensionList, error) {
return c.Client.Extensions(context.Background())
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Extensions",
"(",
")",
"(",
"osquery",
".",
"InternalExtensionList",
",",
"error",
")",
"{",
"return",
"c",
".",
"Client",
".",
"Extensions",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"... | // Extensions requests the list of active registered extensions. | [
"Extensions",
"requests",
"the",
"list",
"of",
"active",
"registered",
"extensions",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L67-L69 |
14,701 | kolide/osquery-go | client.go | RegisterExtension | func (c *ExtensionManagerClient) RegisterExtension(info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
return c.Client.RegisterExtension(context.Background(), info, registry)
} | go | func (c *ExtensionManagerClient) RegisterExtension(info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
return c.Client.RegisterExtension(context.Background(), info, registry)
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"RegisterExtension",
"(",
"info",
"*",
"osquery",
".",
"InternalExtensionInfo",
",",
"registry",
"osquery",
".",
"ExtensionRegistry",
")",
"(",
"*",
"osquery",
".",
"ExtensionStatus",
",",
"error",
")",
"{",
... | // RegisterExtension registers the extension plugins with the osquery process. | [
"RegisterExtension",
"registers",
"the",
"extension",
"plugins",
"with",
"the",
"osquery",
"process",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L72-L74 |
14,702 | kolide/osquery-go | client.go | Options | func (c *ExtensionManagerClient) Options() (osquery.InternalOptionList, error) {
return c.Client.Options(context.Background())
} | go | func (c *ExtensionManagerClient) Options() (osquery.InternalOptionList, error) {
return c.Client.Options(context.Background())
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Options",
"(",
")",
"(",
"osquery",
".",
"InternalOptionList",
",",
"error",
")",
"{",
"return",
"c",
".",
"Client",
".",
"Options",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}"
] | // Options requests the list of bootstrap or configuration options. | [
"Options",
"requests",
"the",
"list",
"of",
"bootstrap",
"or",
"configuration",
"options",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L77-L79 |
14,703 | kolide/osquery-go | client.go | Query | func (c *ExtensionManagerClient) Query(sql string) (*osquery.ExtensionResponse, error) {
return c.Client.Query(context.Background(), sql)
} | go | func (c *ExtensionManagerClient) Query(sql string) (*osquery.ExtensionResponse, error) {
return c.Client.Query(context.Background(), sql)
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Query",
"(",
"sql",
"string",
")",
"(",
"*",
"osquery",
".",
"ExtensionResponse",
",",
"error",
")",
"{",
"return",
"c",
".",
"Client",
".",
"Query",
"(",
"context",
".",
"Background",
"(",
")",
",... | // Query requests a query to be run and returns the extension response.
// Consider using the QueryRow or QueryRows helpers for a more friendly
// interface. | [
"Query",
"requests",
"a",
"query",
"to",
"be",
"run",
"and",
"returns",
"the",
"extension",
"response",
".",
"Consider",
"using",
"the",
"QueryRow",
"or",
"QueryRows",
"helpers",
"for",
"a",
"more",
"friendly",
"interface",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L84-L86 |
14,704 | kolide/osquery-go | client.go | QueryRows | func (c *ExtensionManagerClient) QueryRows(sql string) ([]map[string]string, error) {
res, err := c.Query(sql)
if err != nil {
return nil, errors.Wrap(err, "transport error in query")
}
if res.Status == nil {
return nil, errors.New("query returned nil status")
}
if res.Status.Code != 0 {
return nil, errors.Errorf("query returned error: %s", res.Status.Message)
}
return res.Response, nil
} | go | func (c *ExtensionManagerClient) QueryRows(sql string) ([]map[string]string, error) {
res, err := c.Query(sql)
if err != nil {
return nil, errors.Wrap(err, "transport error in query")
}
if res.Status == nil {
return nil, errors.New("query returned nil status")
}
if res.Status.Code != 0 {
return nil, errors.Errorf("query returned error: %s", res.Status.Message)
}
return res.Response, nil
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"QueryRows",
"(",
"sql",
"string",
")",
"(",
"[",
"]",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"Query",
"(",
"sql",
")",
"\n",
"if",
"er... | // QueryRows is a helper that executes the requested query and returns the
// results. It handles checking both the transport level errors and the osquery
// internal errors by returning a normal Go error type. | [
"QueryRows",
"is",
"a",
"helper",
"that",
"executes",
"the",
"requested",
"query",
"and",
"returns",
"the",
"results",
".",
"It",
"handles",
"checking",
"both",
"the",
"transport",
"level",
"errors",
"and",
"the",
"osquery",
"internal",
"errors",
"by",
"return... | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L91-L104 |
14,705 | kolide/osquery-go | client.go | QueryRow | func (c *ExtensionManagerClient) QueryRow(sql string) (map[string]string, error) {
res, err := c.QueryRows(sql)
if err != nil {
return nil, err
}
if len(res) != 1 {
return nil, errors.Errorf("expected 1 row, got %d", len(res))
}
return res[0], nil
} | go | func (c *ExtensionManagerClient) QueryRow(sql string) (map[string]string, error) {
res, err := c.QueryRows(sql)
if err != nil {
return nil, err
}
if len(res) != 1 {
return nil, errors.Errorf("expected 1 row, got %d", len(res))
}
return res[0], nil
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"QueryRow",
"(",
"sql",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"QueryRows",
"(",
"sql",
")",
"\n",
"if",
"err",
"!=",... | // QueryRow behaves similarly to QueryRows, but it returns an error if the
// query does not return exactly one row. | [
"QueryRow",
"behaves",
"similarly",
"to",
"QueryRows",
"but",
"it",
"returns",
"an",
"error",
"if",
"the",
"query",
"does",
"not",
"return",
"exactly",
"one",
"row",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L108-L117 |
14,706 | kolide/osquery-go | plugin/distributed/distributed.go | NewPlugin | func NewPlugin(name string, getQueries GetQueriesFunc, writeResults WriteResultsFunc) *Plugin {
return &Plugin{name: name, getQueries: getQueries, writeResults: writeResults}
} | go | func NewPlugin(name string, getQueries GetQueriesFunc, writeResults WriteResultsFunc) *Plugin {
return &Plugin{name: name, getQueries: getQueries, writeResults: writeResults}
} | [
"func",
"NewPlugin",
"(",
"name",
"string",
",",
"getQueries",
"GetQueriesFunc",
",",
"writeResults",
"WriteResultsFunc",
")",
"*",
"Plugin",
"{",
"return",
"&",
"Plugin",
"{",
"name",
":",
"name",
",",
"getQueries",
":",
"getQueries",
",",
"writeResults",
":"... | // NewPlugin takes the distributed query functions and returns a struct
// implementing the OsqueryPlugin interface. Use this to wrap the appropriate
// functions into an osquery plugin. | [
"NewPlugin",
"takes",
"the",
"distributed",
"query",
"functions",
"and",
"returns",
"a",
"struct",
"implementing",
"the",
"OsqueryPlugin",
"interface",
".",
"Use",
"this",
"to",
"wrap",
"the",
"appropriate",
"functions",
"into",
"an",
"osquery",
"plugin",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/distributed/distributed.go#L66-L68 |
14,707 | kolide/osquery-go | plugin/distributed/distributed.go | UnmarshalJSON | func (oi *OsqueryInt) UnmarshalJSON(buff []byte) error {
s := string(buff)
if strings.Contains(s, `"`) {
unquoted, err := strconv.Unquote(s)
if err != nil {
return &json.UnmarshalTypeError{
Value: string(buff),
Type: reflect.TypeOf(oi),
Struct: "statuses",
}
}
s = unquoted
}
if len(s) == 0 {
*oi = OsqueryInt(0)
return nil
}
parsedInt, err := strconv.ParseInt(s, 10, 32)
if err != nil {
return &json.UnmarshalTypeError{
Value: string(buff),
Type: reflect.TypeOf(oi),
Struct: "statuses",
}
}
*oi = OsqueryInt(parsedInt)
return nil
} | go | func (oi *OsqueryInt) UnmarshalJSON(buff []byte) error {
s := string(buff)
if strings.Contains(s, `"`) {
unquoted, err := strconv.Unquote(s)
if err != nil {
return &json.UnmarshalTypeError{
Value: string(buff),
Type: reflect.TypeOf(oi),
Struct: "statuses",
}
}
s = unquoted
}
if len(s) == 0 {
*oi = OsqueryInt(0)
return nil
}
parsedInt, err := strconv.ParseInt(s, 10, 32)
if err != nil {
return &json.UnmarshalTypeError{
Value: string(buff),
Type: reflect.TypeOf(oi),
Struct: "statuses",
}
}
*oi = OsqueryInt(parsedInt)
return nil
} | [
"func",
"(",
"oi",
"*",
"OsqueryInt",
")",
"UnmarshalJSON",
"(",
"buff",
"[",
"]",
"byte",
")",
"error",
"{",
"s",
":=",
"string",
"(",
"buff",
")",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"s",
",",
"`\"`",
")",
"{",
"unquoted",
",",
"err",
... | // UnmarshalJSON marshals a json string that is convertable to an int, for
// example "234" -> 234. | [
"UnmarshalJSON",
"marshals",
"a",
"json",
"string",
"that",
"is",
"convertable",
"to",
"an",
"int",
"for",
"example",
"234",
"-",
">",
"234",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/distributed/distributed.go#L106-L136 |
14,708 | kolide/osquery-go | plugin/distributed/distributed.go | UnmarshalJSON | func (rs *ResultsStruct) UnmarshalJSON(buff []byte) error {
emptyRow := []map[string]string{}
rs.Queries = make(map[string][]map[string]string)
rs.Statuses = make(map[string]OsqueryInt)
// Queries can be []map[string]string OR an empty string
// so we need to deal with an interface to accomodate two types
intermediate := struct {
Queries map[string]interface{} `json:"queries"`
Statuses map[string]OsqueryInt `json:"statuses"`
}{}
if err := json.Unmarshal(buff, &intermediate); err != nil {
return err
}
for queryName, status := range intermediate.Statuses {
rs.Statuses[queryName] = status
// Sometimes we have a status but don't have a corresponding
// result.
queryResult, ok := intermediate.Queries[queryName]
if !ok {
rs.Queries[queryName] = emptyRow
continue
}
// Deal with structurally inconsistent results, sometimes a query
// without any results is just a name with an empty string.
switch val := queryResult.(type) {
case string:
rs.Queries[queryName] = emptyRow
case []interface{}:
results, err := convertRows(val)
if err != nil {
return err
}
rs.Queries[queryName] = results
default:
return fmt.Errorf("results for %q unknown type", queryName)
}
}
return nil
} | go | func (rs *ResultsStruct) UnmarshalJSON(buff []byte) error {
emptyRow := []map[string]string{}
rs.Queries = make(map[string][]map[string]string)
rs.Statuses = make(map[string]OsqueryInt)
// Queries can be []map[string]string OR an empty string
// so we need to deal with an interface to accomodate two types
intermediate := struct {
Queries map[string]interface{} `json:"queries"`
Statuses map[string]OsqueryInt `json:"statuses"`
}{}
if err := json.Unmarshal(buff, &intermediate); err != nil {
return err
}
for queryName, status := range intermediate.Statuses {
rs.Statuses[queryName] = status
// Sometimes we have a status but don't have a corresponding
// result.
queryResult, ok := intermediate.Queries[queryName]
if !ok {
rs.Queries[queryName] = emptyRow
continue
}
// Deal with structurally inconsistent results, sometimes a query
// without any results is just a name with an empty string.
switch val := queryResult.(type) {
case string:
rs.Queries[queryName] = emptyRow
case []interface{}:
results, err := convertRows(val)
if err != nil {
return err
}
rs.Queries[queryName] = results
default:
return fmt.Errorf("results for %q unknown type", queryName)
}
}
return nil
} | [
"func",
"(",
"rs",
"*",
"ResultsStruct",
")",
"UnmarshalJSON",
"(",
"buff",
"[",
"]",
"byte",
")",
"error",
"{",
"emptyRow",
":=",
"[",
"]",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"rs",
".",
"Queries",
"=",
"make",
"(",
"map",
"[",
... | // UnmarshalJSON turns structurally inconsistent osquery json into a ResultsStruct. | [
"UnmarshalJSON",
"turns",
"structurally",
"inconsistent",
"osquery",
"json",
"into",
"a",
"ResultsStruct",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/distributed/distributed.go#L145-L183 |
14,709 | arschles/go-in-5-minutes | episode13/models/person.go | CreatePersonTable | func CreatePersonTable(db *sql.DB) (sql.Result, error) {
return db.Exec(
fmt.Sprintf("CREATE TABLE %s (%s varchar(255), %s varchar(255), %s int)",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
)
} | go | func CreatePersonTable(db *sql.DB) (sql.Result, error) {
return db.Exec(
fmt.Sprintf("CREATE TABLE %s (%s varchar(255), %s varchar(255), %s int)",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
)
} | [
"func",
"CreatePersonTable",
"(",
"db",
"*",
"sql",
".",
"DB",
")",
"(",
"sql",
".",
"Result",
",",
"error",
")",
"{",
"return",
"db",
".",
"Exec",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"PersonTableName",
",",
"PersonFirstNameCol",
",",
"... | // CreatePersonTable uses db to create a new table for Person models, and returns the result | [
"CreatePersonTable",
"uses",
"db",
"to",
"create",
"a",
"new",
"table",
"for",
"Person",
"models",
"and",
"returns",
"the",
"result"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode13/models/person.go#L27-L36 |
14,710 | arschles/go-in-5-minutes | episode13/models/person.go | InsertPerson | func InsertPerson(db *sql.DB, person Person) (sql.Result, error) {
return db.Exec(
fmt.Sprintf("INSERT INTO %s VALUES(?, ?, ?)", PersonTableName),
person.FirstName,
person.LastName,
person.Age,
)
} | go | func InsertPerson(db *sql.DB, person Person) (sql.Result, error) {
return db.Exec(
fmt.Sprintf("INSERT INTO %s VALUES(?, ?, ?)", PersonTableName),
person.FirstName,
person.LastName,
person.Age,
)
} | [
"func",
"InsertPerson",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"person",
"Person",
")",
"(",
"sql",
".",
"Result",
",",
"error",
")",
"{",
"return",
"db",
".",
"Exec",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"PersonTableName",
")",
",",
... | // InsertPerson inserts person into db | [
"InsertPerson",
"inserts",
"person",
"into",
"db"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode13/models/person.go#L39-L46 |
14,711 | arschles/go-in-5-minutes | episode13/models/person.go | SelectPerson | func SelectPerson(db *sql.DB, firstName, lastName string, age uint, result *Person) error {
row := db.QueryRow(
fmt.Sprintf(
"SELECT * FROM %s WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
var retFirstName, retLastName string
var retAge uint
if err := row.Scan(&retFirstName, &retLastName, &retAge); err != nil {
return err
}
result.FirstName = retFirstName
result.LastName = retLastName
result.Age = retAge
return nil
} | go | func SelectPerson(db *sql.DB, firstName, lastName string, age uint, result *Person) error {
row := db.QueryRow(
fmt.Sprintf(
"SELECT * FROM %s WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
var retFirstName, retLastName string
var retAge uint
if err := row.Scan(&retFirstName, &retLastName, &retAge); err != nil {
return err
}
result.FirstName = retFirstName
result.LastName = retLastName
result.Age = retAge
return nil
} | [
"func",
"SelectPerson",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"firstName",
",",
"lastName",
"string",
",",
"age",
"uint",
",",
"result",
"*",
"Person",
")",
"error",
"{",
"row",
":=",
"db",
".",
"QueryRow",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"... | // SelectPerson selects a person with the given first & last names and age. On success, writes the result into result and on failure, returns a non-nil error and makes no modifications to result | [
"SelectPerson",
"selects",
"a",
"person",
"with",
"the",
"given",
"first",
"&",
"last",
"names",
"and",
"age",
".",
"On",
"success",
"writes",
"the",
"result",
"into",
"result",
"and",
"on",
"failure",
"returns",
"a",
"non",
"-",
"nil",
"error",
"and",
"... | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode13/models/person.go#L49-L71 |
14,712 | arschles/go-in-5-minutes | episode13/models/person.go | UpdatePerson | func UpdatePerson(db *sql.DB, firstName, lastName string, age uint, newPerson Person) error {
_, err := db.Exec(
fmt.Sprintf(
"UPDATE %s SET %s=?,%s=?,%s=? WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
newPerson.FirstName,
newPerson.LastName,
newPerson.Age,
firstName,
lastName,
age,
)
return err
} | go | func UpdatePerson(db *sql.DB, firstName, lastName string, age uint, newPerson Person) error {
_, err := db.Exec(
fmt.Sprintf(
"UPDATE %s SET %s=?,%s=?,%s=? WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
newPerson.FirstName,
newPerson.LastName,
newPerson.Age,
firstName,
lastName,
age,
)
return err
} | [
"func",
"UpdatePerson",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"firstName",
",",
"lastName",
"string",
",",
"age",
"uint",
",",
"newPerson",
"Person",
")",
"error",
"{",
"_",
",",
"err",
":=",
"db",
".",
"Exec",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"... | // UpdatePerson updates the person with the given first & last names and age with newPerson. Returns a non-nil error if the update failed, and nil if the update succeeded | [
"UpdatePerson",
"updates",
"the",
"person",
"with",
"the",
"given",
"first",
"&",
"last",
"names",
"and",
"age",
"with",
"newPerson",
".",
"Returns",
"a",
"non",
"-",
"nil",
"error",
"if",
"the",
"update",
"failed",
"and",
"nil",
"if",
"the",
"update",
"... | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode13/models/person.go#L74-L94 |
14,713 | arschles/go-in-5-minutes | episode13/models/person.go | DeletePerson | func DeletePerson(db *sql.DB, firstName, lastName string, age uint) error {
_, err := db.Exec(
fmt.Sprintf(
"DELETE FROM %s WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
return err
} | go | func DeletePerson(db *sql.DB, firstName, lastName string, age uint) error {
_, err := db.Exec(
fmt.Sprintf(
"DELETE FROM %s WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
return err
} | [
"func",
"DeletePerson",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"firstName",
",",
"lastName",
"string",
",",
"age",
"uint",
")",
"error",
"{",
"_",
",",
"err",
":=",
"db",
".",
"Exec",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"PersonTableNa... | // DeletePerson deletes the person with the given first & last names and age. Returns a non-nil error if the delete failed, and nil if the delete succeeded | [
"DeletePerson",
"deletes",
"the",
"person",
"with",
"the",
"given",
"first",
"&",
"last",
"names",
"and",
"age",
".",
"Returns",
"a",
"non",
"-",
"nil",
"error",
"if",
"the",
"delete",
"failed",
"and",
"nil",
"if",
"the",
"delete",
"succeeded"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode13/models/person.go#L97-L111 |
14,714 | arschles/go-in-5-minutes | episode22/actions/otheraction.go | OtherHandler | func OtherHandler(c buffalo.Context) error {
name := c.Param("name")
c.Set("name", name)
return c.Render(200, r.HTML("other.html"))
} | go | func OtherHandler(c buffalo.Context) error {
name := c.Param("name")
c.Set("name", name)
return c.Render(200, r.HTML("other.html"))
} | [
"func",
"OtherHandler",
"(",
"c",
"buffalo",
".",
"Context",
")",
"error",
"{",
"name",
":=",
"c",
".",
"Param",
"(",
"\"",
"\"",
")",
"\n",
"c",
".",
"Set",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"return",
"c",
".",
"Render",
"(",
"200",
","... | // OtherHandler is a default handler to serve up
// a home page. | [
"OtherHandler",
"is",
"a",
"default",
"handler",
"to",
"serve",
"up",
"a",
"home",
"page",
"."
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode22/actions/otheraction.go#L7-L11 |
14,715 | arschles/go-in-5-minutes | episode5/handlers/renderer.go | NewRenderRenderer | func NewRenderRenderer(dir string, extensions []string, funcs []template.FuncMap, dev bool) *RenderRenderer {
opts := render.Options{
Directory: dir,
Extensions: extensions,
Funcs: funcs,
IsDevelopment: dev,
}
return &RenderRenderer{r: render.New(opts)}
} | go | func NewRenderRenderer(dir string, extensions []string, funcs []template.FuncMap, dev bool) *RenderRenderer {
opts := render.Options{
Directory: dir,
Extensions: extensions,
Funcs: funcs,
IsDevelopment: dev,
}
return &RenderRenderer{r: render.New(opts)}
} | [
"func",
"NewRenderRenderer",
"(",
"dir",
"string",
",",
"extensions",
"[",
"]",
"string",
",",
"funcs",
"[",
"]",
"template",
".",
"FuncMap",
",",
"dev",
"bool",
")",
"*",
"RenderRenderer",
"{",
"opts",
":=",
"render",
".",
"Options",
"{",
"Directory",
"... | // NewRenderRenderer returns a new RenderRenderer, where the underlying render.Render
// serves templates out of dir with the given func map. it's configured in dev mode
// according to the dev boolean | [
"NewRenderRenderer",
"returns",
"a",
"new",
"RenderRenderer",
"where",
"the",
"underlying",
"render",
".",
"Render",
"serves",
"templates",
"out",
"of",
"dir",
"with",
"the",
"given",
"func",
"map",
".",
"it",
"s",
"configured",
"in",
"dev",
"mode",
"according... | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode5/handlers/renderer.go#L29-L37 |
14,716 | arschles/go-in-5-minutes | episode5/handlers/renderer.go | Render | func (r *RenderRenderer) Render(w http.ResponseWriter, code int, templateName string, data interface{}, layout string) {
if layout != "" {
r.r.HTML(w, code, templateName, data, render.HTMLOptions{Layout: layout})
return
}
r.r.HTML(w, code, templateName, data)
} | go | func (r *RenderRenderer) Render(w http.ResponseWriter, code int, templateName string, data interface{}, layout string) {
if layout != "" {
r.r.HTML(w, code, templateName, data, render.HTMLOptions{Layout: layout})
return
}
r.r.HTML(w, code, templateName, data)
} | [
"func",
"(",
"r",
"*",
"RenderRenderer",
")",
"Render",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"code",
"int",
",",
"templateName",
"string",
",",
"data",
"interface",
"{",
"}",
",",
"layout",
"string",
")",
"{",
"if",
"layout",
"!=",
"\"",
"\"",... | // Render is the interface implementation | [
"Render",
"is",
"the",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode5/handlers/renderer.go#L40-L46 |
14,717 | arschles/go-in-5-minutes | episode9/conf/conf.go | NewMem | func NewMem() Data {
return &memData{l: &sync.RWMutex{}, strings: make(map[string]string), ints: make(map[string]int)}
} | go | func NewMem() Data {
return &memData{l: &sync.RWMutex{}, strings: make(map[string]string), ints: make(map[string]int)}
} | [
"func",
"NewMem",
"(",
")",
"Data",
"{",
"return",
"&",
"memData",
"{",
"l",
":",
"&",
"sync",
".",
"RWMutex",
"{",
"}",
",",
"strings",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"ints",
":",
"make",
"(",
"map",
"[",
"str... | // NewMem creates a Data implementation that stores config data in memory | [
"NewMem",
"creates",
"a",
"Data",
"implementation",
"that",
"stores",
"config",
"data",
"in",
"memory"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode9/conf/conf.go#L40-L42 |
14,718 | arschles/go-in-5-minutes | episode9/conf/conf.go | SetInt | func (m *memData) SetInt(name string, i int) {
m.l.Lock()
defer m.l.Unlock()
m.ints[name] = i
} | go | func (m *memData) SetInt(name string, i int) {
m.l.Lock()
defer m.l.Unlock()
m.ints[name] = i
} | [
"func",
"(",
"m",
"*",
"memData",
")",
"SetInt",
"(",
"name",
"string",
",",
"i",
"int",
")",
"{",
"m",
".",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"l",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"ints",
"[",
"name",
"]",
"=",
... | // SetInt is the interface implementation | [
"SetInt",
"is",
"the",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode9/conf/conf.go#L45-L49 |
14,719 | arschles/go-in-5-minutes | episode9/conf/conf.go | GetInt | func (m *memData) GetInt(name string) (int, error) {
m.l.RLock()
defer m.l.RUnlock()
i, ok := m.ints[name]
if !ok {
return 0, ErrNotFound
}
return i, nil
} | go | func (m *memData) GetInt(name string) (int, error) {
m.l.RLock()
defer m.l.RUnlock()
i, ok := m.ints[name]
if !ok {
return 0, ErrNotFound
}
return i, nil
} | [
"func",
"(",
"m",
"*",
"memData",
")",
"GetInt",
"(",
"name",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"m",
".",
"l",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"l",
".",
"RUnlock",
"(",
")",
"\n",
"i",
",",
"ok",
":=",
"m",... | // GetInt is the interface implementation | [
"GetInt",
"is",
"the",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode9/conf/conf.go#L52-L60 |
14,720 | arschles/go-in-5-minutes | episode11/db/mem.go | Save | func (m *Mem) Save(key models.Key, model models.Model) error {
m.mut.Lock()
defer m.mut.Unlock()
m.m[key.String()] = model
return nil
} | go | func (m *Mem) Save(key models.Key, model models.Model) error {
m.mut.Lock()
defer m.mut.Unlock()
m.m[key.String()] = model
return nil
} | [
"func",
"(",
"m",
"*",
"Mem",
")",
"Save",
"(",
"key",
"models",
".",
"Key",
",",
"model",
"models",
".",
"Model",
")",
"error",
"{",
"m",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mut",
".",
"Unlock",
"(",
")",
"\n",
"m",
... | // Save is the interface implementation. Overwrites existing keys and never returns an error | [
"Save",
"is",
"the",
"interface",
"implementation",
".",
"Overwrites",
"existing",
"keys",
"and",
"never",
"returns",
"an",
"error"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/db/mem.go#L25-L30 |
14,721 | arschles/go-in-5-minutes | episode11/db/mem.go | Delete | func (m *Mem) Delete(key models.Key) error {
m.mut.Lock()
defer m.mut.Unlock()
delete(m.m, key.String())
return nil
} | go | func (m *Mem) Delete(key models.Key) error {
m.mut.Lock()
defer m.mut.Unlock()
delete(m.m, key.String())
return nil
} | [
"func",
"(",
"m",
"*",
"Mem",
")",
"Delete",
"(",
"key",
"models",
".",
"Key",
")",
"error",
"{",
"m",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mut",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"m",
".",
"m",
",",
"key... | // Delete is the interface implementation. Never returns an error, even if the key didn't exist | [
"Delete",
"is",
"the",
"interface",
"implementation",
".",
"Never",
"returns",
"an",
"error",
"even",
"if",
"the",
"key",
"didn",
"t",
"exist"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/db/mem.go#L33-L38 |
14,722 | arschles/go-in-5-minutes | episode11/db/mem.go | Get | func (m *Mem) Get(key models.Key, model models.Model) error {
m.mut.RLock()
defer m.mut.RUnlock()
md, ok := m.m[key.String()]
if !ok {
return ErrNotFound
}
return model.Set(md)
} | go | func (m *Mem) Get(key models.Key, model models.Model) error {
m.mut.RLock()
defer m.mut.RUnlock()
md, ok := m.m[key.String()]
if !ok {
return ErrNotFound
}
return model.Set(md)
} | [
"func",
"(",
"m",
"*",
"Mem",
")",
"Get",
"(",
"key",
"models",
".",
"Key",
",",
"model",
"models",
".",
"Model",
")",
"error",
"{",
"m",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n",
"md"... | // Get is the interface implementation. Returns ErrNotFound if no such key existed. Callers should pass a pointer to a model so that Get can write the fetched model into it | [
"Get",
"is",
"the",
"interface",
"implementation",
".",
"Returns",
"ErrNotFound",
"if",
"no",
"such",
"key",
"existed",
".",
"Callers",
"should",
"pass",
"a",
"pointer",
"to",
"a",
"model",
"so",
"that",
"Get",
"can",
"write",
"the",
"fetched",
"model",
"i... | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/db/mem.go#L41-L49 |
14,723 | arschles/go-in-5-minutes | episode12/dishes/manager.go | randDishIdx | func (m *Manager) randDishIdx() int {
if len(m.dishes) == 0 {
return -1
}
return rand.Intn(len(m.dishes))
} | go | func (m *Manager) randDishIdx() int {
if len(m.dishes) == 0 {
return -1
}
return rand.Intn(len(m.dishes))
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"randDishIdx",
"(",
")",
"int",
"{",
"if",
"len",
"(",
"m",
".",
"dishes",
")",
"==",
"0",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"return",
"rand",
".",
"Intn",
"(",
"len",
"(",
"m",
".",
"dishes",
")... | // randDishIdx returns a random index into the dishes slice, or -1 if the slice
// is empty | [
"randDishIdx",
"returns",
"a",
"random",
"index",
"into",
"the",
"dishes",
"slice",
"or",
"-",
"1",
"if",
"the",
"slice",
"is",
"empty"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode12/dishes/manager.go#L68-L73 |
14,724 | arschles/go-in-5-minutes | episode24/actions/app.go | App | func App() *buffalo.App {
if app == nil {
app = buffalo.New(buffalo.Options{
Env: ENV,
SessionName: "_episode24_session",
})
// Automatically redirect to SSL
app.Use(ssl.ForceSSL(secure.Options{
SSLRedirect: ENV == "production",
SSLProxyHeaders: map[string]string{"X-Forwarded-Proto": "https"},
}))
if ENV == "development" {
app.Use(middleware.ParameterLogger)
}
// Protect against CSRF attacks. https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
// Remove to disable this.
app.Use(csrf.New)
// Wraps each request in a transaction.
// c.Value("tx").(*pop.PopTransaction)
// Remove to disable this.
app.Use(middleware.PopTransaction(models.DB))
// Setup and use translations:
var err error
if T, err = i18n.New(packr.NewBox("../locales"), "en-US"); err != nil {
app.Stop(err)
}
app.Use(T.Middleware())
app.GET("/", HomeHandler)
app.Resource("/gifms", GifmsResource{})
app.ServeFiles("/", assetsBox) // serve files from the public directory
}
return app
} | go | func App() *buffalo.App {
if app == nil {
app = buffalo.New(buffalo.Options{
Env: ENV,
SessionName: "_episode24_session",
})
// Automatically redirect to SSL
app.Use(ssl.ForceSSL(secure.Options{
SSLRedirect: ENV == "production",
SSLProxyHeaders: map[string]string{"X-Forwarded-Proto": "https"},
}))
if ENV == "development" {
app.Use(middleware.ParameterLogger)
}
// Protect against CSRF attacks. https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
// Remove to disable this.
app.Use(csrf.New)
// Wraps each request in a transaction.
// c.Value("tx").(*pop.PopTransaction)
// Remove to disable this.
app.Use(middleware.PopTransaction(models.DB))
// Setup and use translations:
var err error
if T, err = i18n.New(packr.NewBox("../locales"), "en-US"); err != nil {
app.Stop(err)
}
app.Use(T.Middleware())
app.GET("/", HomeHandler)
app.Resource("/gifms", GifmsResource{})
app.ServeFiles("/", assetsBox) // serve files from the public directory
}
return app
} | [
"func",
"App",
"(",
")",
"*",
"buffalo",
".",
"App",
"{",
"if",
"app",
"==",
"nil",
"{",
"app",
"=",
"buffalo",
".",
"New",
"(",
"buffalo",
".",
"Options",
"{",
"Env",
":",
"ENV",
",",
"SessionName",
":",
"\"",
"\"",
",",
"}",
")",
"\n",
"// Au... | // App is where all routes and middleware for buffalo
// should be defined. This is the nerve center of your
// application. | [
"App",
"is",
"where",
"all",
"routes",
"and",
"middleware",
"for",
"buffalo",
"should",
"be",
"defined",
".",
"This",
"is",
"the",
"nerve",
"center",
"of",
"your",
"application",
"."
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode24/actions/app.go#L25-L64 |
14,725 | arschles/go-in-5-minutes | episode3/admin_api_handlers.go | releaseAllServers | func releaseAllServers(w http.ResponseWriter, r *http.Request) {
mx.Lock()
defer mx.Unlock()
for _, status := range servers {
status.Reserved = false
}
if err := json.NewEncoder(w).Encode(servers); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusNoContent)
}
} | go | func releaseAllServers(w http.ResponseWriter, r *http.Request) {
mx.Lock()
defer mx.Unlock()
for _, status := range servers {
status.Reserved = false
}
if err := json.NewEncoder(w).Encode(servers); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusNoContent)
}
} | [
"func",
"releaseAllServers",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"mx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mx",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"status",
":=",
"range",
"serve... | // releaseAllServers is the handler to release the lock on all servers. it's an admin-only handler | [
"releaseAllServers",
"is",
"the",
"handler",
"to",
"release",
"the",
"lock",
"on",
"all",
"servers",
".",
"it",
"s",
"an",
"admin",
"-",
"only",
"handler"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode3/admin_api_handlers.go#L10-L20 |
14,726 | arschles/go-in-5-minutes | episode3/admin_api_handlers.go | getAllServers | func getAllServers(w http.ResponseWriter, r *http.Request) {
mx.RLock()
defer mx.RUnlock()
if err := json.NewEncoder(w).Encode(servers); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | go | func getAllServers(w http.ResponseWriter, r *http.Request) {
mx.RLock()
defer mx.RUnlock()
if err := json.NewEncoder(w).Encode(servers); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | [
"func",
"getAllServers",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"mx",
".",
"RLock",
"(",
")",
"\n",
"defer",
"mx",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"NewEncoder",
"(",... | // getAllServers is the handler to get the status of all servers. it's admin-only | [
"getAllServers",
"is",
"the",
"handler",
"to",
"get",
"the",
"status",
"of",
"all",
"servers",
".",
"it",
"s",
"admin",
"-",
"only"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode3/admin_api_handlers.go#L23-L30 |
14,727 | arschles/go-in-5-minutes | episode11/db/redis.go | Save | func (r *Redis) Save(k models.Key, m models.Model) error {
b, err := m.MarshalBinary()
if err != nil {
return err
}
return r.client.Set(k.String(), b, time.Duration(0)).Err()
} | go | func (r *Redis) Save(k models.Key, m models.Model) error {
b, err := m.MarshalBinary()
if err != nil {
return err
}
return r.client.Set(k.String(), b, time.Duration(0)).Err()
} | [
"func",
"(",
"r",
"*",
"Redis",
")",
"Save",
"(",
"k",
"models",
".",
"Key",
",",
"m",
"models",
".",
"Model",
")",
"error",
"{",
"b",
",",
"err",
":=",
"m",
".",
"MarshalBinary",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
... | // Save is the interface implementation | [
"Save",
"is",
"the",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/db/redis.go#L21-L27 |
14,728 | arschles/go-in-5-minutes | episode11/db/redis.go | Delete | func (r *Redis) Delete(k models.Key) error {
return r.client.Del(k.String()).Err()
} | go | func (r *Redis) Delete(k models.Key) error {
return r.client.Del(k.String()).Err()
} | [
"func",
"(",
"r",
"*",
"Redis",
")",
"Delete",
"(",
"k",
"models",
".",
"Key",
")",
"error",
"{",
"return",
"r",
".",
"client",
".",
"Del",
"(",
"k",
".",
"String",
"(",
")",
")",
".",
"Err",
"(",
")",
"\n",
"}"
] | // Delete is the interface implementation | [
"Delete",
"is",
"the",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/db/redis.go#L30-L32 |
14,729 | arschles/go-in-5-minutes | episode14/main.go | hdl | func hdl(t *template.Template) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Notice that t.Execute takes an io.Writer as its first argument. The variable w (an http.ResponseWriter) implements io.Writer, so we pass it and allow the implementation to call its Write function as necessary
if err := t.Execute(w, r.URL.Query()); err != nil {
http.Error(w, fmt.Sprintf("error executing template (%s)", err), http.StatusInternalServerError)
}
})
} | go | func hdl(t *template.Template) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Notice that t.Execute takes an io.Writer as its first argument. The variable w (an http.ResponseWriter) implements io.Writer, so we pass it and allow the implementation to call its Write function as necessary
if err := t.Execute(w, r.URL.Query()); err != nil {
http.Error(w, fmt.Sprintf("error executing template (%s)", err), http.StatusInternalServerError)
}
})
} | [
"func",
"hdl",
"(",
"t",
"*",
"template",
".",
"Template",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"// Notice that t.... | // hdl is a handler that calls t.Execute, passing all of the query string values as data to the template | [
"hdl",
"is",
"a",
"handler",
"that",
"calls",
"t",
".",
"Execute",
"passing",
"all",
"of",
"the",
"query",
"string",
"values",
"as",
"data",
"to",
"the",
"template"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode14/main.go#L11-L18 |
14,730 | arschles/go-in-5-minutes | episode11/conf.go | GetConfig | func GetConfig() (*Config, error) {
conf := new(Config)
if err := envconfig.Process(AppName, conf); err != nil {
return nil, err
}
return conf, nil
} | go | func GetConfig() (*Config, error) {
conf := new(Config)
if err := envconfig.Process(AppName, conf); err != nil {
return nil, err
}
return conf, nil
} | [
"func",
"GetConfig",
"(",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"conf",
":=",
"new",
"(",
"Config",
")",
"\n",
"if",
"err",
":=",
"envconfig",
".",
"Process",
"(",
"AppName",
",",
"conf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"n... | // GetConfig uses envconfig to populate and return a Config struct. Returns all envconfig errors if they occurred | [
"GetConfig",
"uses",
"envconfig",
"to",
"populate",
"and",
"return",
"a",
"Config",
"struct",
".",
"Returns",
"all",
"envconfig",
"errors",
"if",
"they",
"occurred"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/conf.go#L21-L27 |
14,731 | arschles/go-in-5-minutes | episode16/set.go | exists | func (s *set) exists(elt setElement) bool {
_, ok := s.m[elt]
return ok
} | go | func (s *set) exists(elt setElement) bool {
_, ok := s.m[elt]
return ok
} | [
"func",
"(",
"s",
"*",
"set",
")",
"exists",
"(",
"elt",
"setElement",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"s",
".",
"m",
"[",
"elt",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // returns true if elt already exists in s | [
"returns",
"true",
"if",
"elt",
"already",
"exists",
"in",
"s"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode16/set.go#L18-L21 |
14,732 | arschles/go-in-5-minutes | episode16/set.go | add | func (s *set) add(elt setElement) bool {
_, ok := s.m[elt]
s.m[elt] = struct{}{}
return !ok
} | go | func (s *set) add(elt setElement) bool {
_, ok := s.m[elt]
s.m[elt] = struct{}{}
return !ok
} | [
"func",
"(",
"s",
"*",
"set",
")",
"add",
"(",
"elt",
"setElement",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"s",
".",
"m",
"[",
"elt",
"]",
"\n",
"s",
".",
"m",
"[",
"elt",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"return",
"!",
"ok"... | // adds elt to s unless it already exists. returns true if it was added successfully | [
"adds",
"elt",
"to",
"s",
"unless",
"it",
"already",
"exists",
".",
"returns",
"true",
"if",
"it",
"was",
"added",
"successfully"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode16/set.go#L24-L28 |
14,733 | arschles/go-in-5-minutes | episode16/set.go | remove | func (s *set) remove(elt setElement) bool {
_, ok := s.m[elt]
if !ok {
return false
}
delete(s.m, elt)
return true
} | go | func (s *set) remove(elt setElement) bool {
_, ok := s.m[elt]
if !ok {
return false
}
delete(s.m, elt)
return true
} | [
"func",
"(",
"s",
"*",
"set",
")",
"remove",
"(",
"elt",
"setElement",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"s",
".",
"m",
"[",
"elt",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"delete",
"(",
"s",
".",
"m",
","... | // removes elt from s unless it doesn't exist. returns true if it was removed, false otherwise | [
"removes",
"elt",
"from",
"s",
"unless",
"it",
"doesn",
"t",
"exist",
".",
"returns",
"true",
"if",
"it",
"was",
"removed",
"false",
"otherwise"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode16/set.go#L31-L38 |
14,734 | arschles/go-in-5-minutes | episode16/set.go | removeAll | func (s *set) removeAll() int {
ret := len(s.m)
s.m = make(map[setElement]struct{})
return ret
} | go | func (s *set) removeAll() int {
ret := len(s.m)
s.m = make(map[setElement]struct{})
return ret
} | [
"func",
"(",
"s",
"*",
"set",
")",
"removeAll",
"(",
")",
"int",
"{",
"ret",
":=",
"len",
"(",
"s",
".",
"m",
")",
"\n",
"s",
".",
"m",
"=",
"make",
"(",
"map",
"[",
"setElement",
"]",
"struct",
"{",
"}",
")",
"\n",
"return",
"ret",
"\n",
"... | // removeAll removes all elements from s and returns the total number of elements removed | [
"removeAll",
"removes",
"all",
"elements",
"from",
"s",
"and",
"returns",
"the",
"total",
"number",
"of",
"elements",
"removed"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode16/set.go#L41-L45 |
14,735 | arschles/go-in-5-minutes | episode11/models/app.go | UnmarshalBinary | func (a *App) UnmarshalBinary(b []byte) error {
return json.Unmarshal(b, a)
} | go | func (a *App) UnmarshalBinary(b []byte) error {
return json.Unmarshal(b, a)
} | [
"func",
"(",
"a",
"*",
"App",
")",
"UnmarshalBinary",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"a",
")",
"\n",
"}"
] | // UnmarshalBinary is the encoding.BinaryUnmarshaler interface implementation | [
"UnmarshalBinary",
"is",
"the",
"encoding",
".",
"BinaryUnmarshaler",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/models/app.go#L37-L39 |
14,736 | arschles/go-in-5-minutes | episode11/models/app.go | Set | func (a *App) Set(m Model) error {
app, ok := m.(*App)
if !ok {
return fmt.Errorf("given model %+v was not an *App", m)
}
*a = *app
return nil
} | go | func (a *App) Set(m Model) error {
app, ok := m.(*App)
if !ok {
return fmt.Errorf("given model %+v was not an *App", m)
}
*a = *app
return nil
} | [
"func",
"(",
"a",
"*",
"App",
")",
"Set",
"(",
"m",
"Model",
")",
"error",
"{",
"app",
",",
"ok",
":=",
"m",
".",
"(",
"*",
"App",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",... | // Set is the Model interface implementation | [
"Set",
"is",
"the",
"Model",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode11/models/app.go#L42-L49 |
14,737 | arschles/go-in-5-minutes | episode1/handlers/get_key.go | GetKey | func GetKey(db storage.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := r.URL.Query().Get("key")
if key == "" {
http.Error(w, "missing key name in query string", http.StatusBadRequest)
return
}
val, err := db.Get(key)
if err == storage.ErrNotFound {
http.Error(w, "not found", http.StatusNotFound)
return
} else if err != nil {
http.Error(w, fmt.Sprintf("error getting value from database: %s", err), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Write(val)
})
} | go | func GetKey(db storage.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := r.URL.Query().Get("key")
if key == "" {
http.Error(w, "missing key name in query string", http.StatusBadRequest)
return
}
val, err := db.Get(key)
if err == storage.ErrNotFound {
http.Error(w, "not found", http.StatusNotFound)
return
} else if err != nil {
http.Error(w, fmt.Sprintf("error getting value from database: %s", err), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Write(val)
})
} | [
"func",
"GetKey",
"(",
"db",
"storage",
".",
"DB",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"key",
":=",
"r",
".",... | // GetKey returns an http.Handler that can get a key registered by Gorilla mux
// as "key" in the path. It gets the value of the key from db | [
"GetKey",
"returns",
"an",
"http",
".",
"Handler",
"that",
"can",
"get",
"a",
"key",
"registered",
"by",
"Gorilla",
"mux",
"as",
"key",
"in",
"the",
"path",
".",
"It",
"gets",
"the",
"value",
"of",
"the",
"key",
"from",
"db"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode1/handlers/get_key.go#L12-L30 |
14,738 | arschles/go-in-5-minutes | episode5/models/mongo_db.go | Upsert | func (m *MongoDB) Upsert(key string, val Model) (bool, error) {
sess := m.sess.Copy()
defer sess.Close()
coll := sess.DB(dbName).C(candiesColl)
cInfo, err := coll.Upsert(bson.M{"key": key}, objWrapper{Key: key, Data: val})
if err != nil {
return false, err
}
// the Updated field is set when already existed, otherwise the UpsertedID field is set.
// see the func at https://bazaar.launchpad.net/+branch/mgo/v2/view/head:/session.go#L1896
return cInfo.UpsertedId != nil, nil
} | go | func (m *MongoDB) Upsert(key string, val Model) (bool, error) {
sess := m.sess.Copy()
defer sess.Close()
coll := sess.DB(dbName).C(candiesColl)
cInfo, err := coll.Upsert(bson.M{"key": key}, objWrapper{Key: key, Data: val})
if err != nil {
return false, err
}
// the Updated field is set when already existed, otherwise the UpsertedID field is set.
// see the func at https://bazaar.launchpad.net/+branch/mgo/v2/view/head:/session.go#L1896
return cInfo.UpsertedId != nil, nil
} | [
"func",
"(",
"m",
"*",
"MongoDB",
")",
"Upsert",
"(",
"key",
"string",
",",
"val",
"Model",
")",
"(",
"bool",
",",
"error",
")",
"{",
"sess",
":=",
"m",
".",
"sess",
".",
"Copy",
"(",
")",
"\n",
"defer",
"sess",
".",
"Close",
"(",
")",
"\n",
... | // Upsert is the interface implementation | [
"Upsert",
"is",
"the",
"interface",
"implementation"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode5/models/mongo_db.go#L74-L85 |
14,739 | arschles/go-in-5-minutes | episode3/api_handlers.go | releaseServer | func releaseServer(w http.ResponseWriter, r *http.Request) {
name, ok := mux.Vars(r)["name"]
if !ok {
http.Error(w, "name missing in URL path", http.StatusBadRequest)
return
}
mx.Lock()
defer mx.Unlock()
server, ok := servers[name]
if !ok {
http.Error(w, "no such server", http.StatusNotFound)
return
}
server.Reserved = false
if err := json.NewEncoder(w).Encode(server); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | go | func releaseServer(w http.ResponseWriter, r *http.Request) {
name, ok := mux.Vars(r)["name"]
if !ok {
http.Error(w, "name missing in URL path", http.StatusBadRequest)
return
}
mx.Lock()
defer mx.Unlock()
server, ok := servers[name]
if !ok {
http.Error(w, "no such server", http.StatusNotFound)
return
}
server.Reserved = false
if err := json.NewEncoder(w).Encode(server); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | [
"func",
"releaseServer",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"name",
",",
"ok",
":=",
"mux",
".",
"Vars",
"(",
"r",
")",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"http",
".",
"Error... | // releaseServer is the handler to release a specific server by name | [
"releaseServer",
"is",
"the",
"handler",
"to",
"release",
"a",
"specific",
"server",
"by",
"name"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode3/api_handlers.go#L58-L76 |
14,740 | arschles/go-in-5-minutes | episode1/handlers/put_key.go | PutKey | func PutKey(db storage.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := r.URL.Query().Get("key")
if key == "" {
http.Error(w, "missing key name in path", http.StatusBadRequest)
return
}
defer r.Body.Close()
val, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, "error reading PUT body", http.StatusBadRequest)
return
}
if err := db.Set(key, val); err != nil {
http.Error(w, "error setting value in DB", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
})
} | go | func PutKey(db storage.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := r.URL.Query().Get("key")
if key == "" {
http.Error(w, "missing key name in path", http.StatusBadRequest)
return
}
defer r.Body.Close()
val, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, "error reading PUT body", http.StatusBadRequest)
return
}
if err := db.Set(key, val); err != nil {
http.Error(w, "error setting value in DB", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
})
} | [
"func",
"PutKey",
"(",
"db",
"storage",
".",
"DB",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"key",
":=",
"r",
".",... | // PutKey returns an http.Handler that can set a value for the key registered by Gorilla
// mux as "key" in the path. It expects the value to be in the body of the PUT request | [
"PutKey",
"returns",
"an",
"http",
".",
"Handler",
"that",
"can",
"set",
"a",
"value",
"for",
"the",
"key",
"registered",
"by",
"Gorilla",
"mux",
"as",
"key",
"in",
"the",
"path",
".",
"It",
"expects",
"the",
"value",
"to",
"be",
"in",
"the",
"body",
... | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode1/handlers/put_key.go#L12-L31 |
14,741 | arschles/go-in-5-minutes | episode0/redis_database.go | Get | func (i RedisClientWrapper) Get(key string) ([]byte, error) {
val, ok := i.Client.Get(key).Result()
if ok != nil {
return nil, fmt.Errorf("Error: %s", ok)
}
return []byte(val), nil
} | go | func (i RedisClientWrapper) Get(key string) ([]byte, error) {
val, ok := i.Client.Get(key).Result()
if ok != nil {
return nil, fmt.Errorf("Error: %s", ok)
}
return []byte(val), nil
} | [
"func",
"(",
"i",
"RedisClientWrapper",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"val",
",",
"ok",
":=",
"i",
".",
"Client",
".",
"Get",
"(",
"key",
")",
".",
"Result",
"(",
")",
"\n",
"if",
"ok",
... | //Get method of the RedisClientWrapper type | [
"Get",
"method",
"of",
"the",
"RedisClientWrapper",
"type"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode0/redis_database.go#L16-L22 |
14,742 | arschles/go-in-5-minutes | episode0/redis_database.go | Set | func (i RedisClientWrapper) Set(key string, val []byte) error {
err := i.Client.Set(key, val, 0).Err()
return err
} | go | func (i RedisClientWrapper) Set(key string, val []byte) error {
err := i.Client.Set(key, val, 0).Err()
return err
} | [
"func",
"(",
"i",
"RedisClientWrapper",
")",
"Set",
"(",
"key",
"string",
",",
"val",
"[",
"]",
"byte",
")",
"error",
"{",
"err",
":=",
"i",
".",
"Client",
".",
"Set",
"(",
"key",
",",
"val",
",",
"0",
")",
".",
"Err",
"(",
")",
"\n",
"return",... | //Set method of the RedisClientWrapper type | [
"Set",
"method",
"of",
"the",
"RedisClientWrapper",
"type"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode0/redis_database.go#L25-L28 |
14,743 | arschles/go-in-5-minutes | episode20/transformer.go | transform | func (t *transformer) transform(key string, fn func(string) string) bool {
t.mut.Lock()
defer t.mut.Unlock()
val, found := t.cache[key]
if !found {
return false
}
str, ok := val.(string)
if !ok {
return false
}
newStr := fn(str)
t.cache[key] = newStr
return true
} | go | func (t *transformer) transform(key string, fn func(string) string) bool {
t.mut.Lock()
defer t.mut.Unlock()
val, found := t.cache[key]
if !found {
return false
}
str, ok := val.(string)
if !ok {
return false
}
newStr := fn(str)
t.cache[key] = newStr
return true
} | [
"func",
"(",
"t",
"*",
"transformer",
")",
"transform",
"(",
"key",
"string",
",",
"fn",
"func",
"(",
"string",
")",
"string",
")",
"bool",
"{",
"t",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"Unlock",
"(",
")",
"\... | // looks up key in the cache. if it exists, runs its value through fn, puts the new value
// back into the cache, and returns true. otherwise does nothing and returns false | [
"looks",
"up",
"key",
"in",
"the",
"cache",
".",
"if",
"it",
"exists",
"runs",
"its",
"value",
"through",
"fn",
"puts",
"the",
"new",
"value",
"back",
"into",
"the",
"cache",
"and",
"returns",
"true",
".",
"otherwise",
"does",
"nothing",
"and",
"returns"... | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode20/transformer.go#L14-L28 |
14,744 | arschles/go-in-5-minutes | episode20/transformer.go | remove | func (t *transformer) remove(key string) bool {
t.mut.Lock()
defer t.mut.Unlock()
if _, found := t.cache[key]; found {
delete(t.cache, key)
return true
}
return false
} | go | func (t *transformer) remove(key string) bool {
t.mut.Lock()
defer t.mut.Unlock()
if _, found := t.cache[key]; found {
delete(t.cache, key)
return true
}
return false
} | [
"func",
"(",
"t",
"*",
"transformer",
")",
"remove",
"(",
"key",
"string",
")",
"bool",
"{",
"t",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"found",
":=",
"t",
".",
"cach... | // removes key from the cache if it existed and returns true. otherwise returns false | [
"removes",
"key",
"from",
"the",
"cache",
"if",
"it",
"existed",
"and",
"returns",
"true",
".",
"otherwise",
"returns",
"false"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode20/transformer.go#L31-L39 |
14,745 | arschles/go-in-5-minutes | episode15/main.go | pluralize | func pluralize(i int, singular, plural string) string {
if i == 1 {
return singular
}
return plural
} | go | func pluralize(i int, singular, plural string) string {
if i == 1 {
return singular
}
return plural
} | [
"func",
"pluralize",
"(",
"i",
"int",
",",
"singular",
",",
"plural",
"string",
")",
"string",
"{",
"if",
"i",
"==",
"1",
"{",
"return",
"singular",
"\n",
"}",
"\n",
"return",
"plural",
"\n",
"}"
] | // convenience function that returns plural if i != 1, singular otherwise | [
"convenience",
"function",
"that",
"returns",
"plural",
"if",
"i",
"!",
"=",
"1",
"singular",
"otherwise"
] | ac81bfabceea8f9293f63a4c1a7ea096f4cc085c | https://github.com/arschles/go-in-5-minutes/blob/ac81bfabceea8f9293f63a4c1a7ea096f4cc085c/episode15/main.go#L27-L32 |
14,746 | milosgajdos83/tenus | veth_linux.go | SetPeerLinkIp | func (veth *VethPair) SetPeerLinkIp(ip net.IP, nw *net.IPNet) error {
return netlink.NetworkLinkAddIp(veth.peerIfc, ip, nw)
} | go | func (veth *VethPair) SetPeerLinkIp(ip net.IP, nw *net.IPNet) error {
return netlink.NetworkLinkAddIp(veth.peerIfc, ip, nw)
} | [
"func",
"(",
"veth",
"*",
"VethPair",
")",
"SetPeerLinkIp",
"(",
"ip",
"net",
".",
"IP",
",",
"nw",
"*",
"net",
".",
"IPNet",
")",
"error",
"{",
"return",
"netlink",
".",
"NetworkLinkAddIp",
"(",
"veth",
".",
"peerIfc",
",",
"ip",
",",
"nw",
")",
"... | // SetPeerLinkIp configures peer link's IP address | [
"SetPeerLinkIp",
"configures",
"peer",
"link",
"s",
"IP",
"address"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/veth_linux.go#L162-L164 |
14,747 | milosgajdos83/tenus | veth_linux.go | SetPeerLinkNsToDocker | func (veth *VethPair) SetPeerLinkNsToDocker(name string, dockerHost string) error {
pid, err := DockerPidByName(name, dockerHost)
if err != nil {
return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return netlink.NetworkSetNsPid(veth.peerIfc, pid)
} | go | func (veth *VethPair) SetPeerLinkNsToDocker(name string, dockerHost string) error {
pid, err := DockerPidByName(name, dockerHost)
if err != nil {
return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return netlink.NetworkSetNsPid(veth.peerIfc, pid)
} | [
"func",
"(",
"veth",
"*",
"VethPair",
")",
"SetPeerLinkNsToDocker",
"(",
"name",
"string",
",",
"dockerHost",
"string",
")",
"error",
"{",
"pid",
",",
"err",
":=",
"DockerPidByName",
"(",
"name",
",",
"dockerHost",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{... | // SetPeerLinkNsToDocker sends peer link into Docker | [
"SetPeerLinkNsToDocker",
"sends",
"peer",
"link",
"into",
"Docker"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/veth_linux.go#L167-L174 |
14,748 | milosgajdos83/tenus | veth_linux.go | SetPeerLinkNsPid | func (veth *VethPair) SetPeerLinkNsPid(nspid int) error {
return netlink.NetworkSetNsPid(veth.peerIfc, nspid)
} | go | func (veth *VethPair) SetPeerLinkNsPid(nspid int) error {
return netlink.NetworkSetNsPid(veth.peerIfc, nspid)
} | [
"func",
"(",
"veth",
"*",
"VethPair",
")",
"SetPeerLinkNsPid",
"(",
"nspid",
"int",
")",
"error",
"{",
"return",
"netlink",
".",
"NetworkSetNsPid",
"(",
"veth",
".",
"peerIfc",
",",
"nspid",
")",
"\n",
"}"
] | // SetPeerLinkNsPid sends peer link into container specified by PID | [
"SetPeerLinkNsPid",
"sends",
"peer",
"link",
"into",
"container",
"specified",
"by",
"PID"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/veth_linux.go#L177-L179 |
14,749 | milosgajdos83/tenus | veth_linux.go | SetPeerLinkNsFd | func (veth *VethPair) SetPeerLinkNsFd(nspath string) error {
fd, err := syscall.Open(nspath, syscall.O_RDONLY, 0)
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(veth.peerIfc, fd)
} | go | func (veth *VethPair) SetPeerLinkNsFd(nspath string) error {
fd, err := syscall.Open(nspath, syscall.O_RDONLY, 0)
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(veth.peerIfc, fd)
} | [
"func",
"(",
"veth",
"*",
"VethPair",
")",
"SetPeerLinkNsFd",
"(",
"nspath",
"string",
")",
"error",
"{",
"fd",
",",
"err",
":=",
"syscall",
".",
"Open",
"(",
"nspath",
",",
"syscall",
".",
"O_RDONLY",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // SetPeerLinkNsFd sends peer link into container specified by path | [
"SetPeerLinkNsFd",
"sends",
"peer",
"link",
"into",
"container",
"specified",
"by",
"path"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/veth_linux.go#L182-L189 |
14,750 | milosgajdos83/tenus | veth_linux.go | SetPeerLinkNetInNs | func (veth *VethPair) SetPeerLinkNetInNs(nspid int, ip net.IP, network *net.IPNet, gw *net.IP) error {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(nspid); err != nil {
return fmt.Errorf("Setting network namespace failed: %s", err)
}
if err := netlink.NetworkLinkAddIp(veth.peerIfc, ip, network); err != nil {
return fmt.Errorf("Unable to set IP: %s in pid: %d network namespace", ip.String(), nspid)
}
if err := netlink.NetworkLinkUp(veth.peerIfc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", veth.peerIfc.Name, nspid)
}
if gw != nil {
if err := netlink.AddDefaultGw(gw.String(), veth.peerIfc.Name); err != nil {
return fmt.Errorf("Unable to set Default gateway: %s in pid: %d network namespace", gw.String(), nspid)
}
}
return nil
} | go | func (veth *VethPair) SetPeerLinkNetInNs(nspid int, ip net.IP, network *net.IPNet, gw *net.IP) error {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(nspid); err != nil {
return fmt.Errorf("Setting network namespace failed: %s", err)
}
if err := netlink.NetworkLinkAddIp(veth.peerIfc, ip, network); err != nil {
return fmt.Errorf("Unable to set IP: %s in pid: %d network namespace", ip.String(), nspid)
}
if err := netlink.NetworkLinkUp(veth.peerIfc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", veth.peerIfc.Name, nspid)
}
if gw != nil {
if err := netlink.AddDefaultGw(gw.String(), veth.peerIfc.Name); err != nil {
return fmt.Errorf("Unable to set Default gateway: %s in pid: %d network namespace", gw.String(), nspid)
}
}
return nil
} | [
"func",
"(",
"veth",
"*",
"VethPair",
")",
"SetPeerLinkNetInNs",
"(",
"nspid",
"int",
",",
"ip",
"net",
".",
"IP",
",",
"network",
"*",
"net",
".",
"IPNet",
",",
"gw",
"*",
"net",
".",
"IP",
")",
"error",
"{",
"origNs",
",",
"_",
":=",
"NetNsHandle... | // SetPeerLinkNetInNs configures peer link's IP network in network namespace specified by PID | [
"SetPeerLinkNetInNs",
"configures",
"peer",
"link",
"s",
"IP",
"network",
"in",
"network",
"namespace",
"specified",
"by",
"PID"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/veth_linux.go#L192-L216 |
14,751 | milosgajdos83/tenus | helpers_linux.go | makeNetInterfaceName | func makeNetInterfaceName(base string) string {
for {
name := base + randomString(6)
if _, err := net.InterfaceByName(name); err == nil {
continue
}
return name
}
} | go | func makeNetInterfaceName(base string) string {
for {
name := base + randomString(6)
if _, err := net.InterfaceByName(name); err == nil {
continue
}
return name
}
} | [
"func",
"makeNetInterfaceName",
"(",
"base",
"string",
")",
"string",
"{",
"for",
"{",
"name",
":=",
"base",
"+",
"randomString",
"(",
"6",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"net",
".",
"InterfaceByName",
"(",
"name",
")",
";",
"err",
"==",
"ni... | // generates new unused network interfaces name with given prefix | [
"generates",
"new",
"unused",
"network",
"interfaces",
"name",
"with",
"given",
"prefix"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/helpers_linux.go#L41-L50 |
14,752 | milosgajdos83/tenus | helpers_linux.go | validMacAddress | func validMacAddress(macaddr string) error {
if _, err := net.ParseMAC(macaddr); err != nil {
return fmt.Errorf("Can not parse MAC address: %s", err)
}
if _, err := FindInterfaceByMacAddress(macaddr); err == nil {
return fmt.Errorf("MAC Address already assigned on the host: %s", macaddr)
}
return nil
} | go | func validMacAddress(macaddr string) error {
if _, err := net.ParseMAC(macaddr); err != nil {
return fmt.Errorf("Can not parse MAC address: %s", err)
}
if _, err := FindInterfaceByMacAddress(macaddr); err == nil {
return fmt.Errorf("MAC Address already assigned on the host: %s", macaddr)
}
return nil
} | [
"func",
"validMacAddress",
"(",
"macaddr",
"string",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"net",
".",
"ParseMAC",
"(",
"macaddr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
... | // validates MacAddress LinkOption | [
"validates",
"MacAddress",
"LinkOption"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/helpers_linux.go#L62-L72 |
14,753 | milosgajdos83/tenus | helpers_linux.go | validFlags | func validFlags(flags net.Flags) error {
if (flags & syscall.IFF_UP) != syscall.IFF_UP {
return fmt.Errorf("Unsupported network flags specified: %v", flags)
}
return nil
} | go | func validFlags(flags net.Flags) error {
if (flags & syscall.IFF_UP) != syscall.IFF_UP {
return fmt.Errorf("Unsupported network flags specified: %v", flags)
}
return nil
} | [
"func",
"validFlags",
"(",
"flags",
"net",
".",
"Flags",
")",
"error",
"{",
"if",
"(",
"flags",
"&",
"syscall",
".",
"IFF_UP",
")",
"!=",
"syscall",
".",
"IFF_UP",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"flags",
")",
"\n",
"}",
... | // validates Flags LinkOption | [
"validates",
"Flags",
"LinkOption"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/helpers_linux.go#L84-L90 |
14,754 | milosgajdos83/tenus | helpers_linux.go | NetInterfaceNameValid | func NetInterfaceNameValid(name string) (bool, error) {
if name == "" {
return false, errors.New("Interface name can not be empty")
}
if len(name) == 1 {
return false, fmt.Errorf("Interface name too short: %s", name)
}
if len(name) > netlink.IFNAMSIZ {
return false, fmt.Errorf("Interface name too long: %s", name)
}
for _, char := range name {
if unicode.IsSpace(char) || char > 0x7F {
return false, fmt.Errorf("Invalid characters in interface name: %s", name)
}
}
return true, nil
} | go | func NetInterfaceNameValid(name string) (bool, error) {
if name == "" {
return false, errors.New("Interface name can not be empty")
}
if len(name) == 1 {
return false, fmt.Errorf("Interface name too short: %s", name)
}
if len(name) > netlink.IFNAMSIZ {
return false, fmt.Errorf("Interface name too long: %s", name)
}
for _, char := range name {
if unicode.IsSpace(char) || char > 0x7F {
return false, fmt.Errorf("Invalid characters in interface name: %s", name)
}
}
return true, nil
} | [
"func",
"NetInterfaceNameValid",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"name",
... | // NetInterfaceNameValid checks if the network interface name is valid.
// It accepts interface name as a string. It returns error if invalid interface name is supplied. | [
"NetInterfaceNameValid",
"checks",
"if",
"the",
"network",
"interface",
"name",
"is",
"valid",
".",
"It",
"accepts",
"interface",
"name",
"as",
"a",
"string",
".",
"It",
"returns",
"error",
"if",
"invalid",
"interface",
"name",
"is",
"supplied",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/helpers_linux.go#L94-L114 |
14,755 | milosgajdos83/tenus | helpers_linux.go | NetNsHandle | func NetNsHandle(nspid int) (uintptr, error) {
if nspid <= 0 || nspid == 1 {
return 0, fmt.Errorf("Incorred PID specified: %d", nspid)
}
nsPath := path.Join("/", "proc", strconv.Itoa(nspid), "ns/net")
if nsPath == "" {
return 0, fmt.Errorf("Could not find Network namespace for pid: %d", nspid)
}
file, err := os.Open(nsPath)
if err != nil {
return 0, fmt.Errorf("Could not open Network Namespace: %s", err)
}
return file.Fd(), nil
} | go | func NetNsHandle(nspid int) (uintptr, error) {
if nspid <= 0 || nspid == 1 {
return 0, fmt.Errorf("Incorred PID specified: %d", nspid)
}
nsPath := path.Join("/", "proc", strconv.Itoa(nspid), "ns/net")
if nsPath == "" {
return 0, fmt.Errorf("Could not find Network namespace for pid: %d", nspid)
}
file, err := os.Open(nsPath)
if err != nil {
return 0, fmt.Errorf("Could not open Network Namespace: %s", err)
}
return file.Fd(), nil
} | [
"func",
"NetNsHandle",
"(",
"nspid",
"int",
")",
"(",
"uintptr",
",",
"error",
")",
"{",
"if",
"nspid",
"<=",
"0",
"||",
"nspid",
"==",
"1",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"nspid",
")",
"\n",
"}",
"\n\n",
"... | // NetNsHandle returns a file descriptor handle for network namespace specified by PID.
// It returns error if network namespace could not be found or if network namespace path could not be opened. | [
"NetNsHandle",
"returns",
"a",
"file",
"descriptor",
"handle",
"for",
"network",
"namespace",
"specified",
"by",
"PID",
".",
"It",
"returns",
"error",
"if",
"network",
"namespace",
"could",
"not",
"be",
"found",
"or",
"if",
"network",
"namespace",
"path",
"cou... | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/helpers_linux.go#L206-L222 |
14,756 | milosgajdos83/tenus | helpers_linux.go | SetNetNsToPid | func SetNetNsToPid(nspid int) error {
if nspid <= 0 || nspid == 1 {
return fmt.Errorf("Incorred PID specified: %d", nspid)
}
nsFd, err := NetNsHandle(nspid)
defer syscall.Close(int(nsFd))
if err != nil {
return fmt.Errorf("Could not get network namespace handle: %s", err)
}
if err := system.Setns(nsFd, syscall.CLONE_NEWNET); err != nil {
return fmt.Errorf("Unable to set the network namespace: %v", err)
}
return nil
} | go | func SetNetNsToPid(nspid int) error {
if nspid <= 0 || nspid == 1 {
return fmt.Errorf("Incorred PID specified: %d", nspid)
}
nsFd, err := NetNsHandle(nspid)
defer syscall.Close(int(nsFd))
if err != nil {
return fmt.Errorf("Could not get network namespace handle: %s", err)
}
if err := system.Setns(nsFd, syscall.CLONE_NEWNET); err != nil {
return fmt.Errorf("Unable to set the network namespace: %v", err)
}
return nil
} | [
"func",
"SetNetNsToPid",
"(",
"nspid",
"int",
")",
"error",
"{",
"if",
"nspid",
"<=",
"0",
"||",
"nspid",
"==",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"nspid",
")",
"\n",
"}",
"\n\n",
"nsFd",
",",
"err",
":=",
"NetNsHandle"... | // SetNetNsToPid sets network namespace to the one specied by PID.
// It returns error if the network namespace could not be set. | [
"SetNetNsToPid",
"sets",
"network",
"namespace",
"to",
"the",
"one",
"specied",
"by",
"PID",
".",
"It",
"returns",
"error",
"if",
"the",
"network",
"namespace",
"could",
"not",
"be",
"set",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/helpers_linux.go#L226-L242 |
14,757 | milosgajdos83/tenus | bridge_linux.go | BridgeFromName | func BridgeFromName(ifcName string) (Bridger, error) {
if ok, err := NetInterfaceNameValid(ifcName); !ok {
return nil, err
}
newIfc, err := net.InterfaceByName(ifcName)
if err != nil {
return nil, fmt.Errorf("Could not find the new interface: %s", err)
}
return &Bridge{
Link: Link{
ifc: newIfc,
},
}, nil
} | go | func BridgeFromName(ifcName string) (Bridger, error) {
if ok, err := NetInterfaceNameValid(ifcName); !ok {
return nil, err
}
newIfc, err := net.InterfaceByName(ifcName)
if err != nil {
return nil, fmt.Errorf("Could not find the new interface: %s", err)
}
return &Bridge{
Link: Link{
ifc: newIfc,
},
}, nil
} | [
"func",
"BridgeFromName",
"(",
"ifcName",
"string",
")",
"(",
"Bridger",
",",
"error",
")",
"{",
"if",
"ok",
",",
"err",
":=",
"NetInterfaceNameValid",
"(",
"ifcName",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"newIfc",
... | // BridgeFromName returns a tenus network bridge from an existing bridge of given name on the Linux host.
// It returns error if the bridge of the given name cannot be found. | [
"BridgeFromName",
"returns",
"a",
"tenus",
"network",
"bridge",
"from",
"an",
"existing",
"bridge",
"of",
"given",
"name",
"on",
"the",
"Linux",
"host",
".",
"It",
"returns",
"error",
"if",
"the",
"bridge",
"of",
"the",
"given",
"name",
"cannot",
"be",
"fo... | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/bridge_linux.go#L92-L107 |
14,758 | milosgajdos83/tenus | link_linux.go | NewLinkFrom | func NewLinkFrom(ifcName string) (Linker, error) {
if ok, err := NetInterfaceNameValid(ifcName); !ok {
return nil, err
}
newIfc, err := net.InterfaceByName(ifcName)
if err != nil {
return nil, fmt.Errorf("Could not find the new interface: %s", err)
}
return &Link{
ifc: newIfc,
}, nil
} | go | func NewLinkFrom(ifcName string) (Linker, error) {
if ok, err := NetInterfaceNameValid(ifcName); !ok {
return nil, err
}
newIfc, err := net.InterfaceByName(ifcName)
if err != nil {
return nil, fmt.Errorf("Could not find the new interface: %s", err)
}
return &Link{
ifc: newIfc,
}, nil
} | [
"func",
"NewLinkFrom",
"(",
"ifcName",
"string",
")",
"(",
"Linker",
",",
"error",
")",
"{",
"if",
"ok",
",",
"err",
":=",
"NetInterfaceNameValid",
"(",
"ifcName",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"newIfc",
",... | // NewLinkFrom creates new tenus link on Linux host from an existing interface of given name | [
"NewLinkFrom",
"creates",
"new",
"tenus",
"link",
"on",
"Linux",
"host",
"from",
"an",
"existing",
"interface",
"of",
"given",
"name"
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L86-L99 |
14,759 | milosgajdos83/tenus | link_linux.go | SetLinkNetNsPid | func (l *Link) SetLinkNetNsPid(nspid int) error {
return netlink.NetworkSetNsPid(l.NetInterface(), nspid)
} | go | func (l *Link) SetLinkNetNsPid(nspid int) error {
return netlink.NetworkSetNsPid(l.NetInterface(), nspid)
} | [
"func",
"(",
"l",
"*",
"Link",
")",
"SetLinkNetNsPid",
"(",
"nspid",
"int",
")",
"error",
"{",
"return",
"netlink",
".",
"NetworkSetNsPid",
"(",
"l",
".",
"NetInterface",
"(",
")",
",",
"nspid",
")",
"\n",
"}"
] | // SetLinkNetNsPid moves the link to Network namespace specified by PID. | [
"SetLinkNetNsPid",
"moves",
"the",
"link",
"to",
"Network",
"namespace",
"specified",
"by",
"PID",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L208-L210 |
14,760 | milosgajdos83/tenus | link_linux.go | SetLinkNetInNs | func (l *Link) SetLinkNetInNs(nspid int, ip net.IP, network *net.IPNet, gw *net.IP) error {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(nspid); err != nil {
return fmt.Errorf("Setting network namespace failed: %s", err)
}
if err := netlink.NetworkLinkAddIp(l.NetInterface(), ip, network); err != nil {
return fmt.Errorf("Unable to set IP: %s in pid: %d network namespace", ip.String(), nspid)
}
if err := netlink.NetworkLinkUp(l.ifc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", l.ifc.Name, nspid)
}
if gw != nil {
if err := netlink.AddDefaultGw(gw.String(), l.NetInterface().Name); err != nil {
return fmt.Errorf("Unable to set Default gateway: %s in pid: %d network namespace", gw.String(), nspid)
}
}
return nil
} | go | func (l *Link) SetLinkNetInNs(nspid int, ip net.IP, network *net.IPNet, gw *net.IP) error {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(nspid); err != nil {
return fmt.Errorf("Setting network namespace failed: %s", err)
}
if err := netlink.NetworkLinkAddIp(l.NetInterface(), ip, network); err != nil {
return fmt.Errorf("Unable to set IP: %s in pid: %d network namespace", ip.String(), nspid)
}
if err := netlink.NetworkLinkUp(l.ifc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", l.ifc.Name, nspid)
}
if gw != nil {
if err := netlink.AddDefaultGw(gw.String(), l.NetInterface().Name); err != nil {
return fmt.Errorf("Unable to set Default gateway: %s in pid: %d network namespace", gw.String(), nspid)
}
}
return nil
} | [
"func",
"(",
"l",
"*",
"Link",
")",
"SetLinkNetInNs",
"(",
"nspid",
"int",
",",
"ip",
"net",
".",
"IP",
",",
"network",
"*",
"net",
".",
"IPNet",
",",
"gw",
"*",
"net",
".",
"IP",
")",
"error",
"{",
"origNs",
",",
"_",
":=",
"NetNsHandle",
"(",
... | // SetLinkNetInNs configures network settings of the link in network namespace specified by PID. | [
"SetLinkNetInNs",
"configures",
"network",
"settings",
"of",
"the",
"link",
"in",
"network",
"namespace",
"specified",
"by",
"PID",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L213-L237 |
14,761 | milosgajdos83/tenus | link_linux.go | SetLinkNsFd | func (l *Link) SetLinkNsFd(nspath string) error {
fd, err := syscall.Open(nspath, syscall.O_RDONLY, 0)
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(l.NetInterface(), fd)
} | go | func (l *Link) SetLinkNsFd(nspath string) error {
fd, err := syscall.Open(nspath, syscall.O_RDONLY, 0)
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(l.NetInterface(), fd)
} | [
"func",
"(",
"l",
"*",
"Link",
")",
"SetLinkNsFd",
"(",
"nspath",
"string",
")",
"error",
"{",
"fd",
",",
"err",
":=",
"syscall",
".",
"Open",
"(",
"nspath",
",",
"syscall",
".",
"O_RDONLY",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"re... | // SetLinkNsFd sets the link's Linux namespace to the one specified by filesystem path. | [
"SetLinkNsFd",
"sets",
"the",
"link",
"s",
"Linux",
"namespace",
"to",
"the",
"one",
"specified",
"by",
"filesystem",
"path",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L240-L247 |
14,762 | milosgajdos83/tenus | link_linux.go | SetLinkNsToDocker | func (l *Link) SetLinkNsToDocker(name string, dockerHost string) error {
pid, err := DockerPidByName(name, dockerHost)
if err != nil {
return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return l.SetLinkNetNsPid(pid)
} | go | func (l *Link) SetLinkNsToDocker(name string, dockerHost string) error {
pid, err := DockerPidByName(name, dockerHost)
if err != nil {
return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return l.SetLinkNetNsPid(pid)
} | [
"func",
"(",
"l",
"*",
"Link",
")",
"SetLinkNsToDocker",
"(",
"name",
"string",
",",
"dockerHost",
"string",
")",
"error",
"{",
"pid",
",",
"err",
":=",
"DockerPidByName",
"(",
"name",
",",
"dockerHost",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"retur... | // SetLinkNsToDocker sets the link's Linux namespace to a running Docker one specified by Docker name. | [
"SetLinkNsToDocker",
"sets",
"the",
"link",
"s",
"Linux",
"namespace",
"to",
"a",
"running",
"Docker",
"one",
"specified",
"by",
"Docker",
"name",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L250-L257 |
14,763 | milosgajdos83/tenus | link_linux.go | RenameInterfaceByName | func RenameInterfaceByName(old string, newName string) error {
iface, err := net.InterfaceByName(old)
if err != nil {
return err
}
return netlink.NetworkChangeName(iface, newName)
} | go | func RenameInterfaceByName(old string, newName string) error {
iface, err := net.InterfaceByName(old)
if err != nil {
return err
}
return netlink.NetworkChangeName(iface, newName)
} | [
"func",
"RenameInterfaceByName",
"(",
"old",
"string",
",",
"newName",
"string",
")",
"error",
"{",
"iface",
",",
"err",
":=",
"net",
".",
"InterfaceByName",
"(",
"old",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"retur... | // RenameInterfaceByName renames an interface of given name. | [
"RenameInterfaceByName",
"renames",
"an",
"interface",
"of",
"given",
"name",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L260-L266 |
14,764 | milosgajdos83/tenus | link_linux.go | setLinkOptions | func setLinkOptions(ifc *net.Interface, opts LinkOptions) error {
macaddr, mtu, flags, ns := opts.MacAddr, opts.MTU, opts.Flags, opts.Ns
// if MTU is passed in LinkOptions
if mtu != 0 {
if err := validMtu(mtu); err != nil {
return err
}
if err := netlink.NetworkSetMTU(ifc, mtu); err != nil {
return fmt.Errorf("Unable to set MTU: %s", err)
}
}
// if MacAddress is passed in LinkOptions
if macaddr != "" {
if err := validMacAddress(macaddr); err != nil {
return err
}
if err := netlink.NetworkSetMacAddress(ifc, macaddr); err != nil {
return fmt.Errorf("Unable to set MAC Address: %s", err)
}
}
// if ns is passed in LinkOptions
if ns != 0 {
if err := validNs(ns); err != nil {
return err
}
if err := netlink.NetworkSetNsPid(ifc, ns); err != nil {
return fmt.Errorf("Unable to set Network namespace: %s", err)
}
}
// if flags is passed in LinkOptions
if flags != 0 {
if err := validFlags(flags); err != nil {
return err
}
if ns != 0 && (ns != 1 || ns != os.Getpid()) {
if (flags & syscall.IFF_UP) == syscall.IFF_UP {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(ns); err != nil {
return fmt.Errorf("Switching to %d network namespace failed: %s", ns, err)
}
if err := netlink.NetworkLinkUp(ifc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", ifc.Name, ns)
}
}
} else {
if err := netlink.NetworkLinkUp(ifc); err != nil {
return fmt.Errorf("Could not bring up network link %s: %s", ifc.Name, err)
}
}
}
return nil
} | go | func setLinkOptions(ifc *net.Interface, opts LinkOptions) error {
macaddr, mtu, flags, ns := opts.MacAddr, opts.MTU, opts.Flags, opts.Ns
// if MTU is passed in LinkOptions
if mtu != 0 {
if err := validMtu(mtu); err != nil {
return err
}
if err := netlink.NetworkSetMTU(ifc, mtu); err != nil {
return fmt.Errorf("Unable to set MTU: %s", err)
}
}
// if MacAddress is passed in LinkOptions
if macaddr != "" {
if err := validMacAddress(macaddr); err != nil {
return err
}
if err := netlink.NetworkSetMacAddress(ifc, macaddr); err != nil {
return fmt.Errorf("Unable to set MAC Address: %s", err)
}
}
// if ns is passed in LinkOptions
if ns != 0 {
if err := validNs(ns); err != nil {
return err
}
if err := netlink.NetworkSetNsPid(ifc, ns); err != nil {
return fmt.Errorf("Unable to set Network namespace: %s", err)
}
}
// if flags is passed in LinkOptions
if flags != 0 {
if err := validFlags(flags); err != nil {
return err
}
if ns != 0 && (ns != 1 || ns != os.Getpid()) {
if (flags & syscall.IFF_UP) == syscall.IFF_UP {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(ns); err != nil {
return fmt.Errorf("Switching to %d network namespace failed: %s", ns, err)
}
if err := netlink.NetworkLinkUp(ifc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", ifc.Name, ns)
}
}
} else {
if err := netlink.NetworkLinkUp(ifc); err != nil {
return fmt.Errorf("Could not bring up network link %s: %s", ifc.Name, err)
}
}
}
return nil
} | [
"func",
"setLinkOptions",
"(",
"ifc",
"*",
"net",
".",
"Interface",
",",
"opts",
"LinkOptions",
")",
"error",
"{",
"macaddr",
",",
"mtu",
",",
"flags",
",",
"ns",
":=",
"opts",
".",
"MacAddr",
",",
"opts",
".",
"MTU",
",",
"opts",
".",
"Flags",
",",
... | // setLinkOptions validates and sets link's various options passed in as LinkOptions. | [
"setLinkOptions",
"validates",
"and",
"sets",
"link",
"s",
"various",
"options",
"passed",
"in",
"as",
"LinkOptions",
"."
] | 1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b | https://github.com/milosgajdos83/tenus/blob/1f3ed00ae7d84ecdd97a628d26551590f5a3ab4b/link_linux.go#L269-L333 |
14,765 | go-gremlin/gremlin | connection.go | ExecQuery | func (c *Client) ExecQuery(query string) ([]byte, error) {
req := Query(query)
return c.Exec(req)
} | go | func (c *Client) ExecQuery(query string) ([]byte, error) {
req := Query(query)
return c.Exec(req)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ExecQuery",
"(",
"query",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"req",
":=",
"Query",
"(",
"query",
")",
"\n",
"return",
"c",
".",
"Exec",
"(",
"req",
")",
"\n",
"}"
] | // Client executes the provided request | [
"Client",
"executes",
"the",
"provided",
"request"
] | 0036b9fca17fe60367221cd043525a688ae8b3ea | https://github.com/go-gremlin/gremlin/blob/0036b9fca17fe60367221cd043525a688ae8b3ea/connection.go#L38-L41 |
14,766 | go-gremlin/gremlin | connection.go | NewAuthInfo | func NewAuthInfo(options ...OptAuth) (*AuthInfo, error) {
auth := &AuthInfo{}
for _, op := range options {
err := op(auth)
if err != nil {
return nil, err
}
}
return auth, nil
} | go | func NewAuthInfo(options ...OptAuth) (*AuthInfo, error) {
auth := &AuthInfo{}
for _, op := range options {
err := op(auth)
if err != nil {
return nil, err
}
}
return auth, nil
} | [
"func",
"NewAuthInfo",
"(",
"options",
"...",
"OptAuth",
")",
"(",
"*",
"AuthInfo",
",",
"error",
")",
"{",
"auth",
":=",
"&",
"AuthInfo",
"{",
"}",
"\n",
"for",
"_",
",",
"op",
":=",
"range",
"options",
"{",
"err",
":=",
"op",
"(",
"auth",
")",
... | // Constructor for different authentication possibilities | [
"Constructor",
"for",
"different",
"authentication",
"possibilities"
] | 0036b9fca17fe60367221cd043525a688ae8b3ea | https://github.com/go-gremlin/gremlin/blob/0036b9fca17fe60367221cd043525a688ae8b3ea/connection.go#L121-L130 |
14,767 | go-gremlin/gremlin | connection.go | OptAuthEnv | func OptAuthEnv() OptAuth {
return func(auth *AuthInfo) error {
user, ok := os.LookupEnv("GREMLIN_USER")
if !ok {
return errors.New("Variable GREMLIN_USER is not set")
}
pass, ok := os.LookupEnv("GREMLIN_PASS")
if !ok {
return errors.New("Variable GREMLIN_PASS is not set")
}
auth.User = user
auth.Pass = pass
return nil
}
} | go | func OptAuthEnv() OptAuth {
return func(auth *AuthInfo) error {
user, ok := os.LookupEnv("GREMLIN_USER")
if !ok {
return errors.New("Variable GREMLIN_USER is not set")
}
pass, ok := os.LookupEnv("GREMLIN_PASS")
if !ok {
return errors.New("Variable GREMLIN_PASS is not set")
}
auth.User = user
auth.Pass = pass
return nil
}
} | [
"func",
"OptAuthEnv",
"(",
")",
"OptAuth",
"{",
"return",
"func",
"(",
"auth",
"*",
"AuthInfo",
")",
"error",
"{",
"user",
",",
"ok",
":=",
"os",
".",
"LookupEnv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
... | // Sets authentication info from environment variables GREMLIN_USER and GREMLIN_PASS | [
"Sets",
"authentication",
"info",
"from",
"environment",
"variables",
"GREMLIN_USER",
"and",
"GREMLIN_PASS"
] | 0036b9fca17fe60367221cd043525a688ae8b3ea | https://github.com/go-gremlin/gremlin/blob/0036b9fca17fe60367221cd043525a688ae8b3ea/connection.go#L133-L147 |
14,768 | go-gremlin/gremlin | connection.go | OptAuthUserPass | func OptAuthUserPass(user, pass string) OptAuth {
return func(auth *AuthInfo) error {
auth.User = user
auth.Pass = pass
return nil
}
} | go | func OptAuthUserPass(user, pass string) OptAuth {
return func(auth *AuthInfo) error {
auth.User = user
auth.Pass = pass
return nil
}
} | [
"func",
"OptAuthUserPass",
"(",
"user",
",",
"pass",
"string",
")",
"OptAuth",
"{",
"return",
"func",
"(",
"auth",
"*",
"AuthInfo",
")",
"error",
"{",
"auth",
".",
"User",
"=",
"user",
"\n",
"auth",
".",
"Pass",
"=",
"pass",
"\n",
"return",
"nil",
"\... | // Sets authentication information from username and password | [
"Sets",
"authentication",
"information",
"from",
"username",
"and",
"password"
] | 0036b9fca17fe60367221cd043525a688ae8b3ea | https://github.com/go-gremlin/gremlin/blob/0036b9fca17fe60367221cd043525a688ae8b3ea/connection.go#L150-L156 |
14,769 | go-gremlin/gremlin | connection.go | Authenticate | func (c *Client) Authenticate(requestId string) ([]byte, error) {
auth, err := NewAuthInfo(c.Auth...)
if err != nil {
return nil, err
}
var sasl []byte
sasl = append(sasl, 0)
sasl = append(sasl, []byte(auth.User)...)
sasl = append(sasl, 0)
sasl = append(sasl, []byte(auth.Pass)...)
saslEnc := base64.StdEncoding.EncodeToString(sasl)
args := &RequestArgs{Sasl: saslEnc}
authReq := &Request{
RequestId: requestId,
Processor: "trasversal",
Op: "authentication",
Args: args,
}
return c.Exec(authReq)
} | go | func (c *Client) Authenticate(requestId string) ([]byte, error) {
auth, err := NewAuthInfo(c.Auth...)
if err != nil {
return nil, err
}
var sasl []byte
sasl = append(sasl, 0)
sasl = append(sasl, []byte(auth.User)...)
sasl = append(sasl, 0)
sasl = append(sasl, []byte(auth.Pass)...)
saslEnc := base64.StdEncoding.EncodeToString(sasl)
args := &RequestArgs{Sasl: saslEnc}
authReq := &Request{
RequestId: requestId,
Processor: "trasversal",
Op: "authentication",
Args: args,
}
return c.Exec(authReq)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Authenticate",
"(",
"requestId",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"auth",
",",
"err",
":=",
"NewAuthInfo",
"(",
"c",
".",
"Auth",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",... | // Authenticates the connection | [
"Authenticates",
"the",
"connection"
] | 0036b9fca17fe60367221cd043525a688ae8b3ea | https://github.com/go-gremlin/gremlin/blob/0036b9fca17fe60367221cd043525a688ae8b3ea/connection.go#L159-L178 |
14,770 | go-gremlin/gremlin | response.go | String | func (r Response) String() string {
return fmt.Sprintf("Response \nRequestId: %v, \nStatus: {%#v}, \nResult: {%#v}\n", r.RequestId, r.Status, r.Result)
} | go | func (r Response) String() string {
return fmt.Sprintf("Response \nRequestId: %v, \nStatus: {%#v}, \nResult: {%#v}\n", r.RequestId, r.Status, r.Result)
} | [
"func",
"(",
"r",
"Response",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"r",
".",
"RequestId",
",",
"r",
".",
"Status",
",",
"r",
".",
"Result",
")",
"\n",
"}"
] | // Implementation of the stringer interface. Useful for exploration | [
"Implementation",
"of",
"the",
"stringer",
"interface",
".",
"Useful",
"for",
"exploration"
] | 0036b9fca17fe60367221cd043525a688ae8b3ea | https://github.com/go-gremlin/gremlin/blob/0036b9fca17fe60367221cd043525a688ae8b3ea/response.go#L26-L28 |
14,771 | Coccodrillo/apns | mock_feedback_server.go | StartMockFeedbackServer | func StartMockFeedbackServer(certFile, keyFile string) {
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
log.Panic(err)
}
config := tls.Config{Certificates: []tls.Certificate{cert}, ClientAuth: tls.RequireAnyClientCert}
log.Print("- starting Mock Apple Feedback TCP server at 0.0.0.0:5555")
srv, _ := tls.Listen("tcp", "0.0.0.0:5555", &config)
for {
conn, err := srv.Accept()
if err != nil {
log.Panic(err)
}
go loop(conn)
}
} | go | func StartMockFeedbackServer(certFile, keyFile string) {
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
log.Panic(err)
}
config := tls.Config{Certificates: []tls.Certificate{cert}, ClientAuth: tls.RequireAnyClientCert}
log.Print("- starting Mock Apple Feedback TCP server at 0.0.0.0:5555")
srv, _ := tls.Listen("tcp", "0.0.0.0:5555", &config)
for {
conn, err := srv.Accept()
if err != nil {
log.Panic(err)
}
go loop(conn)
}
} | [
"func",
"StartMockFeedbackServer",
"(",
"certFile",
",",
"keyFile",
"string",
")",
"{",
"cert",
",",
"err",
":=",
"tls",
".",
"LoadX509KeyPair",
"(",
"certFile",
",",
"keyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Panic",
"(",
"err",
... | // StartMockFeedbackServer spins up a simple stand-in for the Apple
// feedback service that can be used for testing purposes. Doesn't
// handle many errors, etc. Just for the sake of having something "live"
// to hit. | [
"StartMockFeedbackServer",
"spins",
"up",
"a",
"simple",
"stand",
"-",
"in",
"for",
"the",
"Apple",
"feedback",
"service",
"that",
"can",
"be",
"used",
"for",
"testing",
"purposes",
".",
"Doesn",
"t",
"handle",
"many",
"errors",
"etc",
".",
"Just",
"for",
... | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/mock_feedback_server.go#L16-L32 |
14,772 | Coccodrillo/apns | push_notification.go | NewPushNotification | func NewPushNotification() (pn *PushNotification) {
pn = new(PushNotification)
pn.payload = make(map[string]interface{})
pn.Identifier = rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(IdentifierUbound)
pn.Priority = 10
return
} | go | func NewPushNotification() (pn *PushNotification) {
pn = new(PushNotification)
pn.payload = make(map[string]interface{})
pn.Identifier = rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(IdentifierUbound)
pn.Priority = 10
return
} | [
"func",
"NewPushNotification",
"(",
")",
"(",
"pn",
"*",
"PushNotification",
")",
"{",
"pn",
"=",
"new",
"(",
"PushNotification",
")",
"\n",
"pn",
".",
"payload",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"pn",
".... | // NewPushNotification creates and returns a PushNotification structure.
// It also initializes the pseudo-random identifier. | [
"NewPushNotification",
"creates",
"and",
"returns",
"a",
"PushNotification",
"structure",
".",
"It",
"also",
"initializes",
"the",
"pseudo",
"-",
"random",
"identifier",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/push_notification.go#L87-L93 |
14,773 | Coccodrillo/apns | push_notification.go | AddPayload | func (pn *PushNotification) AddPayload(p *Payload) {
// This deserves some explanation.
//
// Setting an exported field of type int to 0
// triggers the omitempty behavior if you've set it.
// Since the badge is optional, we should omit it if
// it's not set. However, we want to include it if the
// value is 0, so there's a hack in push_notification.go
// that exploits the fact that Apple treats -1 for a
// badge value as though it were 0 (i.e. it clears the
// badge but doesn't stop the notification from going
// through successfully.)
//
// Still a hack though :)
if p.Badge == 0 {
p.Badge = -1
}
pn.Set("aps", p)
} | go | func (pn *PushNotification) AddPayload(p *Payload) {
// This deserves some explanation.
//
// Setting an exported field of type int to 0
// triggers the omitempty behavior if you've set it.
// Since the badge is optional, we should omit it if
// it's not set. However, we want to include it if the
// value is 0, so there's a hack in push_notification.go
// that exploits the fact that Apple treats -1 for a
// badge value as though it were 0 (i.e. it clears the
// badge but doesn't stop the notification from going
// through successfully.)
//
// Still a hack though :)
if p.Badge == 0 {
p.Badge = -1
}
pn.Set("aps", p)
} | [
"func",
"(",
"pn",
"*",
"PushNotification",
")",
"AddPayload",
"(",
"p",
"*",
"Payload",
")",
"{",
"// This deserves some explanation.",
"//",
"// Setting an exported field of type int to 0",
"// triggers the omitempty behavior if you've set it.",
"// Since the badge is optional, w... | // AddPayload sets the "aps" payload section of the request. It also
// has a hack described within to deal with specific zero values. | [
"AddPayload",
"sets",
"the",
"aps",
"payload",
"section",
"of",
"the",
"request",
".",
"It",
"also",
"has",
"a",
"hack",
"described",
"within",
"to",
"deal",
"with",
"specific",
"zero",
"values",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/push_notification.go#L97-L115 |
14,774 | Coccodrillo/apns | push_notification.go | Set | func (pn *PushNotification) Set(key string, value interface{}) {
pn.payload[key] = value
} | go | func (pn *PushNotification) Set(key string, value interface{}) {
pn.payload[key] = value
} | [
"func",
"(",
"pn",
"*",
"PushNotification",
")",
"Set",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"pn",
".",
"payload",
"[",
"key",
"]",
"=",
"value",
"\n",
"}"
] | // Set defines the value of a payload key. | [
"Set",
"defines",
"the",
"value",
"of",
"a",
"payload",
"key",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/push_notification.go#L123-L125 |
14,775 | Coccodrillo/apns | push_notification.go | PayloadString | func (pn *PushNotification) PayloadString() (string, error) {
j, err := pn.PayloadJSON()
return string(j), err
} | go | func (pn *PushNotification) PayloadString() (string, error) {
j, err := pn.PayloadJSON()
return string(j), err
} | [
"func",
"(",
"pn",
"*",
"PushNotification",
")",
"PayloadString",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"j",
",",
"err",
":=",
"pn",
".",
"PayloadJSON",
"(",
")",
"\n",
"return",
"string",
"(",
"j",
")",
",",
"err",
"\n",
"}"
] | // PayloadString returns the current payload in string format. | [
"PayloadString",
"returns",
"the",
"current",
"payload",
"in",
"string",
"format",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/push_notification.go#L133-L136 |
14,776 | Coccodrillo/apns | push_notification.go | ToBytes | func (pn *PushNotification) ToBytes() ([]byte, error) {
token, err := hex.DecodeString(pn.DeviceToken)
if err != nil {
return nil, err
}
if len(token) != deviceTokenLength {
return nil, errors.New("device token has incorrect length")
}
payload, err := pn.PayloadJSON()
if err != nil {
return nil, err
}
if len(payload) > MaxPayloadSizeBytes {
return nil, errors.New("payload is larger than the " + strconv.Itoa(MaxPayloadSizeBytes) + " byte limit")
}
frameBuffer := new(bytes.Buffer)
binary.Write(frameBuffer, binary.BigEndian, uint8(deviceTokenItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(deviceTokenLength))
binary.Write(frameBuffer, binary.BigEndian, token)
binary.Write(frameBuffer, binary.BigEndian, uint8(payloadItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(len(payload)))
binary.Write(frameBuffer, binary.BigEndian, payload)
binary.Write(frameBuffer, binary.BigEndian, uint8(notificationIdentifierItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(notificationIdentifierLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Identifier)
binary.Write(frameBuffer, binary.BigEndian, uint8(expirationDateItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(expirationDateLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Expiry)
binary.Write(frameBuffer, binary.BigEndian, uint8(priorityItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(priorityLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Priority)
buffer := bytes.NewBuffer([]byte{})
binary.Write(buffer, binary.BigEndian, uint8(pushCommandValue))
binary.Write(buffer, binary.BigEndian, uint32(frameBuffer.Len()))
binary.Write(buffer, binary.BigEndian, frameBuffer.Bytes())
return buffer.Bytes(), nil
} | go | func (pn *PushNotification) ToBytes() ([]byte, error) {
token, err := hex.DecodeString(pn.DeviceToken)
if err != nil {
return nil, err
}
if len(token) != deviceTokenLength {
return nil, errors.New("device token has incorrect length")
}
payload, err := pn.PayloadJSON()
if err != nil {
return nil, err
}
if len(payload) > MaxPayloadSizeBytes {
return nil, errors.New("payload is larger than the " + strconv.Itoa(MaxPayloadSizeBytes) + " byte limit")
}
frameBuffer := new(bytes.Buffer)
binary.Write(frameBuffer, binary.BigEndian, uint8(deviceTokenItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(deviceTokenLength))
binary.Write(frameBuffer, binary.BigEndian, token)
binary.Write(frameBuffer, binary.BigEndian, uint8(payloadItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(len(payload)))
binary.Write(frameBuffer, binary.BigEndian, payload)
binary.Write(frameBuffer, binary.BigEndian, uint8(notificationIdentifierItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(notificationIdentifierLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Identifier)
binary.Write(frameBuffer, binary.BigEndian, uint8(expirationDateItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(expirationDateLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Expiry)
binary.Write(frameBuffer, binary.BigEndian, uint8(priorityItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(priorityLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Priority)
buffer := bytes.NewBuffer([]byte{})
binary.Write(buffer, binary.BigEndian, uint8(pushCommandValue))
binary.Write(buffer, binary.BigEndian, uint32(frameBuffer.Len()))
binary.Write(buffer, binary.BigEndian, frameBuffer.Bytes())
return buffer.Bytes(), nil
} | [
"func",
"(",
"pn",
"*",
"PushNotification",
")",
"ToBytes",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"token",
",",
"err",
":=",
"hex",
".",
"DecodeString",
"(",
"pn",
".",
"DeviceToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"... | // ToBytes returns a byte array of the complete PushNotification
// struct. This array is what should be transmitted to the APN Service. | [
"ToBytes",
"returns",
"a",
"byte",
"array",
"of",
"the",
"complete",
"PushNotification",
"struct",
".",
"This",
"array",
"is",
"what",
"should",
"be",
"transmitted",
"to",
"the",
"APN",
"Service",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/push_notification.go#L140-L178 |
14,777 | Coccodrillo/apns | client.go | BareClient | func BareClient(gateway, certificateBase64, keyBase64 string) (c *Client) {
c = new(Client)
c.Gateway = gateway
c.CertificateBase64 = certificateBase64
c.KeyBase64 = keyBase64
return
} | go | func BareClient(gateway, certificateBase64, keyBase64 string) (c *Client) {
c = new(Client)
c.Gateway = gateway
c.CertificateBase64 = certificateBase64
c.KeyBase64 = keyBase64
return
} | [
"func",
"BareClient",
"(",
"gateway",
",",
"certificateBase64",
",",
"keyBase64",
"string",
")",
"(",
"c",
"*",
"Client",
")",
"{",
"c",
"=",
"new",
"(",
"Client",
")",
"\n",
"c",
".",
"Gateway",
"=",
"gateway",
"\n",
"c",
".",
"CertificateBase64",
"="... | // BareClient can be used to set the contents of your
// certificate and key blocks manually. | [
"BareClient",
"can",
"be",
"used",
"to",
"set",
"the",
"contents",
"of",
"your",
"certificate",
"and",
"key",
"blocks",
"manually",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/client.go#L39-L45 |
14,778 | Coccodrillo/apns | client.go | NewClient | func NewClient(gateway, certificateFile, keyFile string) (c *Client) {
c = new(Client)
c.Gateway = gateway
c.CertificateFile = certificateFile
c.KeyFile = keyFile
return
} | go | func NewClient(gateway, certificateFile, keyFile string) (c *Client) {
c = new(Client)
c.Gateway = gateway
c.CertificateFile = certificateFile
c.KeyFile = keyFile
return
} | [
"func",
"NewClient",
"(",
"gateway",
",",
"certificateFile",
",",
"keyFile",
"string",
")",
"(",
"c",
"*",
"Client",
")",
"{",
"c",
"=",
"new",
"(",
"Client",
")",
"\n",
"c",
".",
"Gateway",
"=",
"gateway",
"\n",
"c",
".",
"CertificateFile",
"=",
"ce... | // NewClient assumes you'll be passing in paths that
// point to your certificate and key. | [
"NewClient",
"assumes",
"you",
"ll",
"be",
"passing",
"in",
"paths",
"that",
"point",
"to",
"your",
"certificate",
"and",
"key",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/client.go#L49-L55 |
14,779 | Coccodrillo/apns | client.go | Send | func (client *Client) Send(pn *PushNotification) (resp *PushNotificationResponse) {
resp = new(PushNotificationResponse)
payload, err := pn.ToBytes()
if err != nil {
resp.Success = false
resp.Error = err
return
}
err = client.ConnectAndWrite(resp, payload)
if err != nil {
resp.Success = false
resp.Error = err
return
}
resp.Success = true
resp.Error = nil
return
} | go | func (client *Client) Send(pn *PushNotification) (resp *PushNotificationResponse) {
resp = new(PushNotificationResponse)
payload, err := pn.ToBytes()
if err != nil {
resp.Success = false
resp.Error = err
return
}
err = client.ConnectAndWrite(resp, payload)
if err != nil {
resp.Success = false
resp.Error = err
return
}
resp.Success = true
resp.Error = nil
return
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"Send",
"(",
"pn",
"*",
"PushNotification",
")",
"(",
"resp",
"*",
"PushNotificationResponse",
")",
"{",
"resp",
"=",
"new",
"(",
"PushNotificationResponse",
")",
"\n\n",
"payload",
",",
"err",
":=",
"pn",
".",
... | // Send connects to the APN service and sends your push notification.
// Remember that if the submission is successful, Apple won't reply. | [
"Send",
"connects",
"to",
"the",
"APN",
"service",
"and",
"sends",
"your",
"push",
"notification",
".",
"Remember",
"that",
"if",
"the",
"submission",
"is",
"successful",
"Apple",
"won",
"t",
"reply",
"."
] | 91763352f7bfc26cca140cda1dad70e0ec9a4236 | https://github.com/Coccodrillo/apns/blob/91763352f7bfc26cca140cda1dad70e0ec9a4236/client.go#L59-L80 |
14,780 | go4org/go4 | types/types.go | ParseTime3339OrZero | func ParseTime3339OrZero(v string) Time3339 {
t, err := time.Parse(time.RFC3339Nano, v)
if err != nil {
return Time3339{}
}
return Time3339(t)
} | go | func ParseTime3339OrZero(v string) Time3339 {
t, err := time.Parse(time.RFC3339Nano, v)
if err != nil {
return Time3339{}
}
return Time3339(t)
} | [
"func",
"ParseTime3339OrZero",
"(",
"v",
"string",
")",
"Time3339",
"{",
"t",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339Nano",
",",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Time3339",
"{",
"}",
"\n",
"}",
"\... | // ParseTime3339OrZero parses a string in RFC3339 format. If it's invalid,
// the zero time value is returned instead. | [
"ParseTime3339OrZero",
"parses",
"a",
"string",
"in",
"RFC3339",
"format",
".",
"If",
"it",
"s",
"invalid",
"the",
"zero",
"time",
"value",
"is",
"returned",
"instead",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/types/types.go#L87-L93 |
14,781 | go4org/go4 | types/types.go | IsAnyZero | func (t *Time3339) IsAnyZero() bool {
return t == nil || time.Time(*t).IsZero() || time.Time(*t).Unix() == 0
} | go | func (t *Time3339) IsAnyZero() bool {
return t == nil || time.Time(*t).IsZero() || time.Time(*t).Unix() == 0
} | [
"func",
"(",
"t",
"*",
"Time3339",
")",
"IsAnyZero",
"(",
")",
"bool",
"{",
"return",
"t",
"==",
"nil",
"||",
"time",
".",
"Time",
"(",
"*",
"t",
")",
".",
"IsZero",
"(",
")",
"||",
"time",
".",
"Time",
"(",
"*",
"t",
")",
".",
"Unix",
"(",
... | // IsAnyZero returns whether the time is Go zero or Unix zero. | [
"IsAnyZero",
"returns",
"whether",
"the",
"time",
"is",
"Go",
"zero",
"or",
"Unix",
"zero",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/types/types.go#L111-L113 |
14,782 | go4org/go4 | jsonconfig/eval.go | ReadFile | func (c *ConfigParser) ReadFile(path string) (Obj, error) {
if path == "" && c.Open == nil {
return nil, errors.New("ReadFile of empty string but Open hook not defined")
}
c.touchedFiles = make(map[string]bool)
var err error
c.rootJSON, err = c.recursiveReadJSON(path)
return c.rootJSON, err
} | go | func (c *ConfigParser) ReadFile(path string) (Obj, error) {
if path == "" && c.Open == nil {
return nil, errors.New("ReadFile of empty string but Open hook not defined")
}
c.touchedFiles = make(map[string]bool)
var err error
c.rootJSON, err = c.recursiveReadJSON(path)
return c.rootJSON, err
} | [
"func",
"(",
"c",
"*",
"ConfigParser",
")",
"ReadFile",
"(",
"path",
"string",
")",
"(",
"Obj",
",",
"error",
")",
"{",
"if",
"path",
"==",
"\"",
"\"",
"&&",
"c",
".",
"Open",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"... | // ReadFile parses the provided path and returns the config file.
// If path is empty, the c.Open function must be defined. | [
"ReadFile",
"parses",
"the",
"provided",
"path",
"and",
"returns",
"the",
"config",
"file",
".",
"If",
"path",
"is",
"empty",
"the",
"c",
".",
"Open",
"function",
"must",
"be",
"defined",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/jsonconfig/eval.go#L88-L96 |
14,783 | go4org/go4 | jsonconfig/eval.go | recursiveReadJSON | func (c *ConfigParser) recursiveReadJSON(configPath string) (decodedObject map[string]interface{}, err error) {
if configPath != "" {
absConfigPath, err := filepath.Abs(configPath)
if err != nil {
return nil, fmt.Errorf("Failed to expand absolute path for %s", configPath)
}
if c.touchedFiles[absConfigPath] {
return nil, fmt.Errorf("ConfigParser include cycle detected reading config: %v",
absConfigPath)
}
c.touchedFiles[absConfigPath] = true
c.includeStack.Push(absConfigPath)
defer c.includeStack.Pop()
}
var f File
if f, err = c.open(configPath); err != nil {
return nil, fmt.Errorf("Failed to open config: %v", err)
}
defer f.Close()
decodedObject = make(map[string]interface{})
dj := json.NewDecoder(f)
if err = dj.Decode(&decodedObject); err != nil {
extra := ""
if serr, ok := err.(*json.SyntaxError); ok {
if _, serr := f.Seek(0, os.SEEK_SET); serr != nil {
log.Fatalf("seek error: %v", serr)
}
line, col, highlight := errorutil.HighlightBytePosition(f, serr.Offset)
extra = fmt.Sprintf(":\nError at line %d, column %d (file offset %d):\n%s",
line, col, serr.Offset, highlight)
}
return nil, fmt.Errorf("error parsing JSON object in config file %s%s\n%v",
f.Name(), extra, err)
}
if err = c.evaluateExpressions(decodedObject, nil, false); err != nil {
return nil, fmt.Errorf("error expanding JSON config expressions in %s:\n%v",
f.Name(), err)
}
return decodedObject, nil
} | go | func (c *ConfigParser) recursiveReadJSON(configPath string) (decodedObject map[string]interface{}, err error) {
if configPath != "" {
absConfigPath, err := filepath.Abs(configPath)
if err != nil {
return nil, fmt.Errorf("Failed to expand absolute path for %s", configPath)
}
if c.touchedFiles[absConfigPath] {
return nil, fmt.Errorf("ConfigParser include cycle detected reading config: %v",
absConfigPath)
}
c.touchedFiles[absConfigPath] = true
c.includeStack.Push(absConfigPath)
defer c.includeStack.Pop()
}
var f File
if f, err = c.open(configPath); err != nil {
return nil, fmt.Errorf("Failed to open config: %v", err)
}
defer f.Close()
decodedObject = make(map[string]interface{})
dj := json.NewDecoder(f)
if err = dj.Decode(&decodedObject); err != nil {
extra := ""
if serr, ok := err.(*json.SyntaxError); ok {
if _, serr := f.Seek(0, os.SEEK_SET); serr != nil {
log.Fatalf("seek error: %v", serr)
}
line, col, highlight := errorutil.HighlightBytePosition(f, serr.Offset)
extra = fmt.Sprintf(":\nError at line %d, column %d (file offset %d):\n%s",
line, col, serr.Offset, highlight)
}
return nil, fmt.Errorf("error parsing JSON object in config file %s%s\n%v",
f.Name(), extra, err)
}
if err = c.evaluateExpressions(decodedObject, nil, false); err != nil {
return nil, fmt.Errorf("error expanding JSON config expressions in %s:\n%v",
f.Name(), err)
}
return decodedObject, nil
} | [
"func",
"(",
"c",
"*",
"ConfigParser",
")",
"recursiveReadJSON",
"(",
"configPath",
"string",
")",
"(",
"decodedObject",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"if",
"configPath",
"!=",
"\"",
"\"",
"{",
"absConfi... | // Decodes and evaluates a json config file, watching for include cycles. | [
"Decodes",
"and",
"evaluates",
"a",
"json",
"config",
"file",
"watching",
"for",
"include",
"cycles",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/jsonconfig/eval.go#L99-L143 |
14,784 | go4org/go4 | jsonconfig/eval.go | CheckTypes | func (c *ConfigParser) CheckTypes(m map[string]interface{}) error {
return c.evaluateExpressions(m, nil, true)
} | go | func (c *ConfigParser) CheckTypes(m map[string]interface{}) error {
return c.evaluateExpressions(m, nil, true)
} | [
"func",
"(",
"c",
"*",
"ConfigParser",
")",
"CheckTypes",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"c",
".",
"evaluateExpressions",
"(",
"m",
",",
"nil",
",",
"true",
")",
"\n",
"}"
] | // CheckTypes parses m and returns an error if it encounters a type or value
// that is not supported by this package. | [
"CheckTypes",
"parses",
"m",
"and",
"returns",
"an",
"error",
"if",
"it",
"encounters",
"a",
"type",
"or",
"value",
"that",
"is",
"not",
"supported",
"by",
"this",
"package",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/jsonconfig/eval.go#L199-L201 |
14,785 | go4org/go4 | jsonconfig/eval.go | evaluateExpressions | func (c *ConfigParser) evaluateExpressions(m map[string]interface{}, seenKeys []string, testOnly bool) error {
for k, ei := range m {
thisPath := append(seenKeys, k)
switch subval := ei.(type) {
case string, bool, float64, nil:
continue
case []interface{}:
if len(subval) == 0 {
continue
}
evaled, err := c.evalValue(subval)
if err != nil {
return fmt.Errorf("%s: value error %v", strings.Join(thisPath, "."), err)
}
if !testOnly {
m[k] = evaled
}
case map[string]interface{}:
if err := c.evaluateExpressions(subval, thisPath, testOnly); err != nil {
return err
}
default:
return fmt.Errorf("%s: unhandled type %T", strings.Join(thisPath, "."), ei)
}
}
return nil
} | go | func (c *ConfigParser) evaluateExpressions(m map[string]interface{}, seenKeys []string, testOnly bool) error {
for k, ei := range m {
thisPath := append(seenKeys, k)
switch subval := ei.(type) {
case string, bool, float64, nil:
continue
case []interface{}:
if len(subval) == 0 {
continue
}
evaled, err := c.evalValue(subval)
if err != nil {
return fmt.Errorf("%s: value error %v", strings.Join(thisPath, "."), err)
}
if !testOnly {
m[k] = evaled
}
case map[string]interface{}:
if err := c.evaluateExpressions(subval, thisPath, testOnly); err != nil {
return err
}
default:
return fmt.Errorf("%s: unhandled type %T", strings.Join(thisPath, "."), ei)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"ConfigParser",
")",
"evaluateExpressions",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"seenKeys",
"[",
"]",
"string",
",",
"testOnly",
"bool",
")",
"error",
"{",
"for",
"k",
",",
"ei",
":=",
"range",
"m",... | // evaluateExpressions parses recursively m, populating it with the values
// that are found, unless testOnly is true. | [
"evaluateExpressions",
"parses",
"recursively",
"m",
"populating",
"it",
"with",
"the",
"values",
"that",
"are",
"found",
"unless",
"testOnly",
"is",
"true",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/jsonconfig/eval.go#L205-L231 |
14,786 | go4org/go4 | jsonconfig/eval.go | ConfigFilePath | func (c *ConfigParser) ConfigFilePath(configFile string) (path string, err error) {
// Try to open as absolute / relative to CWD
_, err = os.Stat(configFile)
if err != nil && filepath.IsAbs(configFile) {
return "", err
}
if err == nil {
return configFile, nil
}
for _, d := range c.IncludeDirs {
if _, err := os.Stat(filepath.Join(d, configFile)); err == nil {
return filepath.Join(d, configFile), nil
}
}
return "", os.ErrNotExist
} | go | func (c *ConfigParser) ConfigFilePath(configFile string) (path string, err error) {
// Try to open as absolute / relative to CWD
_, err = os.Stat(configFile)
if err != nil && filepath.IsAbs(configFile) {
return "", err
}
if err == nil {
return configFile, nil
}
for _, d := range c.IncludeDirs {
if _, err := os.Stat(filepath.Join(d, configFile)); err == nil {
return filepath.Join(d, configFile), nil
}
}
return "", os.ErrNotExist
} | [
"func",
"(",
"c",
"*",
"ConfigParser",
")",
"ConfigFilePath",
"(",
"configFile",
"string",
")",
"(",
"path",
"string",
",",
"err",
"error",
")",
"{",
"// Try to open as absolute / relative to CWD",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"configFile",
... | // ConfigFilePath checks if configFile is found and returns a usable path to it.
// It first checks if configFile is an absolute path, or if it's found in the
// current working directory. If not, it then checks if configFile is in one of
// c.IncludeDirs. It returns an error if configFile is absolute and could not be
// statted, or os.ErrNotExist if configFile was not found. | [
"ConfigFilePath",
"checks",
"if",
"configFile",
"is",
"found",
"and",
"returns",
"a",
"usable",
"path",
"to",
"it",
".",
"It",
"first",
"checks",
"if",
"configFile",
"is",
"an",
"absolute",
"path",
"or",
"if",
"it",
"s",
"found",
"in",
"the",
"current",
... | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/jsonconfig/eval.go#L304-L321 |
14,787 | go4org/go4 | oauthutil/oauth.go | cachedToken | func cachedToken(cacheFile string) (*oauth2.Token, error) {
tok := new(oauth2.Token)
tokenData, err := wkfs.ReadFile(cacheFile)
if err != nil {
return nil, err
}
if err = json.Unmarshal(tokenData, tok); err != nil {
return nil, err
}
if !tok.Valid() {
if tok != nil && time.Now().After(tok.Expiry) {
return nil, errExpiredToken
}
return nil, errors.New("invalid token")
}
return tok, nil
} | go | func cachedToken(cacheFile string) (*oauth2.Token, error) {
tok := new(oauth2.Token)
tokenData, err := wkfs.ReadFile(cacheFile)
if err != nil {
return nil, err
}
if err = json.Unmarshal(tokenData, tok); err != nil {
return nil, err
}
if !tok.Valid() {
if tok != nil && time.Now().After(tok.Expiry) {
return nil, errExpiredToken
}
return nil, errors.New("invalid token")
}
return tok, nil
} | [
"func",
"cachedToken",
"(",
"cacheFile",
"string",
")",
"(",
"*",
"oauth2",
".",
"Token",
",",
"error",
")",
"{",
"tok",
":=",
"new",
"(",
"oauth2",
".",
"Token",
")",
"\n",
"tokenData",
",",
"err",
":=",
"wkfs",
".",
"ReadFile",
"(",
"cacheFile",
")... | // cachedToken returns the token saved in cacheFile. It specifically returns
// errTokenExpired if the token is expired. | [
"cachedToken",
"returns",
"the",
"token",
"saved",
"in",
"cacheFile",
".",
"It",
"specifically",
"returns",
"errTokenExpired",
"if",
"the",
"token",
"is",
"expired",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/oauthutil/oauth.go#L59-L75 |
14,788 | go4org/go4 | oauthutil/oauth.go | NewRefreshTokenSource | func NewRefreshTokenSource(config *oauth2.Config, refreshToken string) oauth2.TokenSource {
var noInitialToken *oauth2.Token = nil
return oauth2.ReuseTokenSource(noInitialToken, config.TokenSource(
oauth2.NoContext, // TODO: maybe accept a context later.
&oauth2.Token{RefreshToken: refreshToken},
))
} | go | func NewRefreshTokenSource(config *oauth2.Config, refreshToken string) oauth2.TokenSource {
var noInitialToken *oauth2.Token = nil
return oauth2.ReuseTokenSource(noInitialToken, config.TokenSource(
oauth2.NoContext, // TODO: maybe accept a context later.
&oauth2.Token{RefreshToken: refreshToken},
))
} | [
"func",
"NewRefreshTokenSource",
"(",
"config",
"*",
"oauth2",
".",
"Config",
",",
"refreshToken",
"string",
")",
"oauth2",
".",
"TokenSource",
"{",
"var",
"noInitialToken",
"*",
"oauth2",
".",
"Token",
"=",
"nil",
"\n",
"return",
"oauth2",
".",
"ReuseTokenSou... | // NewRefreshTokenSource returns a token source that obtains its initial token
// based on the provided config and the refresh token. | [
"NewRefreshTokenSource",
"returns",
"a",
"token",
"source",
"that",
"obtains",
"its",
"initial",
"token",
"based",
"on",
"the",
"provided",
"config",
"and",
"the",
"refresh",
"token",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/oauthutil/oauth.go#L115-L121 |
14,789 | go4org/go4 | media/heif/bmff/bmff.go | ReadBox | func (r *Reader) ReadBox() (Box, error) {
if r.noMoreBoxes {
return nil, io.EOF
}
if r.lastBox != nil {
if _, err := io.Copy(ioutil.Discard, r.lastBox.Body()); err != nil {
return nil, err
}
}
var buf [8]byte
_, err := io.ReadFull(r.br, buf[:4])
if err != nil {
return nil, err
}
box := &box{
size: int64(binary.BigEndian.Uint32(buf[:4])),
}
_, err = io.ReadFull(r.br, box.boxType[:]) // 4 more bytes
if err != nil {
return nil, err
}
// Special cases for size:
var remain int64
switch box.size {
case 1:
// 1 means it's actually a 64-bit size, after the type.
_, err = io.ReadFull(r.br, buf[:8])
if err != nil {
return nil, err
}
box.size = int64(binary.BigEndian.Uint64(buf[:8]))
if box.size < 0 {
// Go uses int64 for sizes typically, but BMFF uses uint64.
// We assume for now that nobody actually uses boxes larger
// than int64.
return nil, fmt.Errorf("unexpectedly large box %q", box.boxType)
}
remain = box.size - 2*4 - 8
case 0:
// 0 means unknown & to read to end of file. No more boxes.
r.noMoreBoxes = true
default:
remain = box.size - 2*4
}
if remain < 0 {
return nil, fmt.Errorf("Box header for %q has size %d, suggesting %d (negative) bytes remain", box.boxType, box.size, remain)
}
if box.size > 0 {
box.body = io.LimitReader(r.br, remain)
} else {
box.body = r.br
}
r.lastBox = box
return box, nil
} | go | func (r *Reader) ReadBox() (Box, error) {
if r.noMoreBoxes {
return nil, io.EOF
}
if r.lastBox != nil {
if _, err := io.Copy(ioutil.Discard, r.lastBox.Body()); err != nil {
return nil, err
}
}
var buf [8]byte
_, err := io.ReadFull(r.br, buf[:4])
if err != nil {
return nil, err
}
box := &box{
size: int64(binary.BigEndian.Uint32(buf[:4])),
}
_, err = io.ReadFull(r.br, box.boxType[:]) // 4 more bytes
if err != nil {
return nil, err
}
// Special cases for size:
var remain int64
switch box.size {
case 1:
// 1 means it's actually a 64-bit size, after the type.
_, err = io.ReadFull(r.br, buf[:8])
if err != nil {
return nil, err
}
box.size = int64(binary.BigEndian.Uint64(buf[:8]))
if box.size < 0 {
// Go uses int64 for sizes typically, but BMFF uses uint64.
// We assume for now that nobody actually uses boxes larger
// than int64.
return nil, fmt.Errorf("unexpectedly large box %q", box.boxType)
}
remain = box.size - 2*4 - 8
case 0:
// 0 means unknown & to read to end of file. No more boxes.
r.noMoreBoxes = true
default:
remain = box.size - 2*4
}
if remain < 0 {
return nil, fmt.Errorf("Box header for %q has size %d, suggesting %d (negative) bytes remain", box.boxType, box.size, remain)
}
if box.size > 0 {
box.body = io.LimitReader(r.br, remain)
} else {
box.body = r.br
}
r.lastBox = box
return box, nil
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"ReadBox",
"(",
")",
"(",
"Box",
",",
"error",
")",
"{",
"if",
"r",
".",
"noMoreBoxes",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"if",
"r",
".",
"lastBox",
"!=",
"nil",
"{",
"if",
"_"... | // ReadBox reads the next box.
//
// If the previously read box was not read to completion, ReadBox consumes
// the rest of its data.
//
// At the end, the error is io.EOF. | [
"ReadBox",
"reads",
"the",
"next",
"box",
".",
"If",
"the",
"previously",
"read",
"box",
"was",
"not",
"read",
"to",
"completion",
"ReadBox",
"consumes",
"the",
"rest",
"of",
"its",
"data",
".",
"At",
"the",
"end",
"the",
"error",
"is",
"io",
".",
"EOF... | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/media/heif/bmff/bmff.go#L167-L224 |
14,790 | go4org/go4 | media/heif/bmff/bmff.go | ReadAndParseBox | func (r *Reader) ReadAndParseBox(typ BoxType) (Box, error) {
box, err := r.ReadBox()
if err != nil {
return nil, fmt.Errorf("error reading %q box: %v", typ, err)
}
if box.Type() != typ {
return nil, fmt.Errorf("error reading %q box: got box type %q instead", typ, box.Type())
}
pbox, err := box.Parse()
if err != nil {
return nil, fmt.Errorf("error parsing read %q box: %v", typ, err)
}
return pbox, nil
} | go | func (r *Reader) ReadAndParseBox(typ BoxType) (Box, error) {
box, err := r.ReadBox()
if err != nil {
return nil, fmt.Errorf("error reading %q box: %v", typ, err)
}
if box.Type() != typ {
return nil, fmt.Errorf("error reading %q box: got box type %q instead", typ, box.Type())
}
pbox, err := box.Parse()
if err != nil {
return nil, fmt.Errorf("error parsing read %q box: %v", typ, err)
}
return pbox, nil
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"ReadAndParseBox",
"(",
"typ",
"BoxType",
")",
"(",
"Box",
",",
"error",
")",
"{",
"box",
",",
"err",
":=",
"r",
".",
"ReadBox",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
"... | // ReadAndParseBox wraps the ReadBox method, ensuring that the read box is of type typ
// and parses successfully. It returns the parsed box. | [
"ReadAndParseBox",
"wraps",
"the",
"ReadBox",
"method",
"ensuring",
"that",
"the",
"read",
"box",
"is",
"of",
"type",
"typ",
"and",
"parses",
"successfully",
".",
"It",
"returns",
"the",
"parsed",
"box",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/media/heif/bmff/bmff.go#L228-L241 |
14,791 | go4org/go4 | net/throttle/throttle.go | byteTime | func (r Rate) byteTime(n int) time.Duration {
if r.KBps == 0 {
return 0
}
return time.Duration(float64(n)/1024/float64(r.KBps)) * time.Second
} | go | func (r Rate) byteTime(n int) time.Duration {
if r.KBps == 0 {
return 0
}
return time.Duration(float64(n)/1024/float64(r.KBps)) * time.Second
} | [
"func",
"(",
"r",
"Rate",
")",
"byteTime",
"(",
"n",
"int",
")",
"time",
".",
"Duration",
"{",
"if",
"r",
".",
"KBps",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"time",
".",
"Duration",
"(",
"float64",
"(",
"n",
")",
"/",
"1024"... | // byteTime returns the time required for n bytes. | [
"byteTime",
"returns",
"the",
"time",
"required",
"for",
"n",
"bytes",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/net/throttle/throttle.go#L37-L42 |
14,792 | go4org/go4 | lock/lock.go | lockPortable | func lockPortable(name string) (io.Closer, error) {
fi, err := os.Stat(name)
if err == nil && fi.Size() > 0 {
st := portableLockStatus(name)
switch st {
case statusLocked:
return nil, fmt.Errorf("file %q already locked", name)
case statusStale:
os.Remove(name)
case statusInvalid:
return nil, fmt.Errorf("can't Lock file %q: has invalid contents", name)
}
}
f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_EXCL, 0666)
if err != nil {
return nil, fmt.Errorf("failed to create lock file %s %v", name, err)
}
if err := json.NewEncoder(f).Encode(&pidLockMeta{OwnerPID: os.Getpid()}); err != nil {
return nil, fmt.Errorf("cannot write owner pid: %v", err)
}
return &unlocker{
f: f,
abs: name,
portable: true,
}, nil
} | go | func lockPortable(name string) (io.Closer, error) {
fi, err := os.Stat(name)
if err == nil && fi.Size() > 0 {
st := portableLockStatus(name)
switch st {
case statusLocked:
return nil, fmt.Errorf("file %q already locked", name)
case statusStale:
os.Remove(name)
case statusInvalid:
return nil, fmt.Errorf("can't Lock file %q: has invalid contents", name)
}
}
f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_EXCL, 0666)
if err != nil {
return nil, fmt.Errorf("failed to create lock file %s %v", name, err)
}
if err := json.NewEncoder(f).Encode(&pidLockMeta{OwnerPID: os.Getpid()}); err != nil {
return nil, fmt.Errorf("cannot write owner pid: %v", err)
}
return &unlocker{
f: f,
abs: name,
portable: true,
}, nil
} | [
"func",
"lockPortable",
"(",
"name",
"string",
")",
"(",
"io",
".",
"Closer",
",",
"error",
")",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"name",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"fi",
".",
"Size",
"(",
")",
">",
"0",
"{... | // lockPortable is a portable version not using fcntl. Doesn't handle crashes as gracefully,
// since it can leave stale lock files. | [
"lockPortable",
"is",
"a",
"portable",
"version",
"not",
"using",
"fcntl",
".",
"Doesn",
"t",
"handle",
"crashes",
"as",
"gracefully",
"since",
"it",
"can",
"leave",
"stale",
"lock",
"files",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/lock/lock.go#L70-L95 |
14,793 | go4org/go4 | cloud/google/gcsutil/storage.go | simpleRequest | func simpleRequest(method, url_ string) (*http.Request, error) {
req, err := http.NewRequest(method, url_, nil)
if err != nil {
return nil, err
}
req.Header.Set("x-goog-api-version", "2")
return req, err
} | go | func simpleRequest(method, url_ string) (*http.Request, error) {
req, err := http.NewRequest(method, url_, nil)
if err != nil {
return nil, err
}
req.Header.Set("x-goog-api-version", "2")
return req, err
} | [
"func",
"simpleRequest",
"(",
"method",
",",
"url_",
"string",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"method",
",",
"url_",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
... | // Makes a simple body-less google storage request | [
"Makes",
"a",
"simple",
"body",
"-",
"less",
"google",
"storage",
"request"
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/cloud/google/gcsutil/storage.go#L76-L83 |
14,794 | go4org/go4 | cloud/google/gcsutil/storage.go | GetPartialObject | func GetPartialObject(ctx context.Context, obj Object, offset, length int64) (io.ReadCloser, error) {
if offset < 0 {
return nil, errors.New("invalid negative offset")
}
if err := obj.valid(); err != nil {
return nil, err
}
req, err := simpleRequest("GET", gsAccessURL+"/"+obj.Bucket+"/"+obj.Key)
if err != nil {
return nil, err
}
if length >= 0 {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+length-1))
} else {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-", offset))
}
req.Cancel = ctx.Done()
res, err := ctxutil.Client(ctx).Do(req)
if err != nil {
return nil, fmt.Errorf("GET (offset=%d, length=%d) failed: %v\n", offset, length, err)
}
if res.StatusCode == http.StatusNotFound {
res.Body.Close()
return nil, os.ErrNotExist
}
if !(res.StatusCode == http.StatusPartialContent || (offset == 0 && res.StatusCode == http.StatusOK)) {
res.Body.Close()
if res.StatusCode == http.StatusRequestedRangeNotSatisfiable {
return nil, ErrInvalidRange
}
return nil, fmt.Errorf("GET (offset=%d, length=%d) got failed status: %v\n", offset, length, res.Status)
}
return res.Body, nil
} | go | func GetPartialObject(ctx context.Context, obj Object, offset, length int64) (io.ReadCloser, error) {
if offset < 0 {
return nil, errors.New("invalid negative offset")
}
if err := obj.valid(); err != nil {
return nil, err
}
req, err := simpleRequest("GET", gsAccessURL+"/"+obj.Bucket+"/"+obj.Key)
if err != nil {
return nil, err
}
if length >= 0 {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+length-1))
} else {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-", offset))
}
req.Cancel = ctx.Done()
res, err := ctxutil.Client(ctx).Do(req)
if err != nil {
return nil, fmt.Errorf("GET (offset=%d, length=%d) failed: %v\n", offset, length, err)
}
if res.StatusCode == http.StatusNotFound {
res.Body.Close()
return nil, os.ErrNotExist
}
if !(res.StatusCode == http.StatusPartialContent || (offset == 0 && res.StatusCode == http.StatusOK)) {
res.Body.Close()
if res.StatusCode == http.StatusRequestedRangeNotSatisfiable {
return nil, ErrInvalidRange
}
return nil, fmt.Errorf("GET (offset=%d, length=%d) got failed status: %v\n", offset, length, res.Status)
}
return res.Body, nil
} | [
"func",
"GetPartialObject",
"(",
"ctx",
"context",
".",
"Context",
",",
"obj",
"Object",
",",
"offset",
",",
"length",
"int64",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"if",
"offset",
"<",
"0",
"{",
"return",
"nil",
",",
"errors",
... | // GetPartialObject fetches part of a Google Cloud Storage object.
// This function relies on the ctx ctxutil.HTTPClient value being set to an OAuth2
// authorized and authenticated HTTP client.
// If length is negative, the rest of the object is returned.
// It returns ErrInvalidRange if the server replies with http.StatusRequestedRangeNotSatisfiable.
// The caller must call Close on the returned value. | [
"GetPartialObject",
"fetches",
"part",
"of",
"a",
"Google",
"Cloud",
"Storage",
"object",
".",
"This",
"function",
"relies",
"on",
"the",
"ctx",
"ctxutil",
".",
"HTTPClient",
"value",
"being",
"set",
"to",
"an",
"OAuth2",
"authorized",
"and",
"authenticated",
... | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/cloud/google/gcsutil/storage.go#L94-L129 |
14,795 | go4org/go4 | cloud/google/gcsutil/storage.go | EnumerateObjects | func EnumerateObjects(ctx context.Context, bucket, after string, limit int) ([]*storage.ObjectAttrs, error) {
// Build url, with query params
var params []string
if after != "" {
params = append(params, "marker="+url.QueryEscape(after))
}
if limit > 0 {
params = append(params, fmt.Sprintf("max-keys=%v", limit))
}
query := ""
if len(params) > 0 {
query = "?" + strings.Join(params, "&")
}
req, err := simpleRequest("GET", gsAccessURL+"/"+bucket+"/"+query)
if err != nil {
return nil, err
}
req.Cancel = ctx.Done()
res, err := ctxutil.Client(ctx).Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("gcsutil: bad enumerate response code: %v", res.Status)
}
var xres struct {
Contents []SizedObject
}
if err = xml.NewDecoder(res.Body).Decode(&xres); err != nil {
return nil, err
}
objAttrs := make([]*storage.ObjectAttrs, len(xres.Contents))
for k, o := range xres.Contents {
objAttrs[k] = &storage.ObjectAttrs{
Name: o.Key,
Size: o.Size,
}
}
return objAttrs, nil
} | go | func EnumerateObjects(ctx context.Context, bucket, after string, limit int) ([]*storage.ObjectAttrs, error) {
// Build url, with query params
var params []string
if after != "" {
params = append(params, "marker="+url.QueryEscape(after))
}
if limit > 0 {
params = append(params, fmt.Sprintf("max-keys=%v", limit))
}
query := ""
if len(params) > 0 {
query = "?" + strings.Join(params, "&")
}
req, err := simpleRequest("GET", gsAccessURL+"/"+bucket+"/"+query)
if err != nil {
return nil, err
}
req.Cancel = ctx.Done()
res, err := ctxutil.Client(ctx).Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("gcsutil: bad enumerate response code: %v", res.Status)
}
var xres struct {
Contents []SizedObject
}
if err = xml.NewDecoder(res.Body).Decode(&xres); err != nil {
return nil, err
}
objAttrs := make([]*storage.ObjectAttrs, len(xres.Contents))
for k, o := range xres.Contents {
objAttrs[k] = &storage.ObjectAttrs{
Name: o.Key,
Size: o.Size,
}
}
return objAttrs, nil
} | [
"func",
"EnumerateObjects",
"(",
"ctx",
"context",
".",
"Context",
",",
"bucket",
",",
"after",
"string",
",",
"limit",
"int",
")",
"(",
"[",
"]",
"*",
"storage",
".",
"ObjectAttrs",
",",
"error",
")",
"{",
"// Build url, with query params",
"var",
"params",... | // EnumerateObjects lists the objects in a bucket.
// This function relies on the ctx oauth2.HTTPClient value being set to an OAuth2
// authorized and authenticated HTTP client.
// If after is non-empty, listing will begin with lexically greater object names.
// If limit is non-zero, the length of the list will be limited to that number. | [
"EnumerateObjects",
"lists",
"the",
"objects",
"in",
"a",
"bucket",
".",
"This",
"function",
"relies",
"on",
"the",
"ctx",
"oauth2",
".",
"HTTPClient",
"value",
"being",
"set",
"to",
"an",
"OAuth2",
"authorized",
"and",
"authenticated",
"HTTP",
"client",
".",
... | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/cloud/google/gcsutil/storage.go#L136-L180 |
14,796 | go4org/go4 | cloud/cloudlaunch/cloudlaunch.go | uploadBinary | func (cl *cloudLaunch) uploadBinary() {
ctx := context.Background()
if cl.BinaryBucket == "" {
log.Fatal("cloudlaunch: Config.BinaryBucket is empty")
}
stoClient, err := storage.NewClient(ctx, option.WithHTTPClient(cl.oauthClient))
if err != nil {
log.Fatal(err)
}
w := stoClient.Bucket(cl.BinaryBucket).Object(cl.binaryObject()).NewWriter(ctx)
if err != nil {
log.Fatal(err)
}
w.ACL = []storage.ACLRule{
// If you don't give the owners access, the web UI seems to
// have a bug and doesn't have access to see that it's public, so
// won't render the "Shared Publicly" link. So we do that, even
// though it's dumb and unnecessary otherwise:
{
Entity: storage.ACLEntity("project-owners-" + cl.GCEProjectID),
Role: storage.RoleOwner,
},
// Public, so our systemd unit can get it easily:
{
Entity: storage.AllUsers,
Role: storage.RoleReader,
},
}
w.CacheControl = "no-cache"
selfPath := getSelfPath()
log.Printf("Uploading %q to %v", selfPath, cl.binaryURL())
f, err := os.Open(selfPath)
if err != nil {
log.Fatal(err)
}
defer f.Close()
n, err := io.Copy(w, f)
if err != nil {
log.Fatal(err)
}
if err := w.Close(); err != nil {
log.Fatal(err)
}
log.Printf("Uploaded %d bytes", n)
} | go | func (cl *cloudLaunch) uploadBinary() {
ctx := context.Background()
if cl.BinaryBucket == "" {
log.Fatal("cloudlaunch: Config.BinaryBucket is empty")
}
stoClient, err := storage.NewClient(ctx, option.WithHTTPClient(cl.oauthClient))
if err != nil {
log.Fatal(err)
}
w := stoClient.Bucket(cl.BinaryBucket).Object(cl.binaryObject()).NewWriter(ctx)
if err != nil {
log.Fatal(err)
}
w.ACL = []storage.ACLRule{
// If you don't give the owners access, the web UI seems to
// have a bug and doesn't have access to see that it's public, so
// won't render the "Shared Publicly" link. So we do that, even
// though it's dumb and unnecessary otherwise:
{
Entity: storage.ACLEntity("project-owners-" + cl.GCEProjectID),
Role: storage.RoleOwner,
},
// Public, so our systemd unit can get it easily:
{
Entity: storage.AllUsers,
Role: storage.RoleReader,
},
}
w.CacheControl = "no-cache"
selfPath := getSelfPath()
log.Printf("Uploading %q to %v", selfPath, cl.binaryURL())
f, err := os.Open(selfPath)
if err != nil {
log.Fatal(err)
}
defer f.Close()
n, err := io.Copy(w, f)
if err != nil {
log.Fatal(err)
}
if err := w.Close(); err != nil {
log.Fatal(err)
}
log.Printf("Uploaded %d bytes", n)
} | [
"func",
"(",
"cl",
"*",
"cloudLaunch",
")",
"uploadBinary",
"(",
")",
"{",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"if",
"cl",
".",
"BinaryBucket",
"==",
"\"",
"\"",
"{",
"log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\... | // uploadBinary uploads the currently-running Linux binary.
// It crashes if it fails. | [
"uploadBinary",
"uploads",
"the",
"currently",
"-",
"running",
"Linux",
"binary",
".",
"It",
"crashes",
"if",
"it",
"fails",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/cloud/cloudlaunch/cloudlaunch.go#L232-L276 |
14,797 | go4org/go4 | cloud/cloudlaunch/cloudlaunch.go | findIP | func (cl *cloudLaunch) findIP() string {
// Try to find it by name.
aggAddrList, err := cl.computeService.Addresses.AggregatedList(cl.GCEProjectID).Do()
if err != nil {
log.Fatal(err)
}
// https://godoc.org/google.golang.org/api/compute/v1#AddressAggregatedList
var ip string
IPLoop:
for _, asl := range aggAddrList.Items {
for _, addr := range asl.Addresses {
log.Printf(" addr: %#v", addr)
if addr.Name == cl.Name+"-ip" && addr.Status == "RESERVED" && zoneInRegion(cl.zone(), addr.Region) {
ip = addr.Address
break IPLoop
}
}
}
return ip
} | go | func (cl *cloudLaunch) findIP() string {
// Try to find it by name.
aggAddrList, err := cl.computeService.Addresses.AggregatedList(cl.GCEProjectID).Do()
if err != nil {
log.Fatal(err)
}
// https://godoc.org/google.golang.org/api/compute/v1#AddressAggregatedList
var ip string
IPLoop:
for _, asl := range aggAddrList.Items {
for _, addr := range asl.Addresses {
log.Printf(" addr: %#v", addr)
if addr.Name == cl.Name+"-ip" && addr.Status == "RESERVED" && zoneInRegion(cl.zone(), addr.Region) {
ip = addr.Address
break IPLoop
}
}
}
return ip
} | [
"func",
"(",
"cl",
"*",
"cloudLaunch",
")",
"findIP",
"(",
")",
"string",
"{",
"// Try to find it by name.",
"aggAddrList",
",",
"err",
":=",
"cl",
".",
"computeService",
".",
"Addresses",
".",
"AggregatedList",
"(",
"cl",
".",
"GCEProjectID",
")",
".",
"Do"... | // findIP finds an IP address to use, or returns the empty string if none is found.
// It tries to find a reserved one in the same region where the name of the reserved IP
// is "NAME-ip" and the IP is not in use. | [
"findIP",
"finds",
"an",
"IP",
"address",
"to",
"use",
"or",
"returns",
"the",
"empty",
"string",
"if",
"none",
"is",
"found",
".",
"It",
"tries",
"to",
"find",
"a",
"reserved",
"one",
"in",
"the",
"same",
"region",
"where",
"the",
"name",
"of",
"the",... | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/cloud/cloudlaunch/cloudlaunch.go#L308-L327 |
14,798 | go4org/go4 | cloud/cloudlaunch/cloudlaunch.go | lookupInstance | func (cl *cloudLaunch) lookupInstance() *compute.Instance {
inst, err := cl.computeService.Instances.Get(cl.GCEProjectID, cl.zone(), cl.instName()).Do()
if ae, ok := err.(*googleapi.Error); ok && ae.Code == 404 {
return nil
} else if err != nil {
log.Fatalf("Instances.Get: %v", err)
}
return inst
} | go | func (cl *cloudLaunch) lookupInstance() *compute.Instance {
inst, err := cl.computeService.Instances.Get(cl.GCEProjectID, cl.zone(), cl.instName()).Do()
if ae, ok := err.(*googleapi.Error); ok && ae.Code == 404 {
return nil
} else if err != nil {
log.Fatalf("Instances.Get: %v", err)
}
return inst
} | [
"func",
"(",
"cl",
"*",
"cloudLaunch",
")",
"lookupInstance",
"(",
")",
"*",
"compute",
".",
"Instance",
"{",
"inst",
",",
"err",
":=",
"cl",
".",
"computeService",
".",
"Instances",
".",
"Get",
"(",
"cl",
".",
"GCEProjectID",
",",
"cl",
".",
"zone",
... | // returns nil if instance doesn't exist. | [
"returns",
"nil",
"if",
"instance",
"doesn",
"t",
"exist",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/cloud/cloudlaunch/cloudlaunch.go#L426-L434 |
14,799 | go4org/go4 | rollsum/rollsum.go | Roll | func (rs *RollSum) Roll(ch byte) {
wp := &rs.window[rs.wofs]
rs.add(uint32(*wp), uint32(ch))
*wp = ch
rs.wofs = (rs.wofs + 1) & (windowSize - 1)
} | go | func (rs *RollSum) Roll(ch byte) {
wp := &rs.window[rs.wofs]
rs.add(uint32(*wp), uint32(ch))
*wp = ch
rs.wofs = (rs.wofs + 1) & (windowSize - 1)
} | [
"func",
"(",
"rs",
"*",
"RollSum",
")",
"Roll",
"(",
"ch",
"byte",
")",
"{",
"wp",
":=",
"&",
"rs",
".",
"window",
"[",
"rs",
".",
"wofs",
"]",
"\n",
"rs",
".",
"add",
"(",
"uint32",
"(",
"*",
"wp",
")",
",",
"uint32",
"(",
"ch",
")",
")",
... | // Roll adds ch to the rolling sum. | [
"Roll",
"adds",
"ch",
"to",
"the",
"rolling",
"sum",
"."
] | 94abd6928b1da39b1d757b60c93fb2419c409fa1 | https://github.com/go4org/go4/blob/94abd6928b1da39b1d757b60c93fb2419c409fa1/rollsum/rollsum.go#L54-L59 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.