id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
16,600 | pkg/xattr | xattr.go | FSet | func FSet(f *os.File, name string, data []byte) error {
if err := fsetxattr(f, name, data, 0); err != nil {
return &Error{"xattr.FSet", f.Name(), name, err}
}
return nil
} | go | func FSet(f *os.File, name string, data []byte) error {
if err := fsetxattr(f, name, data, 0); err != nil {
return &Error{"xattr.FSet", f.Name(), name, err}
}
return nil
} | [
"func",
"FSet",
"(",
"f",
"*",
"os",
".",
"File",
",",
"name",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"fsetxattr",
"(",
"f",
",",
"name",
",",
"data",
",",
"0",
")",
";",
"err",
"!=",
"nil",
"{",
"retur... | // FSet is like Set but accepts a os.File instead of a file path. | [
"FSet",
"is",
"like",
"Set",
"but",
"accepts",
"a",
"os",
".",
"File",
"instead",
"of",
"a",
"file",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L122-L127 |
16,601 | pkg/xattr | xattr.go | SetWithFlags | func SetWithFlags(path, name string, data []byte, flags int) error {
if err := setxattr(path, name, data, flags); err != nil {
return &Error{"xattr.SetWithFlags", path, name, err}
}
return nil
} | go | func SetWithFlags(path, name string, data []byte, flags int) error {
if err := setxattr(path, name, data, flags); err != nil {
return &Error{"xattr.SetWithFlags", path, name, err}
}
return nil
} | [
"func",
"SetWithFlags",
"(",
"path",
",",
"name",
"string",
",",
"data",
"[",
"]",
"byte",
",",
"flags",
"int",
")",
"error",
"{",
"if",
"err",
":=",
"setxattr",
"(",
"path",
",",
"name",
",",
"data",
",",
"flags",
")",
";",
"err",
"!=",
"nil",
"... | // SetWithFlags associates name and data together as an attribute of path.
// Forwards the flags parameter to the syscall layer. | [
"SetWithFlags",
"associates",
"name",
"and",
"data",
"together",
"as",
"an",
"attribute",
"of",
"path",
".",
"Forwards",
"the",
"flags",
"parameter",
"to",
"the",
"syscall",
"layer",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L131-L136 |
16,602 | pkg/xattr | xattr.go | LSetWithFlags | func LSetWithFlags(path, name string, data []byte, flags int) error {
if err := lsetxattr(path, name, data, flags); err != nil {
return &Error{"xattr.LSetWithFlags", path, name, err}
}
return nil
} | go | func LSetWithFlags(path, name string, data []byte, flags int) error {
if err := lsetxattr(path, name, data, flags); err != nil {
return &Error{"xattr.LSetWithFlags", path, name, err}
}
return nil
} | [
"func",
"LSetWithFlags",
"(",
"path",
",",
"name",
"string",
",",
"data",
"[",
"]",
"byte",
",",
"flags",
"int",
")",
"error",
"{",
"if",
"err",
":=",
"lsetxattr",
"(",
"path",
",",
"name",
",",
"data",
",",
"flags",
")",
";",
"err",
"!=",
"nil",
... | // LSetWithFlags is like SetWithFlags but does not follow a symlink at
// the end of the path. | [
"LSetWithFlags",
"is",
"like",
"SetWithFlags",
"but",
"does",
"not",
"follow",
"a",
"symlink",
"at",
"the",
"end",
"of",
"the",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L140-L145 |
16,603 | pkg/xattr | xattr.go | FSetWithFlags | func FSetWithFlags(f *os.File, name string, data []byte, flags int) error {
if err := fsetxattr(f, name, data, flags); err != nil {
return &Error{"xattr.FSetWithFlags", f.Name(), name, err}
}
return nil
} | go | func FSetWithFlags(f *os.File, name string, data []byte, flags int) error {
if err := fsetxattr(f, name, data, flags); err != nil {
return &Error{"xattr.FSetWithFlags", f.Name(), name, err}
}
return nil
} | [
"func",
"FSetWithFlags",
"(",
"f",
"*",
"os",
".",
"File",
",",
"name",
"string",
",",
"data",
"[",
"]",
"byte",
",",
"flags",
"int",
")",
"error",
"{",
"if",
"err",
":=",
"fsetxattr",
"(",
"f",
",",
"name",
",",
"data",
",",
"flags",
")",
";",
... | // FSetWithFlags is like SetWithFlags but accepts a os.File instead of a file path. | [
"FSetWithFlags",
"is",
"like",
"SetWithFlags",
"but",
"accepts",
"a",
"os",
".",
"File",
"instead",
"of",
"a",
"file",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L148-L153 |
16,604 | pkg/xattr | xattr.go | Remove | func Remove(path, name string) error {
if err := removexattr(path, name); err != nil {
return &Error{"xattr.Remove", path, name, err}
}
return nil
} | go | func Remove(path, name string) error {
if err := removexattr(path, name); err != nil {
return &Error{"xattr.Remove", path, name, err}
}
return nil
} | [
"func",
"Remove",
"(",
"path",
",",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"removexattr",
"(",
"path",
",",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"&",
"Error",
"{",
"\"",
"\"",
",",
"path",
",",
"name",
",",
"err",... | // Remove removes the attribute associated with the given path. | [
"Remove",
"removes",
"the",
"attribute",
"associated",
"with",
"the",
"given",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L156-L161 |
16,605 | pkg/xattr | xattr.go | LRemove | func LRemove(path, name string) error {
if err := lremovexattr(path, name); err != nil {
return &Error{"xattr.LRemove", path, name, err}
}
return nil
} | go | func LRemove(path, name string) error {
if err := lremovexattr(path, name); err != nil {
return &Error{"xattr.LRemove", path, name, err}
}
return nil
} | [
"func",
"LRemove",
"(",
"path",
",",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"lremovexattr",
"(",
"path",
",",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"&",
"Error",
"{",
"\"",
"\"",
",",
"path",
",",
"name",
",",
"err... | // LRemove is like Remove but does not follow a symlink at the end of the
// path. | [
"LRemove",
"is",
"like",
"Remove",
"but",
"does",
"not",
"follow",
"a",
"symlink",
"at",
"the",
"end",
"of",
"the",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L165-L170 |
16,606 | pkg/xattr | xattr.go | FRemove | func FRemove(f *os.File, name string) error {
if err := fremovexattr(f, name); err != nil {
return &Error{"xattr.FRemove", f.Name(), name, err}
}
return nil
} | go | func FRemove(f *os.File, name string) error {
if err := fremovexattr(f, name); err != nil {
return &Error{"xattr.FRemove", f.Name(), name, err}
}
return nil
} | [
"func",
"FRemove",
"(",
"f",
"*",
"os",
".",
"File",
",",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"fremovexattr",
"(",
"f",
",",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"&",
"Error",
"{",
"\"",
"\"",
",",
"f",
".",
... | // FRemove is like Remove but accepts a os.File instead of a file path. | [
"FRemove",
"is",
"like",
"Remove",
"but",
"accepts",
"a",
"os",
".",
"File",
"instead",
"of",
"a",
"file",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L173-L178 |
16,607 | pkg/xattr | xattr.go | List | func List(path string) ([]string, error) {
return list(path, func(data []byte) (int, error) {
return listxattr(path, data)
})
} | go | func List(path string) ([]string, error) {
return list(path, func(data []byte) (int, error) {
return listxattr(path, data)
})
} | [
"func",
"List",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"list",
"(",
"path",
",",
"func",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"listxattr",
"(",
"path",
... | // List retrieves a list of names of extended attributes associated
// with the given path in the file system. | [
"List",
"retrieves",
"a",
"list",
"of",
"names",
"of",
"extended",
"attributes",
"associated",
"with",
"the",
"given",
"path",
"in",
"the",
"file",
"system",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L182-L186 |
16,608 | pkg/xattr | xattr.go | LList | func LList(path string) ([]string, error) {
return list(path, func(data []byte) (int, error) {
return llistxattr(path, data)
})
} | go | func LList(path string) ([]string, error) {
return list(path, func(data []byte) (int, error) {
return llistxattr(path, data)
})
} | [
"func",
"LList",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"list",
"(",
"path",
",",
"func",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"llistxattr",
"(",
"path",... | // LList is like List but does not follow a symlink at the end of the
// path. | [
"LList",
"is",
"like",
"List",
"but",
"does",
"not",
"follow",
"a",
"symlink",
"at",
"the",
"end",
"of",
"the",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L190-L194 |
16,609 | pkg/xattr | xattr.go | FList | func FList(f *os.File) ([]string, error) {
return list(f.Name(), func(data []byte) (int, error) {
return flistxattr(f, data)
})
} | go | func FList(f *os.File) ([]string, error) {
return list(f.Name(), func(data []byte) (int, error) {
return flistxattr(f, data)
})
} | [
"func",
"FList",
"(",
"f",
"*",
"os",
".",
"File",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"list",
"(",
"f",
".",
"Name",
"(",
")",
",",
"func",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",... | // FList is like List but accepts a os.File instead of a file path. | [
"FList",
"is",
"like",
"List",
"but",
"accepts",
"a",
"os",
".",
"File",
"instead",
"of",
"a",
"file",
"path",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L197-L201 |
16,610 | pkg/xattr | xattr.go | list | func list(path string, listxattrFunc listxattrFunc) ([]string, error) {
myname := "xattr.list"
// find size.
size, err := listxattrFunc(nil)
if err != nil {
return nil, &Error{myname, path, "", err}
}
if size > 0 {
// `size + 1` because of ERANGE error when reading
// from a SMB1 mount point (https://github.com/pkg/xattr/issues/16).
buf := make([]byte, size+1)
// Read into buffer of that size.
read, err := listxattrFunc(buf)
if err != nil {
return nil, &Error{myname, path, "", err}
}
return stringsFromByteSlice(buf[:read]), nil
}
return []string{}, nil
} | go | func list(path string, listxattrFunc listxattrFunc) ([]string, error) {
myname := "xattr.list"
// find size.
size, err := listxattrFunc(nil)
if err != nil {
return nil, &Error{myname, path, "", err}
}
if size > 0 {
// `size + 1` because of ERANGE error when reading
// from a SMB1 mount point (https://github.com/pkg/xattr/issues/16).
buf := make([]byte, size+1)
// Read into buffer of that size.
read, err := listxattrFunc(buf)
if err != nil {
return nil, &Error{myname, path, "", err}
}
return stringsFromByteSlice(buf[:read]), nil
}
return []string{}, nil
} | [
"func",
"list",
"(",
"path",
"string",
",",
"listxattrFunc",
"listxattrFunc",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"myname",
":=",
"\"",
"\"",
"\n",
"// find size.",
"size",
",",
"err",
":=",
"listxattrFunc",
"(",
"nil",
")",
"\n",
"if... | // list contains the buffer allocation logic used by both List and LList. | [
"list",
"contains",
"the",
"buffer",
"allocation",
"logic",
"used",
"by",
"both",
"List",
"and",
"LList",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L206-L225 |
16,611 | pkg/xattr | xattr.go | bytePtrFromSlice | func bytePtrFromSlice(data []byte) (ptr *byte, size int) {
size = len(data)
if size > 0 {
ptr = &data[0]
}
return
} | go | func bytePtrFromSlice(data []byte) (ptr *byte, size int) {
size = len(data)
if size > 0 {
ptr = &data[0]
}
return
} | [
"func",
"bytePtrFromSlice",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"ptr",
"*",
"byte",
",",
"size",
"int",
")",
"{",
"size",
"=",
"len",
"(",
"data",
")",
"\n",
"if",
"size",
">",
"0",
"{",
"ptr",
"=",
"&",
"data",
"[",
"0",
"]",
"\n",
"}",... | // bytePtrFromSlice returns a pointer to array of bytes and a size. | [
"bytePtrFromSlice",
"returns",
"a",
"pointer",
"to",
"array",
"of",
"bytes",
"and",
"a",
"size",
"."
] | f2ae4ae548121ce70f98b72822c65d86900849c3 | https://github.com/pkg/xattr/blob/f2ae4ae548121ce70f98b72822c65d86900849c3/xattr.go#L228-L234 |
16,612 | kobolog/gorb | util/net.go | AddrFamily | func AddrFamily(ip net.IP) int {
if len(ip) == v4Length {
return IPv4
}
if len(ip) == v6Length && bytes.HasPrefix(ip, v4Prefix) {
return IPv4
}
return IPv6
} | go | func AddrFamily(ip net.IP) int {
if len(ip) == v4Length {
return IPv4
}
if len(ip) == v6Length && bytes.HasPrefix(ip, v4Prefix) {
return IPv4
}
return IPv6
} | [
"func",
"AddrFamily",
"(",
"ip",
"net",
".",
"IP",
")",
"int",
"{",
"if",
"len",
"(",
"ip",
")",
"==",
"v4Length",
"{",
"return",
"IPv4",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"ip",
")",
"==",
"v6Length",
"&&",
"bytes",
".",
"HasPrefix",
"(",
"ip"... | // AddrFamily returns the address family of an IP address. | [
"AddrFamily",
"returns",
"the",
"address",
"family",
"of",
"an",
"IP",
"address",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/util/net.go#L45-L55 |
16,613 | kobolog/gorb | util/net.go | InterfaceIPs | func InterfaceIPs(device string) (ips []net.IP, _ error) {
var networks []net.Addr
if iface, err := net.InterfaceByName(device); err != nil {
return nil, err
} else if networks, err = iface.Addrs(); err != nil {
return nil, err
}
for _, network := range networks {
if ipNet, castable := network.(*net.IPNet); castable {
ips = append(ips, ipNet.IP)
}
}
// Note that on non-IP interfaces it will be an empty slice
// and no error indicator. Maybe that's not super-perfect.
return ips, nil
} | go | func InterfaceIPs(device string) (ips []net.IP, _ error) {
var networks []net.Addr
if iface, err := net.InterfaceByName(device); err != nil {
return nil, err
} else if networks, err = iface.Addrs(); err != nil {
return nil, err
}
for _, network := range networks {
if ipNet, castable := network.(*net.IPNet); castable {
ips = append(ips, ipNet.IP)
}
}
// Note that on non-IP interfaces it will be an empty slice
// and no error indicator. Maybe that's not super-perfect.
return ips, nil
} | [
"func",
"InterfaceIPs",
"(",
"device",
"string",
")",
"(",
"ips",
"[",
"]",
"net",
".",
"IP",
",",
"_",
"error",
")",
"{",
"var",
"networks",
"[",
"]",
"net",
".",
"Addr",
"\n\n",
"if",
"iface",
",",
"err",
":=",
"net",
".",
"InterfaceByName",
"(",... | // InterfaceIPs returns a slice of interface IP addresses. | [
"InterfaceIPs",
"returns",
"a",
"slice",
"of",
"interface",
"IP",
"addresses",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/util/net.go#L58-L76 |
16,614 | kobolog/gorb | core/options.go | Validate | func (o *ServiceOptions) Validate(defaultHost net.IP) error {
if o.Port == 0 {
return ErrMissingEndpoint
}
if len(o.Host) != 0 {
if addr, err := net.ResolveIPAddr("ip", o.Host); err == nil {
o.host = addr.IP
} else {
return err
}
} else if defaultHost != nil {
o.host = defaultHost
} else {
return ErrMissingEndpoint
}
if len(o.Protocol) == 0 {
o.Protocol = "tcp"
}
o.Protocol = strings.ToLower(o.Protocol)
switch o.Protocol {
case "tcp":
o.protocol = syscall.IPPROTO_TCP
case "udp":
o.protocol = syscall.IPPROTO_UDP
default:
return ErrUnknownProtocol
}
if o.Flags != "" {
for _, flag := range strings.Split(o.Flags, "|") {
if _, ok := schedulerFlags[flag]; !ok {
return ErrUnknownFlag
}
}
}
if len(o.Method) == 0 {
// WRR since Pulse will dynamically reweight backends.
o.Method = "wrr"
}
return nil
} | go | func (o *ServiceOptions) Validate(defaultHost net.IP) error {
if o.Port == 0 {
return ErrMissingEndpoint
}
if len(o.Host) != 0 {
if addr, err := net.ResolveIPAddr("ip", o.Host); err == nil {
o.host = addr.IP
} else {
return err
}
} else if defaultHost != nil {
o.host = defaultHost
} else {
return ErrMissingEndpoint
}
if len(o.Protocol) == 0 {
o.Protocol = "tcp"
}
o.Protocol = strings.ToLower(o.Protocol)
switch o.Protocol {
case "tcp":
o.protocol = syscall.IPPROTO_TCP
case "udp":
o.protocol = syscall.IPPROTO_UDP
default:
return ErrUnknownProtocol
}
if o.Flags != "" {
for _, flag := range strings.Split(o.Flags, "|") {
if _, ok := schedulerFlags[flag]; !ok {
return ErrUnknownFlag
}
}
}
if len(o.Method) == 0 {
// WRR since Pulse will dynamically reweight backends.
o.Method = "wrr"
}
return nil
} | [
"func",
"(",
"o",
"*",
"ServiceOptions",
")",
"Validate",
"(",
"defaultHost",
"net",
".",
"IP",
")",
"error",
"{",
"if",
"o",
".",
"Port",
"==",
"0",
"{",
"return",
"ErrMissingEndpoint",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"o",
".",
"Host",
")",
"... | // Validate fills missing fields and validates virtual service configuration. | [
"Validate",
"fills",
"missing",
"fields",
"and",
"validates",
"virtual",
"service",
"configuration",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/options.go#L69-L115 |
16,615 | kobolog/gorb | core/options.go | Validate | func (o *BackendOptions) Validate() error {
if len(o.Host) == 0 || o.Port == 0 {
return ErrMissingEndpoint
}
if addr, err := net.ResolveIPAddr("ip", o.Host); err == nil {
o.host = addr.IP
} else {
return err
}
if o.Weight <= 0 {
o.Weight = 100
}
if len(o.Method) == 0 {
o.Method = "nat"
}
o.Method = strings.ToLower(o.Method)
switch o.Method {
case "dr":
o.methodID = gnl2go.IPVS_DIRECTROUTE
case "nat":
o.methodID = gnl2go.IPVS_MASQUERADING
case "tunnel", "ipip":
o.methodID = gnl2go.IPVS_TUNNELING
default:
return ErrUnknownMethod
}
if o.Pulse == nil {
// It doesn't make much sense to have a backend with no Pulse.
o.Pulse = &pulse.Options{}
}
return nil
} | go | func (o *BackendOptions) Validate() error {
if len(o.Host) == 0 || o.Port == 0 {
return ErrMissingEndpoint
}
if addr, err := net.ResolveIPAddr("ip", o.Host); err == nil {
o.host = addr.IP
} else {
return err
}
if o.Weight <= 0 {
o.Weight = 100
}
if len(o.Method) == 0 {
o.Method = "nat"
}
o.Method = strings.ToLower(o.Method)
switch o.Method {
case "dr":
o.methodID = gnl2go.IPVS_DIRECTROUTE
case "nat":
o.methodID = gnl2go.IPVS_MASQUERADING
case "tunnel", "ipip":
o.methodID = gnl2go.IPVS_TUNNELING
default:
return ErrUnknownMethod
}
if o.Pulse == nil {
// It doesn't make much sense to have a backend with no Pulse.
o.Pulse = &pulse.Options{}
}
return nil
} | [
"func",
"(",
"o",
"*",
"BackendOptions",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"o",
".",
"Host",
")",
"==",
"0",
"||",
"o",
".",
"Port",
"==",
"0",
"{",
"return",
"ErrMissingEndpoint",
"\n",
"}",
"\n\n",
"if",
"addr",
",",
"e... | // Validate fills missing fields and validates backend configuration. | [
"Validate",
"fills",
"missing",
"fields",
"and",
"validates",
"backend",
"configuration",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/options.go#L156-L194 |
16,616 | kobolog/gorb | pulse/options.go | Validate | func (o *Options) Validate() error {
if len(o.Type) == 0 {
// TCP is a safe guess: the majority of services are TCP-based.
o.Type = "tcp"
}
if len(o.Interval) == 0 {
o.Interval = "1m"
}
o.Type = strings.ToLower(o.Type)
if fn := get[o.Type]; fn == nil {
return ErrUnknownPulseType
}
var err error
if o.interval, err = util.ParseInterval(o.Interval); err != nil {
return err
} else if o.interval <= 0 {
return ErrInvalidPulseInterval
}
return nil
} | go | func (o *Options) Validate() error {
if len(o.Type) == 0 {
// TCP is a safe guess: the majority of services are TCP-based.
o.Type = "tcp"
}
if len(o.Interval) == 0 {
o.Interval = "1m"
}
o.Type = strings.ToLower(o.Type)
if fn := get[o.Type]; fn == nil {
return ErrUnknownPulseType
}
var err error
if o.interval, err = util.ParseInterval(o.Interval); err != nil {
return err
} else if o.interval <= 0 {
return ErrInvalidPulseInterval
}
return nil
} | [
"func",
"(",
"o",
"*",
"Options",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"o",
".",
"Type",
")",
"==",
"0",
"{",
"// TCP is a safe guess: the majority of services are TCP-based.",
"o",
".",
"Type",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"... | // Validate fills missing fields and validates Pulse configuration. | [
"Validate",
"fills",
"missing",
"fields",
"and",
"validates",
"Pulse",
"configuration",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/pulse/options.go#L47-L72 |
16,617 | kobolog/gorb | pulse/metrics.go | NewMetrics | func NewMetrics() *Metrics {
return &Metrics{Status: StatusUp, Health: 1, Uptime: 0, lastTs: time.Now()}
} | go | func NewMetrics() *Metrics {
return &Metrics{Status: StatusUp, Health: 1, Uptime: 0, lastTs: time.Now()}
} | [
"func",
"NewMetrics",
"(",
")",
"*",
"Metrics",
"{",
"return",
"&",
"Metrics",
"{",
"Status",
":",
"StatusUp",
",",
"Health",
":",
"1",
",",
"Uptime",
":",
"0",
",",
"lastTs",
":",
"time",
".",
"Now",
"(",
")",
"}",
"\n",
"}"
] | // NewMetrics creates a new instance of metrics. | [
"NewMetrics",
"creates",
"a",
"new",
"instance",
"of",
"metrics",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/pulse/metrics.go#L39-L41 |
16,618 | kobolog/gorb | pulse/metrics.go | Update | func (m *Metrics) Update(status StatusType) Metrics {
m.Status = status
m.Health = 0
m.record = append(m.record, status)
if len(m.record) > 100 {
m.record = m.record[1:]
}
for _, result := range m.record {
m.Health += float64(result)
}
m.Health = 1.0 - m.Health/float64(len(m.record))
if ts := time.Now(); m.Status != StatusUp {
m.Uptime, m.lastTs = 0, ts
} else {
m.Uptime, m.lastTs = m.Uptime+ts.Sub(m.lastTs)/time.Second, ts
}
return *m
} | go | func (m *Metrics) Update(status StatusType) Metrics {
m.Status = status
m.Health = 0
m.record = append(m.record, status)
if len(m.record) > 100 {
m.record = m.record[1:]
}
for _, result := range m.record {
m.Health += float64(result)
}
m.Health = 1.0 - m.Health/float64(len(m.record))
if ts := time.Now(); m.Status != StatusUp {
m.Uptime, m.lastTs = 0, ts
} else {
m.Uptime, m.lastTs = m.Uptime+ts.Sub(m.lastTs)/time.Second, ts
}
return *m
} | [
"func",
"(",
"m",
"*",
"Metrics",
")",
"Update",
"(",
"status",
"StatusType",
")",
"Metrics",
"{",
"m",
".",
"Status",
"=",
"status",
"\n",
"m",
".",
"Health",
"=",
"0",
"\n",
"m",
".",
"record",
"=",
"append",
"(",
"m",
".",
"record",
",",
"stat... | // Update updates metrics based on Pulse status message. | [
"Update",
"updates",
"metrics",
"based",
"on",
"Pulse",
"status",
"message",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/pulse/metrics.go#L44-L66 |
16,619 | kobolog/gorb | util/time.go | ParseInterval | func ParseInterval(s string) (time.Duration, error) {
if m := reInterval.FindStringSubmatch(strings.TrimSpace(s)); len(m) != 0 {
value, _ := strconv.ParseInt(m[1], 10, 32)
duration := intervals[strings.ToLower(m[2])]
return duration * time.Duration(value), nil
}
return 0, errInvalidIntervalFormat
} | go | func ParseInterval(s string) (time.Duration, error) {
if m := reInterval.FindStringSubmatch(strings.TrimSpace(s)); len(m) != 0 {
value, _ := strconv.ParseInt(m[1], 10, 32)
duration := intervals[strings.ToLower(m[2])]
return duration * time.Duration(value), nil
}
return 0, errInvalidIntervalFormat
} | [
"func",
"ParseInterval",
"(",
"s",
"string",
")",
"(",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"if",
"m",
":=",
"reInterval",
".",
"FindStringSubmatch",
"(",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
")",
";",
"len",
"(",
"m",
")",
"!=",
... | // ParseInterval parses an interval string and returns the corresponding duration. | [
"ParseInterval",
"parses",
"an",
"interval",
"string",
"and",
"returns",
"the",
"corresponding",
"duration",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/util/time.go#L49-L58 |
16,620 | kobolog/gorb | util/json.go | MustMarshal | func MustMarshal(object interface{}, options JSONOptions) []byte {
output, err := json.Marshal(&object)
if err != nil {
panic(err)
}
switch {
case options.Indent:
buffer := bytes.Buffer{}
// TODO(@kobolog): Expose indentation options via JSONOptions.
json.Indent(&buffer, output, "", "\t")
return buffer.Bytes()
default:
return output
}
} | go | func MustMarshal(object interface{}, options JSONOptions) []byte {
output, err := json.Marshal(&object)
if err != nil {
panic(err)
}
switch {
case options.Indent:
buffer := bytes.Buffer{}
// TODO(@kobolog): Expose indentation options via JSONOptions.
json.Indent(&buffer, output, "", "\t")
return buffer.Bytes()
default:
return output
}
} | [
"func",
"MustMarshal",
"(",
"object",
"interface",
"{",
"}",
",",
"options",
"JSONOptions",
")",
"[",
"]",
"byte",
"{",
"output",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"object",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
... | // MustMarshal will try to convert the given object to JSON or panic if there's an error. | [
"MustMarshal",
"will",
"try",
"to",
"convert",
"the",
"given",
"object",
"to",
"JSON",
"or",
"panic",
"if",
"there",
"s",
"an",
"error",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/util/json.go#L34-L53 |
16,621 | kobolog/gorb | disco/disco.go | New | func New(opts *Options) (Driver, error) {
switch opts.Type {
case "consul":
return newConsulDriver(opts.Args)
default:
return &noopDriver{}, nil
}
} | go | func New(opts *Options) (Driver, error) {
switch opts.Type {
case "consul":
return newConsulDriver(opts.Args)
default:
return &noopDriver{}, nil
}
} | [
"func",
"New",
"(",
"opts",
"*",
"Options",
")",
"(",
"Driver",
",",
"error",
")",
"{",
"switch",
"opts",
".",
"Type",
"{",
"case",
"\"",
"\"",
":",
"return",
"newConsulDriver",
"(",
"opts",
".",
"Args",
")",
"\n",
"default",
":",
"return",
"&",
"n... | // New creates a new Discovery from the provided options. | [
"New",
"creates",
"a",
"new",
"Discovery",
"from",
"the",
"provided",
"options",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/disco/disco.go#L40-L47 |
16,622 | kobolog/gorb | pulse/pulse.go | New | func New(host string, port uint16, opts *Options) (*Pulse, error) {
if err := opts.Validate(); err != nil {
return nil, err
}
d, err := get[opts.Type](host, port, opts.Args)
if err != nil {
return nil, err
}
stopCh := make(chan struct{})
return &Pulse{d, opts.interval, stopCh, NewMetrics()}, nil
} | go | func New(host string, port uint16, opts *Options) (*Pulse, error) {
if err := opts.Validate(); err != nil {
return nil, err
}
d, err := get[opts.Type](host, port, opts.Args)
if err != nil {
return nil, err
}
stopCh := make(chan struct{})
return &Pulse{d, opts.interval, stopCh, NewMetrics()}, nil
} | [
"func",
"New",
"(",
"host",
"string",
",",
"port",
"uint16",
",",
"opts",
"*",
"Options",
")",
"(",
"*",
"Pulse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"opts",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
... | // New creates a new Pulse from the provided endpoint and options. | [
"New",
"creates",
"a",
"new",
"Pulse",
"from",
"the",
"provided",
"endpoint",
"and",
"options",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/pulse/pulse.go#L57-L70 |
16,623 | kobolog/gorb | pulse/pulse.go | Loop | func (p *Pulse) Loop(id ID, pulseCh chan Update, consumerStopCh <-chan struct{}) {
log.Infof("starting pulse for %s", id)
// Randomize the first health-check to avoid thundering herd syndrome.
interval := time.Duration(rng.Int63n(int64(p.interval)))
for {
select {
case <-time.After(interval):
select {
// Recalculate metrics and statistics and send them to Context.
case pulseCh <- Update{id, p.metrics.Update(p.driver.Check())}:
case <-consumerStopCh:
// prevent blocking if the consumer stops before us
}
case <-p.stopCh:
log.Infof("stopping pulse for %s", id)
pulseCh <- Update{id, p.metrics.Update(StatusRemoved)}
return
}
// TODO(@kobolog): Add exponential back-offs, thresholds.
interval = p.interval
log.Debugf("current pulse for %s: %s", id, p.metrics.Status.String())
}
} | go | func (p *Pulse) Loop(id ID, pulseCh chan Update, consumerStopCh <-chan struct{}) {
log.Infof("starting pulse for %s", id)
// Randomize the first health-check to avoid thundering herd syndrome.
interval := time.Duration(rng.Int63n(int64(p.interval)))
for {
select {
case <-time.After(interval):
select {
// Recalculate metrics and statistics and send them to Context.
case pulseCh <- Update{id, p.metrics.Update(p.driver.Check())}:
case <-consumerStopCh:
// prevent blocking if the consumer stops before us
}
case <-p.stopCh:
log.Infof("stopping pulse for %s", id)
pulseCh <- Update{id, p.metrics.Update(StatusRemoved)}
return
}
// TODO(@kobolog): Add exponential back-offs, thresholds.
interval = p.interval
log.Debugf("current pulse for %s: %s", id, p.metrics.Status.String())
}
} | [
"func",
"(",
"p",
"*",
"Pulse",
")",
"Loop",
"(",
"id",
"ID",
",",
"pulseCh",
"chan",
"Update",
",",
"consumerStopCh",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"id",
")",
"\n\n",
"// Randomize the first h... | // Loop starts the Pulse. | [
"Loop",
"starts",
"the",
"Pulse",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/pulse/pulse.go#L79-L105 |
16,624 | kobolog/gorb | util/map.go | Get | func (do DynamicMap) Get(key string, d interface{}) interface{} {
if v, exists := do[key]; !exists {
return d
} else if vt, dt := reflect.TypeOf(v), reflect.TypeOf(d); vt.ConvertibleTo(dt) {
return v
} else if isInt(v.(string)) {
convertedValue, _ := strconv.Atoi(v.(string))
return convertedValue
} else {
return d
}
} | go | func (do DynamicMap) Get(key string, d interface{}) interface{} {
if v, exists := do[key]; !exists {
return d
} else if vt, dt := reflect.TypeOf(v), reflect.TypeOf(d); vt.ConvertibleTo(dt) {
return v
} else if isInt(v.(string)) {
convertedValue, _ := strconv.Atoi(v.(string))
return convertedValue
} else {
return d
}
} | [
"func",
"(",
"do",
"DynamicMap",
")",
"Get",
"(",
"key",
"string",
",",
"d",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"if",
"v",
",",
"exists",
":=",
"do",
"[",
"key",
"]",
";",
"!",
"exists",
"{",
"return",
"d",
"\n",
"}",
"else... | // Get returns a typed option or a default value if the option is not set. | [
"Get",
"returns",
"a",
"typed",
"option",
"or",
"a",
"default",
"value",
"if",
"the",
"option",
"is",
"not",
"set",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/util/map.go#L33-L44 |
16,625 | kobolog/gorb | core/context.go | NewContext | func NewContext(options ContextOptions) (*Context, error) {
log.Info("initializing IPVS context")
ctx := &Context{
ipvs: &gnl2go.IpvsClient{},
services: make(map[string]*service),
backends: make(map[string]*backend),
pulseCh: make(chan pulse.Update),
stopCh: make(chan struct{}),
}
if len(options.Disco) > 0 {
log.Infof("creating Consul client with Agent URL: %s", options.Disco)
var err error
ctx.disco, err = disco.New(&disco.Options{
Type: "consul",
Args: util.DynamicMap{"URL": options.Disco}})
if err != nil {
return nil, err
}
} else {
ctx.disco, _ = disco.New(&disco.Options{Type: "none"})
}
if len(options.Endpoints) > 0 {
// TODO(@kobolog): Bind virtual services on multiple endpoints.
ctx.endpoint = options.Endpoints[0]
if options.ListenPort != 0 {
log.Info("Registered the REST service to Consul.")
ctx.disco.Expose("gorb", ctx.endpoint.String(), options.ListenPort)
}
}
if err := ctx.ipvs.Init(); err != nil {
log.Errorf("unable to initialize IPVS context: %s", err)
// Here and in other places: IPVS errors are abstracted to make GNL2GO
// replaceable in the future, since it's not really maintained anymore.
return nil, ErrIpvsSyscallFailed
}
if options.Flush && ctx.ipvs.Flush() != nil {
log.Errorf("unable to clean up IPVS pools - ensure ip_vs is loaded")
ctx.Close()
return nil, ErrIpvsSyscallFailed
}
if options.VipInterface != "" {
var err error
if ctx.vipInterface, err = netlink.LinkByName(options.VipInterface); err != nil {
ctx.Close()
return nil, fmt.Errorf(
"unable to find the interface '%s' for VIPs: %s",
options.VipInterface, err)
}
log.Infof("VIPs will be added to interface '%s'", ctx.vipInterface.Attrs().Name)
}
// Fire off a pulse notifications sink goroutine.
go ctx.run()
return ctx, nil
} | go | func NewContext(options ContextOptions) (*Context, error) {
log.Info("initializing IPVS context")
ctx := &Context{
ipvs: &gnl2go.IpvsClient{},
services: make(map[string]*service),
backends: make(map[string]*backend),
pulseCh: make(chan pulse.Update),
stopCh: make(chan struct{}),
}
if len(options.Disco) > 0 {
log.Infof("creating Consul client with Agent URL: %s", options.Disco)
var err error
ctx.disco, err = disco.New(&disco.Options{
Type: "consul",
Args: util.DynamicMap{"URL": options.Disco}})
if err != nil {
return nil, err
}
} else {
ctx.disco, _ = disco.New(&disco.Options{Type: "none"})
}
if len(options.Endpoints) > 0 {
// TODO(@kobolog): Bind virtual services on multiple endpoints.
ctx.endpoint = options.Endpoints[0]
if options.ListenPort != 0 {
log.Info("Registered the REST service to Consul.")
ctx.disco.Expose("gorb", ctx.endpoint.String(), options.ListenPort)
}
}
if err := ctx.ipvs.Init(); err != nil {
log.Errorf("unable to initialize IPVS context: %s", err)
// Here and in other places: IPVS errors are abstracted to make GNL2GO
// replaceable in the future, since it's not really maintained anymore.
return nil, ErrIpvsSyscallFailed
}
if options.Flush && ctx.ipvs.Flush() != nil {
log.Errorf("unable to clean up IPVS pools - ensure ip_vs is loaded")
ctx.Close()
return nil, ErrIpvsSyscallFailed
}
if options.VipInterface != "" {
var err error
if ctx.vipInterface, err = netlink.LinkByName(options.VipInterface); err != nil {
ctx.Close()
return nil, fmt.Errorf(
"unable to find the interface '%s' for VIPs: %s",
options.VipInterface, err)
}
log.Infof("VIPs will be added to interface '%s'", ctx.vipInterface.Attrs().Name)
}
// Fire off a pulse notifications sink goroutine.
go ctx.run()
return ctx, nil
} | [
"func",
"NewContext",
"(",
"options",
"ContextOptions",
")",
"(",
"*",
"Context",
",",
"error",
")",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"ctx",
":=",
"&",
"Context",
"{",
"ipvs",
":",
"&",
"gnl2go",
".",
"IpvsClient",
"{",
"}",
"... | // NewContext creates a new Context and initializes IPVS. | [
"NewContext",
"creates",
"a",
"new",
"Context",
"and",
"initializes",
"IPVS",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/context.go#L92-L157 |
16,626 | kobolog/gorb | core/context.go | Close | func (ctx *Context) Close() {
log.Info("shutting down IPVS context")
// This will also shutdown the pulse notification sink goroutine.
close(ctx.stopCh)
for vsID := range ctx.services {
ctx.RemoveService(vsID)
}
// This is not strictly required, as far as I know.
ctx.ipvs.Exit()
} | go | func (ctx *Context) Close() {
log.Info("shutting down IPVS context")
// This will also shutdown the pulse notification sink goroutine.
close(ctx.stopCh)
for vsID := range ctx.services {
ctx.RemoveService(vsID)
}
// This is not strictly required, as far as I know.
ctx.ipvs.Exit()
} | [
"func",
"(",
"ctx",
"*",
"Context",
")",
"Close",
"(",
")",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"// This will also shutdown the pulse notification sink goroutine.",
"close",
"(",
"ctx",
".",
"stopCh",
")",
"\n\n",
"for",
"vsID",
":=",
"ran... | // Close shuts down IPVS and closes the Context. | [
"Close",
"shuts",
"down",
"IPVS",
"and",
"closes",
"the",
"Context",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/context.go#L160-L172 |
16,627 | kobolog/gorb | core/context.go | ListServices | func (ctx *Context) ListServices() ([]string, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
r := make([]string, 0, len(ctx.services))
for vsID := range ctx.services {
r = append(r, vsID)
}
return r, nil
} | go | func (ctx *Context) ListServices() ([]string, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
r := make([]string, 0, len(ctx.services))
for vsID := range ctx.services {
r = append(r, vsID)
}
return r, nil
} | [
"func",
"(",
"ctx",
"*",
"Context",
")",
"ListServices",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"ctx",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"ctx",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"r",
":=",
"m... | // ListServices returns a list of all registered services. | [
"ListServices",
"returns",
"a",
"list",
"of",
"all",
"registered",
"services",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/context.go#L486-L497 |
16,628 | kobolog/gorb | core/context.go | GetService | func (ctx *Context) GetService(vsID string) (*ServiceInfo, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
vs, exists := ctx.services[vsID]
if !exists {
return nil, ErrObjectNotFound
}
result := ServiceInfo{Options: vs.options}
// This is O(n), can be optimized with reverse backend map.
for rsID, backend := range ctx.backends {
if backend.service != vs {
continue
}
result.Backends = append(result.Backends, rsID)
result.Health += backend.metrics.Health
}
if len(result.Backends) == 0 {
// Service without backends is healthy, albeit useless.
result.Health = 1.0
} else {
result.Health /= float64(len(result.Backends))
}
return &result, nil
} | go | func (ctx *Context) GetService(vsID string) (*ServiceInfo, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
vs, exists := ctx.services[vsID]
if !exists {
return nil, ErrObjectNotFound
}
result := ServiceInfo{Options: vs.options}
// This is O(n), can be optimized with reverse backend map.
for rsID, backend := range ctx.backends {
if backend.service != vs {
continue
}
result.Backends = append(result.Backends, rsID)
result.Health += backend.metrics.Health
}
if len(result.Backends) == 0 {
// Service without backends is healthy, albeit useless.
result.Health = 1.0
} else {
result.Health /= float64(len(result.Backends))
}
return &result, nil
} | [
"func",
"(",
"ctx",
"*",
"Context",
")",
"GetService",
"(",
"vsID",
"string",
")",
"(",
"*",
"ServiceInfo",
",",
"error",
")",
"{",
"ctx",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"ctx",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
... | // GetService returns information about a virtual service. | [
"GetService",
"returns",
"information",
"about",
"a",
"virtual",
"service",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/context.go#L508-L538 |
16,629 | kobolog/gorb | core/context.go | GetBackend | func (ctx *Context) GetBackend(vsID, rsID string) (*BackendInfo, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
rs, exists := ctx.backends[rsID]
if !exists {
return nil, ErrObjectNotFound
}
return &BackendInfo{rs.options, rs.metrics}, nil
} | go | func (ctx *Context) GetBackend(vsID, rsID string) (*BackendInfo, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
rs, exists := ctx.backends[rsID]
if !exists {
return nil, ErrObjectNotFound
}
return &BackendInfo{rs.options, rs.metrics}, nil
} | [
"func",
"(",
"ctx",
"*",
"Context",
")",
"GetBackend",
"(",
"vsID",
",",
"rsID",
"string",
")",
"(",
"*",
"BackendInfo",
",",
"error",
")",
"{",
"ctx",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"ctx",
".",
"mutex",
".",
"RUnlock",
"(",
... | // GetBackend returns information about a backend. | [
"GetBackend",
"returns",
"information",
"about",
"a",
"backend",
"."
] | 8240420c08e2486a34a043eff26df7d387791743 | https://github.com/kobolog/gorb/blob/8240420c08e2486a34a043eff26df7d387791743/core/context.go#L547-L558 |
16,630 | vanng822/go-solr | solr/parser.go | ParseFacets | func (parser *ExtensiveResultParser) ParseFacets(response *SolrResponse, sr *SolrResult) {
if fc, ok := response.Response["facet_counts"].(map[string]interface{}); ok {
sr.FacetCounts = fc
if f, ok := fc["facet_fields"].(map[string]interface{}); ok {
sr.Facets = f
}
}
} | go | func (parser *ExtensiveResultParser) ParseFacets(response *SolrResponse, sr *SolrResult) {
if fc, ok := response.Response["facet_counts"].(map[string]interface{}); ok {
sr.FacetCounts = fc
if f, ok := fc["facet_fields"].(map[string]interface{}); ok {
sr.Facets = f
}
}
} | [
"func",
"(",
"parser",
"*",
"ExtensiveResultParser",
")",
"ParseFacets",
"(",
"response",
"*",
"SolrResponse",
",",
"sr",
"*",
"SolrResult",
")",
"{",
"if",
"fc",
",",
"ok",
":=",
"response",
".",
"Response",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",... | // ParseJsonFacets will assign facets and build sr.jsonfacets if there is a facet_counts | [
"ParseJsonFacets",
"will",
"assign",
"facets",
"and",
"build",
"sr",
".",
"jsonfacets",
"if",
"there",
"is",
"a",
"facet_counts"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/parser.go#L88-L95 |
16,631 | vanng822/go-solr | solr/parser.go | ParseJsonFacets | func (parser *ExtensiveResultParser) ParseJsonFacets(response *SolrResponse, sr *SolrResult) {
if jf, ok := response.Response["facets"].(map[string]interface{}); ok {
sr.JsonFacets = jf
}
} | go | func (parser *ExtensiveResultParser) ParseJsonFacets(response *SolrResponse, sr *SolrResult) {
if jf, ok := response.Response["facets"].(map[string]interface{}); ok {
sr.JsonFacets = jf
}
} | [
"func",
"(",
"parser",
"*",
"ExtensiveResultParser",
")",
"ParseJsonFacets",
"(",
"response",
"*",
"SolrResponse",
",",
"sr",
"*",
"SolrResult",
")",
"{",
"if",
"jf",
",",
"ok",
":=",
"response",
".",
"Response",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
... | // ParseJsonFacets will assign facets and build sr.jsonfacets if there is a facets | [
"ParseJsonFacets",
"will",
"assign",
"facets",
"and",
"build",
"sr",
".",
"jsonfacets",
"if",
"there",
"is",
"a",
"facets"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/parser.go#L98-L102 |
16,632 | vanng822/go-solr | solr/parser.go | ParseFacetCounts | func (parser *StandardResultParser) ParseFacetCounts(response *SolrResponse, sr *SolrResult) {
if facetCounts, ok := response.Response["facet_counts"].(map[string]interface{}); ok {
sr.FacetCounts = facetCounts
}
} | go | func (parser *StandardResultParser) ParseFacetCounts(response *SolrResponse, sr *SolrResult) {
if facetCounts, ok := response.Response["facet_counts"].(map[string]interface{}); ok {
sr.FacetCounts = facetCounts
}
} | [
"func",
"(",
"parser",
"*",
"StandardResultParser",
")",
"ParseFacetCounts",
"(",
"response",
"*",
"SolrResponse",
",",
"sr",
"*",
"SolrResult",
")",
"{",
"if",
"facetCounts",
",",
"ok",
":=",
"response",
".",
"Response",
"[",
"\"",
"\"",
"]",
".",
"(",
... | // ParseFacetCounts will assign facet_counts to sr if there is one.
// No modification done here | [
"ParseFacetCounts",
"will",
"assign",
"facet_counts",
"to",
"sr",
"if",
"there",
"is",
"one",
".",
"No",
"modification",
"done",
"here"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/parser.go#L198-L202 |
16,633 | vanng822/go-solr | solr/parser.go | ParseHighlighting | func (parser *StandardResultParser) ParseHighlighting(response *SolrResponse, sr *SolrResult) {
if highlighting, ok := response.Response["highlighting"].(map[string]interface{}); ok {
sr.Highlighting = highlighting
}
} | go | func (parser *StandardResultParser) ParseHighlighting(response *SolrResponse, sr *SolrResult) {
if highlighting, ok := response.Response["highlighting"].(map[string]interface{}); ok {
sr.Highlighting = highlighting
}
} | [
"func",
"(",
"parser",
"*",
"StandardResultParser",
")",
"ParseHighlighting",
"(",
"response",
"*",
"SolrResponse",
",",
"sr",
"*",
"SolrResult",
")",
"{",
"if",
"highlighting",
",",
"ok",
":=",
"response",
".",
"Response",
"[",
"\"",
"\"",
"]",
".",
"(",
... | // ParseHighlighting will assign highlighting to sr if there is one.
// No modification done here | [
"ParseHighlighting",
"will",
"assign",
"highlighting",
"to",
"sr",
"if",
"there",
"is",
"one",
".",
"No",
"modification",
"done",
"here"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/parser.go#L206-L210 |
16,634 | vanng822/go-solr | solr/parser.go | ParseStats | func (parser *StandardResultParser) ParseStats(response *SolrResponse, sr *SolrResult) {
if stats, ok := response.Response["stats"].(map[string]interface{}); ok {
sr.Stats = stats
}
} | go | func (parser *StandardResultParser) ParseStats(response *SolrResponse, sr *SolrResult) {
if stats, ok := response.Response["stats"].(map[string]interface{}); ok {
sr.Stats = stats
}
} | [
"func",
"(",
"parser",
"*",
"StandardResultParser",
")",
"ParseStats",
"(",
"response",
"*",
"SolrResponse",
",",
"sr",
"*",
"SolrResult",
")",
"{",
"if",
"stats",
",",
"ok",
":=",
"response",
".",
"Response",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"["... | // Parse stats if there is in response | [
"Parse",
"stats",
"if",
"there",
"is",
"in",
"response"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/parser.go#L213-L217 |
16,635 | vanng822/go-solr | solr/core_admin.go | SetBasicAuth | func (ca *CoreAdmin) SetBasicAuth(username, password string) {
ca.username = username
ca.password = password
} | go | func (ca *CoreAdmin) SetBasicAuth(username, password string) {
ca.username = username
ca.password = password
} | [
"func",
"(",
"ca",
"*",
"CoreAdmin",
")",
"SetBasicAuth",
"(",
"username",
",",
"password",
"string",
")",
"{",
"ca",
".",
"username",
"=",
"username",
"\n",
"ca",
".",
"password",
"=",
"password",
"\n",
"}"
] | // Set basic auth in case solr require login | [
"Set",
"basic",
"auth",
"in",
"case",
"solr",
"require",
"login"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/core_admin.go#L28-L31 |
16,636 | vanng822/go-solr | solr/connection.go | HTTPPost | func HTTPPost(path string, data *[]byte, headers [][]string, username, password string) ([]byte, error) {
var (
req *http.Request
err error
)
client := &http.Client{Transport: &transport}
if data == nil {
req, err = http.NewRequest("POST", path, nil)
} else {
req, err = http.NewRequest("POST", path, bytes.NewReader(*data))
}
if err != nil {
return nil, err
}
if username != "" && password != "" {
req.SetBasicAuth(username, password)
}
if len(headers) > 0 {
for i := range headers {
req.Header.Add(headers[i][0], headers[i][1])
}
}
return makeRequest(client, req)
} | go | func HTTPPost(path string, data *[]byte, headers [][]string, username, password string) ([]byte, error) {
var (
req *http.Request
err error
)
client := &http.Client{Transport: &transport}
if data == nil {
req, err = http.NewRequest("POST", path, nil)
} else {
req, err = http.NewRequest("POST", path, bytes.NewReader(*data))
}
if err != nil {
return nil, err
}
if username != "" && password != "" {
req.SetBasicAuth(username, password)
}
if len(headers) > 0 {
for i := range headers {
req.Header.Add(headers[i][0], headers[i][1])
}
}
return makeRequest(client, req)
} | [
"func",
"HTTPPost",
"(",
"path",
"string",
",",
"data",
"*",
"[",
"]",
"byte",
",",
"headers",
"[",
"]",
"[",
"]",
"string",
",",
"username",
",",
"password",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"req",
"*",
... | // HTTPPost make a POST request to path which also includes domain, headers are optional | [
"HTTPPost",
"make",
"a",
"POST",
"request",
"to",
"path",
"which",
"also",
"includes",
"domain",
"headers",
"are",
"optional"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/connection.go#L24-L51 |
16,637 | vanng822/go-solr | solr/connection.go | HTTPGet | func HTTPGet(url string, headers [][]string, username, password string) ([]byte, error) {
client := &http.Client{Transport: &transport}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
if username != "" && password != "" {
req.SetBasicAuth(username, password)
}
if len(headers) > 0 {
for i := range headers {
req.Header.Add(headers[i][0], headers[i][1])
}
}
return makeRequest(client, req)
} | go | func HTTPGet(url string, headers [][]string, username, password string) ([]byte, error) {
client := &http.Client{Transport: &transport}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
if username != "" && password != "" {
req.SetBasicAuth(username, password)
}
if len(headers) > 0 {
for i := range headers {
req.Header.Add(headers[i][0], headers[i][1])
}
}
return makeRequest(client, req)
} | [
"func",
"HTTPGet",
"(",
"url",
"string",
",",
"headers",
"[",
"]",
"[",
"]",
"string",
",",
"username",
",",
"password",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"client",
":=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":"... | // HTTPGet make a GET request to url, headers are optional | [
"HTTPGet",
"make",
"a",
"GET",
"request",
"to",
"url",
"headers",
"are",
"optional"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/connection.go#L54-L72 |
16,638 | vanng822/go-solr | solr/connection.go | NewConnection | func NewConnection(solrUrl, core string) (*Connection, error) {
u, err := url.ParseRequestURI(strings.TrimRight(solrUrl, "/"))
if err != nil {
return nil, err
}
return &Connection{url: u, core: core}, nil
} | go | func NewConnection(solrUrl, core string) (*Connection, error) {
u, err := url.ParseRequestURI(strings.TrimRight(solrUrl, "/"))
if err != nil {
return nil, err
}
return &Connection{url: u, core: core}, nil
} | [
"func",
"NewConnection",
"(",
"solrUrl",
",",
"core",
"string",
")",
"(",
"*",
"Connection",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"strings",
".",
"TrimRight",
"(",
"solrUrl",
",",
"\"",
"\"",
")",
")",
"\... | // NewConnection will parse solrUrl and return a connection object, solrUrl must be a absolute url or path | [
"NewConnection",
"will",
"parse",
"solrUrl",
"and",
"return",
"a",
"connection",
"object",
"solrUrl",
"must",
"be",
"a",
"absolute",
"url",
"or",
"path"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/connection.go#L129-L135 |
16,639 | vanng822/go-solr | solr/connection.go | Update | func (c *Connection) Update(data interface{}, params *url.Values) (*SolrUpdateResponse, error) {
b, err := json2bytes(data)
if err != nil {
return nil, err
}
if params == nil {
params = &url.Values{}
}
params.Set("wt", "json")
r, err := HTTPPost(fmt.Sprintf("%s/%s/update/?%s", c.url.String(), c.core, params.Encode()), b, [][]string{{"Content-Type", "application/json"}}, c.username, c.password)
if err != nil {
return nil, err
}
resp, err := bytes2json(&r)
if err != nil {
return nil, err
}
// check error in resp
if !successStatus(resp) || hasError(resp) {
return &SolrUpdateResponse{Success: false, Result: resp}, nil
}
return &SolrUpdateResponse{Success: true, Result: resp}, nil
} | go | func (c *Connection) Update(data interface{}, params *url.Values) (*SolrUpdateResponse, error) {
b, err := json2bytes(data)
if err != nil {
return nil, err
}
if params == nil {
params = &url.Values{}
}
params.Set("wt", "json")
r, err := HTTPPost(fmt.Sprintf("%s/%s/update/?%s", c.url.String(), c.core, params.Encode()), b, [][]string{{"Content-Type", "application/json"}}, c.username, c.password)
if err != nil {
return nil, err
}
resp, err := bytes2json(&r)
if err != nil {
return nil, err
}
// check error in resp
if !successStatus(resp) || hasError(resp) {
return &SolrUpdateResponse{Success: false, Result: resp}, nil
}
return &SolrUpdateResponse{Success: true, Result: resp}, nil
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"Update",
"(",
"data",
"interface",
"{",
"}",
",",
"params",
"*",
"url",
".",
"Values",
")",
"(",
"*",
"SolrUpdateResponse",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"json2bytes",
"(",
"data",
")",
"\... | // Update take optional params which can use to specify addition parameters such as commit=true | [
"Update",
"take",
"optional",
"params",
"which",
"can",
"use",
"to",
"specify",
"addition",
"parameters",
"such",
"as",
"commit",
"=",
"true"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/connection.go#L172-L201 |
16,640 | vanng822/go-solr | solr/search.go | NewSearch | func NewSearch(c *Connection, q *Query) *Search {
s := new(Search)
if q != nil {
s.SetQuery(q)
}
if c != nil {
s.conn = c
}
return s
} | go | func NewSearch(c *Connection, q *Query) *Search {
s := new(Search)
if q != nil {
s.SetQuery(q)
}
if c != nil {
s.conn = c
}
return s
} | [
"func",
"NewSearch",
"(",
"c",
"*",
"Connection",
",",
"q",
"*",
"Query",
")",
"*",
"Search",
"{",
"s",
":=",
"new",
"(",
"Search",
")",
"\n",
"if",
"q",
"!=",
"nil",
"{",
"s",
".",
"SetQuery",
"(",
"q",
")",
"\n",
"}",
"\n\n",
"if",
"c",
"!=... | // NewSearch takes c and q as optional | [
"NewSearch",
"takes",
"c",
"and",
"q",
"as",
"optional"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/search.go#L15-L25 |
16,641 | vanng822/go-solr | solr/search.go | QueryParams | func (s *Search) QueryParams() *url.Values {
if s.query == nil {
s.query = NewQuery()
}
if s.Debug != "" {
s.query.params.Set("debug", s.Debug)
s.query.params.Set("indent", "true")
}
return s.query.params
} | go | func (s *Search) QueryParams() *url.Values {
if s.query == nil {
s.query = NewQuery()
}
if s.Debug != "" {
s.query.params.Set("debug", s.Debug)
s.query.params.Set("indent", "true")
}
return s.query.params
} | [
"func",
"(",
"s",
"*",
"Search",
")",
"QueryParams",
"(",
")",
"*",
"url",
".",
"Values",
"{",
"if",
"s",
".",
"query",
"==",
"nil",
"{",
"s",
".",
"query",
"=",
"NewQuery",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"Debug",
"!=",
"\"",
"\... | // Return query params including debug and indent if Debug is set | [
"Return",
"query",
"params",
"including",
"debug",
"and",
"indent",
"if",
"Debug",
"is",
"set"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/search.go#L33-L45 |
16,642 | vanng822/go-solr | solr/search.go | Result | func (s *Search) Result(parser ResultParser) (*SolrResult, error) {
resp, err := s.Resource("select", s.QueryParams())
if err != nil {
return nil, err
}
if parser == nil {
parser = new(StandardResultParser)
}
return parser.Parse(resp)
} | go | func (s *Search) Result(parser ResultParser) (*SolrResult, error) {
resp, err := s.Resource("select", s.QueryParams())
if err != nil {
return nil, err
}
if parser == nil {
parser = new(StandardResultParser)
}
return parser.Parse(resp)
} | [
"func",
"(",
"s",
"*",
"Search",
")",
"Result",
"(",
"parser",
"ResultParser",
")",
"(",
"*",
"SolrResult",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"Resource",
"(",
"\"",
"\"",
",",
"s",
".",
"QueryParams",
"(",
")",
")",
"\n"... | // Result will create a StandardResultParser if no parser specified.
// parser must be an implementation of ResultParser interface | [
"Result",
"will",
"create",
"a",
"StandardResultParser",
"if",
"no",
"parser",
"specified",
".",
"parser",
"must",
"be",
"an",
"implementation",
"of",
"ResultParser",
"interface"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/search.go#L64-L73 |
16,643 | vanng822/go-solr | solr/schema.go | NewSchema | func NewSchema(solrUrl, core string) (*Schema, error) {
u, err := url.ParseRequestURI(strings.TrimRight(solrUrl, "/"))
if err != nil {
return nil, err
}
return &Schema{url: u, core: core}, nil
} | go | func NewSchema(solrUrl, core string) (*Schema, error) {
u, err := url.ParseRequestURI(strings.TrimRight(solrUrl, "/"))
if err != nil {
return nil, err
}
return &Schema{url: u, core: core}, nil
} | [
"func",
"NewSchema",
"(",
"solrUrl",
",",
"core",
"string",
")",
"(",
"*",
"Schema",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"strings",
".",
"TrimRight",
"(",
"solrUrl",
",",
"\"",
"\"",
")",
")",
"\n",
"i... | // NewSchema will parse solrUrl and return a schema object, solrUrl must be a absolute url or path | [
"NewSchema",
"will",
"parse",
"solrUrl",
"and",
"return",
"a",
"schema",
"object",
"solrUrl",
"must",
"be",
"a",
"absolute",
"url",
"or",
"path"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/schema.go#L17-L24 |
16,644 | vanng822/go-solr | solr/query.go | Start | func (q *Query) Start(start int) {
q.params.Set("start", fmt.Sprintf("%d", start))
} | go | func (q *Query) Start(start int) {
q.params.Set("start", fmt.Sprintf("%d", start))
} | [
"func",
"(",
"q",
"*",
"Query",
")",
"Start",
"(",
"start",
"int",
")",
"{",
"q",
".",
"params",
".",
"Set",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"start",
")",
")",
"\n",
"}"
] | // Start sets start value which is the offset of result | [
"Start",
"sets",
"start",
"value",
"which",
"is",
"the",
"offset",
"of",
"result"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/query.go#L127-L129 |
16,645 | vanng822/go-solr | solr/query.go | Rows | func (q *Query) Rows(rows int) {
q.params.Set("rows", fmt.Sprintf("%d", rows))
} | go | func (q *Query) Rows(rows int) {
q.params.Set("rows", fmt.Sprintf("%d", rows))
} | [
"func",
"(",
"q",
"*",
"Query",
")",
"Rows",
"(",
"rows",
"int",
")",
"{",
"q",
".",
"params",
".",
"Set",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"rows",
")",
")",
"\n",
"}"
] | // Rows sets value for rows which means set the limit for how many rows to return | [
"Rows",
"sets",
"value",
"for",
"rows",
"which",
"means",
"set",
"the",
"limit",
"for",
"how",
"many",
"rows",
"to",
"return"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/query.go#L132-L134 |
16,646 | vanng822/go-solr | solr/solr.go | Has | func (d Document) Has(k string) bool {
_, ok := d[k]
return ok
} | go | func (d Document) Has(k string) bool {
_, ok := d[k]
return ok
} | [
"func",
"(",
"d",
"Document",
")",
"Has",
"(",
"k",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"d",
"[",
"k",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // Has check if a key exist in document | [
"Has",
"check",
"if",
"a",
"key",
"exist",
"in",
"document"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L17-L20 |
16,647 | vanng822/go-solr | solr/solr.go | Get | func (d Document) Get(k string) interface{} {
v, _ := d[k]
return v
} | go | func (d Document) Get(k string) interface{} {
v, _ := d[k]
return v
} | [
"func",
"(",
"d",
"Document",
")",
"Get",
"(",
"k",
"string",
")",
"interface",
"{",
"}",
"{",
"v",
",",
"_",
":=",
"d",
"[",
"k",
"]",
"\n",
"return",
"v",
"\n",
"}"
] | // Get returns value of a key | [
"Get",
"returns",
"value",
"of",
"a",
"key"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L23-L26 |
16,648 | vanng822/go-solr | solr/solr.go | NewSolrInterface | func NewSolrInterface(solrUrl, core string) (*SolrInterface, error) {
c, err := NewConnection(solrUrl, core)
if err != nil {
return nil, err
}
return &SolrInterface{conn: c}, nil
} | go | func NewSolrInterface(solrUrl, core string) (*SolrInterface, error) {
c, err := NewConnection(solrUrl, core)
if err != nil {
return nil, err
}
return &SolrInterface{conn: c}, nil
} | [
"func",
"NewSolrInterface",
"(",
"solrUrl",
",",
"core",
"string",
")",
"(",
"*",
"SolrInterface",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"NewConnection",
"(",
"solrUrl",
",",
"core",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
... | // Return a new instance of SolrInterface | [
"Return",
"a",
"new",
"instance",
"of",
"SolrInterface"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L107-L113 |
16,649 | vanng822/go-solr | solr/solr.go | Search | func (si *SolrInterface) Search(q *Query) *Search {
return NewSearch(si.conn, q)
} | go | func (si *SolrInterface) Search(q *Query) *Search {
return NewSearch(si.conn, q)
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"Search",
"(",
"q",
"*",
"Query",
")",
"*",
"Search",
"{",
"return",
"NewSearch",
"(",
"si",
".",
"conn",
",",
"q",
")",
"\n",
"}"
] | // Return a new instace of Search, q is optional and one can set it later | [
"Return",
"a",
"new",
"instace",
"of",
"Search",
"q",
"is",
"optional",
"and",
"one",
"can",
"set",
"it",
"later"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L128-L130 |
16,650 | vanng822/go-solr | solr/solr.go | makeAddChunks | func makeAddChunks(docs []Document, chunk_size int) []map[string]interface{} {
if chunk_size < 1 {
chunk_size = 100
}
docs_len := len(docs)
num_chunk := int(math.Ceil(float64(docs_len) / float64(chunk_size)))
doc_counter := 0
chunks := make([]map[string]interface{}, num_chunk)
for i := 0; i < num_chunk; i++ {
add := make([]Document, 0, chunk_size)
for j := 0; j < chunk_size; j++ {
if doc_counter >= docs_len {
break
}
add = append(add, docs[doc_counter])
doc_counter++
}
chunks[i] = M{"add": add}
}
return chunks
} | go | func makeAddChunks(docs []Document, chunk_size int) []map[string]interface{} {
if chunk_size < 1 {
chunk_size = 100
}
docs_len := len(docs)
num_chunk := int(math.Ceil(float64(docs_len) / float64(chunk_size)))
doc_counter := 0
chunks := make([]map[string]interface{}, num_chunk)
for i := 0; i < num_chunk; i++ {
add := make([]Document, 0, chunk_size)
for j := 0; j < chunk_size; j++ {
if doc_counter >= docs_len {
break
}
add = append(add, docs[doc_counter])
doc_counter++
}
chunks[i] = M{"add": add}
}
return chunks
} | [
"func",
"makeAddChunks",
"(",
"docs",
"[",
"]",
"Document",
",",
"chunk_size",
"int",
")",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"if",
"chunk_size",
"<",
"1",
"{",
"chunk_size",
"=",
"100",
"\n",
"}",
"\n",
"docs_len",
":="... | // makeAddChunks splits the documents into chunks. If chunk_size is less than one it will be default to 100 | [
"makeAddChunks",
"splits",
"the",
"documents",
"into",
"chunks",
".",
"If",
"chunk_size",
"is",
"less",
"than",
"one",
"it",
"will",
"be",
"default",
"to",
"100"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L133-L153 |
16,651 | vanng822/go-solr | solr/solr.go | Add | func (si *SolrInterface) Add(docs []Document, chunk_size int, params *url.Values) (*SolrUpdateResponse, error) {
result := &SolrUpdateResponse{Success: true}
responses := M{}
chunks := makeAddChunks(docs, chunk_size)
for i := 0; i < len(chunks); i++ {
res, err := si.Update(chunks[i], params)
if err != nil {
return nil, err
}
result.Success = result.Success && res.Success
responses[fmt.Sprintf("chunk_%d", i+1)] = M{
"result": res.Result,
"success": res.Success,
"total": len(chunks[i]["add"].([]Document))}
}
result.Result = responses
return result, nil
} | go | func (si *SolrInterface) Add(docs []Document, chunk_size int, params *url.Values) (*SolrUpdateResponse, error) {
result := &SolrUpdateResponse{Success: true}
responses := M{}
chunks := makeAddChunks(docs, chunk_size)
for i := 0; i < len(chunks); i++ {
res, err := si.Update(chunks[i], params)
if err != nil {
return nil, err
}
result.Success = result.Success && res.Success
responses[fmt.Sprintf("chunk_%d", i+1)] = M{
"result": res.Result,
"success": res.Success,
"total": len(chunks[i]["add"].([]Document))}
}
result.Result = responses
return result, nil
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"Add",
"(",
"docs",
"[",
"]",
"Document",
",",
"chunk_size",
"int",
",",
"params",
"*",
"url",
".",
"Values",
")",
"(",
"*",
"SolrUpdateResponse",
",",
"error",
")",
"{",
"result",
":=",
"&",
"SolrUpdateRes... | // Add will insert documents in batch of chunk_size. success is false as long as one chunk failed.
// The result in SolrUpdateResponse is summery of response from all chunks
// with key chunk_%d | [
"Add",
"will",
"insert",
"documents",
"in",
"batch",
"of",
"chunk_size",
".",
"success",
"is",
"false",
"as",
"long",
"as",
"one",
"chunk",
"failed",
".",
"The",
"result",
"in",
"SolrUpdateResponse",
"is",
"summery",
"of",
"response",
"from",
"all",
"chunks"... | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L158-L176 |
16,652 | vanng822/go-solr | solr/solr.go | DeleteAll | func (si *SolrInterface) DeleteAll() (*SolrUpdateResponse, error) {
params := &url.Values{}
params.Add("commit", "true")
return si.Delete(M{"query": "*:*"}, params)
} | go | func (si *SolrInterface) DeleteAll() (*SolrUpdateResponse, error) {
params := &url.Values{}
params.Add("commit", "true")
return si.Delete(M{"query": "*:*"}, params)
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"DeleteAll",
"(",
")",
"(",
"*",
"SolrUpdateResponse",
",",
"error",
")",
"{",
"params",
":=",
"&",
"url",
".",
"Values",
"{",
"}",
"\n",
"params",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"... | // DeleteAll will remove all documents and commit | [
"DeleteAll",
"will",
"remove",
"all",
"documents",
"and",
"commit"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L188-L192 |
16,653 | vanng822/go-solr | solr/solr.go | Commit | func (si *SolrInterface) Commit() (*SolrUpdateResponse, error) {
params := &url.Values{}
params.Add("commit", "true")
return si.Update(M{}, params)
} | go | func (si *SolrInterface) Commit() (*SolrUpdateResponse, error) {
params := &url.Values{}
params.Add("commit", "true")
return si.Update(M{}, params)
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"Commit",
"(",
")",
"(",
"*",
"SolrUpdateResponse",
",",
"error",
")",
"{",
"params",
":=",
"&",
"url",
".",
"Values",
"{",
"}",
"\n",
"params",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n"... | // Commit the changes since the last commit | [
"Commit",
"the",
"changes",
"since",
"the",
"last",
"commit"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L203-L207 |
16,654 | vanng822/go-solr | solr/solr.go | CoreAdmin | func (si *SolrInterface) CoreAdmin() (*CoreAdmin, error) {
ca, err := NewCoreAdmin(si.conn.url.String())
if err != nil {
return nil, err
}
ca.SetBasicAuth(si.conn.username, si.conn.password)
return ca, nil
} | go | func (si *SolrInterface) CoreAdmin() (*CoreAdmin, error) {
ca, err := NewCoreAdmin(si.conn.url.String())
if err != nil {
return nil, err
}
ca.SetBasicAuth(si.conn.username, si.conn.password)
return ca, nil
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"CoreAdmin",
"(",
")",
"(",
"*",
"CoreAdmin",
",",
"error",
")",
"{",
"ca",
",",
"err",
":=",
"NewCoreAdmin",
"(",
"si",
".",
"conn",
".",
"url",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",... | // Return new instance of CoreAdmin with provided solrUrl and basic auth | [
"Return",
"new",
"instance",
"of",
"CoreAdmin",
"with",
"provided",
"solrUrl",
"and",
"basic",
"auth"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L225-L232 |
16,655 | vanng822/go-solr | solr/solr.go | Schema | func (si *SolrInterface) Schema() (*Schema, error) {
s, err := NewSchema(si.conn.url.String(), si.conn.core)
if err != nil {
return nil, err
}
s.SetBasicAuth(si.conn.username, si.conn.password)
return s, nil
} | go | func (si *SolrInterface) Schema() (*Schema, error) {
s, err := NewSchema(si.conn.url.String(), si.conn.core)
if err != nil {
return nil, err
}
s.SetBasicAuth(si.conn.username, si.conn.password)
return s, nil
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"Schema",
"(",
")",
"(",
"*",
"Schema",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"NewSchema",
"(",
"si",
".",
"conn",
".",
"url",
".",
"String",
"(",
")",
",",
"si",
".",
"conn",
".",
"core",
... | // Return new instance of Schema with provided solrUrl and basic auth | [
"Return",
"new",
"instance",
"of",
"Schema",
"with",
"provided",
"solrUrl",
"and",
"basic",
"auth"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L235-L242 |
16,656 | vanng822/go-solr | solr/solr.go | Ping | func (si *SolrInterface) Ping() (status string, qtime int, err error) {
r, err := HTTPGet(fmt.Sprintf("%s/%s/admin/ping?wt=json", si.conn.url.String(), si.conn.core), nil, si.conn.username, si.conn.password)
if err != nil {
return "", -1, err
}
resp, err := bytes2json(&r)
if err != nil {
return "", -1, err
}
status, ok := resp["status"].(string)
if ok == false {
return "", -1, fmt.Errorf("Unexpected response returned")
}
if QTime, ok := resp["responseHeader"].(map[string]interface{})["QTime"].(float64); ok {
qtime = int(QTime)
} else {
qtime = -1
}
return status, qtime, nil
} | go | func (si *SolrInterface) Ping() (status string, qtime int, err error) {
r, err := HTTPGet(fmt.Sprintf("%s/%s/admin/ping?wt=json", si.conn.url.String(), si.conn.core), nil, si.conn.username, si.conn.password)
if err != nil {
return "", -1, err
}
resp, err := bytes2json(&r)
if err != nil {
return "", -1, err
}
status, ok := resp["status"].(string)
if ok == false {
return "", -1, fmt.Errorf("Unexpected response returned")
}
if QTime, ok := resp["responseHeader"].(map[string]interface{})["QTime"].(float64); ok {
qtime = int(QTime)
} else {
qtime = -1
}
return status, qtime, nil
} | [
"func",
"(",
"si",
"*",
"SolrInterface",
")",
"Ping",
"(",
")",
"(",
"status",
"string",
",",
"qtime",
"int",
",",
"err",
"error",
")",
"{",
"r",
",",
"err",
":=",
"HTTPGet",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"si",
".",
"conn",
... | // Return 'status' and QTime from solr, if everything is fine status should have value 'OK'
// QTime will have value -1 if can not determine | [
"Return",
"status",
"and",
"QTime",
"from",
"solr",
"if",
"everything",
"is",
"fine",
"status",
"should",
"have",
"value",
"OK",
"QTime",
"will",
"have",
"value",
"-",
"1",
"if",
"can",
"not",
"determine"
] | e3dd1d051d54b735110ab6ed8a6c6f948c8d789f | https://github.com/vanng822/go-solr/blob/e3dd1d051d54b735110ab6ed8a6c6f948c8d789f/solr/solr.go#L246-L266 |
16,657 | mfonda/simhash | simhash.go | Vectorize | func Vectorize(features []Feature) Vector {
var v Vector
for _, feature := range features {
sum := feature.Sum()
weight := feature.Weight()
for i := uint8(0); i < 64; i++ {
bit := ((sum >> i) & 1)
if bit == 1 {
v[i] += weight
} else {
v[i] -= weight
}
}
}
return v
} | go | func Vectorize(features []Feature) Vector {
var v Vector
for _, feature := range features {
sum := feature.Sum()
weight := feature.Weight()
for i := uint8(0); i < 64; i++ {
bit := ((sum >> i) & 1)
if bit == 1 {
v[i] += weight
} else {
v[i] -= weight
}
}
}
return v
} | [
"func",
"Vectorize",
"(",
"features",
"[",
"]",
"Feature",
")",
"Vector",
"{",
"var",
"v",
"Vector",
"\n",
"for",
"_",
",",
"feature",
":=",
"range",
"features",
"{",
"sum",
":=",
"feature",
".",
"Sum",
"(",
")",
"\n",
"weight",
":=",
"feature",
".",... | // Vectorize generates 64 dimension vectors given a set of features.
// Vectors are initialized to zero. The i-th element of the vector is then
// incremented by weight of the i-th feature if the i-th bit of the feature
// is set, and decremented by the weight of the i-th feature otherwise. | [
"Vectorize",
"generates",
"64",
"dimension",
"vectors",
"given",
"a",
"set",
"of",
"features",
".",
"Vectors",
"are",
"initialized",
"to",
"zero",
".",
"The",
"i",
"-",
"th",
"element",
"of",
"the",
"vector",
"is",
"then",
"incremented",
"by",
"weight",
"o... | 79f94a1100d6da8bee6f6c253efc860a137a3186 | https://github.com/mfonda/simhash/blob/79f94a1100d6da8bee6f6c253efc860a137a3186/simhash.go#L40-L55 |
16,658 | mfonda/simhash | simhash.go | NewFeature | func NewFeature(f []byte) feature {
h := fnv.New64()
h.Write(f)
return feature{h.Sum64(), 1}
} | go | func NewFeature(f []byte) feature {
h := fnv.New64()
h.Write(f)
return feature{h.Sum64(), 1}
} | [
"func",
"NewFeature",
"(",
"f",
"[",
"]",
"byte",
")",
"feature",
"{",
"h",
":=",
"fnv",
".",
"New64",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"f",
")",
"\n",
"return",
"feature",
"{",
"h",
".",
"Sum64",
"(",
")",
",",
"1",
"}",
"\n",
"}"
] | // Returns a new feature representing the given byte slice, using a weight of 1 | [
"Returns",
"a",
"new",
"feature",
"representing",
"the",
"given",
"byte",
"slice",
"using",
"a",
"weight",
"of",
"1"
] | 79f94a1100d6da8bee6f6c253efc860a137a3186 | https://github.com/mfonda/simhash/blob/79f94a1100d6da8bee6f6c253efc860a137a3186/simhash.go#L112-L116 |
16,659 | mfonda/simhash | simhash.go | NewFeatureWithWeight | func NewFeatureWithWeight(f []byte, weight int) feature {
fw := NewFeature(f)
fw.weight = weight
return fw
} | go | func NewFeatureWithWeight(f []byte, weight int) feature {
fw := NewFeature(f)
fw.weight = weight
return fw
} | [
"func",
"NewFeatureWithWeight",
"(",
"f",
"[",
"]",
"byte",
",",
"weight",
"int",
")",
"feature",
"{",
"fw",
":=",
"NewFeature",
"(",
"f",
")",
"\n",
"fw",
".",
"weight",
"=",
"weight",
"\n",
"return",
"fw",
"\n",
"}"
] | // Returns a new feature representing the given byte slice with the given weight | [
"Returns",
"a",
"new",
"feature",
"representing",
"the",
"given",
"byte",
"slice",
"with",
"the",
"given",
"weight"
] | 79f94a1100d6da8bee6f6c253efc860a137a3186 | https://github.com/mfonda/simhash/blob/79f94a1100d6da8bee6f6c253efc860a137a3186/simhash.go#L119-L123 |
16,660 | hnakamur/go-scp | sink.go | ReceiveFile | func (s *SCP) ReceiveFile(srcFile, destFile string) error {
srcFile = realPath(filepath.Clean(srcFile))
destFile = filepath.Clean(destFile)
fiDest, err := os.Stat(destFile)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("failed to get information of destnation file: err=%s", err)
}
if err == nil && fiDest.IsDir() {
destFile = filepath.Join(destFile, filepath.Base(srcFile))
}
return runSinkSession(s.client, srcFile, false, "", false, true, func(s *sinkSession) error {
h, err := s.ReadHeaderOrReply()
if err != nil {
return fmt.Errorf("failed to read scp message header: err=%s", err)
}
timeHeader, ok := h.(timeMsgHeader)
if !ok {
return fmt.Errorf("expected time message header, got %+v", h)
}
h, err = s.ReadHeaderOrReply()
if err != nil {
return fmt.Errorf("failed to read scp message header: err=%s", err)
}
fileHeader, ok := h.(fileMsgHeader)
if !ok {
return fmt.Errorf("expected file message header, got %+v", h)
}
return copyFileBodyFromRemote(s, destFile, timeHeader, fileHeader)
})
} | go | func (s *SCP) ReceiveFile(srcFile, destFile string) error {
srcFile = realPath(filepath.Clean(srcFile))
destFile = filepath.Clean(destFile)
fiDest, err := os.Stat(destFile)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("failed to get information of destnation file: err=%s", err)
}
if err == nil && fiDest.IsDir() {
destFile = filepath.Join(destFile, filepath.Base(srcFile))
}
return runSinkSession(s.client, srcFile, false, "", false, true, func(s *sinkSession) error {
h, err := s.ReadHeaderOrReply()
if err != nil {
return fmt.Errorf("failed to read scp message header: err=%s", err)
}
timeHeader, ok := h.(timeMsgHeader)
if !ok {
return fmt.Errorf("expected time message header, got %+v", h)
}
h, err = s.ReadHeaderOrReply()
if err != nil {
return fmt.Errorf("failed to read scp message header: err=%s", err)
}
fileHeader, ok := h.(fileMsgHeader)
if !ok {
return fmt.Errorf("expected file message header, got %+v", h)
}
return copyFileBodyFromRemote(s, destFile, timeHeader, fileHeader)
})
} | [
"func",
"(",
"s",
"*",
"SCP",
")",
"ReceiveFile",
"(",
"srcFile",
",",
"destFile",
"string",
")",
"error",
"{",
"srcFile",
"=",
"realPath",
"(",
"filepath",
".",
"Clean",
"(",
"srcFile",
")",
")",
"\n",
"destFile",
"=",
"filepath",
".",
"Clean",
"(",
... | // ReceiveFile copies a single remote file to the local machine with
// the specified name. The time and permission will be set to the same value
// of the source file. | [
"ReceiveFile",
"copies",
"a",
"single",
"remote",
"file",
"to",
"the",
"local",
"machine",
"with",
"the",
"specified",
"name",
".",
"The",
"time",
"and",
"permission",
"will",
"be",
"set",
"to",
"the",
"same",
"value",
"of",
"the",
"source",
"file",
"."
] | badb3bf1aae27e4e97b6494af96eed04a145a8a6 | https://github.com/hnakamur/go-scp/blob/badb3bf1aae27e4e97b6494af96eed04a145a8a6/sink.go#L54-L86 |
16,661 | hnakamur/go-scp | source.go | SendFile | func (s *SCP) SendFile(srcFile, destFile string) error {
srcFile = filepath.Clean(srcFile)
destFile = realPath(filepath.Clean(destFile))
return runSourceSession(s.client, destFile, false, "", false, true, func(s *sourceSession) error {
osFileInfo, err := os.Stat(srcFile)
if err != nil {
return fmt.Errorf("failed to stat source file: err=%s", err)
}
fi := newFileInfoFromOS(osFileInfo, "")
file, err := os.Open(srcFile)
if err != nil {
return fmt.Errorf("failed to open source file: err=%s", err)
}
// NOTE: file will be closed by WriteFile.
err = s.WriteFile(fi, file)
if err != nil {
return fmt.Errorf("failed to copy file: err=%s", err)
}
return nil
})
} | go | func (s *SCP) SendFile(srcFile, destFile string) error {
srcFile = filepath.Clean(srcFile)
destFile = realPath(filepath.Clean(destFile))
return runSourceSession(s.client, destFile, false, "", false, true, func(s *sourceSession) error {
osFileInfo, err := os.Stat(srcFile)
if err != nil {
return fmt.Errorf("failed to stat source file: err=%s", err)
}
fi := newFileInfoFromOS(osFileInfo, "")
file, err := os.Open(srcFile)
if err != nil {
return fmt.Errorf("failed to open source file: err=%s", err)
}
// NOTE: file will be closed by WriteFile.
err = s.WriteFile(fi, file)
if err != nil {
return fmt.Errorf("failed to copy file: err=%s", err)
}
return nil
})
} | [
"func",
"(",
"s",
"*",
"SCP",
")",
"SendFile",
"(",
"srcFile",
",",
"destFile",
"string",
")",
"error",
"{",
"srcFile",
"=",
"filepath",
".",
"Clean",
"(",
"srcFile",
")",
"\n",
"destFile",
"=",
"realPath",
"(",
"filepath",
".",
"Clean",
"(",
"destFile... | // SendFile copies a single local file to the remote server.
// The time and permission will be set with the value of the source file. | [
"SendFile",
"copies",
"a",
"single",
"local",
"file",
"to",
"the",
"remote",
"server",
".",
"The",
"time",
"and",
"permission",
"will",
"be",
"set",
"with",
"the",
"value",
"of",
"the",
"source",
"file",
"."
] | badb3bf1aae27e4e97b6494af96eed04a145a8a6 | https://github.com/hnakamur/go-scp/blob/badb3bf1aae27e4e97b6494af96eed04a145a8a6/source.go#L33-L55 |
16,662 | hnakamur/go-scp | source.go | SendDir | func (s *SCP) SendDir(srcDir, destDir string, acceptFn AcceptFunc) error {
srcDir = filepath.Clean(srcDir)
destDir = realPath(filepath.Clean(destDir))
if acceptFn == nil {
acceptFn = acceptAny
}
return runSourceSession(s.client, destDir, false, "", true, true, func(s *sourceSession) error {
prevDirSkipped := false
endDirectories := func(prevDir, dir string) error {
rel, err := filepath.Rel(prevDir, dir)
if err != nil {
return err
}
for _, comp := range strings.Split(rel, string([]rune{filepath.Separator})) {
if comp == ".." {
if prevDirSkipped {
prevDirSkipped = false
} else {
err := s.EndDirectory()
if err != nil {
return err
}
}
}
}
return nil
}
prevDir := srcDir
myWalkFn := func(path string, info os.FileInfo, err error) error {
// We must check err is not nil first.
// See https://golang.org/pkg/path/filepath/#WalkFunc
if err != nil {
return err
}
isDir := info.IsDir()
var dir string
if isDir {
dir = path
} else {
dir = filepath.Dir(path)
}
defer func() {
prevDir = dir
}()
err = endDirectories(prevDir, dir)
if err != nil {
return err
}
scpFileInfo := newFileInfoFromOS(info, "")
accepted, err := acceptFn(filepath.Dir(path), scpFileInfo)
if err != nil {
return err
}
if isDir {
if !accepted {
prevDirSkipped = true
return filepath.SkipDir
}
err := s.StartDirectory(scpFileInfo)
if err != nil {
return err
}
} else {
if accepted {
fi := newFileInfoFromOS(info, "")
file, err := os.Open(path)
if err != nil {
return err
}
err = s.WriteFile(fi, file)
if err != nil {
return err
}
}
}
return nil
}
err := filepath.Walk(srcDir, myWalkFn)
if err != nil {
return err
}
return endDirectories(prevDir, srcDir)
})
} | go | func (s *SCP) SendDir(srcDir, destDir string, acceptFn AcceptFunc) error {
srcDir = filepath.Clean(srcDir)
destDir = realPath(filepath.Clean(destDir))
if acceptFn == nil {
acceptFn = acceptAny
}
return runSourceSession(s.client, destDir, false, "", true, true, func(s *sourceSession) error {
prevDirSkipped := false
endDirectories := func(prevDir, dir string) error {
rel, err := filepath.Rel(prevDir, dir)
if err != nil {
return err
}
for _, comp := range strings.Split(rel, string([]rune{filepath.Separator})) {
if comp == ".." {
if prevDirSkipped {
prevDirSkipped = false
} else {
err := s.EndDirectory()
if err != nil {
return err
}
}
}
}
return nil
}
prevDir := srcDir
myWalkFn := func(path string, info os.FileInfo, err error) error {
// We must check err is not nil first.
// See https://golang.org/pkg/path/filepath/#WalkFunc
if err != nil {
return err
}
isDir := info.IsDir()
var dir string
if isDir {
dir = path
} else {
dir = filepath.Dir(path)
}
defer func() {
prevDir = dir
}()
err = endDirectories(prevDir, dir)
if err != nil {
return err
}
scpFileInfo := newFileInfoFromOS(info, "")
accepted, err := acceptFn(filepath.Dir(path), scpFileInfo)
if err != nil {
return err
}
if isDir {
if !accepted {
prevDirSkipped = true
return filepath.SkipDir
}
err := s.StartDirectory(scpFileInfo)
if err != nil {
return err
}
} else {
if accepted {
fi := newFileInfoFromOS(info, "")
file, err := os.Open(path)
if err != nil {
return err
}
err = s.WriteFile(fi, file)
if err != nil {
return err
}
}
}
return nil
}
err := filepath.Walk(srcDir, myWalkFn)
if err != nil {
return err
}
return endDirectories(prevDir, srcDir)
})
} | [
"func",
"(",
"s",
"*",
"SCP",
")",
"SendDir",
"(",
"srcDir",
",",
"destDir",
"string",
",",
"acceptFn",
"AcceptFunc",
")",
"error",
"{",
"srcDir",
"=",
"filepath",
".",
"Clean",
"(",
"srcDir",
")",
"\n",
"destDir",
"=",
"realPath",
"(",
"filepath",
"."... | // SendDir copies files and directories under the local srcDir to
// to the remote destDir. You can filter the files and directories to be copied with acceptFn.
// However this filtering is done at the receiver side, so all file bodies are transferred
// over the network even if some files are filtered out. If you need more efficiency,
// it is better to use another method like the tar command.
// If acceptFn is nil, all files and directories will be copied.
// The time and permission will be set to the same value of the source file or directory. | [
"SendDir",
"copies",
"files",
"and",
"directories",
"under",
"the",
"local",
"srcDir",
"to",
"to",
"the",
"remote",
"destDir",
".",
"You",
"can",
"filter",
"the",
"files",
"and",
"directories",
"to",
"be",
"copied",
"with",
"acceptFn",
".",
"However",
"this"... | badb3bf1aae27e4e97b6494af96eed04a145a8a6 | https://github.com/hnakamur/go-scp/blob/badb3bf1aae27e4e97b6494af96eed04a145a8a6/source.go#L74-L166 |
16,663 | jinzhu/inflection | inflections.go | AddPlural | func AddPlural(find, replace string) {
pluralInflections = append(pluralInflections, Regular{find, replace})
compile()
} | go | func AddPlural(find, replace string) {
pluralInflections = append(pluralInflections, Regular{find, replace})
compile()
} | [
"func",
"AddPlural",
"(",
"find",
",",
"replace",
"string",
")",
"{",
"pluralInflections",
"=",
"append",
"(",
"pluralInflections",
",",
"Regular",
"{",
"find",
",",
"replace",
"}",
")",
"\n",
"compile",
"(",
")",
"\n",
"}"
] | // AddPlural adds a plural inflection | [
"AddPlural",
"adds",
"a",
"plural",
"inflection"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L180-L183 |
16,664 | jinzhu/inflection | inflections.go | AddSingular | func AddSingular(find, replace string) {
singularInflections = append(singularInflections, Regular{find, replace})
compile()
} | go | func AddSingular(find, replace string) {
singularInflections = append(singularInflections, Regular{find, replace})
compile()
} | [
"func",
"AddSingular",
"(",
"find",
",",
"replace",
"string",
")",
"{",
"singularInflections",
"=",
"append",
"(",
"singularInflections",
",",
"Regular",
"{",
"find",
",",
"replace",
"}",
")",
"\n",
"compile",
"(",
")",
"\n",
"}"
] | // AddSingular adds a singular inflection | [
"AddSingular",
"adds",
"a",
"singular",
"inflection"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L186-L189 |
16,665 | jinzhu/inflection | inflections.go | AddIrregular | func AddIrregular(singular, plural string) {
irregularInflections = append(irregularInflections, Irregular{singular, plural})
compile()
} | go | func AddIrregular(singular, plural string) {
irregularInflections = append(irregularInflections, Irregular{singular, plural})
compile()
} | [
"func",
"AddIrregular",
"(",
"singular",
",",
"plural",
"string",
")",
"{",
"irregularInflections",
"=",
"append",
"(",
"irregularInflections",
",",
"Irregular",
"{",
"singular",
",",
"plural",
"}",
")",
"\n",
"compile",
"(",
")",
"\n",
"}"
] | // AddIrregular adds an irregular inflection | [
"AddIrregular",
"adds",
"an",
"irregular",
"inflection"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L192-L195 |
16,666 | jinzhu/inflection | inflections.go | GetPlural | func GetPlural() RegularSlice {
plurals := make(RegularSlice, len(pluralInflections))
copy(plurals, pluralInflections)
return plurals
} | go | func GetPlural() RegularSlice {
plurals := make(RegularSlice, len(pluralInflections))
copy(plurals, pluralInflections)
return plurals
} | [
"func",
"GetPlural",
"(",
")",
"RegularSlice",
"{",
"plurals",
":=",
"make",
"(",
"RegularSlice",
",",
"len",
"(",
"pluralInflections",
")",
")",
"\n",
"copy",
"(",
"plurals",
",",
"pluralInflections",
")",
"\n",
"return",
"plurals",
"\n",
"}"
] | // GetPlural retrieves the plural inflection values | [
"GetPlural",
"retrieves",
"the",
"plural",
"inflection",
"values"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L204-L208 |
16,667 | jinzhu/inflection | inflections.go | GetSingular | func GetSingular() RegularSlice {
singulars := make(RegularSlice, len(singularInflections))
copy(singulars, singularInflections)
return singulars
} | go | func GetSingular() RegularSlice {
singulars := make(RegularSlice, len(singularInflections))
copy(singulars, singularInflections)
return singulars
} | [
"func",
"GetSingular",
"(",
")",
"RegularSlice",
"{",
"singulars",
":=",
"make",
"(",
"RegularSlice",
",",
"len",
"(",
"singularInflections",
")",
")",
"\n",
"copy",
"(",
"singulars",
",",
"singularInflections",
")",
"\n",
"return",
"singulars",
"\n",
"}"
] | // GetSingular retrieves the singular inflection values | [
"GetSingular",
"retrieves",
"the",
"singular",
"inflection",
"values"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L211-L215 |
16,668 | jinzhu/inflection | inflections.go | GetIrregular | func GetIrregular() IrregularSlice {
irregular := make(IrregularSlice, len(irregularInflections))
copy(irregular, irregularInflections)
return irregular
} | go | func GetIrregular() IrregularSlice {
irregular := make(IrregularSlice, len(irregularInflections))
copy(irregular, irregularInflections)
return irregular
} | [
"func",
"GetIrregular",
"(",
")",
"IrregularSlice",
"{",
"irregular",
":=",
"make",
"(",
"IrregularSlice",
",",
"len",
"(",
"irregularInflections",
")",
")",
"\n",
"copy",
"(",
"irregular",
",",
"irregularInflections",
")",
"\n",
"return",
"irregular",
"\n",
"... | // GetIrregular retrieves the irregular inflection values | [
"GetIrregular",
"retrieves",
"the",
"irregular",
"inflection",
"values"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L218-L222 |
16,669 | jinzhu/inflection | inflections.go | GetUncountable | func GetUncountable() []string {
uncountables := make([]string, len(uncountableInflections))
copy(uncountables, uncountableInflections)
return uncountables
} | go | func GetUncountable() []string {
uncountables := make([]string, len(uncountableInflections))
copy(uncountables, uncountableInflections)
return uncountables
} | [
"func",
"GetUncountable",
"(",
")",
"[",
"]",
"string",
"{",
"uncountables",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"uncountableInflections",
")",
")",
"\n",
"copy",
"(",
"uncountables",
",",
"uncountableInflections",
")",
"\n",
"return",
... | // GetUncountable retrieves the uncountable inflection values | [
"GetUncountable",
"retrieves",
"the",
"uncountable",
"inflection",
"values"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L225-L229 |
16,670 | jinzhu/inflection | inflections.go | Plural | func Plural(str string) string {
for _, inflection := range compiledPluralMaps {
if inflection.regexp.MatchString(str) {
return inflection.regexp.ReplaceAllString(str, inflection.replace)
}
}
return str
} | go | func Plural(str string) string {
for _, inflection := range compiledPluralMaps {
if inflection.regexp.MatchString(str) {
return inflection.regexp.ReplaceAllString(str, inflection.replace)
}
}
return str
} | [
"func",
"Plural",
"(",
"str",
"string",
")",
"string",
"{",
"for",
"_",
",",
"inflection",
":=",
"range",
"compiledPluralMaps",
"{",
"if",
"inflection",
".",
"regexp",
".",
"MatchString",
"(",
"str",
")",
"{",
"return",
"inflection",
".",
"regexp",
".",
... | // Plural converts a word to its plural form | [
"Plural",
"converts",
"a",
"word",
"to",
"its",
"plural",
"form"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L256-L263 |
16,671 | jinzhu/inflection | inflections.go | Singular | func Singular(str string) string {
for _, inflection := range compiledSingularMaps {
if inflection.regexp.MatchString(str) {
return inflection.regexp.ReplaceAllString(str, inflection.replace)
}
}
return str
} | go | func Singular(str string) string {
for _, inflection := range compiledSingularMaps {
if inflection.regexp.MatchString(str) {
return inflection.regexp.ReplaceAllString(str, inflection.replace)
}
}
return str
} | [
"func",
"Singular",
"(",
"str",
"string",
")",
"string",
"{",
"for",
"_",
",",
"inflection",
":=",
"range",
"compiledSingularMaps",
"{",
"if",
"inflection",
".",
"regexp",
".",
"MatchString",
"(",
"str",
")",
"{",
"return",
"inflection",
".",
"regexp",
"."... | // Singular converts a word to its singular form | [
"Singular",
"converts",
"a",
"word",
"to",
"its",
"singular",
"form"
] | 04140366298a54a039076d798123ffa108fff46c | https://github.com/jinzhu/inflection/blob/04140366298a54a039076d798123ffa108fff46c/inflections.go#L266-L273 |
16,672 | drone/drone-go | plugin/webhook/handler.go | Handler | func Handler(plugin Plugin, secret string, logs logger.Logger) http.Handler {
handler := &handler{
secret: secret,
plugin: plugin,
logger: logs,
}
if handler.logger == nil {
handler.logger = logger.Discard()
}
return handler
} | go | func Handler(plugin Plugin, secret string, logs logger.Logger) http.Handler {
handler := &handler{
secret: secret,
plugin: plugin,
logger: logs,
}
if handler.logger == nil {
handler.logger = logger.Discard()
}
return handler
} | [
"func",
"Handler",
"(",
"plugin",
"Plugin",
",",
"secret",
"string",
",",
"logs",
"logger",
".",
"Logger",
")",
"http",
".",
"Handler",
"{",
"handler",
":=",
"&",
"handler",
"{",
"secret",
":",
"secret",
",",
"plugin",
":",
"plugin",
",",
"logger",
":"... | // Handler returns a http.Handler that accepts JSON-encoded
// HTTP requests for a webhook, invokes the underlying webhook
// plugin, and writes the JSON-encoded data to the HTTP response.
//
// The handler verifies the authenticity of the HTTP request
// using the http-signature, and returns a 400 Bad Request if
// the signature is missing or invalid.
//
// The handler can optionally encrypt the response body using
// aesgcm if the HTTP request includes the Accept-Encoding header
// set to aesgcm. | [
"Handler",
"returns",
"a",
"http",
".",
"Handler",
"that",
"accepts",
"JSON",
"-",
"encoded",
"HTTP",
"requests",
"for",
"a",
"webhook",
"invokes",
"the",
"underlying",
"webhook",
"plugin",
"and",
"writes",
"the",
"JSON",
"-",
"encoded",
"data",
"to",
"the",... | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/plugin/webhook/handler.go#L38-L48 |
16,673 | drone/drone-go | plugin/internal/client/client.go | New | func New(endpoint, secret string, skipverify bool) *Client {
client := &Client{
Accept: "application/json",
Encoding: "identity",
Endpoint: endpoint,
Secret: secret,
}
if skipverify {
client.Client = &http.Client{
CheckRedirect: func(*http.Request, []*http.Request) error {
return http.ErrUseLastResponse
},
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
}
return client
} | go | func New(endpoint, secret string, skipverify bool) *Client {
client := &Client{
Accept: "application/json",
Encoding: "identity",
Endpoint: endpoint,
Secret: secret,
}
if skipverify {
client.Client = &http.Client{
CheckRedirect: func(*http.Request, []*http.Request) error {
return http.ErrUseLastResponse
},
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
}
return client
} | [
"func",
"New",
"(",
"endpoint",
",",
"secret",
"string",
",",
"skipverify",
"bool",
")",
"*",
"Client",
"{",
"client",
":=",
"&",
"Client",
"{",
"Accept",
":",
"\"",
"\"",
",",
"Encoding",
":",
"\"",
"\"",
",",
"Endpoint",
":",
"endpoint",
",",
"Secr... | // New returns a new http.Client with signature verification. | [
"New",
"returns",
"a",
"new",
"http",
".",
"Client",
"with",
"signature",
"verification",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/plugin/internal/client/client.go#L58-L79 |
16,674 | drone/drone-go | plugin/internal/client/client.go | Do | func (s *Client) Do(in, out interface{}) error {
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
data, err := json.Marshal(in)
if err != nil {
return err
}
buf := bytes.NewBuffer(data)
req, err := http.NewRequest("POST", s.Endpoint, buf)
if err != nil {
return err
}
req = req.WithContext(ctx)
req.Header.Add("Accept", s.Accept)
req.Header.Add("Accept-Encoding", s.Encoding)
req.Header.Add("Content-Type", "application/json")
req.Header.Add("Digest", "SHA-256="+digest(data))
req.Header.Add("Date", time.Now().UTC().Format(http.TimeFormat))
err = signer.SignRequest("hmac-key", s.Secret, req)
if err != nil {
return err
}
res, err := s.client().Do(req)
if err != nil {
return err
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return err
}
if res.StatusCode > 299 {
// if the response body includes an error message
// we should return the error string.
if len(body) != 0 {
return errors.New(
string(body),
)
}
// if the response body is empty we should return
// the default status code text.
return errors.New(
http.StatusText(res.StatusCode),
)
}
// if the response body return no content we exit
// immediately. We do not read or unmarshal the response
// and we do not return an error.
if res.StatusCode == 204 {
return nil
}
// the response body may be optionally encrypted
// using the aesgcm algorithm. If encrypted,
// decrypt using the shared secret.
if res.Header.Get("Content-Encoding") == "aesgcm" {
secret, err := aesgcm.Key(s.Secret)
if err != nil {
return err
}
plaintext, err := aesgcm.Decrypt(body, secret)
if err != nil {
return err
}
body = []byte(plaintext)
}
if out == nil {
return nil
}
return json.Unmarshal(body, out)
} | go | func (s *Client) Do(in, out interface{}) error {
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
data, err := json.Marshal(in)
if err != nil {
return err
}
buf := bytes.NewBuffer(data)
req, err := http.NewRequest("POST", s.Endpoint, buf)
if err != nil {
return err
}
req = req.WithContext(ctx)
req.Header.Add("Accept", s.Accept)
req.Header.Add("Accept-Encoding", s.Encoding)
req.Header.Add("Content-Type", "application/json")
req.Header.Add("Digest", "SHA-256="+digest(data))
req.Header.Add("Date", time.Now().UTC().Format(http.TimeFormat))
err = signer.SignRequest("hmac-key", s.Secret, req)
if err != nil {
return err
}
res, err := s.client().Do(req)
if err != nil {
return err
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return err
}
if res.StatusCode > 299 {
// if the response body includes an error message
// we should return the error string.
if len(body) != 0 {
return errors.New(
string(body),
)
}
// if the response body is empty we should return
// the default status code text.
return errors.New(
http.StatusText(res.StatusCode),
)
}
// if the response body return no content we exit
// immediately. We do not read or unmarshal the response
// and we do not return an error.
if res.StatusCode == 204 {
return nil
}
// the response body may be optionally encrypted
// using the aesgcm algorithm. If encrypted,
// decrypt using the shared secret.
if res.Header.Get("Content-Encoding") == "aesgcm" {
secret, err := aesgcm.Key(s.Secret)
if err != nil {
return err
}
plaintext, err := aesgcm.Decrypt(body, secret)
if err != nil {
return err
}
body = []byte(plaintext)
}
if out == nil {
return nil
}
return json.Unmarshal(body, out)
} | [
"func",
"(",
"s",
"*",
"Client",
")",
"Do",
"(",
"in",
",",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"t... | // Do makes an http.Request to the target endpoint. | [
"Do",
"makes",
"an",
"http",
".",
"Request",
"to",
"the",
"target",
"endpoint",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/plugin/internal/client/client.go#L93-L172 |
16,675 | drone/drone-go | drone/client.go | New | func New(uri string) Client {
return &client{http.DefaultClient, strings.TrimSuffix(uri, "/")}
} | go | func New(uri string) Client {
return &client{http.DefaultClient, strings.TrimSuffix(uri, "/")}
} | [
"func",
"New",
"(",
"uri",
"string",
")",
"Client",
"{",
"return",
"&",
"client",
"{",
"http",
".",
"DefaultClient",
",",
"strings",
".",
"TrimSuffix",
"(",
"uri",
",",
"\"",
"\"",
")",
"}",
"\n",
"}"
] | // New returns a client at the specified url. | [
"New",
"returns",
"a",
"client",
"at",
"the",
"specified",
"url",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L88-L90 |
16,676 | drone/drone-go | drone/client.go | Self | func (c *client) Self() (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathSelf, c.addr)
err := c.get(uri, out)
return out, err
} | go | func (c *client) Self() (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathSelf, c.addr)
err := c.get(uri, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Self",
"(",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"User",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathSelf",
",",
"c",
".",
"addr",
")",
"\n",
"err",
":=",
... | // Self returns the currently authenticated user. | [
"Self",
"returns",
"the",
"currently",
"authenticated",
"user",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L108-L113 |
16,677 | drone/drone-go | drone/client.go | User | func (c *client) User(login string) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.get(uri, out)
return out, err
} | go | func (c *client) User(login string) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.get(uri, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"User",
"(",
"login",
"string",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"User",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathUser",
",",
"c",
".",
"addr",
",",
... | // User returns a user by login. | [
"User",
"returns",
"a",
"user",
"by",
"login",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L116-L121 |
16,678 | drone/drone-go | drone/client.go | UserList | func (c *client) UserList() ([]*User, error) {
var out []*User
uri := fmt.Sprintf(pathUsers, c.addr)
err := c.get(uri, &out)
return out, err
} | go | func (c *client) UserList() ([]*User, error) {
var out []*User
uri := fmt.Sprintf(pathUsers, c.addr)
err := c.get(uri, &out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"UserList",
"(",
")",
"(",
"[",
"]",
"*",
"User",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"User",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathUsers",
",",
"c",
".",
"addr",
")",
"\n",... | // UserList returns a list of all registered users. | [
"UserList",
"returns",
"a",
"list",
"of",
"all",
"registered",
"users",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L124-L129 |
16,679 | drone/drone-go | drone/client.go | UserCreate | func (c *client) UserCreate(in *User) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUsers, c.addr)
err := c.post(uri, in, out)
return out, err
} | go | func (c *client) UserCreate(in *User) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUsers, c.addr)
err := c.post(uri, in, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"UserCreate",
"(",
"in",
"*",
"User",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"User",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathUsers",
",",
"c",
".",
"addr",
... | // UserCreate creates a new user account. | [
"UserCreate",
"creates",
"a",
"new",
"user",
"account",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L132-L137 |
16,680 | drone/drone-go | drone/client.go | UserUpdate | func (c *client) UserUpdate(login string, in *UserPatch) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.patch(uri, in, out)
return out, err
} | go | func (c *client) UserUpdate(login string, in *UserPatch) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.patch(uri, in, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"UserUpdate",
"(",
"login",
"string",
",",
"in",
"*",
"UserPatch",
")",
"(",
"*",
"User",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"User",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathUser... | // UserUpdate updates a user account. | [
"UserUpdate",
"updates",
"a",
"user",
"account",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L140-L145 |
16,681 | drone/drone-go | drone/client.go | UserDelete | func (c *client) UserDelete(login string) error {
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.delete(uri)
return err
} | go | func (c *client) UserDelete(login string) error {
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.delete(uri)
return err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"UserDelete",
"(",
"login",
"string",
")",
"error",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathUser",
",",
"c",
".",
"addr",
",",
"login",
")",
"\n",
"err",
":=",
"c",
".",
"delete",
"(",
"uri",
")",
... | // UserDelete deletes a user account. | [
"UserDelete",
"deletes",
"a",
"user",
"account",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L148-L152 |
16,682 | drone/drone-go | drone/client.go | Repo | func (c *client) Repo(owner string, name string) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.get(uri, out)
return out, err
} | go | func (c *client) Repo(owner string, name string) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.get(uri, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Repo",
"(",
"owner",
"string",
",",
"name",
"string",
")",
"(",
"*",
"Repo",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"Repo",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathRepo",
",",
"c... | // Repo returns a repository by name. | [
"Repo",
"returns",
"a",
"repository",
"by",
"name",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L155-L160 |
16,683 | drone/drone-go | drone/client.go | RepoList | func (c *client) RepoList() ([]*Repo, error) {
var out []*Repo
uri := fmt.Sprintf(pathRepos, c.addr)
err := c.get(uri, &out)
return out, err
} | go | func (c *client) RepoList() ([]*Repo, error) {
var out []*Repo
uri := fmt.Sprintf(pathRepos, c.addr)
err := c.get(uri, &out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"RepoList",
"(",
")",
"(",
"[",
"]",
"*",
"Repo",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"Repo",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathRepos",
",",
"c",
".",
"addr",
")",
"\n",... | // RepoList returns a list of all repositories to which
// the user has explicit access in the host system. | [
"RepoList",
"returns",
"a",
"list",
"of",
"all",
"repositories",
"to",
"which",
"the",
"user",
"has",
"explicit",
"access",
"in",
"the",
"host",
"system",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L164-L169 |
16,684 | drone/drone-go | drone/client.go | RepoListSync | func (c *client) RepoListSync() ([]*Repo, error) {
var out []*Repo
uri := fmt.Sprintf(pathRepos, c.addr)
err := c.post(uri, nil, &out)
return out, err
} | go | func (c *client) RepoListSync() ([]*Repo, error) {
var out []*Repo
uri := fmt.Sprintf(pathRepos, c.addr)
err := c.post(uri, nil, &out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"RepoListSync",
"(",
")",
"(",
"[",
"]",
"*",
"Repo",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"Repo",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathRepos",
",",
"c",
".",
"addr",
")",
"... | // RepoListSync returns a list of all repositories to which
// the user has explicit access in the host system. | [
"RepoListSync",
"returns",
"a",
"list",
"of",
"all",
"repositories",
"to",
"which",
"the",
"user",
"has",
"explicit",
"access",
"in",
"the",
"host",
"system",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L173-L178 |
16,685 | drone/drone-go | drone/client.go | RepoEnable | func (c *client) RepoEnable(owner, name string) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.post(uri, nil, out)
return out, err
} | go | func (c *client) RepoEnable(owner, name string) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.post(uri, nil, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"RepoEnable",
"(",
"owner",
",",
"name",
"string",
")",
"(",
"*",
"Repo",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"Repo",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathRepo",
",",
"c",
"... | // RepoEnable activates a repository. | [
"RepoEnable",
"activates",
"a",
"repository",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L181-L186 |
16,686 | drone/drone-go | drone/client.go | RepoDisable | func (c *client) RepoDisable(owner, name string) error {
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.delete(uri)
return err
} | go | func (c *client) RepoDisable(owner, name string) error {
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.delete(uri)
return err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"RepoDisable",
"(",
"owner",
",",
"name",
"string",
")",
"error",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathRepo",
",",
"c",
".",
"addr",
",",
"owner",
",",
"name",
")",
"\n",
"err",
":=",
"c",
".",
... | // RepoDisable disables a repository. | [
"RepoDisable",
"disables",
"a",
"repository",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L189-L193 |
16,687 | drone/drone-go | drone/client.go | RepoUpdate | func (c *client) RepoUpdate(owner, name string, in *RepoPatch) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.patch(uri, in, out)
return out, err
} | go | func (c *client) RepoUpdate(owner, name string, in *RepoPatch) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.patch(uri, in, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"RepoUpdate",
"(",
"owner",
",",
"name",
"string",
",",
"in",
"*",
"RepoPatch",
")",
"(",
"*",
"Repo",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"Repo",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
... | // RepoUpdate updates a repository. | [
"RepoUpdate",
"updates",
"a",
"repository",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L203-L208 |
16,688 | drone/drone-go | drone/client.go | RepoRepair | func (c *client) RepoRepair(owner, name string) error {
uri := fmt.Sprintf(pathRepair, c.addr, owner, name)
return c.post(uri, nil, nil)
} | go | func (c *client) RepoRepair(owner, name string) error {
uri := fmt.Sprintf(pathRepair, c.addr, owner, name)
return c.post(uri, nil, nil)
} | [
"func",
"(",
"c",
"*",
"client",
")",
"RepoRepair",
"(",
"owner",
",",
"name",
"string",
")",
"error",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathRepair",
",",
"c",
".",
"addr",
",",
"owner",
",",
"name",
")",
"\n",
"return",
"c",
".",
"p... | // RepoRepair repais the repository hooks. | [
"RepoRepair",
"repais",
"the",
"repository",
"hooks",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L219-L222 |
16,689 | drone/drone-go | drone/client.go | Build | func (c *client) Build(owner, name string, num int) (*Build, error) {
out := new(Build)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, num)
err := c.get(uri, out)
return out, err
} | go | func (c *client) Build(owner, name string, num int) (*Build, error) {
out := new(Build)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, num)
err := c.get(uri, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Build",
"(",
"owner",
",",
"name",
"string",
",",
"num",
"int",
")",
"(",
"*",
"Build",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"Build",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathBu... | // Build returns a repository build by number. | [
"Build",
"returns",
"a",
"repository",
"build",
"by",
"number",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L225-L230 |
16,690 | drone/drone-go | drone/client.go | BuildLast | func (c *client) BuildLast(owner, name, branch string) (*Build, error) {
out := new(Build)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, "latest")
if len(branch) != 0 {
uri += "?branch=" + branch
}
err := c.get(uri, out)
return out, err
} | go | func (c *client) BuildLast(owner, name, branch string) (*Build, error) {
out := new(Build)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, "latest")
if len(branch) != 0 {
uri += "?branch=" + branch
}
err := c.get(uri, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"BuildLast",
"(",
"owner",
",",
"name",
",",
"branch",
"string",
")",
"(",
"*",
"Build",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"Build",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathBuil... | // Build returns the latest repository build by branch. | [
"Build",
"returns",
"the",
"latest",
"repository",
"build",
"by",
"branch",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L233-L241 |
16,691 | drone/drone-go | drone/client.go | BuildList | func (c *client) BuildList(owner, name string, opts ListOptions) ([]*Build, error) {
var out []*Build
uri := fmt.Sprintf(pathBuilds, c.addr, owner, name, encodeListOptions(opts))
err := c.get(uri, &out)
return out, err
} | go | func (c *client) BuildList(owner, name string, opts ListOptions) ([]*Build, error) {
var out []*Build
uri := fmt.Sprintf(pathBuilds, c.addr, owner, name, encodeListOptions(opts))
err := c.get(uri, &out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"BuildList",
"(",
"owner",
",",
"name",
"string",
",",
"opts",
"ListOptions",
")",
"(",
"[",
"]",
"*",
"Build",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"Build",
"\n",
"uri",
":=",
"fmt",
".",
"... | // BuildList returns a list of recent builds for the
// the specified repository. | [
"BuildList",
"returns",
"a",
"list",
"of",
"recent",
"builds",
"for",
"the",
"the",
"specified",
"repository",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L245-L250 |
16,692 | drone/drone-go | drone/client.go | BuildRestart | func (c *client) BuildRestart(owner, name string, build int, params map[string]string) (*Build, error) {
out := new(Build)
val := mapValues(params)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, build)
if len(params) > 0 {
uri = uri + "?" + val.Encode()
}
err := c.post(uri, nil, out)
return out, err
} | go | func (c *client) BuildRestart(owner, name string, build int, params map[string]string) (*Build, error) {
out := new(Build)
val := mapValues(params)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, build)
if len(params) > 0 {
uri = uri + "?" + val.Encode()
}
err := c.post(uri, nil, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"BuildRestart",
"(",
"owner",
",",
"name",
"string",
",",
"build",
"int",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"Build",
",",
"error",
")",
"{",
"out",
":=",
"new",
"(",
"Build",
... | // BuildRestart re-starts a stopped build. | [
"BuildRestart",
"re",
"-",
"starts",
"a",
"stopped",
"build",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L253-L262 |
16,693 | drone/drone-go | drone/client.go | BuildCancel | func (c *client) BuildCancel(owner, name string, build int) error {
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, build)
err := c.delete(uri)
return err
} | go | func (c *client) BuildCancel(owner, name string, build int) error {
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, build)
err := c.delete(uri)
return err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"BuildCancel",
"(",
"owner",
",",
"name",
"string",
",",
"build",
"int",
")",
"error",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathBuild",
",",
"c",
".",
"addr",
",",
"owner",
",",
"name",
",",
"build",
... | // BuildCancel cancels the running job. | [
"BuildCancel",
"cancels",
"the",
"running",
"job",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L265-L269 |
16,694 | drone/drone-go | drone/client.go | BuildPurge | func (c *client) BuildPurge(owner, name string, before int) error {
param := fmt.Sprintf("before=%d", before)
uri := fmt.Sprintf(pathBuilds, c.addr, owner, name, param)
err := c.delete(uri)
return err
} | go | func (c *client) BuildPurge(owner, name string, before int) error {
param := fmt.Sprintf("before=%d", before)
uri := fmt.Sprintf(pathBuilds, c.addr, owner, name, param)
err := c.delete(uri)
return err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"BuildPurge",
"(",
"owner",
",",
"name",
"string",
",",
"before",
"int",
")",
"error",
"{",
"param",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"before",
")",
"\n",
"uri",
":=",
"fmt",
".",
"Sprintf",
... | // BuildPurge purges the build history. | [
"BuildPurge",
"purges",
"the",
"build",
"history",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L272-L277 |
16,695 | drone/drone-go | drone/client.go | Rollback | func (c *client) Rollback(namespace, name string, build int, target string, params map[string]string) (*Build, error) {
out := new(Build)
val := mapValues(params)
val.Set("target", target)
uri := fmt.Sprintf(pathRollback, c.addr, namespace, name, build, val.Encode())
err := c.post(uri, nil, out)
return out, err
} | go | func (c *client) Rollback(namespace, name string, build int, target string, params map[string]string) (*Build, error) {
out := new(Build)
val := mapValues(params)
val.Set("target", target)
uri := fmt.Sprintf(pathRollback, c.addr, namespace, name, build, val.Encode())
err := c.post(uri, nil, out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Rollback",
"(",
"namespace",
",",
"name",
"string",
",",
"build",
"int",
",",
"target",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"Build",
",",
"error",
")",
"{",
"out",
":="... | // Roolback reverts the target environment to an previous build. | [
"Roolback",
"reverts",
"the",
"target",
"environment",
"to",
"an",
"previous",
"build",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L290-L297 |
16,696 | drone/drone-go | drone/client.go | Approve | func (c *client) Approve(namespace, name string, build, stage int) error {
uri := fmt.Sprintf(pathApprove, c.addr, namespace, name, build, stage)
err := c.post(uri, nil, nil)
return err
} | go | func (c *client) Approve(namespace, name string, build, stage int) error {
uri := fmt.Sprintf(pathApprove, c.addr, namespace, name, build, stage)
err := c.post(uri, nil, nil)
return err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Approve",
"(",
"namespace",
",",
"name",
"string",
",",
"build",
",",
"stage",
"int",
")",
"error",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathApprove",
",",
"c",
".",
"addr",
",",
"namespace",
",",
"n... | // Approve approves a blocked build stage. | [
"Approve",
"approves",
"a",
"blocked",
"build",
"stage",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L300-L304 |
16,697 | drone/drone-go | drone/client.go | Logs | func (c *client) Logs(owner, name string, build, stage, step int) ([]*Line, error) {
var out []*Line
uri := fmt.Sprintf(pathLog, c.addr, owner, name, build, stage, step)
err := c.get(uri, &out)
return out, err
} | go | func (c *client) Logs(owner, name string, build, stage, step int) ([]*Line, error) {
var out []*Line
uri := fmt.Sprintf(pathLog, c.addr, owner, name, build, stage, step)
err := c.get(uri, &out)
return out, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Logs",
"(",
"owner",
",",
"name",
"string",
",",
"build",
",",
"stage",
",",
"step",
"int",
")",
"(",
"[",
"]",
"*",
"Line",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"Line",
"\n",
"uri",
":="... | // BuildLogs returns the build logs for the specified job. | [
"BuildLogs",
"returns",
"the",
"build",
"logs",
"for",
"the",
"specified",
"job",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L314-L319 |
16,698 | drone/drone-go | drone/client.go | LogsPurge | func (c *client) LogsPurge(owner, name string, build, stage, step int) error {
uri := fmt.Sprintf(pathLog, c.addr, owner, name, build, stage, step)
err := c.delete(uri)
return err
} | go | func (c *client) LogsPurge(owner, name string, build, stage, step int) error {
uri := fmt.Sprintf(pathLog, c.addr, owner, name, build, stage, step)
err := c.delete(uri)
return err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"LogsPurge",
"(",
"owner",
",",
"name",
"string",
",",
"build",
",",
"stage",
",",
"step",
"int",
")",
"error",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"pathLog",
",",
"c",
".",
"addr",
",",
"owner",
",... | // LogsPurge purges the build logs for the specified build. | [
"LogsPurge",
"purges",
"the",
"build",
"logs",
"for",
"the",
"specified",
"build",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L322-L326 |
16,699 | drone/drone-go | drone/client.go | Sign | func (c *client) Sign(owner, name, file string) (string, error) {
in := struct {
Data string `json:"data"`
}{Data: file}
out := struct {
Data string `json:"data"`
}{}
uri := fmt.Sprintf(pathSign, c.addr, owner, name)
err := c.post(uri, &in, &out)
return out.Data, err
} | go | func (c *client) Sign(owner, name, file string) (string, error) {
in := struct {
Data string `json:"data"`
}{Data: file}
out := struct {
Data string `json:"data"`
}{}
uri := fmt.Sprintf(pathSign, c.addr, owner, name)
err := c.post(uri, &in, &out)
return out.Data, err
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Sign",
"(",
"owner",
",",
"name",
",",
"file",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"in",
":=",
"struct",
"{",
"Data",
"string",
"`json:\"data\"`",
"\n",
"}",
"{",
"Data",
":",
"file",
"}",
... | // Sign signs the yaml file. | [
"Sign",
"signs",
"the",
"yaml",
"file",
"."
] | 618e4496482ebbcc8e0a32499e0a550b1a9c7b98 | https://github.com/drone/drone-go/blob/618e4496482ebbcc8e0a32499e0a550b1a9c7b98/drone/client.go#L329-L339 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.