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
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
149,000 | colinmarc/hdfs | file_writer.go | SetDeadline | func (f *FileWriter) SetDeadline(t time.Time) error {
f.deadline = t
if f.blockWriter != nil {
return f.blockWriter.SetDeadline(t)
}
// Return the error at connection time.
return nil
} | go | func (f *FileWriter) SetDeadline(t time.Time) error {
f.deadline = t
if f.blockWriter != nil {
return f.blockWriter.SetDeadline(t)
}
// Return the error at connection time.
return nil
} | [
"func",
"(",
"f",
"*",
"FileWriter",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"f",
".",
"deadline",
"=",
"t",
"\n",
"if",
"f",
".",
"blockWriter",
"!=",
"nil",
"{",
"return",
"f",
".",
"blockWriter",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}",
"\n\n",
"// Return the error at connection time.",
"return",
"nil",
"\n",
"}"
] | // SetDeadline sets the deadline for future Write, Flush, and Close calls. A
// zero value for t means those calls will not time out.
//
// Note that because of buffering, Write calls that do not result in a blocking
// network call may still succeed after the deadline. | [
"SetDeadline",
"sets",
"the",
"deadline",
"for",
"future",
"Write",
"Flush",
"and",
"Close",
"calls",
".",
"A",
"zero",
"value",
"for",
"t",
"means",
"those",
"calls",
"will",
"not",
"time",
"out",
".",
"Note",
"that",
"because",
"of",
"buffering",
"Write",
"calls",
"that",
"do",
"not",
"result",
"in",
"a",
"blocking",
"network",
"call",
"may",
"still",
"succeed",
"after",
"the",
"deadline",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L149-L157 |
149,001 | colinmarc/hdfs | file_writer.go | Write | func (f *FileWriter) Write(b []byte) (int, error) {
if f.closed {
return 0, io.ErrClosedPipe
}
if f.blockWriter == nil {
err := f.startNewBlock()
if err != nil {
return 0, err
}
}
off := 0
for off < len(b) {
n, err := f.blockWriter.Write(b[off:])
off += n
if err == rpc.ErrEndOfBlock {
err = f.startNewBlock()
}
if err != nil {
return off, err
}
}
return off, nil
} | go | func (f *FileWriter) Write(b []byte) (int, error) {
if f.closed {
return 0, io.ErrClosedPipe
}
if f.blockWriter == nil {
err := f.startNewBlock()
if err != nil {
return 0, err
}
}
off := 0
for off < len(b) {
n, err := f.blockWriter.Write(b[off:])
off += n
if err == rpc.ErrEndOfBlock {
err = f.startNewBlock()
}
if err != nil {
return off, err
}
}
return off, nil
} | [
"func",
"(",
"f",
"*",
"FileWriter",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"f",
".",
"closed",
"{",
"return",
"0",
",",
"io",
".",
"ErrClosedPipe",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"blockWriter",
"==",
"nil",
"{",
"err",
":=",
"f",
".",
"startNewBlock",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"off",
":=",
"0",
"\n",
"for",
"off",
"<",
"len",
"(",
"b",
")",
"{",
"n",
",",
"err",
":=",
"f",
".",
"blockWriter",
".",
"Write",
"(",
"b",
"[",
"off",
":",
"]",
")",
"\n",
"off",
"+=",
"n",
"\n",
"if",
"err",
"==",
"rpc",
".",
"ErrEndOfBlock",
"{",
"err",
"=",
"f",
".",
"startNewBlock",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"off",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"off",
",",
"nil",
"\n",
"}"
] | // Write implements io.Writer for writing to a file in HDFS. Internally, it
// writes data to an internal buffer first, and then later out to HDFS. Because
// of this, it is important that Close is called after all data has been
// written. | [
"Write",
"implements",
"io",
".",
"Writer",
"for",
"writing",
"to",
"a",
"file",
"in",
"HDFS",
".",
"Internally",
"it",
"writes",
"data",
"to",
"an",
"internal",
"buffer",
"first",
"and",
"then",
"later",
"out",
"to",
"HDFS",
".",
"Because",
"of",
"this",
"it",
"is",
"important",
"that",
"Close",
"is",
"called",
"after",
"all",
"data",
"has",
"been",
"written",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L163-L189 |
149,002 | colinmarc/hdfs | file_writer.go | Flush | func (f *FileWriter) Flush() error {
if f.closed {
return io.ErrClosedPipe
}
if f.blockWriter != nil {
return f.blockWriter.Flush()
}
return nil
} | go | func (f *FileWriter) Flush() error {
if f.closed {
return io.ErrClosedPipe
}
if f.blockWriter != nil {
return f.blockWriter.Flush()
}
return nil
} | [
"func",
"(",
"f",
"*",
"FileWriter",
")",
"Flush",
"(",
")",
"error",
"{",
"if",
"f",
".",
"closed",
"{",
"return",
"io",
".",
"ErrClosedPipe",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"blockWriter",
"!=",
"nil",
"{",
"return",
"f",
".",
"blockWriter",
".",
"Flush",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Flush flushes any buffered data out to the datanodes. Even immediately after
// a call to Flush, it is still necessary to call Close once all data has been
// written. | [
"Flush",
"flushes",
"any",
"buffered",
"data",
"out",
"to",
"the",
"datanodes",
".",
"Even",
"immediately",
"after",
"a",
"call",
"to",
"Flush",
"it",
"is",
"still",
"necessary",
"to",
"call",
"Close",
"once",
"all",
"data",
"has",
"been",
"written",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L194-L204 |
149,003 | colinmarc/hdfs | file_writer.go | Close | func (f *FileWriter) Close() error {
if f.closed {
return io.ErrClosedPipe
}
var lastBlock *hdfs.ExtendedBlockProto
if f.blockWriter != nil {
lastBlock = f.blockWriter.Block.GetB()
// Close the blockWriter, flushing any buffered packets.
err := f.finalizeBlock()
if err != nil {
return err
}
}
completeReq := &hdfs.CompleteRequestProto{
Src: proto.String(f.name),
ClientName: proto.String(f.client.namenode.ClientName),
Last: lastBlock,
}
completeResp := &hdfs.CompleteResponseProto{}
err := f.client.namenode.Execute("complete", completeReq, completeResp)
if err != nil {
return &os.PathError{"create", f.name, err}
}
return nil
} | go | func (f *FileWriter) Close() error {
if f.closed {
return io.ErrClosedPipe
}
var lastBlock *hdfs.ExtendedBlockProto
if f.blockWriter != nil {
lastBlock = f.blockWriter.Block.GetB()
// Close the blockWriter, flushing any buffered packets.
err := f.finalizeBlock()
if err != nil {
return err
}
}
completeReq := &hdfs.CompleteRequestProto{
Src: proto.String(f.name),
ClientName: proto.String(f.client.namenode.ClientName),
Last: lastBlock,
}
completeResp := &hdfs.CompleteResponseProto{}
err := f.client.namenode.Execute("complete", completeReq, completeResp)
if err != nil {
return &os.PathError{"create", f.name, err}
}
return nil
} | [
"func",
"(",
"f",
"*",
"FileWriter",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"f",
".",
"closed",
"{",
"return",
"io",
".",
"ErrClosedPipe",
"\n",
"}",
"\n\n",
"var",
"lastBlock",
"*",
"hdfs",
".",
"ExtendedBlockProto",
"\n",
"if",
"f",
".",
"blockWriter",
"!=",
"nil",
"{",
"lastBlock",
"=",
"f",
".",
"blockWriter",
".",
"Block",
".",
"GetB",
"(",
")",
"\n\n",
"// Close the blockWriter, flushing any buffered packets.",
"err",
":=",
"f",
".",
"finalizeBlock",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"completeReq",
":=",
"&",
"hdfs",
".",
"CompleteRequestProto",
"{",
"Src",
":",
"proto",
".",
"String",
"(",
"f",
".",
"name",
")",
",",
"ClientName",
":",
"proto",
".",
"String",
"(",
"f",
".",
"client",
".",
"namenode",
".",
"ClientName",
")",
",",
"Last",
":",
"lastBlock",
",",
"}",
"\n",
"completeResp",
":=",
"&",
"hdfs",
".",
"CompleteResponseProto",
"{",
"}",
"\n\n",
"err",
":=",
"f",
".",
"client",
".",
"namenode",
".",
"Execute",
"(",
"\"",
"\"",
",",
"completeReq",
",",
"completeResp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"f",
".",
"name",
",",
"err",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the file, writing any remaining data out to disk and waiting
// for acknowledgements from the datanodes. It is important that Close is called
// after all data has been written. | [
"Close",
"closes",
"the",
"file",
"writing",
"any",
"remaining",
"data",
"out",
"to",
"disk",
"and",
"waiting",
"for",
"acknowledgements",
"from",
"the",
"datanodes",
".",
"It",
"is",
"important",
"that",
"Close",
"is",
"called",
"after",
"all",
"data",
"has",
"been",
"written",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L209-L238 |
149,004 | colinmarc/hdfs | content_summary.go | GetContentSummary | func (c *Client) GetContentSummary(name string) (*ContentSummary, error) {
cs, err := c.getContentSummary(name)
if err != nil {
err = &os.PathError{"content summary", name, interpretException(err)}
}
return cs, err
} | go | func (c *Client) GetContentSummary(name string) (*ContentSummary, error) {
cs, err := c.getContentSummary(name)
if err != nil {
err = &os.PathError{"content summary", name, interpretException(err)}
}
return cs, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetContentSummary",
"(",
"name",
"string",
")",
"(",
"*",
"ContentSummary",
",",
"error",
")",
"{",
"cs",
",",
"err",
":=",
"c",
".",
"getContentSummary",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"return",
"cs",
",",
"err",
"\n",
"}"
] | // GetContentSummary returns a ContentSummary representing the named file or
// directory. The summary contains information about the entire tree rooted
// in the named file; for instance, it can return the total size of all | [
"GetContentSummary",
"returns",
"a",
"ContentSummary",
"representing",
"the",
"named",
"file",
"or",
"directory",
".",
"The",
"summary",
"contains",
"information",
"about",
"the",
"entire",
"tree",
"rooted",
"in",
"the",
"named",
"file",
";",
"for",
"instance",
"it",
"can",
"return",
"the",
"total",
"size",
"of",
"all"
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/content_summary.go#L21-L28 |
149,005 | colinmarc/hdfs | mkdir.go | Mkdir | func (c *Client) Mkdir(dirname string, perm os.FileMode) error {
return c.mkdir(dirname, perm, false)
} | go | func (c *Client) Mkdir(dirname string, perm os.FileMode) error {
return c.mkdir(dirname, perm, false)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Mkdir",
"(",
"dirname",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"c",
".",
"mkdir",
"(",
"dirname",
",",
"perm",
",",
"false",
")",
"\n",
"}"
] | // Mkdir creates a new directory with the specified name and permission bits. | [
"Mkdir",
"creates",
"a",
"new",
"directory",
"with",
"the",
"specified",
"name",
"and",
"permission",
"bits",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/mkdir.go#L12-L14 |
149,006 | colinmarc/hdfs | mkdir.go | MkdirAll | func (c *Client) MkdirAll(dirname string, perm os.FileMode) error {
return c.mkdir(dirname, perm, true)
} | go | func (c *Client) MkdirAll(dirname string, perm os.FileMode) error {
return c.mkdir(dirname, perm, true)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"MkdirAll",
"(",
"dirname",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"c",
".",
"mkdir",
"(",
"dirname",
",",
"perm",
",",
"true",
")",
"\n",
"}"
] | // MkdirAll creates a directory for dirname, along with any necessary parents,
// and returns nil, or else returns an error. The permission bits perm are used
// for all directories that MkdirAll creates. If dirname is already a directory,
// MkdirAll does nothing and returns nil. | [
"MkdirAll",
"creates",
"a",
"directory",
"for",
"dirname",
"along",
"with",
"any",
"necessary",
"parents",
"and",
"returns",
"nil",
"or",
"else",
"returns",
"an",
"error",
".",
"The",
"permission",
"bits",
"perm",
"are",
"used",
"for",
"all",
"directories",
"that",
"MkdirAll",
"creates",
".",
"If",
"dirname",
"is",
"already",
"a",
"directory",
"MkdirAll",
"does",
"nothing",
"and",
"returns",
"nil",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/mkdir.go#L20-L22 |
149,007 | colinmarc/hdfs | hadoopconf/hadoopconf.go | Load | func Load(path string) (HadoopConf, error) {
var conf HadoopConf
for _, file := range confFiles {
pList := propertyList{}
f, err := ioutil.ReadFile(filepath.Join(path, file))
if os.IsNotExist(err) {
continue
} else if err != nil {
return conf, err
}
err = xml.Unmarshal(f, &pList)
if err != nil {
return conf, fmt.Errorf("%s: %s", path, err)
}
if conf == nil {
conf = make(HadoopConf)
}
for _, prop := range pList.Property {
conf[prop.Name] = prop.Value
}
}
return conf, nil
} | go | func Load(path string) (HadoopConf, error) {
var conf HadoopConf
for _, file := range confFiles {
pList := propertyList{}
f, err := ioutil.ReadFile(filepath.Join(path, file))
if os.IsNotExist(err) {
continue
} else if err != nil {
return conf, err
}
err = xml.Unmarshal(f, &pList)
if err != nil {
return conf, fmt.Errorf("%s: %s", path, err)
}
if conf == nil {
conf = make(HadoopConf)
}
for _, prop := range pList.Property {
conf[prop.Name] = prop.Value
}
}
return conf, nil
} | [
"func",
"Load",
"(",
"path",
"string",
")",
"(",
"HadoopConf",
",",
"error",
")",
"{",
"var",
"conf",
"HadoopConf",
"\n\n",
"for",
"_",
",",
"file",
":=",
"range",
"confFiles",
"{",
"pList",
":=",
"propertyList",
"{",
"}",
"\n",
"f",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"file",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conf",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"xml",
".",
"Unmarshal",
"(",
"f",
",",
"&",
"pList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conf",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"conf",
"==",
"nil",
"{",
"conf",
"=",
"make",
"(",
"HadoopConf",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"prop",
":=",
"range",
"pList",
".",
"Property",
"{",
"conf",
"[",
"prop",
".",
"Name",
"]",
"=",
"prop",
".",
"Value",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"conf",
",",
"nil",
"\n",
"}"
] | // Load returns a HadoopConf object representing configuration from the
// specified path. It will parse core-site.xml, hdfs-site.xml, and
// mapred-site.xml.
//
// If no configuration files could be found, Load returns a nil map. If the
// configuration files exist but there was an error opening or parsing them,
// that is returned as well. | [
"Load",
"returns",
"a",
"HadoopConf",
"object",
"representing",
"configuration",
"from",
"the",
"specified",
"path",
".",
"It",
"will",
"parse",
"core",
"-",
"site",
".",
"xml",
"hdfs",
"-",
"site",
".",
"xml",
"and",
"mapred",
"-",
"site",
".",
"xml",
".",
"If",
"no",
"configuration",
"files",
"could",
"be",
"found",
"Load",
"returns",
"a",
"nil",
"map",
".",
"If",
"the",
"configuration",
"files",
"exist",
"but",
"there",
"was",
"an",
"error",
"opening",
"or",
"parsing",
"them",
"that",
"is",
"returned",
"as",
"well",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/hadoopconf/hadoopconf.go#L64-L91 |
149,008 | colinmarc/hdfs | perms.go | Chmod | func (c *Client) Chmod(name string, perm os.FileMode) error {
req := &hdfs.SetPermissionRequestProto{
Src: proto.String(name),
Permission: &hdfs.FsPermissionProto{Perm: proto.Uint32(uint32(perm))},
}
resp := &hdfs.SetPermissionResponseProto{}
err := c.namenode.Execute("setPermission", req, resp)
if err != nil {
return &os.PathError{"chmod", name, interpretException(err)}
}
return nil
} | go | func (c *Client) Chmod(name string, perm os.FileMode) error {
req := &hdfs.SetPermissionRequestProto{
Src: proto.String(name),
Permission: &hdfs.FsPermissionProto{Perm: proto.Uint32(uint32(perm))},
}
resp := &hdfs.SetPermissionResponseProto{}
err := c.namenode.Execute("setPermission", req, resp)
if err != nil {
return &os.PathError{"chmod", name, interpretException(err)}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Chmod",
"(",
"name",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"req",
":=",
"&",
"hdfs",
".",
"SetPermissionRequestProto",
"{",
"Src",
":",
"proto",
".",
"String",
"(",
"name",
")",
",",
"Permission",
":",
"&",
"hdfs",
".",
"FsPermissionProto",
"{",
"Perm",
":",
"proto",
".",
"Uint32",
"(",
"uint32",
"(",
"perm",
")",
")",
"}",
",",
"}",
"\n",
"resp",
":=",
"&",
"hdfs",
".",
"SetPermissionResponseProto",
"{",
"}",
"\n\n",
"err",
":=",
"c",
".",
"namenode",
".",
"Execute",
"(",
"\"",
"\"",
",",
"req",
",",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Chmod changes the mode of the named file to mode. | [
"Chmod",
"changes",
"the",
"mode",
"of",
"the",
"named",
"file",
"to",
"mode",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/perms.go#L12-L25 |
149,009 | colinmarc/hdfs | internal/rpc/block_reader.go | SetDeadline | func (br *BlockReader) SetDeadline(t time.Time) error {
br.deadline = t
if br.conn != nil {
return br.conn.SetDeadline(t)
}
// Return the error at connection time.
return nil
} | go | func (br *BlockReader) SetDeadline(t time.Time) error {
br.deadline = t
if br.conn != nil {
return br.conn.SetDeadline(t)
}
// Return the error at connection time.
return nil
} | [
"func",
"(",
"br",
"*",
"BlockReader",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"br",
".",
"deadline",
"=",
"t",
"\n",
"if",
"br",
".",
"conn",
"!=",
"nil",
"{",
"return",
"br",
".",
"conn",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}",
"\n\n",
"// Return the error at connection time.",
"return",
"nil",
"\n",
"}"
] | // SetDeadline sets the deadline for future Read calls. A zero value for t
// means Read will not time out. | [
"SetDeadline",
"sets",
"the",
"deadline",
"for",
"future",
"Read",
"calls",
".",
"A",
"zero",
"value",
"for",
"t",
"means",
"Read",
"will",
"not",
"time",
"out",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_reader.go#L44-L52 |
149,010 | colinmarc/hdfs | internal/rpc/block_reader.go | connectNext | func (br *BlockReader) connectNext() error {
address := br.datanodes.next()
if br.DialFunc == nil {
br.DialFunc = (&net.Dialer{}).DialContext
}
conn, err := br.DialFunc(context.Background(), "tcp", address)
if err != nil {
return err
}
err = br.writeBlockReadRequest(conn)
if err != nil {
return err
}
resp, err := readBlockOpResponse(conn)
if err != nil {
return err
} else if resp.GetStatus() != hdfs.Status_SUCCESS {
return fmt.Errorf("read failed: %s (%s)", resp.GetStatus().String(), resp.GetMessage())
}
readInfo := resp.GetReadOpChecksumInfo()
checksumInfo := readInfo.GetChecksum()
var checksumTab *crc32.Table
checksumType := checksumInfo.GetType()
switch checksumType {
case hdfs.ChecksumTypeProto_CHECKSUM_CRC32:
checksumTab = crc32.IEEETable
case hdfs.ChecksumTypeProto_CHECKSUM_CRC32C:
checksumTab = crc32.MakeTable(crc32.Castagnoli)
default:
return fmt.Errorf("unsupported checksum type: %d", checksumType)
}
chunkSize := int(checksumInfo.GetBytesPerChecksum())
stream := newBlockReadStream(conn, chunkSize, checksumTab)
// The read will start aligned to a chunk boundary, so we need to seek forward
// to the requested offset.
amountToDiscard := br.Offset - int64(readInfo.GetChunkOffset())
if amountToDiscard > 0 {
_, err := io.CopyN(ioutil.Discard, stream, amountToDiscard)
if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
conn.Close()
return err
}
}
br.stream = stream
br.conn = conn
err = br.conn.SetDeadline(br.deadline)
if err != nil {
return err
}
return nil
} | go | func (br *BlockReader) connectNext() error {
address := br.datanodes.next()
if br.DialFunc == nil {
br.DialFunc = (&net.Dialer{}).DialContext
}
conn, err := br.DialFunc(context.Background(), "tcp", address)
if err != nil {
return err
}
err = br.writeBlockReadRequest(conn)
if err != nil {
return err
}
resp, err := readBlockOpResponse(conn)
if err != nil {
return err
} else if resp.GetStatus() != hdfs.Status_SUCCESS {
return fmt.Errorf("read failed: %s (%s)", resp.GetStatus().String(), resp.GetMessage())
}
readInfo := resp.GetReadOpChecksumInfo()
checksumInfo := readInfo.GetChecksum()
var checksumTab *crc32.Table
checksumType := checksumInfo.GetType()
switch checksumType {
case hdfs.ChecksumTypeProto_CHECKSUM_CRC32:
checksumTab = crc32.IEEETable
case hdfs.ChecksumTypeProto_CHECKSUM_CRC32C:
checksumTab = crc32.MakeTable(crc32.Castagnoli)
default:
return fmt.Errorf("unsupported checksum type: %d", checksumType)
}
chunkSize := int(checksumInfo.GetBytesPerChecksum())
stream := newBlockReadStream(conn, chunkSize, checksumTab)
// The read will start aligned to a chunk boundary, so we need to seek forward
// to the requested offset.
amountToDiscard := br.Offset - int64(readInfo.GetChunkOffset())
if amountToDiscard > 0 {
_, err := io.CopyN(ioutil.Discard, stream, amountToDiscard)
if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
conn.Close()
return err
}
}
br.stream = stream
br.conn = conn
err = br.conn.SetDeadline(br.deadline)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"br",
"*",
"BlockReader",
")",
"connectNext",
"(",
")",
"error",
"{",
"address",
":=",
"br",
".",
"datanodes",
".",
"next",
"(",
")",
"\n\n",
"if",
"br",
".",
"DialFunc",
"==",
"nil",
"{",
"br",
".",
"DialFunc",
"=",
"(",
"&",
"net",
".",
"Dialer",
"{",
"}",
")",
".",
"DialContext",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"br",
".",
"DialFunc",
"(",
"context",
".",
"Background",
"(",
")",
",",
"\"",
"\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"br",
".",
"writeBlockReadRequest",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"readBlockOpResponse",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"resp",
".",
"GetStatus",
"(",
")",
"!=",
"hdfs",
".",
"Status_SUCCESS",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"resp",
".",
"GetStatus",
"(",
")",
".",
"String",
"(",
")",
",",
"resp",
".",
"GetMessage",
"(",
")",
")",
"\n",
"}",
"\n\n",
"readInfo",
":=",
"resp",
".",
"GetReadOpChecksumInfo",
"(",
")",
"\n",
"checksumInfo",
":=",
"readInfo",
".",
"GetChecksum",
"(",
")",
"\n\n",
"var",
"checksumTab",
"*",
"crc32",
".",
"Table",
"\n",
"checksumType",
":=",
"checksumInfo",
".",
"GetType",
"(",
")",
"\n",
"switch",
"checksumType",
"{",
"case",
"hdfs",
".",
"ChecksumTypeProto_CHECKSUM_CRC32",
":",
"checksumTab",
"=",
"crc32",
".",
"IEEETable",
"\n",
"case",
"hdfs",
".",
"ChecksumTypeProto_CHECKSUM_CRC32C",
":",
"checksumTab",
"=",
"crc32",
".",
"MakeTable",
"(",
"crc32",
".",
"Castagnoli",
")",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"checksumType",
")",
"\n",
"}",
"\n\n",
"chunkSize",
":=",
"int",
"(",
"checksumInfo",
".",
"GetBytesPerChecksum",
"(",
")",
")",
"\n",
"stream",
":=",
"newBlockReadStream",
"(",
"conn",
",",
"chunkSize",
",",
"checksumTab",
")",
"\n\n",
"// The read will start aligned to a chunk boundary, so we need to seek forward",
"// to the requested offset.",
"amountToDiscard",
":=",
"br",
".",
"Offset",
"-",
"int64",
"(",
"readInfo",
".",
"GetChunkOffset",
"(",
")",
")",
"\n",
"if",
"amountToDiscard",
">",
"0",
"{",
"_",
",",
"err",
":=",
"io",
".",
"CopyN",
"(",
"ioutil",
".",
"Discard",
",",
"stream",
",",
"amountToDiscard",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"err",
"=",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"\n\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"br",
".",
"stream",
"=",
"stream",
"\n",
"br",
".",
"conn",
"=",
"conn",
"\n",
"err",
"=",
"br",
".",
"conn",
".",
"SetDeadline",
"(",
"br",
".",
"deadline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // connectNext pops a datanode from the list based on previous failures, and
// connects to it. | [
"connectNext",
"pops",
"a",
"datanode",
"from",
"the",
"list",
"based",
"on",
"previous",
"failures",
"and",
"connects",
"to",
"it",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_reader.go#L130-L194 |
149,011 | colinmarc/hdfs | internal/rpc/kerberos.go | getKerberosTicket | func (c *NamenodeConnection) getKerberosTicket() (gssapi.NegTokenInit, krbtypes.EncryptionKey, error) {
host, _, _ := net.SplitHostPort(c.host.address)
spn := replaceSPNHostWildcard(c.kerberosServicePrincipleName, host)
ticket, key, err := c.kerberosClient.GetServiceTicket(spn)
if err != nil {
return gssapi.NegTokenInit{}, key, err
}
token, err := gssapi.NewNegTokenInitKrb5(*c.kerberosClient.Credentials, ticket, key)
return token, key, err
} | go | func (c *NamenodeConnection) getKerberosTicket() (gssapi.NegTokenInit, krbtypes.EncryptionKey, error) {
host, _, _ := net.SplitHostPort(c.host.address)
spn := replaceSPNHostWildcard(c.kerberosServicePrincipleName, host)
ticket, key, err := c.kerberosClient.GetServiceTicket(spn)
if err != nil {
return gssapi.NegTokenInit{}, key, err
}
token, err := gssapi.NewNegTokenInitKrb5(*c.kerberosClient.Credentials, ticket, key)
return token, key, err
} | [
"func",
"(",
"c",
"*",
"NamenodeConnection",
")",
"getKerberosTicket",
"(",
")",
"(",
"gssapi",
".",
"NegTokenInit",
",",
"krbtypes",
".",
"EncryptionKey",
",",
"error",
")",
"{",
"host",
",",
"_",
",",
"_",
":=",
"net",
".",
"SplitHostPort",
"(",
"c",
".",
"host",
".",
"address",
")",
"\n",
"spn",
":=",
"replaceSPNHostWildcard",
"(",
"c",
".",
"kerberosServicePrincipleName",
",",
"host",
")",
"\n\n",
"ticket",
",",
"key",
",",
"err",
":=",
"c",
".",
"kerberosClient",
".",
"GetServiceTicket",
"(",
"spn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"gssapi",
".",
"NegTokenInit",
"{",
"}",
",",
"key",
",",
"err",
"\n",
"}",
"\n\n",
"token",
",",
"err",
":=",
"gssapi",
".",
"NewNegTokenInitKrb5",
"(",
"*",
"c",
".",
"kerberosClient",
".",
"Credentials",
",",
"ticket",
",",
"key",
")",
"\n",
"return",
"token",
",",
"key",
",",
"err",
"\n",
"}"
] | // getKerberosTicket returns an initial kerberos negotiation token and the
// paired session key, along with an error if any occured. | [
"getKerberosTicket",
"returns",
"an",
"initial",
"kerberos",
"negotiation",
"token",
"and",
"the",
"paired",
"session",
"key",
"along",
"with",
"an",
"error",
"if",
"any",
"occured",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/kerberos.go#L128-L139 |
149,012 | colinmarc/hdfs | internal/rpc/block_write_stream.go | finish | func (s *blockWriteStream) finish() error {
if s.closed {
return nil
}
s.closed = true
if err := s.getAckError(); err != nil {
return err
}
err := s.flush(true)
if err != nil {
return err
}
// The last packet has no data; it's just a marker that the block is finished.
lastPacket := outboundPacket{
seqno: s.seqno,
offset: s.offset,
last: true,
checksums: []byte{},
data: []byte{},
}
s.packets <- lastPacket
err = s.writePacket(lastPacket)
if err != nil {
return err
}
close(s.packets)
// Wait for the ack loop to finish.
<-s.acksDone
// Check one more time for any ack errors.
if err := s.getAckError(); err != nil {
return err
}
return nil
} | go | func (s *blockWriteStream) finish() error {
if s.closed {
return nil
}
s.closed = true
if err := s.getAckError(); err != nil {
return err
}
err := s.flush(true)
if err != nil {
return err
}
// The last packet has no data; it's just a marker that the block is finished.
lastPacket := outboundPacket{
seqno: s.seqno,
offset: s.offset,
last: true,
checksums: []byte{},
data: []byte{},
}
s.packets <- lastPacket
err = s.writePacket(lastPacket)
if err != nil {
return err
}
close(s.packets)
// Wait for the ack loop to finish.
<-s.acksDone
// Check one more time for any ack errors.
if err := s.getAckError(); err != nil {
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"blockWriteStream",
")",
"finish",
"(",
")",
"error",
"{",
"if",
"s",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"s",
".",
"closed",
"=",
"true",
"\n\n",
"if",
"err",
":=",
"s",
".",
"getAckError",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
":=",
"s",
".",
"flush",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// The last packet has no data; it's just a marker that the block is finished.",
"lastPacket",
":=",
"outboundPacket",
"{",
"seqno",
":",
"s",
".",
"seqno",
",",
"offset",
":",
"s",
".",
"offset",
",",
"last",
":",
"true",
",",
"checksums",
":",
"[",
"]",
"byte",
"{",
"}",
",",
"data",
":",
"[",
"]",
"byte",
"{",
"}",
",",
"}",
"\n",
"s",
".",
"packets",
"<-",
"lastPacket",
"\n",
"err",
"=",
"s",
".",
"writePacket",
"(",
"lastPacket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"close",
"(",
"s",
".",
"packets",
")",
"\n\n",
"// Wait for the ack loop to finish.",
"<-",
"s",
".",
"acksDone",
"\n\n",
"// Check one more time for any ack errors.",
"if",
"err",
":=",
"s",
".",
"getAckError",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // finish flushes the rest of the buffered bytes, and then sends a final empty
// packet signifying the end of the block. | [
"finish",
"flushes",
"the",
"rest",
"of",
"the",
"buffered",
"bytes",
"and",
"then",
"sends",
"a",
"final",
"empty",
"packet",
"signifying",
"the",
"end",
"of",
"the",
"block",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_write_stream.go#L108-L147 |
149,013 | colinmarc/hdfs | internal/rpc/block_write_stream.go | flush | func (s *blockWriteStream) flush(force bool) error {
if err := s.getAckError(); err != nil {
return err
}
for s.buf.Len() > 0 && (force || s.buf.Len() >= outboundPacketSize) {
packet := s.makePacket()
s.packets <- packet
s.offset += int64(len(packet.data))
s.seqno++
err := s.writePacket(packet)
if err != nil {
return err
}
}
return nil
} | go | func (s *blockWriteStream) flush(force bool) error {
if err := s.getAckError(); err != nil {
return err
}
for s.buf.Len() > 0 && (force || s.buf.Len() >= outboundPacketSize) {
packet := s.makePacket()
s.packets <- packet
s.offset += int64(len(packet.data))
s.seqno++
err := s.writePacket(packet)
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"blockWriteStream",
")",
"flush",
"(",
"force",
"bool",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"getAckError",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"s",
".",
"buf",
".",
"Len",
"(",
")",
">",
"0",
"&&",
"(",
"force",
"||",
"s",
".",
"buf",
".",
"Len",
"(",
")",
">=",
"outboundPacketSize",
")",
"{",
"packet",
":=",
"s",
".",
"makePacket",
"(",
")",
"\n",
"s",
".",
"packets",
"<-",
"packet",
"\n",
"s",
".",
"offset",
"+=",
"int64",
"(",
"len",
"(",
"packet",
".",
"data",
")",
")",
"\n",
"s",
".",
"seqno",
"++",
"\n\n",
"err",
":=",
"s",
".",
"writePacket",
"(",
"packet",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // flush parcels out the buffered bytes into packets, which it then flushes to
// the datanode. We keep around a reference to the packet, in case the ack
// fails, and we need to send it again later. | [
"flush",
"parcels",
"out",
"the",
"buffered",
"bytes",
"into",
"packets",
"which",
"it",
"then",
"flushes",
"to",
"the",
"datanode",
".",
"We",
"keep",
"around",
"a",
"reference",
"to",
"the",
"packet",
"in",
"case",
"the",
"ack",
"fails",
"and",
"we",
"need",
"to",
"send",
"it",
"again",
"later",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_write_stream.go#L152-L170 |
149,014 | colinmarc/hdfs | internal/rpc/block_write_stream.go | ackPackets | func (s *blockWriteStream) ackPackets() {
reader := bufio.NewReader(s.conn)
for {
p, ok := <-s.packets
if !ok {
// All packets all acked.
return
}
// If we fail to read the ack at all, that counts as a failure from the
// first datanode (the one we're connected to).
ack := &hdfs.PipelineAckProto{}
err := readPrefixedMessage(reader, ack)
if err != nil {
s.ackError = err
break
}
seqno := int(ack.GetSeqno())
for i, status := range ack.GetReply() {
if status != hdfs.Status_SUCCESS {
s.ackError = ackError{status: status, seqno: seqno, pipelineIndex: i}
break
}
}
if seqno != p.seqno {
s.ackError = ErrInvalidSeqno
break
}
}
// Once we've seen an error, just keep reading packets off the channel (but
// not off the socket) until the writing thread figures it out. If we don't,
// the upstream thread could deadlock waiting for the channel to have space.
for _ = range s.packets {
}
} | go | func (s *blockWriteStream) ackPackets() {
reader := bufio.NewReader(s.conn)
for {
p, ok := <-s.packets
if !ok {
// All packets all acked.
return
}
// If we fail to read the ack at all, that counts as a failure from the
// first datanode (the one we're connected to).
ack := &hdfs.PipelineAckProto{}
err := readPrefixedMessage(reader, ack)
if err != nil {
s.ackError = err
break
}
seqno := int(ack.GetSeqno())
for i, status := range ack.GetReply() {
if status != hdfs.Status_SUCCESS {
s.ackError = ackError{status: status, seqno: seqno, pipelineIndex: i}
break
}
}
if seqno != p.seqno {
s.ackError = ErrInvalidSeqno
break
}
}
// Once we've seen an error, just keep reading packets off the channel (but
// not off the socket) until the writing thread figures it out. If we don't,
// the upstream thread could deadlock waiting for the channel to have space.
for _ = range s.packets {
}
} | [
"func",
"(",
"s",
"*",
"blockWriteStream",
")",
"ackPackets",
"(",
")",
"{",
"reader",
":=",
"bufio",
".",
"NewReader",
"(",
"s",
".",
"conn",
")",
"\n\n",
"for",
"{",
"p",
",",
"ok",
":=",
"<-",
"s",
".",
"packets",
"\n",
"if",
"!",
"ok",
"{",
"// All packets all acked.",
"return",
"\n",
"}",
"\n\n",
"// If we fail to read the ack at all, that counts as a failure from the",
"// first datanode (the one we're connected to).",
"ack",
":=",
"&",
"hdfs",
".",
"PipelineAckProto",
"{",
"}",
"\n",
"err",
":=",
"readPrefixedMessage",
"(",
"reader",
",",
"ack",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"ackError",
"=",
"err",
"\n",
"break",
"\n",
"}",
"\n\n",
"seqno",
":=",
"int",
"(",
"ack",
".",
"GetSeqno",
"(",
")",
")",
"\n",
"for",
"i",
",",
"status",
":=",
"range",
"ack",
".",
"GetReply",
"(",
")",
"{",
"if",
"status",
"!=",
"hdfs",
".",
"Status_SUCCESS",
"{",
"s",
".",
"ackError",
"=",
"ackError",
"{",
"status",
":",
"status",
",",
"seqno",
":",
"seqno",
",",
"pipelineIndex",
":",
"i",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"seqno",
"!=",
"p",
".",
"seqno",
"{",
"s",
".",
"ackError",
"=",
"ErrInvalidSeqno",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Once we've seen an error, just keep reading packets off the channel (but",
"// not off the socket) until the writing thread figures it out. If we don't,",
"// the upstream thread could deadlock waiting for the channel to have space.",
"for",
"_",
"=",
"range",
"s",
".",
"packets",
"{",
"}",
"\n",
"}"
] | // ackPackets is meant to run in the background, reading acks and setting
// ackError if one fails. | [
"ackPackets",
"is",
"meant",
"to",
"run",
"in",
"the",
"background",
"reading",
"acks",
"and",
"setting",
"ackError",
"if",
"one",
"fails",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_write_stream.go#L217-L255 |
149,015 | colinmarc/hdfs | stat.go | Stat | func (c *Client) Stat(name string) (os.FileInfo, error) {
fi, err := c.getFileInfo(name)
if err != nil {
err = &os.PathError{"stat", name, interpretException(err)}
}
return fi, err
} | go | func (c *Client) Stat(name string) (os.FileInfo, error) {
fi, err := c.getFileInfo(name)
if err != nil {
err = &os.PathError{"stat", name, interpretException(err)}
}
return fi, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Stat",
"(",
"name",
"string",
")",
"(",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"fi",
",",
"err",
":=",
"c",
".",
"getFileInfo",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"return",
"fi",
",",
"err",
"\n",
"}"
] | // Stat returns an os.FileInfo describing the named file or directory. | [
"Stat",
"returns",
"an",
"os",
".",
"FileInfo",
"describing",
"the",
"named",
"file",
"or",
"directory",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/stat.go#L20-L27 |
149,016 | colinmarc/hdfs | stat.go | AccessTime | func (fi *FileInfo) AccessTime() time.Time {
return time.Unix(int64(fi.status.GetAccessTime())/1000, 0)
} | go | func (fi *FileInfo) AccessTime() time.Time {
return time.Unix(int64(fi.status.GetAccessTime())/1000, 0)
} | [
"func",
"(",
"fi",
"*",
"FileInfo",
")",
"AccessTime",
"(",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"fi",
".",
"status",
".",
"GetAccessTime",
"(",
")",
")",
"/",
"1000",
",",
"0",
")",
"\n",
"}"
] | // AccessTime returns the last time the file was accessed. It's not part of the
// os.FileInfo interface. | [
"AccessTime",
"returns",
"the",
"last",
"time",
"the",
"file",
"was",
"accessed",
".",
"It",
"s",
"not",
"part",
"of",
"the",
"os",
".",
"FileInfo",
"interface",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/stat.go#L104-L106 |
149,017 | colinmarc/hdfs | client.go | NewClient | func NewClient(options ClientOptions) (*Client, error) {
var err error
if options.KerberosClient != nil && options.KerberosClient.Credentials == nil {
return nil, errors.New("kerberos enabled, but kerberos client is missing credentials")
}
if options.KerberosClient != nil && options.KerberosServicePrincipleName == "" {
return nil, errors.New("kerberos enabled, but kerberos namenode SPN is not provided")
}
namenode, err := rpc.NewNamenodeConnection(
rpc.NamenodeConnectionOptions{
Addresses: options.Addresses,
User: options.User,
DialFunc: options.NamenodeDialFunc,
KerberosClient: options.KerberosClient,
KerberosServicePrincipleName: options.KerberosServicePrincipleName,
},
)
if err != nil {
return nil, err
}
return &Client{namenode: namenode, options: options}, nil
} | go | func NewClient(options ClientOptions) (*Client, error) {
var err error
if options.KerberosClient != nil && options.KerberosClient.Credentials == nil {
return nil, errors.New("kerberos enabled, but kerberos client is missing credentials")
}
if options.KerberosClient != nil && options.KerberosServicePrincipleName == "" {
return nil, errors.New("kerberos enabled, but kerberos namenode SPN is not provided")
}
namenode, err := rpc.NewNamenodeConnection(
rpc.NamenodeConnectionOptions{
Addresses: options.Addresses,
User: options.User,
DialFunc: options.NamenodeDialFunc,
KerberosClient: options.KerberosClient,
KerberosServicePrincipleName: options.KerberosServicePrincipleName,
},
)
if err != nil {
return nil, err
}
return &Client{namenode: namenode, options: options}, nil
} | [
"func",
"NewClient",
"(",
"options",
"ClientOptions",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"options",
".",
"KerberosClient",
"!=",
"nil",
"&&",
"options",
".",
"KerberosClient",
".",
"Credentials",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"options",
".",
"KerberosClient",
"!=",
"nil",
"&&",
"options",
".",
"KerberosServicePrincipleName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"namenode",
",",
"err",
":=",
"rpc",
".",
"NewNamenodeConnection",
"(",
"rpc",
".",
"NamenodeConnectionOptions",
"{",
"Addresses",
":",
"options",
".",
"Addresses",
",",
"User",
":",
"options",
".",
"User",
",",
"DialFunc",
":",
"options",
".",
"NamenodeDialFunc",
",",
"KerberosClient",
":",
"options",
".",
"KerberosClient",
",",
"KerberosServicePrincipleName",
":",
"options",
".",
"KerberosServicePrincipleName",
",",
"}",
",",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Client",
"{",
"namenode",
":",
"namenode",
",",
"options",
":",
"options",
"}",
",",
"nil",
"\n",
"}"
] | // NewClient returns a connected Client for the given options, or an error if
// the client could not be created. | [
"NewClient",
"returns",
"a",
"connected",
"Client",
"for",
"the",
"given",
"options",
"or",
"an",
"error",
"if",
"the",
"client",
"could",
"not",
"be",
"created",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/client.go#L122-L147 |
149,018 | colinmarc/hdfs | client.go | CopyToLocal | func (c *Client) CopyToLocal(src string, dst string) error {
remote, err := c.Open(src)
if err != nil {
return err
}
defer remote.Close()
local, err := os.Create(dst)
if err != nil {
return err
}
defer local.Close()
_, err = io.Copy(local, remote)
return err
} | go | func (c *Client) CopyToLocal(src string, dst string) error {
remote, err := c.Open(src)
if err != nil {
return err
}
defer remote.Close()
local, err := os.Create(dst)
if err != nil {
return err
}
defer local.Close()
_, err = io.Copy(local, remote)
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CopyToLocal",
"(",
"src",
"string",
",",
"dst",
"string",
")",
"error",
"{",
"remote",
",",
"err",
":=",
"c",
".",
"Open",
"(",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"remote",
".",
"Close",
"(",
")",
"\n\n",
"local",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"dst",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"local",
".",
"Close",
"(",
")",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"local",
",",
"remote",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // CopyToLocal copies the HDFS file specified by src to the local file at dst.
// If dst already exists, it will be overwritten. | [
"CopyToLocal",
"copies",
"the",
"HDFS",
"file",
"specified",
"by",
"src",
"to",
"the",
"local",
"file",
"at",
"dst",
".",
"If",
"dst",
"already",
"exists",
"it",
"will",
"be",
"overwritten",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/client.go#L200-L215 |
149,019 | colinmarc/hdfs | internal/rpc/checksum_reader.go | SetDeadline | func (cr *ChecksumReader) SetDeadline(t time.Time) error {
cr.deadline = t
// Return the error at connection time.
return nil
} | go | func (cr *ChecksumReader) SetDeadline(t time.Time) error {
cr.deadline = t
// Return the error at connection time.
return nil
} | [
"func",
"(",
"cr",
"*",
"ChecksumReader",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"cr",
".",
"deadline",
"=",
"t",
"\n",
"// Return the error at connection time.",
"return",
"nil",
"\n",
"}"
] | // SetDeadline sets the deadline for future ReadChecksum calls. A zero value
// for t means Read will not time out. | [
"SetDeadline",
"sets",
"the",
"deadline",
"for",
"future",
"ReadChecksum",
"calls",
".",
"A",
"zero",
"value",
"for",
"t",
"means",
"Read",
"will",
"not",
"time",
"out",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/checksum_reader.go#L32-L36 |
149,020 | colinmarc/hdfs | internal/rpc/checksum_reader.go | ReadChecksum | func (cr *ChecksumReader) ReadChecksum() ([]byte, error) {
if cr.datanodes == nil {
locs := cr.Block.GetLocs()
datanodes := make([]string, len(locs))
for i, loc := range locs {
dn := loc.GetId()
datanodes[i] = getDatanodeAddress(dn, cr.UseDatanodeHostname)
}
cr.datanodes = newDatanodeFailover(datanodes)
}
for cr.datanodes.numRemaining() > 0 {
address := cr.datanodes.next()
checksum, err := cr.readChecksum(address)
if err != nil {
cr.datanodes.recordFailure(err)
continue
}
return checksum, nil
}
err := cr.datanodes.lastError()
if err != nil {
err = errors.New("No available datanodes for block.")
}
return nil, err
} | go | func (cr *ChecksumReader) ReadChecksum() ([]byte, error) {
if cr.datanodes == nil {
locs := cr.Block.GetLocs()
datanodes := make([]string, len(locs))
for i, loc := range locs {
dn := loc.GetId()
datanodes[i] = getDatanodeAddress(dn, cr.UseDatanodeHostname)
}
cr.datanodes = newDatanodeFailover(datanodes)
}
for cr.datanodes.numRemaining() > 0 {
address := cr.datanodes.next()
checksum, err := cr.readChecksum(address)
if err != nil {
cr.datanodes.recordFailure(err)
continue
}
return checksum, nil
}
err := cr.datanodes.lastError()
if err != nil {
err = errors.New("No available datanodes for block.")
}
return nil, err
} | [
"func",
"(",
"cr",
"*",
"ChecksumReader",
")",
"ReadChecksum",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"cr",
".",
"datanodes",
"==",
"nil",
"{",
"locs",
":=",
"cr",
".",
"Block",
".",
"GetLocs",
"(",
")",
"\n",
"datanodes",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"locs",
")",
")",
"\n",
"for",
"i",
",",
"loc",
":=",
"range",
"locs",
"{",
"dn",
":=",
"loc",
".",
"GetId",
"(",
")",
"\n",
"datanodes",
"[",
"i",
"]",
"=",
"getDatanodeAddress",
"(",
"dn",
",",
"cr",
".",
"UseDatanodeHostname",
")",
"\n",
"}",
"\n\n",
"cr",
".",
"datanodes",
"=",
"newDatanodeFailover",
"(",
"datanodes",
")",
"\n",
"}",
"\n\n",
"for",
"cr",
".",
"datanodes",
".",
"numRemaining",
"(",
")",
">",
"0",
"{",
"address",
":=",
"cr",
".",
"datanodes",
".",
"next",
"(",
")",
"\n",
"checksum",
",",
"err",
":=",
"cr",
".",
"readChecksum",
"(",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cr",
".",
"datanodes",
".",
"recordFailure",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"return",
"checksum",
",",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"cr",
".",
"datanodes",
".",
"lastError",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"err",
"\n",
"}"
] | // ReadChecksum returns the checksum of the block. | [
"ReadChecksum",
"returns",
"the",
"checksum",
"of",
"the",
"block",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/checksum_reader.go#L39-L68 |
149,021 | gocelery/gocelery | convert.go | GetRealValue | func GetRealValue(val *reflect.Value) interface{} {
if val == nil {
return nil
}
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return val.Int()
case reflect.String:
return val.String()
case reflect.Bool:
return val.Bool()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return val.Uint()
case reflect.Float32, reflect.Float64:
return val.Float()
default:
return nil
}
} | go | func GetRealValue(val *reflect.Value) interface{} {
if val == nil {
return nil
}
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return val.Int()
case reflect.String:
return val.String()
case reflect.Bool:
return val.Bool()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return val.Uint()
case reflect.Float32, reflect.Float64:
return val.Float()
default:
return nil
}
} | [
"func",
"GetRealValue",
"(",
"val",
"*",
"reflect",
".",
"Value",
")",
"interface",
"{",
"}",
"{",
"if",
"val",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"val",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Int",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Int64",
":",
"return",
"val",
".",
"Int",
"(",
")",
"\n",
"case",
"reflect",
".",
"String",
":",
"return",
"val",
".",
"String",
"(",
")",
"\n",
"case",
"reflect",
".",
"Bool",
":",
"return",
"val",
".",
"Bool",
"(",
")",
"\n",
"case",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
",",
"reflect",
".",
"Uint64",
":",
"return",
"val",
".",
"Uint",
"(",
")",
"\n",
"case",
"reflect",
".",
"Float32",
",",
"reflect",
".",
"Float64",
":",
"return",
"val",
".",
"Float",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // GetRealValue returns real value of reflect.Value
// Required for JSON Marshalling | [
"GetRealValue",
"returns",
"real",
"value",
"of",
"reflect",
".",
"Value",
"Required",
"for",
"JSON",
"Marshalling"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/convert.go#L13-L31 |
149,022 | gocelery/gocelery | message.go | GetTaskMessage | func (cm *CeleryMessage) GetTaskMessage() *TaskMessage {
// ensure content-type is 'application/json'
if cm.ContentType != "application/json" {
log.Println("unsupported content type " + cm.ContentType)
return nil
}
// ensure body encoding is base64
if cm.Properties.BodyEncoding != "base64" {
log.Println("unsupported body encoding " + cm.Properties.BodyEncoding)
return nil
}
// ensure content encoding is utf-8
if cm.ContentEncoding != "utf-8" {
log.Println("unsupported encoding " + cm.ContentEncoding)
return nil
}
// decode body
taskMessage, err := DecodeTaskMessage(cm.Body)
if err != nil {
log.Println("failed to decode task message")
return nil
}
return taskMessage
} | go | func (cm *CeleryMessage) GetTaskMessage() *TaskMessage {
// ensure content-type is 'application/json'
if cm.ContentType != "application/json" {
log.Println("unsupported content type " + cm.ContentType)
return nil
}
// ensure body encoding is base64
if cm.Properties.BodyEncoding != "base64" {
log.Println("unsupported body encoding " + cm.Properties.BodyEncoding)
return nil
}
// ensure content encoding is utf-8
if cm.ContentEncoding != "utf-8" {
log.Println("unsupported encoding " + cm.ContentEncoding)
return nil
}
// decode body
taskMessage, err := DecodeTaskMessage(cm.Body)
if err != nil {
log.Println("failed to decode task message")
return nil
}
return taskMessage
} | [
"func",
"(",
"cm",
"*",
"CeleryMessage",
")",
"GetTaskMessage",
"(",
")",
"*",
"TaskMessage",
"{",
"// ensure content-type is 'application/json'",
"if",
"cm",
".",
"ContentType",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
"+",
"cm",
".",
"ContentType",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"// ensure body encoding is base64",
"if",
"cm",
".",
"Properties",
".",
"BodyEncoding",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
"+",
"cm",
".",
"Properties",
".",
"BodyEncoding",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"// ensure content encoding is utf-8",
"if",
"cm",
".",
"ContentEncoding",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
"+",
"cm",
".",
"ContentEncoding",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"// decode body",
"taskMessage",
",",
"err",
":=",
"DecodeTaskMessage",
"(",
"cm",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"taskMessage",
"\n",
"}"
] | // GetTaskMessage retrieve and decode task messages from broker | [
"GetTaskMessage",
"retrieve",
"and",
"decode",
"task",
"messages",
"from",
"broker"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/message.go#L87-L110 |
149,023 | gocelery/gocelery | message.go | DecodeTaskMessage | func DecodeTaskMessage(encodedBody string) (*TaskMessage, error) {
body, err := base64.StdEncoding.DecodeString(encodedBody)
if err != nil {
return nil, err
}
message := taskMessagePool.Get().(*TaskMessage)
err = json.Unmarshal(body, message)
if err != nil {
return nil, err
}
return message, nil
} | go | func DecodeTaskMessage(encodedBody string) (*TaskMessage, error) {
body, err := base64.StdEncoding.DecodeString(encodedBody)
if err != nil {
return nil, err
}
message := taskMessagePool.Get().(*TaskMessage)
err = json.Unmarshal(body, message)
if err != nil {
return nil, err
}
return message, nil
} | [
"func",
"DecodeTaskMessage",
"(",
"encodedBody",
"string",
")",
"(",
"*",
"TaskMessage",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"encodedBody",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"message",
":=",
"taskMessagePool",
".",
"Get",
"(",
")",
".",
"(",
"*",
"TaskMessage",
")",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"message",
",",
"nil",
"\n",
"}"
] | // DecodeTaskMessage decodes base64 encrypted body and return TaskMessage object | [
"DecodeTaskMessage",
"decodes",
"base64",
"encrypted",
"body",
"and",
"return",
"TaskMessage",
"object"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/message.go#L156-L167 |
149,024 | gocelery/gocelery | message.go | Encode | func (tm *TaskMessage) Encode() (string, error) {
jsonData, err := json.Marshal(tm)
if err != nil {
return "", err
}
encodedData := base64.StdEncoding.EncodeToString(jsonData)
return encodedData, err
} | go | func (tm *TaskMessage) Encode() (string, error) {
jsonData, err := json.Marshal(tm)
if err != nil {
return "", err
}
encodedData := base64.StdEncoding.EncodeToString(jsonData)
return encodedData, err
} | [
"func",
"(",
"tm",
"*",
"TaskMessage",
")",
"Encode",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"jsonData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"tm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"encodedData",
":=",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"jsonData",
")",
"\n",
"return",
"encodedData",
",",
"err",
"\n",
"}"
] | // Encode returns base64 json encoded string | [
"Encode",
"returns",
"base64",
"json",
"encoded",
"string"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/message.go#L170-L177 |
149,025 | gocelery/gocelery | amqp.go | deliveryAck | func deliveryAck(delivery amqp.Delivery) {
retryCount := 3
var err error
for retryCount > 0 {
if err = delivery.Ack(false); err == nil {
break
}
}
if err != nil {
log.Printf("amqp_backend: failed to acknowledge result message %+v: %+v", delivery.MessageId, err)
}
} | go | func deliveryAck(delivery amqp.Delivery) {
retryCount := 3
var err error
for retryCount > 0 {
if err = delivery.Ack(false); err == nil {
break
}
}
if err != nil {
log.Printf("amqp_backend: failed to acknowledge result message %+v: %+v", delivery.MessageId, err)
}
} | [
"func",
"deliveryAck",
"(",
"delivery",
"amqp",
".",
"Delivery",
")",
"{",
"retryCount",
":=",
"3",
"\n",
"var",
"err",
"error",
"\n",
"for",
"retryCount",
">",
"0",
"{",
"if",
"err",
"=",
"delivery",
".",
"Ack",
"(",
"false",
")",
";",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"delivery",
".",
"MessageId",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // deliveryAck acknowledges delivery message with retries on error | [
"deliveryAck",
"acknowledges",
"delivery",
"message",
"with",
"retries",
"on",
"error"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp.go#L14-L25 |
149,026 | gocelery/gocelery | worker.go | NewCeleryWorker | func NewCeleryWorker(broker CeleryBroker, backend CeleryBackend, numWorkers int) *CeleryWorker {
return &CeleryWorker{
broker: broker,
backend: backend,
numWorkers: numWorkers,
registeredTasks: map[string]interface{}{},
rateLimitPeriod: 100 * time.Millisecond,
}
} | go | func NewCeleryWorker(broker CeleryBroker, backend CeleryBackend, numWorkers int) *CeleryWorker {
return &CeleryWorker{
broker: broker,
backend: backend,
numWorkers: numWorkers,
registeredTasks: map[string]interface{}{},
rateLimitPeriod: 100 * time.Millisecond,
}
} | [
"func",
"NewCeleryWorker",
"(",
"broker",
"CeleryBroker",
",",
"backend",
"CeleryBackend",
",",
"numWorkers",
"int",
")",
"*",
"CeleryWorker",
"{",
"return",
"&",
"CeleryWorker",
"{",
"broker",
":",
"broker",
",",
"backend",
":",
"backend",
",",
"numWorkers",
":",
"numWorkers",
",",
"registeredTasks",
":",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
",",
"rateLimitPeriod",
":",
"100",
"*",
"time",
".",
"Millisecond",
",",
"}",
"\n",
"}"
] | // NewCeleryWorker returns new celery worker | [
"NewCeleryWorker",
"returns",
"new",
"celery",
"worker"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/worker.go#L29-L37 |
149,027 | gocelery/gocelery | worker.go | GetTask | func (w *CeleryWorker) GetTask(name string) interface{} {
w.taskLock.RLock()
task, ok := w.registeredTasks[name]
if !ok {
w.taskLock.RUnlock()
return nil
}
w.taskLock.RUnlock()
return task
} | go | func (w *CeleryWorker) GetTask(name string) interface{} {
w.taskLock.RLock()
task, ok := w.registeredTasks[name]
if !ok {
w.taskLock.RUnlock()
return nil
}
w.taskLock.RUnlock()
return task
} | [
"func",
"(",
"w",
"*",
"CeleryWorker",
")",
"GetTask",
"(",
"name",
"string",
")",
"interface",
"{",
"}",
"{",
"w",
".",
"taskLock",
".",
"RLock",
"(",
")",
"\n",
"task",
",",
"ok",
":=",
"w",
".",
"registeredTasks",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"w",
".",
"taskLock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"w",
".",
"taskLock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"task",
"\n",
"}"
] | // GetTask retrieves registered task | [
"GetTask",
"retrieves",
"registered",
"task"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/worker.go#L108-L117 |
149,028 | gocelery/gocelery | worker.go | RunTask | func (w *CeleryWorker) RunTask(message *TaskMessage) (*ResultMessage, error) {
// get task
task := w.GetTask(message.Task)
if task == nil {
return nil, fmt.Errorf("task %s is not registered", message.Task)
}
// convert to task interface
taskInterface, ok := task.(CeleryTask)
if ok {
if err := taskInterface.ParseKwargs(message.Kwargs); err != nil {
return nil, err
}
val, err := taskInterface.RunTask()
if err != nil {
return nil, err
}
return getResultMessage(val), err
}
// use reflection to execute function ptr
taskFunc := reflect.ValueOf(task)
return runTaskFunc(&taskFunc, message)
} | go | func (w *CeleryWorker) RunTask(message *TaskMessage) (*ResultMessage, error) {
// get task
task := w.GetTask(message.Task)
if task == nil {
return nil, fmt.Errorf("task %s is not registered", message.Task)
}
// convert to task interface
taskInterface, ok := task.(CeleryTask)
if ok {
if err := taskInterface.ParseKwargs(message.Kwargs); err != nil {
return nil, err
}
val, err := taskInterface.RunTask()
if err != nil {
return nil, err
}
return getResultMessage(val), err
}
// use reflection to execute function ptr
taskFunc := reflect.ValueOf(task)
return runTaskFunc(&taskFunc, message)
} | [
"func",
"(",
"w",
"*",
"CeleryWorker",
")",
"RunTask",
"(",
"message",
"*",
"TaskMessage",
")",
"(",
"*",
"ResultMessage",
",",
"error",
")",
"{",
"// get task",
"task",
":=",
"w",
".",
"GetTask",
"(",
"message",
".",
"Task",
")",
"\n",
"if",
"task",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"message",
".",
"Task",
")",
"\n",
"}",
"\n\n",
"// convert to task interface",
"taskInterface",
",",
"ok",
":=",
"task",
".",
"(",
"CeleryTask",
")",
"\n",
"if",
"ok",
"{",
"if",
"err",
":=",
"taskInterface",
".",
"ParseKwargs",
"(",
"message",
".",
"Kwargs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"val",
",",
"err",
":=",
"taskInterface",
".",
"RunTask",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"getResultMessage",
"(",
"val",
")",
",",
"err",
"\n",
"}",
"\n\n",
"// use reflection to execute function ptr",
"taskFunc",
":=",
"reflect",
".",
"ValueOf",
"(",
"task",
")",
"\n",
"return",
"runTaskFunc",
"(",
"&",
"taskFunc",
",",
"message",
")",
"\n",
"}"
] | // RunTask runs celery task | [
"RunTask",
"runs",
"celery",
"task"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/worker.go#L120-L144 |
149,029 | gocelery/gocelery | redis_backend.go | GetResult | func (cb *RedisCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
conn := cb.Get()
defer conn.Close()
val, err := conn.Do("GET", fmt.Sprintf("celery-task-meta-%s", taskID))
if err != nil {
return nil, err
}
if val == nil {
return nil, fmt.Errorf("result not available")
}
var resultMessage ResultMessage
err = json.Unmarshal(val.([]byte), &resultMessage)
if err != nil {
return nil, err
}
return &resultMessage, nil
} | go | func (cb *RedisCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
conn := cb.Get()
defer conn.Close()
val, err := conn.Do("GET", fmt.Sprintf("celery-task-meta-%s", taskID))
if err != nil {
return nil, err
}
if val == nil {
return nil, fmt.Errorf("result not available")
}
var resultMessage ResultMessage
err = json.Unmarshal(val.([]byte), &resultMessage)
if err != nil {
return nil, err
}
return &resultMessage, nil
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBackend",
")",
"GetResult",
"(",
"taskID",
"string",
")",
"(",
"*",
"ResultMessage",
",",
"error",
")",
"{",
"conn",
":=",
"cb",
".",
"Get",
"(",
")",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"val",
",",
"err",
":=",
"conn",
".",
"Do",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"taskID",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"resultMessage",
"ResultMessage",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"val",
".",
"(",
"[",
"]",
"byte",
")",
",",
"&",
"resultMessage",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"resultMessage",
",",
"nil",
"\n",
"}"
] | // GetResult queries redis backend to get asynchronous result | [
"GetResult",
"queries",
"redis",
"backend",
"to",
"get",
"asynchronous",
"result"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_backend.go#L27-L43 |
149,030 | gocelery/gocelery | redis_backend.go | SetResult | func (cb *RedisCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
resBytes, err := json.Marshal(result)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("SETEX", fmt.Sprintf("celery-task-meta-%s", taskID), 86400, resBytes)
return err
} | go | func (cb *RedisCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
resBytes, err := json.Marshal(result)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("SETEX", fmt.Sprintf("celery-task-meta-%s", taskID), 86400, resBytes)
return err
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBackend",
")",
"SetResult",
"(",
"taskID",
"string",
",",
"result",
"*",
"ResultMessage",
")",
"error",
"{",
"resBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
":=",
"cb",
".",
"Get",
"(",
")",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"conn",
".",
"Do",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"taskID",
")",
",",
"86400",
",",
"resBytes",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // SetResult pushes result back into redis backend | [
"SetResult",
"pushes",
"result",
"back",
"into",
"redis",
"backend"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_backend.go#L46-L55 |
149,031 | gocelery/gocelery | gocelery.go | NewCeleryClient | func NewCeleryClient(broker CeleryBroker, backend CeleryBackend, numWorkers int) (*CeleryClient, error) {
return &CeleryClient{
broker,
backend,
NewCeleryWorker(broker, backend, numWorkers),
}, nil
} | go | func NewCeleryClient(broker CeleryBroker, backend CeleryBackend, numWorkers int) (*CeleryClient, error) {
return &CeleryClient{
broker,
backend,
NewCeleryWorker(broker, backend, numWorkers),
}, nil
} | [
"func",
"NewCeleryClient",
"(",
"broker",
"CeleryBroker",
",",
"backend",
"CeleryBackend",
",",
"numWorkers",
"int",
")",
"(",
"*",
"CeleryClient",
",",
"error",
")",
"{",
"return",
"&",
"CeleryClient",
"{",
"broker",
",",
"backend",
",",
"NewCeleryWorker",
"(",
"broker",
",",
"backend",
",",
"numWorkers",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewCeleryClient creates new celery client | [
"NewCeleryClient",
"creates",
"new",
"celery",
"client"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L33-L39 |
149,032 | gocelery/gocelery | gocelery.go | StartWorkerWithContext | func (cc *CeleryClient) StartWorkerWithContext(ctx context.Context) {
cc.worker.StartWorkerWithContext(ctx)
} | go | func (cc *CeleryClient) StartWorkerWithContext(ctx context.Context) {
cc.worker.StartWorkerWithContext(ctx)
} | [
"func",
"(",
"cc",
"*",
"CeleryClient",
")",
"StartWorkerWithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"cc",
".",
"worker",
".",
"StartWorkerWithContext",
"(",
"ctx",
")",
"\n",
"}"
] | // StartWorkerWithContext starts celery workers with given parent context | [
"StartWorkerWithContext",
"starts",
"celery",
"workers",
"with",
"given",
"parent",
"context"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L47-L49 |
149,033 | gocelery/gocelery | gocelery.go | Delay | func (cc *CeleryClient) Delay(task string, args ...interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Args = args
return cc.delay(celeryTask)
} | go | func (cc *CeleryClient) Delay(task string, args ...interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Args = args
return cc.delay(celeryTask)
} | [
"func",
"(",
"cc",
"*",
"CeleryClient",
")",
"Delay",
"(",
"task",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"AsyncResult",
",",
"error",
")",
"{",
"celeryTask",
":=",
"getTaskMessage",
"(",
"task",
")",
"\n",
"celeryTask",
".",
"Args",
"=",
"args",
"\n",
"return",
"cc",
".",
"delay",
"(",
"celeryTask",
")",
"\n",
"}"
] | // Delay gets asynchronous result | [
"Delay",
"gets",
"asynchronous",
"result"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L67-L71 |
149,034 | gocelery/gocelery | gocelery.go | DelayKwargs | func (cc *CeleryClient) DelayKwargs(task string, args map[string]interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Kwargs = args
return cc.delay(celeryTask)
} | go | func (cc *CeleryClient) DelayKwargs(task string, args map[string]interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Kwargs = args
return cc.delay(celeryTask)
} | [
"func",
"(",
"cc",
"*",
"CeleryClient",
")",
"DelayKwargs",
"(",
"task",
"string",
",",
"args",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"*",
"AsyncResult",
",",
"error",
")",
"{",
"celeryTask",
":=",
"getTaskMessage",
"(",
"task",
")",
"\n",
"celeryTask",
".",
"Kwargs",
"=",
"args",
"\n",
"return",
"cc",
".",
"delay",
"(",
"celeryTask",
")",
"\n",
"}"
] | // DelayKwargs gets asynchronous results with argument map | [
"DelayKwargs",
"gets",
"asynchronous",
"results",
"with",
"argument",
"map"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L74-L78 |
149,035 | gocelery/gocelery | gocelery.go | Get | func (ar *AsyncResult) Get(timeout time.Duration) (interface{}, error) {
ticker := time.NewTicker(50 * time.Millisecond)
timeoutChan := time.After(timeout)
for {
select {
case <-timeoutChan:
err := fmt.Errorf("%v timeout getting result for %s", timeout, ar.TaskID)
return nil, err
case <-ticker.C:
val, err := ar.AsyncGet()
if err != nil {
continue
}
return val, nil
}
}
} | go | func (ar *AsyncResult) Get(timeout time.Duration) (interface{}, error) {
ticker := time.NewTicker(50 * time.Millisecond)
timeoutChan := time.After(timeout)
for {
select {
case <-timeoutChan:
err := fmt.Errorf("%v timeout getting result for %s", timeout, ar.TaskID)
return nil, err
case <-ticker.C:
val, err := ar.AsyncGet()
if err != nil {
continue
}
return val, nil
}
}
} | [
"func",
"(",
"ar",
"*",
"AsyncResult",
")",
"Get",
"(",
"timeout",
"time",
".",
"Duration",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"50",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"timeoutChan",
":=",
"time",
".",
"After",
"(",
"timeout",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"timeoutChan",
":",
"err",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"timeout",
",",
"ar",
".",
"TaskID",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"case",
"<-",
"ticker",
".",
"C",
":",
"val",
",",
"err",
":=",
"ar",
".",
"AsyncGet",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"val",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Get gets actual result from backend
// It blocks for period of time set by timeout and returns error if unavailable | [
"Get",
"gets",
"actual",
"result",
"from",
"backend",
"It",
"blocks",
"for",
"period",
"of",
"time",
"set",
"by",
"timeout",
"and",
"returns",
"error",
"if",
"unavailable"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L120-L136 |
149,036 | gocelery/gocelery | gocelery.go | AsyncGet | func (ar *AsyncResult) AsyncGet() (interface{}, error) {
if ar.result != nil {
return ar.result.Result, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return nil, err
}
if val == nil {
return nil, err
}
if val.Status != "SUCCESS" {
return nil, fmt.Errorf("error response status %v", val)
}
ar.result = val
return val.Result, nil
} | go | func (ar *AsyncResult) AsyncGet() (interface{}, error) {
if ar.result != nil {
return ar.result.Result, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return nil, err
}
if val == nil {
return nil, err
}
if val.Status != "SUCCESS" {
return nil, fmt.Errorf("error response status %v", val)
}
ar.result = val
return val.Result, nil
} | [
"func",
"(",
"ar",
"*",
"AsyncResult",
")",
"AsyncGet",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"ar",
".",
"result",
"!=",
"nil",
"{",
"return",
"ar",
".",
"result",
".",
"Result",
",",
"nil",
"\n",
"}",
"\n",
"val",
",",
"err",
":=",
"ar",
".",
"backend",
".",
"GetResult",
"(",
"ar",
".",
"TaskID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"val",
".",
"Status",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"val",
")",
"\n",
"}",
"\n",
"ar",
".",
"result",
"=",
"val",
"\n",
"return",
"val",
".",
"Result",
",",
"nil",
"\n",
"}"
] | // AsyncGet gets actual result from backend and returns nil if not available | [
"AsyncGet",
"gets",
"actual",
"result",
"from",
"backend",
"and",
"returns",
"nil",
"if",
"not",
"available"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L139-L155 |
149,037 | gocelery/gocelery | gocelery.go | Ready | func (ar *AsyncResult) Ready() (bool, error) {
if ar.result != nil {
return true, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return false, err
}
ar.result = val
return (val != nil), nil
} | go | func (ar *AsyncResult) Ready() (bool, error) {
if ar.result != nil {
return true, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return false, err
}
ar.result = val
return (val != nil), nil
} | [
"func",
"(",
"ar",
"*",
"AsyncResult",
")",
"Ready",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"ar",
".",
"result",
"!=",
"nil",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"val",
",",
"err",
":=",
"ar",
".",
"backend",
".",
"GetResult",
"(",
"ar",
".",
"TaskID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"ar",
".",
"result",
"=",
"val",
"\n",
"return",
"(",
"val",
"!=",
"nil",
")",
",",
"nil",
"\n",
"}"
] | // Ready checks if actual result is ready | [
"Ready",
"checks",
"if",
"actual",
"result",
"is",
"ready"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L158-L168 |
149,038 | gocelery/gocelery | amqp_broker.go | NewAMQPExchange | func NewAMQPExchange(name string) *AMQPExchange {
return &AMQPExchange{
Name: name,
Type: "direct",
Durable: true,
AutoDelete: true,
}
} | go | func NewAMQPExchange(name string) *AMQPExchange {
return &AMQPExchange{
Name: name,
Type: "direct",
Durable: true,
AutoDelete: true,
}
} | [
"func",
"NewAMQPExchange",
"(",
"name",
"string",
")",
"*",
"AMQPExchange",
"{",
"return",
"&",
"AMQPExchange",
"{",
"Name",
":",
"name",
",",
"Type",
":",
"\"",
"\"",
",",
"Durable",
":",
"true",
",",
"AutoDelete",
":",
"true",
",",
"}",
"\n",
"}"
] | // NewAMQPExchange creates new AMQPExchange | [
"NewAMQPExchange",
"creates",
"new",
"AMQPExchange"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L24-L31 |
149,039 | gocelery/gocelery | amqp_broker.go | NewAMQPQueue | func NewAMQPQueue(name string) *AMQPQueue {
return &AMQPQueue{
Name: name,
Durable: true,
AutoDelete: false,
}
} | go | func NewAMQPQueue(name string) *AMQPQueue {
return &AMQPQueue{
Name: name,
Durable: true,
AutoDelete: false,
}
} | [
"func",
"NewAMQPQueue",
"(",
"name",
"string",
")",
"*",
"AMQPQueue",
"{",
"return",
"&",
"AMQPQueue",
"{",
"Name",
":",
"name",
",",
"Durable",
":",
"true",
",",
"AutoDelete",
":",
"false",
",",
"}",
"\n",
"}"
] | // NewAMQPQueue creates new AMQPQueue | [
"NewAMQPQueue",
"creates",
"new",
"AMQPQueue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L41-L47 |
149,040 | gocelery/gocelery | amqp_broker.go | NewAMQPConnection | func NewAMQPConnection(host string) (*amqp.Connection, *amqp.Channel) {
connection, err := amqp.Dial(host)
if err != nil {
panic(err)
}
channel, err := connection.Channel()
if err != nil {
panic(err)
}
return connection, channel
} | go | func NewAMQPConnection(host string) (*amqp.Connection, *amqp.Channel) {
connection, err := amqp.Dial(host)
if err != nil {
panic(err)
}
channel, err := connection.Channel()
if err != nil {
panic(err)
}
return connection, channel
} | [
"func",
"NewAMQPConnection",
"(",
"host",
"string",
")",
"(",
"*",
"amqp",
".",
"Connection",
",",
"*",
"amqp",
".",
"Channel",
")",
"{",
"connection",
",",
"err",
":=",
"amqp",
".",
"Dial",
"(",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"channel",
",",
"err",
":=",
"connection",
".",
"Channel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"connection",
",",
"channel",
"\n",
"}"
] | // NewAMQPConnection creates new AMQP channel | [
"NewAMQPConnection",
"creates",
"new",
"AMQP",
"channel"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L60-L71 |
149,041 | gocelery/gocelery | amqp_broker.go | NewAMQPCeleryBrokerByConnAndChannel | func NewAMQPCeleryBrokerByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBroker {
broker := &AMQPCeleryBroker{
Channel: channel,
connection: conn,
exchange: NewAMQPExchange("default"),
queue: NewAMQPQueue("celery"),
rate: 4,
}
if err := broker.CreateExchange(); err != nil {
panic(err)
}
if err := broker.CreateQueue(); err != nil {
panic(err)
}
if err := broker.Qos(broker.rate, 0, false); err != nil {
panic(err)
}
if err := broker.StartConsumingChannel(); err != nil {
panic(err)
}
return broker
} | go | func NewAMQPCeleryBrokerByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBroker {
broker := &AMQPCeleryBroker{
Channel: channel,
connection: conn,
exchange: NewAMQPExchange("default"),
queue: NewAMQPQueue("celery"),
rate: 4,
}
if err := broker.CreateExchange(); err != nil {
panic(err)
}
if err := broker.CreateQueue(); err != nil {
panic(err)
}
if err := broker.Qos(broker.rate, 0, false); err != nil {
panic(err)
}
if err := broker.StartConsumingChannel(); err != nil {
panic(err)
}
return broker
} | [
"func",
"NewAMQPCeleryBrokerByConnAndChannel",
"(",
"conn",
"*",
"amqp",
".",
"Connection",
",",
"channel",
"*",
"amqp",
".",
"Channel",
")",
"*",
"AMQPCeleryBroker",
"{",
"broker",
":=",
"&",
"AMQPCeleryBroker",
"{",
"Channel",
":",
"channel",
",",
"connection",
":",
"conn",
",",
"exchange",
":",
"NewAMQPExchange",
"(",
"\"",
"\"",
")",
",",
"queue",
":",
"NewAMQPQueue",
"(",
"\"",
"\"",
")",
",",
"rate",
":",
"4",
",",
"}",
"\n",
"if",
"err",
":=",
"broker",
".",
"CreateExchange",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"broker",
".",
"CreateQueue",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"broker",
".",
"Qos",
"(",
"broker",
".",
"rate",
",",
"0",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"broker",
".",
"StartConsumingChannel",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"broker",
"\n",
"}"
] | // NewAMQPCeleryBrokerByConnAndChannel creates new AMQPCeleryBroker using AMQP conn and channel | [
"NewAMQPCeleryBrokerByConnAndChannel",
"creates",
"new",
"AMQPCeleryBroker",
"using",
"AMQP",
"conn",
"and",
"channel"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L79-L100 |
149,042 | gocelery/gocelery | amqp_broker.go | StartConsumingChannel | func (b *AMQPCeleryBroker) StartConsumingChannel() error {
channel, err := b.Consume(b.queue.Name, "", false, false, false, false, nil)
if err != nil {
return err
}
b.consumingChannel = channel
return nil
} | go | func (b *AMQPCeleryBroker) StartConsumingChannel() error {
channel, err := b.Consume(b.queue.Name, "", false, false, false, false, nil)
if err != nil {
return err
}
b.consumingChannel = channel
return nil
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"StartConsumingChannel",
"(",
")",
"error",
"{",
"channel",
",",
"err",
":=",
"b",
".",
"Consume",
"(",
"b",
".",
"queue",
".",
"Name",
",",
"\"",
"\"",
",",
"false",
",",
"false",
",",
"false",
",",
"false",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"b",
".",
"consumingChannel",
"=",
"channel",
"\n",
"return",
"nil",
"\n",
"}"
] | // StartConsumingChannel spawns receiving channel on AMQP queue | [
"StartConsumingChannel",
"spawns",
"receiving",
"channel",
"on",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L103-L110 |
149,043 | gocelery/gocelery | amqp_broker.go | SendCeleryMessage | func (b *AMQPCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
taskMessage := message.GetTaskMessage()
queueName := "celery"
_, err := b.QueueDeclare(
queueName, // name
true, // durable
false, // autoDelete
false, // exclusive
false, // noWait
nil, // args
)
if err != nil {
return err
}
err = b.ExchangeDeclare(
"default",
"direct",
true,
true,
false,
false,
nil,
)
if err != nil {
return err
}
resBytes, err := json.Marshal(taskMessage)
if err != nil {
return err
}
publishMessage := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: "application/json",
Body: resBytes,
}
return b.Publish(
"",
queueName,
false,
false,
publishMessage,
)
} | go | func (b *AMQPCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
taskMessage := message.GetTaskMessage()
queueName := "celery"
_, err := b.QueueDeclare(
queueName, // name
true, // durable
false, // autoDelete
false, // exclusive
false, // noWait
nil, // args
)
if err != nil {
return err
}
err = b.ExchangeDeclare(
"default",
"direct",
true,
true,
false,
false,
nil,
)
if err != nil {
return err
}
resBytes, err := json.Marshal(taskMessage)
if err != nil {
return err
}
publishMessage := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: "application/json",
Body: resBytes,
}
return b.Publish(
"",
queueName,
false,
false,
publishMessage,
)
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"SendCeleryMessage",
"(",
"message",
"*",
"CeleryMessage",
")",
"error",
"{",
"taskMessage",
":=",
"message",
".",
"GetTaskMessage",
"(",
")",
"\n",
"queueName",
":=",
"\"",
"\"",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"QueueDeclare",
"(",
"queueName",
",",
"// name",
"true",
",",
"// durable",
"false",
",",
"// autoDelete",
"false",
",",
"// exclusive",
"false",
",",
"// noWait",
"nil",
",",
"// args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"b",
".",
"ExchangeDeclare",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"true",
",",
"true",
",",
"false",
",",
"false",
",",
"nil",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"resBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"taskMessage",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"publishMessage",
":=",
"amqp",
".",
"Publishing",
"{",
"DeliveryMode",
":",
"amqp",
".",
"Persistent",
",",
"Timestamp",
":",
"time",
".",
"Now",
"(",
")",
",",
"ContentType",
":",
"\"",
"\"",
",",
"Body",
":",
"resBytes",
",",
"}",
"\n\n",
"return",
"b",
".",
"Publish",
"(",
"\"",
"\"",
",",
"queueName",
",",
"false",
",",
"false",
",",
"publishMessage",
",",
")",
"\n",
"}"
] | // SendCeleryMessage sends CeleryMessage to broker | [
"SendCeleryMessage",
"sends",
"CeleryMessage",
"to",
"broker"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L113-L159 |
149,044 | gocelery/gocelery | amqp_broker.go | GetTaskMessage | func (b *AMQPCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
select {
case delivery := <-b.consumingChannel:
deliveryAck(delivery)
var taskMessage TaskMessage
if err := json.Unmarshal(delivery.Body, &taskMessage); err != nil {
return nil, err
}
return &taskMessage, nil
default:
return nil, fmt.Errorf("consuming channel is empty")
}
} | go | func (b *AMQPCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
select {
case delivery := <-b.consumingChannel:
deliveryAck(delivery)
var taskMessage TaskMessage
if err := json.Unmarshal(delivery.Body, &taskMessage); err != nil {
return nil, err
}
return &taskMessage, nil
default:
return nil, fmt.Errorf("consuming channel is empty")
}
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"GetTaskMessage",
"(",
")",
"(",
"*",
"TaskMessage",
",",
"error",
")",
"{",
"select",
"{",
"case",
"delivery",
":=",
"<-",
"b",
".",
"consumingChannel",
":",
"deliveryAck",
"(",
"delivery",
")",
"\n",
"var",
"taskMessage",
"TaskMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"delivery",
".",
"Body",
",",
"&",
"taskMessage",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"taskMessage",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // GetTaskMessage retrieves task message from AMQP queue | [
"GetTaskMessage",
"retrieves",
"task",
"message",
"from",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L162-L174 |
149,045 | gocelery/gocelery | amqp_broker.go | CreateExchange | func (b *AMQPCeleryBroker) CreateExchange() error {
return b.ExchangeDeclare(
b.exchange.Name,
b.exchange.Type,
b.exchange.Durable,
b.exchange.AutoDelete,
false,
false,
nil,
)
} | go | func (b *AMQPCeleryBroker) CreateExchange() error {
return b.ExchangeDeclare(
b.exchange.Name,
b.exchange.Type,
b.exchange.Durable,
b.exchange.AutoDelete,
false,
false,
nil,
)
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"CreateExchange",
"(",
")",
"error",
"{",
"return",
"b",
".",
"ExchangeDeclare",
"(",
"b",
".",
"exchange",
".",
"Name",
",",
"b",
".",
"exchange",
".",
"Type",
",",
"b",
".",
"exchange",
".",
"Durable",
",",
"b",
".",
"exchange",
".",
"AutoDelete",
",",
"false",
",",
"false",
",",
"nil",
",",
")",
"\n",
"}"
] | // CreateExchange declares AMQP exchange with stored configuration | [
"CreateExchange",
"declares",
"AMQP",
"exchange",
"with",
"stored",
"configuration"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L177-L187 |
149,046 | gocelery/gocelery | amqp_broker.go | CreateQueue | func (b *AMQPCeleryBroker) CreateQueue() error {
_, err := b.QueueDeclare(
b.queue.Name,
b.queue.Durable,
b.queue.AutoDelete,
false,
false,
nil,
)
return err
} | go | func (b *AMQPCeleryBroker) CreateQueue() error {
_, err := b.QueueDeclare(
b.queue.Name,
b.queue.Durable,
b.queue.AutoDelete,
false,
false,
nil,
)
return err
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"CreateQueue",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"b",
".",
"QueueDeclare",
"(",
"b",
".",
"queue",
".",
"Name",
",",
"b",
".",
"queue",
".",
"Durable",
",",
"b",
".",
"queue",
".",
"AutoDelete",
",",
"false",
",",
"false",
",",
"nil",
",",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // CreateQueue declares AMQP Queue with stored configuration | [
"CreateQueue",
"declares",
"AMQP",
"Queue",
"with",
"stored",
"configuration"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L190-L200 |
149,047 | gocelery/gocelery | amqp_backend.go | NewAMQPCeleryBackendByConnAndChannel | func NewAMQPCeleryBackendByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBackend {
backend := &AMQPCeleryBackend{
Channel: channel,
connection: conn,
}
return backend
} | go | func NewAMQPCeleryBackendByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBackend {
backend := &AMQPCeleryBackend{
Channel: channel,
connection: conn,
}
return backend
} | [
"func",
"NewAMQPCeleryBackendByConnAndChannel",
"(",
"conn",
"*",
"amqp",
".",
"Connection",
",",
"channel",
"*",
"amqp",
".",
"Channel",
")",
"*",
"AMQPCeleryBackend",
"{",
"backend",
":=",
"&",
"AMQPCeleryBackend",
"{",
"Channel",
":",
"channel",
",",
"connection",
":",
"conn",
",",
"}",
"\n",
"return",
"backend",
"\n",
"}"
] | // NewAMQPCeleryBackendByConnAndChannel creates new AMQPCeleryBackend by AMQP connection and channel | [
"NewAMQPCeleryBackendByConnAndChannel",
"creates",
"new",
"AMQPCeleryBackend",
"by",
"AMQP",
"connection",
"and",
"channel"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L23-L29 |
149,048 | gocelery/gocelery | amqp_backend.go | NewAMQPCeleryBackend | func NewAMQPCeleryBackend(host string) *AMQPCeleryBackend {
backend := NewAMQPCeleryBackendByConnAndChannel(NewAMQPConnection(host))
backend.host = host
return backend
} | go | func NewAMQPCeleryBackend(host string) *AMQPCeleryBackend {
backend := NewAMQPCeleryBackendByConnAndChannel(NewAMQPConnection(host))
backend.host = host
return backend
} | [
"func",
"NewAMQPCeleryBackend",
"(",
"host",
"string",
")",
"*",
"AMQPCeleryBackend",
"{",
"backend",
":=",
"NewAMQPCeleryBackendByConnAndChannel",
"(",
"NewAMQPConnection",
"(",
"host",
")",
")",
"\n",
"backend",
".",
"host",
"=",
"host",
"\n",
"return",
"backend",
"\n",
"}"
] | // NewAMQPCeleryBackend creates new AMQPCeleryBackend | [
"NewAMQPCeleryBackend",
"creates",
"new",
"AMQPCeleryBackend"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L32-L36 |
149,049 | gocelery/gocelery | amqp_backend.go | Reconnect | func (b *AMQPCeleryBackend) Reconnect() {
b.connection.Close()
conn, channel := NewAMQPConnection(b.host)
b.Channel = channel
b.connection = conn
} | go | func (b *AMQPCeleryBackend) Reconnect() {
b.connection.Close()
conn, channel := NewAMQPConnection(b.host)
b.Channel = channel
b.connection = conn
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBackend",
")",
"Reconnect",
"(",
")",
"{",
"b",
".",
"connection",
".",
"Close",
"(",
")",
"\n",
"conn",
",",
"channel",
":=",
"NewAMQPConnection",
"(",
"b",
".",
"host",
")",
"\n",
"b",
".",
"Channel",
"=",
"channel",
"\n",
"b",
".",
"connection",
"=",
"conn",
"\n",
"}"
] | // Reconnect reconnects to AMQP server | [
"Reconnect",
"reconnects",
"to",
"AMQP",
"server"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L39-L44 |
149,050 | gocelery/gocelery | amqp_backend.go | GetResult | func (b *AMQPCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
queueName := strings.Replace(taskID, "-", "", -1)
args := amqp.Table{"x-expires": int32(86400000)}
_, err := b.QueueDeclare(
queueName, // name
true, // durable
true, // autoDelete
false, // exclusive
false, // noWait
args, // args
)
if err != nil {
return nil, err
}
err = b.ExchangeDeclare(
"default",
"direct",
true,
true,
false,
false,
nil,
)
if err != nil {
return nil, err
}
// open channel temporarily
channel, err := b.Consume(queueName, "", false, false, false, false, nil)
if err != nil {
return nil, err
}
var resultMessage ResultMessage
delivery := <-channel
deliveryAck(delivery)
if err := json.Unmarshal(delivery.Body, &resultMessage); err != nil {
return nil, err
}
return &resultMessage, nil
} | go | func (b *AMQPCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
queueName := strings.Replace(taskID, "-", "", -1)
args := amqp.Table{"x-expires": int32(86400000)}
_, err := b.QueueDeclare(
queueName, // name
true, // durable
true, // autoDelete
false, // exclusive
false, // noWait
args, // args
)
if err != nil {
return nil, err
}
err = b.ExchangeDeclare(
"default",
"direct",
true,
true,
false,
false,
nil,
)
if err != nil {
return nil, err
}
// open channel temporarily
channel, err := b.Consume(queueName, "", false, false, false, false, nil)
if err != nil {
return nil, err
}
var resultMessage ResultMessage
delivery := <-channel
deliveryAck(delivery)
if err := json.Unmarshal(delivery.Body, &resultMessage); err != nil {
return nil, err
}
return &resultMessage, nil
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBackend",
")",
"GetResult",
"(",
"taskID",
"string",
")",
"(",
"*",
"ResultMessage",
",",
"error",
")",
"{",
"queueName",
":=",
"strings",
".",
"Replace",
"(",
"taskID",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n\n",
"args",
":=",
"amqp",
".",
"Table",
"{",
"\"",
"\"",
":",
"int32",
"(",
"86400000",
")",
"}",
"\n\n",
"_",
",",
"err",
":=",
"b",
".",
"QueueDeclare",
"(",
"queueName",
",",
"// name",
"true",
",",
"// durable",
"true",
",",
"// autoDelete",
"false",
",",
"// exclusive",
"false",
",",
"// noWait",
"args",
",",
"// args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"ExchangeDeclare",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"true",
",",
"true",
",",
"false",
",",
"false",
",",
"nil",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// open channel temporarily",
"channel",
",",
"err",
":=",
"b",
".",
"Consume",
"(",
"queueName",
",",
"\"",
"\"",
",",
"false",
",",
"false",
",",
"false",
",",
"false",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"resultMessage",
"ResultMessage",
"\n\n",
"delivery",
":=",
"<-",
"channel",
"\n",
"deliveryAck",
"(",
"delivery",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"delivery",
".",
"Body",
",",
"&",
"resultMessage",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"resultMessage",
",",
"nil",
"\n",
"}"
] | // GetResult retrieves result from AMQP queue | [
"GetResult",
"retrieves",
"result",
"from",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L47-L92 |
149,051 | gocelery/gocelery | amqp_backend.go | SetResult | func (b *AMQPCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
result.ID = taskID
//queueName := taskID
queueName := strings.Replace(taskID, "-", "", -1)
// autodelete is automatically set to true by python
// (406) PRECONDITION_FAILED - inequivalent arg 'durable' for queue 'bc58c0d895c7421eb7cb2b9bbbd8b36f' in vhost '/': received 'true' but current is 'false'
args := amqp.Table{"x-expires": int32(86400000)}
_, err := b.QueueDeclare(
queueName, // name
true, // durable
true, // autoDelete
false, // exclusive
false, // noWait
args, // args
)
if err != nil {
return err
}
err = b.ExchangeDeclare(
"default",
"direct",
true,
true,
false,
false,
nil,
)
if err != nil {
return err
}
resBytes, err := json.Marshal(result)
if err != nil {
return err
}
message := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: "application/json",
Body: resBytes,
}
return b.Publish(
"",
queueName,
false,
false,
message,
)
} | go | func (b *AMQPCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
result.ID = taskID
//queueName := taskID
queueName := strings.Replace(taskID, "-", "", -1)
// autodelete is automatically set to true by python
// (406) PRECONDITION_FAILED - inequivalent arg 'durable' for queue 'bc58c0d895c7421eb7cb2b9bbbd8b36f' in vhost '/': received 'true' but current is 'false'
args := amqp.Table{"x-expires": int32(86400000)}
_, err := b.QueueDeclare(
queueName, // name
true, // durable
true, // autoDelete
false, // exclusive
false, // noWait
args, // args
)
if err != nil {
return err
}
err = b.ExchangeDeclare(
"default",
"direct",
true,
true,
false,
false,
nil,
)
if err != nil {
return err
}
resBytes, err := json.Marshal(result)
if err != nil {
return err
}
message := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: "application/json",
Body: resBytes,
}
return b.Publish(
"",
queueName,
false,
false,
message,
)
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBackend",
")",
"SetResult",
"(",
"taskID",
"string",
",",
"result",
"*",
"ResultMessage",
")",
"error",
"{",
"result",
".",
"ID",
"=",
"taskID",
"\n\n",
"//queueName := taskID",
"queueName",
":=",
"strings",
".",
"Replace",
"(",
"taskID",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n\n",
"// autodelete is automatically set to true by python",
"// (406) PRECONDITION_FAILED - inequivalent arg 'durable' for queue 'bc58c0d895c7421eb7cb2b9bbbd8b36f' in vhost '/': received 'true' but current is 'false'",
"args",
":=",
"amqp",
".",
"Table",
"{",
"\"",
"\"",
":",
"int32",
"(",
"86400000",
")",
"}",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"QueueDeclare",
"(",
"queueName",
",",
"// name",
"true",
",",
"// durable",
"true",
",",
"// autoDelete",
"false",
",",
"// exclusive",
"false",
",",
"// noWait",
"args",
",",
"// args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"ExchangeDeclare",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"true",
",",
"true",
",",
"false",
",",
"false",
",",
"nil",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"resBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"message",
":=",
"amqp",
".",
"Publishing",
"{",
"DeliveryMode",
":",
"amqp",
".",
"Persistent",
",",
"Timestamp",
":",
"time",
".",
"Now",
"(",
")",
",",
"ContentType",
":",
"\"",
"\"",
",",
"Body",
":",
"resBytes",
",",
"}",
"\n",
"return",
"b",
".",
"Publish",
"(",
"\"",
"\"",
",",
"queueName",
",",
"false",
",",
"false",
",",
"message",
",",
")",
"\n",
"}"
] | // SetResult sets result back to AMQP queue | [
"SetResult",
"sets",
"result",
"back",
"to",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L95-L149 |
149,052 | gocelery/gocelery | redis_broker.go | NewRedisPool | func NewRedisPool(uri string) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.DialURL(uri)
if err != nil {
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
} | go | func NewRedisPool(uri string) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.DialURL(uri)
if err != nil {
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
} | [
"func",
"NewRedisPool",
"(",
"uri",
"string",
")",
"*",
"redis",
".",
"Pool",
"{",
"return",
"&",
"redis",
".",
"Pool",
"{",
"MaxIdle",
":",
"3",
",",
"IdleTimeout",
":",
"240",
"*",
"time",
".",
"Second",
",",
"Dial",
":",
"func",
"(",
")",
"(",
"redis",
".",
"Conn",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"redis",
".",
"DialURL",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
",",
"err",
"\n",
"}",
",",
"TestOnBorrow",
":",
"func",
"(",
"c",
"redis",
".",
"Conn",
",",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"Do",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}",
",",
"}",
"\n",
"}"
] | // NewRedisPool creates pool of redis connections from given connection string | [
"NewRedisPool",
"creates",
"pool",
"of",
"redis",
"connections",
"from",
"given",
"connection",
"string"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L22-L38 |
149,053 | gocelery/gocelery | redis_broker.go | SendCeleryMessage | func (cb *RedisCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
jsonBytes, err := json.Marshal(message)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("LPUSH", cb.queueName, jsonBytes)
if err != nil {
return err
}
return nil
} | go | func (cb *RedisCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
jsonBytes, err := json.Marshal(message)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("LPUSH", cb.queueName, jsonBytes)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBroker",
")",
"SendCeleryMessage",
"(",
"message",
"*",
"CeleryMessage",
")",
"error",
"{",
"jsonBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
":=",
"cb",
".",
"Get",
"(",
")",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"conn",
".",
"Do",
"(",
"\"",
"\"",
",",
"cb",
".",
"queueName",
",",
"jsonBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SendCeleryMessage sends CeleryMessage to redis queue | [
"SendCeleryMessage",
"sends",
"CeleryMessage",
"to",
"redis",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L49-L61 |
149,054 | gocelery/gocelery | redis_broker.go | GetCeleryMessage | func (cb *RedisCeleryBroker) GetCeleryMessage() (*CeleryMessage, error) {
conn := cb.Get()
defer conn.Close()
messageJSON, err := conn.Do("BLPOP", cb.queueName, "1")
if err != nil {
return nil, err
}
if messageJSON == nil {
return nil, fmt.Errorf("null message received from redis")
}
messageList := messageJSON.([]interface{})
if string(messageList[0].([]byte)) != "celery" {
return nil, fmt.Errorf("not a celery message: %v", messageList[0])
}
var message CeleryMessage
if err := json.Unmarshal(messageList[1].([]byte), &message); err != nil {
return nil, err
}
return &message, nil
} | go | func (cb *RedisCeleryBroker) GetCeleryMessage() (*CeleryMessage, error) {
conn := cb.Get()
defer conn.Close()
messageJSON, err := conn.Do("BLPOP", cb.queueName, "1")
if err != nil {
return nil, err
}
if messageJSON == nil {
return nil, fmt.Errorf("null message received from redis")
}
messageList := messageJSON.([]interface{})
if string(messageList[0].([]byte)) != "celery" {
return nil, fmt.Errorf("not a celery message: %v", messageList[0])
}
var message CeleryMessage
if err := json.Unmarshal(messageList[1].([]byte), &message); err != nil {
return nil, err
}
return &message, nil
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBroker",
")",
"GetCeleryMessage",
"(",
")",
"(",
"*",
"CeleryMessage",
",",
"error",
")",
"{",
"conn",
":=",
"cb",
".",
"Get",
"(",
")",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"messageJSON",
",",
"err",
":=",
"conn",
".",
"Do",
"(",
"\"",
"\"",
",",
"cb",
".",
"queueName",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"messageJSON",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"messageList",
":=",
"messageJSON",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"string",
"(",
"messageList",
"[",
"0",
"]",
".",
"(",
"[",
"]",
"byte",
")",
")",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"messageList",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"var",
"message",
"CeleryMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"messageList",
"[",
"1",
"]",
".",
"(",
"[",
"]",
"byte",
")",
",",
"&",
"message",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"message",
",",
"nil",
"\n",
"}"
] | // GetCeleryMessage retrieves celery message from redis queue | [
"GetCeleryMessage",
"retrieves",
"celery",
"message",
"from",
"redis",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L64-L83 |
149,055 | gocelery/gocelery | redis_broker.go | GetTaskMessage | func (cb *RedisCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
celeryMessage, err := cb.GetCeleryMessage()
if err != nil {
return nil, err
}
return celeryMessage.GetTaskMessage(), nil
} | go | func (cb *RedisCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
celeryMessage, err := cb.GetCeleryMessage()
if err != nil {
return nil, err
}
return celeryMessage.GetTaskMessage(), nil
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBroker",
")",
"GetTaskMessage",
"(",
")",
"(",
"*",
"TaskMessage",
",",
"error",
")",
"{",
"celeryMessage",
",",
"err",
":=",
"cb",
".",
"GetCeleryMessage",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"celeryMessage",
".",
"GetTaskMessage",
"(",
")",
",",
"nil",
"\n",
"}"
] | // GetTaskMessage retrieves task message from redis queue | [
"GetTaskMessage",
"retrieves",
"task",
"message",
"from",
"redis",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L86-L92 |
149,056 | pseudomuto/protoc-gen-doc | filters.go | NoBrFilter | func NoBrFilter(content string) string {
normalized := strings.Replace(content, "\r\n", "\n", -1)
paragraphs := multiNewlinePattern.Split(normalized, -1)
for i, p := range paragraphs {
withoutCR := strings.Replace(p, "\r", " ", -1)
withoutLF := strings.Replace(withoutCR, "\n", " ", -1)
paragraphs[i] = spacePattern.ReplaceAllString(withoutLF, " ")
}
return strings.Join(paragraphs, "\n\n")
} | go | func NoBrFilter(content string) string {
normalized := strings.Replace(content, "\r\n", "\n", -1)
paragraphs := multiNewlinePattern.Split(normalized, -1)
for i, p := range paragraphs {
withoutCR := strings.Replace(p, "\r", " ", -1)
withoutLF := strings.Replace(withoutCR, "\n", " ", -1)
paragraphs[i] = spacePattern.ReplaceAllString(withoutLF, " ")
}
return strings.Join(paragraphs, "\n\n")
} | [
"func",
"NoBrFilter",
"(",
"content",
"string",
")",
"string",
"{",
"normalized",
":=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\\r",
"\\n",
"\"",
",",
"\"",
"\\n",
"\"",
",",
"-",
"1",
")",
"\n",
"paragraphs",
":=",
"multiNewlinePattern",
".",
"Split",
"(",
"normalized",
",",
"-",
"1",
")",
"\n",
"for",
"i",
",",
"p",
":=",
"range",
"paragraphs",
"{",
"withoutCR",
":=",
"strings",
".",
"Replace",
"(",
"p",
",",
"\"",
"\\r",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"withoutLF",
":=",
"strings",
".",
"Replace",
"(",
"withoutCR",
",",
"\"",
"\\n",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"paragraphs",
"[",
"i",
"]",
"=",
"spacePattern",
".",
"ReplaceAllString",
"(",
"withoutLF",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"paragraphs",
",",
"\"",
"\\n",
"\\n",
"\"",
")",
"\n",
"}"
] | // NoBrFilter removes single CR and LF from content. | [
"NoBrFilter",
"removes",
"single",
"CR",
"and",
"LF",
"from",
"content",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/filters.go#L29-L38 |
149,057 | pseudomuto/protoc-gen-doc | template.go | NewTemplate | func NewTemplate(descs []*protokit.FileDescriptor) *Template {
files := make([]*File, 0, len(descs))
for _, f := range descs {
file := &File{
Name: f.GetName(),
Description: description(f.GetSyntaxComments().String()),
Package: f.GetPackage(),
HasEnums: len(f.Enums) > 0,
HasExtensions: len(f.Extensions) > 0,
HasMessages: len(f.Messages) > 0,
HasServices: len(f.Services) > 0,
Enums: make(orderedEnums, 0, len(f.Enums)),
Extensions: make(orderedExtensions, 0, len(f.Extensions)),
Messages: make(orderedMessages, 0, len(f.Messages)),
Services: make(orderedServices, 0, len(f.Services)),
Options: mergeOptions(extractOptions(f.GetOptions()), extensions.Transform(f.OptionExtensions)),
}
for _, e := range f.Enums {
file.Enums = append(file.Enums, parseEnum(e))
}
for _, e := range f.Extensions {
file.Extensions = append(file.Extensions, parseFileExtension(e))
}
// Recursively add nested types from messages
var addFromMessage func(*protokit.Descriptor)
addFromMessage = func(m *protokit.Descriptor) {
file.Messages = append(file.Messages, parseMessage(m))
for _, e := range m.Enums {
file.Enums = append(file.Enums, parseEnum(e))
}
for _, n := range m.Messages {
addFromMessage(n)
}
}
for _, m := range f.Messages {
addFromMessage(m)
}
for _, s := range f.Services {
file.Services = append(file.Services, parseService(s))
}
sort.Sort(file.Enums)
sort.Sort(file.Extensions)
sort.Sort(file.Messages)
sort.Sort(file.Services)
files = append(files, file)
}
return &Template{Files: files, Scalars: makeScalars()}
} | go | func NewTemplate(descs []*protokit.FileDescriptor) *Template {
files := make([]*File, 0, len(descs))
for _, f := range descs {
file := &File{
Name: f.GetName(),
Description: description(f.GetSyntaxComments().String()),
Package: f.GetPackage(),
HasEnums: len(f.Enums) > 0,
HasExtensions: len(f.Extensions) > 0,
HasMessages: len(f.Messages) > 0,
HasServices: len(f.Services) > 0,
Enums: make(orderedEnums, 0, len(f.Enums)),
Extensions: make(orderedExtensions, 0, len(f.Extensions)),
Messages: make(orderedMessages, 0, len(f.Messages)),
Services: make(orderedServices, 0, len(f.Services)),
Options: mergeOptions(extractOptions(f.GetOptions()), extensions.Transform(f.OptionExtensions)),
}
for _, e := range f.Enums {
file.Enums = append(file.Enums, parseEnum(e))
}
for _, e := range f.Extensions {
file.Extensions = append(file.Extensions, parseFileExtension(e))
}
// Recursively add nested types from messages
var addFromMessage func(*protokit.Descriptor)
addFromMessage = func(m *protokit.Descriptor) {
file.Messages = append(file.Messages, parseMessage(m))
for _, e := range m.Enums {
file.Enums = append(file.Enums, parseEnum(e))
}
for _, n := range m.Messages {
addFromMessage(n)
}
}
for _, m := range f.Messages {
addFromMessage(m)
}
for _, s := range f.Services {
file.Services = append(file.Services, parseService(s))
}
sort.Sort(file.Enums)
sort.Sort(file.Extensions)
sort.Sort(file.Messages)
sort.Sort(file.Services)
files = append(files, file)
}
return &Template{Files: files, Scalars: makeScalars()}
} | [
"func",
"NewTemplate",
"(",
"descs",
"[",
"]",
"*",
"protokit",
".",
"FileDescriptor",
")",
"*",
"Template",
"{",
"files",
":=",
"make",
"(",
"[",
"]",
"*",
"File",
",",
"0",
",",
"len",
"(",
"descs",
")",
")",
"\n\n",
"for",
"_",
",",
"f",
":=",
"range",
"descs",
"{",
"file",
":=",
"&",
"File",
"{",
"Name",
":",
"f",
".",
"GetName",
"(",
")",
",",
"Description",
":",
"description",
"(",
"f",
".",
"GetSyntaxComments",
"(",
")",
".",
"String",
"(",
")",
")",
",",
"Package",
":",
"f",
".",
"GetPackage",
"(",
")",
",",
"HasEnums",
":",
"len",
"(",
"f",
".",
"Enums",
")",
">",
"0",
",",
"HasExtensions",
":",
"len",
"(",
"f",
".",
"Extensions",
")",
">",
"0",
",",
"HasMessages",
":",
"len",
"(",
"f",
".",
"Messages",
")",
">",
"0",
",",
"HasServices",
":",
"len",
"(",
"f",
".",
"Services",
")",
">",
"0",
",",
"Enums",
":",
"make",
"(",
"orderedEnums",
",",
"0",
",",
"len",
"(",
"f",
".",
"Enums",
")",
")",
",",
"Extensions",
":",
"make",
"(",
"orderedExtensions",
",",
"0",
",",
"len",
"(",
"f",
".",
"Extensions",
")",
")",
",",
"Messages",
":",
"make",
"(",
"orderedMessages",
",",
"0",
",",
"len",
"(",
"f",
".",
"Messages",
")",
")",
",",
"Services",
":",
"make",
"(",
"orderedServices",
",",
"0",
",",
"len",
"(",
"f",
".",
"Services",
")",
")",
",",
"Options",
":",
"mergeOptions",
"(",
"extractOptions",
"(",
"f",
".",
"GetOptions",
"(",
")",
")",
",",
"extensions",
".",
"Transform",
"(",
"f",
".",
"OptionExtensions",
")",
")",
",",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"f",
".",
"Enums",
"{",
"file",
".",
"Enums",
"=",
"append",
"(",
"file",
".",
"Enums",
",",
"parseEnum",
"(",
"e",
")",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"f",
".",
"Extensions",
"{",
"file",
".",
"Extensions",
"=",
"append",
"(",
"file",
".",
"Extensions",
",",
"parseFileExtension",
"(",
"e",
")",
")",
"\n",
"}",
"\n\n",
"// Recursively add nested types from messages",
"var",
"addFromMessage",
"func",
"(",
"*",
"protokit",
".",
"Descriptor",
")",
"\n",
"addFromMessage",
"=",
"func",
"(",
"m",
"*",
"protokit",
".",
"Descriptor",
")",
"{",
"file",
".",
"Messages",
"=",
"append",
"(",
"file",
".",
"Messages",
",",
"parseMessage",
"(",
"m",
")",
")",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"m",
".",
"Enums",
"{",
"file",
".",
"Enums",
"=",
"append",
"(",
"file",
".",
"Enums",
",",
"parseEnum",
"(",
"e",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"m",
".",
"Messages",
"{",
"addFromMessage",
"(",
"n",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"f",
".",
"Messages",
"{",
"addFromMessage",
"(",
"m",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"f",
".",
"Services",
"{",
"file",
".",
"Services",
"=",
"append",
"(",
"file",
".",
"Services",
",",
"parseService",
"(",
"s",
")",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Sort",
"(",
"file",
".",
"Enums",
")",
"\n",
"sort",
".",
"Sort",
"(",
"file",
".",
"Extensions",
")",
"\n",
"sort",
".",
"Sort",
"(",
"file",
".",
"Messages",
")",
"\n",
"sort",
".",
"Sort",
"(",
"file",
".",
"Services",
")",
"\n\n",
"files",
"=",
"append",
"(",
"files",
",",
"file",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"Template",
"{",
"Files",
":",
"files",
",",
"Scalars",
":",
"makeScalars",
"(",
")",
"}",
"\n",
"}"
] | // NewTemplate creates a Template object from a set of descriptors. | [
"NewTemplate",
"creates",
"a",
"Template",
"object",
"from",
"a",
"set",
"of",
"descriptors",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L24-L79 |
149,058 | pseudomuto/protoc-gen-doc | template.go | FieldOptions | func (m Message) FieldOptions() []string {
optionSet := make(map[string]struct{})
for _, field := range m.Fields {
for option := range field.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
options = append(options, option)
}
sort.Strings(options)
return options
} | go | func (m Message) FieldOptions() []string {
optionSet := make(map[string]struct{})
for _, field := range m.Fields {
for option := range field.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
options = append(options, option)
}
sort.Strings(options)
return options
} | [
"func",
"(",
"m",
"Message",
")",
"FieldOptions",
"(",
")",
"[",
"]",
"string",
"{",
"optionSet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"field",
":=",
"range",
"m",
".",
"Fields",
"{",
"for",
"option",
":=",
"range",
"field",
".",
"Options",
"{",
"optionSet",
"[",
"option",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"optionSet",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"options",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"optionSet",
")",
")",
"\n",
"for",
"option",
":=",
"range",
"optionSet",
"{",
"options",
"=",
"append",
"(",
"options",
",",
"option",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"options",
")",
"\n",
"return",
"options",
"\n",
"}"
] | // FieldOptions returns all options that are set on the fields in this message. | [
"FieldOptions",
"returns",
"all",
"options",
"that",
"are",
"set",
"on",
"the",
"fields",
"in",
"this",
"message",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L190-L206 |
149,059 | pseudomuto/protoc-gen-doc | template.go | FieldsWithOption | func (m Message) FieldsWithOption(optionName string) []*MessageField {
fields := make([]*MessageField, 0, len(m.Fields))
for _, field := range m.Fields {
if _, ok := field.Options[optionName]; ok {
fields = append(fields, field)
}
}
if len(fields) > 0 {
return fields
}
return nil
} | go | func (m Message) FieldsWithOption(optionName string) []*MessageField {
fields := make([]*MessageField, 0, len(m.Fields))
for _, field := range m.Fields {
if _, ok := field.Options[optionName]; ok {
fields = append(fields, field)
}
}
if len(fields) > 0 {
return fields
}
return nil
} | [
"func",
"(",
"m",
"Message",
")",
"FieldsWithOption",
"(",
"optionName",
"string",
")",
"[",
"]",
"*",
"MessageField",
"{",
"fields",
":=",
"make",
"(",
"[",
"]",
"*",
"MessageField",
",",
"0",
",",
"len",
"(",
"m",
".",
"Fields",
")",
")",
"\n",
"for",
"_",
",",
"field",
":=",
"range",
"m",
".",
"Fields",
"{",
"if",
"_",
",",
"ok",
":=",
"field",
".",
"Options",
"[",
"optionName",
"]",
";",
"ok",
"{",
"fields",
"=",
"append",
"(",
"fields",
",",
"field",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"fields",
")",
">",
"0",
"{",
"return",
"fields",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // FieldsWithOption returns all fields that have the given option set.
// If no single value has the option set, this returns nil. | [
"FieldsWithOption",
"returns",
"all",
"fields",
"that",
"have",
"the",
"given",
"option",
"set",
".",
"If",
"no",
"single",
"value",
"has",
"the",
"option",
"set",
"this",
"returns",
"nil",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L210-L221 |
149,060 | pseudomuto/protoc-gen-doc | template.go | ValueOptions | func (e Enum) ValueOptions() []string {
optionSet := make(map[string]struct{})
for _, value := range e.Values {
for option := range value.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
options = append(options, option)
}
sort.Strings(options)
return options
} | go | func (e Enum) ValueOptions() []string {
optionSet := make(map[string]struct{})
for _, value := range e.Values {
for option := range value.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
options = append(options, option)
}
sort.Strings(options)
return options
} | [
"func",
"(",
"e",
"Enum",
")",
"ValueOptions",
"(",
")",
"[",
"]",
"string",
"{",
"optionSet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"e",
".",
"Values",
"{",
"for",
"option",
":=",
"range",
"value",
".",
"Options",
"{",
"optionSet",
"[",
"option",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"optionSet",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"options",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"optionSet",
")",
")",
"\n",
"for",
"option",
":=",
"range",
"optionSet",
"{",
"options",
"=",
"append",
"(",
"options",
",",
"option",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"options",
")",
"\n",
"return",
"options",
"\n",
"}"
] | // ValueOptions returns all options that are set on the values in this enum. | [
"ValueOptions",
"returns",
"all",
"options",
"that",
"are",
"set",
"on",
"the",
"values",
"in",
"this",
"enum",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L267-L283 |
149,061 | pseudomuto/protoc-gen-doc | template.go | ValuesWithOption | func (e Enum) ValuesWithOption(optionName string) []*EnumValue {
values := make([]*EnumValue, 0, len(e.Values))
for _, value := range e.Values {
if _, ok := value.Options[optionName]; ok {
values = append(values, value)
}
}
if len(values) > 0 {
return values
}
return nil
} | go | func (e Enum) ValuesWithOption(optionName string) []*EnumValue {
values := make([]*EnumValue, 0, len(e.Values))
for _, value := range e.Values {
if _, ok := value.Options[optionName]; ok {
values = append(values, value)
}
}
if len(values) > 0 {
return values
}
return nil
} | [
"func",
"(",
"e",
"Enum",
")",
"ValuesWithOption",
"(",
"optionName",
"string",
")",
"[",
"]",
"*",
"EnumValue",
"{",
"values",
":=",
"make",
"(",
"[",
"]",
"*",
"EnumValue",
",",
"0",
",",
"len",
"(",
"e",
".",
"Values",
")",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"e",
".",
"Values",
"{",
"if",
"_",
",",
"ok",
":=",
"value",
".",
"Options",
"[",
"optionName",
"]",
";",
"ok",
"{",
"values",
"=",
"append",
"(",
"values",
",",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"values",
")",
">",
"0",
"{",
"return",
"values",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ValuesWithOption returns all values that have the given option set.
// If no single value has the option set, this returns nil. | [
"ValuesWithOption",
"returns",
"all",
"values",
"that",
"have",
"the",
"given",
"option",
"set",
".",
"If",
"no",
"single",
"value",
"has",
"the",
"option",
"set",
"this",
"returns",
"nil",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L287-L298 |
149,062 | pseudomuto/protoc-gen-doc | template.go | MethodOptions | func (s Service) MethodOptions() []string {
optionSet := make(map[string]struct{})
for _, method := range s.Methods {
for option := range method.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
options = append(options, option)
}
sort.Strings(options)
return options
} | go | func (s Service) MethodOptions() []string {
optionSet := make(map[string]struct{})
for _, method := range s.Methods {
for option := range method.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
options = append(options, option)
}
sort.Strings(options)
return options
} | [
"func",
"(",
"s",
"Service",
")",
"MethodOptions",
"(",
")",
"[",
"]",
"string",
"{",
"optionSet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"method",
":=",
"range",
"s",
".",
"Methods",
"{",
"for",
"option",
":=",
"range",
"method",
".",
"Options",
"{",
"optionSet",
"[",
"option",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"optionSet",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"options",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"optionSet",
")",
")",
"\n",
"for",
"option",
":=",
"range",
"optionSet",
"{",
"options",
"=",
"append",
"(",
"options",
",",
"option",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"options",
")",
"\n",
"return",
"options",
"\n",
"}"
] | // MethodOptions returns all options that are set on the methods in this service. | [
"MethodOptions",
"returns",
"all",
"options",
"that",
"are",
"set",
"on",
"the",
"methods",
"in",
"this",
"service",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L327-L343 |
149,063 | pseudomuto/protoc-gen-doc | template.go | MethodsWithOption | func (s Service) MethodsWithOption(optionName string) []*ServiceMethod {
methods := make([]*ServiceMethod, 0, len(s.Methods))
for _, method := range s.Methods {
if _, ok := method.Options[optionName]; ok {
methods = append(methods, method)
}
}
if len(methods) > 0 {
return methods
}
return nil
} | go | func (s Service) MethodsWithOption(optionName string) []*ServiceMethod {
methods := make([]*ServiceMethod, 0, len(s.Methods))
for _, method := range s.Methods {
if _, ok := method.Options[optionName]; ok {
methods = append(methods, method)
}
}
if len(methods) > 0 {
return methods
}
return nil
} | [
"func",
"(",
"s",
"Service",
")",
"MethodsWithOption",
"(",
"optionName",
"string",
")",
"[",
"]",
"*",
"ServiceMethod",
"{",
"methods",
":=",
"make",
"(",
"[",
"]",
"*",
"ServiceMethod",
",",
"0",
",",
"len",
"(",
"s",
".",
"Methods",
")",
")",
"\n",
"for",
"_",
",",
"method",
":=",
"range",
"s",
".",
"Methods",
"{",
"if",
"_",
",",
"ok",
":=",
"method",
".",
"Options",
"[",
"optionName",
"]",
";",
"ok",
"{",
"methods",
"=",
"append",
"(",
"methods",
",",
"method",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"methods",
")",
">",
"0",
"{",
"return",
"methods",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // MethodsWithOption returns all methods that have the given option set.
// If no single method has the option set, this returns nil. | [
"MethodsWithOption",
"returns",
"all",
"methods",
"that",
"have",
"the",
"given",
"option",
"set",
".",
"If",
"no",
"single",
"method",
"has",
"the",
"option",
"set",
"this",
"returns",
"nil",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L347-L358 |
149,064 | pseudomuto/protoc-gen-doc | plugin.go | Generate | func (p *Plugin) Generate(r *plugin_go.CodeGeneratorRequest) (*plugin_go.CodeGeneratorResponse, error) {
options, err := ParseOptions(r)
if err != nil {
return nil, err
}
result := excludeUnwantedProtos(protokit.ParseCodeGenRequest(r), options.ExcludePatterns)
template := NewTemplate(result)
customTemplate := ""
if options.TemplateFile != "" {
data, err := ioutil.ReadFile(options.TemplateFile)
if err != nil {
return nil, err
}
customTemplate = string(data)
}
output, err := RenderTemplate(options.Type, template, customTemplate)
if err != nil {
return nil, err
}
resp := new(plugin_go.CodeGeneratorResponse)
resp.File = append(resp.File, &plugin_go.CodeGeneratorResponse_File{
Name: proto.String(options.OutputFile),
Content: proto.String(string(output)),
})
return resp, nil
} | go | func (p *Plugin) Generate(r *plugin_go.CodeGeneratorRequest) (*plugin_go.CodeGeneratorResponse, error) {
options, err := ParseOptions(r)
if err != nil {
return nil, err
}
result := excludeUnwantedProtos(protokit.ParseCodeGenRequest(r), options.ExcludePatterns)
template := NewTemplate(result)
customTemplate := ""
if options.TemplateFile != "" {
data, err := ioutil.ReadFile(options.TemplateFile)
if err != nil {
return nil, err
}
customTemplate = string(data)
}
output, err := RenderTemplate(options.Type, template, customTemplate)
if err != nil {
return nil, err
}
resp := new(plugin_go.CodeGeneratorResponse)
resp.File = append(resp.File, &plugin_go.CodeGeneratorResponse_File{
Name: proto.String(options.OutputFile),
Content: proto.String(string(output)),
})
return resp, nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Generate",
"(",
"r",
"*",
"plugin_go",
".",
"CodeGeneratorRequest",
")",
"(",
"*",
"plugin_go",
".",
"CodeGeneratorResponse",
",",
"error",
")",
"{",
"options",
",",
"err",
":=",
"ParseOptions",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"result",
":=",
"excludeUnwantedProtos",
"(",
"protokit",
".",
"ParseCodeGenRequest",
"(",
"r",
")",
",",
"options",
".",
"ExcludePatterns",
")",
"\n",
"template",
":=",
"NewTemplate",
"(",
"result",
")",
"\n\n",
"customTemplate",
":=",
"\"",
"\"",
"\n\n",
"if",
"options",
".",
"TemplateFile",
"!=",
"\"",
"\"",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"options",
".",
"TemplateFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"customTemplate",
"=",
"string",
"(",
"data",
")",
"\n",
"}",
"\n\n",
"output",
",",
"err",
":=",
"RenderTemplate",
"(",
"options",
".",
"Type",
",",
"template",
",",
"customTemplate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
":=",
"new",
"(",
"plugin_go",
".",
"CodeGeneratorResponse",
")",
"\n",
"resp",
".",
"File",
"=",
"append",
"(",
"resp",
".",
"File",
",",
"&",
"plugin_go",
".",
"CodeGeneratorResponse_File",
"{",
"Name",
":",
"proto",
".",
"String",
"(",
"options",
".",
"OutputFile",
")",
",",
"Content",
":",
"proto",
".",
"String",
"(",
"string",
"(",
"output",
")",
")",
",",
"}",
")",
"\n\n",
"return",
"resp",
",",
"nil",
"\n",
"}"
] | // Generate compiles the documentation and generates the CodeGeneratorResponse to send back to protoc. It does this
// by rendering a template based on the options parsed from the CodeGeneratorRequest. | [
"Generate",
"compiles",
"the",
"documentation",
"and",
"generates",
"the",
"CodeGeneratorResponse",
"to",
"send",
"back",
"to",
"protoc",
".",
"It",
"does",
"this",
"by",
"rendering",
"a",
"template",
"based",
"on",
"the",
"options",
"parsed",
"from",
"the",
"CodeGeneratorRequest",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/plugin.go#L29-L61 |
149,065 | pseudomuto/protoc-gen-doc | extensions/extensions.go | Transform | func Transform(extensions map[string]interface{}) map[string]interface{} {
if extensions == nil {
return nil
}
out := make(map[string]interface{}, len(extensions))
for name, payload := range extensions {
transform, ok := transformers[name]
if !ok {
// No transformer registered, skip.
continue
}
transformedPayload := transform(payload)
if transformedPayload == nil {
// Transformer returned nothing, skip.
continue
}
out[name] = transformedPayload
}
return out
} | go | func Transform(extensions map[string]interface{}) map[string]interface{} {
if extensions == nil {
return nil
}
out := make(map[string]interface{}, len(extensions))
for name, payload := range extensions {
transform, ok := transformers[name]
if !ok {
// No transformer registered, skip.
continue
}
transformedPayload := transform(payload)
if transformedPayload == nil {
// Transformer returned nothing, skip.
continue
}
out[name] = transformedPayload
}
return out
} | [
"func",
"Transform",
"(",
"extensions",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"if",
"extensions",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"extensions",
")",
")",
"\n",
"for",
"name",
",",
"payload",
":=",
"range",
"extensions",
"{",
"transform",
",",
"ok",
":=",
"transformers",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"// No transformer registered, skip.",
"continue",
"\n",
"}",
"\n",
"transformedPayload",
":=",
"transform",
"(",
"payload",
")",
"\n",
"if",
"transformedPayload",
"==",
"nil",
"{",
"// Transformer returned nothing, skip.",
"continue",
"\n",
"}",
"\n",
"out",
"[",
"name",
"]",
"=",
"transformedPayload",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // Transform the extensions using the registered transformers. | [
"Transform",
"the",
"extensions",
"using",
"the",
"registered",
"transformers",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/extensions/extensions.go#L16-L35 |
149,066 | pseudomuto/protoc-gen-doc | extensions/lyft_validate/lyft_validate.go | Rules | func (v ValidateExtension) Rules() []ValidateRule {
if v.FieldRules == nil {
return nil
}
if v.rules == nil {
v.rules = flattenRules("", reflect.ValueOf(v.FieldRules))
}
return v.rules
} | go | func (v ValidateExtension) Rules() []ValidateRule {
if v.FieldRules == nil {
return nil
}
if v.rules == nil {
v.rules = flattenRules("", reflect.ValueOf(v.FieldRules))
}
return v.rules
} | [
"func",
"(",
"v",
"ValidateExtension",
")",
"Rules",
"(",
")",
"[",
"]",
"ValidateRule",
"{",
"if",
"v",
".",
"FieldRules",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"rules",
"==",
"nil",
"{",
"v",
".",
"rules",
"=",
"flattenRules",
"(",
"\"",
"\"",
",",
"reflect",
".",
"ValueOf",
"(",
"v",
".",
"FieldRules",
")",
")",
"\n",
"}",
"\n",
"return",
"v",
".",
"rules",
"\n",
"}"
] | // Rules returns the set of rules for this extension. | [
"Rules",
"returns",
"the",
"set",
"of",
"rules",
"for",
"this",
"extension",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/extensions/lyft_validate/lyft_validate.go#L28-L36 |
149,067 | pseudomuto/protoc-gen-doc | cmd/protoc-gen-doc/flags.go | PrintHelp | func (f *Flags) PrintHelp() {
fmt.Fprintf(f.writer, "Usage of %s:\n", f.appName)
fmt.Fprintf(f.writer, "%s\n", helpMessage)
fmt.Fprintf(f.writer, "FLAGS\n")
f.flagSet.PrintDefaults()
} | go | func (f *Flags) PrintHelp() {
fmt.Fprintf(f.writer, "Usage of %s:\n", f.appName)
fmt.Fprintf(f.writer, "%s\n", helpMessage)
fmt.Fprintf(f.writer, "FLAGS\n")
f.flagSet.PrintDefaults()
} | [
"func",
"(",
"f",
"*",
"Flags",
")",
"PrintHelp",
"(",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\"",
",",
"f",
".",
"appName",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\"",
",",
"helpMessage",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"f",
".",
"flagSet",
".",
"PrintDefaults",
"(",
")",
"\n",
"}"
] | // PrintHelp prints the usage string including all flags to the `io.Writer` that was supplied to the `Flags` object. | [
"PrintHelp",
"prints",
"the",
"usage",
"string",
"including",
"all",
"flags",
"to",
"the",
"io",
".",
"Writer",
"that",
"was",
"supplied",
"to",
"the",
"Flags",
"object",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/cmd/protoc-gen-doc/flags.go#L68-L73 |
149,068 | pseudomuto/protoc-gen-doc | cmd/protoc-gen-doc/flags.go | PrintVersion | func (f *Flags) PrintVersion() {
fmt.Fprintf(f.writer, "%s version %s\n", f.appName, Version())
} | go | func (f *Flags) PrintVersion() {
fmt.Fprintf(f.writer, "%s version %s\n", f.appName, Version())
} | [
"func",
"(",
"f",
"*",
"Flags",
")",
"PrintVersion",
"(",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\"",
",",
"f",
".",
"appName",
",",
"Version",
"(",
")",
")",
"\n",
"}"
] | // PrintVersion prints the version string to the `io.Writer` that was supplied to the `Flags` object. | [
"PrintVersion",
"prints",
"the",
"version",
"string",
"to",
"the",
"io",
".",
"Writer",
"that",
"was",
"supplied",
"to",
"the",
"Flags",
"object",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/cmd/protoc-gen-doc/flags.go#L76-L78 |
149,069 | pseudomuto/protoc-gen-doc | extensions/validator_field/validator_field.go | Rules | func (v ValidatorExtension) Rules() []ValidatorRule {
if v.FieldValidator == nil {
return nil
}
if v.rules != nil {
return v.rules
}
vv := reflect.ValueOf(*v.FieldValidator)
vt := vv.Type()
for i := 0; i < vt.NumField(); i++ {
tag, ok := vt.Field(i).Tag.Lookup("protobuf")
if !ok {
continue
}
for _, opt := range strings.Split(tag, ",") {
if strings.HasPrefix(opt, "name=") {
tag = strings.TrimPrefix(opt, "name=")
break
}
}
value := vv.Field(i)
if value.IsNil() {
continue
}
value = reflect.Indirect(value)
v.rules = append(v.rules, ValidatorRule{Name: tag, Value: value.Interface()})
}
return v.rules
} | go | func (v ValidatorExtension) Rules() []ValidatorRule {
if v.FieldValidator == nil {
return nil
}
if v.rules != nil {
return v.rules
}
vv := reflect.ValueOf(*v.FieldValidator)
vt := vv.Type()
for i := 0; i < vt.NumField(); i++ {
tag, ok := vt.Field(i).Tag.Lookup("protobuf")
if !ok {
continue
}
for _, opt := range strings.Split(tag, ",") {
if strings.HasPrefix(opt, "name=") {
tag = strings.TrimPrefix(opt, "name=")
break
}
}
value := vv.Field(i)
if value.IsNil() {
continue
}
value = reflect.Indirect(value)
v.rules = append(v.rules, ValidatorRule{Name: tag, Value: value.Interface()})
}
return v.rules
} | [
"func",
"(",
"v",
"ValidatorExtension",
")",
"Rules",
"(",
")",
"[",
"]",
"ValidatorRule",
"{",
"if",
"v",
".",
"FieldValidator",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"rules",
"!=",
"nil",
"{",
"return",
"v",
".",
"rules",
"\n",
"}",
"\n",
"vv",
":=",
"reflect",
".",
"ValueOf",
"(",
"*",
"v",
".",
"FieldValidator",
")",
"\n",
"vt",
":=",
"vv",
".",
"Type",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"vt",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"tag",
",",
"ok",
":=",
"vt",
".",
"Field",
"(",
"i",
")",
".",
"Tag",
".",
"Lookup",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"strings",
".",
"Split",
"(",
"tag",
",",
"\"",
"\"",
")",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"opt",
",",
"\"",
"\"",
")",
"{",
"tag",
"=",
"strings",
".",
"TrimPrefix",
"(",
"opt",
",",
"\"",
"\"",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"value",
":=",
"vv",
".",
"Field",
"(",
"i",
")",
"\n",
"if",
"value",
".",
"IsNil",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"value",
"=",
"reflect",
".",
"Indirect",
"(",
"value",
")",
"\n",
"v",
".",
"rules",
"=",
"append",
"(",
"v",
".",
"rules",
",",
"ValidatorRule",
"{",
"Name",
":",
"tag",
",",
"Value",
":",
"value",
".",
"Interface",
"(",
")",
"}",
")",
"\n",
"}",
"\n",
"return",
"v",
".",
"rules",
"\n",
"}"
] | // Rules returns all active rules | [
"Rules",
"returns",
"all",
"active",
"rules"
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/extensions/validator_field/validator_field.go#L45-L73 |
149,070 | pseudomuto/protoc-gen-doc | cmd/protoc-gen-doc/main.go | HandleFlags | func HandleFlags(f *Flags) bool {
if !f.HasMatch() {
return false
}
if f.ShowHelp() {
f.PrintHelp()
}
if f.ShowVersion() {
f.PrintVersion()
}
return true
} | go | func HandleFlags(f *Flags) bool {
if !f.HasMatch() {
return false
}
if f.ShowHelp() {
f.PrintHelp()
}
if f.ShowVersion() {
f.PrintVersion()
}
return true
} | [
"func",
"HandleFlags",
"(",
"f",
"*",
"Flags",
")",
"bool",
"{",
"if",
"!",
"f",
".",
"HasMatch",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"ShowHelp",
"(",
")",
"{",
"f",
".",
"PrintHelp",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"ShowVersion",
"(",
")",
"{",
"f",
".",
"PrintVersion",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // HandleFlags checks if there's a match and returns true if it was "handled" | [
"HandleFlags",
"checks",
"if",
"there",
"s",
"a",
"match",
"and",
"returns",
"true",
"if",
"it",
"was",
"handled"
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/cmd/protoc-gen-doc/main.go#L39-L53 |
149,071 | pressly/sup | ssh.go | initAuthMethod | func initAuthMethod() {
var signers []ssh.Signer
// If there's a running SSH Agent, try to use its Private keys.
sock, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
if err == nil {
agent := agent.NewClient(sock)
signers, _ = agent.Signers()
}
// Try to read user's SSH private keys form the standard paths.
files, _ := filepath.Glob(os.Getenv("HOME") + "/.ssh/id_*")
for _, file := range files {
if strings.HasSuffix(file, ".pub") {
continue // Skip public keys.
}
data, err := ioutil.ReadFile(file)
if err != nil {
continue
}
signer, err := ssh.ParsePrivateKey(data)
if err != nil {
continue
}
signers = append(signers, signer)
}
authMethod = ssh.PublicKeys(signers...)
} | go | func initAuthMethod() {
var signers []ssh.Signer
// If there's a running SSH Agent, try to use its Private keys.
sock, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
if err == nil {
agent := agent.NewClient(sock)
signers, _ = agent.Signers()
}
// Try to read user's SSH private keys form the standard paths.
files, _ := filepath.Glob(os.Getenv("HOME") + "/.ssh/id_*")
for _, file := range files {
if strings.HasSuffix(file, ".pub") {
continue // Skip public keys.
}
data, err := ioutil.ReadFile(file)
if err != nil {
continue
}
signer, err := ssh.ParsePrivateKey(data)
if err != nil {
continue
}
signers = append(signers, signer)
}
authMethod = ssh.PublicKeys(signers...)
} | [
"func",
"initAuthMethod",
"(",
")",
"{",
"var",
"signers",
"[",
"]",
"ssh",
".",
"Signer",
"\n\n",
"// If there's a running SSH Agent, try to use its Private keys.",
"sock",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"agent",
":=",
"agent",
".",
"NewClient",
"(",
"sock",
")",
"\n",
"signers",
",",
"_",
"=",
"agent",
".",
"Signers",
"(",
")",
"\n",
"}",
"\n\n",
"// Try to read user's SSH private keys form the standard paths.",
"files",
",",
"_",
":=",
"filepath",
".",
"Glob",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"+",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"file",
",",
"\"",
"\"",
")",
"{",
"continue",
"// Skip public keys.",
"\n",
"}",
"\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"signer",
",",
"err",
":=",
"ssh",
".",
"ParsePrivateKey",
"(",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"signers",
"=",
"append",
"(",
"signers",
",",
"signer",
")",
"\n\n",
"}",
"\n",
"authMethod",
"=",
"ssh",
".",
"PublicKeys",
"(",
"signers",
"...",
")",
"\n",
"}"
] | // initAuthMethod initiates SSH authentication method. | [
"initAuthMethod",
"initiates",
"SSH",
"authentication",
"method",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L83-L111 |
149,072 | pressly/sup | ssh.go | Run | func (c *SSHClient) Run(task *Task) error {
if c.running {
return fmt.Errorf("Session already running")
}
if c.sessOpened {
return fmt.Errorf("Session already connected")
}
sess, err := c.conn.NewSession()
if err != nil {
return err
}
c.remoteStdin, err = sess.StdinPipe()
if err != nil {
return err
}
c.remoteStdout, err = sess.StdoutPipe()
if err != nil {
return err
}
c.remoteStderr, err = sess.StderrPipe()
if err != nil {
return err
}
if task.TTY {
// Set up terminal modes
modes := ssh.TerminalModes{
ssh.ECHO: 0, // disable echoing
ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
}
// Request pseudo terminal
if err := sess.RequestPty("xterm", 80, 40, modes); err != nil {
return ErrTask{task, fmt.Sprintf("request for pseudo terminal failed: %s", err)}
}
}
// Start the remote command.
if err := sess.Start(c.env + task.Run); err != nil {
return ErrTask{task, err.Error()}
}
c.sess = sess
c.sessOpened = true
c.running = true
return nil
} | go | func (c *SSHClient) Run(task *Task) error {
if c.running {
return fmt.Errorf("Session already running")
}
if c.sessOpened {
return fmt.Errorf("Session already connected")
}
sess, err := c.conn.NewSession()
if err != nil {
return err
}
c.remoteStdin, err = sess.StdinPipe()
if err != nil {
return err
}
c.remoteStdout, err = sess.StdoutPipe()
if err != nil {
return err
}
c.remoteStderr, err = sess.StderrPipe()
if err != nil {
return err
}
if task.TTY {
// Set up terminal modes
modes := ssh.TerminalModes{
ssh.ECHO: 0, // disable echoing
ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
}
// Request pseudo terminal
if err := sess.RequestPty("xterm", 80, 40, modes); err != nil {
return ErrTask{task, fmt.Sprintf("request for pseudo terminal failed: %s", err)}
}
}
// Start the remote command.
if err := sess.Start(c.env + task.Run); err != nil {
return ErrTask{task, err.Error()}
}
c.sess = sess
c.sessOpened = true
c.running = true
return nil
} | [
"func",
"(",
"c",
"*",
"SSHClient",
")",
"Run",
"(",
"task",
"*",
"Task",
")",
"error",
"{",
"if",
"c",
".",
"running",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"sessOpened",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sess",
",",
"err",
":=",
"c",
".",
"conn",
".",
"NewSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"remoteStdin",
",",
"err",
"=",
"sess",
".",
"StdinPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"remoteStdout",
",",
"err",
"=",
"sess",
".",
"StdoutPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"remoteStderr",
",",
"err",
"=",
"sess",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"task",
".",
"TTY",
"{",
"// Set up terminal modes",
"modes",
":=",
"ssh",
".",
"TerminalModes",
"{",
"ssh",
".",
"ECHO",
":",
"0",
",",
"// disable echoing",
"ssh",
".",
"TTY_OP_ISPEED",
":",
"14400",
",",
"// input speed = 14.4kbaud",
"ssh",
".",
"TTY_OP_OSPEED",
":",
"14400",
",",
"// output speed = 14.4kbaud",
"}",
"\n",
"// Request pseudo terminal",
"if",
"err",
":=",
"sess",
".",
"RequestPty",
"(",
"\"",
"\"",
",",
"80",
",",
"40",
",",
"modes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ErrTask",
"{",
"task",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Start the remote command.",
"if",
"err",
":=",
"sess",
".",
"Start",
"(",
"c",
".",
"env",
"+",
"task",
".",
"Run",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ErrTask",
"{",
"task",
",",
"err",
".",
"Error",
"(",
")",
"}",
"\n",
"}",
"\n\n",
"c",
".",
"sess",
"=",
"sess",
"\n",
"c",
".",
"sessOpened",
"=",
"true",
"\n",
"c",
".",
"running",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] | // Run runs the task.Run command remotely on c.host. | [
"Run",
"runs",
"the",
"task",
".",
"Run",
"command",
"remotely",
"on",
"c",
".",
"host",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L154-L204 |
149,073 | pressly/sup | ssh.go | Wait | func (c *SSHClient) Wait() error {
if !c.running {
return fmt.Errorf("Trying to wait on stopped session")
}
err := c.sess.Wait()
c.sess.Close()
c.running = false
c.sessOpened = false
return err
} | go | func (c *SSHClient) Wait() error {
if !c.running {
return fmt.Errorf("Trying to wait on stopped session")
}
err := c.sess.Wait()
c.sess.Close()
c.running = false
c.sessOpened = false
return err
} | [
"func",
"(",
"c",
"*",
"SSHClient",
")",
"Wait",
"(",
")",
"error",
"{",
"if",
"!",
"c",
".",
"running",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"c",
".",
"sess",
".",
"Wait",
"(",
")",
"\n",
"c",
".",
"sess",
".",
"Close",
"(",
")",
"\n",
"c",
".",
"running",
"=",
"false",
"\n",
"c",
".",
"sessOpened",
"=",
"false",
"\n\n",
"return",
"err",
"\n",
"}"
] | // Wait waits until the remote command finishes and exits.
// It closes the SSH session. | [
"Wait",
"waits",
"until",
"the",
"remote",
"command",
"finishes",
"and",
"exits",
".",
"It",
"closes",
"the",
"SSH",
"session",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L208-L219 |
149,074 | pressly/sup | ssh.go | DialThrough | func (sc *SSHClient) DialThrough(net, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
conn, err := sc.conn.Dial(net, addr)
if err != nil {
return nil, err
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return ssh.NewClient(c, chans, reqs), nil
} | go | func (sc *SSHClient) DialThrough(net, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
conn, err := sc.conn.Dial(net, addr)
if err != nil {
return nil, err
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return ssh.NewClient(c, chans, reqs), nil
} | [
"func",
"(",
"sc",
"*",
"SSHClient",
")",
"DialThrough",
"(",
"net",
",",
"addr",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"Client",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"sc",
".",
"conn",
".",
"Dial",
"(",
"net",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"c",
",",
"chans",
",",
"reqs",
",",
"err",
":=",
"ssh",
".",
"NewClientConn",
"(",
"conn",
",",
"addr",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"ssh",
".",
"NewClient",
"(",
"c",
",",
"chans",
",",
"reqs",
")",
",",
"nil",
"\n\n",
"}"
] | // DialThrough will create a new connection from the ssh server sc is connected to. DialThrough is an SSHDialer. | [
"DialThrough",
"will",
"create",
"a",
"new",
"connection",
"from",
"the",
"ssh",
"server",
"sc",
"is",
"connected",
"to",
".",
"DialThrough",
"is",
"an",
"SSHDialer",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L222-L233 |
149,075 | pressly/sup | ssh.go | Close | func (c *SSHClient) Close() error {
if c.sessOpened {
c.sess.Close()
c.sessOpened = false
}
if !c.connOpened {
return fmt.Errorf("Trying to close the already closed connection")
}
err := c.conn.Close()
c.connOpened = false
c.running = false
return err
} | go | func (c *SSHClient) Close() error {
if c.sessOpened {
c.sess.Close()
c.sessOpened = false
}
if !c.connOpened {
return fmt.Errorf("Trying to close the already closed connection")
}
err := c.conn.Close()
c.connOpened = false
c.running = false
return err
} | [
"func",
"(",
"c",
"*",
"SSHClient",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"sessOpened",
"{",
"c",
".",
"sess",
".",
"Close",
"(",
")",
"\n",
"c",
".",
"sessOpened",
"=",
"false",
"\n",
"}",
"\n",
"if",
"!",
"c",
".",
"connOpened",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"c",
".",
"connOpened",
"=",
"false",
"\n",
"c",
".",
"running",
"=",
"false",
"\n\n",
"return",
"err",
"\n",
"}"
] | // Close closes the underlying SSH connection and session. | [
"Close",
"closes",
"the",
"underlying",
"SSH",
"connection",
"and",
"session",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L236-L250 |
149,076 | pressly/sup | supfile.go | Set | func (e *EnvList) Set(key, value string) {
for i, v := range *e {
if v.Key == key {
(*e)[i].Value = value
return
}
}
*e = append(*e, &EnvVar{
Key: key,
Value: value,
})
} | go | func (e *EnvList) Set(key, value string) {
for i, v := range *e {
if v.Key == key {
(*e)[i].Value = value
return
}
}
*e = append(*e, &EnvVar{
Key: key,
Value: value,
})
} | [
"func",
"(",
"e",
"*",
"EnvList",
")",
"Set",
"(",
"key",
",",
"value",
"string",
")",
"{",
"for",
"i",
",",
"v",
":=",
"range",
"*",
"e",
"{",
"if",
"v",
".",
"Key",
"==",
"key",
"{",
"(",
"*",
"e",
")",
"[",
"i",
"]",
".",
"Value",
"=",
"value",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"*",
"e",
"=",
"append",
"(",
"*",
"e",
",",
"&",
"EnvVar",
"{",
"Key",
":",
"key",
",",
"Value",
":",
"value",
",",
"}",
")",
"\n",
"}"
] | // Set key to be equal value in this list. | [
"Set",
"key",
"to",
"be",
"equal",
"value",
"in",
"this",
"list",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/supfile.go#L199-L211 |
149,077 | pressly/sup | supfile.go | NewSupfile | func NewSupfile(data []byte) (*Supfile, error) {
var conf Supfile
if err := yaml.Unmarshal(data, &conf); err != nil {
return nil, err
}
// API backward compatibility. Will be deprecated in v1.0.
switch conf.Version {
case "":
conf.Version = "0.1"
fallthrough
case "0.1":
for _, cmd := range conf.Commands.cmds {
if cmd.RunOnce {
return nil, ErrMustUpdate{"command.run_once is not supported in Supfile v" + conf.Version}
}
}
fallthrough
case "0.2":
for _, cmd := range conf.Commands.cmds {
if cmd.Once {
return nil, ErrMustUpdate{"command.once is not supported in Supfile v" + conf.Version}
}
if cmd.Local != "" {
return nil, ErrMustUpdate{"command.local is not supported in Supfile v" + conf.Version}
}
if cmd.Serial != 0 {
return nil, ErrMustUpdate{"command.serial is not supported in Supfile v" + conf.Version}
}
}
for _, network := range conf.Networks.nets {
if network.Inventory != "" {
return nil, ErrMustUpdate{"network.inventory is not supported in Supfile v" + conf.Version}
}
}
fallthrough
case "0.3":
var warning string
for key, cmd := range conf.Commands.cmds {
if cmd.RunOnce {
warning = "Warning: command.run_once was deprecated by command.once in Supfile v" + conf.Version + "\n"
cmd.Once = true
conf.Commands.cmds[key] = cmd
}
}
if warning != "" {
fmt.Fprintf(os.Stderr, warning)
}
fallthrough
case "0.4", "0.5":
default:
return nil, ErrUnsupportedSupfileVersion{"unsupported Supfile version " + conf.Version}
}
return &conf, nil
} | go | func NewSupfile(data []byte) (*Supfile, error) {
var conf Supfile
if err := yaml.Unmarshal(data, &conf); err != nil {
return nil, err
}
// API backward compatibility. Will be deprecated in v1.0.
switch conf.Version {
case "":
conf.Version = "0.1"
fallthrough
case "0.1":
for _, cmd := range conf.Commands.cmds {
if cmd.RunOnce {
return nil, ErrMustUpdate{"command.run_once is not supported in Supfile v" + conf.Version}
}
}
fallthrough
case "0.2":
for _, cmd := range conf.Commands.cmds {
if cmd.Once {
return nil, ErrMustUpdate{"command.once is not supported in Supfile v" + conf.Version}
}
if cmd.Local != "" {
return nil, ErrMustUpdate{"command.local is not supported in Supfile v" + conf.Version}
}
if cmd.Serial != 0 {
return nil, ErrMustUpdate{"command.serial is not supported in Supfile v" + conf.Version}
}
}
for _, network := range conf.Networks.nets {
if network.Inventory != "" {
return nil, ErrMustUpdate{"network.inventory is not supported in Supfile v" + conf.Version}
}
}
fallthrough
case "0.3":
var warning string
for key, cmd := range conf.Commands.cmds {
if cmd.RunOnce {
warning = "Warning: command.run_once was deprecated by command.once in Supfile v" + conf.Version + "\n"
cmd.Once = true
conf.Commands.cmds[key] = cmd
}
}
if warning != "" {
fmt.Fprintf(os.Stderr, warning)
}
fallthrough
case "0.4", "0.5":
default:
return nil, ErrUnsupportedSupfileVersion{"unsupported Supfile version " + conf.Version}
}
return &conf, nil
} | [
"func",
"NewSupfile",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"Supfile",
",",
"error",
")",
"{",
"var",
"conf",
"Supfile",
"\n\n",
"if",
"err",
":=",
"yaml",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"conf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// API backward compatibility. Will be deprecated in v1.0.",
"switch",
"conf",
".",
"Version",
"{",
"case",
"\"",
"\"",
":",
"conf",
".",
"Version",
"=",
"\"",
"\"",
"\n",
"fallthrough",
"\n\n",
"case",
"\"",
"\"",
":",
"for",
"_",
",",
"cmd",
":=",
"range",
"conf",
".",
"Commands",
".",
"cmds",
"{",
"if",
"cmd",
".",
"RunOnce",
"{",
"return",
"nil",
",",
"ErrMustUpdate",
"{",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"fallthrough",
"\n\n",
"case",
"\"",
"\"",
":",
"for",
"_",
",",
"cmd",
":=",
"range",
"conf",
".",
"Commands",
".",
"cmds",
"{",
"if",
"cmd",
".",
"Once",
"{",
"return",
"nil",
",",
"ErrMustUpdate",
"{",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"}",
"\n",
"}",
"\n",
"if",
"cmd",
".",
"Local",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrMustUpdate",
"{",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"}",
"\n",
"}",
"\n",
"if",
"cmd",
".",
"Serial",
"!=",
"0",
"{",
"return",
"nil",
",",
"ErrMustUpdate",
"{",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"network",
":=",
"range",
"conf",
".",
"Networks",
".",
"nets",
"{",
"if",
"network",
".",
"Inventory",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrMustUpdate",
"{",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"fallthrough",
"\n\n",
"case",
"\"",
"\"",
":",
"var",
"warning",
"string",
"\n",
"for",
"key",
",",
"cmd",
":=",
"range",
"conf",
".",
"Commands",
".",
"cmds",
"{",
"if",
"cmd",
".",
"RunOnce",
"{",
"warning",
"=",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"+",
"\"",
"\\n",
"\"",
"\n",
"cmd",
".",
"Once",
"=",
"true",
"\n",
"conf",
".",
"Commands",
".",
"cmds",
"[",
"key",
"]",
"=",
"cmd",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"warning",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"warning",
")",
"\n",
"}",
"\n\n",
"fallthrough",
"\n\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"default",
":",
"return",
"nil",
",",
"ErrUnsupportedSupfileVersion",
"{",
"\"",
"\"",
"+",
"conf",
".",
"Version",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"conf",
",",
"nil",
"\n",
"}"
] | // NewSupfile parses configuration file and returns Supfile or error. | [
"NewSupfile",
"parses",
"configuration",
"file",
"and",
"returns",
"Supfile",
"or",
"error",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/supfile.go#L266-L328 |
149,078 | pressly/sup | supfile.go | ParseInventory | func (n Network) ParseInventory() ([]string, error) {
if n.Inventory == "" {
return nil, nil
}
cmd := exec.Command("/bin/sh", "-c", n.Inventory)
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, n.Env.Slice()...)
cmd.Stderr = os.Stderr
output, err := cmd.Output()
if err != nil {
return nil, err
}
var hosts []string
buf := bytes.NewBuffer(output)
for {
host, err := buf.ReadString('\n')
if err != nil {
if err == io.EOF {
break
}
return nil, err
}
host = strings.TrimSpace(host)
// skip empty lines and comments
if host == "" || host[:1] == "#" {
continue
}
hosts = append(hosts, host)
}
return hosts, nil
} | go | func (n Network) ParseInventory() ([]string, error) {
if n.Inventory == "" {
return nil, nil
}
cmd := exec.Command("/bin/sh", "-c", n.Inventory)
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, n.Env.Slice()...)
cmd.Stderr = os.Stderr
output, err := cmd.Output()
if err != nil {
return nil, err
}
var hosts []string
buf := bytes.NewBuffer(output)
for {
host, err := buf.ReadString('\n')
if err != nil {
if err == io.EOF {
break
}
return nil, err
}
host = strings.TrimSpace(host)
// skip empty lines and comments
if host == "" || host[:1] == "#" {
continue
}
hosts = append(hosts, host)
}
return hosts, nil
} | [
"func",
"(",
"n",
"Network",
")",
"ParseInventory",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"n",
".",
"Inventory",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"n",
".",
"Inventory",
")",
"\n",
"cmd",
".",
"Env",
"=",
"os",
".",
"Environ",
"(",
")",
"\n",
"cmd",
".",
"Env",
"=",
"append",
"(",
"cmd",
".",
"Env",
",",
"n",
".",
"Env",
".",
"Slice",
"(",
")",
"...",
")",
"\n",
"cmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"output",
",",
"err",
":=",
"cmd",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"hosts",
"[",
"]",
"string",
"\n",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"output",
")",
"\n",
"for",
"{",
"host",
",",
"err",
":=",
"buf",
".",
"ReadString",
"(",
"'\\n'",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"host",
"=",
"strings",
".",
"TrimSpace",
"(",
"host",
")",
"\n",
"// skip empty lines and comments",
"if",
"host",
"==",
"\"",
"\"",
"||",
"host",
"[",
":",
"1",
"]",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"hosts",
"=",
"append",
"(",
"hosts",
",",
"host",
")",
"\n",
"}",
"\n",
"return",
"hosts",
",",
"nil",
"\n",
"}"
] | // ParseInventory runs the inventory command, if provided, and appends
// the command's output lines to the manually defined list of hosts. | [
"ParseInventory",
"runs",
"the",
"inventory",
"command",
"if",
"provided",
"and",
"appends",
"the",
"command",
"s",
"output",
"lines",
"to",
"the",
"manually",
"defined",
"list",
"of",
"hosts",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/supfile.go#L332-L366 |
149,079 | bndr/gojenkins | jenkins.go | Info | func (j *Jenkins) Info() (*ExecutorResponse, error) {
_, err := j.Requester.Get("/", j.Raw, nil)
if err != nil {
return nil, err
}
return j.Raw, nil
} | go | func (j *Jenkins) Info() (*ExecutorResponse, error) {
_, err := j.Requester.Get("/", j.Raw, nil)
if err != nil {
return nil, err
}
return j.Raw, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"Info",
"(",
")",
"(",
"*",
"ExecutorResponse",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"Get",
"(",
"\"",
"\"",
",",
"j",
".",
"Raw",
",",
"nil",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"j",
".",
"Raw",
",",
"nil",
"\n",
"}"
] | // Get Basic Information About Jenkins | [
"Get",
"Basic",
"Information",
"About",
"Jenkins"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L84-L91 |
149,080 | bndr/gojenkins | jenkins.go | SafeRestart | func (j *Jenkins) SafeRestart() error {
_, err := j.Requester.Post("/safeRestart", strings.NewReader(""), struct{}{}, map[string]string{})
return err
} | go | func (j *Jenkins) SafeRestart() error {
_, err := j.Requester.Post("/safeRestart", strings.NewReader(""), struct{}{}, map[string]string{})
return err
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"SafeRestart",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"Post",
"(",
"\"",
"\"",
",",
"strings",
".",
"NewReader",
"(",
"\"",
"\"",
")",
",",
"struct",
"{",
"}",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // SafeRestart jenkins, restart will be done when there are no jobs running | [
"SafeRestart",
"jenkins",
"restart",
"will",
"be",
"done",
"when",
"there",
"are",
"no",
"jobs",
"running"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L94-L97 |
149,081 | bndr/gojenkins | jenkins.go | DeleteNode | func (j *Jenkins) DeleteNode(name string) (bool, error) {
node := Node{Jenkins: j, Raw: new(NodeResponse), Base: "/computer/" + name}
return node.Delete()
} | go | func (j *Jenkins) DeleteNode(name string) (bool, error) {
node := Node{Jenkins: j, Raw: new(NodeResponse), Base: "/computer/" + name}
return node.Delete()
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"DeleteNode",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"node",
":=",
"Node",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"NodeResponse",
")",
",",
"Base",
":",
"\"",
"\"",
"+",
"name",
"}",
"\n",
"return",
"node",
".",
"Delete",
"(",
")",
"\n",
"}"
] | // Delete a Jenkins slave node | [
"Delete",
"a",
"Jenkins",
"slave",
"node"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L179-L182 |
149,082 | bndr/gojenkins | jenkins.go | RenameJob | func (j *Jenkins) RenameJob(job string, name string) *Job {
jobObj := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + job}
jobObj.Rename(name)
return &jobObj
} | go | func (j *Jenkins) RenameJob(job string, name string) *Job {
jobObj := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + job}
jobObj.Rename(name)
return &jobObj
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"RenameJob",
"(",
"job",
"string",
",",
"name",
"string",
")",
"*",
"Job",
"{",
"jobObj",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",",
"Base",
":",
"\"",
"\"",
"+",
"job",
"}",
"\n",
"jobObj",
".",
"Rename",
"(",
"name",
")",
"\n",
"return",
"&",
"jobObj",
"\n",
"}"
] | // Rename a job.
// First parameter job old name, Second parameter job new name. | [
"Rename",
"a",
"job",
".",
"First",
"parameter",
"job",
"old",
"name",
"Second",
"parameter",
"job",
"new",
"name",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L231-L235 |
149,083 | bndr/gojenkins | jenkins.go | CopyJob | func (j *Jenkins) CopyJob(copyFrom string, newName string) (*Job, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + copyFrom}
_, err := job.Poll()
if err != nil {
return nil, err
}
return job.Copy(newName)
} | go | func (j *Jenkins) CopyJob(copyFrom string, newName string) (*Job, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + copyFrom}
_, err := job.Poll()
if err != nil {
return nil, err
}
return job.Copy(newName)
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"CopyJob",
"(",
"copyFrom",
"string",
",",
"newName",
"string",
")",
"(",
"*",
"Job",
",",
"error",
")",
"{",
"job",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",",
"Base",
":",
"\"",
"\"",
"+",
"copyFrom",
"}",
"\n",
"_",
",",
"err",
":=",
"job",
".",
"Poll",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"job",
".",
"Copy",
"(",
"newName",
")",
"\n",
"}"
] | // Create a copy of a job.
// First parameter Name of the job to copy from, Second parameter new job name. | [
"Create",
"a",
"copy",
"of",
"a",
"job",
".",
"First",
"parameter",
"Name",
"of",
"the",
"job",
"to",
"copy",
"from",
"Second",
"parameter",
"new",
"job",
"name",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L239-L246 |
149,084 | bndr/gojenkins | jenkins.go | DeleteJob | func (j *Jenkins) DeleteJob(name string) (bool, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
return job.Delete()
} | go | func (j *Jenkins) DeleteJob(name string) (bool, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
return job.Delete()
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"DeleteJob",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"job",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",",
"Base",
":",
"\"",
"\"",
"+",
"name",
"}",
"\n",
"return",
"job",
".",
"Delete",
"(",
")",
"\n",
"}"
] | // Delete a job. | [
"Delete",
"a",
"job",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L249-L252 |
149,085 | bndr/gojenkins | jenkins.go | BuildJob | func (j *Jenkins) BuildJob(name string, options ...interface{}) (int64, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
var params map[string]string
if len(options) > 0 {
params, _ = options[0].(map[string]string)
}
return job.InvokeSimple(params)
} | go | func (j *Jenkins) BuildJob(name string, options ...interface{}) (int64, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
var params map[string]string
if len(options) > 0 {
params, _ = options[0].(map[string]string)
}
return job.InvokeSimple(params)
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"BuildJob",
"(",
"name",
"string",
",",
"options",
"...",
"interface",
"{",
"}",
")",
"(",
"int64",
",",
"error",
")",
"{",
"job",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",",
"Base",
":",
"\"",
"\"",
"+",
"name",
"}",
"\n",
"var",
"params",
"map",
"[",
"string",
"]",
"string",
"\n",
"if",
"len",
"(",
"options",
")",
">",
"0",
"{",
"params",
",",
"_",
"=",
"options",
"[",
"0",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"}",
"\n",
"return",
"job",
".",
"InvokeSimple",
"(",
"params",
")",
"\n",
"}"
] | // Invoke a job.
// First parameter job name, second parameter is optional Build parameters. | [
"Invoke",
"a",
"job",
".",
"First",
"parameter",
"job",
"name",
"second",
"parameter",
"is",
"optional",
"Build",
"parameters",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L256-L263 |
149,086 | bndr/gojenkins | jenkins.go | GetAllJobNames | func (j *Jenkins) GetAllJobNames() ([]InnerJob, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
return exec.Raw.Jobs, nil
} | go | func (j *Jenkins) GetAllJobNames() ([]InnerJob, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
return exec.Raw.Jobs, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetAllJobNames",
"(",
")",
"(",
"[",
"]",
"InnerJob",
",",
"error",
")",
"{",
"exec",
":=",
"Executor",
"{",
"Raw",
":",
"new",
"(",
"ExecutorResponse",
")",
",",
"Jenkins",
":",
"j",
"}",
"\n",
"_",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"GetJSON",
"(",
"\"",
"\"",
",",
"exec",
".",
"Raw",
",",
"nil",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"exec",
".",
"Raw",
".",
"Jobs",
",",
"nil",
"\n",
"}"
] | // Get Only Array of Job Names, Color, URL
// Does not query each single Job. | [
"Get",
"Only",
"Array",
"of",
"Job",
"Names",
"Color",
"URL",
"Does",
"not",
"query",
"each",
"single",
"Job",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L372-L381 |
149,087 | bndr/gojenkins | jenkins.go | GetAllJobs | func (j *Jenkins) GetAllJobs() ([]*Job, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
jobs := make([]*Job, len(exec.Raw.Jobs))
for i, job := range exec.Raw.Jobs {
ji, err := j.GetJob(job.Name)
if err != nil {
return nil, err
}
jobs[i] = ji
}
return jobs, nil
} | go | func (j *Jenkins) GetAllJobs() ([]*Job, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
jobs := make([]*Job, len(exec.Raw.Jobs))
for i, job := range exec.Raw.Jobs {
ji, err := j.GetJob(job.Name)
if err != nil {
return nil, err
}
jobs[i] = ji
}
return jobs, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetAllJobs",
"(",
")",
"(",
"[",
"]",
"*",
"Job",
",",
"error",
")",
"{",
"exec",
":=",
"Executor",
"{",
"Raw",
":",
"new",
"(",
"ExecutorResponse",
")",
",",
"Jenkins",
":",
"j",
"}",
"\n",
"_",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"GetJSON",
"(",
"\"",
"\"",
",",
"exec",
".",
"Raw",
",",
"nil",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"jobs",
":=",
"make",
"(",
"[",
"]",
"*",
"Job",
",",
"len",
"(",
"exec",
".",
"Raw",
".",
"Jobs",
")",
")",
"\n",
"for",
"i",
",",
"job",
":=",
"range",
"exec",
".",
"Raw",
".",
"Jobs",
"{",
"ji",
",",
"err",
":=",
"j",
".",
"GetJob",
"(",
"job",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"jobs",
"[",
"i",
"]",
"=",
"ji",
"\n",
"}",
"\n",
"return",
"jobs",
",",
"nil",
"\n",
"}"
] | // Get All Possible Job Objects.
// Each job will be queried. | [
"Get",
"All",
"Possible",
"Job",
"Objects",
".",
"Each",
"job",
"will",
"be",
"queried",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L385-L402 |
149,088 | bndr/gojenkins | jenkins.go | GetQueue | func (j *Jenkins) GetQueue() (*Queue, error) {
q := &Queue{Jenkins: j, Raw: new(queueResponse), Base: j.GetQueueUrl()}
_, err := q.Poll()
if err != nil {
return nil, err
}
return q, nil
} | go | func (j *Jenkins) GetQueue() (*Queue, error) {
q := &Queue{Jenkins: j, Raw: new(queueResponse), Base: j.GetQueueUrl()}
_, err := q.Poll()
if err != nil {
return nil, err
}
return q, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetQueue",
"(",
")",
"(",
"*",
"Queue",
",",
"error",
")",
"{",
"q",
":=",
"&",
"Queue",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"queueResponse",
")",
",",
"Base",
":",
"j",
".",
"GetQueueUrl",
"(",
")",
"}",
"\n",
"_",
",",
"err",
":=",
"q",
".",
"Poll",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"q",
",",
"nil",
"\n",
"}"
] | // Returns a Queue | [
"Returns",
"a",
"Queue"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L405-L412 |
149,089 | bndr/gojenkins | jenkins.go | GetQueueItem | func (j *Jenkins) GetQueueItem(id int64) (*Task, error) {
t := &Task{Raw: new(taskResponse), Jenkins: j, Base: j.getQueueItemURL(id)}
_, err := t.Poll()
if err != nil {
return nil, err
}
return t, nil
} | go | func (j *Jenkins) GetQueueItem(id int64) (*Task, error) {
t := &Task{Raw: new(taskResponse), Jenkins: j, Base: j.getQueueItemURL(id)}
_, err := t.Poll()
if err != nil {
return nil, err
}
return t, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetQueueItem",
"(",
"id",
"int64",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"t",
":=",
"&",
"Task",
"{",
"Raw",
":",
"new",
"(",
"taskResponse",
")",
",",
"Jenkins",
":",
"j",
",",
"Base",
":",
"j",
".",
"getQueueItemURL",
"(",
"id",
")",
"}",
"\n",
"_",
",",
"err",
":=",
"t",
".",
"Poll",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"t",
",",
"nil",
"\n",
"}"
] | // GetQueueItem returns a single queue Task | [
"GetQueueItem",
"returns",
"a",
"single",
"queue",
"Task"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L419-L426 |
149,090 | bndr/gojenkins | jenkins.go | GetArtifactData | func (j *Jenkins) GetArtifactData(id string) (*FingerPrintResponse, error) {
fp := FingerPrint{Jenkins: j, Base: "/fingerprint/", Id: id, Raw: new(FingerPrintResponse)}
return fp.GetInfo()
} | go | func (j *Jenkins) GetArtifactData(id string) (*FingerPrintResponse, error) {
fp := FingerPrint{Jenkins: j, Base: "/fingerprint/", Id: id, Raw: new(FingerPrintResponse)}
return fp.GetInfo()
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetArtifactData",
"(",
"id",
"string",
")",
"(",
"*",
"FingerPrintResponse",
",",
"error",
")",
"{",
"fp",
":=",
"FingerPrint",
"{",
"Jenkins",
":",
"j",
",",
"Base",
":",
"\"",
"\"",
",",
"Id",
":",
"id",
",",
"Raw",
":",
"new",
"(",
"FingerPrintResponse",
")",
"}",
"\n",
"return",
"fp",
".",
"GetInfo",
"(",
")",
"\n",
"}"
] | // Get Artifact data by Hash | [
"Get",
"Artifact",
"data",
"by",
"Hash"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L433-L436 |
149,091 | bndr/gojenkins | jenkins.go | GetPlugins | func (j *Jenkins) GetPlugins(depth int) (*Plugins, error) {
p := Plugins{Jenkins: j, Raw: new(PluginResponse), Base: "/pluginManager", Depth: depth}
_, err := p.Poll()
if err != nil {
return nil, err
}
return &p, nil
} | go | func (j *Jenkins) GetPlugins(depth int) (*Plugins, error) {
p := Plugins{Jenkins: j, Raw: new(PluginResponse), Base: "/pluginManager", Depth: depth}
_, err := p.Poll()
if err != nil {
return nil, err
}
return &p, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetPlugins",
"(",
"depth",
"int",
")",
"(",
"*",
"Plugins",
",",
"error",
")",
"{",
"p",
":=",
"Plugins",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"PluginResponse",
")",
",",
"Base",
":",
"\"",
"\"",
",",
"Depth",
":",
"depth",
"}",
"\n",
"_",
",",
"err",
":=",
"p",
".",
"Poll",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"p",
",",
"nil",
"\n",
"}"
] | // Returns the list of all plugins installed on the Jenkins server.
// You can supply depth parameter, to limit how much data is returned. | [
"Returns",
"the",
"list",
"of",
"all",
"plugins",
"installed",
"on",
"the",
"Jenkins",
"server",
".",
"You",
"can",
"supply",
"depth",
"parameter",
"to",
"limit",
"how",
"much",
"data",
"is",
"returned",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L440-L447 |
149,092 | bndr/gojenkins | jenkins.go | UninstallPlugin | func (j *Jenkins) UninstallPlugin(name string) error {
url := fmt.Sprintf("/pluginManager/plugin/%s/doUninstall", name)
resp, err := j.Requester.Post(url, strings.NewReader(""), struct{}{}, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid status code returned: %d", resp.StatusCode)
}
return err
} | go | func (j *Jenkins) UninstallPlugin(name string) error {
url := fmt.Sprintf("/pluginManager/plugin/%s/doUninstall", name)
resp, err := j.Requester.Post(url, strings.NewReader(""), struct{}{}, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid status code returned: %d", resp.StatusCode)
}
return err
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"UninstallPlugin",
"(",
"name",
"string",
")",
"error",
"{",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"resp",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"Post",
"(",
"url",
",",
"strings",
".",
"NewReader",
"(",
"\"",
"\"",
")",
",",
"struct",
"{",
"}",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"200",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // UninstallPlugin plugin otherwise returns error | [
"UninstallPlugin",
"plugin",
"otherwise",
"returns",
"error"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L450-L457 |
149,093 | bndr/gojenkins | jenkins.go | HasPlugin | func (j *Jenkins) HasPlugin(name string) (*Plugin, error) {
p, err := j.GetPlugins(1)
if err != nil {
return nil, err
}
return p.Contains(name), nil
} | go | func (j *Jenkins) HasPlugin(name string) (*Plugin, error) {
p, err := j.GetPlugins(1)
if err != nil {
return nil, err
}
return p.Contains(name), nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"HasPlugin",
"(",
"name",
"string",
")",
"(",
"*",
"Plugin",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"j",
".",
"GetPlugins",
"(",
"1",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"p",
".",
"Contains",
"(",
"name",
")",
",",
"nil",
"\n",
"}"
] | // Check if the plugin is installed on the server.
// Depth level 1 is used. If you need to go deeper, you can use GetPlugins, and iterate through them. | [
"Check",
"if",
"the",
"plugin",
"is",
"installed",
"on",
"the",
"server",
".",
"Depth",
"level",
"1",
"is",
"used",
".",
"If",
"you",
"need",
"to",
"go",
"deeper",
"you",
"can",
"use",
"GetPlugins",
"and",
"iterate",
"through",
"them",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L461-L468 |
149,094 | bndr/gojenkins | jenkins.go | InstallPlugin | func (j *Jenkins) InstallPlugin(name string, version string) error {
xml := fmt.Sprintf(`<jenkins><install plugin="%s@%s" /></jenkins>`, name, version)
resp, err := j.Requester.PostXML("/pluginManager/installNecessaryPlugins", xml, j.Raw, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid status code returned: %d", resp.StatusCode)
}
return err
} | go | func (j *Jenkins) InstallPlugin(name string, version string) error {
xml := fmt.Sprintf(`<jenkins><install plugin="%s@%s" /></jenkins>`, name, version)
resp, err := j.Requester.PostXML("/pluginManager/installNecessaryPlugins", xml, j.Raw, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid status code returned: %d", resp.StatusCode)
}
return err
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"InstallPlugin",
"(",
"name",
"string",
",",
"version",
"string",
")",
"error",
"{",
"xml",
":=",
"fmt",
".",
"Sprintf",
"(",
"`<jenkins><install plugin=\"%s@%s\" /></jenkins>`",
",",
"name",
",",
"version",
")",
"\n",
"resp",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"PostXML",
"(",
"\"",
"\"",
",",
"xml",
",",
"j",
".",
"Raw",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
")",
"\n\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"200",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //InstallPlugin with given version and name | [
"InstallPlugin",
"with",
"given",
"version",
"and",
"name"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L471-L479 |
149,095 | bndr/gojenkins | credentials.go | List | func (cm CredentialsManager) List(domain string) ([]string, error) {
idsResponse := credentialIDs{}
ids := make([]string, 0)
err := cm.handleResponse(cm.J.Requester.Get(cm.fillURL(credentialsListURL, domain), &idsResponse, listQuery))
if err != nil {
return ids, err
}
for _, id := range idsResponse.Credentials {
ids = append(ids, id.ID)
}
return ids, nil
} | go | func (cm CredentialsManager) List(domain string) ([]string, error) {
idsResponse := credentialIDs{}
ids := make([]string, 0)
err := cm.handleResponse(cm.J.Requester.Get(cm.fillURL(credentialsListURL, domain), &idsResponse, listQuery))
if err != nil {
return ids, err
}
for _, id := range idsResponse.Credentials {
ids = append(ids, id.ID)
}
return ids, nil
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"List",
"(",
"domain",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"idsResponse",
":=",
"credentialIDs",
"{",
"}",
"\n",
"ids",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"err",
":=",
"cm",
".",
"handleResponse",
"(",
"cm",
".",
"J",
".",
"Requester",
".",
"Get",
"(",
"cm",
".",
"fillURL",
"(",
"credentialsListURL",
",",
"domain",
")",
",",
"&",
"idsResponse",
",",
"listQuery",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ids",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"id",
":=",
"range",
"idsResponse",
".",
"Credentials",
"{",
"ids",
"=",
"append",
"(",
"ids",
",",
"id",
".",
"ID",
")",
"\n",
"}",
"\n\n",
"return",
"ids",
",",
"nil",
"\n",
"}"
] | //List ids if credentials stored inside provided domain | [
"List",
"ids",
"if",
"credentials",
"stored",
"inside",
"provided",
"domain"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L110-L124 |
149,096 | bndr/gojenkins | credentials.go | Add | func (cm CredentialsManager) Add(domain string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(createCredentialsURL, domain), creds)
} | go | func (cm CredentialsManager) Add(domain string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(createCredentialsURL, domain), creds)
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"Add",
"(",
"domain",
"string",
",",
"creds",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"cm",
".",
"postCredsXML",
"(",
"cm",
".",
"fillURL",
"(",
"createCredentialsURL",
",",
"domain",
")",
",",
"creds",
")",
"\n",
"}"
] | //Add credential to given domain, creds must be struct which is parsable to xml | [
"Add",
"credential",
"to",
"given",
"domain",
"creds",
"must",
"be",
"struct",
"which",
"is",
"parsable",
"to",
"xml"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L139-L141 |
149,097 | bndr/gojenkins | credentials.go | Delete | func (cm CredentialsManager) Delete(domain string, id string) error {
return cm.handleResponse(cm.J.Requester.Post(cm.fillURL(deleteCredentialURL, domain, id), nil, cm.J.Raw, map[string]string{}))
} | go | func (cm CredentialsManager) Delete(domain string, id string) error {
return cm.handleResponse(cm.J.Requester.Post(cm.fillURL(deleteCredentialURL, domain, id), nil, cm.J.Raw, map[string]string{}))
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"Delete",
"(",
"domain",
"string",
",",
"id",
"string",
")",
"error",
"{",
"return",
"cm",
".",
"handleResponse",
"(",
"cm",
".",
"J",
".",
"Requester",
".",
"Post",
"(",
"cm",
".",
"fillURL",
"(",
"deleteCredentialURL",
",",
"domain",
",",
"id",
")",
",",
"nil",
",",
"cm",
".",
"J",
".",
"Raw",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
")",
")",
"\n",
"}"
] | //Delete credential in given domain with given id | [
"Delete",
"credential",
"in",
"given",
"domain",
"with",
"given",
"id"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L144-L146 |
149,098 | bndr/gojenkins | credentials.go | Update | func (cm CredentialsManager) Update(domain string, id string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(configCredentialURL, domain, id), creds)
} | go | func (cm CredentialsManager) Update(domain string, id string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(configCredentialURL, domain, id), creds)
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"Update",
"(",
"domain",
"string",
",",
"id",
"string",
",",
"creds",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"cm",
".",
"postCredsXML",
"(",
"cm",
".",
"fillURL",
"(",
"configCredentialURL",
",",
"domain",
",",
"id",
")",
",",
"creds",
")",
"\n",
"}"
] | //Update credential in given domain with given id, creds must be pointer to struct which is parsable to xml | [
"Update",
"credential",
"in",
"given",
"domain",
"with",
"given",
"id",
"creds",
"must",
"be",
"pointer",
"to",
"struct",
"which",
"is",
"parsable",
"to",
"xml"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L149-L151 |
149,099 | bndr/gojenkins | request.go | redirectPolicyFunc | func (r *Requester) redirectPolicyFunc(req *http.Request, via []*http.Request) error {
if r.BasicAuth != nil {
req.SetBasicAuth(r.BasicAuth.Username, r.BasicAuth.Password)
}
return nil
} | go | func (r *Requester) redirectPolicyFunc(req *http.Request, via []*http.Request) error {
if r.BasicAuth != nil {
req.SetBasicAuth(r.BasicAuth.Username, r.BasicAuth.Password)
}
return nil
} | [
"func",
"(",
"r",
"*",
"Requester",
")",
"redirectPolicyFunc",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"via",
"[",
"]",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"if",
"r",
".",
"BasicAuth",
"!=",
"nil",
"{",
"req",
".",
"SetBasicAuth",
"(",
"r",
".",
"BasicAuth",
".",
"Username",
",",
"r",
".",
"BasicAuth",
".",
"Password",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | //Add auth on redirect if required. | [
"Add",
"auth",
"on",
"redirect",
"if",
"required",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/request.go#L138-L143 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.