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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
153,900 | uhoh-itsmaciek/femebe | util/util.go | AutoDial | func AutoDial(location string) (net.Conn, error) {
if strings.Contains(location, "/") {
return net.Dial("unix", location)
}
return net.Dial("tcp", location)
} | go | func AutoDial(location string) (net.Conn, error) {
if strings.Contains(location, "/") {
return net.Dial("unix", location)
}
return net.Dial("tcp", location)
} | [
"func",
"AutoDial",
"(",
"location",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"if",
"strings",
".",
"Contains",
"(",
"location",
",",
"\"",
"\"",
")",
"{",
"return",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"location",
")",
... | // Automatically chooses between unix sockets and tcp sockets for
// dialing. | [
"Automatically",
"chooses",
"between",
"unix",
"sockets",
"and",
"tcp",
"sockets",
"for",
"dialing",
"."
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/util/util.go#L32-L37 |
153,901 | c4milo/handlers | session/session_handler.go | WithMaxAge | func WithMaxAge(d time.Duration) option {
return func(h *handler) {
h.maxAge = int(d.Seconds())
// h.expires = time.Now().Add(d)
}
} | go | func WithMaxAge(d time.Duration) option {
return func(h *handler) {
h.maxAge = int(d.Seconds())
// h.expires = time.Now().Add(d)
}
} | [
"func",
"WithMaxAge",
"(",
"d",
"time",
".",
"Duration",
")",
"option",
"{",
"return",
"func",
"(",
"h",
"*",
"handler",
")",
"{",
"h",
".",
"maxAge",
"=",
"int",
"(",
"d",
".",
"Seconds",
"(",
")",
")",
"\n",
"// h.expires = time.Now().Add(d)",
"}",
... | // WithMaxAge allows to set the duration of the session. | [
"WithMaxAge",
"allows",
"to",
"set",
"the",
"duration",
"of",
"the",
"session",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session_handler.go#L53-L58 |
153,902 | c4milo/handlers | session/session_handler.go | Load | func (h *handler) Load(r *http.Request) (*Session, error) {
s := New(h.name, h.keys)
cookie, err := r.Cookie(h.name)
if err != nil {
// No session cookie found, we finish initializing a new one.
s.Cookie.MaxAge = h.maxAge
s.Cookie.Domain = h.domain
s.Cookie.HttpOnly = true
// When external stores are configured, we want to store the session ID in
// the cookie to be able to store and retrieve its data.
if h.store != nil {
s.Value = genID(idSize)
}
} else {
s.Cookie = cookie
}
if r.TLS != nil {
s.Secure = true
}
data := []byte(s.Value)
if h.store != nil {
sessionID := s.Value
data, err = h.store.Load(sessionID)
if err != nil {
return s, errors.Wrapf(err, "failed loading session ID: %s", sessionID)
}
}
if err := s.Decode(data); err != nil {
return s, err
}
return s, nil
} | go | func (h *handler) Load(r *http.Request) (*Session, error) {
s := New(h.name, h.keys)
cookie, err := r.Cookie(h.name)
if err != nil {
// No session cookie found, we finish initializing a new one.
s.Cookie.MaxAge = h.maxAge
s.Cookie.Domain = h.domain
s.Cookie.HttpOnly = true
// When external stores are configured, we want to store the session ID in
// the cookie to be able to store and retrieve its data.
if h.store != nil {
s.Value = genID(idSize)
}
} else {
s.Cookie = cookie
}
if r.TLS != nil {
s.Secure = true
}
data := []byte(s.Value)
if h.store != nil {
sessionID := s.Value
data, err = h.store.Load(sessionID)
if err != nil {
return s, errors.Wrapf(err, "failed loading session ID: %s", sessionID)
}
}
if err := s.Decode(data); err != nil {
return s, err
}
return s, nil
} | [
"func",
"(",
"h",
"*",
"handler",
")",
"Load",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"Session",
",",
"error",
")",
"{",
"s",
":=",
"New",
"(",
"h",
".",
"name",
",",
"h",
".",
"keys",
")",
"\n\n",
"cookie",
",",
"err",
":=",
... | // Load loads the session, either form the built-in cookie store or an external Store | [
"Load",
"loads",
"the",
"session",
"either",
"form",
"the",
"built",
"-",
"in",
"cookie",
"store",
"or",
"an",
"external",
"Store"
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session_handler.go#L61-L98 |
153,903 | c4milo/handlers | session/session_handler.go | Save | func (h *handler) Save(w http.ResponseWriter, s *Session) error {
if !s.isDirty {
return nil
}
defer http.SetCookie(w, s.Cookie)
// If session was destroyed by user, make sure the destroy operation
// from external Store is also invoked.
if s.MaxAge == -1 && h.store != nil {
return h.store.Destroy(s.Value)
}
data, err := s.Encode()
if err != nil {
return err
}
if h.store != nil {
return h.store.Save(s.Value, data)
}
s.Value = string(data[:])
return nil
} | go | func (h *handler) Save(w http.ResponseWriter, s *Session) error {
if !s.isDirty {
return nil
}
defer http.SetCookie(w, s.Cookie)
// If session was destroyed by user, make sure the destroy operation
// from external Store is also invoked.
if s.MaxAge == -1 && h.store != nil {
return h.store.Destroy(s.Value)
}
data, err := s.Encode()
if err != nil {
return err
}
if h.store != nil {
return h.store.Save(s.Value, data)
}
s.Value = string(data[:])
return nil
} | [
"func",
"(",
"h",
"*",
"handler",
")",
"Save",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"s",
"*",
"Session",
")",
"error",
"{",
"if",
"!",
"s",
".",
"isDirty",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"defer",
"http",
".",
"SetCookie",
"(",
... | // Save persist session data either on the built-in cookie store or an external Store.
// When external store is used, the cookie's value contains the session ID. | [
"Save",
"persist",
"session",
"data",
"either",
"on",
"the",
"built",
"-",
"in",
"cookie",
"store",
"or",
"an",
"external",
"Store",
".",
"When",
"external",
"store",
"is",
"used",
"the",
"cookie",
"s",
"value",
"contains",
"the",
"session",
"ID",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session_handler.go#L102-L126 |
153,904 | c4milo/handlers | session/session_handler.go | Handler | func Handler(h http.Handler, opts ...option) http.Handler {
sh := new(handler)
sh.name = "hs"
sh.maxAge = 86400 // 1 day
for _, opt := range opts {
opt(sh)
}
if len(sh.keys) == 0 {
panic("session: at least one secret key is required")
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
session, err := sh.Load(r)
if err != nil {
http.Error(w, fmt.Sprintf("Internal error: %#v", err), http.StatusInternalServerError)
return
}
ctx := newContext(r.Context(), session)
res := internal.NewResponseWriter(w)
res.Before(func(w internal.ResponseWriter) {
sh.Save(w, session)
})
h.ServeHTTP(res, r.WithContext(ctx))
})
} | go | func Handler(h http.Handler, opts ...option) http.Handler {
sh := new(handler)
sh.name = "hs"
sh.maxAge = 86400 // 1 day
for _, opt := range opts {
opt(sh)
}
if len(sh.keys) == 0 {
panic("session: at least one secret key is required")
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
session, err := sh.Load(r)
if err != nil {
http.Error(w, fmt.Sprintf("Internal error: %#v", err), http.StatusInternalServerError)
return
}
ctx := newContext(r.Context(), session)
res := internal.NewResponseWriter(w)
res.Before(func(w internal.ResponseWriter) {
sh.Save(w, session)
})
h.ServeHTTP(res, r.WithContext(ctx))
})
} | [
"func",
"Handler",
"(",
"h",
"http",
".",
"Handler",
",",
"opts",
"...",
"option",
")",
"http",
".",
"Handler",
"{",
"sh",
":=",
"new",
"(",
"handler",
")",
"\n",
"sh",
".",
"name",
"=",
"\"",
"\"",
"\n",
"sh",
".",
"maxAge",
"=",
"86400",
"// 1 ... | // Handler verifies and creates new sessions. If a session is found and valid,
// it is attached to the Request's context for further modification or retrieval by other
// handlers. Sessions are automatically saved before sending the response. | [
"Handler",
"verifies",
"and",
"creates",
"new",
"sessions",
".",
"If",
"a",
"session",
"is",
"found",
"and",
"valid",
"it",
"is",
"attached",
"to",
"the",
"Request",
"s",
"context",
"for",
"further",
"modification",
"or",
"retrieval",
"by",
"other",
"handler... | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session_handler.go#L131-L158 |
153,905 | megamsys/libgo | events/bills/balances.go | NewBalances | func NewBalances(email string, m map[string]string) (*Balances, error) {
// Here skips balances fetching for the VMs which is launched on opennebula,
// that does not have records on vertice database
if email == "" {
return nil, fmt.Errorf("account_id should not be empty")
}
args := api.NewArgs(m)
args.Email = email
cl := api.NewClient(args, BALANCE+email)
response, err := cl.Get()
if err != nil {
return nil, err
}
ac := &ApiBalances{}
err = json.Unmarshal(response, ac)
if err != nil {
return nil, err
}
b := &ac.Results[0]
return b, nil
} | go | func NewBalances(email string, m map[string]string) (*Balances, error) {
// Here skips balances fetching for the VMs which is launched on opennebula,
// that does not have records on vertice database
if email == "" {
return nil, fmt.Errorf("account_id should not be empty")
}
args := api.NewArgs(m)
args.Email = email
cl := api.NewClient(args, BALANCE+email)
response, err := cl.Get()
if err != nil {
return nil, err
}
ac := &ApiBalances{}
err = json.Unmarshal(response, ac)
if err != nil {
return nil, err
}
b := &ac.Results[0]
return b, nil
} | [
"func",
"NewBalances",
"(",
"email",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"Balances",
",",
"error",
")",
"{",
"// Here skips balances fetching for the VMs which is launched on opennebula,",
"// that does not have records on vertice databas... | //Temporary hack to create an assembly from its id.
//This is used by SetStatus.
//We need add a Notifier interface duck typed by Box and Carton ? | [
"Temporary",
"hack",
"to",
"create",
"an",
"assembly",
"from",
"its",
"id",
".",
"This",
"is",
"used",
"by",
"SetStatus",
".",
"We",
"need",
"add",
"a",
"Notifier",
"interface",
"duck",
"typed",
"by",
"Box",
"and",
"Carton",
"?"
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/events/bills/balances.go#L69-L92 |
153,906 | megamsys/libgo | db/scylla.go | newDBConn | func newDBConn(ops Options) (*ScyllaDB, error) {
r, err := newScyllaDB(ScyllaDBOpts{
KeySpaceName: ops.Keyspace,
NodeIps: ops.Hosts,
Username: ops.Username,
Password: ops.Password,
Debug: true,
})
if err != nil {
return nil, err
}
return r, nil
} | go | func newDBConn(ops Options) (*ScyllaDB, error) {
r, err := newScyllaDB(ScyllaDBOpts{
KeySpaceName: ops.Keyspace,
NodeIps: ops.Hosts,
Username: ops.Username,
Password: ops.Password,
Debug: true,
})
if err != nil {
return nil, err
}
return r, nil
} | [
"func",
"newDBConn",
"(",
"ops",
"Options",
")",
"(",
"*",
"ScyllaDB",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"newScyllaDB",
"(",
"ScyllaDBOpts",
"{",
"KeySpaceName",
":",
"ops",
".",
"Keyspace",
",",
"NodeIps",
":",
"ops",
".",
"Hosts",
",",
... | //A global function which helps to avoid passing config of riak everywhere. | [
"A",
"global",
"function",
"which",
"helps",
"to",
"avoid",
"passing",
"config",
"of",
"riak",
"everywhere",
"."
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/db/scylla.go#L21-L33 |
153,907 | megamsys/libgo | db/scylla.go | FetchListdb | func FetchListdb(tinfo Options, limit int, dat, data interface{}) error {
t, err := newDBConn(tinfo)
if err != nil {
return err
}
defer t.Close()
d := t.newScyllaTable(tinfo, dat)
if d != nil {
//err := d.read(ScyllaWhere{Clauses: tinfo.Clauses}, data)
err = d.readMulti(tinfo.PksClauses, limit, data)
if err != nil {
return err
}
}
return nil
} | go | func FetchListdb(tinfo Options, limit int, dat, data interface{}) error {
t, err := newDBConn(tinfo)
if err != nil {
return err
}
defer t.Close()
d := t.newScyllaTable(tinfo, dat)
if d != nil {
//err := d.read(ScyllaWhere{Clauses: tinfo.Clauses}, data)
err = d.readMulti(tinfo.PksClauses, limit, data)
if err != nil {
return err
}
}
return nil
} | [
"func",
"FetchListdb",
"(",
"tinfo",
"Options",
",",
"limit",
"int",
",",
"dat",
",",
"data",
"interface",
"{",
"}",
")",
"error",
"{",
"t",
",",
"err",
":=",
"newDBConn",
"(",
"tinfo",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n... | // dat referes the structure of table and data for array of row | [
"dat",
"referes",
"the",
"structure",
"of",
"table",
"and",
"data",
"for",
"array",
"of",
"row"
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/db/scylla.go#L60-L75 |
153,908 | uhoh-itsmaciek/femebe | buf/pack_buffer.go | ReadLen | func (b *PackBuffer) ReadLen() int {
if b.w >= len(b.s) {
return 0
}
return (b.w - b.r)
} | go | func (b *PackBuffer) ReadLen() int {
if b.w >= len(b.s) {
return 0
}
return (b.w - b.r)
} | [
"func",
"(",
"b",
"*",
"PackBuffer",
")",
"ReadLen",
"(",
")",
"int",
"{",
"if",
"b",
".",
"w",
">=",
"len",
"(",
"b",
".",
"s",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"b",
".",
"w",
"-",
"b",
".",
"r",
")",
"\n",
"}"
] | //The amount left to be read | [
"The",
"amount",
"left",
"to",
"be",
"read"
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/pack_buffer.go#L59-L64 |
153,909 | uhoh-itsmaciek/femebe | buf/pack_buffer.go | WriteLen | func (b *PackBuffer) WriteLen() int {
if b.w >= len(b.s) {
return 0
}
return len(b.s) - b.w
} | go | func (b *PackBuffer) WriteLen() int {
if b.w >= len(b.s) {
return 0
}
return len(b.s) - b.w
} | [
"func",
"(",
"b",
"*",
"PackBuffer",
")",
"WriteLen",
"(",
")",
"int",
"{",
"if",
"b",
".",
"w",
">=",
"len",
"(",
"b",
".",
"s",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"len",
"(",
"b",
".",
"s",
")",
"-",
"b",
".",
"w",
"\n"... | //the amount of room left to write before there is no room or buffer needs to be compacted | [
"the",
"amount",
"of",
"room",
"left",
"to",
"write",
"before",
"there",
"is",
"no",
"room",
"or",
"buffer",
"needs",
"to",
"be",
"compacted"
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/pack_buffer.go#L67-L72 |
153,910 | uhoh-itsmaciek/femebe | buf/pack_buffer.go | Seek | func (b *PackBuffer) Seek(offset int64, whence int) (int64, error) {
var abs int64
switch whence {
case 0:
abs = offset
case 1:
abs = int64(b.r) + offset
case 2:
abs = int64(len(b.s)) + offset
default:
return 0, errors.New("bytes: invalid whence")
}
if abs < 0 {
return 0, errors.New("bytes: negative position")
}
if abs >= 1<<31 {
return 0, errors.New("bytes: position out of range")
}
b.r = int(abs)
return abs, nil
} | go | func (b *PackBuffer) Seek(offset int64, whence int) (int64, error) {
var abs int64
switch whence {
case 0:
abs = offset
case 1:
abs = int64(b.r) + offset
case 2:
abs = int64(len(b.s)) + offset
default:
return 0, errors.New("bytes: invalid whence")
}
if abs < 0 {
return 0, errors.New("bytes: negative position")
}
if abs >= 1<<31 {
return 0, errors.New("bytes: position out of range")
}
b.r = int(abs)
return abs, nil
} | [
"func",
"(",
"b",
"*",
"PackBuffer",
")",
"Seek",
"(",
"offset",
"int64",
",",
"whence",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"abs",
"int64",
"\n",
"switch",
"whence",
"{",
"case",
"0",
":",
"abs",
"=",
"offset",
"\n",
"case",
... | // Seek implements the io.Seeker interface.
// This again feels like you don't know if your buffer has been compacted... | [
"Seek",
"implements",
"the",
"io",
".",
"Seeker",
"interface",
".",
"This",
"again",
"feels",
"like",
"you",
"don",
"t",
"know",
"if",
"your",
"buffer",
"has",
"been",
"compacted",
"..."
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/pack_buffer.go#L123-L143 |
153,911 | uhoh-itsmaciek/femebe | buf/pack_buffer.go | Compact | func (b *PackBuffer) Compact(squash bool) (err error) {
if squash {
b.r = 0
b.w = 0
} else {
if b.r == b.w {
b.r = 0
b.w = 0
} else {
var temp []byte
count := copy(temp, b.s[b.r:b.w])
if count == 0 {
return
}
copy(b.s, temp)
b.w = b.r - b.w
b.r = 0
}
}
return
} | go | func (b *PackBuffer) Compact(squash bool) (err error) {
if squash {
b.r = 0
b.w = 0
} else {
if b.r == b.w {
b.r = 0
b.w = 0
} else {
var temp []byte
count := copy(temp, b.s[b.r:b.w])
if count == 0 {
return
}
copy(b.s, temp)
b.w = b.r - b.w
b.r = 0
}
}
return
} | [
"func",
"(",
"b",
"*",
"PackBuffer",
")",
"Compact",
"(",
"squash",
"bool",
")",
"(",
"err",
"error",
")",
"{",
"if",
"squash",
"{",
"b",
".",
"r",
"=",
"0",
"\n",
"b",
".",
"w",
"=",
"0",
"\n",
"}",
"else",
"{",
"if",
"b",
".",
"r",
"==",
... | //Compacts and sets read and write cursors to where it belongs | [
"Compacts",
"and",
"sets",
"read",
"and",
"write",
"cursors",
"to",
"where",
"it",
"belongs"
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/pack_buffer.go#L146-L166 |
153,912 | uhoh-itsmaciek/femebe | buf/pack_buffer.go | Write | func (b *PackBuffer) Write(p []byte) (n int, err error) {
space := b.WriteLen()
if space < len(p) {
n = copy(b.s[b.w:], p)
b.w = b.w + n
} else {
b.Compact(false)
space = b.WriteLen()
if space > len(p) {
n = copy(b.s[b.w:], p[:])
} else {
n = copy(b.s[b.w:], p[:space])
}
}
if n == 0 {
return 0, errors.New("No room left in buffer")
}
return n, nil
} | go | func (b *PackBuffer) Write(p []byte) (n int, err error) {
space := b.WriteLen()
if space < len(p) {
n = copy(b.s[b.w:], p)
b.w = b.w + n
} else {
b.Compact(false)
space = b.WriteLen()
if space > len(p) {
n = copy(b.s[b.w:], p[:])
} else {
n = copy(b.s[b.w:], p[:space])
}
}
if n == 0 {
return 0, errors.New("No room left in buffer")
}
return n, nil
} | [
"func",
"(",
"b",
"*",
"PackBuffer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"space",
":=",
"b",
".",
"WriteLen",
"(",
")",
"\n",
"if",
"space",
"<",
"len",
"(",
"p",
")",
"{",
"n",
"="... | //Writes without compacting if possible, if needed it does, if there is no room
//then it returns an error | [
"Writes",
"without",
"compacting",
"if",
"possible",
"if",
"needed",
"it",
"does",
"if",
"there",
"is",
"no",
"room",
"then",
"it",
"returns",
"an",
"error"
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/pack_buffer.go#L170-L189 |
153,913 | atsaki/golang-cloudstack-library | NATApi.go | DeleteIpForwardingRule | func (c *Client) DeleteIpForwardingRule(p *DeleteIpForwardingRuleParameter) (*Result, error) {
obj, err := c.Request("deleteIpForwardingRule", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | go | func (c *Client) DeleteIpForwardingRule(p *DeleteIpForwardingRuleParameter) (*Result, error) {
obj, err := c.Request("deleteIpForwardingRule", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteIpForwardingRule",
"(",
"p",
"*",
"DeleteIpForwardingRuleParameter",
")",
"(",
"*",
"Result",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamToMap",
"(... | // Deletes an ip forwarding rule | [
"Deletes",
"an",
"ip",
"forwarding",
"rule"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/NATApi.go#L17-L23 |
153,914 | atsaki/golang-cloudstack-library | NATApi.go | EnableStaticNat | func (c *Client) EnableStaticNat(p *EnableStaticNatParameter) (*Result, error) {
obj, err := c.Request("enableStaticNat", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | go | func (c *Client) EnableStaticNat(p *EnableStaticNatParameter) (*Result, error) {
obj, err := c.Request("enableStaticNat", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"EnableStaticNat",
"(",
"p",
"*",
"EnableStaticNatParameter",
")",
"(",
"*",
"Result",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamToMap",
"(",
"p",
")... | // Enables static nat for given ip address | [
"Enables",
"static",
"nat",
"for",
"given",
"ip",
"address"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/NATApi.go#L47-L53 |
153,915 | atsaki/golang-cloudstack-library | NATApi.go | CreateIpForwardingRule | func (c *Client) CreateIpForwardingRule(p *CreateIpForwardingRuleParameter) (*IpForwardingRule, error) {
obj, err := c.Request("createIpForwardingRule", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*IpForwardingRule), err
} | go | func (c *Client) CreateIpForwardingRule(p *CreateIpForwardingRuleParameter) (*IpForwardingRule, error) {
obj, err := c.Request("createIpForwardingRule", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*IpForwardingRule), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateIpForwardingRule",
"(",
"p",
"*",
"CreateIpForwardingRuleParameter",
")",
"(",
"*",
"IpForwardingRule",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamTo... | // Creates an ip forwarding rule | [
"Creates",
"an",
"ip",
"forwarding",
"rule"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/NATApi.go#L84-L90 |
153,916 | atsaki/golang-cloudstack-library | NATApi.go | DisableStaticNat | func (c *Client) DisableStaticNat(p *DisableStaticNatParameter) (*Result, error) {
obj, err := c.Request("disableStaticNat", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | go | func (c *Client) DisableStaticNat(p *DisableStaticNatParameter) (*Result, error) {
obj, err := c.Request("disableStaticNat", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DisableStaticNat",
"(",
"p",
"*",
"DisableStaticNatParameter",
")",
"(",
"*",
"Result",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamToMap",
"(",
"p",
... | // Disables static rule for given ip address | [
"Disables",
"static",
"rule",
"for",
"given",
"ip",
"address"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/NATApi.go#L106-L112 |
153,917 | atsaki/golang-cloudstack-library | NATApi.go | ListIpForwardingRules | func (c *Client) ListIpForwardingRules(p *ListIpForwardingRulesParameter) ([]*IpForwardingRule, error) {
obj, err := c.Request("listIpForwardingRules", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.([]*IpForwardingRule), err
} | go | func (c *Client) ListIpForwardingRules(p *ListIpForwardingRulesParameter) ([]*IpForwardingRule, error) {
obj, err := c.Request("listIpForwardingRules", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.([]*IpForwardingRule), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListIpForwardingRules",
"(",
"p",
"*",
"ListIpForwardingRulesParameter",
")",
"(",
"[",
"]",
"*",
"IpForwardingRule",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"co... | // List the ip forwarding rules | [
"List",
"the",
"ip",
"forwarding",
"rules"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/NATApi.go#L148-L154 |
153,918 | c4milo/handlers | grpcutil/grpc_intcp.go | ForwardMetadataCLIntcp | func ForwardMetadataCLIntcp() grpc.UnaryClientInterceptor {
return func(ctx context.Context, method string, req,
reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker,
opts ...grpc.CallOption) error {
md, ok := metadata.FromIncomingContext(ctx)
if ok {
ctx = metadata.NewOutgoingContext(ctx, md)
}
return invoker(ctx, method, req, reply, cc, opts...)
}
} | go | func ForwardMetadataCLIntcp() grpc.UnaryClientInterceptor {
return func(ctx context.Context, method string, req,
reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker,
opts ...grpc.CallOption) error {
md, ok := metadata.FromIncomingContext(ctx)
if ok {
ctx = metadata.NewOutgoingContext(ctx, md)
}
return invoker(ctx, method, req, reply, cc, opts...)
}
} | [
"func",
"ForwardMetadataCLIntcp",
"(",
")",
"grpc",
".",
"UnaryClientInterceptor",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"method",
"string",
",",
"req",
",",
"reply",
"interface",
"{",
"}",
",",
"cc",
"*",
"grpc",
".",
"ClientC... | // ForwardMetadataCLIntcp returns a client unary interceptor that forwards
// incoming context metadata to its outgoing counterpart. In some scenarios,
// using this interceptor may pose security risks since authorization tokens
// or credentials can be accidentally leaked to third-party services. It can
// be very handy otherwise when used with trusted services. Since it allows
// to delegate or impersonate users when reaching out to internal services by
// forwarding their original access tokens or authentication credentials. | [
"ForwardMetadataCLIntcp",
"returns",
"a",
"client",
"unary",
"interceptor",
"that",
"forwards",
"incoming",
"context",
"metadata",
"to",
"its",
"outgoing",
"counterpart",
".",
"In",
"some",
"scenarios",
"using",
"this",
"interceptor",
"may",
"pose",
"security",
"ris... | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/grpcutil/grpc_intcp.go#L16-L27 |
153,919 | megamsys/libgo | utils/timed_store.go | NewTimedStore | func NewTimedStore(age time.Duration, maxItems int) *TimedStore {
return &TimedStore{
buffer: make(timedStoreDataSlice, 0),
age: age,
maxItems: maxItems,
}
} | go | func NewTimedStore(age time.Duration, maxItems int) *TimedStore {
return &TimedStore{
buffer: make(timedStoreDataSlice, 0),
age: age,
maxItems: maxItems,
}
} | [
"func",
"NewTimedStore",
"(",
"age",
"time",
".",
"Duration",
",",
"maxItems",
"int",
")",
"*",
"TimedStore",
"{",
"return",
"&",
"TimedStore",
"{",
"buffer",
":",
"make",
"(",
"timedStoreDataSlice",
",",
"0",
")",
",",
"age",
":",
"age",
",",
"maxItems"... | // Returns a new thread-compatible TimedStore.
// A maxItems value of -1 means no limit. | [
"Returns",
"a",
"new",
"thread",
"-",
"compatible",
"TimedStore",
".",
"A",
"maxItems",
"value",
"of",
"-",
"1",
"means",
"no",
"limit",
"."
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/utils/timed_store.go#L37-L43 |
153,920 | megamsys/libgo | utils/timed_store.go | getData | func (self *TimedStore) getData(index int) timedStoreData {
return self.buffer[len(self.buffer)-index-1]
} | go | func (self *TimedStore) getData(index int) timedStoreData {
return self.buffer[len(self.buffer)-index-1]
} | [
"func",
"(",
"self",
"*",
"TimedStore",
")",
"getData",
"(",
"index",
"int",
")",
"timedStoreData",
"{",
"return",
"self",
".",
"buffer",
"[",
"len",
"(",
"self",
".",
"buffer",
")",
"-",
"index",
"-",
"1",
"]",
"\n",
"}"
] | // Gets the data at the specified index. Note that elements are output in LIFO order. | [
"Gets",
"the",
"data",
"at",
"the",
"specified",
"index",
".",
"Note",
"that",
"elements",
"are",
"output",
"in",
"LIFO",
"order",
"."
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/utils/timed_store.go#L135-L137 |
153,921 | c4milo/handlers | csrf/csrf.go | Handler | func Handler(h http.Handler, opts ...Option) http.Handler {
// Sets default options
csrf := &handler{
name: "xt",
}
for _, opt := range opts {
opt(csrf)
}
if csrf.secret == "" {
panic(errSecretRequired)
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Re-enables browser's XSS filter if it was disabled
w.Header().Set("x-xss-protection", "1; mode=block")
// Set the token on the response to GET and HEAD requests
switch r.Method {
case http.MethodGet, http.MethodHead, http.MethodOptions:
setToken(w, csrf.name, csrf.secret, csrf.userID, csrf.domain)
h.ServeHTTP(w, r)
return
}
// Verify using origin header first
// Details about Origin header can be found at https://wiki.mozilla.org/Security/Origin
originValue := r.Header.Get("origin")
if originValue != "" {
originURL, err := url.ParseRequestURI(originValue)
if err == nil && originURL.Host == r.Host {
setToken(w, csrf.name, csrf.secret, csrf.userID, csrf.domain)
h.ServeHTTP(w, r)
return
}
// log.Printf("csrf: %+v\n", err)
}
// If origin is not supported or came back empty or null, verify cookie instead.
cookie, err := r.Cookie(csrf.name)
if err != nil {
http.Error(w, errForbidden, http.StatusForbidden)
return
}
if !xsrftoken.Valid(cookie.Value, csrf.secret, csrf.userID, "Global") {
http.Error(w, errForbidden, http.StatusForbidden)
return
}
setToken(w, csrf.name, csrf.secret, csrf.userID, csrf.domain)
h.ServeHTTP(w, r)
})
} | go | func Handler(h http.Handler, opts ...Option) http.Handler {
// Sets default options
csrf := &handler{
name: "xt",
}
for _, opt := range opts {
opt(csrf)
}
if csrf.secret == "" {
panic(errSecretRequired)
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Re-enables browser's XSS filter if it was disabled
w.Header().Set("x-xss-protection", "1; mode=block")
// Set the token on the response to GET and HEAD requests
switch r.Method {
case http.MethodGet, http.MethodHead, http.MethodOptions:
setToken(w, csrf.name, csrf.secret, csrf.userID, csrf.domain)
h.ServeHTTP(w, r)
return
}
// Verify using origin header first
// Details about Origin header can be found at https://wiki.mozilla.org/Security/Origin
originValue := r.Header.Get("origin")
if originValue != "" {
originURL, err := url.ParseRequestURI(originValue)
if err == nil && originURL.Host == r.Host {
setToken(w, csrf.name, csrf.secret, csrf.userID, csrf.domain)
h.ServeHTTP(w, r)
return
}
// log.Printf("csrf: %+v\n", err)
}
// If origin is not supported or came back empty or null, verify cookie instead.
cookie, err := r.Cookie(csrf.name)
if err != nil {
http.Error(w, errForbidden, http.StatusForbidden)
return
}
if !xsrftoken.Valid(cookie.Value, csrf.secret, csrf.userID, "Global") {
http.Error(w, errForbidden, http.StatusForbidden)
return
}
setToken(w, csrf.name, csrf.secret, csrf.userID, csrf.domain)
h.ServeHTTP(w, r)
})
} | [
"func",
"Handler",
"(",
"h",
"http",
".",
"Handler",
",",
"opts",
"...",
"Option",
")",
"http",
".",
"Handler",
"{",
"// Sets default options",
"csrf",
":=",
"&",
"handler",
"{",
"name",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":="... | // Handler checks Origin header first, if not set or has value "null" it validates using
// a HMAC CSRF token. For enabling Single Page Applications to send the XSRF cookie using
// async HTTP requests, use CORS and make sure Access-Control-Allow-Credential is enabled. | [
"Handler",
"checks",
"Origin",
"header",
"first",
"if",
"not",
"set",
"or",
"has",
"value",
"null",
"it",
"validates",
"using",
"a",
"HMAC",
"CSRF",
"token",
".",
"For",
"enabling",
"Single",
"Page",
"Applications",
"to",
"send",
"the",
"XSRF",
"cookie",
"... | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/csrf/csrf.go#L69-L123 |
153,922 | uhoh-itsmaciek/femebe | core/stream.go | SendSSLRequestResponse | func (c *MessageStream) SendSSLRequestResponse(r byte) error {
if c.state != ConnStartup {
return fmt.Errorf("SendSSLRequestResponse called while the connection is not in the startup phase")
}
_, err := c.rw.Write([]byte{r})
return err
} | go | func (c *MessageStream) SendSSLRequestResponse(r byte) error {
if c.state != ConnStartup {
return fmt.Errorf("SendSSLRequestResponse called while the connection is not in the startup phase")
}
_, err := c.rw.Write([]byte{r})
return err
} | [
"func",
"(",
"c",
"*",
"MessageStream",
")",
"SendSSLRequestResponse",
"(",
"r",
"byte",
")",
"error",
"{",
"if",
"c",
".",
"state",
"!=",
"ConnStartup",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"... | // Send a response to an SSLRequest to the message stream. See
// RejectSSLRequest and AcceptSSLRequest. | [
"Send",
"a",
"response",
"to",
"an",
"SSLRequest",
"to",
"the",
"message",
"stream",
".",
"See",
"RejectSSLRequest",
"and",
"AcceptSSLRequest",
"."
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/core/stream.go#L122-L128 |
153,923 | uhoh-itsmaciek/femebe | example/simpleproxy.go | main | func main() {
if len(os.Args) != 3 {
fmt.Printf("Usage: simpleproxy LISTENADDR SERVERADDR\n")
os.Exit(1)
}
ln, err := util.AutoListen(os.Args[1])
if err != nil {
fmt.Printf("Could not listen on address: %v\n", err)
os.Exit(1)
}
// Signal handling; this is pretty ghetto now, but at least we
// can exit cleanly on an interrupt. N.B.: this currently does
// not correctly capture SIGTERM on Linux (and possibly
// elsewhere)--it just kills the process directly without
// involving the signal handler.
sigch := make(chan os.Signal)
signal.Notify(sigch, os.Interrupt, os.Kill)
watchSigs := func() {
for sig := range sigch {
fmt.Printf("Got signal %v", sig)
if sig == os.Kill {
os.Exit(2)
} else if sig == os.Interrupt {
os.Exit(0)
}
}
}
go watchSigs()
target := os.Args[2]
resolver := &fixedResolver{target}
manager := femebe.NewSimpleSessionManager()
p := &proxy{resolver, manager}
for {
conn, err := ln.Accept()
if err != nil {
fmt.Printf("Error: %v\n", err)
continue
}
log.Print("accepting connection")
go p.handleConnection(conn, target)
}
} | go | func main() {
if len(os.Args) != 3 {
fmt.Printf("Usage: simpleproxy LISTENADDR SERVERADDR\n")
os.Exit(1)
}
ln, err := util.AutoListen(os.Args[1])
if err != nil {
fmt.Printf("Could not listen on address: %v\n", err)
os.Exit(1)
}
// Signal handling; this is pretty ghetto now, but at least we
// can exit cleanly on an interrupt. N.B.: this currently does
// not correctly capture SIGTERM on Linux (and possibly
// elsewhere)--it just kills the process directly without
// involving the signal handler.
sigch := make(chan os.Signal)
signal.Notify(sigch, os.Interrupt, os.Kill)
watchSigs := func() {
for sig := range sigch {
fmt.Printf("Got signal %v", sig)
if sig == os.Kill {
os.Exit(2)
} else if sig == os.Interrupt {
os.Exit(0)
}
}
}
go watchSigs()
target := os.Args[2]
resolver := &fixedResolver{target}
manager := femebe.NewSimpleSessionManager()
p := &proxy{resolver, manager}
for {
conn, err := ln.Accept()
if err != nil {
fmt.Printf("Error: %v\n", err)
continue
}
log.Print("accepting connection")
go p.handleConnection(conn, target)
}
} | [
"func",
"main",
"(",
")",
"{",
"if",
"len",
"(",
"os",
".",
"Args",
")",
"!=",
"3",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n\n",
"ln",
",",
"err",
":=",
"util",
".",
"A... | // Startup and main client acceptance loop | [
"Startup",
"and",
"main",
"client",
"acceptance",
"loop"
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/example/simpleproxy.go#L17-L65 |
153,924 | megamsys/libgo | events/writer.go | GetPastEvents | func (ew *EventsWriter) GetPastEvents(request *Request) ([]*Event, error) {
if ew.H != nil {
return ew.H.GetEvents(request)
}
return nil, nil
} | go | func (ew *EventsWriter) GetPastEvents(request *Request) ([]*Event, error) {
if ew.H != nil {
return ew.H.GetEvents(request)
}
return nil, nil
} | [
"func",
"(",
"ew",
"*",
"EventsWriter",
")",
"GetPastEvents",
"(",
"request",
"*",
"Request",
")",
"(",
"[",
"]",
"*",
"Event",
",",
"error",
")",
"{",
"if",
"ew",
".",
"H",
"!=",
"nil",
"{",
"return",
"ew",
".",
"H",
".",
"GetEvents",
"(",
"requ... | // can be called by the api which will return all events satisfying the request | [
"can",
"be",
"called",
"by",
"the",
"api",
"which",
"will",
"return",
"all",
"events",
"satisfying",
"the",
"request"
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/events/writer.go#L71-L76 |
153,925 | megamsys/libgo | events/writer.go | parseEventsStoragePolicy | func parseEventsStoragePolicy() StoragePolicy {
policy := DefaultStoragePolicy()
// Parse max age.
parts := strings.Split(eventStorageAgeLimit, ",")
for _, part := range parts {
items := strings.Split(part, "=")
if len(items) != 2 {
log.Warningf("Unknown event storage policy %q when parsing max age", part)
continue
}
dur, err := time.ParseDuration(items[1])
if err != nil {
log.Warningf("Unable to parse event max age duration %q: %v", items[1], err)
continue
}
if items[0] == "default" {
policy.DefaultMaxAge = dur
continue
}
policy.PerTypeMaxAge[EventType(items[0])] = dur
}
// Parse max number.
parts = strings.Split(eventStorageEventLimit, ",")
for _, part := range parts {
items := strings.Split(part, "=")
if len(items) != 2 {
log.Warningf("Unknown event storage policy %q when parsing max event limit", part)
continue
}
val, err := strconv.Atoi(items[1])
if err != nil {
log.Warningf("Unable to parse integer from %q: %v", items[1], err)
continue
}
if items[0] == "default" {
policy.DefaultMaxNumEvents = val
continue
}
policy.PerTypeMaxNumEvents[EventType(items[0])] = val
}
return policy
} | go | func parseEventsStoragePolicy() StoragePolicy {
policy := DefaultStoragePolicy()
// Parse max age.
parts := strings.Split(eventStorageAgeLimit, ",")
for _, part := range parts {
items := strings.Split(part, "=")
if len(items) != 2 {
log.Warningf("Unknown event storage policy %q when parsing max age", part)
continue
}
dur, err := time.ParseDuration(items[1])
if err != nil {
log.Warningf("Unable to parse event max age duration %q: %v", items[1], err)
continue
}
if items[0] == "default" {
policy.DefaultMaxAge = dur
continue
}
policy.PerTypeMaxAge[EventType(items[0])] = dur
}
// Parse max number.
parts = strings.Split(eventStorageEventLimit, ",")
for _, part := range parts {
items := strings.Split(part, "=")
if len(items) != 2 {
log.Warningf("Unknown event storage policy %q when parsing max event limit", part)
continue
}
val, err := strconv.Atoi(items[1])
if err != nil {
log.Warningf("Unable to parse integer from %q: %v", items[1], err)
continue
}
if items[0] == "default" {
policy.DefaultMaxNumEvents = val
continue
}
policy.PerTypeMaxNumEvents[EventType(items[0])] = val
}
return policy
} | [
"func",
"parseEventsStoragePolicy",
"(",
")",
"StoragePolicy",
"{",
"policy",
":=",
"DefaultStoragePolicy",
"(",
")",
"\n\n",
"// Parse max age.",
"parts",
":=",
"strings",
".",
"Split",
"(",
"eventStorageAgeLimit",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
... | // Parses the events StoragePolicy from the flags. | [
"Parses",
"the",
"events",
"StoragePolicy",
"from",
"the",
"flags",
"."
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/events/writer.go#L106-L150 |
153,926 | acoshift/middleware | middleware.go | Chain | func Chain(hs ...Middleware) Middleware {
return func(h http.Handler) http.Handler {
for i := len(hs); i > 0; i-- {
h = hs[i-1](h)
}
return h
}
} | go | func Chain(hs ...Middleware) Middleware {
return func(h http.Handler) http.Handler {
for i := len(hs); i > 0; i-- {
h = hs[i-1](h)
}
return h
}
} | [
"func",
"Chain",
"(",
"hs",
"...",
"Middleware",
")",
"Middleware",
"{",
"return",
"func",
"(",
"h",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"for",
"i",
":=",
"len",
"(",
"hs",
")",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"h"... | // Chain is the helper function for chain middlewares into one middleware | [
"Chain",
"is",
"the",
"helper",
"function",
"for",
"chain",
"middlewares",
"into",
"one",
"middleware"
] | 72ef9c385871dd1964bcdf6170ce9aefeff90fd8 | https://github.com/acoshift/middleware/blob/72ef9c385871dd1964bcdf6170ce9aefeff90fd8/middleware.go#L9-L16 |
153,927 | casimir/xdg-go | xdg.go | DataPath | func (a App) DataPath(file string) string {
return a.path("XDG_DATA_HOME", DataHome, file)
} | go | func (a App) DataPath(file string) string {
return a.path("XDG_DATA_HOME", DataHome, file)
} | [
"func",
"(",
"a",
"App",
")",
"DataPath",
"(",
"file",
"string",
")",
"string",
"{",
"return",
"a",
".",
"path",
"(",
"\"",
"\"",
",",
"DataHome",
",",
"file",
")",
"\n",
"}"
] | // DataPath determines the full path of a data file. | [
"DataPath",
"determines",
"the",
"full",
"path",
"of",
"a",
"data",
"file",
"."
] | 372ccc2180dab73316615641d5617c5ed3e35529 | https://github.com/casimir/xdg-go/blob/372ccc2180dab73316615641d5617c5ed3e35529/xdg.go#L24-L26 |
153,928 | casimir/xdg-go | xdg.go | ConfigPath | func (a App) ConfigPath(file string) string {
return a.path("XDG_CONFIG_HOME", ConfigHome, file)
} | go | func (a App) ConfigPath(file string) string {
return a.path("XDG_CONFIG_HOME", ConfigHome, file)
} | [
"func",
"(",
"a",
"App",
")",
"ConfigPath",
"(",
"file",
"string",
")",
"string",
"{",
"return",
"a",
".",
"path",
"(",
"\"",
"\"",
",",
"ConfigHome",
",",
"file",
")",
"\n",
"}"
] | // ConfigPath determines the full path of a data file. | [
"ConfigPath",
"determines",
"the",
"full",
"path",
"of",
"a",
"data",
"file",
"."
] | 372ccc2180dab73316615641d5617c5ed3e35529 | https://github.com/casimir/xdg-go/blob/372ccc2180dab73316615641d5617c5ed3e35529/xdg.go#L29-L31 |
153,929 | casimir/xdg-go | xdg.go | CachePath | func (a App) CachePath(file string) string {
return a.path("XDG_CACHE_HOME", CacheHome, file)
} | go | func (a App) CachePath(file string) string {
return a.path("XDG_CACHE_HOME", CacheHome, file)
} | [
"func",
"(",
"a",
"App",
")",
"CachePath",
"(",
"file",
"string",
")",
"string",
"{",
"return",
"a",
".",
"path",
"(",
"\"",
"\"",
",",
"CacheHome",
",",
"file",
")",
"\n",
"}"
] | // CachePath determines the full path of a cached file. | [
"CachePath",
"determines",
"the",
"full",
"path",
"of",
"a",
"cached",
"file",
"."
] | 372ccc2180dab73316615641d5617c5ed3e35529 | https://github.com/casimir/xdg-go/blob/372ccc2180dab73316615641d5617c5ed3e35529/xdg.go#L34-L36 |
153,930 | casimir/xdg-go | xdg.go | SystemDataPaths | func (a App) SystemDataPaths(file string) []string {
return a.multiPaths("XDG_DATA_DIRS", DataDirs, file)
} | go | func (a App) SystemDataPaths(file string) []string {
return a.multiPaths("XDG_DATA_DIRS", DataDirs, file)
} | [
"func",
"(",
"a",
"App",
")",
"SystemDataPaths",
"(",
"file",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"a",
".",
"multiPaths",
"(",
"\"",
"\"",
",",
"DataDirs",
",",
"file",
")",
"\n",
"}"
] | // SystemDataPaths determines system-wide possible paths for a data file. | [
"SystemDataPaths",
"determines",
"system",
"-",
"wide",
"possible",
"paths",
"for",
"a",
"data",
"file",
"."
] | 372ccc2180dab73316615641d5617c5ed3e35529 | https://github.com/casimir/xdg-go/blob/372ccc2180dab73316615641d5617c5ed3e35529/xdg.go#L54-L56 |
153,931 | casimir/xdg-go | xdg.go | SystemConfigPaths | func (a App) SystemConfigPaths(file string) []string {
return a.multiPaths("XDG_CONFIG_DIRS", ConfigDirs, file)
} | go | func (a App) SystemConfigPaths(file string) []string {
return a.multiPaths("XDG_CONFIG_DIRS", ConfigDirs, file)
} | [
"func",
"(",
"a",
"App",
")",
"SystemConfigPaths",
"(",
"file",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"a",
".",
"multiPaths",
"(",
"\"",
"\"",
",",
"ConfigDirs",
",",
"file",
")",
"\n",
"}"
] | // SystemConfigPaths determines system-wide possible paths for a config file. | [
"SystemConfigPaths",
"determines",
"system",
"-",
"wide",
"possible",
"paths",
"for",
"a",
"config",
"file",
"."
] | 372ccc2180dab73316615641d5617c5ed3e35529 | https://github.com/casimir/xdg-go/blob/372ccc2180dab73316615641d5617c5ed3e35529/xdg.go#L59-L61 |
153,932 | gyuho/dataframe | column.go | NewColumn | func NewColumn(hd string) Column {
return &column{
dataType: STRING,
header: hd,
size: 0,
data: []Value{},
}
} | go | func NewColumn(hd string) Column {
return &column{
dataType: STRING,
header: hd,
size: 0,
data: []Value{},
}
} | [
"func",
"NewColumn",
"(",
"hd",
"string",
")",
"Column",
"{",
"return",
"&",
"column",
"{",
"dataType",
":",
"STRING",
",",
"header",
":",
"hd",
",",
"size",
":",
"0",
",",
"data",
":",
"[",
"]",
"Value",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewColumn creates a new Column. | [
"NewColumn",
"creates",
"a",
"new",
"Column",
"."
] | 008fc241adc41d4bd5c54b9f6564ef16407c030e | https://github.com/gyuho/dataframe/blob/008fc241adc41d4bd5c54b9f6564ef16407c030e/column.go#L130-L137 |
153,933 | gyuho/dataframe | column.go | NewColumnTyped | func NewColumnTyped(hd string, tp DATA_TYPE) Column {
return &column{
dataType: tp,
header: hd,
size: 0,
data: []Value{},
}
} | go | func NewColumnTyped(hd string, tp DATA_TYPE) Column {
return &column{
dataType: tp,
header: hd,
size: 0,
data: []Value{},
}
} | [
"func",
"NewColumnTyped",
"(",
"hd",
"string",
",",
"tp",
"DATA_TYPE",
")",
"Column",
"{",
"return",
"&",
"column",
"{",
"dataType",
":",
"tp",
",",
"header",
":",
"hd",
",",
"size",
":",
"0",
",",
"data",
":",
"[",
"]",
"Value",
"{",
"}",
",",
"... | // NewColumnTyped creates a new Column with data type. | [
"NewColumnTyped",
"creates",
"a",
"new",
"Column",
"with",
"data",
"type",
"."
] | 008fc241adc41d4bd5c54b9f6564ef16407c030e | https://github.com/gyuho/dataframe/blob/008fc241adc41d4bd5c54b9f6564ef16407c030e/column.go#L140-L147 |
153,934 | c4milo/handlers | session/session.go | New | func New(name string, keys []string) *Session {
session := Session{
data: make(map[interface{}]interface{}),
Cookie: &http.Cookie{Name: name},
keys: keys,
}
return &session
} | go | func New(name string, keys []string) *Session {
session := Session{
data: make(map[interface{}]interface{}),
Cookie: &http.Cookie{Name: name},
keys: keys,
}
return &session
} | [
"func",
"New",
"(",
"name",
"string",
",",
"keys",
"[",
"]",
"string",
")",
"*",
"Session",
"{",
"session",
":=",
"Session",
"{",
"data",
":",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
")",
",",
"Cookie",
":",
"&... | // New returns a new Session | [
"New",
"returns",
"a",
"new",
"Session"
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L48-L55 |
153,935 | c4milo/handlers | session/session.go | Set | func (s *Session) Set(key string, value interface{}) error {
s.isDirty = true
s.data[key] = value
return nil
} | go | func (s *Session) Set(key string, value interface{}) error {
s.isDirty = true
s.data[key] = value
return nil
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Set",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"s",
".",
"isDirty",
"=",
"true",
"\n\n",
"s",
".",
"data",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"nil",
"\n",
... | // Set assigns a value to a specific key. | [
"Set",
"assigns",
"a",
"value",
"to",
"a",
"specific",
"key",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L58-L63 |
153,936 | c4milo/handlers | session/session.go | Delete | func (s *Session) Delete(key string) error {
s.isDirty = true
delete(s.data, key)
return nil
} | go | func (s *Session) Delete(key string) error {
s.isDirty = true
delete(s.data, key)
return nil
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Delete",
"(",
"key",
"string",
")",
"error",
"{",
"s",
".",
"isDirty",
"=",
"true",
"\n\n",
"delete",
"(",
"s",
".",
"data",
",",
"key",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Delete removes the given key's value from the session store. | [
"Delete",
"removes",
"the",
"given",
"key",
"s",
"value",
"from",
"the",
"session",
"store",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L71-L76 |
153,937 | c4milo/handlers | session/session.go | Destroy | func (s *Session) Destroy() {
s.MaxAge = -1
s.Expires = time.Now()
s.data = make(map[interface{}]interface{})
s.isDirty = true
} | go | func (s *Session) Destroy() {
s.MaxAge = -1
s.Expires = time.Now()
s.data = make(map[interface{}]interface{})
s.isDirty = true
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Destroy",
"(",
")",
"{",
"s",
".",
"MaxAge",
"=",
"-",
"1",
"\n",
"s",
".",
"Expires",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"s",
".",
"data",
"=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"... | // Destroy signals the user's browser to remove the session cookie. | [
"Destroy",
"signals",
"the",
"user",
"s",
"browser",
"to",
"remove",
"the",
"session",
"cookie",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L79-L84 |
153,938 | c4milo/handlers | session/session.go | Encode | func (s *Session) Encode() ([]byte, error) {
if len(s.data) == 0 {
return nil, nil
}
if len(s.keys) == 0 {
return nil, errors.New("at least one encryption key is required")
}
msg, err := msgpack.Marshal(s.data)
if err != nil {
return nil, errors.Wrapf(err, "failed encoding session data")
}
var nonce [24]byte
if _, err := io.ReadFull(rand.Reader, nonce[:]); err != nil {
return nil, errors.Wrapf(err, "failed generating nonce value")
}
var key [32]byte
copy(key[:], s.keys[0])
box := secretbox.Seal(nonce[:], msg, &nonce, &key)
data := make([]byte, base64.RawStdEncoding.EncodedLen(len(box)))
base64.RawStdEncoding.Encode(data, box)
return data, nil
} | go | func (s *Session) Encode() ([]byte, error) {
if len(s.data) == 0 {
return nil, nil
}
if len(s.keys) == 0 {
return nil, errors.New("at least one encryption key is required")
}
msg, err := msgpack.Marshal(s.data)
if err != nil {
return nil, errors.Wrapf(err, "failed encoding session data")
}
var nonce [24]byte
if _, err := io.ReadFull(rand.Reader, nonce[:]); err != nil {
return nil, errors.Wrapf(err, "failed generating nonce value")
}
var key [32]byte
copy(key[:], s.keys[0])
box := secretbox.Seal(nonce[:], msg, &nonce, &key)
data := make([]byte, base64.RawStdEncoding.EncodedLen(len(box)))
base64.RawStdEncoding.Encode(data, box)
return data, nil
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Encode",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"s",
".",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"s",
".",
... | // Encode encrypts and serializes the session cookie's data. | [
"Encode",
"encrypts",
"and",
"serializes",
"the",
"session",
"cookie",
"s",
"data",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L87-L115 |
153,939 | c4milo/handlers | session/session.go | Decode | func (s *Session) Decode(data []byte) error {
if len(data) == 0 {
return nil
}
box := make([]byte, base64.RawStdEncoding.DecodedLen(len(data)))
if _, err := base64.RawStdEncoding.Decode(box, data); err != nil {
return errors.Wrapf(err, "failed decoding session data")
}
var nonce [24]byte
var msg []byte
var key [32]byte
var ok bool
copy(nonce[:], box[:24])
for _, k := range s.keys {
copy(key[:], k)
msg, ok = secretbox.Open(nil, box[24:], &nonce, &key)
if ok {
if err := msgpack.Unmarshal(msg, &s.data); err != nil {
return errors.Wrapf(err, "failed decoding session data")
}
return nil
}
}
return errors.New("failed decrypting session data")
} | go | func (s *Session) Decode(data []byte) error {
if len(data) == 0 {
return nil
}
box := make([]byte, base64.RawStdEncoding.DecodedLen(len(data)))
if _, err := base64.RawStdEncoding.Decode(box, data); err != nil {
return errors.Wrapf(err, "failed decoding session data")
}
var nonce [24]byte
var msg []byte
var key [32]byte
var ok bool
copy(nonce[:], box[:24])
for _, k := range s.keys {
copy(key[:], k)
msg, ok = secretbox.Open(nil, box[24:], &nonce, &key)
if ok {
if err := msgpack.Unmarshal(msg, &s.data); err != nil {
return errors.Wrapf(err, "failed decoding session data")
}
return nil
}
}
return errors.New("failed decrypting session data")
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Decode",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"box",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"base64",
"... | // Decode decrypts, authenticates and deserializes cookie's session data. | [
"Decode",
"decrypts",
"authenticates",
"and",
"deserializes",
"cookie",
"s",
"session",
"data",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L118-L146 |
153,940 | c4milo/handlers | session/session.go | newContext | func newContext(ctx context.Context, s *Session) context.Context {
return context.WithValue(ctx, sessionKey{}, s)
} | go | func newContext(ctx context.Context, s *Session) context.Context {
return context.WithValue(ctx, sessionKey{}, s)
} | [
"func",
"newContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
"*",
"Session",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"sessionKey",
"{",
"}",
",",
"s",
")",
"\n",
"}"
] | // newContext returns a new context with the provided session inside. | [
"newContext",
"returns",
"a",
"new",
"context",
"with",
"the",
"provided",
"session",
"inside",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L152-L154 |
153,941 | c4milo/handlers | session/session.go | FromContext | func FromContext(ctx context.Context) (s *Session, ok bool) {
s, ok = ctx.Value(sessionKey{}).(*Session)
return
} | go | func FromContext(ctx context.Context) (s *Session, ok bool) {
s, ok = ctx.Value(sessionKey{}).(*Session)
return
} | [
"func",
"FromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"s",
"*",
"Session",
",",
"ok",
"bool",
")",
"{",
"s",
",",
"ok",
"=",
"ctx",
".",
"Value",
"(",
"sessionKey",
"{",
"}",
")",
".",
"(",
"*",
"Session",
")",
"\n",
"return",
... | // FromContext extracts the session from the given context. | [
"FromContext",
"extracts",
"the",
"session",
"from",
"the",
"given",
"context",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L157-L160 |
153,942 | c4milo/handlers | session/session.go | genID | func genID(size int) string {
b := make([]byte, size)
_, err := rand.Read(b)
if err != nil {
return ""
}
return fmt.Sprintf("%x", b)
} | go | func genID(size int) string {
b := make([]byte, size)
_, err := rand.Read(b)
if err != nil {
return ""
}
return fmt.Sprintf("%x", b)
} | [
"func",
"genID",
"(",
"size",
"int",
")",
"string",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"_",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // genID returns a random string | [
"genID",
"returns",
"a",
"random",
"string"
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/session/session.go#L163-L171 |
153,943 | gyuho/dataframe | value_string.go | NewStringValue | func NewStringValue(v interface{}) Value {
switch t := v.(type) {
case string:
return String(t)
case []byte:
return String(t)
case bool:
return String(fmt.Sprintf("%v", t))
case int:
return String(strconv.FormatInt(int64(t), 10))
case int8:
return String(strconv.FormatInt(int64(t), 10))
case int16:
return String(strconv.FormatInt(int64(t), 10))
case int32:
return String(strconv.FormatInt(int64(t), 10))
case int64:
return String(strconv.FormatInt(t, 10))
case uint:
return String(strconv.FormatUint(uint64(t), 10))
case uint8: // byte is an alias for uint8
return String(strconv.FormatUint(uint64(t), 10))
case uint16:
return String(strconv.FormatUint(uint64(t), 10))
case uint32:
return String(strconv.FormatUint(uint64(t), 10))
case float32:
return String(strconv.FormatFloat(float64(t), 'f', -1, 64))
case float64:
return String(strconv.FormatFloat(t, 'f', -1, 64))
case time.Time:
return String(t.String())
case time.Duration:
return String(t.String())
default:
panic(fmt.Errorf("%v(%T) is not supported yet", v, v))
}
} | go | func NewStringValue(v interface{}) Value {
switch t := v.(type) {
case string:
return String(t)
case []byte:
return String(t)
case bool:
return String(fmt.Sprintf("%v", t))
case int:
return String(strconv.FormatInt(int64(t), 10))
case int8:
return String(strconv.FormatInt(int64(t), 10))
case int16:
return String(strconv.FormatInt(int64(t), 10))
case int32:
return String(strconv.FormatInt(int64(t), 10))
case int64:
return String(strconv.FormatInt(t, 10))
case uint:
return String(strconv.FormatUint(uint64(t), 10))
case uint8: // byte is an alias for uint8
return String(strconv.FormatUint(uint64(t), 10))
case uint16:
return String(strconv.FormatUint(uint64(t), 10))
case uint32:
return String(strconv.FormatUint(uint64(t), 10))
case float32:
return String(strconv.FormatFloat(float64(t), 'f', -1, 64))
case float64:
return String(strconv.FormatFloat(t, 'f', -1, 64))
case time.Time:
return String(t.String())
case time.Duration:
return String(t.String())
default:
panic(fmt.Errorf("%v(%T) is not supported yet", v, v))
}
} | [
"func",
"NewStringValue",
"(",
"v",
"interface",
"{",
"}",
")",
"Value",
"{",
"switch",
"t",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"return",
"String",
"(",
"t",
")",
"\n",
"case",
"[",
"]",
"byte",
":",
"return",
"String",
... | // NewStringValue takes any interface and returns Value. | [
"NewStringValue",
"takes",
"any",
"interface",
"and",
"returns",
"Value",
"."
] | 008fc241adc41d4bd5c54b9f6564ef16407c030e | https://github.com/gyuho/dataframe/blob/008fc241adc41d4bd5c54b9f6564ef16407c030e/value_string.go#L13-L50 |
153,944 | atsaki/golang-cloudstack-library | AccountApi.go | AddAccountToProject | func (c *Client) AddAccountToProject(p *AddAccountToProjectParameter) (*Result, error) {
obj, err := c.Request("addAccountToProject", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | go | func (c *Client) AddAccountToProject(p *AddAccountToProjectParameter) (*Result, error) {
obj, err := c.Request("addAccountToProject", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Result), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"AddAccountToProject",
"(",
"p",
"*",
"AddAccountToProjectParameter",
")",
"(",
"*",
"Result",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamToMap",
"(",
"... | // Adds acoount to a project | [
"Adds",
"acoount",
"to",
"a",
"project"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/AccountApi.go#L21-L27 |
153,945 | atsaki/golang-cloudstack-library | AccountApi.go | LockAccount | func (c *Client) LockAccount(p *LockAccountParameter) (*Account, error) {
obj, err := c.Request("lockAccount", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Account), err
} | go | func (c *Client) LockAccount(p *LockAccountParameter) (*Account, error) {
obj, err := c.Request("lockAccount", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*Account), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"LockAccount",
"(",
"p",
"*",
"LockAccountParameter",
")",
"(",
"*",
"Account",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamToMap",
"(",
"p",
")",
")... | // Locks an account | [
"Locks",
"an",
"account"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/AccountApi.go#L129-L135 |
153,946 | c4milo/handlers | logger/logger.go | Output | func Output(out io.Writer) Option {
return func(l *handler) {
l.out = out
}
} | go | func Output(out io.Writer) Option {
return func(l *handler) {
l.out = out
}
} | [
"func",
"Output",
"(",
"out",
"io",
".",
"Writer",
")",
"Option",
"{",
"return",
"func",
"(",
"l",
"*",
"handler",
")",
"{",
"l",
".",
"out",
"=",
"out",
"\n",
"}",
"\n",
"}"
] | // Output allows setting an output writer for logging to be written to | [
"Output",
"allows",
"setting",
"an",
"output",
"writer",
"for",
"logging",
"to",
"be",
"written",
"to"
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/logger/logger.go#L78-L82 |
153,947 | c4milo/handlers | logger/logger.go | Handler | func Handler(h http.Handler, opts ...Option) http.Handler {
// Default options
handler := &handler{
name: "unknown_app",
format: `{id} remote_ip={remote_ip} user-agent={useragent} {method} "{scheme}{host}{url}?{query}" status={status} latency_human={latency_human} latency={latency} rxbytes={rxbytes} txbytes={txbytes}`,
out: os.Stdout,
flags: log.LstdFlags | log.Lmicroseconds,
}
for _, opt := range opts {
opt(handler)
}
l := log.New(handler.out, fmt.Sprintf("[%s] ", handler.name), handler.flags)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
l.Print(applyLogFormat(handler.format, -1, w, r))
res := internal.NewResponseWriter(w)
h.ServeHTTP(res, r)
latency := time.Since(start)
l.Print(applyLogFormat(handler.format, latency, res, r))
})
} | go | func Handler(h http.Handler, opts ...Option) http.Handler {
// Default options
handler := &handler{
name: "unknown_app",
format: `{id} remote_ip={remote_ip} user-agent={useragent} {method} "{scheme}{host}{url}?{query}" status={status} latency_human={latency_human} latency={latency} rxbytes={rxbytes} txbytes={txbytes}`,
out: os.Stdout,
flags: log.LstdFlags | log.Lmicroseconds,
}
for _, opt := range opts {
opt(handler)
}
l := log.New(handler.out, fmt.Sprintf("[%s] ", handler.name), handler.flags)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
l.Print(applyLogFormat(handler.format, -1, w, r))
res := internal.NewResponseWriter(w)
h.ServeHTTP(res, r)
latency := time.Since(start)
l.Print(applyLogFormat(handler.format, latency, res, r))
})
} | [
"func",
"Handler",
"(",
"h",
"http",
".",
"Handler",
",",
"opts",
"...",
"Option",
")",
"http",
".",
"Handler",
"{",
"// Default options",
"handler",
":=",
"&",
"handler",
"{",
"name",
":",
"\"",
"\"",
",",
"format",
":",
"`{id} remote_ip={remote_ip} user-ag... | // Handler does HTTP request logging | [
"Handler",
"does",
"HTTP",
"request",
"logging"
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/logger/logger.go#L85-L111 |
153,948 | megamsys/libgo | pairs/pairs.go | Match | func (p *JsonPairs) Match(k string) string {
for _, j := range *p {
if j.K == k {
return j.V
}
}
return ""
} | go | func (p *JsonPairs) Match(k string) string {
for _, j := range *p {
if j.K == k {
return j.V
}
}
return ""
} | [
"func",
"(",
"p",
"*",
"JsonPairs",
")",
"Match",
"(",
"k",
"string",
")",
"string",
"{",
"for",
"_",
",",
"j",
":=",
"range",
"*",
"p",
"{",
"if",
"j",
".",
"K",
"==",
"k",
"{",
"return",
"j",
".",
"V",
"\n",
"}",
"\n",
"}",
"\n",
"return"... | //match for a key in the JSONPair and send the value | [
"match",
"for",
"a",
"key",
"in",
"the",
"JSONPair",
"and",
"send",
"the",
"value"
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/pairs/pairs.go#L23-L30 |
153,949 | megamsys/libgo | pairs/pairs.go | NukeKeys | func (p *JsonPairs) NukeKeys(m string) {
swap := make(JsonPairs, 0)
for _, j := range *p { //j is key, value of JsonPair
if j.K != m {
swap = append(swap, j)
}
}
*p = swap
} | go | func (p *JsonPairs) NukeKeys(m string) {
swap := make(JsonPairs, 0)
for _, j := range *p { //j is key, value of JsonPair
if j.K != m {
swap = append(swap, j)
}
}
*p = swap
} | [
"func",
"(",
"p",
"*",
"JsonPairs",
")",
"NukeKeys",
"(",
"m",
"string",
")",
"{",
"swap",
":=",
"make",
"(",
"JsonPairs",
",",
"0",
")",
"\n",
"for",
"_",
",",
"j",
":=",
"range",
"*",
"p",
"{",
"//j is key, value of JsonPair",
"if",
"j",
".",
"K"... | //Delete old key and its value | [
"Delete",
"old",
"key",
"and",
"its",
"value"
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/pairs/pairs.go#L73-L81 |
153,950 | gyuho/dataframe | value_data_type.go | ToValue | func ToValue(v interface{}) Value {
switch ReflectTypeOf(v) {
case TIME:
return NewTimeValue(v)
default:
return NewStringValue(v)
}
} | go | func ToValue(v interface{}) Value {
switch ReflectTypeOf(v) {
case TIME:
return NewTimeValue(v)
default:
return NewStringValue(v)
}
} | [
"func",
"ToValue",
"(",
"v",
"interface",
"{",
"}",
")",
"Value",
"{",
"switch",
"ReflectTypeOf",
"(",
"v",
")",
"{",
"case",
"TIME",
":",
"return",
"NewTimeValue",
"(",
"v",
")",
"\n",
"default",
":",
"return",
"NewStringValue",
"(",
"v",
")",
"\n",
... | // ToValue converts to Value. | [
"ToValue",
"converts",
"to",
"Value",
"."
] | 008fc241adc41d4bd5c54b9f6564ef16407c030e | https://github.com/gyuho/dataframe/blob/008fc241adc41d4bd5c54b9f6564ef16407c030e/value_data_type.go#L44-L51 |
153,951 | uhoh-itsmaciek/femebe | proto/oids.go | TypSize | func TypSize(typOid Oid) int16 {
// TODO: right now, we hardcode the length of the various types
// here; ideally, we should have a mapping for the fixed-length
// types (although it seems that all the dynamic-length types,
// even those with explicit length restrictions, is just -1, so
// perhaps we can provide a mapping for that as well).
switch typOid {
case OidBool:
return 1
case OidInt2:
return 2
case OidInt4, OidFloat4:
return 4
case OidInt8, OidFloat8:
return 8
case OidText:
return -1
default:
// unknown, assume variable length
return -1
}
} | go | func TypSize(typOid Oid) int16 {
// TODO: right now, we hardcode the length of the various types
// here; ideally, we should have a mapping for the fixed-length
// types (although it seems that all the dynamic-length types,
// even those with explicit length restrictions, is just -1, so
// perhaps we can provide a mapping for that as well).
switch typOid {
case OidBool:
return 1
case OidInt2:
return 2
case OidInt4, OidFloat4:
return 4
case OidInt8, OidFloat8:
return 8
case OidText:
return -1
default:
// unknown, assume variable length
return -1
}
} | [
"func",
"TypSize",
"(",
"typOid",
"Oid",
")",
"int16",
"{",
"// TODO: right now, we hardcode the length of the various types",
"// here; ideally, we should have a mapping for the fixed-length",
"// types (although it seems that all the dynamic-length types,",
"// even those with explicit lengt... | // TypSize returns the size in bytes of the Postgres type specified by
// typOid, where undertood by femebe. For variable-length types or if
// the type is not known, -1 is returned. | [
"TypSize",
"returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"Postgres",
"type",
"specified",
"by",
"typOid",
"where",
"undertood",
"by",
"femebe",
".",
"For",
"variable",
"-",
"length",
"types",
"or",
"if",
"the",
"type",
"is",
"not",
"known",
"-",
... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/proto/oids.go#L6-L27 |
153,952 | atsaki/golang-cloudstack-library | types.go | Set | func (nb *NullBase) Set(value interface{}) error {
nb.valid = false
nb.value = nil
if value == nil {
return nil
}
nb.valid = true
nb.value = value
return nil
} | go | func (nb *NullBase) Set(value interface{}) error {
nb.valid = false
nb.value = nil
if value == nil {
return nil
}
nb.valid = true
nb.value = value
return nil
} | [
"func",
"(",
"nb",
"*",
"NullBase",
")",
"Set",
"(",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"nb",
".",
"valid",
"=",
"false",
"\n",
"nb",
".",
"value",
"=",
"nil",
"\n\n",
"if",
"value",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
... | // Set value. If nil is given, value is cleared. | [
"Set",
"value",
".",
"If",
"nil",
"is",
"given",
"value",
"is",
"cleared",
"."
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L92-L105 |
153,953 | atsaki/golang-cloudstack-library | types.go | String | func (nb NullBase) String() string {
if nb.IsNil() {
return "null"
}
return fmt.Sprint(nb.value)
} | go | func (nb NullBase) String() string {
if nb.IsNil() {
return "null"
}
return fmt.Sprint(nb.value)
} | [
"func",
"(",
"nb",
"NullBase",
")",
"String",
"(",
")",
"string",
"{",
"if",
"nb",
".",
"IsNil",
"(",
")",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprint",
"(",
"nb",
".",
"value",
")",
"\n",
"}"
] | // Return Value as String. If no value is set, return "null". | [
"Return",
"Value",
"as",
"String",
".",
"If",
"no",
"value",
"is",
"set",
"return",
"null",
"."
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L116-L121 |
153,954 | atsaki/golang-cloudstack-library | types.go | Set | func (nb *NullBool) Set(value interface{}) error {
nb.valid = false
nb.value = false
if value == nil {
return nil
}
b, err := strconv.ParseBool(fmt.Sprint(value))
if err != nil {
return err
}
nb.valid = true
nb.value = b
return nil
} | go | func (nb *NullBool) Set(value interface{}) error {
nb.valid = false
nb.value = false
if value == nil {
return nil
}
b, err := strconv.ParseBool(fmt.Sprint(value))
if err != nil {
return err
}
nb.valid = true
nb.value = b
return nil
} | [
"func",
"(",
"nb",
"*",
"NullBool",
")",
"Set",
"(",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"nb",
".",
"valid",
"=",
"false",
"\n",
"nb",
".",
"value",
"=",
"false",
"\n\n",
"if",
"value",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",... | // Set Value. Value is converted by strconv.ParseBool | [
"Set",
"Value",
".",
"Value",
"is",
"converted",
"by",
"strconv",
".",
"ParseBool"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L138-L156 |
153,955 | atsaki/golang-cloudstack-library | types.go | Set | func (ns *NullString) Set(value interface{}) error {
ns.valid = false
ns.value = ""
if value == nil {
return nil
}
ns.valid = true
ns.value = fmt.Sprint(value)
return nil
} | go | func (ns *NullString) Set(value interface{}) error {
ns.valid = false
ns.value = ""
if value == nil {
return nil
}
ns.valid = true
ns.value = fmt.Sprint(value)
return nil
} | [
"func",
"(",
"ns",
"*",
"NullString",
")",
"Set",
"(",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"ns",
".",
"valid",
"=",
"false",
"\n",
"ns",
".",
"value",
"=",
"\"",
"\"",
"\n\n",
"if",
"value",
"==",
"nil",
"{",
"return",
"nil",
"\n",... | // Set Value. Value is converted by fmt.Sprint | [
"Set",
"Value",
".",
"Value",
"is",
"converted",
"by",
"fmt",
".",
"Sprint"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L173-L186 |
153,956 | atsaki/golang-cloudstack-library | types.go | Set | func (nn *NullNumber) Set(value interface{}) error {
nn.valid = false
nn.value = ""
if value == nil {
return nil
}
s := fmt.Sprint(value)
_, err := strconv.ParseFloat(s, 64)
if err != nil {
return err
}
nn.valid = true
nn.value = s
return nil
} | go | func (nn *NullNumber) Set(value interface{}) error {
nn.valid = false
nn.value = ""
if value == nil {
return nil
}
s := fmt.Sprint(value)
_, err := strconv.ParseFloat(s, 64)
if err != nil {
return err
}
nn.valid = true
nn.value = s
return nil
} | [
"func",
"(",
"nn",
"*",
"NullNumber",
")",
"Set",
"(",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"nn",
".",
"valid",
"=",
"false",
"\n",
"nn",
".",
"value",
"=",
"\"",
"\"",
"\n\n",
"if",
"value",
"==",
"nil",
"{",
"return",
"nil",
"\n",... | // Set Value. Value is converted to string by fmt.Sprint | [
"Set",
"Value",
".",
"Value",
"is",
"converted",
"to",
"string",
"by",
"fmt",
".",
"Sprint"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L203-L222 |
153,957 | atsaki/golang-cloudstack-library | types.go | Int64 | func (nn NullNumber) Int64() (int64, error) {
if nn.IsNil() {
return 0, errors.New("NullNumber is nil")
}
return strconv.ParseInt(nn.value.(string), 10, 64)
} | go | func (nn NullNumber) Int64() (int64, error) {
if nn.IsNil() {
return 0, errors.New("NullNumber is nil")
}
return strconv.ParseInt(nn.value.(string), 10, 64)
} | [
"func",
"(",
"nn",
"NullNumber",
")",
"Int64",
"(",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"nn",
".",
"IsNil",
"(",
")",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"strconv",
".",
... | // Return Value as int64 | [
"Return",
"Value",
"as",
"int64"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L225-L230 |
153,958 | atsaki/golang-cloudstack-library | types.go | UInt64 | func (nn NullNumber) UInt64() (uint64, error) {
if nn.IsNil() {
return 0, errors.New("NullNumber is nil")
}
return strconv.ParseUint(nn.value.(string), 10, 64)
} | go | func (nn NullNumber) UInt64() (uint64, error) {
if nn.IsNil() {
return 0, errors.New("NullNumber is nil")
}
return strconv.ParseUint(nn.value.(string), 10, 64)
} | [
"func",
"(",
"nn",
"NullNumber",
")",
"UInt64",
"(",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"nn",
".",
"IsNil",
"(",
")",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"strconv",
".",... | // Return Value as uint64 | [
"Return",
"Value",
"as",
"uint64"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L233-L238 |
153,959 | atsaki/golang-cloudstack-library | types.go | Float64 | func (nn NullNumber) Float64() (float64, error) {
if nn.IsNil() {
return 0, errors.New("NullNumber is nil")
}
return strconv.ParseFloat(nn.value.(string), 64)
} | go | func (nn NullNumber) Float64() (float64, error) {
if nn.IsNil() {
return 0, errors.New("NullNumber is nil")
}
return strconv.ParseFloat(nn.value.(string), 64)
} | [
"func",
"(",
"nn",
"NullNumber",
")",
"Float64",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"if",
"nn",
".",
"IsNil",
"(",
")",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"strconv",
".... | // Return Value as float64 | [
"Return",
"Value",
"as",
"float64"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/types.go#L241-L246 |
153,960 | acoshift/middleware | hsts.go | HSTS | func HSTS(config HSTSConfig) Middleware {
if config.Skipper == nil {
config.Skipper = DefaultSkipper
}
hs := "max-age=" + strconv.FormatInt(int64(config.MaxAge/time.Second), 10)
if config.IncludeSubDomains {
hs += "; includeSubDomains"
}
if config.Preload {
hs += "; preload"
}
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if config.Skipper(r) {
h.ServeHTTP(w, r)
return
}
w.Header().Set("Strict-Transport-Security", hs)
h.ServeHTTP(w, r)
})
}
} | go | func HSTS(config HSTSConfig) Middleware {
if config.Skipper == nil {
config.Skipper = DefaultSkipper
}
hs := "max-age=" + strconv.FormatInt(int64(config.MaxAge/time.Second), 10)
if config.IncludeSubDomains {
hs += "; includeSubDomains"
}
if config.Preload {
hs += "; preload"
}
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if config.Skipper(r) {
h.ServeHTTP(w, r)
return
}
w.Header().Set("Strict-Transport-Security", hs)
h.ServeHTTP(w, r)
})
}
} | [
"func",
"HSTS",
"(",
"config",
"HSTSConfig",
")",
"Middleware",
"{",
"if",
"config",
".",
"Skipper",
"==",
"nil",
"{",
"config",
".",
"Skipper",
"=",
"DefaultSkipper",
"\n",
"}",
"\n\n",
"hs",
":=",
"\"",
"\"",
"+",
"strconv",
".",
"FormatInt",
"(",
"i... | // HSTS creates new HSTS middleware | [
"HSTS",
"creates",
"new",
"HSTS",
"middleware"
] | 72ef9c385871dd1964bcdf6170ce9aefeff90fd8 | https://github.com/acoshift/middleware/blob/72ef9c385871dd1964bcdf6170ce9aefeff90fd8/hsts.go#L35-L58 |
153,961 | uhoh-itsmaciek/femebe | porcelain.go | NewSimpleConnector | func NewSimpleConnector(target string, options map[string]string) Connector {
return &simpleConnector{backendAddr: target, opts: options}
} | go | func NewSimpleConnector(target string, options map[string]string) Connector {
return &simpleConnector{backendAddr: target, opts: options}
} | [
"func",
"NewSimpleConnector",
"(",
"target",
"string",
",",
"options",
"map",
"[",
"string",
"]",
"string",
")",
"Connector",
"{",
"return",
"&",
"simpleConnector",
"{",
"backendAddr",
":",
"target",
",",
"opts",
":",
"options",
"}",
"\n",
"}"
] | // Make a Connector that always prefers TLS and connects using the
// options specified here. | [
"Make",
"a",
"Connector",
"that",
"always",
"prefers",
"TLS",
"and",
"connects",
"using",
"the",
"options",
"specified",
"here",
"."
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/porcelain.go#L139-L141 |
153,962 | uhoh-itsmaciek/femebe | porcelain.go | NewSimpleRouter | func NewSimpleRouter(fe, be core.Stream) Router {
return &simpleRouter{
backendPid: 0,
secretKey: 0,
fe: fe,
be: be,
}
} | go | func NewSimpleRouter(fe, be core.Stream) Router {
return &simpleRouter{
backendPid: 0,
secretKey: 0,
fe: fe,
be: be,
}
} | [
"func",
"NewSimpleRouter",
"(",
"fe",
",",
"be",
"core",
".",
"Stream",
")",
"Router",
"{",
"return",
"&",
"simpleRouter",
"{",
"backendPid",
":",
"0",
",",
"secretKey",
":",
"0",
",",
"fe",
":",
"fe",
",",
"be",
":",
"be",
",",
"}",
"\n",
"}"
] | // Make a new Router that captures cancellation data and ferries
// messages back and forth for the two streams. Flush the "to" stream
// when no more messages are available on the "from" stream, in both
// directions. | [
"Make",
"a",
"new",
"Router",
"that",
"captures",
"cancellation",
"data",
"and",
"ferries",
"messages",
"back",
"and",
"forth",
"for",
"the",
"two",
"streams",
".",
"Flush",
"the",
"to",
"stream",
"when",
"no",
"more",
"messages",
"are",
"available",
"on",
... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/porcelain.go#L199-L206 |
153,963 | uhoh-itsmaciek/femebe | codec/encoding.go | DescribeType | func DescribeType(typ proto.Oid) string {
switch typ {
case proto.OidText, proto.OidVarchar:
return "string"
case proto.OidBytea:
return "[]byte"
case proto.OidTimestamp, proto.OidTimestamptz, proto.OidTime, proto.OidTimetz, proto.OidDate:
return "time.Time"
case proto.OidBool:
return "boolean"
case proto.OidInt8, proto.OidInt4, proto.OidInt2:
return "int64"
case proto.OidFloat4, proto.OidFloat8:
return "float64"
default:
return "unknown"
}
} | go | func DescribeType(typ proto.Oid) string {
switch typ {
case proto.OidText, proto.OidVarchar:
return "string"
case proto.OidBytea:
return "[]byte"
case proto.OidTimestamp, proto.OidTimestamptz, proto.OidTime, proto.OidTimetz, proto.OidDate:
return "time.Time"
case proto.OidBool:
return "boolean"
case proto.OidInt8, proto.OidInt4, proto.OidInt2:
return "int64"
case proto.OidFloat4, proto.OidFloat8:
return "float64"
default:
return "unknown"
}
} | [
"func",
"DescribeType",
"(",
"typ",
"proto",
".",
"Oid",
")",
"string",
"{",
"switch",
"typ",
"{",
"case",
"proto",
".",
"OidText",
",",
"proto",
".",
"OidVarchar",
":",
"return",
"\"",
"\"",
"\n",
"case",
"proto",
".",
"OidBytea",
":",
"return",
"\"",... | // Describe which Go type this Postgres OID will map to in the scheme
// above | [
"Describe",
"which",
"Go",
"type",
"this",
"Postgres",
"OID",
"will",
"map",
"to",
"in",
"the",
"scheme",
"above"
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/codec/encoding.go#L153-L170 |
153,964 | acoshift/middleware | cors.go | CORS | func CORS(config CORSConfig) Middleware {
if config.Skipper == nil {
config.Skipper = DefaultSkipper
}
allowMethods := strings.Join(config.AllowMethods, ",")
allowHeaders := strings.Join(config.AllowHeaders, ",")
exposeHeaders := strings.Join(config.ExposeHeaders, ",")
maxAge := ""
if config.MaxAge > time.Duration(0) {
maxAge = strconv.FormatInt(int64(config.MaxAge/time.Second), 10)
}
allowOrigins := make(map[string]struct{})
for _, v := range config.AllowOrigins {
allowOrigins[v] = struct{}{}
}
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if config.Skipper(r) {
h.ServeHTTP(w, r)
return
}
if origin := r.Header.Get("Origin"); origin != "" {
h := w.Header()
if config.AllowAllOrigins {
h.Set("Access-Control-Allow-Origin", "*")
} else if _, ok := allowOrigins[origin]; ok {
h.Set("Access-Control-Allow-Origin", origin)
} else {
w.WriteHeader(http.StatusForbidden)
return
}
if config.AllowCredentials {
h.Set("Access-Control-Allow-Credentials", "true")
}
if r.Method == http.MethodOptions {
if allowMethods != "" {
h.Set("Access-Control-Allow-Methods", allowMethods)
}
if allowHeaders != "" {
h.Set("Access-Control-Allow-Headers", allowHeaders)
}
if maxAge != "" {
h.Set("Access-Control-Max-Age", maxAge)
}
if !config.AllowAllOrigins {
h.Add("Vary", "Origin")
}
h.Add("Vary", "Access-Control-Request-Method")
h.Add("Vary", "Access-Control-Request-Headers")
w.WriteHeader(http.StatusNoContent)
return
}
if exposeHeaders != "" {
h.Set("Access-Control-Expose-Headers", exposeHeaders)
}
if !config.AllowAllOrigins {
h.Set("Vary", "Origin")
}
}
h.ServeHTTP(w, r)
})
}
} | go | func CORS(config CORSConfig) Middleware {
if config.Skipper == nil {
config.Skipper = DefaultSkipper
}
allowMethods := strings.Join(config.AllowMethods, ",")
allowHeaders := strings.Join(config.AllowHeaders, ",")
exposeHeaders := strings.Join(config.ExposeHeaders, ",")
maxAge := ""
if config.MaxAge > time.Duration(0) {
maxAge = strconv.FormatInt(int64(config.MaxAge/time.Second), 10)
}
allowOrigins := make(map[string]struct{})
for _, v := range config.AllowOrigins {
allowOrigins[v] = struct{}{}
}
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if config.Skipper(r) {
h.ServeHTTP(w, r)
return
}
if origin := r.Header.Get("Origin"); origin != "" {
h := w.Header()
if config.AllowAllOrigins {
h.Set("Access-Control-Allow-Origin", "*")
} else if _, ok := allowOrigins[origin]; ok {
h.Set("Access-Control-Allow-Origin", origin)
} else {
w.WriteHeader(http.StatusForbidden)
return
}
if config.AllowCredentials {
h.Set("Access-Control-Allow-Credentials", "true")
}
if r.Method == http.MethodOptions {
if allowMethods != "" {
h.Set("Access-Control-Allow-Methods", allowMethods)
}
if allowHeaders != "" {
h.Set("Access-Control-Allow-Headers", allowHeaders)
}
if maxAge != "" {
h.Set("Access-Control-Max-Age", maxAge)
}
if !config.AllowAllOrigins {
h.Add("Vary", "Origin")
}
h.Add("Vary", "Access-Control-Request-Method")
h.Add("Vary", "Access-Control-Request-Headers")
w.WriteHeader(http.StatusNoContent)
return
}
if exposeHeaders != "" {
h.Set("Access-Control-Expose-Headers", exposeHeaders)
}
if !config.AllowAllOrigins {
h.Set("Vary", "Origin")
}
}
h.ServeHTTP(w, r)
})
}
} | [
"func",
"CORS",
"(",
"config",
"CORSConfig",
")",
"Middleware",
"{",
"if",
"config",
".",
"Skipper",
"==",
"nil",
"{",
"config",
".",
"Skipper",
"=",
"DefaultSkipper",
"\n",
"}",
"\n\n",
"allowMethods",
":=",
"strings",
".",
"Join",
"(",
"config",
".",
"... | // CORS creates new CORS middleware | [
"CORS",
"creates",
"new",
"CORS",
"middleware"
] | 72ef9c385871dd1964bcdf6170ce9aefeff90fd8 | https://github.com/acoshift/middleware/blob/72ef9c385871dd1964bcdf6170ce9aefeff90fd8/cors.go#L40-L115 |
153,965 | c4milo/handlers | grpcutil/grpc_lz4.go | NewLZ4Compressor | func NewLZ4Compressor() grpc.Compressor {
return &compressor{
alg: "lz4",
pool: sync.Pool{
New: func() interface{} {
return lz4.NewWriter(ioutil.Discard)
},
},
}
} | go | func NewLZ4Compressor() grpc.Compressor {
return &compressor{
alg: "lz4",
pool: sync.Pool{
New: func() interface{} {
return lz4.NewWriter(ioutil.Discard)
},
},
}
} | [
"func",
"NewLZ4Compressor",
"(",
")",
"grpc",
".",
"Compressor",
"{",
"return",
"&",
"compressor",
"{",
"alg",
":",
"\"",
"\"",
",",
"pool",
":",
"sync",
".",
"Pool",
"{",
"New",
":",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"return",
"lz4",
"... | // NewLZ4Compressor returns a new LZ4 compressor instance. | [
"NewLZ4Compressor",
"returns",
"a",
"new",
"LZ4",
"compressor",
"instance",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/grpcutil/grpc_lz4.go#L19-L28 |
153,966 | c4milo/handlers | grpcutil/grpc_lz4.go | NewLZ4Decompressor | func NewLZ4Decompressor() grpc.Decompressor {
return &decompressor{
alg: "lz4",
pool: sync.Pool{
New: func() interface{} {
return lz4.NewReader(nil)
},
},
}
} | go | func NewLZ4Decompressor() grpc.Decompressor {
return &decompressor{
alg: "lz4",
pool: sync.Pool{
New: func() interface{} {
return lz4.NewReader(nil)
},
},
}
} | [
"func",
"NewLZ4Decompressor",
"(",
")",
"grpc",
".",
"Decompressor",
"{",
"return",
"&",
"decompressor",
"{",
"alg",
":",
"\"",
"\"",
",",
"pool",
":",
"sync",
".",
"Pool",
"{",
"New",
":",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"return",
"lz4... | // NewLZ4Decompressor returns a new LZ4 decompressor instance. | [
"NewLZ4Decompressor",
"returns",
"a",
"new",
"LZ4",
"decompressor",
"instance",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/grpcutil/grpc_lz4.go#L52-L61 |
153,967 | atsaki/golang-cloudstack-library | cloudstack.go | getErrorText | func getErrorText(m map[string]json.RawMessage) string {
quoted, ok := m["errortext"]
if !ok {
return ""
}
errortext, err := strconv.Unquote(string(quoted))
if err != nil {
return string(quoted)
}
return errortext
} | go | func getErrorText(m map[string]json.RawMessage) string {
quoted, ok := m["errortext"]
if !ok {
return ""
}
errortext, err := strconv.Unquote(string(quoted))
if err != nil {
return string(quoted)
}
return errortext
} | [
"func",
"getErrorText",
"(",
"m",
"map",
"[",
"string",
"]",
"json",
".",
"RawMessage",
")",
"string",
"{",
"quoted",
",",
"ok",
":=",
"m",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"errortext",
",... | // Get error message from API response | [
"Get",
"error",
"message",
"from",
"API",
"response"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/cloudstack.go#L32-L44 |
153,968 | atsaki/golang-cloudstack-library | cloudstack.go | getObjectJson | func getObjectJson(cmd *Command, resp []byte, isJobResult bool) (objJson []byte, err error) {
var respBody []byte
if isJobResult {
respBody = resp
} else {
respBody, err = getResponseContent(cmd, resp)
if err != nil {
return nil, err
}
if cmd.IsAsync {
// return jobid
return respBody, nil
}
}
switch cmd.ObjectType {
case "result":
return respBody, nil
default:
respBodyMap, err := convertJsonToMap(respBody)
if err != nil {
return nil, err
}
objJson, ok := respBodyMap[cmd.ObjectType]
if !ok {
if errortext := getErrorText(respBodyMap); errortext != "" {
return nil, errors.New(errortext)
}
// respBodyMap can be empty. For example, list api returns nothing.
if len(respBodyMap) == 0 {
return nil, nil
}
// Type can be null. For example, destroyvirtualmachine is executed with expunge=true
if objJson, ok := respBodyMap["null"]; ok {
return objJson, nil
}
return nil, fmt.Errorf(
"Unexpected format: response doesn't contain %s or errortext",
cmd.ObjectType)
}
return objJson, nil
}
} | go | func getObjectJson(cmd *Command, resp []byte, isJobResult bool) (objJson []byte, err error) {
var respBody []byte
if isJobResult {
respBody = resp
} else {
respBody, err = getResponseContent(cmd, resp)
if err != nil {
return nil, err
}
if cmd.IsAsync {
// return jobid
return respBody, nil
}
}
switch cmd.ObjectType {
case "result":
return respBody, nil
default:
respBodyMap, err := convertJsonToMap(respBody)
if err != nil {
return nil, err
}
objJson, ok := respBodyMap[cmd.ObjectType]
if !ok {
if errortext := getErrorText(respBodyMap); errortext != "" {
return nil, errors.New(errortext)
}
// respBodyMap can be empty. For example, list api returns nothing.
if len(respBodyMap) == 0 {
return nil, nil
}
// Type can be null. For example, destroyvirtualmachine is executed with expunge=true
if objJson, ok := respBodyMap["null"]; ok {
return objJson, nil
}
return nil, fmt.Errorf(
"Unexpected format: response doesn't contain %s or errortext",
cmd.ObjectType)
}
return objJson, nil
}
} | [
"func",
"getObjectJson",
"(",
"cmd",
"*",
"Command",
",",
"resp",
"[",
"]",
"byte",
",",
"isJobResult",
"bool",
")",
"(",
"objJson",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"respBody",
"[",
"]",
"byte",
"\n\n",
"if",
"isJobResult",
"{... | // Get content from API response | [
"Get",
"content",
"from",
"API",
"response"
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/cloudstack.go#L78-L123 |
153,969 | uhoh-itsmaciek/femebe | buf/buffer.go | WriteInt16 | func WriteInt16(w io.Writer, val int16) (n int, err error) {
var be [2]byte
valBytes := be[0:2]
binary.BigEndian.PutUint16(valBytes, uint16(val))
return w.Write(valBytes)
} | go | func WriteInt16(w io.Writer, val int16) (n int, err error) {
var be [2]byte
valBytes := be[0:2]
binary.BigEndian.PutUint16(valBytes, uint16(val))
return w.Write(valBytes)
} | [
"func",
"WriteInt16",
"(",
"w",
"io",
".",
"Writer",
",",
"val",
"int16",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"var",
"be",
"[",
"2",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"2",
"]",
"\n",
"binary",
".",
"Bi... | // WriteInt16 writes the bytes of the int16 val to the io.Writer w
// in big-endian byte order. It returns the number of bytes written
// and any error encountered in writing. Like io.Writer, it will
// return a non-nil error if not all bytes are written. | [
"WriteInt16",
"writes",
"the",
"bytes",
"of",
"the",
"int16",
"val",
"to",
"the",
"io",
".",
"Writer",
"w",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"written",
"and",
"any",
"error",
"encountered"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L13-L18 |
153,970 | uhoh-itsmaciek/femebe | buf/buffer.go | WriteInt32 | func WriteInt32(w io.Writer, val int32) (n int, err error) {
return WriteUint32(w, uint32(val))
} | go | func WriteInt32(w io.Writer, val int32) (n int, err error) {
return WriteUint32(w, uint32(val))
} | [
"func",
"WriteInt32",
"(",
"w",
"io",
".",
"Writer",
",",
"val",
"int32",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"WriteUint32",
"(",
"w",
",",
"uint32",
"(",
"val",
")",
")",
"\n",
"}"
] | // WriteInt32 writes the bytes of the int32 val to the io.Writer w
// in big-endian byte order. It returns the number of bytes written
// and any error encountered in writing. Like io.Writer, it will
// return a non-nil error if not all bytes are written. | [
"WriteInt32",
"writes",
"the",
"bytes",
"of",
"the",
"int32",
"val",
"to",
"the",
"io",
".",
"Writer",
"w",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"written",
"and",
"any",
"error",
"encountered"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L24-L26 |
153,971 | uhoh-itsmaciek/femebe | buf/buffer.go | WriteUint32 | func WriteUint32(w io.Writer, val uint32) (n int, err error) {
var be [4]byte
valBytes := be[0:4]
binary.BigEndian.PutUint32(valBytes, val)
return w.Write(valBytes)
} | go | func WriteUint32(w io.Writer, val uint32) (n int, err error) {
var be [4]byte
valBytes := be[0:4]
binary.BigEndian.PutUint32(valBytes, val)
return w.Write(valBytes)
} | [
"func",
"WriteUint32",
"(",
"w",
"io",
".",
"Writer",
",",
"val",
"uint32",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"var",
"be",
"[",
"4",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"4",
"]",
"\n",
"binary",
".",
"... | // WriteUint32 writes the bytes of the uint32 val to the io.Writer w
// in big-endian byte order. It returns the number of bytes written
// and any error encountered in writing. Like io.Writer, it will
// return a non-nil error if not all bytes are written. | [
"WriteUint32",
"writes",
"the",
"bytes",
"of",
"the",
"uint32",
"val",
"to",
"the",
"io",
".",
"Writer",
"w",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"written",
"and",
"any",
"error",
"encountere... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L32-L38 |
153,972 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadInt16 | func ReadInt16(r io.Reader) (int16, error) {
var be [2]byte
valBytes := be[0:2]
if _, err := io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return int16(binary.BigEndian.Uint16(valBytes)), nil
} | go | func ReadInt16(r io.Reader) (int16, error) {
var be [2]byte
valBytes := be[0:2]
if _, err := io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return int16(binary.BigEndian.Uint16(valBytes)), nil
} | [
"func",
"ReadInt16",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int16",
",",
"error",
")",
"{",
"var",
"be",
"[",
"2",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"2",
"]",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull"... | // ReadInt16 reads a 16-bit signed integer from the io.Reader r in
// big-endian byte order. Note that if an error is encountered when
// reading, it will be returned along with the value 0. An EOF error
// is returned when no bytes could be read; an UnexpectedEOF if some
// bytes were read first. | [
"ReadInt16",
"reads",
"a",
"16",
"-",
"bit",
"signed",
"integer",
"from",
"the",
"io",
".",
"Reader",
"r",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"Note",
"that",
"if",
"an",
"error",
"is",
"encountered",
"when",
"reading",
"it",
"will",
"be"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L58-L66 |
153,973 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadUint16 | func ReadUint16(r io.Reader) (uint16, error) {
var be [2]byte
valBytes := be[0:2]
if _, err := io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return uint16(binary.BigEndian.Uint16(valBytes)), nil
} | go | func ReadUint16(r io.Reader) (uint16, error) {
var be [2]byte
valBytes := be[0:2]
if _, err := io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return uint16(binary.BigEndian.Uint16(valBytes)), nil
} | [
"func",
"ReadUint16",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"uint16",
",",
"error",
")",
"{",
"var",
"be",
"[",
"2",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"2",
"]",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFul... | // ReadUint16 reads a 16-bit unsigned integer from the io.Reader r in
// big-endian byte order. Note that if an error is encountered when
// reading, it will be returned along with the value 0. An EOF error
// is returned when no bytes could be read; an UnexpectedEOF if some
// bytes were read first. | [
"ReadUint16",
"reads",
"a",
"16",
"-",
"bit",
"unsigned",
"integer",
"from",
"the",
"io",
".",
"Reader",
"r",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"Note",
"that",
"if",
"an",
"error",
"is",
"encountered",
"when",
"reading",
"it",
"will",
"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L73-L81 |
153,974 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadInt32 | func ReadInt32(r io.Reader) (int32, error) {
var be [4]byte
valBytes := be[0:4]
if _, err := io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return int32(binary.BigEndian.Uint32(valBytes)), nil
} | go | func ReadInt32(r io.Reader) (int32, error) {
var be [4]byte
valBytes := be[0:4]
if _, err := io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return int32(binary.BigEndian.Uint32(valBytes)), nil
} | [
"func",
"ReadInt32",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int32",
",",
"error",
")",
"{",
"var",
"be",
"[",
"4",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"4",
"]",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull"... | // ReadInt32 reads a 32-bit signed integer from the io.Reader r in
// big-endian byte order. Note that if an error is encountered when
// reading, it will be returned along with the value 0. An EOF error
// is returned when no bytes could be read; an UnexpectedEOF if some
// bytes were read first. | [
"ReadInt32",
"reads",
"a",
"32",
"-",
"bit",
"signed",
"integer",
"from",
"the",
"io",
".",
"Reader",
"r",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"Note",
"that",
"if",
"an",
"error",
"is",
"encountered",
"when",
"reading",
"it",
"will",
"be"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L88-L96 |
153,975 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadUint32 | func ReadUint32(r io.Reader) (ret uint32, err error) {
var be [4]byte
valBytes := be[0:4]
if _, err = io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return binary.BigEndian.Uint32(valBytes), nil
} | go | func ReadUint32(r io.Reader) (ret uint32, err error) {
var be [4]byte
valBytes := be[0:4]
if _, err = io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return binary.BigEndian.Uint32(valBytes), nil
} | [
"func",
"ReadUint32",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"ret",
"uint32",
",",
"err",
"error",
")",
"{",
"var",
"be",
"[",
"4",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"4",
"]",
"\n",
"if",
"_",
",",
"err",
"=",
"io",
... | // ReadUint32 reads a 32-bit unsigned integer from the io.Reader r in
// big-endian byte order. Note that if an error is encountered when
// reading, it will be returned along with the value 0. An EOF error
// is returned when no bytes could be read; an UnexpectedEOF if some
// bytes were read first. | [
"ReadUint32",
"reads",
"a",
"32",
"-",
"bit",
"unsigned",
"integer",
"from",
"the",
"io",
".",
"Reader",
"r",
"in",
"big",
"-",
"endian",
"byte",
"order",
".",
"Note",
"that",
"if",
"an",
"error",
"is",
"encountered",
"when",
"reading",
"it",
"will",
"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L103-L111 |
153,976 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadUint32FromBuffer | func ReadUint32FromBuffer(r *bytes.Buffer) uint32 {
return binary.BigEndian.Uint32(r.Next(4))
} | go | func ReadUint32FromBuffer(r *bytes.Buffer) uint32 {
return binary.BigEndian.Uint32(r.Next(4))
} | [
"func",
"ReadUint32FromBuffer",
"(",
"r",
"*",
"bytes",
".",
"Buffer",
")",
"uint32",
"{",
"return",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"r",
".",
"Next",
"(",
"4",
")",
")",
"\n",
"}"
] | // ReadUint32FromBuffer reads a 32-bit unsigned integer from the
// bytes.Buffer r in big-endian byte order. | [
"ReadUint32FromBuffer",
"reads",
"a",
"32",
"-",
"bit",
"unsigned",
"integer",
"from",
"the",
"bytes",
".",
"Buffer",
"r",
"in",
"big",
"-",
"endian",
"byte",
"order",
"."
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L115-L117 |
153,977 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadCString | func ReadCString(r io.Reader) (s string, err error) {
var be [1]byte
charBuf := be[0:1]
var accum bytes.Buffer
for {
n, err := r.Read(charBuf)
if err != nil {
return "", err
}
// Handle the case of no error, yet no bytes were
// retrieved.
if n < 1 {
continue
}
switch charBuf[0] {
case '\000':
return string(accum.Bytes()), nil
default:
accum.Write(charBuf)
}
}
} | go | func ReadCString(r io.Reader) (s string, err error) {
var be [1]byte
charBuf := be[0:1]
var accum bytes.Buffer
for {
n, err := r.Read(charBuf)
if err != nil {
return "", err
}
// Handle the case of no error, yet no bytes were
// retrieved.
if n < 1 {
continue
}
switch charBuf[0] {
case '\000':
return string(accum.Bytes()), nil
default:
accum.Write(charBuf)
}
}
} | [
"func",
"ReadCString",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"s",
"string",
",",
"err",
"error",
")",
"{",
"var",
"be",
"[",
"1",
"]",
"byte",
"\n",
"charBuf",
":=",
"be",
"[",
"0",
":",
"1",
"]",
"\n\n",
"var",
"accum",
"bytes",
".",
"Buffe... | // ReadCString reads a null-terminated string in UTF-8 encoding from
// the io.Reader r. If an error is encountered in decoding, it returns
// an empty string and the error. | [
"ReadCString",
"reads",
"a",
"null",
"-",
"terminated",
"string",
"in",
"UTF",
"-",
"8",
"encoding",
"from",
"the",
"io",
".",
"Reader",
"r",
".",
"If",
"an",
"error",
"is",
"encountered",
"in",
"decoding",
"it",
"returns",
"an",
"empty",
"string",
"and"... | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L122-L148 |
153,978 | uhoh-itsmaciek/femebe | buf/buffer.go | ReadByte | func ReadByte(r io.Reader) (ret byte, err error) {
var be [1]byte
valBytes := be[0:1]
if _, err = io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return valBytes[0], nil
} | go | func ReadByte(r io.Reader) (ret byte, err error) {
var be [1]byte
valBytes := be[0:1]
if _, err = io.ReadFull(r, valBytes); err != nil {
return 0, err
}
return valBytes[0], nil
} | [
"func",
"ReadByte",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"ret",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"be",
"[",
"1",
"]",
"byte",
"\n",
"valBytes",
":=",
"be",
"[",
"0",
":",
"1",
"]",
"\n\n",
"if",
"_",
",",
"err",
"=",
"io",
... | // ReadByte reads a single byte from the io.Reader r. If an error is
// encountered in reading, it returns 0 and the error. | [
"ReadByte",
"reads",
"a",
"single",
"byte",
"from",
"the",
"io",
".",
"Reader",
"r",
".",
"If",
"an",
"error",
"is",
"encountered",
"in",
"reading",
"it",
"returns",
"0",
"and",
"the",
"error",
"."
] | 78f00f2ef7b41255fe56120e95887461adb2aa38 | https://github.com/uhoh-itsmaciek/femebe/blob/78f00f2ef7b41255fe56120e95887461adb2aa38/buf/buffer.go#L152-L161 |
153,979 | atsaki/golang-cloudstack-library | VirtualMachineApi.go | DestroyVirtualMachine | func (c *Client) DestroyVirtualMachine(p *DestroyVirtualMachineParameter) (*VirtualMachine, error) {
obj, err := c.Request("destroyVirtualMachine", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*VirtualMachine), err
} | go | func (c *Client) DestroyVirtualMachine(p *DestroyVirtualMachineParameter) (*VirtualMachine, error) {
obj, err := c.Request("destroyVirtualMachine", convertParamToMap(p))
if err != nil {
return nil, err
}
return obj.(*VirtualMachine), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DestroyVirtualMachine",
"(",
"p",
"*",
"DestroyVirtualMachineParameter",
")",
"(",
"*",
"VirtualMachine",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Request",
"(",
"\"",
"\"",
",",
"convertParamToMap"... | // Destroys a virtual machine. Once destroyed, only the administrator can
// recover it. | [
"Destroys",
"a",
"virtual",
"machine",
".",
"Once",
"destroyed",
"only",
"the",
"administrator",
"can",
"recover",
"it",
"."
] | 81da56f938156dd18edfce7a3ff15c0f77b47bfb | https://github.com/atsaki/golang-cloudstack-library/blob/81da56f938156dd18edfce7a3ff15c0f77b47bfb/VirtualMachineApi.go#L619-L625 |
153,980 | tv42/birpc | birpc.go | RegisterService | func (r *Registry) RegisterService(object interface{}) {
methods, err := getRPCMethodsOfType(object)
if err != nil {
// programmer error
panic(err)
}
serviceName := reflect.Indirect(reflect.ValueOf(object)).Type().Name()
r.mu.Lock()
defer r.mu.Unlock()
for _, fn := range methods {
name := serviceName + "." + fn.method.Name
r.functions[name] = fn
}
} | go | func (r *Registry) RegisterService(object interface{}) {
methods, err := getRPCMethodsOfType(object)
if err != nil {
// programmer error
panic(err)
}
serviceName := reflect.Indirect(reflect.ValueOf(object)).Type().Name()
r.mu.Lock()
defer r.mu.Unlock()
for _, fn := range methods {
name := serviceName + "." + fn.method.Name
r.functions[name] = fn
}
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"RegisterService",
"(",
"object",
"interface",
"{",
"}",
")",
"{",
"methods",
",",
"err",
":=",
"getRPCMethodsOfType",
"(",
"object",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// programmer error",
"panic",
"(",
"... | // RegisterService registers all exported methods of service, allowing
// them to be called remotely. The name of the methods will be of the
// format SERVICE.METHOD, where SERVICE is the type name or the object
// passed in, and METHOD is the name of each method.
//
// The methods are expect to have at least two arguments, referred to
// as args and reply. Reply should be a pointer type, and the method
// should fill it with the result. The types used are limited only by
// the codec needing to be able to marshal them for transport. For
// example, for wetsock the args and reply must marshal to JSON.
//
// Rest of the arguments are filled on best-effort basis, if their
// types are known to birpc and the codec in use.
//
// The methods should have return type error. | [
"RegisterService",
"registers",
"all",
"exported",
"methods",
"of",
"service",
"allowing",
"them",
"to",
"be",
"called",
"remotely",
".",
"The",
"name",
"of",
"the",
"methods",
"will",
"be",
"of",
"the",
"format",
"SERVICE",
".",
"METHOD",
"where",
"SERVICE",
... | 22dcbfff0024e83a23cb42c800c1523a3ba08a4c | https://github.com/tv42/birpc/blob/22dcbfff0024e83a23cb42c800c1523a3ba08a4c/birpc.go#L99-L115 |
153,981 | tv42/birpc | birpc.go | NewRegistry | func NewRegistry() *Registry {
r := &Registry{}
r.functions = make(map[string]*function)
return r
} | go | func NewRegistry() *Registry {
r := &Registry{}
r.functions = make(map[string]*function)
return r
} | [
"func",
"NewRegistry",
"(",
")",
"*",
"Registry",
"{",
"r",
":=",
"&",
"Registry",
"{",
"}",
"\n",
"r",
".",
"functions",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"function",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // NewRegistry creates a new Registry. | [
"NewRegistry",
"creates",
"a",
"new",
"Registry",
"."
] | 22dcbfff0024e83a23cb42c800c1523a3ba08a4c | https://github.com/tv42/birpc/blob/22dcbfff0024e83a23cb42c800c1523a3ba08a4c/birpc.go#L118-L122 |
153,982 | tv42/birpc | birpc.go | NewEndpoint | func NewEndpoint(codec Codec, registry *Registry) *Endpoint {
if registry == nil {
registry = dummyRegistry
}
e := &Endpoint{}
e.codec = codec
e.server.registry = registry
e.client.pending = make(map[uint64]*rpc.Call)
return e
} | go | func NewEndpoint(codec Codec, registry *Registry) *Endpoint {
if registry == nil {
registry = dummyRegistry
}
e := &Endpoint{}
e.codec = codec
e.server.registry = registry
e.client.pending = make(map[uint64]*rpc.Call)
return e
} | [
"func",
"NewEndpoint",
"(",
"codec",
"Codec",
",",
"registry",
"*",
"Registry",
")",
"*",
"Endpoint",
"{",
"if",
"registry",
"==",
"nil",
"{",
"registry",
"=",
"dummyRegistry",
"\n",
"}",
"\n",
"e",
":=",
"&",
"Endpoint",
"{",
"}",
"\n",
"e",
".",
"c... | // NewEndpoint creates a new endpoint that uses codec to talk to a
// peer. To actually process messages, call endpoint.Serve; this is
// done so you can capture errors. Registry can be nil to serve no
// callables from this peer. | [
"NewEndpoint",
"creates",
"a",
"new",
"endpoint",
"that",
"uses",
"codec",
"to",
"talk",
"to",
"a",
"peer",
".",
"To",
"actually",
"process",
"messages",
"call",
"endpoint",
".",
"Serve",
";",
"this",
"is",
"done",
"so",
"you",
"can",
"capture",
"errors",
... | 22dcbfff0024e83a23cb42c800c1523a3ba08a4c | https://github.com/tv42/birpc/blob/22dcbfff0024e83a23cb42c800c1523a3ba08a4c/birpc.go#L176-L185 |
153,983 | tv42/birpc | birpc.go | Serve | func (e *Endpoint) Serve() error {
defer e.codec.Close()
defer e.server.running.Wait()
for {
var msg Message
err := e.codec.ReadMessage(&msg)
if err != nil {
return err
}
if msg.Func != "" {
err = e.serve_request(&msg)
} else {
err = e.serve_response(&msg)
}
if err != nil {
return err
}
}
} | go | func (e *Endpoint) Serve() error {
defer e.codec.Close()
defer e.server.running.Wait()
for {
var msg Message
err := e.codec.ReadMessage(&msg)
if err != nil {
return err
}
if msg.Func != "" {
err = e.serve_request(&msg)
} else {
err = e.serve_response(&msg)
}
if err != nil {
return err
}
}
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"Serve",
"(",
")",
"error",
"{",
"defer",
"e",
".",
"codec",
".",
"Close",
"(",
")",
"\n",
"defer",
"e",
".",
"server",
".",
"running",
".",
"Wait",
"(",
")",
"\n",
"for",
"{",
"var",
"msg",
"Message",
"\... | // Serve messages from this connection. Serve blocks, serving the
// connection until the client disconnects, or there is an error. | [
"Serve",
"messages",
"from",
"this",
"connection",
".",
"Serve",
"blocks",
"serving",
"the",
"connection",
"until",
"the",
"client",
"disconnects",
"or",
"there",
"is",
"an",
"error",
"."
] | 22dcbfff0024e83a23cb42c800c1523a3ba08a4c | https://github.com/tv42/birpc/blob/22dcbfff0024e83a23cb42c800c1523a3ba08a4c/birpc.go#L244-L263 |
153,984 | megamsys/libgo | os/os_linux.go | ReadRelease | func ReadRelease(f string) (map[string]string, error) {
stream, err := ioutil.ReadFile(osFile)
if err != nil {
return nil, err
}
values := make(map[string]string)
releaseDetail := strings.Split(string(stream), " ")
values["ID"] = releaseDetail[0]
values["VERSION_ID"] = releaseDetail[2]
id, ok := values["ID"]
if !ok {
return nil, errors.New("OS release file is missing ID")
}
if _, ok := values["VERSION_ID"]; !ok {
values["VERSION_ID"], ok = defaultVersionIDs[id]
if !ok {
return nil, errors.New("OS release file is missing VERSION_ID")
}
}
return values, nil
} | go | func ReadRelease(f string) (map[string]string, error) {
stream, err := ioutil.ReadFile(osFile)
if err != nil {
return nil, err
}
values := make(map[string]string)
releaseDetail := strings.Split(string(stream), " ")
values["ID"] = releaseDetail[0]
values["VERSION_ID"] = releaseDetail[2]
id, ok := values["ID"]
if !ok {
return nil, errors.New("OS release file is missing ID")
}
if _, ok := values["VERSION_ID"]; !ok {
values["VERSION_ID"], ok = defaultVersionIDs[id]
if !ok {
return nil, errors.New("OS release file is missing VERSION_ID")
}
}
return values, nil
} | [
"func",
"ReadRelease",
"(",
"f",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"stream",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"osFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
... | // ReadRelease parses the information in the redhat-release file. | [
"ReadRelease",
"parses",
"the",
"information",
"in",
"the",
"redhat",
"-",
"release",
"file",
"."
] | 101454b20f1af0541edb9391c75724e6c0143562 | https://github.com/megamsys/libgo/blob/101454b20f1af0541edb9391c75724e6c0143562/os/os_linux.go#L93-L113 |
153,985 | c4milo/handlers | grpcutil/grpc_handler.go | WithServerOpts | func WithServerOpts(opts []grpc.ServerOption) Option {
return func(o *options) {
o.serverOpts = opts
}
} | go | func WithServerOpts(opts []grpc.ServerOption) Option {
return func(o *options) {
o.serverOpts = opts
}
} | [
"func",
"WithServerOpts",
"(",
"opts",
"[",
"]",
"grpc",
".",
"ServerOption",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"options",
")",
"{",
"o",
".",
"serverOpts",
"=",
"opts",
"\n",
"}",
"\n",
"}"
] | // WithServerOpts sets gRPC server options. Optional. | [
"WithServerOpts",
"sets",
"gRPC",
"server",
"options",
".",
"Optional",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/grpcutil/grpc_handler.go#L42-L46 |
153,986 | c4milo/handlers | grpcutil/grpc_handler.go | WithGWServerOpts | func WithGWServerOpts(opts []runtime.ServeMuxOption) Option {
return func(o *options) {
o.gwServerOpts = opts
}
} | go | func WithGWServerOpts(opts []runtime.ServeMuxOption) Option {
return func(o *options) {
o.gwServerOpts = opts
}
} | [
"func",
"WithGWServerOpts",
"(",
"opts",
"[",
"]",
"runtime",
".",
"ServeMuxOption",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"options",
")",
"{",
"o",
".",
"gwServerOpts",
"=",
"opts",
"\n",
"}",
"\n",
"}"
] | // WithGWServerOpts sets GRPC Gateway server options. Optional. | [
"WithGWServerOpts",
"sets",
"GRPC",
"Gateway",
"server",
"options",
".",
"Optional",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/grpcutil/grpc_handler.go#L49-L53 |
153,987 | c4milo/handlers | grpcutil/grpc_handler.go | WithTLSCert | func WithTLSCert(cert *tls.Certificate) Option {
return func(o *options) {
o.cert = cert
}
} | go | func WithTLSCert(cert *tls.Certificate) Option {
return func(o *options) {
o.cert = cert
}
} | [
"func",
"WithTLSCert",
"(",
"cert",
"*",
"tls",
".",
"Certificate",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"options",
")",
"{",
"o",
".",
"cert",
"=",
"cert",
"\n",
"}",
"\n",
"}"
] | // WithTLSCert sets the TLS certificate to use by the gRPC server and OpenAPI gRPC client. Required. | [
"WithTLSCert",
"sets",
"the",
"TLS",
"certificate",
"to",
"use",
"by",
"the",
"gRPC",
"server",
"and",
"OpenAPI",
"gRPC",
"client",
".",
"Required",
"."
] | ea1b5d30c5ba55fdc1d737d0222daccb3d98d057 | https://github.com/c4milo/handlers/blob/ea1b5d30c5ba55fdc1d737d0222daccb3d98d057/grpcutil/grpc_handler.go#L63-L67 |
153,988 | acoshift/middleware | csrf.go | CSRF | func CSRF(c CSRFConfig) func(http.Handler) http.Handler {
if c.ForbiddenHandler == nil {
c.ForbiddenHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Forbidden", http.StatusForbidden)
})
}
normalize := func(s string) (string, bool) {
return s, true
}
origins := make([]string, len(c.Origins))
copy(origins, c.Origins)
if c.IgnoreProto {
for i := range origins {
origins[i], _ = removeProto(origins[i])
}
normalize = removeProto
}
checkOrigin := func(r *http.Request) bool {
origin := r.Header.Get("Origin")
if c.Force || origin != "" {
origin, b := normalize(origin)
if !b {
return false
}
for _, allow := range origins {
if origin == allow {
return true
}
}
return false
}
return true
}
checkReferer := func(r *http.Request) bool {
referer := r.Referer()
if c.Force || referer != "" {
referer, b := normalize(referer)
if !b {
return false
}
for _, allow := range origins {
if strings.HasPrefix(referer, allow+"/") {
return true
}
}
return false
}
return true
}
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
if !checkOrigin(r) || !checkReferer(r) {
c.ForbiddenHandler.ServeHTTP(w, r)
return
}
}
h.ServeHTTP(w, r)
})
}
} | go | func CSRF(c CSRFConfig) func(http.Handler) http.Handler {
if c.ForbiddenHandler == nil {
c.ForbiddenHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Forbidden", http.StatusForbidden)
})
}
normalize := func(s string) (string, bool) {
return s, true
}
origins := make([]string, len(c.Origins))
copy(origins, c.Origins)
if c.IgnoreProto {
for i := range origins {
origins[i], _ = removeProto(origins[i])
}
normalize = removeProto
}
checkOrigin := func(r *http.Request) bool {
origin := r.Header.Get("Origin")
if c.Force || origin != "" {
origin, b := normalize(origin)
if !b {
return false
}
for _, allow := range origins {
if origin == allow {
return true
}
}
return false
}
return true
}
checkReferer := func(r *http.Request) bool {
referer := r.Referer()
if c.Force || referer != "" {
referer, b := normalize(referer)
if !b {
return false
}
for _, allow := range origins {
if strings.HasPrefix(referer, allow+"/") {
return true
}
}
return false
}
return true
}
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
if !checkOrigin(r) || !checkReferer(r) {
c.ForbiddenHandler.ServeHTTP(w, r)
return
}
}
h.ServeHTTP(w, r)
})
}
} | [
"func",
"CSRF",
"(",
"c",
"CSRFConfig",
")",
"func",
"(",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"if",
"c",
".",
"ForbiddenHandler",
"==",
"nil",
"{",
"c",
".",
"ForbiddenHandler",
"=",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
... | // CSRF creates new csrf middleware | [
"CSRF",
"creates",
"new",
"csrf",
"middleware"
] | 72ef9c385871dd1964bcdf6170ce9aefeff90fd8 | https://github.com/acoshift/middleware/blob/72ef9c385871dd1964bcdf6170ce9aefeff90fd8/csrf.go#L17-L89 |
153,989 | contactless/org.eclipse.paho.mqtt.golang | packets/packets.go | NewControlPacket | func NewControlPacket(packetType byte) (cp ControlPacket) {
switch packetType {
case Connect:
cp = &ConnectPacket{FixedHeader: &FixedHeader{MessageType: Connect}}
case Connack:
cp = &ConnackPacket{FixedHeader: &FixedHeader{MessageType: Connack}}
case Disconnect:
cp = &DisconnectPacket{FixedHeader: &FixedHeader{MessageType: Disconnect}}
case Publish:
cp = &PublishPacket{FixedHeader: &FixedHeader{MessageType: Publish}}
case Puback:
cp = &PubackPacket{FixedHeader: &FixedHeader{MessageType: Puback}}
case Pubrec:
cp = &PubrecPacket{FixedHeader: &FixedHeader{MessageType: Pubrec}}
case Pubrel:
cp = &PubrelPacket{FixedHeader: &FixedHeader{MessageType: Pubrel, Qos: 1}}
case Pubcomp:
cp = &PubcompPacket{FixedHeader: &FixedHeader{MessageType: Pubcomp}}
case Subscribe:
cp = &SubscribePacket{FixedHeader: &FixedHeader{MessageType: Subscribe, Qos: 1}}
case Suback:
cp = &SubackPacket{FixedHeader: &FixedHeader{MessageType: Suback}}
case Unsubscribe:
cp = &UnsubscribePacket{FixedHeader: &FixedHeader{MessageType: Unsubscribe, Qos: 1}}
case Unsuback:
cp = &UnsubackPacket{FixedHeader: &FixedHeader{MessageType: Unsuback}}
case Pingreq:
cp = &PingreqPacket{FixedHeader: &FixedHeader{MessageType: Pingreq}}
case Pingresp:
cp = &PingrespPacket{FixedHeader: &FixedHeader{MessageType: Pingresp}}
default:
return nil
}
return cp
} | go | func NewControlPacket(packetType byte) (cp ControlPacket) {
switch packetType {
case Connect:
cp = &ConnectPacket{FixedHeader: &FixedHeader{MessageType: Connect}}
case Connack:
cp = &ConnackPacket{FixedHeader: &FixedHeader{MessageType: Connack}}
case Disconnect:
cp = &DisconnectPacket{FixedHeader: &FixedHeader{MessageType: Disconnect}}
case Publish:
cp = &PublishPacket{FixedHeader: &FixedHeader{MessageType: Publish}}
case Puback:
cp = &PubackPacket{FixedHeader: &FixedHeader{MessageType: Puback}}
case Pubrec:
cp = &PubrecPacket{FixedHeader: &FixedHeader{MessageType: Pubrec}}
case Pubrel:
cp = &PubrelPacket{FixedHeader: &FixedHeader{MessageType: Pubrel, Qos: 1}}
case Pubcomp:
cp = &PubcompPacket{FixedHeader: &FixedHeader{MessageType: Pubcomp}}
case Subscribe:
cp = &SubscribePacket{FixedHeader: &FixedHeader{MessageType: Subscribe, Qos: 1}}
case Suback:
cp = &SubackPacket{FixedHeader: &FixedHeader{MessageType: Suback}}
case Unsubscribe:
cp = &UnsubscribePacket{FixedHeader: &FixedHeader{MessageType: Unsubscribe, Qos: 1}}
case Unsuback:
cp = &UnsubackPacket{FixedHeader: &FixedHeader{MessageType: Unsuback}}
case Pingreq:
cp = &PingreqPacket{FixedHeader: &FixedHeader{MessageType: Pingreq}}
case Pingresp:
cp = &PingrespPacket{FixedHeader: &FixedHeader{MessageType: Pingresp}}
default:
return nil
}
return cp
} | [
"func",
"NewControlPacket",
"(",
"packetType",
"byte",
")",
"(",
"cp",
"ControlPacket",
")",
"{",
"switch",
"packetType",
"{",
"case",
"Connect",
":",
"cp",
"=",
"&",
"ConnectPacket",
"{",
"FixedHeader",
":",
"&",
"FixedHeader",
"{",
"MessageType",
":",
"Con... | //NewControlPacket is used to create a new ControlPacket of the type specified
//by packetType, this is usually done by reference to the packet type constants
//defined in packets.go. The newly created ControlPacket is empty and a pointer
//is returned. | [
"NewControlPacket",
"is",
"used",
"to",
"create",
"a",
"new",
"ControlPacket",
"of",
"the",
"type",
"specified",
"by",
"packetType",
"this",
"is",
"usually",
"done",
"by",
"reference",
"to",
"the",
"packet",
"type",
"constants",
"defined",
"in",
"packets",
"."... | bc107ec72972f0e7048787415ea061578b5c3f33 | https://github.com/contactless/org.eclipse.paho.mqtt.golang/blob/bc107ec72972f0e7048787415ea061578b5c3f33/packets/packets.go#L145-L179 |
153,990 | gyuho/dataframe | value_time.go | NewTimeValue | func NewTimeValue(v interface{}) Value {
switch t := v.(type) {
case time.Time:
return GoTime(t)
default:
panic(fmt.Errorf("%v(%T) is not supported yet", v, v))
}
} | go | func NewTimeValue(v interface{}) Value {
switch t := v.(type) {
case time.Time:
return GoTime(t)
default:
panic(fmt.Errorf("%v(%T) is not supported yet", v, v))
}
} | [
"func",
"NewTimeValue",
"(",
"v",
"interface",
"{",
"}",
")",
"Value",
"{",
"switch",
"t",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"time",
".",
"Time",
":",
"return",
"GoTime",
"(",
"t",
")",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",... | // NewTimeValue takes any interface and returns Value. | [
"NewTimeValue",
"takes",
"any",
"interface",
"and",
"returns",
"Value",
"."
] | 008fc241adc41d4bd5c54b9f6564ef16407c030e | https://github.com/gyuho/dataframe/blob/008fc241adc41d4bd5c54b9f6564ef16407c030e/value_time.go#L12-L19 |
153,991 | gocontrib/auth | middleware.go | RequireUser | func RequireUser(config *Config) func(http.Handler) http.Handler {
config = config.SetDefaults()
return func(next http.Handler) http.Handler {
return &middleware{
config: config,
next: next,
}
}
} | go | func RequireUser(config *Config) func(http.Handler) http.Handler {
config = config.SetDefaults()
return func(next http.Handler) http.Handler {
return &middleware{
config: config,
next: next,
}
}
} | [
"func",
"RequireUser",
"(",
"config",
"*",
"Config",
")",
"func",
"(",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"config",
"=",
"config",
".",
"SetDefaults",
"(",
")",
"\n",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
... | // RequireUser creates auth middleware with given configuration. | [
"RequireUser",
"creates",
"auth",
"middleware",
"with",
"given",
"configuration",
"."
] | 71451935f159b63a80956018581919ef824fbd0e | https://github.com/gocontrib/auth/blob/71451935f159b63a80956018581919ef824fbd0e/middleware.go#L16-L24 |
153,992 | gocontrib/auth | middleware.go | RequireAdmin | func RequireAdmin(config *Config) func(http.Handler) http.Handler {
config = config.SetDefaults()
return func(next http.Handler) http.Handler {
return &middleware{
config: config,
next: next,
requireAdmin: true,
}
}
} | go | func RequireAdmin(config *Config) func(http.Handler) http.Handler {
config = config.SetDefaults()
return func(next http.Handler) http.Handler {
return &middleware{
config: config,
next: next,
requireAdmin: true,
}
}
} | [
"func",
"RequireAdmin",
"(",
"config",
"*",
"Config",
")",
"func",
"(",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"config",
"=",
"config",
".",
"SetDefaults",
"(",
")",
"\n",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
... | // RequireAdmin creates auth middleware that authenticates only admin users. | [
"RequireAdmin",
"creates",
"auth",
"middleware",
"that",
"authenticates",
"only",
"admin",
"users",
"."
] | 71451935f159b63a80956018581919ef824fbd0e | https://github.com/gocontrib/auth/blob/71451935f159b63a80956018581919ef824fbd0e/middleware.go#L27-L36 |
153,993 | gocontrib/auth | middleware.go | authenticate | func (m *middleware) authenticate(r *http.Request) (context.Context, *Error) {
var h = r.Header.Get(authorizationHeader)
if len(h) > 0 {
return m.validateHeader(r, h)
}
cookie, err := r.Cookie(m.config.TokenCookie)
if err == nil && cookie != nil {
return m.validateJWT(r, cookie.Value)
}
// from query string
token := r.URL.Query().Get(m.config.TokenKey)
if len(token) > 0 {
return m.validateJWT(r, token)
}
return nil, ErrBadAuthorizationHeader
} | go | func (m *middleware) authenticate(r *http.Request) (context.Context, *Error) {
var h = r.Header.Get(authorizationHeader)
if len(h) > 0 {
return m.validateHeader(r, h)
}
cookie, err := r.Cookie(m.config.TokenCookie)
if err == nil && cookie != nil {
return m.validateJWT(r, cookie.Value)
}
// from query string
token := r.URL.Query().Get(m.config.TokenKey)
if len(token) > 0 {
return m.validateJWT(r, token)
}
return nil, ErrBadAuthorizationHeader
} | [
"func",
"(",
"m",
"*",
"middleware",
")",
"authenticate",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"context",
".",
"Context",
",",
"*",
"Error",
")",
"{",
"var",
"h",
"=",
"r",
".",
"Header",
".",
"Get",
"(",
"authorizationHeader",
")",
"\n... | // Validates auth header or auth_token. | [
"Validates",
"auth",
"header",
"or",
"auth_token",
"."
] | 71451935f159b63a80956018581919ef824fbd0e | https://github.com/gocontrib/auth/blob/71451935f159b63a80956018581919ef824fbd0e/middleware.go#L58-L76 |
153,994 | gocontrib/auth | middleware.go | validateHeader | func (m *middleware) validateHeader(r *http.Request, auth string) (context.Context, *Error) {
var f = strings.Fields(auth)
if len(f) != 2 {
return nil, ErrBadAuthorizationHeader
}
var scheme = strings.ToLower(f[0])
var token = f[1]
switch scheme {
case schemeBasic:
return m.validateBasicAuth(r)
case schemeBearer:
return m.validateJWT(r, token)
default:
return nil, ErrUnsupportedAuthScheme
}
} | go | func (m *middleware) validateHeader(r *http.Request, auth string) (context.Context, *Error) {
var f = strings.Fields(auth)
if len(f) != 2 {
return nil, ErrBadAuthorizationHeader
}
var scheme = strings.ToLower(f[0])
var token = f[1]
switch scheme {
case schemeBasic:
return m.validateBasicAuth(r)
case schemeBearer:
return m.validateJWT(r, token)
default:
return nil, ErrUnsupportedAuthScheme
}
} | [
"func",
"(",
"m",
"*",
"middleware",
")",
"validateHeader",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"auth",
"string",
")",
"(",
"context",
".",
"Context",
",",
"*",
"Error",
")",
"{",
"var",
"f",
"=",
"strings",
".",
"Fields",
"(",
"auth",
")",... | // Validates authorization header. | [
"Validates",
"authorization",
"header",
"."
] | 71451935f159b63a80956018581919ef824fbd0e | https://github.com/gocontrib/auth/blob/71451935f159b63a80956018581919ef824fbd0e/middleware.go#L79-L96 |
153,995 | nickvanw/ircx | bot.go | New | func New(server, name string, config Config) *Bot {
b := &Bot{
Server: server,
OriginalName: name,
Config: config,
Data: make(chan *irc.Message, 10), // buffer 10 messages
handlers: make(map[string][]Handler),
tries: 0,
}
return b
} | go | func New(server, name string, config Config) *Bot {
b := &Bot{
Server: server,
OriginalName: name,
Config: config,
Data: make(chan *irc.Message, 10), // buffer 10 messages
handlers: make(map[string][]Handler),
tries: 0,
}
return b
} | [
"func",
"New",
"(",
"server",
",",
"name",
"string",
",",
"config",
"Config",
")",
"*",
"Bot",
"{",
"b",
":=",
"&",
"Bot",
"{",
"Server",
":",
"server",
",",
"OriginalName",
":",
"name",
",",
"Config",
":",
"config",
",",
"Data",
":",
"make",
"(",
... | // New creates a new IRC bot with the specified server, name and config | [
"New",
"creates",
"a",
"new",
"IRC",
"bot",
"with",
"the",
"specified",
"server",
"name",
"and",
"config"
] | 49cff0c1f801176c4cdf774252a5803f25cdb815 | https://github.com/nickvanw/ircx/blob/49cff0c1f801176c4cdf774252a5803f25cdb815/bot.go#L42-L52 |
153,996 | nickvanw/ircx | bot.go | Connect | func (b *Bot) Connect() error {
var conn net.Conn
var err error
if b.Config.TLSConfig == nil {
conn, err = net.Dial("tcp", b.Server)
} else {
conn, err = tls.Dial("tcp", b.Server, b.Config.TLSConfig)
}
if err != nil {
return err
}
b.conn = conn
b.reader = irc.NewDecoder(conn)
b.writer = irc.NewEncoder(conn)
b.Sender = serverSender{writer: b.writer, logger: b.Logger}
for _, msg := range b.connectMessages() {
level.Debug(b.Logger()).Log("action", "send", "message", msg.String())
if err := b.writer.Encode(msg); err != nil {
level.Error(b.Logger()).Log("action", "send", "error", err)
return err
}
}
b.tries = 0
go b.ReadLoop()
return nil
} | go | func (b *Bot) Connect() error {
var conn net.Conn
var err error
if b.Config.TLSConfig == nil {
conn, err = net.Dial("tcp", b.Server)
} else {
conn, err = tls.Dial("tcp", b.Server, b.Config.TLSConfig)
}
if err != nil {
return err
}
b.conn = conn
b.reader = irc.NewDecoder(conn)
b.writer = irc.NewEncoder(conn)
b.Sender = serverSender{writer: b.writer, logger: b.Logger}
for _, msg := range b.connectMessages() {
level.Debug(b.Logger()).Log("action", "send", "message", msg.String())
if err := b.writer.Encode(msg); err != nil {
level.Error(b.Logger()).Log("action", "send", "error", err)
return err
}
}
b.tries = 0
go b.ReadLoop()
return nil
} | [
"func",
"(",
"b",
"*",
"Bot",
")",
"Connect",
"(",
")",
"error",
"{",
"var",
"conn",
"net",
".",
"Conn",
"\n",
"var",
"err",
"error",
"\n",
"if",
"b",
".",
"Config",
".",
"TLSConfig",
"==",
"nil",
"{",
"conn",
",",
"err",
"=",
"net",
".",
"Dial... | // Connect attempts to connect to the given IRC server | [
"Connect",
"attempts",
"to",
"connect",
"to",
"the",
"given",
"IRC",
"server"
] | 49cff0c1f801176c4cdf774252a5803f25cdb815 | https://github.com/nickvanw/ircx/blob/49cff0c1f801176c4cdf774252a5803f25cdb815/bot.go#L55-L80 |
153,997 | nickvanw/ircx | bot.go | connectMessages | func (b *Bot) connectMessages() []*irc.Message {
messages := []*irc.Message{}
if b.Config.Password != "" {
messages = append(messages, &irc.Message{
Command: irc.PASS,
Params: []string{b.Config.Password},
})
}
messages = append(messages, &irc.Message{
Command: irc.NICK,
Params: []string{b.OriginalName},
})
messages = append(messages, &irc.Message{
Command: irc.USER,
Params: []string{b.Config.User, "0", "*", b.Config.User},
})
return messages
} | go | func (b *Bot) connectMessages() []*irc.Message {
messages := []*irc.Message{}
if b.Config.Password != "" {
messages = append(messages, &irc.Message{
Command: irc.PASS,
Params: []string{b.Config.Password},
})
}
messages = append(messages, &irc.Message{
Command: irc.NICK,
Params: []string{b.OriginalName},
})
messages = append(messages, &irc.Message{
Command: irc.USER,
Params: []string{b.Config.User, "0", "*", b.Config.User},
})
return messages
} | [
"func",
"(",
"b",
"*",
"Bot",
")",
"connectMessages",
"(",
")",
"[",
"]",
"*",
"irc",
".",
"Message",
"{",
"messages",
":=",
"[",
"]",
"*",
"irc",
".",
"Message",
"{",
"}",
"\n",
"if",
"b",
".",
"Config",
".",
"Password",
"!=",
"\"",
"\"",
"{",... | // connectMessages is a list of IRC messages to send when attempting to
// connect to the IRC server. | [
"connectMessages",
"is",
"a",
"list",
"of",
"IRC",
"messages",
"to",
"send",
"when",
"attempting",
"to",
"connect",
"to",
"the",
"IRC",
"server",
"."
] | 49cff0c1f801176c4cdf774252a5803f25cdb815 | https://github.com/nickvanw/ircx/blob/49cff0c1f801176c4cdf774252a5803f25cdb815/bot.go#L95-L112 |
153,998 | nickvanw/ircx | bot.go | Reconnect | func (b *Bot) Reconnect() error {
if b.Config.MaxRetries > 0 {
b.conn.Close()
for b.tries < b.Config.MaxRetries {
level.Info(b.Logger()).Log("action", "reconnect", "server", b.Server)
if err := b.Connect(); err != nil {
b.tries++
duration := time.Duration(math.Pow(2.0, float64(b.tries))*200) * time.Millisecond
level.Error(b.Logger()).Log("action", "reconnect_error", "delay", duration, "error", err)
time.Sleep(duration)
} else {
break
}
}
return errors.New("Too many reconnects")
}
close(b.Data)
return nil
} | go | func (b *Bot) Reconnect() error {
if b.Config.MaxRetries > 0 {
b.conn.Close()
for b.tries < b.Config.MaxRetries {
level.Info(b.Logger()).Log("action", "reconnect", "server", b.Server)
if err := b.Connect(); err != nil {
b.tries++
duration := time.Duration(math.Pow(2.0, float64(b.tries))*200) * time.Millisecond
level.Error(b.Logger()).Log("action", "reconnect_error", "delay", duration, "error", err)
time.Sleep(duration)
} else {
break
}
}
return errors.New("Too many reconnects")
}
close(b.Data)
return nil
} | [
"func",
"(",
"b",
"*",
"Bot",
")",
"Reconnect",
"(",
")",
"error",
"{",
"if",
"b",
".",
"Config",
".",
"MaxRetries",
">",
"0",
"{",
"b",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"for",
"b",
".",
"tries",
"<",
"b",
".",
"Config",
".",
"MaxRe... | // Reconnect checks to make sure we want to, and then attempts to
// reconnect to the server | [
"Reconnect",
"checks",
"to",
"make",
"sure",
"we",
"want",
"to",
"and",
"then",
"attempts",
"to",
"reconnect",
"to",
"the",
"server"
] | 49cff0c1f801176c4cdf774252a5803f25cdb815 | https://github.com/nickvanw/ircx/blob/49cff0c1f801176c4cdf774252a5803f25cdb815/bot.go#L116-L134 |
153,999 | nickvanw/ircx | bot.go | ReadLoop | func (b *Bot) ReadLoop() error {
for {
b.conn.SetDeadline(time.Now().Add(300 * time.Second))
msg, err := b.reader.Decode()
if err != nil {
level.Error(b.Logger()).Log("action", "readloop", "error", err)
return b.Reconnect()
}
if msg == nil {
continue // invalid message
}
level.Debug(b.Logger()).Log("action", "read", "message", msg.String())
b.Data <- msg
}
} | go | func (b *Bot) ReadLoop() error {
for {
b.conn.SetDeadline(time.Now().Add(300 * time.Second))
msg, err := b.reader.Decode()
if err != nil {
level.Error(b.Logger()).Log("action", "readloop", "error", err)
return b.Reconnect()
}
if msg == nil {
continue // invalid message
}
level.Debug(b.Logger()).Log("action", "read", "message", msg.String())
b.Data <- msg
}
} | [
"func",
"(",
"b",
"*",
"Bot",
")",
"ReadLoop",
"(",
")",
"error",
"{",
"for",
"{",
"b",
".",
"conn",
".",
"SetDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"300",
"*",
"time",
".",
"Second",
")",
")",
"\n",
"msg",
",",
"err",... | // ReadLoop sets a timeout of 300 seconds, and then attempts to read
// from the IRC server. If there is an error, it calls Reconnect | [
"ReadLoop",
"sets",
"a",
"timeout",
"of",
"300",
"seconds",
"and",
"then",
"attempts",
"to",
"read",
"from",
"the",
"IRC",
"server",
".",
"If",
"there",
"is",
"an",
"error",
"it",
"calls",
"Reconnect"
] | 49cff0c1f801176c4cdf774252a5803f25cdb815 | https://github.com/nickvanw/ircx/blob/49cff0c1f801176c4cdf774252a5803f25cdb815/bot.go#L138-L152 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.