id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
16,000 |
hjson/hjson-go
|
encode.go
|
DefaultOptions
|
func DefaultOptions() EncoderOptions {
opt := EncoderOptions{}
opt.Eol = "\n"
opt.BracesSameLine = false
opt.EmitRootBraces = true
opt.QuoteAlways = false
opt.IndentBy = " "
opt.AllowMinusZero = false
opt.UnknownAsNull = false
return opt
}
|
go
|
func DefaultOptions() EncoderOptions {
opt := EncoderOptions{}
opt.Eol = "\n"
opt.BracesSameLine = false
opt.EmitRootBraces = true
opt.QuoteAlways = false
opt.IndentBy = " "
opt.AllowMinusZero = false
opt.UnknownAsNull = false
return opt
}
|
[
"func",
"DefaultOptions",
"(",
")",
"EncoderOptions",
"{",
"opt",
":=",
"EncoderOptions",
"{",
"}",
"\n",
"opt",
".",
"Eol",
"=",
"\"",
"\\n",
"\"",
"\n",
"opt",
".",
"BracesSameLine",
"=",
"false",
"\n",
"opt",
".",
"EmitRootBraces",
"=",
"true",
"\n",
"opt",
".",
"QuoteAlways",
"=",
"false",
"\n",
"opt",
".",
"IndentBy",
"=",
"\"",
"\"",
"\n",
"opt",
".",
"AllowMinusZero",
"=",
"false",
"\n",
"opt",
".",
"UnknownAsNull",
"=",
"false",
"\n",
"return",
"opt",
"\n",
"}"
] |
// DefaultOptions returns the default encoding options.
|
[
"DefaultOptions",
"returns",
"the",
"default",
"encoding",
"options",
"."
] |
9147687966d9f3424e938ac93f70fbeae23f1321
|
https://github.com/hjson/hjson-go/blob/9147687966d9f3424e938ac93f70fbeae23f1321/encode.go#L36-L46
|
16,001 |
hjson/hjson-go
|
decode.go
|
Unmarshal
|
func Unmarshal(data []byte, v interface{}) (err error) {
var value interface{}
parser := &hjsonParser{data, 0, ' '}
parser.resetAt()
value, err = parser.rootValue()
if err != nil {
return err
}
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return errors.New("non-pointer " + reflect.TypeOf(v).String())
}
for rv.Kind() == reflect.Ptr {
rv = rv.Elem()
}
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
rv.Set(reflect.ValueOf(value))
return err
}
|
go
|
func Unmarshal(data []byte, v interface{}) (err error) {
var value interface{}
parser := &hjsonParser{data, 0, ' '}
parser.resetAt()
value, err = parser.rootValue()
if err != nil {
return err
}
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return errors.New("non-pointer " + reflect.TypeOf(v).String())
}
for rv.Kind() == reflect.Ptr {
rv = rv.Elem()
}
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
rv.Set(reflect.ValueOf(value))
return err
}
|
[
"func",
"Unmarshal",
"(",
"data",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"var",
"value",
"interface",
"{",
"}",
"\n",
"parser",
":=",
"&",
"hjsonParser",
"{",
"data",
",",
"0",
",",
"' '",
"}",
"\n",
"parser",
".",
"resetAt",
"(",
")",
"\n",
"value",
",",
"err",
"=",
"parser",
".",
"rootValue",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"if",
"rv",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"||",
"rv",
".",
"IsNil",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"reflect",
".",
"TypeOf",
"(",
"v",
")",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"for",
"rv",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"rv",
"=",
"rv",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"e",
":=",
"recover",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"rv",
".",
"Set",
"(",
"reflect",
".",
"ValueOf",
"(",
"value",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Unmarshal parses the Hjson-encoded data and stores the result
// in the value pointed to by v.
//
// Unmarshal uses the inverse of the encodings that
// Marshal uses, allocating maps, slices, and pointers as necessary.
//
|
[
"Unmarshal",
"parses",
"the",
"Hjson",
"-",
"encoded",
"data",
"and",
"stores",
"the",
"result",
"in",
"the",
"value",
"pointed",
"to",
"by",
"v",
".",
"Unmarshal",
"uses",
"the",
"inverse",
"of",
"the",
"encodings",
"that",
"Marshal",
"uses",
"allocating",
"maps",
"slices",
"and",
"pointers",
"as",
"necessary",
"."
] |
9147687966d9f3424e938ac93f70fbeae23f1321
|
https://github.com/hjson/hjson-go/blob/9147687966d9f3424e938ac93f70fbeae23f1321/decode.go#L458-L481
|
16,002 |
kylelemons/godebug
|
pretty/public.go
|
Sprint
|
func (cfg *Config) Sprint(vals ...interface{}) string {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.String()
}
|
go
|
func (cfg *Config) Sprint(vals ...interface{}) string {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.String()
}
|
[
"func",
"(",
"cfg",
"*",
"Config",
")",
"Sprint",
"(",
"vals",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"cfg",
".",
"fprint",
"(",
"buf",
",",
"vals",
"...",
")",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] |
// Sprint returns a string representation of the given value according to cfg.
|
[
"Sprint",
"returns",
"a",
"string",
"representation",
"of",
"the",
"given",
"value",
"according",
"to",
"cfg",
"."
] |
009bb93e63da0d3607040fbc75007ff3e635a5a5
|
https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L118-L122
|
16,003 |
kylelemons/godebug
|
pretty/public.go
|
Fprint
|
func Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
return DefaultConfig.Fprint(w, vals...)
}
|
go
|
func Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
return DefaultConfig.Fprint(w, vals...)
}
|
[
"func",
"Fprint",
"(",
"w",
"io",
".",
"Writer",
",",
"vals",
"...",
"interface",
"{",
"}",
")",
"(",
"n",
"int64",
",",
"err",
"error",
")",
"{",
"return",
"DefaultConfig",
".",
"Fprint",
"(",
"w",
",",
"vals",
"...",
")",
"\n",
"}"
] |
// Fprint writes the representation of the given value to the writer according to the DefaultConfig.
|
[
"Fprint",
"writes",
"the",
"representation",
"of",
"the",
"given",
"value",
"to",
"the",
"writer",
"according",
"to",
"the",
"DefaultConfig",
"."
] |
009bb93e63da0d3607040fbc75007ff3e635a5a5
|
https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L125-L127
|
16,004 |
kylelemons/godebug
|
pretty/public.go
|
Fprint
|
func (cfg *Config) Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.WriteTo(w)
}
|
go
|
func (cfg *Config) Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.WriteTo(w)
}
|
[
"func",
"(",
"cfg",
"*",
"Config",
")",
"Fprint",
"(",
"w",
"io",
".",
"Writer",
",",
"vals",
"...",
"interface",
"{",
"}",
")",
"(",
"n",
"int64",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"cfg",
".",
"fprint",
"(",
"buf",
",",
"vals",
"...",
")",
"\n",
"return",
"buf",
".",
"WriteTo",
"(",
"w",
")",
"\n",
"}"
] |
// Fprint writes the representation of the given value to the writer according to the cfg.
|
[
"Fprint",
"writes",
"the",
"representation",
"of",
"the",
"given",
"value",
"to",
"the",
"writer",
"according",
"to",
"the",
"cfg",
"."
] |
009bb93e63da0d3607040fbc75007ff3e635a5a5
|
https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L130-L134
|
16,005 |
kylelemons/godebug
|
pretty/public.go
|
Compare
|
func (cfg *Config) Compare(a, b interface{}) string {
diffCfg := *cfg
diffCfg.Diffable = true
return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
}
|
go
|
func (cfg *Config) Compare(a, b interface{}) string {
diffCfg := *cfg
diffCfg.Diffable = true
return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
}
|
[
"func",
"(",
"cfg",
"*",
"Config",
")",
"Compare",
"(",
"a",
",",
"b",
"interface",
"{",
"}",
")",
"string",
"{",
"diffCfg",
":=",
"*",
"cfg",
"\n",
"diffCfg",
".",
"Diffable",
"=",
"true",
"\n",
"return",
"diff",
".",
"Diff",
"(",
"cfg",
".",
"Sprint",
"(",
"a",
")",
",",
"cfg",
".",
"Sprint",
"(",
"b",
")",
")",
"\n",
"}"
] |
// Compare returns a string containing a line-by-line unified diff of the
// values in got and want according to the cfg.
|
[
"Compare",
"returns",
"a",
"string",
"containing",
"a",
"line",
"-",
"by",
"-",
"line",
"unified",
"diff",
"of",
"the",
"values",
"in",
"got",
"and",
"want",
"according",
"to",
"the",
"cfg",
"."
] |
009bb93e63da0d3607040fbc75007ff3e635a5a5
|
https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L149-L153
|
16,006 |
kylelemons/godebug
|
diff/diff.go
|
Diff
|
func Diff(A, B string) string {
aLines := strings.Split(A, "\n")
bLines := strings.Split(B, "\n")
chunks := DiffChunks(aLines, bLines)
buf := new(bytes.Buffer)
for _, c := range chunks {
for _, line := range c.Added {
fmt.Fprintf(buf, "+%s\n", line)
}
for _, line := range c.Deleted {
fmt.Fprintf(buf, "-%s\n", line)
}
for _, line := range c.Equal {
fmt.Fprintf(buf, " %s\n", line)
}
}
return strings.TrimRight(buf.String(), "\n")
}
|
go
|
func Diff(A, B string) string {
aLines := strings.Split(A, "\n")
bLines := strings.Split(B, "\n")
chunks := DiffChunks(aLines, bLines)
buf := new(bytes.Buffer)
for _, c := range chunks {
for _, line := range c.Added {
fmt.Fprintf(buf, "+%s\n", line)
}
for _, line := range c.Deleted {
fmt.Fprintf(buf, "-%s\n", line)
}
for _, line := range c.Equal {
fmt.Fprintf(buf, " %s\n", line)
}
}
return strings.TrimRight(buf.String(), "\n")
}
|
[
"func",
"Diff",
"(",
"A",
",",
"B",
"string",
")",
"string",
"{",
"aLines",
":=",
"strings",
".",
"Split",
"(",
"A",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"bLines",
":=",
"strings",
".",
"Split",
"(",
"B",
",",
"\"",
"\\n",
"\"",
")",
"\n\n",
"chunks",
":=",
"DiffChunks",
"(",
"aLines",
",",
"bLines",
")",
"\n\n",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"chunks",
"{",
"for",
"_",
",",
"line",
":=",
"range",
"c",
".",
"Added",
"{",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
",",
"line",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"line",
":=",
"range",
"c",
".",
"Deleted",
"{",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
",",
"line",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"line",
":=",
"range",
"c",
".",
"Equal",
"{",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
",",
"line",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimRight",
"(",
"buf",
".",
"String",
"(",
")",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] |
// Diff returns a string containing a line-by-line unified diff of the linewise
// changes required to make A into B. Each line is prefixed with '+', '-', or
// ' ' to indicate if it should be added, removed, or is correct respectively.
|
[
"Diff",
"returns",
"a",
"string",
"containing",
"a",
"line",
"-",
"by",
"-",
"line",
"unified",
"diff",
"of",
"the",
"linewise",
"changes",
"required",
"to",
"make",
"A",
"into",
"B",
".",
"Each",
"line",
"is",
"prefixed",
"with",
"+",
"-",
"or",
"to",
"indicate",
"if",
"it",
"should",
"be",
"added",
"removed",
"or",
"is",
"correct",
"respectively",
"."
] |
009bb93e63da0d3607040fbc75007ff3e635a5a5
|
https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/diff/diff.go#L41-L60
|
16,007 |
pivotal-cf/brokerapi
|
domain/apiresponses/failure_responses.go
|
ValidatedStatusCode
|
func (f *FailureResponse) ValidatedStatusCode(logger lager.Logger) int {
if f.statusCode < 400 || 600 <= f.statusCode {
if logger != nil {
logger.Error("validating-status-code", fmt.Errorf("Invalid failure http response code: 600, expected 4xx or 5xx, returning internal server error: 500."))
}
return http.StatusInternalServerError
}
return f.statusCode
}
|
go
|
func (f *FailureResponse) ValidatedStatusCode(logger lager.Logger) int {
if f.statusCode < 400 || 600 <= f.statusCode {
if logger != nil {
logger.Error("validating-status-code", fmt.Errorf("Invalid failure http response code: 600, expected 4xx or 5xx, returning internal server error: 500."))
}
return http.StatusInternalServerError
}
return f.statusCode
}
|
[
"func",
"(",
"f",
"*",
"FailureResponse",
")",
"ValidatedStatusCode",
"(",
"logger",
"lager",
".",
"Logger",
")",
"int",
"{",
"if",
"f",
".",
"statusCode",
"<",
"400",
"||",
"600",
"<=",
"f",
".",
"statusCode",
"{",
"if",
"logger",
"!=",
"nil",
"{",
"logger",
".",
"Error",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"return",
"http",
".",
"StatusInternalServerError",
"\n",
"}",
"\n",
"return",
"f",
".",
"statusCode",
"\n",
"}"
] |
// ValidatedStatusCode returns the HTTP response status code. If the code is not 4xx
// or 5xx, an InternalServerError will be returned instead.
|
[
"ValidatedStatusCode",
"returns",
"the",
"HTTP",
"response",
"status",
"code",
".",
"If",
"the",
"code",
"is",
"not",
"4xx",
"or",
"5xx",
"an",
"InternalServerError",
"will",
"be",
"returned",
"instead",
"."
] |
0689a56bf95377293e632db1ad1432b311ff3962
|
https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L49-L57
|
16,008 |
pivotal-cf/brokerapi
|
domain/apiresponses/failure_responses.go
|
AppendErrorMessage
|
func (f *FailureResponse) AppendErrorMessage(msg string) *FailureResponse {
return &FailureResponse{
error: errors.New(fmt.Sprintf("%s %s", f.Error(), msg)),
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
}
|
go
|
func (f *FailureResponse) AppendErrorMessage(msg string) *FailureResponse {
return &FailureResponse{
error: errors.New(fmt.Sprintf("%s %s", f.Error(), msg)),
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
}
|
[
"func",
"(",
"f",
"*",
"FailureResponse",
")",
"AppendErrorMessage",
"(",
"msg",
"string",
")",
"*",
"FailureResponse",
"{",
"return",
"&",
"FailureResponse",
"{",
"error",
":",
"errors",
".",
"New",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"f",
".",
"Error",
"(",
")",
",",
"msg",
")",
")",
",",
"statusCode",
":",
"f",
".",
"statusCode",
",",
"loggerAction",
":",
"f",
".",
"loggerAction",
",",
"emptyResponse",
":",
"f",
".",
"emptyResponse",
",",
"errorKey",
":",
"f",
".",
"errorKey",
",",
"}",
"\n",
"}"
] |
// AppendErrorMessage returns an error with the message updated. All other properties are preserved.
|
[
"AppendErrorMessage",
"returns",
"an",
"error",
"with",
"the",
"message",
"updated",
".",
"All",
"other",
"properties",
"are",
"preserved",
"."
] |
0689a56bf95377293e632db1ad1432b311ff3962
|
https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L65-L73
|
16,009 |
pivotal-cf/brokerapi
|
domain/apiresponses/failure_responses.go
|
NewFailureResponseBuilder
|
func NewFailureResponseBuilder(err error, statusCode int, loggerAction string) *FailureResponseBuilder {
return &FailureResponseBuilder{
error: err,
statusCode: statusCode,
loggerAction: loggerAction,
emptyResponse: false,
}
}
|
go
|
func NewFailureResponseBuilder(err error, statusCode int, loggerAction string) *FailureResponseBuilder {
return &FailureResponseBuilder{
error: err,
statusCode: statusCode,
loggerAction: loggerAction,
emptyResponse: false,
}
}
|
[
"func",
"NewFailureResponseBuilder",
"(",
"err",
"error",
",",
"statusCode",
"int",
",",
"loggerAction",
"string",
")",
"*",
"FailureResponseBuilder",
"{",
"return",
"&",
"FailureResponseBuilder",
"{",
"error",
":",
"err",
",",
"statusCode",
":",
"statusCode",
",",
"loggerAction",
":",
"loggerAction",
",",
"emptyResponse",
":",
"false",
",",
"}",
"\n",
"}"
] |
// NewFailureResponseBuilder returns a pointer to a newly instantiated FailureResponseBuilder
// Accepts required arguments to create a FailureResponse.
|
[
"NewFailureResponseBuilder",
"returns",
"a",
"pointer",
"to",
"a",
"newly",
"instantiated",
"FailureResponseBuilder",
"Accepts",
"required",
"arguments",
"to",
"create",
"a",
"FailureResponse",
"."
] |
0689a56bf95377293e632db1ad1432b311ff3962
|
https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L86-L93
|
16,010 |
pivotal-cf/brokerapi
|
domain/apiresponses/failure_responses.go
|
WithErrorKey
|
func (f *FailureResponseBuilder) WithErrorKey(errorKey string) *FailureResponseBuilder {
f.errorKey = errorKey
return f
}
|
go
|
func (f *FailureResponseBuilder) WithErrorKey(errorKey string) *FailureResponseBuilder {
f.errorKey = errorKey
return f
}
|
[
"func",
"(",
"f",
"*",
"FailureResponseBuilder",
")",
"WithErrorKey",
"(",
"errorKey",
"string",
")",
"*",
"FailureResponseBuilder",
"{",
"f",
".",
"errorKey",
"=",
"errorKey",
"\n",
"return",
"f",
"\n",
"}"
] |
// WithErrorKey adds a custom ErrorKey which will be used in FailureResponse to add an `Error`
// field to the JSON HTTP response body
|
[
"WithErrorKey",
"adds",
"a",
"custom",
"ErrorKey",
"which",
"will",
"be",
"used",
"in",
"FailureResponse",
"to",
"add",
"an",
"Error",
"field",
"to",
"the",
"JSON",
"HTTP",
"response",
"body"
] |
0689a56bf95377293e632db1ad1432b311ff3962
|
https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L97-L100
|
16,011 |
pivotal-cf/brokerapi
|
domain/apiresponses/failure_responses.go
|
Build
|
func (f *FailureResponseBuilder) Build() *FailureResponse {
return &FailureResponse{
error: f.error,
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
}
|
go
|
func (f *FailureResponseBuilder) Build() *FailureResponse {
return &FailureResponse{
error: f.error,
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
}
|
[
"func",
"(",
"f",
"*",
"FailureResponseBuilder",
")",
"Build",
"(",
")",
"*",
"FailureResponse",
"{",
"return",
"&",
"FailureResponse",
"{",
"error",
":",
"f",
".",
"error",
",",
"statusCode",
":",
"f",
".",
"statusCode",
",",
"loggerAction",
":",
"f",
".",
"loggerAction",
",",
"emptyResponse",
":",
"f",
".",
"emptyResponse",
",",
"errorKey",
":",
"f",
".",
"errorKey",
",",
"}",
"\n",
"}"
] |
// Build returns the generated FailureResponse built using previously configured variables.
|
[
"Build",
"returns",
"the",
"generated",
"FailureResponse",
"built",
"using",
"previously",
"configured",
"variables",
"."
] |
0689a56bf95377293e632db1ad1432b311ff3962
|
https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L110-L118
|
16,012 |
jonas747/dca
|
dca.go
|
DecodeFrame
|
func DecodeFrame(r io.Reader) (frame []byte, err error) {
var size int16
err = binary.Read(r, binary.LittleEndian, &size)
if err != nil {
return
}
if size < 0 {
return nil, ErrNegativeFrameSize
}
frame = make([]byte, size)
err = binary.Read(r, binary.LittleEndian, &frame)
return
}
|
go
|
func DecodeFrame(r io.Reader) (frame []byte, err error) {
var size int16
err = binary.Read(r, binary.LittleEndian, &size)
if err != nil {
return
}
if size < 0 {
return nil, ErrNegativeFrameSize
}
frame = make([]byte, size)
err = binary.Read(r, binary.LittleEndian, &frame)
return
}
|
[
"func",
"DecodeFrame",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"frame",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"size",
"int16",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"size",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"size",
"<",
"0",
"{",
"return",
"nil",
",",
"ErrNegativeFrameSize",
"\n",
"}",
"\n\n",
"frame",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"frame",
")",
"\n",
"return",
"\n",
"}"
] |
// DecodeFrame decodes a dca frame from an io.Reader and returns the raw opus audio ready to be sent to discord
|
[
"DecodeFrame",
"decodes",
"a",
"dca",
"frame",
"from",
"an",
"io",
".",
"Reader",
"and",
"returns",
"the",
"raw",
"opus",
"audio",
"ready",
"to",
"be",
"sent",
"to",
"discord"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/dca.go#L54-L68
|
16,013 |
jonas747/dca
|
decode.go
|
NewDecoder
|
func NewDecoder(r io.Reader) *Decoder {
decoder := &Decoder{
r: bufio.NewReader(r),
}
return decoder
}
|
go
|
func NewDecoder(r io.Reader) *Decoder {
decoder := &Decoder{
r: bufio.NewReader(r),
}
return decoder
}
|
[
"func",
"NewDecoder",
"(",
"r",
"io",
".",
"Reader",
")",
"*",
"Decoder",
"{",
"decoder",
":=",
"&",
"Decoder",
"{",
"r",
":",
"bufio",
".",
"NewReader",
"(",
"r",
")",
",",
"}",
"\n\n",
"return",
"decoder",
"\n",
"}"
] |
// NewDecoder returns a new dca decoder
|
[
"NewDecoder",
"returns",
"a",
"new",
"dca",
"decoder"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L29-L35
|
16,014 |
jonas747/dca
|
decode.go
|
ReadMetadata
|
func (d *Decoder) ReadMetadata() error {
if d.firstFrameProcessed {
return ErrNotFirstFrame
}
d.firstFrameProcessed = true
fingerprint, err := d.r.Peek(4)
if err != nil {
return err
}
if string(fingerprint[:3]) != "DCA" {
return ErrNotDCA
}
// We just peeked earlier, mark this portion as read
d.r.Discard(4)
// Read the format version
version, err := strconv.ParseInt(string(fingerprint[3:]), 10, 32)
if err != nil {
return err
}
d.FormatVersion = int(version)
// The length of the metadata
var metaLen int32
err = binary.Read(d.r, binary.LittleEndian, &metaLen)
if err != nil {
return err
}
// Read in the metadata itself
jsonBuf := make([]byte, metaLen)
err = binary.Read(d.r, binary.LittleEndian, &jsonBuf)
if err != nil {
return err
}
// And unmarshal it
var metadata *Metadata
err = json.Unmarshal(jsonBuf, &metadata)
d.Metadata = metadata
return err
}
|
go
|
func (d *Decoder) ReadMetadata() error {
if d.firstFrameProcessed {
return ErrNotFirstFrame
}
d.firstFrameProcessed = true
fingerprint, err := d.r.Peek(4)
if err != nil {
return err
}
if string(fingerprint[:3]) != "DCA" {
return ErrNotDCA
}
// We just peeked earlier, mark this portion as read
d.r.Discard(4)
// Read the format version
version, err := strconv.ParseInt(string(fingerprint[3:]), 10, 32)
if err != nil {
return err
}
d.FormatVersion = int(version)
// The length of the metadata
var metaLen int32
err = binary.Read(d.r, binary.LittleEndian, &metaLen)
if err != nil {
return err
}
// Read in the metadata itself
jsonBuf := make([]byte, metaLen)
err = binary.Read(d.r, binary.LittleEndian, &jsonBuf)
if err != nil {
return err
}
// And unmarshal it
var metadata *Metadata
err = json.Unmarshal(jsonBuf, &metadata)
d.Metadata = metadata
return err
}
|
[
"func",
"(",
"d",
"*",
"Decoder",
")",
"ReadMetadata",
"(",
")",
"error",
"{",
"if",
"d",
".",
"firstFrameProcessed",
"{",
"return",
"ErrNotFirstFrame",
"\n",
"}",
"\n",
"d",
".",
"firstFrameProcessed",
"=",
"true",
"\n\n",
"fingerprint",
",",
"err",
":=",
"d",
".",
"r",
".",
"Peek",
"(",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"string",
"(",
"fingerprint",
"[",
":",
"3",
"]",
")",
"!=",
"\"",
"\"",
"{",
"return",
"ErrNotDCA",
"\n",
"}",
"\n\n",
"// We just peeked earlier, mark this portion as read",
"d",
".",
"r",
".",
"Discard",
"(",
"4",
")",
"\n\n",
"// Read the format version",
"version",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"string",
"(",
"fingerprint",
"[",
"3",
":",
"]",
")",
",",
"10",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"d",
".",
"FormatVersion",
"=",
"int",
"(",
"version",
")",
"\n\n",
"// The length of the metadata",
"var",
"metaLen",
"int32",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"d",
".",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"metaLen",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Read in the metadata itself",
"jsonBuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"metaLen",
")",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"d",
".",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"jsonBuf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// And unmarshal it",
"var",
"metadata",
"*",
"Metadata",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"jsonBuf",
",",
"&",
"metadata",
")",
"\n",
"d",
".",
"Metadata",
"=",
"metadata",
"\n",
"return",
"err",
"\n",
"}"
] |
// ReadMetadata reads the first metadata frame
// OpusFrame will call this automatically if
|
[
"ReadMetadata",
"reads",
"the",
"first",
"metadata",
"frame",
"OpusFrame",
"will",
"call",
"this",
"automatically",
"if"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L39-L83
|
16,015 |
jonas747/dca
|
decode.go
|
OpusFrame
|
func (d *Decoder) OpusFrame() (frame []byte, err error) {
if !d.firstFrameProcessed {
// Check to see if this contains metadata and read the metadata if so
magic, err := d.r.Peek(3)
if err != nil {
return nil, err
}
if string(magic) == "DCA" {
err = d.ReadMetadata()
if err != nil {
return nil, err
}
}
}
frame, err = DecodeFrame(d.r)
return
}
|
go
|
func (d *Decoder) OpusFrame() (frame []byte, err error) {
if !d.firstFrameProcessed {
// Check to see if this contains metadata and read the metadata if so
magic, err := d.r.Peek(3)
if err != nil {
return nil, err
}
if string(magic) == "DCA" {
err = d.ReadMetadata()
if err != nil {
return nil, err
}
}
}
frame, err = DecodeFrame(d.r)
return
}
|
[
"func",
"(",
"d",
"*",
"Decoder",
")",
"OpusFrame",
"(",
")",
"(",
"frame",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"if",
"!",
"d",
".",
"firstFrameProcessed",
"{",
"// Check to see if this contains metadata and read the metadata if so",
"magic",
",",
"err",
":=",
"d",
".",
"r",
".",
"Peek",
"(",
"3",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"string",
"(",
"magic",
")",
"==",
"\"",
"\"",
"{",
"err",
"=",
"d",
".",
"ReadMetadata",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"frame",
",",
"err",
"=",
"DecodeFrame",
"(",
"d",
".",
"r",
")",
"\n",
"return",
"\n",
"}"
] |
// OpusFrame returns the next audio frame
// If this is the first frame it will also check for metadata in it
|
[
"OpusFrame",
"returns",
"the",
"next",
"audio",
"frame",
"If",
"this",
"is",
"the",
"first",
"frame",
"it",
"will",
"also",
"check",
"for",
"metadata",
"in",
"it"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L87-L105
|
16,016 |
jonas747/dca
|
decode.go
|
FrameDuration
|
func (d *Decoder) FrameDuration() time.Duration {
if d.Metadata == nil {
return 20
}
// I don't understand nick, why does it have to be like this nick, please nick, im not having a good time nick.
// 960B = pcm framesize of 20ms 1 channel audio
return time.Duration(((d.Metadata.Opus.FrameSize/d.Metadata.Opus.Channels)/960)*20) * time.Millisecond
}
|
go
|
func (d *Decoder) FrameDuration() time.Duration {
if d.Metadata == nil {
return 20
}
// I don't understand nick, why does it have to be like this nick, please nick, im not having a good time nick.
// 960B = pcm framesize of 20ms 1 channel audio
return time.Duration(((d.Metadata.Opus.FrameSize/d.Metadata.Opus.Channels)/960)*20) * time.Millisecond
}
|
[
"func",
"(",
"d",
"*",
"Decoder",
")",
"FrameDuration",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"d",
".",
"Metadata",
"==",
"nil",
"{",
"return",
"20",
"\n",
"}",
"\n\n",
"// I don't understand nick, why does it have to be like this nick, please nick, im not having a good time nick.",
"// 960B = pcm framesize of 20ms 1 channel audio",
"return",
"time",
".",
"Duration",
"(",
"(",
"(",
"d",
".",
"Metadata",
".",
"Opus",
".",
"FrameSize",
"/",
"d",
".",
"Metadata",
".",
"Opus",
".",
"Channels",
")",
"/",
"960",
")",
"*",
"20",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"}"
] |
// FrameDuration implements OpusReader, returnining the specified duration per frame
|
[
"FrameDuration",
"implements",
"OpusReader",
"returnining",
"the",
"specified",
"duration",
"per",
"frame"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L108-L116
|
16,017 |
jonas747/dca
|
stream.go
|
PlaybackPosition
|
func (s *StreamingSession) PlaybackPosition() time.Duration {
s.Lock()
dur := time.Duration(s.framesSent) * s.source.FrameDuration()
s.Unlock()
return dur
}
|
go
|
func (s *StreamingSession) PlaybackPosition() time.Duration {
s.Lock()
dur := time.Duration(s.framesSent) * s.source.FrameDuration()
s.Unlock()
return dur
}
|
[
"func",
"(",
"s",
"*",
"StreamingSession",
")",
"PlaybackPosition",
"(",
")",
"time",
".",
"Duration",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"dur",
":=",
"time",
".",
"Duration",
"(",
"s",
".",
"framesSent",
")",
"*",
"s",
".",
"source",
".",
"FrameDuration",
"(",
")",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n",
"return",
"dur",
"\n",
"}"
] |
// PlaybackPosition returns the the duration of content we have transmitted so far
|
[
"PlaybackPosition",
"returns",
"the",
"the",
"duration",
"of",
"content",
"we",
"have",
"transmitted",
"so",
"far"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/stream.go#L160-L165
|
16,018 |
jonas747/dca
|
stream.go
|
Finished
|
func (s *StreamingSession) Finished() (bool, error) {
s.Lock()
err := s.err
fin := s.finished
s.Unlock()
return fin, err
}
|
go
|
func (s *StreamingSession) Finished() (bool, error) {
s.Lock()
err := s.err
fin := s.finished
s.Unlock()
return fin, err
}
|
[
"func",
"(",
"s",
"*",
"StreamingSession",
")",
"Finished",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"err",
":=",
"s",
".",
"err",
"\n",
"fin",
":=",
"s",
".",
"finished",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"fin",
",",
"err",
"\n",
"}"
] |
// Finished returns wether the stream finished or not, and any error that caused it to stop
|
[
"Finished",
"returns",
"wether",
"the",
"stream",
"finished",
"or",
"not",
"and",
"any",
"error",
"that",
"caused",
"it",
"to",
"stop"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/stream.go#L168-L175
|
16,019 |
jonas747/dca
|
stream.go
|
Paused
|
func (s *StreamingSession) Paused() bool {
s.Lock()
p := s.paused
s.Unlock()
return p
}
|
go
|
func (s *StreamingSession) Paused() bool {
s.Lock()
p := s.paused
s.Unlock()
return p
}
|
[
"func",
"(",
"s",
"*",
"StreamingSession",
")",
"Paused",
"(",
")",
"bool",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"p",
":=",
"s",
".",
"paused",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
"\n",
"}"
] |
// Paused returns wether the sream is paused or not
|
[
"Paused",
"returns",
"wether",
"the",
"sream",
"is",
"paused",
"or",
"not"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/stream.go#L178-L184
|
16,020 |
jonas747/dca
|
encode.go
|
Validate
|
func (opts *EncodeOptions) Validate() error {
if opts.Volume < 0 || opts.Volume > 512 {
return errors.New("Out of bounds volume (0-512)")
}
if opts.FrameDuration != 20 && opts.FrameDuration != 40 && opts.FrameDuration != 60 {
return errors.New("Invalid FrameDuration")
}
if opts.PacketLoss < 0 || opts.PacketLoss > 100 {
return errors.New("Invalid packet loss percentage")
}
if opts.Application != AudioApplicationAudio && opts.Application != AudioApplicationVoip && opts.Application != AudioApplicationLowDelay {
return errors.New("Invalid audio application")
}
if opts.CompressionLevel < 0 || opts.CompressionLevel > 10 {
return errors.New("Compression level out of bounds (0-10)")
}
if opts.Threads < 0 {
return errors.New("Number of threads can't be less than 0")
}
return nil
}
|
go
|
func (opts *EncodeOptions) Validate() error {
if opts.Volume < 0 || opts.Volume > 512 {
return errors.New("Out of bounds volume (0-512)")
}
if opts.FrameDuration != 20 && opts.FrameDuration != 40 && opts.FrameDuration != 60 {
return errors.New("Invalid FrameDuration")
}
if opts.PacketLoss < 0 || opts.PacketLoss > 100 {
return errors.New("Invalid packet loss percentage")
}
if opts.Application != AudioApplicationAudio && opts.Application != AudioApplicationVoip && opts.Application != AudioApplicationLowDelay {
return errors.New("Invalid audio application")
}
if opts.CompressionLevel < 0 || opts.CompressionLevel > 10 {
return errors.New("Compression level out of bounds (0-10)")
}
if opts.Threads < 0 {
return errors.New("Number of threads can't be less than 0")
}
return nil
}
|
[
"func",
"(",
"opts",
"*",
"EncodeOptions",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"opts",
".",
"Volume",
"<",
"0",
"||",
"opts",
".",
"Volume",
">",
"512",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"FrameDuration",
"!=",
"20",
"&&",
"opts",
".",
"FrameDuration",
"!=",
"40",
"&&",
"opts",
".",
"FrameDuration",
"!=",
"60",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"PacketLoss",
"<",
"0",
"||",
"opts",
".",
"PacketLoss",
">",
"100",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"Application",
"!=",
"AudioApplicationAudio",
"&&",
"opts",
".",
"Application",
"!=",
"AudioApplicationVoip",
"&&",
"opts",
".",
"Application",
"!=",
"AudioApplicationLowDelay",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"CompressionLevel",
"<",
"0",
"||",
"opts",
".",
"CompressionLevel",
">",
"10",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"Threads",
"<",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Validate returns an error if the options are not correct
|
[
"Validate",
"returns",
"an",
"error",
"if",
"the",
"options",
"are",
"not",
"correct"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L65-L91
|
16,021 |
jonas747/dca
|
encode.go
|
EncodeMem
|
func EncodeMem(r io.Reader, options *EncodeOptions) (session *EncodeSession, err error) {
err = options.Validate()
if err != nil {
return
}
session = &EncodeSession{
options: options,
pipeReader: r,
frameChannel: make(chan *Frame, options.BufferedFrames),
}
go session.run()
return
}
|
go
|
func EncodeMem(r io.Reader, options *EncodeOptions) (session *EncodeSession, err error) {
err = options.Validate()
if err != nil {
return
}
session = &EncodeSession{
options: options,
pipeReader: r,
frameChannel: make(chan *Frame, options.BufferedFrames),
}
go session.run()
return
}
|
[
"func",
"EncodeMem",
"(",
"r",
"io",
".",
"Reader",
",",
"options",
"*",
"EncodeOptions",
")",
"(",
"session",
"*",
"EncodeSession",
",",
"err",
"error",
")",
"{",
"err",
"=",
"options",
".",
"Validate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"session",
"=",
"&",
"EncodeSession",
"{",
"options",
":",
"options",
",",
"pipeReader",
":",
"r",
",",
"frameChannel",
":",
"make",
"(",
"chan",
"*",
"Frame",
",",
"options",
".",
"BufferedFrames",
")",
",",
"}",
"\n",
"go",
"session",
".",
"run",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// EncodedMem encodes data from memory
|
[
"EncodedMem",
"encodes",
"data",
"from",
"memory"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L143-L156
|
16,022 |
jonas747/dca
|
encode.go
|
Stop
|
func (e *EncodeSession) Stop() error {
e.Lock()
defer e.Unlock()
if !e.running || e.process == nil {
return errors.New("Not running")
}
err := e.process.Kill()
return err
}
|
go
|
func (e *EncodeSession) Stop() error {
e.Lock()
defer e.Unlock()
if !e.running || e.process == nil {
return errors.New("Not running")
}
err := e.process.Kill()
return err
}
|
[
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"Stop",
"(",
")",
"error",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"e",
".",
"running",
"||",
"e",
".",
"process",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"e",
".",
"process",
".",
"Kill",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Stop stops the encoding session
|
[
"Stop",
"stops",
"the",
"encoding",
"session"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L541-L550
|
16,023 |
jonas747/dca
|
encode.go
|
OpusFrame
|
func (e *EncodeSession) OpusFrame() (frame []byte, err error) {
f := <-e.frameChannel
if f == nil {
return nil, io.EOF
}
if f.metaData {
// Return the next one then...
return e.OpusFrame()
}
if len(f.data) < 2 {
return nil, ErrBadFrame
}
return f.data[2:], nil
}
|
go
|
func (e *EncodeSession) OpusFrame() (frame []byte, err error) {
f := <-e.frameChannel
if f == nil {
return nil, io.EOF
}
if f.metaData {
// Return the next one then...
return e.OpusFrame()
}
if len(f.data) < 2 {
return nil, ErrBadFrame
}
return f.data[2:], nil
}
|
[
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"OpusFrame",
"(",
")",
"(",
"frame",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"f",
":=",
"<-",
"e",
".",
"frameChannel",
"\n",
"if",
"f",
"==",
"nil",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"metaData",
"{",
"// Return the next one then...",
"return",
"e",
".",
"OpusFrame",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"f",
".",
"data",
")",
"<",
"2",
"{",
"return",
"nil",
",",
"ErrBadFrame",
"\n",
"}",
"\n\n",
"return",
"f",
".",
"data",
"[",
"2",
":",
"]",
",",
"nil",
"\n",
"}"
] |
// OpusFrame implements OpusReader, returning the next opus frame
|
[
"OpusFrame",
"implements",
"OpusReader",
"returning",
"the",
"next",
"opus",
"frame"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L564-L580
|
16,024 |
jonas747/dca
|
encode.go
|
Running
|
func (e *EncodeSession) Running() (running bool) {
e.Lock()
running = e.running
e.Unlock()
return
}
|
go
|
func (e *EncodeSession) Running() (running bool) {
e.Lock()
running = e.running
e.Unlock()
return
}
|
[
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"Running",
"(",
")",
"(",
"running",
"bool",
")",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"running",
"=",
"e",
".",
"running",
"\n",
"e",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// Running returns true if running
|
[
"Running",
"returns",
"true",
"if",
"running"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L583-L588
|
16,025 |
jonas747/dca
|
encode.go
|
FrameDuration
|
func (e *EncodeSession) FrameDuration() time.Duration {
return time.Duration(e.options.FrameDuration) * time.Millisecond
}
|
go
|
func (e *EncodeSession) FrameDuration() time.Duration {
return time.Duration(e.options.FrameDuration) * time.Millisecond
}
|
[
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"FrameDuration",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Duration",
"(",
"e",
".",
"options",
".",
"FrameDuration",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"}"
] |
// FrameDuration implements OpusReader, retruning the duratio of each frame
|
[
"FrameDuration",
"implements",
"OpusReader",
"retruning",
"the",
"duratio",
"of",
"each",
"frame"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L646-L648
|
16,026 |
jonas747/dca
|
encode.go
|
Error
|
func (e *EncodeSession) Error() error {
e.Lock()
defer e.Unlock()
return e.err
}
|
go
|
func (e *EncodeSession) Error() error {
e.Lock()
defer e.Unlock()
return e.err
}
|
[
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"Error",
"(",
")",
"error",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"Unlock",
"(",
")",
"\n",
"return",
"e",
".",
"err",
"\n",
"}"
] |
// Error returns any error that occured during the encoding process
|
[
"Error",
"returns",
"any",
"error",
"that",
"occured",
"during",
"the",
"encoding",
"process"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L651-L655
|
16,027 |
jonas747/dca
|
encode.go
|
FFMPEGMessages
|
func (e *EncodeSession) FFMPEGMessages() string {
e.Lock()
output := e.ffmpegOutput
e.Unlock()
return output
}
|
go
|
func (e *EncodeSession) FFMPEGMessages() string {
e.Lock()
output := e.ffmpegOutput
e.Unlock()
return output
}
|
[
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"FFMPEGMessages",
"(",
")",
"string",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"output",
":=",
"e",
".",
"ffmpegOutput",
"\n",
"e",
".",
"Unlock",
"(",
")",
"\n",
"return",
"output",
"\n",
"}"
] |
// FFMPEGMessages returns messages printed by ffmpeg to stderr, you can use this to see what ffmpeg is saying if your encoding fails
|
[
"FFMPEGMessages",
"returns",
"messages",
"printed",
"by",
"ffmpeg",
"to",
"stderr",
"you",
"can",
"use",
"this",
"to",
"see",
"what",
"ffmpeg",
"is",
"saying",
"if",
"your",
"encoding",
"fails"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L658-L663
|
16,028 |
jonas747/dca
|
cmd/dca/main.go
|
init
|
func init() {
flag.StringVar(&InFile, "i", "pipe:0", "infile")
flag.IntVar(&Volume, "vol", 256, "change audio volume (256=normal)")
flag.IntVar(&Channels, "ac", 2, "audio channels")
flag.IntVar(&FrameRate, "ar", 48000, "audio sampling rate")
flag.IntVar(&FrameDuration, "as", 20, "audio frame duration can be 20, 40, or 60 (ms)")
flag.IntVar(&Bitrate, "ab", 128, "audio encoding bitrate in kb/s can be 8 - 128")
flag.IntVar(&Threads, "threads", 0, "number of threads to use, 0 for auto")
flag.BoolVar(&VBR, "vbr", true, "variable bitrate")
flag.BoolVar(&RawOutput, "raw", false, "Raw opus output (no metadata or magic bytes)")
flag.StringVar(&Application, "aa", "audio", "audio application can be voip, audio, or lowdelay")
flag.StringVar(&CoverFormat, "cf", "jpeg", "format the cover art will be encoded with")
flag.StringVar(&Comment, "com", "", "leave a comment in the metadata")
flag.BoolVar(&Quiet, "quiet", false, "disable stats output to stderr")
flag.Parse()
}
|
go
|
func init() {
flag.StringVar(&InFile, "i", "pipe:0", "infile")
flag.IntVar(&Volume, "vol", 256, "change audio volume (256=normal)")
flag.IntVar(&Channels, "ac", 2, "audio channels")
flag.IntVar(&FrameRate, "ar", 48000, "audio sampling rate")
flag.IntVar(&FrameDuration, "as", 20, "audio frame duration can be 20, 40, or 60 (ms)")
flag.IntVar(&Bitrate, "ab", 128, "audio encoding bitrate in kb/s can be 8 - 128")
flag.IntVar(&Threads, "threads", 0, "number of threads to use, 0 for auto")
flag.BoolVar(&VBR, "vbr", true, "variable bitrate")
flag.BoolVar(&RawOutput, "raw", false, "Raw opus output (no metadata or magic bytes)")
flag.StringVar(&Application, "aa", "audio", "audio application can be voip, audio, or lowdelay")
flag.StringVar(&CoverFormat, "cf", "jpeg", "format the cover art will be encoded with")
flag.StringVar(&Comment, "com", "", "leave a comment in the metadata")
flag.BoolVar(&Quiet, "quiet", false, "disable stats output to stderr")
flag.Parse()
}
|
[
"func",
"init",
"(",
")",
"{",
"flag",
".",
"StringVar",
"(",
"&",
"InFile",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"Volume",
",",
"\"",
"\"",
",",
"256",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"Channels",
",",
"\"",
"\"",
",",
"2",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"FrameRate",
",",
"\"",
"\"",
",",
"48000",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"FrameDuration",
",",
"\"",
"\"",
",",
"20",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"Bitrate",
",",
"\"",
"\"",
",",
"128",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"Threads",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"BoolVar",
"(",
"&",
"VBR",
",",
"\"",
"\"",
",",
"true",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"BoolVar",
"(",
"&",
"RawOutput",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"StringVar",
"(",
"&",
"Application",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"StringVar",
"(",
"&",
"CoverFormat",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"StringVar",
"(",
"&",
"Comment",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"BoolVar",
"(",
"&",
"Quiet",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n\n",
"flag",
".",
"Parse",
"(",
")",
"\n",
"}"
] |
// init configures and parses the command line arguments
|
[
"init",
"configures",
"and",
"parses",
"the",
"command",
"line",
"arguments"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/cmd/dca/main.go#L59-L76
|
16,029 |
jonas747/dca
|
cmd/dca/main.go
|
main
|
func main() {
//////////////////////////////////////////////////////////////////////////
// BLOCK : Basic setup and validation
//////////////////////////////////////////////////////////////////////////
// If only one argument provided assume it's a filename.
if len(os.Args) == 2 {
InFile = os.Args[1]
}
// If reading from a file, verify it exists.
if InFile != "pipe:0" {
if _, err := os.Stat(InFile); os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "warning: infile does not exist as a file on this system, will still continue on incase this is something else that ffmpeg accepts")
}
}
// If reading from pipe, make sure pipe is open
if InFile == "pipe:0" {
fi, err := os.Stdin.Stat()
if err != nil {
fmt.Println(err)
return
}
if (fi.Mode() & os.ModeCharDevice) == 0 {
} else {
fmt.Fprintln(os.Stderr, "error: stdin is not a pipe.")
flag.Usage()
return
}
}
if Bitrate < 1 || Bitrate > 512 {
Bitrate = 64 // Set to Discord default
}
//////////////////////////////////////////////////////////////////////////
// BLOCK : Start reader and writer workers
//////////////////////////////////////////////////////////////////////////
options := &dca.EncodeOptions{
Volume: Volume,
Channels: Channels,
FrameRate: FrameRate,
FrameDuration: FrameDuration,
Bitrate: Bitrate,
RawOutput: RawOutput,
Application: dca.AudioApplication(Application),
CoverFormat: CoverFormat,
VBR: VBR,
Comment: Comment,
Threads: Threads,
}
var session *dca.EncodeSession
var output = os.Stdout
if InFile == "pipe:0" {
session, err = dca.EncodeMem(os.Stdin, options)
} else {
session, err = dca.EncodeFile(InFile, options)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Failed creating an encoding session: ", err)
os.Exit(1)
}
if !Quiet {
go statusPrinter(session)
}
_, err := io.Copy(output, session)
if err != nil {
fmt.Fprintln(os.Stderr, "\nError writing:", err)
os.Exit(1)
} else if !Quiet {
fmt.Fprintf(os.Stderr, "\nFinished encoding\n")
fmt.Fprint(os.Stderr, "ffmpeg output\n\n", session.FFMPEGMessages())
}
}
|
go
|
func main() {
//////////////////////////////////////////////////////////////////////////
// BLOCK : Basic setup and validation
//////////////////////////////////////////////////////////////////////////
// If only one argument provided assume it's a filename.
if len(os.Args) == 2 {
InFile = os.Args[1]
}
// If reading from a file, verify it exists.
if InFile != "pipe:0" {
if _, err := os.Stat(InFile); os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "warning: infile does not exist as a file on this system, will still continue on incase this is something else that ffmpeg accepts")
}
}
// If reading from pipe, make sure pipe is open
if InFile == "pipe:0" {
fi, err := os.Stdin.Stat()
if err != nil {
fmt.Println(err)
return
}
if (fi.Mode() & os.ModeCharDevice) == 0 {
} else {
fmt.Fprintln(os.Stderr, "error: stdin is not a pipe.")
flag.Usage()
return
}
}
if Bitrate < 1 || Bitrate > 512 {
Bitrate = 64 // Set to Discord default
}
//////////////////////////////////////////////////////////////////////////
// BLOCK : Start reader and writer workers
//////////////////////////////////////////////////////////////////////////
options := &dca.EncodeOptions{
Volume: Volume,
Channels: Channels,
FrameRate: FrameRate,
FrameDuration: FrameDuration,
Bitrate: Bitrate,
RawOutput: RawOutput,
Application: dca.AudioApplication(Application),
CoverFormat: CoverFormat,
VBR: VBR,
Comment: Comment,
Threads: Threads,
}
var session *dca.EncodeSession
var output = os.Stdout
if InFile == "pipe:0" {
session, err = dca.EncodeMem(os.Stdin, options)
} else {
session, err = dca.EncodeFile(InFile, options)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Failed creating an encoding session: ", err)
os.Exit(1)
}
if !Quiet {
go statusPrinter(session)
}
_, err := io.Copy(output, session)
if err != nil {
fmt.Fprintln(os.Stderr, "\nError writing:", err)
os.Exit(1)
} else if !Quiet {
fmt.Fprintf(os.Stderr, "\nFinished encoding\n")
fmt.Fprint(os.Stderr, "ffmpeg output\n\n", session.FFMPEGMessages())
}
}
|
[
"func",
"main",
"(",
")",
"{",
"//////////////////////////////////////////////////////////////////////////",
"// BLOCK : Basic setup and validation",
"//////////////////////////////////////////////////////////////////////////",
"// If only one argument provided assume it's a filename.",
"if",
"len",
"(",
"os",
".",
"Args",
")",
"==",
"2",
"{",
"InFile",
"=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n",
"}",
"\n\n",
"// If reading from a file, verify it exists.",
"if",
"InFile",
"!=",
"\"",
"\"",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"InFile",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If reading from pipe, make sure pipe is open",
"if",
"InFile",
"==",
"\"",
"\"",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stdin",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"(",
"fi",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeCharDevice",
")",
"==",
"0",
"{",
"}",
"else",
"{",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"Usage",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"Bitrate",
"<",
"1",
"||",
"Bitrate",
">",
"512",
"{",
"Bitrate",
"=",
"64",
"// Set to Discord default",
"\n",
"}",
"\n\n",
"//////////////////////////////////////////////////////////////////////////",
"// BLOCK : Start reader and writer workers",
"//////////////////////////////////////////////////////////////////////////",
"options",
":=",
"&",
"dca",
".",
"EncodeOptions",
"{",
"Volume",
":",
"Volume",
",",
"Channels",
":",
"Channels",
",",
"FrameRate",
":",
"FrameRate",
",",
"FrameDuration",
":",
"FrameDuration",
",",
"Bitrate",
":",
"Bitrate",
",",
"RawOutput",
":",
"RawOutput",
",",
"Application",
":",
"dca",
".",
"AudioApplication",
"(",
"Application",
")",
",",
"CoverFormat",
":",
"CoverFormat",
",",
"VBR",
":",
"VBR",
",",
"Comment",
":",
"Comment",
",",
"Threads",
":",
"Threads",
",",
"}",
"\n\n",
"var",
"session",
"*",
"dca",
".",
"EncodeSession",
"\n",
"var",
"output",
"=",
"os",
".",
"Stdout",
"\n\n",
"if",
"InFile",
"==",
"\"",
"\"",
"{",
"session",
",",
"err",
"=",
"dca",
".",
"EncodeMem",
"(",
"os",
".",
"Stdin",
",",
"options",
")",
"\n",
"}",
"else",
"{",
"session",
",",
"err",
"=",
"dca",
".",
"EncodeFile",
"(",
"InFile",
",",
"options",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"Quiet",
"{",
"go",
"statusPrinter",
"(",
"session",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"output",
",",
"session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"else",
"if",
"!",
"Quiet",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\\n",
"\"",
")",
"\n",
"fmt",
".",
"Fprint",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\\n",
"\"",
",",
"session",
".",
"FFMPEGMessages",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// very simple program that wraps ffmpeg and outputs raw opus data frames
// with a uint16 header for each frame with the frame length in bytes
|
[
"very",
"simple",
"program",
"that",
"wraps",
"ffmpeg",
"and",
"outputs",
"raw",
"opus",
"data",
"frames",
"with",
"a",
"uint16",
"header",
"for",
"each",
"frame",
"with",
"the",
"frame",
"length",
"in",
"bytes"
] |
10e959e9d3e808cd961308760de0c1c36285fed7
|
https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/cmd/dca/main.go#L80-L162
|
16,030 |
aerokube/ggr
|
proxy.go
|
WithSuitableAuthentication
|
func WithSuitableAuthentication(authenticator *auth.BasicAuth, handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
if !guestAccessAllowed {
//All requests require authentication
requireBasicAuth(authenticator, handler)(w, r)
} else if _, _, basicAuthPresent := r.BasicAuth(); !basicAuthPresent {
//Run the handler as unauthenticated user
confLock.RLock()
_, ok := quota[guestUserName]
confLock.RUnlock()
if !ok {
reply(w, errMsg("Guest access is unavailable"), http.StatusUnauthorized)
} else {
handler(w, r)
}
} else {
//Run the handler using basic authentication
if fileExists(users) {
requireBasicAuth(authenticator, handler)(w, r)
} else {
handler(w, r)
}
}
}
}
|
go
|
func WithSuitableAuthentication(authenticator *auth.BasicAuth, handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
if !guestAccessAllowed {
//All requests require authentication
requireBasicAuth(authenticator, handler)(w, r)
} else if _, _, basicAuthPresent := r.BasicAuth(); !basicAuthPresent {
//Run the handler as unauthenticated user
confLock.RLock()
_, ok := quota[guestUserName]
confLock.RUnlock()
if !ok {
reply(w, errMsg("Guest access is unavailable"), http.StatusUnauthorized)
} else {
handler(w, r)
}
} else {
//Run the handler using basic authentication
if fileExists(users) {
requireBasicAuth(authenticator, handler)(w, r)
} else {
handler(w, r)
}
}
}
}
|
[
"func",
"WithSuitableAuthentication",
"(",
"authenticator",
"*",
"auth",
".",
"BasicAuth",
",",
"handler",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
")",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"!",
"guestAccessAllowed",
"{",
"//All requests require authentication",
"requireBasicAuth",
"(",
"authenticator",
",",
"handler",
")",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"else",
"if",
"_",
",",
"_",
",",
"basicAuthPresent",
":=",
"r",
".",
"BasicAuth",
"(",
")",
";",
"!",
"basicAuthPresent",
"{",
"//Run the handler as unauthenticated user",
"confLock",
".",
"RLock",
"(",
")",
"\n",
"_",
",",
"ok",
":=",
"quota",
"[",
"guestUserName",
"]",
"\n",
"confLock",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"reply",
"(",
"w",
",",
"errMsg",
"(",
"\"",
"\"",
")",
",",
"http",
".",
"StatusUnauthorized",
")",
"\n",
"}",
"else",
"{",
"handler",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"//Run the handler using basic authentication",
"if",
"fileExists",
"(",
"users",
")",
"{",
"requireBasicAuth",
"(",
"authenticator",
",",
"handler",
")",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"else",
"{",
"handler",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
//WithSuitableAuthentication handles basic authentication and guest quota processing
|
[
"WithSuitableAuthentication",
"handles",
"basic",
"authentication",
"and",
"guest",
"quota",
"processing"
] |
7fd402dceba08932f755f8ea29295e4826c025ee
|
https://github.com/aerokube/ggr/blob/7fd402dceba08932f755f8ea29295e4826c025ee/proxy.go#L589-L613
|
16,031 |
nu7hatch/gouuid
|
uuid.go
|
Parse
|
func Parse(b []byte) (u *UUID, err error) {
if len(b) != 16 {
err = errors.New("Given slice is not valid UUID sequence")
return
}
u = new(UUID)
copy(u[:], b)
return
}
|
go
|
func Parse(b []byte) (u *UUID, err error) {
if len(b) != 16 {
err = errors.New("Given slice is not valid UUID sequence")
return
}
u = new(UUID)
copy(u[:], b)
return
}
|
[
"func",
"Parse",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"b",
")",
"!=",
"16",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"u",
"=",
"new",
"(",
"UUID",
")",
"\n",
"copy",
"(",
"u",
"[",
":",
"]",
",",
"b",
")",
"\n",
"return",
"\n",
"}"
] |
// Parse creates a UUID object from given bytes slice.
|
[
"Parse",
"creates",
"a",
"UUID",
"object",
"from",
"given",
"bytes",
"slice",
"."
] |
179d4d0c4d8d407a32af483c2354df1d2c91e6c3
|
https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L73-L81
|
16,032 |
nu7hatch/gouuid
|
uuid.go
|
NewV3
|
func NewV3(ns *UUID, name []byte) (u *UUID, err error) {
if ns == nil {
err = errors.New("Invalid namespace UUID")
return
}
u = new(UUID)
// Set all bits to MD5 hash generated from namespace and name.
u.setBytesFromHash(md5.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(3)
return
}
|
go
|
func NewV3(ns *UUID, name []byte) (u *UUID, err error) {
if ns == nil {
err = errors.New("Invalid namespace UUID")
return
}
u = new(UUID)
// Set all bits to MD5 hash generated from namespace and name.
u.setBytesFromHash(md5.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(3)
return
}
|
[
"func",
"NewV3",
"(",
"ns",
"*",
"UUID",
",",
"name",
"[",
"]",
"byte",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"if",
"ns",
"==",
"nil",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"u",
"=",
"new",
"(",
"UUID",
")",
"\n",
"// Set all bits to MD5 hash generated from namespace and name.",
"u",
".",
"setBytesFromHash",
"(",
"md5",
".",
"New",
"(",
")",
",",
"ns",
"[",
":",
"]",
",",
"name",
")",
"\n",
"u",
".",
"setVariant",
"(",
"ReservedRFC4122",
")",
"\n",
"u",
".",
"setVersion",
"(",
"3",
")",
"\n",
"return",
"\n",
"}"
] |
// Generate a UUID based on the MD5 hash of a namespace identifier
// and a name.
|
[
"Generate",
"a",
"UUID",
"based",
"on",
"the",
"MD5",
"hash",
"of",
"a",
"namespace",
"identifier",
"and",
"a",
"name",
"."
] |
179d4d0c4d8d407a32af483c2354df1d2c91e6c3
|
https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L85-L96
|
16,033 |
nu7hatch/gouuid
|
uuid.go
|
NewV4
|
func NewV4() (u *UUID, err error) {
u = new(UUID)
// Set all bits to randomly (or pseudo-randomly) chosen values.
_, err = rand.Read(u[:])
if err != nil {
return
}
u.setVariant(ReservedRFC4122)
u.setVersion(4)
return
}
|
go
|
func NewV4() (u *UUID, err error) {
u = new(UUID)
// Set all bits to randomly (or pseudo-randomly) chosen values.
_, err = rand.Read(u[:])
if err != nil {
return
}
u.setVariant(ReservedRFC4122)
u.setVersion(4)
return
}
|
[
"func",
"NewV4",
"(",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"u",
"=",
"new",
"(",
"UUID",
")",
"\n",
"// Set all bits to randomly (or pseudo-randomly) chosen values.",
"_",
",",
"err",
"=",
"rand",
".",
"Read",
"(",
"u",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"u",
".",
"setVariant",
"(",
"ReservedRFC4122",
")",
"\n",
"u",
".",
"setVersion",
"(",
"4",
")",
"\n",
"return",
"\n",
"}"
] |
// Generate a random UUID.
|
[
"Generate",
"a",
"random",
"UUID",
"."
] |
179d4d0c4d8d407a32af483c2354df1d2c91e6c3
|
https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L99-L109
|
16,034 |
nu7hatch/gouuid
|
uuid.go
|
NewV5
|
func NewV5(ns *UUID, name []byte) (u *UUID, err error) {
u = new(UUID)
// Set all bits to truncated SHA1 hash generated from namespace
// and name.
u.setBytesFromHash(sha1.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(5)
return
}
|
go
|
func NewV5(ns *UUID, name []byte) (u *UUID, err error) {
u = new(UUID)
// Set all bits to truncated SHA1 hash generated from namespace
// and name.
u.setBytesFromHash(sha1.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(5)
return
}
|
[
"func",
"NewV5",
"(",
"ns",
"*",
"UUID",
",",
"name",
"[",
"]",
"byte",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"u",
"=",
"new",
"(",
"UUID",
")",
"\n",
"// Set all bits to truncated SHA1 hash generated from namespace",
"// and name.",
"u",
".",
"setBytesFromHash",
"(",
"sha1",
".",
"New",
"(",
")",
",",
"ns",
"[",
":",
"]",
",",
"name",
")",
"\n",
"u",
".",
"setVariant",
"(",
"ReservedRFC4122",
")",
"\n",
"u",
".",
"setVersion",
"(",
"5",
")",
"\n",
"return",
"\n",
"}"
] |
// Generate a UUID based on the SHA-1 hash of a namespace identifier
// and a name.
|
[
"Generate",
"a",
"UUID",
"based",
"on",
"the",
"SHA",
"-",
"1",
"hash",
"of",
"a",
"namespace",
"identifier",
"and",
"a",
"name",
"."
] |
179d4d0c4d8d407a32af483c2354df1d2c91e6c3
|
https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L113-L121
|
16,035 |
nu7hatch/gouuid
|
uuid.go
|
setBytesFromHash
|
func (u *UUID) setBytesFromHash(hash hash.Hash, ns, name []byte) {
hash.Write(ns[:])
hash.Write(name)
copy(u[:], hash.Sum([]byte{})[:16])
}
|
go
|
func (u *UUID) setBytesFromHash(hash hash.Hash, ns, name []byte) {
hash.Write(ns[:])
hash.Write(name)
copy(u[:], hash.Sum([]byte{})[:16])
}
|
[
"func",
"(",
"u",
"*",
"UUID",
")",
"setBytesFromHash",
"(",
"hash",
"hash",
".",
"Hash",
",",
"ns",
",",
"name",
"[",
"]",
"byte",
")",
"{",
"hash",
".",
"Write",
"(",
"ns",
"[",
":",
"]",
")",
"\n",
"hash",
".",
"Write",
"(",
"name",
")",
"\n",
"copy",
"(",
"u",
"[",
":",
"]",
",",
"hash",
".",
"Sum",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
"[",
":",
"16",
"]",
")",
"\n",
"}"
] |
// Generate a MD5 hash of a namespace and a name, and copy it to the
// UUID slice.
|
[
"Generate",
"a",
"MD5",
"hash",
"of",
"a",
"namespace",
"and",
"a",
"name",
"and",
"copy",
"it",
"to",
"the",
"UUID",
"slice",
"."
] |
179d4d0c4d8d407a32af483c2354df1d2c91e6c3
|
https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L125-L129
|
16,036 |
michaelklishin/rabbit-hole
|
vhosts.go
|
ListVhosts
|
func (c *Client) ListVhosts() (rec []VhostInfo, err error) {
req, err := newGETRequest(c, "vhosts")
if err != nil {
return []VhostInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []VhostInfo{}, err
}
return rec, nil
}
|
go
|
func (c *Client) ListVhosts() (rec []VhostInfo, err error) {
req, err := newGETRequest(c, "vhosts")
if err != nil {
return []VhostInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []VhostInfo{}, err
}
return rec, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"ListVhosts",
"(",
")",
"(",
"rec",
"[",
"]",
"VhostInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"VhostInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"executeAndParseRequest",
"(",
"c",
",",
"req",
",",
"&",
"rec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"VhostInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rec",
",",
"nil",
"\n",
"}"
] |
// ListVhosts returns a list of virtual hosts.
|
[
"ListVhosts",
"returns",
"a",
"list",
"of",
"virtual",
"hosts",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/vhosts.go#L81-L92
|
16,037 |
michaelklishin/rabbit-hole
|
vhosts.go
|
PutVhost
|
func (c *Client) PutVhost(vhostname string, settings VhostSettings) (res *http.Response, err error) {
body, err := json.Marshal(settings)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "vhosts/"+PathEscape(vhostname), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
}
|
go
|
func (c *Client) PutVhost(vhostname string, settings VhostSettings) (res *http.Response, err error) {
body, err := json.Marshal(settings)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "vhosts/"+PathEscape(vhostname), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"PutVhost",
"(",
"vhostname",
"string",
",",
"settings",
"VhostSettings",
")",
"(",
"res",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"settings",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"newRequestWithBody",
"(",
"c",
",",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"PathEscape",
"(",
"vhostname",
")",
",",
"body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
",",
"err",
"=",
"executeRequest",
"(",
"c",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// Creates or updates a virtual host.
|
[
"Creates",
"or",
"updates",
"a",
"virtual",
"host",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/vhosts.go#L123-L140
|
16,038 |
michaelklishin/rabbit-hole
|
client.go
|
NewTLSClient
|
func NewTLSClient(uri string, username string, password string, transport http.RoundTripper) (me *Client, err error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
me = &Client{
Endpoint: uri,
host: u.Host,
Username: username,
Password: password,
transport: transport,
}
return me, nil
}
|
go
|
func NewTLSClient(uri string, username string, password string, transport http.RoundTripper) (me *Client, err error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
me = &Client{
Endpoint: uri,
host: u.Host,
Username: username,
Password: password,
transport: transport,
}
return me, nil
}
|
[
"func",
"NewTLSClient",
"(",
"uri",
"string",
",",
"username",
"string",
",",
"password",
"string",
",",
"transport",
"http",
".",
"RoundTripper",
")",
"(",
"me",
"*",
"Client",
",",
"err",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"me",
"=",
"&",
"Client",
"{",
"Endpoint",
":",
"uri",
",",
"host",
":",
"u",
".",
"Host",
",",
"Username",
":",
"username",
",",
"Password",
":",
"password",
",",
"transport",
":",
"transport",
",",
"}",
"\n\n",
"return",
"me",
",",
"nil",
"\n",
"}"
] |
// Creates a client with a transport; it is up to the developer to make that layer secure.
|
[
"Creates",
"a",
"client",
"with",
"a",
"transport",
";",
"it",
"is",
"up",
"to",
"the",
"developer",
"to",
"make",
"that",
"layer",
"secure",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/client.go#L41-L56
|
16,039 |
michaelklishin/rabbit-hole
|
permissions.go
|
ListPermissions
|
func (c *Client) ListPermissions() (rec []PermissionInfo, err error) {
req, err := newGETRequest(c, "permissions/")
if err != nil {
return []PermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []PermissionInfo{}, err
}
return rec, nil
}
|
go
|
func (c *Client) ListPermissions() (rec []PermissionInfo, err error) {
req, err := newGETRequest(c, "permissions/")
if err != nil {
return []PermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []PermissionInfo{}, err
}
return rec, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"ListPermissions",
"(",
")",
"(",
"rec",
"[",
"]",
"PermissionInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"PermissionInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"executeAndParseRequest",
"(",
"c",
",",
"req",
",",
"&",
"rec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"PermissionInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rec",
",",
"nil",
"\n",
"}"
] |
// ListPermissions returns permissions for all users and virtual hosts.
|
[
"ListPermissions",
"returns",
"permissions",
"for",
"all",
"users",
"and",
"virtual",
"hosts",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/permissions.go#L29-L40
|
16,040 |
michaelklishin/rabbit-hole
|
permissions.go
|
UpdatePermissionsIn
|
func (c *Client) UpdatePermissionsIn(vhost, username string, permissions Permissions) (res *http.Response, err error) {
body, err := json.Marshal(permissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
}
|
go
|
func (c *Client) UpdatePermissionsIn(vhost, username string, permissions Permissions) (res *http.Response, err error) {
body, err := json.Marshal(permissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"UpdatePermissionsIn",
"(",
"vhost",
",",
"username",
"string",
",",
"permissions",
"Permissions",
")",
"(",
"res",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"permissions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"newRequestWithBody",
"(",
"c",
",",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"PathEscape",
"(",
"vhost",
")",
"+",
"\"",
"\"",
"+",
"PathEscape",
"(",
"username",
")",
",",
"body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
",",
"err",
"=",
"executeRequest",
"(",
"c",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// Updates permissions of user in virtual host.
|
[
"Updates",
"permissions",
"of",
"user",
"in",
"virtual",
"host",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/permissions.go#L89-L106
|
16,041 |
michaelklishin/rabbit-hole
|
topic_permissions.go
|
ListTopicPermissions
|
func (c *Client) ListTopicPermissions() (rec []TopicPermissionInfo, err error) {
req, err := newGETRequest(c, "topic-permissions/")
if err != nil {
return []TopicPermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []TopicPermissionInfo{}, err
}
return rec, nil
}
|
go
|
func (c *Client) ListTopicPermissions() (rec []TopicPermissionInfo, err error) {
req, err := newGETRequest(c, "topic-permissions/")
if err != nil {
return []TopicPermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []TopicPermissionInfo{}, err
}
return rec, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"ListTopicPermissions",
"(",
")",
"(",
"rec",
"[",
"]",
"TopicPermissionInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"TopicPermissionInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"executeAndParseRequest",
"(",
"c",
",",
"req",
",",
"&",
"rec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"TopicPermissionInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rec",
",",
"nil",
"\n",
"}"
] |
// ListTopicPermissions returns topic-permissions for all users and virtual hosts.
|
[
"ListTopicPermissions",
"returns",
"topic",
"-",
"permissions",
"for",
"all",
"users",
"and",
"virtual",
"hosts",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/topic_permissions.go#L28-L39
|
16,042 |
michaelklishin/rabbit-hole
|
topic_permissions.go
|
UpdateTopicPermissionsIn
|
func (c *Client) UpdateTopicPermissionsIn(vhost, username string, TopicPermissions TopicPermissions) (res *http.Response, err error) {
body, err := json.Marshal(TopicPermissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "topic-permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
}
|
go
|
func (c *Client) UpdateTopicPermissionsIn(vhost, username string, TopicPermissions TopicPermissions) (res *http.Response, err error) {
body, err := json.Marshal(TopicPermissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "topic-permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateTopicPermissionsIn",
"(",
"vhost",
",",
"username",
"string",
",",
"TopicPermissions",
"TopicPermissions",
")",
"(",
"res",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"TopicPermissions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"newRequestWithBody",
"(",
"c",
",",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"PathEscape",
"(",
"vhost",
")",
"+",
"\"",
"\"",
"+",
"PathEscape",
"(",
"username",
")",
",",
"body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
",",
"err",
"=",
"executeRequest",
"(",
"c",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// Updates topic-permissions of user in virtual host.
|
[
"Updates",
"topic",
"-",
"permissions",
"of",
"user",
"in",
"virtual",
"host",
"."
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/topic_permissions.go#L88-L105
|
16,043 |
michaelklishin/rabbit-hole
|
bindings.go
|
ListBindings
|
func (c *Client) ListBindings() (rec []BindingInfo, err error) {
req, err := newGETRequest(c, "bindings/")
if err != nil {
return []BindingInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []BindingInfo{}, err
}
return rec, nil
}
|
go
|
func (c *Client) ListBindings() (rec []BindingInfo, err error) {
req, err := newGETRequest(c, "bindings/")
if err != nil {
return []BindingInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []BindingInfo{}, err
}
return rec, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"ListBindings",
"(",
")",
"(",
"rec",
"[",
"]",
"BindingInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"BindingInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"executeAndParseRequest",
"(",
"c",
",",
"req",
",",
"&",
"rec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"BindingInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rec",
",",
"nil",
"\n",
"}"
] |
// ListBindings returns all bindings
|
[
"ListBindings",
"returns",
"all",
"bindings"
] |
cfa3c7b4e6be452ebc192d079f8303ea67ef92f4
|
https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/bindings.go#L53-L64
|
16,044 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/decoder.go
|
NewDecoder
|
func NewDecoder(r io.Reader) Decoder {
return Decoder{
r: r,
buf: &bytes.Buffer{},
}
}
|
go
|
func NewDecoder(r io.Reader) Decoder {
return Decoder{
r: r,
buf: &bytes.Buffer{},
}
}
|
[
"func",
"NewDecoder",
"(",
"r",
"io",
".",
"Reader",
")",
"Decoder",
"{",
"return",
"Decoder",
"{",
"r",
":",
"r",
",",
"buf",
":",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"}",
"\n",
"}"
] |
// NewDecoder Creates a new Decoder object
|
[
"NewDecoder",
"Creates",
"a",
"new",
"Decoder",
"object"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/decoder.go#L27-L32
|
16,045 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/decoder.go
|
read
|
func (d Decoder) read() (*bytes.Buffer, error) {
output := &bytes.Buffer{}
for {
lengthBytes := make([]byte, 2)
if numRead, err := io.ReadFull(d.r, lengthBytes); numRead != 2 {
return nil, errors.Wrap(err, "Couldn't read expected bytes for message length. Read: %d Expected: 2.", numRead)
}
// Chunk header contains length of current message
messageLen := binary.BigEndian.Uint16(lengthBytes)
if messageLen == 0 {
// If the length is 0, the chunk is done.
return output, nil
}
data, err := d.readData(messageLen)
if err != nil {
return output, errors.Wrap(err, "An error occurred reading message data")
}
numWritten, err := output.Write(data)
if numWritten < len(data) {
return output, errors.New("Didn't write full data on output. Expected: %d Wrote: %d", len(data), numWritten)
} else if err != nil {
return output, errors.Wrap(err, "Error writing data to output")
}
}
}
|
go
|
func (d Decoder) read() (*bytes.Buffer, error) {
output := &bytes.Buffer{}
for {
lengthBytes := make([]byte, 2)
if numRead, err := io.ReadFull(d.r, lengthBytes); numRead != 2 {
return nil, errors.Wrap(err, "Couldn't read expected bytes for message length. Read: %d Expected: 2.", numRead)
}
// Chunk header contains length of current message
messageLen := binary.BigEndian.Uint16(lengthBytes)
if messageLen == 0 {
// If the length is 0, the chunk is done.
return output, nil
}
data, err := d.readData(messageLen)
if err != nil {
return output, errors.Wrap(err, "An error occurred reading message data")
}
numWritten, err := output.Write(data)
if numWritten < len(data) {
return output, errors.New("Didn't write full data on output. Expected: %d Wrote: %d", len(data), numWritten)
} else if err != nil {
return output, errors.Wrap(err, "Error writing data to output")
}
}
}
|
[
"func",
"(",
"d",
"Decoder",
")",
"read",
"(",
")",
"(",
"*",
"bytes",
".",
"Buffer",
",",
"error",
")",
"{",
"output",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"for",
"{",
"lengthBytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"if",
"numRead",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"d",
".",
"r",
",",
"lengthBytes",
")",
";",
"numRead",
"!=",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
",",
"numRead",
")",
"\n",
"}",
"\n\n",
"// Chunk header contains length of current message",
"messageLen",
":=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"lengthBytes",
")",
"\n",
"if",
"messageLen",
"==",
"0",
"{",
"// If the length is 0, the chunk is done.",
"return",
"output",
",",
"nil",
"\n",
"}",
"\n\n",
"data",
",",
"err",
":=",
"d",
".",
"readData",
"(",
"messageLen",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"output",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"numWritten",
",",
"err",
":=",
"output",
".",
"Write",
"(",
"data",
")",
"\n",
"if",
"numWritten",
"<",
"len",
"(",
"data",
")",
"{",
"return",
"output",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"len",
"(",
"data",
")",
",",
"numWritten",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"output",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Read out the object bytes to decode
|
[
"Read",
"out",
"the",
"object",
"bytes",
"to",
"decode"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/decoder.go#L40-L67
|
16,046 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/decoder.go
|
Decode
|
func (d Decoder) Decode() (interface{}, error) {
data, err := d.read()
if err != nil {
return nil, err
}
return d.decode(data)
}
|
go
|
func (d Decoder) Decode() (interface{}, error) {
data, err := d.read()
if err != nil {
return nil, err
}
return d.decode(data)
}
|
[
"func",
"(",
"d",
"Decoder",
")",
"Decode",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"d",
".",
"read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"decode",
"(",
"data",
")",
"\n",
"}"
] |
// Decode decodes the stream to an object
|
[
"Decode",
"decodes",
"the",
"stream",
"to",
"an",
"object"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/decoder.go#L92-L99
|
16,047 |
johnnadratowski/golang-neo4j-bolt-driver
|
errors/errors.go
|
New
|
func New(msg string, args ...interface{}) *Error {
return &Error{
msg: fmt.Sprintf(msg, args...),
stack: debug.Stack(),
level: 0,
}
}
|
go
|
func New(msg string, args ...interface{}) *Error {
return &Error{
msg: fmt.Sprintf(msg, args...),
stack: debug.Stack(),
level: 0,
}
}
|
[
"func",
"New",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"return",
"&",
"Error",
"{",
"msg",
":",
"fmt",
".",
"Sprintf",
"(",
"msg",
",",
"args",
"...",
")",
",",
"stack",
":",
"debug",
".",
"Stack",
"(",
")",
",",
"level",
":",
"0",
",",
"}",
"\n",
"}"
] |
// New makes a new error
|
[
"New",
"makes",
"a",
"new",
"error"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/errors/errors.go#L18-L24
|
16,048 |
johnnadratowski/golang-neo4j-bolt-driver
|
errors/errors.go
|
Wrap
|
func Wrap(err error, msg string, args ...interface{}) *Error {
if e, ok := err.(*Error); ok {
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: e,
}
}
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: err,
stack: debug.Stack(),
}
}
|
go
|
func Wrap(err error, msg string, args ...interface{}) *Error {
if e, ok := err.(*Error); ok {
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: e,
}
}
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: err,
stack: debug.Stack(),
}
}
|
[
"func",
"Wrap",
"(",
"err",
"error",
",",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"Error",
")",
";",
"ok",
"{",
"return",
"&",
"Error",
"{",
"msg",
":",
"fmt",
".",
"Sprintf",
"(",
"msg",
",",
"args",
"...",
")",
",",
"wrapped",
":",
"e",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"Error",
"{",
"msg",
":",
"fmt",
".",
"Sprintf",
"(",
"msg",
",",
"args",
"...",
")",
",",
"wrapped",
":",
"err",
",",
"stack",
":",
"debug",
".",
"Stack",
"(",
")",
",",
"}",
"\n",
"}"
] |
// Wrap wraps an error with a new error
|
[
"Wrap",
"wraps",
"an",
"error",
"with",
"a",
"new",
"error"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/errors/errors.go#L27-L40
|
16,049 |
johnnadratowski/golang-neo4j-bolt-driver
|
errors/errors.go
|
InnerMost
|
func (e *Error) InnerMost() error {
if e.wrapped == nil {
return e
}
if inner, ok := e.wrapped.(*Error); ok {
return inner.InnerMost()
}
return e.wrapped
}
|
go
|
func (e *Error) InnerMost() error {
if e.wrapped == nil {
return e
}
if inner, ok := e.wrapped.(*Error); ok {
return inner.InnerMost()
}
return e.wrapped
}
|
[
"func",
"(",
"e",
"*",
"Error",
")",
"InnerMost",
"(",
")",
"error",
"{",
"if",
"e",
".",
"wrapped",
"==",
"nil",
"{",
"return",
"e",
"\n",
"}",
"\n\n",
"if",
"inner",
",",
"ok",
":=",
"e",
".",
"wrapped",
".",
"(",
"*",
"Error",
")",
";",
"ok",
"{",
"return",
"inner",
".",
"InnerMost",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"e",
".",
"wrapped",
"\n",
"}"
] |
// InnerMost returns the innermost error wrapped by this error
|
[
"InnerMost",
"returns",
"the",
"innermost",
"error",
"wrapped",
"by",
"this",
"error"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/errors/errors.go#L53-L63
|
16,050 |
johnnadratowski/golang-neo4j-bolt-driver
|
util.go
|
sprintByteHex
|
func sprintByteHex(b []byte) string {
output := "\t"
for i, b := range b {
output += fmt.Sprintf("%x", b)
if (i+1)%16 == 0 {
output += "\n\n\t"
} else if (i+1)%4 == 0 {
output += " "
} else {
output += " "
}
}
output += "\n"
return output
}
|
go
|
func sprintByteHex(b []byte) string {
output := "\t"
for i, b := range b {
output += fmt.Sprintf("%x", b)
if (i+1)%16 == 0 {
output += "\n\n\t"
} else if (i+1)%4 == 0 {
output += " "
} else {
output += " "
}
}
output += "\n"
return output
}
|
[
"func",
"sprintByteHex",
"(",
"b",
"[",
"]",
"byte",
")",
"string",
"{",
"output",
":=",
"\"",
"\\t",
"\"",
"\n",
"for",
"i",
",",
"b",
":=",
"range",
"b",
"{",
"output",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
")",
"\n",
"if",
"(",
"i",
"+",
"1",
")",
"%",
"16",
"==",
"0",
"{",
"output",
"+=",
"\"",
"\\n",
"\\n",
"\\t",
"\"",
"\n",
"}",
"else",
"if",
"(",
"i",
"+",
"1",
")",
"%",
"4",
"==",
"0",
"{",
"output",
"+=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"output",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"output",
"+=",
"\"",
"\\n",
"\"",
"\n\n",
"return",
"output",
"\n",
"}"
] |
// sprintByteHex returns a formatted string of the byte array in hexadecimal
// with a nicely formatted human-readable output
|
[
"sprintByteHex",
"returns",
"a",
"formatted",
"string",
"of",
"the",
"byte",
"array",
"in",
"hexadecimal",
"with",
"a",
"nicely",
"formatted",
"human",
"-",
"readable",
"output"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/util.go#L13-L28
|
16,051 |
johnnadratowski/golang-neo4j-bolt-driver
|
util.go
|
driverArgsToMap
|
func driverArgsToMap(args []driver.Value) (map[string]interface{}, error) {
output := map[string]interface{}{}
for _, arg := range args {
argBytes, ok := arg.([]byte)
if !ok {
return nil, errors.New("You must pass only a gob encoded map to the Exec/Query args")
}
m, err := encoding.Unmarshal(argBytes)
if err != nil {
return nil, err
}
for k, v := range m.(map[string]interface{}) {
output[k] = v
}
}
return output, nil
}
|
go
|
func driverArgsToMap(args []driver.Value) (map[string]interface{}, error) {
output := map[string]interface{}{}
for _, arg := range args {
argBytes, ok := arg.([]byte)
if !ok {
return nil, errors.New("You must pass only a gob encoded map to the Exec/Query args")
}
m, err := encoding.Unmarshal(argBytes)
if err != nil {
return nil, err
}
for k, v := range m.(map[string]interface{}) {
output[k] = v
}
}
return output, nil
}
|
[
"func",
"driverArgsToMap",
"(",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"output",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"for",
"_",
",",
"arg",
":=",
"range",
"args",
"{",
"argBytes",
",",
"ok",
":=",
"arg",
".",
"(",
"[",
"]",
"byte",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
",",
"err",
":=",
"encoding",
".",
"Unmarshal",
"(",
"argBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"m",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"output",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"return",
"output",
",",
"nil",
"\n",
"}"
] |
// driverArgsToMap turns driver.Value list into a parameter map
// for neo4j parameters
|
[
"driverArgsToMap",
"turns",
"driver",
".",
"Value",
"list",
"into",
"a",
"parameter",
"map",
"for",
"neo4j",
"parameters"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/util.go#L32-L52
|
16,052 |
johnnadratowski/golang-neo4j-bolt-driver
|
tx.go
|
Commit
|
func (t *boltTx) Commit() error {
if t.closed {
return errors.New("Transaction already closed")
}
if t.conn.statement != nil {
if err := t.conn.statement.Close(); err != nil {
return errors.Wrap(err, "An error occurred closing open rows in transaction Commit")
}
}
successInt, pullInt, err := t.conn.sendRunPullAllConsumeSingle("COMMIT", nil)
if err != nil {
return errors.Wrap(err, "An error occurred committing transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type committing transaction: %#v", success)
}
log.Infof("Got success message committing transaction: %#v", success)
pull, ok := pullInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type pulling transaction: %#v", pull)
}
log.Infof("Got success message pulling transaction: %#v", pull)
t.conn.transaction = nil
t.closed = true
return err
}
|
go
|
func (t *boltTx) Commit() error {
if t.closed {
return errors.New("Transaction already closed")
}
if t.conn.statement != nil {
if err := t.conn.statement.Close(); err != nil {
return errors.Wrap(err, "An error occurred closing open rows in transaction Commit")
}
}
successInt, pullInt, err := t.conn.sendRunPullAllConsumeSingle("COMMIT", nil)
if err != nil {
return errors.Wrap(err, "An error occurred committing transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type committing transaction: %#v", success)
}
log.Infof("Got success message committing transaction: %#v", success)
pull, ok := pullInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type pulling transaction: %#v", pull)
}
log.Infof("Got success message pulling transaction: %#v", pull)
t.conn.transaction = nil
t.closed = true
return err
}
|
[
"func",
"(",
"t",
"*",
"boltTx",
")",
"Commit",
"(",
")",
"error",
"{",
"if",
"t",
".",
"closed",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"conn",
".",
"statement",
"!=",
"nil",
"{",
"if",
"err",
":=",
"t",
".",
"conn",
".",
"statement",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"successInt",
",",
"pullInt",
",",
"err",
":=",
"t",
".",
"conn",
".",
"sendRunPullAllConsumeSingle",
"(",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"success",
",",
"ok",
":=",
"successInt",
".",
"(",
"messages",
".",
"SuccessMessage",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"success",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"success",
")",
"\n\n",
"pull",
",",
"ok",
":=",
"pullInt",
".",
"(",
"messages",
".",
"SuccessMessage",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"pull",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"pull",
")",
"\n\n",
"t",
".",
"conn",
".",
"transaction",
"=",
"nil",
"\n",
"t",
".",
"closed",
"=",
"true",
"\n",
"return",
"err",
"\n",
"}"
] |
// Commit commits and closes the transaction
|
[
"Commit",
"commits",
"and",
"closes",
"the",
"transaction"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/tx.go#L29-L61
|
16,053 |
johnnadratowski/golang-neo4j-bolt-driver
|
driver.go
|
Open
|
func (d *boltDriver) Open(connStr string) (driver.Conn, error) {
return newBoltConn(connStr, d) // Never use pooling when using SQL driver
}
|
go
|
func (d *boltDriver) Open(connStr string) (driver.Conn, error) {
return newBoltConn(connStr, d) // Never use pooling when using SQL driver
}
|
[
"func",
"(",
"d",
"*",
"boltDriver",
")",
"Open",
"(",
"connStr",
"string",
")",
"(",
"driver",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"newBoltConn",
"(",
"connStr",
",",
"d",
")",
"// Never use pooling when using SQL driver",
"\n",
"}"
] |
// Open opens a new Bolt connection to the Neo4J database
|
[
"Open",
"opens",
"a",
"new",
"Bolt",
"connection",
"to",
"the",
"Neo4J",
"database"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L58-L60
|
16,054 |
johnnadratowski/golang-neo4j-bolt-driver
|
driver.go
|
NewDriverPool
|
func NewDriverPool(connStr string, max int) (DriverPool, error) {
return createDriverPool(connStr, max)
}
|
go
|
func NewDriverPool(connStr string, max int) (DriverPool, error) {
return createDriverPool(connStr, max)
}
|
[
"func",
"NewDriverPool",
"(",
"connStr",
"string",
",",
"max",
"int",
")",
"(",
"DriverPool",
",",
"error",
")",
"{",
"return",
"createDriverPool",
"(",
"connStr",
",",
"max",
")",
"\n",
"}"
] |
// NewDriverPool creates a new Driver object with connection pooling
|
[
"NewDriverPool",
"creates",
"a",
"new",
"Driver",
"object",
"with",
"connection",
"pooling"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L96-L98
|
16,055 |
johnnadratowski/golang-neo4j-bolt-driver
|
driver.go
|
NewClosableDriverPool
|
func NewClosableDriverPool(connStr string, max int) (ClosableDriverPool, error) {
return createDriverPool(connStr, max)
}
|
go
|
func NewClosableDriverPool(connStr string, max int) (ClosableDriverPool, error) {
return createDriverPool(connStr, max)
}
|
[
"func",
"NewClosableDriverPool",
"(",
"connStr",
"string",
",",
"max",
"int",
")",
"(",
"ClosableDriverPool",
",",
"error",
")",
"{",
"return",
"createDriverPool",
"(",
"connStr",
",",
"max",
")",
"\n",
"}"
] |
// NewClosableDriverPool create a closable driver pool
|
[
"NewClosableDriverPool",
"create",
"a",
"closable",
"driver",
"pool"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L101-L103
|
16,056 |
johnnadratowski/golang-neo4j-bolt-driver
|
driver.go
|
OpenPool
|
func (d *boltDriverPool) OpenPool() (Conn, error) {
// For each connection request we need to block in case the Close function is called. This gives us a guarantee
// when closing the pool no new connections are made.
d.refLock.Lock()
defer d.refLock.Unlock()
if !d.closed {
conn := <-d.pool
if connectionNilOrClosed(conn) {
if err := conn.initialize(); err != nil {
return nil, err
}
d.connRefs = append(d.connRefs, conn)
}
return conn, nil
}
return nil, errors.New("Driver pool has been closed")
}
|
go
|
func (d *boltDriverPool) OpenPool() (Conn, error) {
// For each connection request we need to block in case the Close function is called. This gives us a guarantee
// when closing the pool no new connections are made.
d.refLock.Lock()
defer d.refLock.Unlock()
if !d.closed {
conn := <-d.pool
if connectionNilOrClosed(conn) {
if err := conn.initialize(); err != nil {
return nil, err
}
d.connRefs = append(d.connRefs, conn)
}
return conn, nil
}
return nil, errors.New("Driver pool has been closed")
}
|
[
"func",
"(",
"d",
"*",
"boltDriverPool",
")",
"OpenPool",
"(",
")",
"(",
"Conn",
",",
"error",
")",
"{",
"// For each connection request we need to block in case the Close function is called. This gives us a guarantee",
"// when closing the pool no new connections are made.",
"d",
".",
"refLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"refLock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"d",
".",
"closed",
"{",
"conn",
":=",
"<-",
"d",
".",
"pool",
"\n",
"if",
"connectionNilOrClosed",
"(",
"conn",
")",
"{",
"if",
"err",
":=",
"conn",
".",
"initialize",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"d",
".",
"connRefs",
"=",
"append",
"(",
"d",
".",
"connRefs",
",",
"conn",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// OpenPool opens a returns a Bolt connection from the pool to the Neo4J database.
|
[
"OpenPool",
"opens",
"a",
"returns",
"a",
"Bolt",
"connection",
"from",
"the",
"pool",
"to",
"the",
"Neo4J",
"database",
"."
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L125-L141
|
16,057 |
johnnadratowski/golang-neo4j-bolt-driver
|
driver.go
|
Close
|
func (d *boltDriverPool) Close() error {
// Lock the connection ref so no new connections can be added
d.refLock.Lock()
defer d.refLock.Unlock()
for _, conn := range d.connRefs {
// Remove the reference to the pool, to allow a clean up of the connection
conn.poolDriver = nil
err := conn.Close()
if err != nil {
d.closed = true
return err
}
}
// Mark the pool as closed to stop any new connections
d.closed = true
return nil
}
|
go
|
func (d *boltDriverPool) Close() error {
// Lock the connection ref so no new connections can be added
d.refLock.Lock()
defer d.refLock.Unlock()
for _, conn := range d.connRefs {
// Remove the reference to the pool, to allow a clean up of the connection
conn.poolDriver = nil
err := conn.Close()
if err != nil {
d.closed = true
return err
}
}
// Mark the pool as closed to stop any new connections
d.closed = true
return nil
}
|
[
"func",
"(",
"d",
"*",
"boltDriverPool",
")",
"Close",
"(",
")",
"error",
"{",
"// Lock the connection ref so no new connections can be added",
"d",
".",
"refLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"refLock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"conn",
":=",
"range",
"d",
".",
"connRefs",
"{",
"// Remove the reference to the pool, to allow a clean up of the connection",
"conn",
".",
"poolDriver",
"=",
"nil",
"\n",
"err",
":=",
"conn",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"d",
".",
"closed",
"=",
"true",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"// Mark the pool as closed to stop any new connections",
"d",
".",
"closed",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close all connections in the pool
|
[
"Close",
"all",
"connections",
"in",
"the",
"pool"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L158-L174
|
16,058 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
newBoltConn
|
func newBoltConn(connStr string, driver *boltDriver) (*boltConn, error) {
c := createBoltConn(connStr)
c.driver = driver
err := c.initialize()
if err != nil {
return nil, errors.Wrap(err, "An error occurred initializing connection")
}
return c, nil
}
|
go
|
func newBoltConn(connStr string, driver *boltDriver) (*boltConn, error) {
c := createBoltConn(connStr)
c.driver = driver
err := c.initialize()
if err != nil {
return nil, errors.Wrap(err, "An error occurred initializing connection")
}
return c, nil
}
|
[
"func",
"newBoltConn",
"(",
"connStr",
"string",
",",
"driver",
"*",
"boltDriver",
")",
"(",
"*",
"boltConn",
",",
"error",
")",
"{",
"c",
":=",
"createBoltConn",
"(",
"connStr",
")",
"\n",
"c",
".",
"driver",
"=",
"driver",
"\n\n",
"err",
":=",
"c",
".",
"initialize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// newBoltConn Creates a new bolt connection
|
[
"newBoltConn",
"Creates",
"a",
"new",
"bolt",
"connection"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L97-L108
|
16,059 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
newPooledBoltConn
|
func newPooledBoltConn(connStr string, driver DriverPool) (*boltConn, error) {
c := createBoltConn(connStr)
c.poolDriver = driver
return c, nil
}
|
go
|
func newPooledBoltConn(connStr string, driver DriverPool) (*boltConn, error) {
c := createBoltConn(connStr)
c.poolDriver = driver
return c, nil
}
|
[
"func",
"newPooledBoltConn",
"(",
"connStr",
"string",
",",
"driver",
"DriverPool",
")",
"(",
"*",
"boltConn",
",",
"error",
")",
"{",
"c",
":=",
"createBoltConn",
"(",
"connStr",
")",
"\n",
"c",
".",
"poolDriver",
"=",
"driver",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// newPooledBoltConn Creates a new bolt connection with a pooled driver
|
[
"newPooledBoltConn",
"Creates",
"a",
"new",
"bolt",
"connection",
"with",
"a",
"pooled",
"driver"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L111-L117
|
16,060 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
Read
|
func (c *boltConn) Read(b []byte) (n int, err error) {
if err := c.conn.SetReadDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting read deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Read(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Read %d bytes from stream:\n\n%s\n", n, sprintByteHex(b))
}
if err != nil && err != io.EOF {
c.connErr = errors.Wrap(err, "An error occurred reading from stream")
err = driver.ErrBadConn
}
return n, err
}
|
go
|
func (c *boltConn) Read(b []byte) (n int, err error) {
if err := c.conn.SetReadDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting read deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Read(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Read %d bytes from stream:\n\n%s\n", n, sprintByteHex(b))
}
if err != nil && err != io.EOF {
c.connErr = errors.Wrap(err, "An error occurred reading from stream")
err = driver.ErrBadConn
}
return n, err
}
|
[
"func",
"(",
"c",
"*",
"boltConn",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"conn",
".",
"SetReadDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"c",
".",
"timeout",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"connErr",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"0",
",",
"driver",
".",
"ErrBadConn",
"\n",
"}",
"\n\n",
"n",
",",
"err",
"=",
"c",
".",
"conn",
".",
"Read",
"(",
"b",
")",
"\n\n",
"if",
"log",
".",
"GetLevel",
"(",
")",
">=",
"log",
".",
"TraceLevel",
"{",
"log",
".",
"Tracef",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
",",
"n",
",",
"sprintByteHex",
"(",
"b",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"c",
".",
"connErr",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"driver",
".",
"ErrBadConn",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// Read reads the data from the underlying connection
|
[
"Read",
"reads",
"the",
"data",
"from",
"the",
"underlying",
"connection"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L320-L337
|
16,061 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
Write
|
func (c *boltConn) Write(b []byte) (n int, err error) {
if err := c.conn.SetWriteDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting write deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Write(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Wrote %d of %d bytes to stream:\n\n%s\n", len(b), n, sprintByteHex(b[:n]))
}
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred writing to stream")
err = driver.ErrBadConn
}
return n, err
}
|
go
|
func (c *boltConn) Write(b []byte) (n int, err error) {
if err := c.conn.SetWriteDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting write deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Write(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Wrote %d of %d bytes to stream:\n\n%s\n", len(b), n, sprintByteHex(b[:n]))
}
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred writing to stream")
err = driver.ErrBadConn
}
return n, err
}
|
[
"func",
"(",
"c",
"*",
"boltConn",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"conn",
".",
"SetWriteDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"c",
".",
"timeout",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"connErr",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"0",
",",
"driver",
".",
"ErrBadConn",
"\n",
"}",
"\n\n",
"n",
",",
"err",
"=",
"c",
".",
"conn",
".",
"Write",
"(",
"b",
")",
"\n\n",
"if",
"log",
".",
"GetLevel",
"(",
")",
">=",
"log",
".",
"TraceLevel",
"{",
"log",
".",
"Tracef",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"b",
")",
",",
"n",
",",
"sprintByteHex",
"(",
"b",
"[",
":",
"n",
"]",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"connErr",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"driver",
".",
"ErrBadConn",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// Write writes the data to the underlying connection
|
[
"Write",
"writes",
"the",
"data",
"to",
"the",
"underlying",
"connection"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L340-L357
|
16,062 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
Close
|
func (c *boltConn) Close() error {
if c.closed {
return nil
}
if c.statement != nil {
if err := c.statement.Close(); err != nil {
return err
}
}
if c.transaction != nil {
if err := c.transaction.Rollback(); err != nil {
return errors.Wrap(err, "Error rolling back transaction when closing connection")
}
}
if c.poolDriver != nil {
// If using connection pooling, don't close connection, just reclaim it
err := c.poolDriver.reclaim(c)
if err != nil {
log.Errorf("An error occurred reclaiming connection for pool: %s", err)
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
err := c.conn.Close()
c.closed = true
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
|
go
|
func (c *boltConn) Close() error {
if c.closed {
return nil
}
if c.statement != nil {
if err := c.statement.Close(); err != nil {
return err
}
}
if c.transaction != nil {
if err := c.transaction.Rollback(); err != nil {
return errors.Wrap(err, "Error rolling back transaction when closing connection")
}
}
if c.poolDriver != nil {
// If using connection pooling, don't close connection, just reclaim it
err := c.poolDriver.reclaim(c)
if err != nil {
log.Errorf("An error occurred reclaiming connection for pool: %s", err)
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
err := c.conn.Close()
c.closed = true
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"boltConn",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"statement",
"!=",
"nil",
"{",
"if",
"err",
":=",
"c",
".",
"statement",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"transaction",
"!=",
"nil",
"{",
"if",
"err",
":=",
"c",
".",
"transaction",
".",
"Rollback",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"poolDriver",
"!=",
"nil",
"{",
"// If using connection pooling, don't close connection, just reclaim it",
"err",
":=",
"c",
".",
"poolDriver",
".",
"reclaim",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"c",
".",
"connErr",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"driver",
".",
"ErrBadConn",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"c",
".",
"closed",
"=",
"true",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"connErr",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"driver",
".",
"ErrBadConn",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Close closes the connection
// Driver may allow for pooling in the future, keeping connections alive
|
[
"Close",
"closes",
"the",
"connection",
"Driver",
"may",
"allow",
"for",
"pooling",
"in",
"the",
"future",
"keeping",
"connections",
"alive"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L361-L398
|
16,063 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
Prepare
|
func (c *boltConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(query)
}
|
go
|
func (c *boltConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(query)
}
|
[
"func",
"(",
"c",
"*",
"boltConn",
")",
"Prepare",
"(",
"query",
"string",
")",
"(",
"driver",
".",
"Stmt",
",",
"error",
")",
"{",
"return",
"c",
".",
"prepare",
"(",
"query",
")",
"\n",
"}"
] |
// Prepare prepares a new statement for a query
|
[
"Prepare",
"prepares",
"a",
"new",
"statement",
"for",
"a",
"query"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L473-L475
|
16,064 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
PreparePipeline
|
func (c *boltConn) PreparePipeline(queries ...string) (PipelineStmt, error) {
if c.statement != nil {
return nil, errors.New("An open statement already exists")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
c.statement = newPipelineStmt(queries, c)
return c.statement, nil
}
|
go
|
func (c *boltConn) PreparePipeline(queries ...string) (PipelineStmt, error) {
if c.statement != nil {
return nil, errors.New("An open statement already exists")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
c.statement = newPipelineStmt(queries, c)
return c.statement, nil
}
|
[
"func",
"(",
"c",
"*",
"boltConn",
")",
"PreparePipeline",
"(",
"queries",
"...",
"string",
")",
"(",
"PipelineStmt",
",",
"error",
")",
"{",
"if",
"c",
".",
"statement",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"closed",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
".",
"statement",
"=",
"newPipelineStmt",
"(",
"queries",
",",
"c",
")",
"\n",
"return",
"c",
".",
"statement",
",",
"nil",
"\n",
"}"
] |
// PreparePipeline prepares a new pipeline statement for a query.
|
[
"PreparePipeline",
"prepares",
"a",
"new",
"pipeline",
"statement",
"for",
"a",
"query",
"."
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L483-L492
|
16,065 |
johnnadratowski/golang-neo4j-bolt-driver
|
conn.go
|
Begin
|
func (c *boltConn) Begin() (driver.Tx, error) {
if c.transaction != nil {
return nil, errors.New("An open transaction already exists")
}
if c.statement != nil {
return nil, errors.New("Cannot open a transaction when you already have an open statement")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
successInt, pullInt, err := c.sendRunPullAllConsumeSingle("BEGIN", nil)
if err != nil {
return nil, errors.Wrap(err, "An error occurred beginning transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type beginning transaction: %#v", success)
}
log.Infof("Got success message beginning transaction: %#v", success)
success, ok = pullInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type pulling transaction: %#v", success)
}
log.Infof("Got success message pulling transaction: %#v", success)
return newTx(c), nil
}
|
go
|
func (c *boltConn) Begin() (driver.Tx, error) {
if c.transaction != nil {
return nil, errors.New("An open transaction already exists")
}
if c.statement != nil {
return nil, errors.New("Cannot open a transaction when you already have an open statement")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
successInt, pullInt, err := c.sendRunPullAllConsumeSingle("BEGIN", nil)
if err != nil {
return nil, errors.Wrap(err, "An error occurred beginning transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type beginning transaction: %#v", success)
}
log.Infof("Got success message beginning transaction: %#v", success)
success, ok = pullInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type pulling transaction: %#v", success)
}
log.Infof("Got success message pulling transaction: %#v", success)
return newTx(c), nil
}
|
[
"func",
"(",
"c",
"*",
"boltConn",
")",
"Begin",
"(",
")",
"(",
"driver",
".",
"Tx",
",",
"error",
")",
"{",
"if",
"c",
".",
"transaction",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"statement",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"closed",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"successInt",
",",
"pullInt",
",",
"err",
":=",
"c",
".",
"sendRunPullAllConsumeSingle",
"(",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"success",
",",
"ok",
":=",
"successInt",
".",
"(",
"messages",
".",
"SuccessMessage",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"success",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"success",
")",
"\n\n",
"success",
",",
"ok",
"=",
"pullInt",
".",
"(",
"messages",
".",
"SuccessMessage",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"success",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"success",
")",
"\n\n",
"return",
"newTx",
"(",
"c",
")",
",",
"nil",
"\n",
"}"
] |
// Begin begins a new transaction with the Neo4J Database
|
[
"Begin",
"begins",
"a",
"new",
"transaction",
"with",
"the",
"Neo4J",
"Database"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L506-L537
|
16,066 |
johnnadratowski/golang-neo4j-bolt-driver
|
structures/messages/run.go
|
NewRunMessage
|
func NewRunMessage(statement string, parameters map[string]interface{}) RunMessage {
return RunMessage{
statement: statement,
parameters: parameters,
}
}
|
go
|
func NewRunMessage(statement string, parameters map[string]interface{}) RunMessage {
return RunMessage{
statement: statement,
parameters: parameters,
}
}
|
[
"func",
"NewRunMessage",
"(",
"statement",
"string",
",",
"parameters",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"RunMessage",
"{",
"return",
"RunMessage",
"{",
"statement",
":",
"statement",
",",
"parameters",
":",
"parameters",
",",
"}",
"\n",
"}"
] |
// NewRunMessage Gets a new RunMessage struct
|
[
"NewRunMessage",
"Gets",
"a",
"new",
"RunMessage",
"struct"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/structures/messages/run.go#L15-L20
|
16,067 |
johnnadratowski/golang-neo4j-bolt-driver
|
rows.go
|
Columns
|
func (r *boltRows) Columns() []string {
fieldsInt, ok := r.metadata["fields"]
if !ok {
return []string{}
}
fields, ok := fieldsInt.([]interface{})
if !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
fieldsStr := make([]string, len(fields))
for i, f := range fields {
if fieldsStr[i], ok = f.(string); !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
}
return fieldsStr
}
|
go
|
func (r *boltRows) Columns() []string {
fieldsInt, ok := r.metadata["fields"]
if !ok {
return []string{}
}
fields, ok := fieldsInt.([]interface{})
if !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
fieldsStr := make([]string, len(fields))
for i, f := range fields {
if fieldsStr[i], ok = f.(string); !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
}
return fieldsStr
}
|
[
"func",
"(",
"r",
"*",
"boltRows",
")",
"Columns",
"(",
")",
"[",
"]",
"string",
"{",
"fieldsInt",
",",
"ok",
":=",
"r",
".",
"metadata",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n\n",
"fields",
",",
"ok",
":=",
"fieldsInt",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"fieldsInt",
")",
"\n",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n\n",
"fieldsStr",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"fields",
")",
")",
"\n",
"for",
"i",
",",
"f",
":=",
"range",
"fields",
"{",
"if",
"fieldsStr",
"[",
"i",
"]",
",",
"ok",
"=",
"f",
".",
"(",
"string",
")",
";",
"!",
"ok",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"fieldsInt",
")",
"\n",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fieldsStr",
"\n",
"}"
] |
// Columns returns the columns from the result
|
[
"Columns",
"returns",
"the",
"columns",
"from",
"the",
"result"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L93-L113
|
16,068 |
johnnadratowski/golang-neo4j-bolt-driver
|
rows.go
|
Close
|
func (r *boltRows) Close() error {
if r.closed {
return nil
}
if !r.consumed {
// Discard all messages if not consumed
respInt, err := r.statement.conn.sendDiscardAllConsume()
if err != nil {
return errors.Wrap(err, "An error occurred discarding messages on row close")
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
default:
return errors.New("Unrecognized response type discarding all rows: Value: %#v", resp)
}
} else if !r.finishedConsume {
// If this is a pipeline statement, we need to "consume all" multiple times
numConsume := 1
if r.statement.queries != nil {
numQueries := len(r.statement.queries)
if numQueries > 0 {
// So, every pipeline statement has two successes
// but by the time you get to the row object, one has
// been consumed. Hence we need to clear out the
// rest of the messages on close by taking the current
// index * 2 but removing the first success
numConsume = ((numQueries - r.pipelineIndex) * 2) - 1
}
}
// Clear out all unconsumed messages if we
// never finished consuming them.
_, _, err := r.statement.conn.consumeAllMultiple(numConsume)
if err != nil {
return errors.Wrap(err, "An error occurred clearing out unconsumed stream")
}
}
r.closed = true
r.statement.rows = nil
if r.closeStatement {
return r.statement.Close()
}
return nil
}
|
go
|
func (r *boltRows) Close() error {
if r.closed {
return nil
}
if !r.consumed {
// Discard all messages if not consumed
respInt, err := r.statement.conn.sendDiscardAllConsume()
if err != nil {
return errors.Wrap(err, "An error occurred discarding messages on row close")
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
default:
return errors.New("Unrecognized response type discarding all rows: Value: %#v", resp)
}
} else if !r.finishedConsume {
// If this is a pipeline statement, we need to "consume all" multiple times
numConsume := 1
if r.statement.queries != nil {
numQueries := len(r.statement.queries)
if numQueries > 0 {
// So, every pipeline statement has two successes
// but by the time you get to the row object, one has
// been consumed. Hence we need to clear out the
// rest of the messages on close by taking the current
// index * 2 but removing the first success
numConsume = ((numQueries - r.pipelineIndex) * 2) - 1
}
}
// Clear out all unconsumed messages if we
// never finished consuming them.
_, _, err := r.statement.conn.consumeAllMultiple(numConsume)
if err != nil {
return errors.Wrap(err, "An error occurred clearing out unconsumed stream")
}
}
r.closed = true
r.statement.rows = nil
if r.closeStatement {
return r.statement.Close()
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"boltRows",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"!",
"r",
".",
"consumed",
"{",
"// Discard all messages if not consumed",
"respInt",
",",
"err",
":=",
"r",
".",
"statement",
".",
"conn",
".",
"sendDiscardAllConsume",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"resp",
":=",
"respInt",
".",
"(",
"type",
")",
"{",
"case",
"messages",
".",
"SuccessMessage",
":",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"}",
"\n\n",
"}",
"else",
"if",
"!",
"r",
".",
"finishedConsume",
"{",
"// If this is a pipeline statement, we need to \"consume all\" multiple times",
"numConsume",
":=",
"1",
"\n",
"if",
"r",
".",
"statement",
".",
"queries",
"!=",
"nil",
"{",
"numQueries",
":=",
"len",
"(",
"r",
".",
"statement",
".",
"queries",
")",
"\n",
"if",
"numQueries",
">",
"0",
"{",
"// So, every pipeline statement has two successes",
"// but by the time you get to the row object, one has",
"// been consumed. Hence we need to clear out the",
"// rest of the messages on close by taking the current",
"// index * 2 but removing the first success",
"numConsume",
"=",
"(",
"(",
"numQueries",
"-",
"r",
".",
"pipelineIndex",
")",
"*",
"2",
")",
"-",
"1",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Clear out all unconsumed messages if we",
"// never finished consuming them.",
"_",
",",
"_",
",",
"err",
":=",
"r",
".",
"statement",
".",
"conn",
".",
"consumeAllMultiple",
"(",
"numConsume",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"r",
".",
"closed",
"=",
"true",
"\n",
"r",
".",
"statement",
".",
"rows",
"=",
"nil",
"\n\n",
"if",
"r",
".",
"closeStatement",
"{",
"return",
"r",
".",
"statement",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close closes the rows
|
[
"Close",
"closes",
"the",
"rows"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L121-L170
|
16,069 |
johnnadratowski/golang-neo4j-bolt-driver
|
rows.go
|
Next
|
func (r *boltRows) Next(dest []driver.Value) error {
data, _, err := r.NextNeo()
if err != nil {
return err
}
for i, item := range data {
switch item := item.(type) {
case []interface{}, map[string]interface{}, graph.Node, graph.Path, graph.Relationship, graph.UnboundRelationship:
dest[i], err = encoding.Marshal(item)
if err != nil {
return err
}
default:
dest[i], err = driver.DefaultParameterConverter.ConvertValue(item)
if err != nil {
return err
}
}
}
return nil
}
|
go
|
func (r *boltRows) Next(dest []driver.Value) error {
data, _, err := r.NextNeo()
if err != nil {
return err
}
for i, item := range data {
switch item := item.(type) {
case []interface{}, map[string]interface{}, graph.Node, graph.Path, graph.Relationship, graph.UnboundRelationship:
dest[i], err = encoding.Marshal(item)
if err != nil {
return err
}
default:
dest[i], err = driver.DefaultParameterConverter.ConvertValue(item)
if err != nil {
return err
}
}
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"boltRows",
")",
"Next",
"(",
"dest",
"[",
"]",
"driver",
".",
"Value",
")",
"error",
"{",
"data",
",",
"_",
",",
"err",
":=",
"r",
".",
"NextNeo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"item",
":=",
"range",
"data",
"{",
"switch",
"item",
":=",
"item",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"interface",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"graph",
".",
"Node",
",",
"graph",
".",
"Path",
",",
"graph",
".",
"Relationship",
",",
"graph",
".",
"UnboundRelationship",
":",
"dest",
"[",
"i",
"]",
",",
"err",
"=",
"encoding",
".",
"Marshal",
"(",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"default",
":",
"dest",
"[",
"i",
"]",
",",
"err",
"=",
"driver",
".",
"DefaultParameterConverter",
".",
"ConvertValue",
"(",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n\n",
"}"
] |
// Next gets the next row result
|
[
"Next",
"gets",
"the",
"next",
"row",
"result"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L173-L196
|
16,070 |
johnnadratowski/golang-neo4j-bolt-driver
|
rows.go
|
NextNeo
|
func (r *boltRows) NextNeo() ([]interface{}, map[string]interface{}, error) {
if r.closed {
return nil, nil, errors.New("Rows are already closed")
}
if !r.consumed {
r.consumed = true
if err := r.statement.conn.sendPullAll(); err != nil {
r.finishedConsume = true
return nil, nil, err
}
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
r.finishedConsume = true
return nil, resp.Metadata, io.EOF
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil
default:
return nil, nil, errors.New("Unrecognized response type getting next query row: %#v", resp)
}
}
|
go
|
func (r *boltRows) NextNeo() ([]interface{}, map[string]interface{}, error) {
if r.closed {
return nil, nil, errors.New("Rows are already closed")
}
if !r.consumed {
r.consumed = true
if err := r.statement.conn.sendPullAll(); err != nil {
r.finishedConsume = true
return nil, nil, err
}
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
r.finishedConsume = true
return nil, resp.Metadata, io.EOF
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil
default:
return nil, nil, errors.New("Unrecognized response type getting next query row: %#v", resp)
}
}
|
[
"func",
"(",
"r",
"*",
"boltRows",
")",
"NextNeo",
"(",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"r",
".",
"closed",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"r",
".",
"consumed",
"{",
"r",
".",
"consumed",
"=",
"true",
"\n",
"if",
"err",
":=",
"r",
".",
"statement",
".",
"conn",
".",
"sendPullAll",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"r",
".",
"finishedConsume",
"=",
"true",
"\n",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"respInt",
",",
"err",
":=",
"r",
".",
"statement",
".",
"conn",
".",
"consume",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"resp",
":=",
"respInt",
".",
"(",
"type",
")",
"{",
"case",
"messages",
".",
"SuccessMessage",
":",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"r",
".",
"finishedConsume",
"=",
"true",
"\n",
"return",
"nil",
",",
"resp",
".",
"Metadata",
",",
"io",
".",
"EOF",
"\n",
"case",
"messages",
".",
"RecordMessage",
":",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"return",
"resp",
".",
"Fields",
",",
"nil",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"}",
"\n",
"}"
] |
// NextNeo gets the next row result
// When the rows are completed, returns the success metadata
// and io.EOF
|
[
"NextNeo",
"gets",
"the",
"next",
"row",
"result",
"When",
"the",
"rows",
"are",
"completed",
"returns",
"the",
"success",
"metadata",
"and",
"io",
".",
"EOF"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L201-L230
|
16,071 |
johnnadratowski/golang-neo4j-bolt-driver
|
rows.go
|
NextPipeline
|
func (r *boltRows) NextPipeline() ([]interface{}, map[string]interface{}, PipelineRows, error) {
if r.closed {
return nil, nil, nil, errors.New("Rows are already closed")
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
if r.pipelineIndex == len(r.statement.queries)-1 {
r.finishedConsume = true
return nil, nil, nil, err
}
successResp, err := r.statement.conn.consume()
if err != nil && err != io.EOF {
return nil, nil, nil, errors.Wrap(err, "An error occurred getting next set of rows from pipeline command: %#v", successResp)
}
success, ok := successResp.(messages.SuccessMessage)
if !ok {
return nil, nil, nil, errors.New("Unexpected response getting next set of rows from pipeline command: %#v", successResp)
}
r.statement.rows = newPipelineRows(r.statement, success.Metadata, r.pipelineIndex+1)
r.statement.rows.closeStatement = r.closeStatement
return nil, success.Metadata, r.statement.rows, nil
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil, nil
default:
return nil, nil, nil, errors.New("Unrecognized response type getting next pipeline row: %#v", resp)
}
}
|
go
|
func (r *boltRows) NextPipeline() ([]interface{}, map[string]interface{}, PipelineRows, error) {
if r.closed {
return nil, nil, nil, errors.New("Rows are already closed")
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
if r.pipelineIndex == len(r.statement.queries)-1 {
r.finishedConsume = true
return nil, nil, nil, err
}
successResp, err := r.statement.conn.consume()
if err != nil && err != io.EOF {
return nil, nil, nil, errors.Wrap(err, "An error occurred getting next set of rows from pipeline command: %#v", successResp)
}
success, ok := successResp.(messages.SuccessMessage)
if !ok {
return nil, nil, nil, errors.New("Unexpected response getting next set of rows from pipeline command: %#v", successResp)
}
r.statement.rows = newPipelineRows(r.statement, success.Metadata, r.pipelineIndex+1)
r.statement.rows.closeStatement = r.closeStatement
return nil, success.Metadata, r.statement.rows, nil
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil, nil
default:
return nil, nil, nil, errors.New("Unrecognized response type getting next pipeline row: %#v", resp)
}
}
|
[
"func",
"(",
"r",
"*",
"boltRows",
")",
"NextPipeline",
"(",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"PipelineRows",
",",
"error",
")",
"{",
"if",
"r",
".",
"closed",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"respInt",
",",
"err",
":=",
"r",
".",
"statement",
".",
"conn",
".",
"consume",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"resp",
":=",
"respInt",
".",
"(",
"type",
")",
"{",
"case",
"messages",
".",
"SuccessMessage",
":",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n\n",
"if",
"r",
".",
"pipelineIndex",
"==",
"len",
"(",
"r",
".",
"statement",
".",
"queries",
")",
"-",
"1",
"{",
"r",
".",
"finishedConsume",
"=",
"true",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"successResp",
",",
"err",
":=",
"r",
".",
"statement",
".",
"conn",
".",
"consume",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
",",
"successResp",
")",
"\n",
"}",
"\n\n",
"success",
",",
"ok",
":=",
"successResp",
".",
"(",
"messages",
".",
"SuccessMessage",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"successResp",
")",
"\n",
"}",
"\n\n",
"r",
".",
"statement",
".",
"rows",
"=",
"newPipelineRows",
"(",
"r",
".",
"statement",
",",
"success",
".",
"Metadata",
",",
"r",
".",
"pipelineIndex",
"+",
"1",
")",
"\n",
"r",
".",
"statement",
".",
"rows",
".",
"closeStatement",
"=",
"r",
".",
"closeStatement",
"\n",
"return",
"nil",
",",
"success",
".",
"Metadata",
",",
"r",
".",
"statement",
".",
"rows",
",",
"nil",
"\n\n",
"case",
"messages",
".",
"RecordMessage",
":",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"return",
"resp",
".",
"Fields",
",",
"nil",
",",
"nil",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"}",
"\n",
"}"
] |
// NextPipeline gets the next row result
// When the rows are completed, returns the success metadata and the next
// set of rows.
// When all rows are completed, returns io.EOF
|
[
"NextPipeline",
"gets",
"the",
"next",
"row",
"result",
"When",
"the",
"rows",
"are",
"completed",
"returns",
"the",
"success",
"metadata",
"and",
"the",
"next",
"set",
"of",
"rows",
".",
"When",
"all",
"rows",
"are",
"completed",
"returns",
"io",
".",
"EOF"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L250-L289
|
16,072 |
johnnadratowski/golang-neo4j-bolt-driver
|
structures/messages/init.go
|
NewInitMessage
|
func NewInitMessage(clientName string, user string, password string) InitMessage {
var authToken map[string]interface{}
if user == "" {
authToken = map[string]interface{}{
"scheme": "none",
}
} else {
authToken = map[string]interface{}{
"scheme": "basic",
"principal": user,
"credentials": password,
}
}
return InitMessage{
clientName: clientName,
authToken: authToken,
}
}
|
go
|
func NewInitMessage(clientName string, user string, password string) InitMessage {
var authToken map[string]interface{}
if user == "" {
authToken = map[string]interface{}{
"scheme": "none",
}
} else {
authToken = map[string]interface{}{
"scheme": "basic",
"principal": user,
"credentials": password,
}
}
return InitMessage{
clientName: clientName,
authToken: authToken,
}
}
|
[
"func",
"NewInitMessage",
"(",
"clientName",
"string",
",",
"user",
"string",
",",
"password",
"string",
")",
"InitMessage",
"{",
"var",
"authToken",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"if",
"user",
"==",
"\"",
"\"",
"{",
"authToken",
"=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
"\n",
"}",
"else",
"{",
"authToken",
"=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"user",
",",
"\"",
"\"",
":",
"password",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"InitMessage",
"{",
"clientName",
":",
"clientName",
",",
"authToken",
":",
"authToken",
",",
"}",
"\n",
"}"
] |
// NewInitMessage Gets a new InitMessage struct
|
[
"NewInitMessage",
"Gets",
"a",
"new",
"InitMessage",
"struct"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/structures/messages/init.go#L15-L33
|
16,073 |
johnnadratowski/golang-neo4j-bolt-driver
|
log/log.go
|
SetLevel
|
func SetLevel(levelStr string) {
switch strings.ToLower(levelStr) {
case "trace":
level = TraceLevel
case "info":
level = InfoLevel
case "error":
level = ErrorLevel
default:
level = NoneLevel
}
}
|
go
|
func SetLevel(levelStr string) {
switch strings.ToLower(levelStr) {
case "trace":
level = TraceLevel
case "info":
level = InfoLevel
case "error":
level = ErrorLevel
default:
level = NoneLevel
}
}
|
[
"func",
"SetLevel",
"(",
"levelStr",
"string",
")",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"levelStr",
")",
"{",
"case",
"\"",
"\"",
":",
"level",
"=",
"TraceLevel",
"\n",
"case",
"\"",
"\"",
":",
"level",
"=",
"InfoLevel",
"\n",
"case",
"\"",
"\"",
":",
"level",
"=",
"ErrorLevel",
"\n",
"default",
":",
"level",
"=",
"NoneLevel",
"\n",
"}",
"\n",
"}"
] |
// SetLevel sets the logging level of this package. levelStr should be one of "trace", "info", or "error
|
[
"SetLevel",
"sets",
"the",
"logging",
"level",
"of",
"this",
"package",
".",
"levelStr",
"should",
"be",
"one",
"of",
"trace",
"info",
"or",
"error"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L34-L45
|
16,074 |
johnnadratowski/golang-neo4j-bolt-driver
|
log/log.go
|
Tracef
|
func Tracef(msg string, args ...interface{}) {
if level >= TraceLevel {
TraceLog.Printf(msg, args...)
}
}
|
go
|
func Tracef(msg string, args ...interface{}) {
if level >= TraceLevel {
TraceLog.Printf(msg, args...)
}
}
|
[
"func",
"Tracef",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">=",
"TraceLevel",
"{",
"TraceLog",
".",
"Printf",
"(",
"msg",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// Tracef writes a trace log in the format of Printf
|
[
"Tracef",
"writes",
"a",
"trace",
"log",
"in",
"the",
"format",
"of",
"Printf"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L60-L64
|
16,075 |
johnnadratowski/golang-neo4j-bolt-driver
|
log/log.go
|
Infof
|
func Infof(msg string, args ...interface{}) {
if level >= InfoLevel {
InfoLog.Printf(msg, args...)
}
}
|
go
|
func Infof(msg string, args ...interface{}) {
if level >= InfoLevel {
InfoLog.Printf(msg, args...)
}
}
|
[
"func",
"Infof",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">=",
"InfoLevel",
"{",
"InfoLog",
".",
"Printf",
"(",
"msg",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// Infof writes an info log in the format of Printf
|
[
"Infof",
"writes",
"an",
"info",
"log",
"in",
"the",
"format",
"of",
"Printf"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L74-L78
|
16,076 |
johnnadratowski/golang-neo4j-bolt-driver
|
log/log.go
|
Errorf
|
func Errorf(msg string, args ...interface{}) {
if level >= ErrorLevel {
ErrorLog.Printf(msg, args...)
}
}
|
go
|
func Errorf(msg string, args ...interface{}) {
if level >= ErrorLevel {
ErrorLog.Printf(msg, args...)
}
}
|
[
"func",
"Errorf",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">=",
"ErrorLevel",
"{",
"ErrorLog",
".",
"Printf",
"(",
"msg",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// Errorf writes an error log in the format of Printf
|
[
"Errorf",
"writes",
"an",
"error",
"log",
"in",
"the",
"format",
"of",
"Printf"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L88-L92
|
16,077 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/encoder.go
|
NewEncoder
|
func NewEncoder(w io.Writer, chunkSize uint16) Encoder {
return Encoder{
w: w,
buf: &bytes.Buffer{},
chunkSize: chunkSize,
}
}
|
go
|
func NewEncoder(w io.Writer, chunkSize uint16) Encoder {
return Encoder{
w: w,
buf: &bytes.Buffer{},
chunkSize: chunkSize,
}
}
|
[
"func",
"NewEncoder",
"(",
"w",
"io",
".",
"Writer",
",",
"chunkSize",
"uint16",
")",
"Encoder",
"{",
"return",
"Encoder",
"{",
"w",
":",
"w",
",",
"buf",
":",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"chunkSize",
":",
"chunkSize",
",",
"}",
"\n",
"}"
] |
// NewEncoder Creates a new Encoder object
|
[
"NewEncoder",
"Creates",
"a",
"new",
"Encoder",
"object"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L91-L97
|
16,078 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/encoder.go
|
Marshal
|
func Marshal(v interface{}) ([]byte, error) {
x := &bytes.Buffer{}
err := NewEncoder(x, math.MaxUint16).Encode(v)
return x.Bytes(), err
}
|
go
|
func Marshal(v interface{}) ([]byte, error) {
x := &bytes.Buffer{}
err := NewEncoder(x, math.MaxUint16).Encode(v)
return x.Bytes(), err
}
|
[
"func",
"Marshal",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"x",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"err",
":=",
"NewEncoder",
"(",
"x",
",",
"math",
".",
"MaxUint16",
")",
".",
"Encode",
"(",
"v",
")",
"\n",
"return",
"x",
".",
"Bytes",
"(",
")",
",",
"err",
"\n",
"}"
] |
// Marshal is used to marshal an object to the bolt interface encoded bytes
|
[
"Marshal",
"is",
"used",
"to",
"marshal",
"an",
"object",
"to",
"the",
"bolt",
"interface",
"encoded",
"bytes"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L100-L104
|
16,079 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/encoder.go
|
Write
|
func (e Encoder) Write(p []byte) (n int, err error) {
n, err = e.buf.Write(p)
if err != nil {
err = errors.Wrap(err, "An error occurred writing to encoder temp buffer")
return n, err
}
length := e.buf.Len()
for length >= int(e.chunkSize) {
if err := binary.Write(e.w, binary.BigEndian, e.chunkSize); err != nil {
return 0, errors.Wrap(err, "An error occured writing chunksize")
}
numWritten, err := e.w.Write(e.buf.Next(int(e.chunkSize)))
if err != nil {
err = errors.Wrap(err, "An error occured writing a chunk")
}
return numWritten, err
}
return n, nil
}
|
go
|
func (e Encoder) Write(p []byte) (n int, err error) {
n, err = e.buf.Write(p)
if err != nil {
err = errors.Wrap(err, "An error occurred writing to encoder temp buffer")
return n, err
}
length := e.buf.Len()
for length >= int(e.chunkSize) {
if err := binary.Write(e.w, binary.BigEndian, e.chunkSize); err != nil {
return 0, errors.Wrap(err, "An error occured writing chunksize")
}
numWritten, err := e.w.Write(e.buf.Next(int(e.chunkSize)))
if err != nil {
err = errors.Wrap(err, "An error occured writing a chunk")
}
return numWritten, err
}
return n, nil
}
|
[
"func",
"(",
"e",
"Encoder",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"n",
",",
"err",
"=",
"e",
".",
"buf",
".",
"Write",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}",
"\n\n",
"length",
":=",
"e",
".",
"buf",
".",
"Len",
"(",
")",
"\n",
"for",
"length",
">=",
"int",
"(",
"e",
".",
"chunkSize",
")",
"{",
"if",
"err",
":=",
"binary",
".",
"Write",
"(",
"e",
".",
"w",
",",
"binary",
".",
"BigEndian",
",",
"e",
".",
"chunkSize",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"numWritten",
",",
"err",
":=",
"e",
".",
"w",
".",
"Write",
"(",
"e",
".",
"buf",
".",
"Next",
"(",
"int",
"(",
"e",
".",
"chunkSize",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"numWritten",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] |
// write writes to the writer. Buffers the writes using chunkSize.
|
[
"write",
"writes",
"to",
"the",
"writer",
".",
"Buffers",
"the",
"writes",
"using",
"chunkSize",
"."
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L107-L130
|
16,080 |
johnnadratowski/golang-neo4j-bolt-driver
|
encoding/encoder.go
|
flush
|
func (e Encoder) flush() error {
length := e.buf.Len()
if length > 0 {
if err := binary.Write(e.w, binary.BigEndian, uint16(length)); err != nil {
return errors.Wrap(err, "An error occured writing length bytes during flush")
}
if _, err := e.buf.WriteTo(e.w); err != nil {
return errors.Wrap(err, "An error occured writing message bytes during flush")
}
}
_, err := e.w.Write(EndMessage)
if err != nil {
return errors.Wrap(err, "An error occurred ending encoding message")
}
e.buf.Reset()
return nil
}
|
go
|
func (e Encoder) flush() error {
length := e.buf.Len()
if length > 0 {
if err := binary.Write(e.w, binary.BigEndian, uint16(length)); err != nil {
return errors.Wrap(err, "An error occured writing length bytes during flush")
}
if _, err := e.buf.WriteTo(e.w); err != nil {
return errors.Wrap(err, "An error occured writing message bytes during flush")
}
}
_, err := e.w.Write(EndMessage)
if err != nil {
return errors.Wrap(err, "An error occurred ending encoding message")
}
e.buf.Reset()
return nil
}
|
[
"func",
"(",
"e",
"Encoder",
")",
"flush",
"(",
")",
"error",
"{",
"length",
":=",
"e",
".",
"buf",
".",
"Len",
"(",
")",
"\n",
"if",
"length",
">",
"0",
"{",
"if",
"err",
":=",
"binary",
".",
"Write",
"(",
"e",
".",
"w",
",",
"binary",
".",
"BigEndian",
",",
"uint16",
"(",
"length",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"e",
".",
"buf",
".",
"WriteTo",
"(",
"e",
".",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"e",
".",
"w",
".",
"Write",
"(",
"EndMessage",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"e",
".",
"buf",
".",
"Reset",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// flush finishes the encoding stream by flushing it to the writer
|
[
"flush",
"finishes",
"the",
"encoding",
"stream",
"by",
"flushing",
"it",
"to",
"the",
"writer"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L133-L152
|
16,081 |
johnnadratowski/golang-neo4j-bolt-driver
|
recorder.go
|
Read
|
func (r *recorder) Read(b []byte) (n int, err error) {
if r.Conn != nil {
numRead, err := r.Conn.Read(b)
if numRead > 0 {
r.record(b[:numRead], false)
}
if err != nil {
r.recordErr(err, false)
}
return numRead, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to read past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if event.IsWrite {
return 0, errors.New("Recorder expected Read, got Write! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to read past current event in recorder! Bytes: %s. Recorder %#v, Event; %#v", b, r, event)
}
b[i] = event.Event[0]
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
}
|
go
|
func (r *recorder) Read(b []byte) (n int, err error) {
if r.Conn != nil {
numRead, err := r.Conn.Read(b)
if numRead > 0 {
r.record(b[:numRead], false)
}
if err != nil {
r.recordErr(err, false)
}
return numRead, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to read past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if event.IsWrite {
return 0, errors.New("Recorder expected Read, got Write! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to read past current event in recorder! Bytes: %s. Recorder %#v, Event; %#v", b, r, event)
}
b[i] = event.Event[0]
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
}
|
[
"func",
"(",
"r",
"*",
"recorder",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"r",
".",
"Conn",
"!=",
"nil",
"{",
"numRead",
",",
"err",
":=",
"r",
".",
"Conn",
".",
"Read",
"(",
"b",
")",
"\n",
"if",
"numRead",
">",
"0",
"{",
"r",
".",
"record",
"(",
"b",
"[",
":",
"numRead",
"]",
",",
"false",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"r",
".",
"recordErr",
"(",
"err",
",",
"false",
")",
"\n",
"}",
"\n\n",
"return",
"numRead",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"currentEvent",
">=",
"len",
"(",
"r",
".",
"events",
")",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n",
"event",
":=",
"r",
".",
"events",
"[",
"r",
".",
"currentEvent",
"]",
"\n",
"if",
"event",
".",
"IsWrite",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
",",
"event",
")",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"b",
")",
";",
"i",
"++",
"{",
"if",
"len",
"(",
"event",
".",
"Event",
")",
"==",
"0",
"{",
"return",
"i",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"b",
",",
"r",
",",
"event",
")",
"\n",
"}",
"\n",
"b",
"[",
"i",
"]",
"=",
"event",
".",
"Event",
"[",
"0",
"]",
"\n",
"event",
".",
"Event",
"=",
"event",
".",
"Event",
"[",
"1",
":",
"]",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"event",
".",
"Event",
")",
"==",
"0",
"{",
"r",
".",
"currentEvent",
"++",
"\n",
"}",
"\n\n",
"return",
"len",
"(",
"b",
")",
",",
"nil",
"\n",
"}"
] |
// Read from the net conn, recording the interaction
|
[
"Read",
"from",
"the",
"net",
"conn",
"recording",
"the",
"interaction"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/recorder.go#L58-L93
|
16,082 |
johnnadratowski/golang-neo4j-bolt-driver
|
recorder.go
|
Close
|
func (r *recorder) Close() error {
if r.Conn != nil {
err := r.flush()
if err != nil {
return err
}
return r.Conn.Close()
} else if len(r.events) > 0 {
if r.currentEvent != len(r.events) {
return errors.New("Didn't read all of the events in the recorder on close! %#v", r)
}
if len(r.events[len(r.events)-1].Event) != 0 {
return errors.New("Left data in an event in the recorder on close! %#v", r)
}
return nil
}
return nil
}
|
go
|
func (r *recorder) Close() error {
if r.Conn != nil {
err := r.flush()
if err != nil {
return err
}
return r.Conn.Close()
} else if len(r.events) > 0 {
if r.currentEvent != len(r.events) {
return errors.New("Didn't read all of the events in the recorder on close! %#v", r)
}
if len(r.events[len(r.events)-1].Event) != 0 {
return errors.New("Left data in an event in the recorder on close! %#v", r)
}
return nil
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"recorder",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"Conn",
"!=",
"nil",
"{",
"err",
":=",
"r",
".",
"flush",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"r",
".",
"Conn",
".",
"Close",
"(",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"r",
".",
"events",
")",
">",
"0",
"{",
"if",
"r",
".",
"currentEvent",
"!=",
"len",
"(",
"r",
".",
"events",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"r",
".",
"events",
"[",
"len",
"(",
"r",
".",
"events",
")",
"-",
"1",
"]",
".",
"Event",
")",
"!=",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Close the net conn, outputting the recording
|
[
"Close",
"the",
"net",
"conn",
"outputting",
"the",
"recording"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/recorder.go#L96-L116
|
16,083 |
johnnadratowski/golang-neo4j-bolt-driver
|
recorder.go
|
Write
|
func (r *recorder) Write(b []byte) (n int, err error) {
if r.Conn != nil {
numWritten, err := r.Conn.Write(b)
if numWritten > 0 {
r.record(b[:numWritten], true)
}
if err != nil {
r.recordErr(err, true)
}
return numWritten, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to write past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if !event.IsWrite {
return 0, errors.New("Recorder expected Write, got Read! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to write past current event in recorder! %#v, Event: %#v", r, event)
}
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
}
|
go
|
func (r *recorder) Write(b []byte) (n int, err error) {
if r.Conn != nil {
numWritten, err := r.Conn.Write(b)
if numWritten > 0 {
r.record(b[:numWritten], true)
}
if err != nil {
r.recordErr(err, true)
}
return numWritten, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to write past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if !event.IsWrite {
return 0, errors.New("Recorder expected Write, got Read! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to write past current event in recorder! %#v, Event: %#v", r, event)
}
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
}
|
[
"func",
"(",
"r",
"*",
"recorder",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"r",
".",
"Conn",
"!=",
"nil",
"{",
"numWritten",
",",
"err",
":=",
"r",
".",
"Conn",
".",
"Write",
"(",
"b",
")",
"\n",
"if",
"numWritten",
">",
"0",
"{",
"r",
".",
"record",
"(",
"b",
"[",
":",
"numWritten",
"]",
",",
"true",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"r",
".",
"recordErr",
"(",
"err",
",",
"true",
")",
"\n",
"}",
"\n\n",
"return",
"numWritten",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"currentEvent",
">=",
"len",
"(",
"r",
".",
"events",
")",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n",
"event",
":=",
"r",
".",
"events",
"[",
"r",
".",
"currentEvent",
"]",
"\n",
"if",
"!",
"event",
".",
"IsWrite",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
",",
"event",
")",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"b",
")",
";",
"i",
"++",
"{",
"if",
"len",
"(",
"event",
".",
"Event",
")",
"==",
"0",
"{",
"return",
"i",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
",",
"r",
",",
"event",
")",
"\n",
"}",
"\n",
"event",
".",
"Event",
"=",
"event",
".",
"Event",
"[",
"1",
":",
"]",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"event",
".",
"Event",
")",
"==",
"0",
"{",
"r",
".",
"currentEvent",
"++",
"\n",
"}",
"\n\n",
"return",
"len",
"(",
"b",
")",
",",
"nil",
"\n",
"}"
] |
// Write to the net conn, recording the interaction
|
[
"Write",
"to",
"the",
"net",
"conn",
"recording",
"the",
"interaction"
] |
6b24c0085aaeaf3b2844acd18066864e24b57387
|
https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/recorder.go#L119-L153
|
16,084 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
init
|
func init() {
revel.RegisterServerEngine("fasthttp", func() revel.ServerEngine {
return &FastHTTPServer{}
})
revel.RegisterModuleInit(func(m *revel.Module) {
serverLog = m.Log
})
}
|
go
|
func init() {
revel.RegisterServerEngine("fasthttp", func() revel.ServerEngine {
return &FastHTTPServer{}
})
revel.RegisterModuleInit(func(m *revel.Module) {
serverLog = m.Log
})
}
|
[
"func",
"init",
"(",
")",
"{",
"revel",
".",
"RegisterServerEngine",
"(",
"\"",
"\"",
",",
"func",
"(",
")",
"revel",
".",
"ServerEngine",
"{",
"return",
"&",
"FastHTTPServer",
"{",
"}",
"\n",
"}",
")",
"\n",
"revel",
".",
"RegisterModuleInit",
"(",
"func",
"(",
"m",
"*",
"revel",
".",
"Module",
")",
"{",
"serverLog",
"=",
"m",
".",
"Log",
"\n",
"}",
")",
"\n",
"}"
] |
// Called to initialize
|
[
"Called",
"to",
"initialize"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L39-L46
|
16,085 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Init
|
func (f *FastHTTPServer) Init(init *revel.EngineInit) {
f.MaxMultipartSize = int64(revel.Config.IntDefault("server.request.max.multipart.filesize", 32)) << 20 /* 32 MB */
fastHttpContextStack = utils.NewStackLock(revel.Config.IntDefault("server.context.stack", 100),
revel.Config.IntDefault("server.context.maxstack", 200),
func() interface{} { return NewFastHttpContext(f) })
fastHttpMultipartFormStack = utils.NewStackLock(revel.Config.IntDefault("server.form.stack", 100),
revel.Config.IntDefault("server.form.maxstack", 200),
func() interface{} { return &FastHttpMultipartForm{} })
requestHandler := func(ctx *fasthttp.RequestCtx) {
f.RequestHandler(ctx)
}
// Adds the mux list
f.HttpMuxList = init.HTTPMuxList
sort.Sort(f.HttpMuxList)
f.HasAppMux = len(f.HttpMuxList) > 0
f.signalChan = make(chan os.Signal)
f.ServerInit = init
f.Server = &fasthttp.Server{
ReadTimeout: time.Duration(revel.Config.IntDefault("http.timeout.read", 0)) * time.Second,
WriteTimeout: time.Duration(revel.Config.IntDefault("http.timeout.write", 0)) * time.Second,
Handler: requestHandler,
}
}
|
go
|
func (f *FastHTTPServer) Init(init *revel.EngineInit) {
f.MaxMultipartSize = int64(revel.Config.IntDefault("server.request.max.multipart.filesize", 32)) << 20 /* 32 MB */
fastHttpContextStack = utils.NewStackLock(revel.Config.IntDefault("server.context.stack", 100),
revel.Config.IntDefault("server.context.maxstack", 200),
func() interface{} { return NewFastHttpContext(f) })
fastHttpMultipartFormStack = utils.NewStackLock(revel.Config.IntDefault("server.form.stack", 100),
revel.Config.IntDefault("server.form.maxstack", 200),
func() interface{} { return &FastHttpMultipartForm{} })
requestHandler := func(ctx *fasthttp.RequestCtx) {
f.RequestHandler(ctx)
}
// Adds the mux list
f.HttpMuxList = init.HTTPMuxList
sort.Sort(f.HttpMuxList)
f.HasAppMux = len(f.HttpMuxList) > 0
f.signalChan = make(chan os.Signal)
f.ServerInit = init
f.Server = &fasthttp.Server{
ReadTimeout: time.Duration(revel.Config.IntDefault("http.timeout.read", 0)) * time.Second,
WriteTimeout: time.Duration(revel.Config.IntDefault("http.timeout.write", 0)) * time.Second,
Handler: requestHandler,
}
}
|
[
"func",
"(",
"f",
"*",
"FastHTTPServer",
")",
"Init",
"(",
"init",
"*",
"revel",
".",
"EngineInit",
")",
"{",
"f",
".",
"MaxMultipartSize",
"=",
"int64",
"(",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"32",
")",
")",
"<<",
"20",
"/* 32 MB */",
"\n",
"fastHttpContextStack",
"=",
"utils",
".",
"NewStackLock",
"(",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"100",
")",
",",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"200",
")",
",",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"return",
"NewFastHttpContext",
"(",
"f",
")",
"}",
")",
"\n",
"fastHttpMultipartFormStack",
"=",
"utils",
".",
"NewStackLock",
"(",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"100",
")",
",",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"200",
")",
",",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"FastHttpMultipartForm",
"{",
"}",
"}",
")",
"\n\n",
"requestHandler",
":=",
"func",
"(",
"ctx",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"f",
".",
"RequestHandler",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"// Adds the mux list",
"f",
".",
"HttpMuxList",
"=",
"init",
".",
"HTTPMuxList",
"\n",
"sort",
".",
"Sort",
"(",
"f",
".",
"HttpMuxList",
")",
"\n",
"f",
".",
"HasAppMux",
"=",
"len",
"(",
"f",
".",
"HttpMuxList",
")",
">",
"0",
"\n\n",
"f",
".",
"signalChan",
"=",
"make",
"(",
"chan",
"os",
".",
"Signal",
")",
"\n\n",
"f",
".",
"ServerInit",
"=",
"init",
"\n",
"f",
".",
"Server",
"=",
"&",
"fasthttp",
".",
"Server",
"{",
"ReadTimeout",
":",
"time",
".",
"Duration",
"(",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"0",
")",
")",
"*",
"time",
".",
"Second",
",",
"WriteTimeout",
":",
"time",
".",
"Duration",
"(",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"0",
")",
")",
"*",
"time",
".",
"Second",
",",
"Handler",
":",
"requestHandler",
",",
"}",
"\n\n",
"}"
] |
// Called to initialize the FastHttpServer
|
[
"Called",
"to",
"initialize",
"the",
"FastHttpServer"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L49-L75
|
16,086 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
RequestHandler
|
func (f *FastHTTPServer) RequestHandler(ctx *fasthttp.RequestCtx) {
// This section is called if the developer has added custom mux to the app
if f.HasAppMux && f.handleAppMux(ctx) {
return
}
f.handleMux(ctx)
}
|
go
|
func (f *FastHTTPServer) RequestHandler(ctx *fasthttp.RequestCtx) {
// This section is called if the developer has added custom mux to the app
if f.HasAppMux && f.handleAppMux(ctx) {
return
}
f.handleMux(ctx)
}
|
[
"func",
"(",
"f",
"*",
"FastHTTPServer",
")",
"RequestHandler",
"(",
"ctx",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"// This section is called if the developer has added custom mux to the app",
"if",
"f",
".",
"HasAppMux",
"&&",
"f",
".",
"handleAppMux",
"(",
"ctx",
")",
"{",
"return",
"\n",
"}",
"\n",
"f",
".",
"handleMux",
"(",
"ctx",
")",
"\n",
"}"
] |
// The root handler
|
[
"The",
"root",
"handler"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L111-L117
|
16,087 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Event
|
func (f *FastHTTPServer) Event(event revel.Event, args interface{}) revel.EventResponse {
switch event {
case revel.ENGINE_STARTED:
signal.Notify(f.signalChan, os.Interrupt, os.Kill)
go func() {
_ = <-f.signalChan
serverLog.Info("Received quit singal Please wait ... ")
revel.StopServer(nil)
}()
case revel.ENGINE_SHUTDOWN_REQUEST:
if err := f.graceful.Close(); err != nil {
serverLog.Fatal("Failed to close fasthttp server gracefully, exiting using os.exit", "error", err)
}
default:
}
return 0
}
|
go
|
func (f *FastHTTPServer) Event(event revel.Event, args interface{}) revel.EventResponse {
switch event {
case revel.ENGINE_STARTED:
signal.Notify(f.signalChan, os.Interrupt, os.Kill)
go func() {
_ = <-f.signalChan
serverLog.Info("Received quit singal Please wait ... ")
revel.StopServer(nil)
}()
case revel.ENGINE_SHUTDOWN_REQUEST:
if err := f.graceful.Close(); err != nil {
serverLog.Fatal("Failed to close fasthttp server gracefully, exiting using os.exit", "error", err)
}
default:
}
return 0
}
|
[
"func",
"(",
"f",
"*",
"FastHTTPServer",
")",
"Event",
"(",
"event",
"revel",
".",
"Event",
",",
"args",
"interface",
"{",
"}",
")",
"revel",
".",
"EventResponse",
"{",
"switch",
"event",
"{",
"case",
"revel",
".",
"ENGINE_STARTED",
":",
"signal",
".",
"Notify",
"(",
"f",
".",
"signalChan",
",",
"os",
".",
"Interrupt",
",",
"os",
".",
"Kill",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"_",
"=",
"<-",
"f",
".",
"signalChan",
"\n",
"serverLog",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"revel",
".",
"StopServer",
"(",
"nil",
")",
"\n",
"}",
"(",
")",
"\n",
"case",
"revel",
".",
"ENGINE_SHUTDOWN_REQUEST",
":",
"if",
"err",
":=",
"f",
".",
"graceful",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"serverLog",
".",
"Fatal",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"default",
":",
"}",
"\n",
"return",
"0",
"\n",
"}"
] |
// Handle an event generated from Revel
|
[
"Handle",
"an",
"event",
"generated",
"from",
"Revel"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L197-L215
|
16,088 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
NewFastHttpContext
|
func NewFastHttpContext(instance *FastHTTPServer) *FastHttpContext {
if instance == nil {
instance = &FastHTTPServer{MaxMultipartSize: 32 << 20}
}
c := &FastHttpContext{
Request: &FastHttpRequest{header: &FastHttpHeader{isResponse: false},
Engine: instance},
Response: &FastHttpResponse{header: &FastHttpHeader{isResponse: true},
Engine: instance},
}
c.Response.header.Source = c.Response
c.Request.header.Source = c.Request
return c
}
|
go
|
func NewFastHttpContext(instance *FastHTTPServer) *FastHttpContext {
if instance == nil {
instance = &FastHTTPServer{MaxMultipartSize: 32 << 20}
}
c := &FastHttpContext{
Request: &FastHttpRequest{header: &FastHttpHeader{isResponse: false},
Engine: instance},
Response: &FastHttpResponse{header: &FastHttpHeader{isResponse: true},
Engine: instance},
}
c.Response.header.Source = c.Response
c.Request.header.Source = c.Request
return c
}
|
[
"func",
"NewFastHttpContext",
"(",
"instance",
"*",
"FastHTTPServer",
")",
"*",
"FastHttpContext",
"{",
"if",
"instance",
"==",
"nil",
"{",
"instance",
"=",
"&",
"FastHTTPServer",
"{",
"MaxMultipartSize",
":",
"32",
"<<",
"20",
"}",
"\n",
"}",
"\n",
"c",
":=",
"&",
"FastHttpContext",
"{",
"Request",
":",
"&",
"FastHttpRequest",
"{",
"header",
":",
"&",
"FastHttpHeader",
"{",
"isResponse",
":",
"false",
"}",
",",
"Engine",
":",
"instance",
"}",
",",
"Response",
":",
"&",
"FastHttpResponse",
"{",
"header",
":",
"&",
"FastHttpHeader",
"{",
"isResponse",
":",
"true",
"}",
",",
"Engine",
":",
"instance",
"}",
",",
"}",
"\n",
"c",
".",
"Response",
".",
"header",
".",
"Source",
"=",
"c",
".",
"Response",
"\n",
"c",
".",
"Request",
".",
"header",
".",
"Source",
"=",
"c",
".",
"Request",
"\n",
"return",
"c",
"\n",
"}"
] |
// Create a new context
|
[
"Create",
"a",
"new",
"context"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L283-L296
|
16,089 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
SetContext
|
func (c *FastHttpContext) SetContext(context *fasthttp.RequestCtx) {
c.Response.SetContext(context)
c.Request.SetContext(context)
}
|
go
|
func (c *FastHttpContext) SetContext(context *fasthttp.RequestCtx) {
c.Response.SetContext(context)
c.Request.SetContext(context)
}
|
[
"func",
"(",
"c",
"*",
"FastHttpContext",
")",
"SetContext",
"(",
"context",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"c",
".",
"Response",
".",
"SetContext",
"(",
"context",
")",
"\n",
"c",
".",
"Request",
".",
"SetContext",
"(",
"context",
")",
"\n",
"}"
] |
// Called to set the context
|
[
"Called",
"to",
"set",
"the",
"context"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L309-L312
|
16,090 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Get
|
func (r *FastHttpRequest) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.GetHeader()
case revel.HTTP_MULTIPART_FORM:
value, err = r.GetMultipartForm()
case revel.HTTP_QUERY:
value = r.GetQuery()
case revel.HTTP_FORM:
value, err = r.GetForm()
case revel.HTTP_REQUEST_URI:
value = string(r.Original.RequestURI())
case revel.HTTP_REMOTE_ADDR:
value = r.Original.RemoteAddr().String()
case revel.HTTP_METHOD:
value = string(r.Original.Method())
case revel.HTTP_PATH:
value = string(r.Original.Path())
case revel.HTTP_HOST:
value = string(r.Original.Request.Host())
case revel.HTTP_URL:
if r.url == nil {
r.url, _ = url.Parse(string(r.Original.Request.URI().FullURI()))
}
value = r.url
case revel.HTTP_BODY:
value = bytes.NewBuffer(r.Original.Request.Body())
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
}
|
go
|
func (r *FastHttpRequest) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.GetHeader()
case revel.HTTP_MULTIPART_FORM:
value, err = r.GetMultipartForm()
case revel.HTTP_QUERY:
value = r.GetQuery()
case revel.HTTP_FORM:
value, err = r.GetForm()
case revel.HTTP_REQUEST_URI:
value = string(r.Original.RequestURI())
case revel.HTTP_REMOTE_ADDR:
value = r.Original.RemoteAddr().String()
case revel.HTTP_METHOD:
value = string(r.Original.Method())
case revel.HTTP_PATH:
value = string(r.Original.Path())
case revel.HTTP_HOST:
value = string(r.Original.Request.Host())
case revel.HTTP_URL:
if r.url == nil {
r.url, _ = url.Parse(string(r.Original.Request.URI().FullURI()))
}
value = r.url
case revel.HTTP_BODY:
value = bytes.NewBuffer(r.Original.Request.Body())
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
}
|
[
"func",
"(",
"r",
"*",
"FastHttpRequest",
")",
"Get",
"(",
"key",
"int",
")",
"(",
"value",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"switch",
"key",
"{",
"case",
"revel",
".",
"HTTP_SERVER_HEADER",
":",
"value",
"=",
"r",
".",
"GetHeader",
"(",
")",
"\n",
"case",
"revel",
".",
"HTTP_MULTIPART_FORM",
":",
"value",
",",
"err",
"=",
"r",
".",
"GetMultipartForm",
"(",
")",
"\n",
"case",
"revel",
".",
"HTTP_QUERY",
":",
"value",
"=",
"r",
".",
"GetQuery",
"(",
")",
"\n",
"case",
"revel",
".",
"HTTP_FORM",
":",
"value",
",",
"err",
"=",
"r",
".",
"GetForm",
"(",
")",
"\n",
"case",
"revel",
".",
"HTTP_REQUEST_URI",
":",
"value",
"=",
"string",
"(",
"r",
".",
"Original",
".",
"RequestURI",
"(",
")",
")",
"\n",
"case",
"revel",
".",
"HTTP_REMOTE_ADDR",
":",
"value",
"=",
"r",
".",
"Original",
".",
"RemoteAddr",
"(",
")",
".",
"String",
"(",
")",
"\n",
"case",
"revel",
".",
"HTTP_METHOD",
":",
"value",
"=",
"string",
"(",
"r",
".",
"Original",
".",
"Method",
"(",
")",
")",
"\n",
"case",
"revel",
".",
"HTTP_PATH",
":",
"value",
"=",
"string",
"(",
"r",
".",
"Original",
".",
"Path",
"(",
")",
")",
"\n",
"case",
"revel",
".",
"HTTP_HOST",
":",
"value",
"=",
"string",
"(",
"r",
".",
"Original",
".",
"Request",
".",
"Host",
"(",
")",
")",
"\n",
"case",
"revel",
".",
"HTTP_URL",
":",
"if",
"r",
".",
"url",
"==",
"nil",
"{",
"r",
".",
"url",
",",
"_",
"=",
"url",
".",
"Parse",
"(",
"string",
"(",
"r",
".",
"Original",
".",
"Request",
".",
"URI",
"(",
")",
".",
"FullURI",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"value",
"=",
"r",
".",
"url",
"\n",
"case",
"revel",
".",
"HTTP_BODY",
":",
"value",
"=",
"bytes",
".",
"NewBuffer",
"(",
"r",
".",
"Original",
".",
"Request",
".",
"Body",
"(",
")",
")",
"\n",
"default",
":",
"err",
"=",
"revel",
".",
"ENGINE_UNKNOWN_GET",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Gets the value from the request
|
[
"Gets",
"the",
"value",
"from",
"the",
"request"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L321-L353
|
16,091 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
GetQuery
|
func (r *FastHttpRequest) GetQuery() url.Values {
if !r.toQuery {
// Attempt to convert to query
r.query = url.Values{}
r.Original.QueryArgs().VisitAll(func(key, value []byte) {
r.query.Set(string(key), string(value))
})
r.toQuery = true
}
return r.query
}
|
go
|
func (r *FastHttpRequest) GetQuery() url.Values {
if !r.toQuery {
// Attempt to convert to query
r.query = url.Values{}
r.Original.QueryArgs().VisitAll(func(key, value []byte) {
r.query.Set(string(key), string(value))
})
r.toQuery = true
}
return r.query
}
|
[
"func",
"(",
"r",
"*",
"FastHttpRequest",
")",
"GetQuery",
"(",
")",
"url",
".",
"Values",
"{",
"if",
"!",
"r",
".",
"toQuery",
"{",
"// Attempt to convert to query",
"r",
".",
"query",
"=",
"url",
".",
"Values",
"{",
"}",
"\n",
"r",
".",
"Original",
".",
"QueryArgs",
"(",
")",
".",
"VisitAll",
"(",
"func",
"(",
"key",
",",
"value",
"[",
"]",
"byte",
")",
"{",
"r",
".",
"query",
".",
"Set",
"(",
"string",
"(",
"key",
")",
",",
"string",
"(",
"value",
")",
")",
"\n",
"}",
")",
"\n",
"r",
".",
"toQuery",
"=",
"true",
"\n",
"}",
"\n",
"return",
"r",
".",
"query",
"\n",
"}"
] |
// Returns the query string
|
[
"Returns",
"the",
"query",
"string"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L361-L371
|
16,092 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Destroy
|
func (r *FastHttpRequest) Destroy() {
r.Original = nil
r.FormParsed = false
r.MultiFormParsed = false
r.ParsedForm = nil
r.toQuery = false
}
|
go
|
func (r *FastHttpRequest) Destroy() {
r.Original = nil
r.FormParsed = false
r.MultiFormParsed = false
r.ParsedForm = nil
r.toQuery = false
}
|
[
"func",
"(",
"r",
"*",
"FastHttpRequest",
")",
"Destroy",
"(",
")",
"{",
"r",
".",
"Original",
"=",
"nil",
"\n",
"r",
".",
"FormParsed",
"=",
"false",
"\n",
"r",
".",
"MultiFormParsed",
"=",
"false",
"\n",
"r",
".",
"ParsedForm",
"=",
"nil",
"\n",
"r",
".",
"toQuery",
"=",
"false",
"\n\n",
"}"
] |
// Called when request is done
|
[
"Called",
"when",
"request",
"is",
"done"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L418-L425
|
16,093 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Get
|
func (r *FastHttpResponse) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.Header()
case revel.HTTP_STREAM_WRITER:
value = r
case revel.HTTP_WRITER:
value = r.Writer
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
}
|
go
|
func (r *FastHttpResponse) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.Header()
case revel.HTTP_STREAM_WRITER:
value = r
case revel.HTTP_WRITER:
value = r.Writer
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
}
|
[
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"Get",
"(",
"key",
"int",
")",
"(",
"value",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"switch",
"key",
"{",
"case",
"revel",
".",
"HTTP_SERVER_HEADER",
":",
"value",
"=",
"r",
".",
"Header",
"(",
")",
"\n",
"case",
"revel",
".",
"HTTP_STREAM_WRITER",
":",
"value",
"=",
"r",
"\n",
"case",
"revel",
".",
"HTTP_WRITER",
":",
"value",
"=",
"r",
".",
"Writer",
"\n",
"default",
":",
"err",
"=",
"revel",
".",
"ENGINE_UNKNOWN_GET",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// gets the key from the response
|
[
"gets",
"the",
"key",
"from",
"the",
"response"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L428-L440
|
16,094 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Set
|
func (r *FastHttpResponse) Set(key int, value interface{}) (set bool) {
switch key {
case revel.ENGINE_RESPONSE_STATUS:
r.Header().SetStatus(value.(int))
set = true
case revel.HTTP_WRITER:
r.SetWriter(value.(io.Writer))
set = true
}
return
}
|
go
|
func (r *FastHttpResponse) Set(key int, value interface{}) (set bool) {
switch key {
case revel.ENGINE_RESPONSE_STATUS:
r.Header().SetStatus(value.(int))
set = true
case revel.HTTP_WRITER:
r.SetWriter(value.(io.Writer))
set = true
}
return
}
|
[
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"Set",
"(",
"key",
"int",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"set",
"bool",
")",
"{",
"switch",
"key",
"{",
"case",
"revel",
".",
"ENGINE_RESPONSE_STATUS",
":",
"r",
".",
"Header",
"(",
")",
".",
"SetStatus",
"(",
"value",
".",
"(",
"int",
")",
")",
"\n",
"set",
"=",
"true",
"\n",
"case",
"revel",
".",
"HTTP_WRITER",
":",
"r",
".",
"SetWriter",
"(",
"value",
".",
"(",
"io",
".",
"Writer",
")",
")",
"\n",
"set",
"=",
"true",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Sets the key with the value
|
[
"Sets",
"the",
"key",
"with",
"the",
"value"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L443-L453
|
16,095 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
WriteStream
|
func (r *FastHttpResponse) WriteStream(name string, contentlen int64, modtime time.Time, reader io.Reader) error {
// do a simple io.Copy, we do it directly into the writer which may be configured to be a compressed
// writer
ius := r.Original.Request.Header.Peek("If-Unmodified-Since")
if t, err := http.ParseTime(string(ius)); ius != nil && err == nil && !modtime.IsZero() {
// The Date-Modified header truncates sub-second precision, so
// use mtime < t+1s instead of mtime <= t to check for unmodified.
if modtime.Before(t.Add(1 * time.Second)) {
h := r.Original.Response.Header
h.Del("Content-Type")
h.Del("Content-Length")
if h.Peek("Etag") != nil {
h.Del("Last-Modified")
}
h.SetStatusCode(http.StatusNotModified)
return nil
}
}
if contentlen != -1 {
r.Original.Response.Header.Set("Content-Length", strconv.FormatInt(contentlen, 10))
}
if _, err := io.Copy(r.Writer, reader); err != nil {
r.Original.Response.Header.SetStatusCode(http.StatusInternalServerError)
return err
} else {
r.Original.Response.Header.SetStatusCode(http.StatusOK)
}
return nil
}
|
go
|
func (r *FastHttpResponse) WriteStream(name string, contentlen int64, modtime time.Time, reader io.Reader) error {
// do a simple io.Copy, we do it directly into the writer which may be configured to be a compressed
// writer
ius := r.Original.Request.Header.Peek("If-Unmodified-Since")
if t, err := http.ParseTime(string(ius)); ius != nil && err == nil && !modtime.IsZero() {
// The Date-Modified header truncates sub-second precision, so
// use mtime < t+1s instead of mtime <= t to check for unmodified.
if modtime.Before(t.Add(1 * time.Second)) {
h := r.Original.Response.Header
h.Del("Content-Type")
h.Del("Content-Length")
if h.Peek("Etag") != nil {
h.Del("Last-Modified")
}
h.SetStatusCode(http.StatusNotModified)
return nil
}
}
if contentlen != -1 {
r.Original.Response.Header.Set("Content-Length", strconv.FormatInt(contentlen, 10))
}
if _, err := io.Copy(r.Writer, reader); err != nil {
r.Original.Response.Header.SetStatusCode(http.StatusInternalServerError)
return err
} else {
r.Original.Response.Header.SetStatusCode(http.StatusOK)
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"WriteStream",
"(",
"name",
"string",
",",
"contentlen",
"int64",
",",
"modtime",
"time",
".",
"Time",
",",
"reader",
"io",
".",
"Reader",
")",
"error",
"{",
"// do a simple io.Copy, we do it directly into the writer which may be configured to be a compressed",
"// writer",
"ius",
":=",
"r",
".",
"Original",
".",
"Request",
".",
"Header",
".",
"Peek",
"(",
"\"",
"\"",
")",
"\n",
"if",
"t",
",",
"err",
":=",
"http",
".",
"ParseTime",
"(",
"string",
"(",
"ius",
")",
")",
";",
"ius",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"&&",
"!",
"modtime",
".",
"IsZero",
"(",
")",
"{",
"// The Date-Modified header truncates sub-second precision, so",
"// use mtime < t+1s instead of mtime <= t to check for unmodified.",
"if",
"modtime",
".",
"Before",
"(",
"t",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Second",
")",
")",
"{",
"h",
":=",
"r",
".",
"Original",
".",
"Response",
".",
"Header",
"\n",
"h",
".",
"Del",
"(",
"\"",
"\"",
")",
"\n",
"h",
".",
"Del",
"(",
"\"",
"\"",
")",
"\n",
"if",
"h",
".",
"Peek",
"(",
"\"",
"\"",
")",
"!=",
"nil",
"{",
"h",
".",
"Del",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"h",
".",
"SetStatusCode",
"(",
"http",
".",
"StatusNotModified",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"contentlen",
"!=",
"-",
"1",
"{",
"r",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"strconv",
".",
"FormatInt",
"(",
"contentlen",
",",
"10",
")",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"r",
".",
"Writer",
",",
"reader",
")",
";",
"err",
"!=",
"nil",
"{",
"r",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"SetStatusCode",
"(",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"err",
"\n",
"}",
"else",
"{",
"r",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"SetStatusCode",
"(",
"http",
".",
"StatusOK",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Writes a stream to the response
|
[
"Writes",
"a",
"stream",
"to",
"the",
"response"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L471-L502
|
16,096 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Destroy
|
func (r *FastHttpResponse) Destroy() {
if c, ok := r.Writer.(io.Closer); ok {
c.Close()
}
r.Original = nil
r.Writer = nil
}
|
go
|
func (r *FastHttpResponse) Destroy() {
if c, ok := r.Writer.(io.Closer); ok {
c.Close()
}
r.Original = nil
r.Writer = nil
}
|
[
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"Destroy",
"(",
")",
"{",
"if",
"c",
",",
"ok",
":=",
"r",
".",
"Writer",
".",
"(",
"io",
".",
"Closer",
")",
";",
"ok",
"{",
"c",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"r",
".",
"Original",
"=",
"nil",
"\n",
"r",
".",
"Writer",
"=",
"nil",
"\n\n",
"}"
] |
// Called to reset this response
|
[
"Called",
"to",
"reset",
"this",
"response"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L505-L512
|
16,097 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
SetContext
|
func (r *FastHttpResponse) SetContext(w *fasthttp.RequestCtx) {
r.Original = w
r.Writer = w.Response.BodyWriter()
}
|
go
|
func (r *FastHttpResponse) SetContext(w *fasthttp.RequestCtx) {
r.Original = w
r.Writer = w.Response.BodyWriter()
}
|
[
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"SetContext",
"(",
"w",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"r",
".",
"Original",
"=",
"w",
"\n",
"r",
".",
"Writer",
"=",
"w",
".",
"Response",
".",
"BodyWriter",
"(",
")",
"\n",
"}"
] |
// Sets the context
|
[
"Sets",
"the",
"context"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L515-L518
|
16,098 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
SetCookie
|
func (r *FastHttpHeader) SetCookie(cookie string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Add("Set-Cookie", cookie)
}
}
|
go
|
func (r *FastHttpHeader) SetCookie(cookie string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Add("Set-Cookie", cookie)
}
}
|
[
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"SetCookie",
"(",
"cookie",
"string",
")",
"{",
"if",
"r",
".",
"isResponse",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"cookie",
")",
"\n",
"}",
"\n",
"}"
] |
// Sets a cookie
|
[
"Sets",
"a",
"cookie"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L526-L530
|
16,099 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Del
|
func (r *FastHttpHeader) Del(key string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Del(key)
}
}
|
go
|
func (r *FastHttpHeader) Del(key string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Del(key)
}
}
|
[
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"Del",
"(",
"key",
"string",
")",
"{",
"if",
"r",
".",
"isResponse",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"Del",
"(",
"key",
")",
"\n",
"}",
"\n",
"}"
] |
// Deletes a header key
|
[
"Deletes",
"a",
"header",
"key"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L561-L565
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.