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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
2,900 | m3db/m3x | checked/ref.go | DecWrites | func (c *RefCount) DecWrites() {
tracebackEvent(c, c.NumRef(), decWritesEvent)
n := atomic.AddInt32(&c.writes, -1)
if ref := c.NumRef(); ref < 1 {
err := fmt.Errorf("write finish after free: writes=%d, ref=%d", n, ref)
panicRef(c, err)
}
} | go | func (c *RefCount) DecWrites() {
tracebackEvent(c, c.NumRef(), decWritesEvent)
n := atomic.AddInt32(&c.writes, -1)
if ref := c.NumRef(); ref < 1 {
err := fmt.Errorf("write finish after free: writes=%d, ref=%d", n, ref)
panicRef(c, err)
}
} | [
"func",
"(",
"c",
"*",
"RefCount",
")",
"DecWrites",
"(",
")",
"{",
"tracebackEvent",
"(",
"c",
",",
"c",
".",
"NumRef",
"(",
")",
",",
"decWritesEvent",
")",
"\n",
"n",
":=",
"atomic",
".",
"AddInt32",
"(",
"&",
"c",
".",
"writes",
",",
"-",
"1",
")",
"\n\n",
"if",
"ref",
":=",
"c",
".",
"NumRef",
"(",
")",
";",
"ref",
"<",
"1",
"{",
"err",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"n",
",",
"ref",
")",
"\n",
"panicRef",
"(",
"c",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // DecWrites decrements the writes count to this entity. | [
"DecWrites",
"decrements",
"the",
"writes",
"count",
"to",
"this",
"entity",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/checked/ref.go#L142-L150 |
2,901 | m3db/m3x | checked/ref.go | TrackObject | func (c *RefCount) TrackObject(v interface{}) {
if !leakDetectionFlag {
return
}
var size int
switch v := reflect.ValueOf(v); v.Kind() {
case reflect.Ptr:
size = int(v.Type().Elem().Size())
case reflect.Array, reflect.Slice, reflect.Chan:
size = int(v.Type().Elem().Size()) * v.Cap()
case reflect.String:
size = v.Len()
default:
size = int(v.Type().Size())
}
runtime.SetFinalizer(c, func(c *RefCount) {
if c.NumRef() == 0 {
return
}
origin := getDebuggerRef(c).String()
leaks.Lock()
// Keep track of bytes leaked, not objects.
leaks.m[origin] += uint64(size)
leaks.Unlock()
})
} | go | func (c *RefCount) TrackObject(v interface{}) {
if !leakDetectionFlag {
return
}
var size int
switch v := reflect.ValueOf(v); v.Kind() {
case reflect.Ptr:
size = int(v.Type().Elem().Size())
case reflect.Array, reflect.Slice, reflect.Chan:
size = int(v.Type().Elem().Size()) * v.Cap()
case reflect.String:
size = v.Len()
default:
size = int(v.Type().Size())
}
runtime.SetFinalizer(c, func(c *RefCount) {
if c.NumRef() == 0 {
return
}
origin := getDebuggerRef(c).String()
leaks.Lock()
// Keep track of bytes leaked, not objects.
leaks.m[origin] += uint64(size)
leaks.Unlock()
})
} | [
"func",
"(",
"c",
"*",
"RefCount",
")",
"TrackObject",
"(",
"v",
"interface",
"{",
"}",
")",
"{",
"if",
"!",
"leakDetectionFlag",
"{",
"return",
"\n",
"}",
"\n\n",
"var",
"size",
"int",
"\n\n",
"switch",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
";",
"v",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Ptr",
":",
"size",
"=",
"int",
"(",
"v",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
".",
"Size",
"(",
")",
")",
"\n",
"case",
"reflect",
".",
"Array",
",",
"reflect",
".",
"Slice",
",",
"reflect",
".",
"Chan",
":",
"size",
"=",
"int",
"(",
"v",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
".",
"Size",
"(",
")",
")",
"*",
"v",
".",
"Cap",
"(",
")",
"\n",
"case",
"reflect",
".",
"String",
":",
"size",
"=",
"v",
".",
"Len",
"(",
")",
"\n",
"default",
":",
"size",
"=",
"int",
"(",
"v",
".",
"Type",
"(",
")",
".",
"Size",
"(",
")",
")",
"\n",
"}",
"\n\n",
"runtime",
".",
"SetFinalizer",
"(",
"c",
",",
"func",
"(",
"c",
"*",
"RefCount",
")",
"{",
"if",
"c",
".",
"NumRef",
"(",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"origin",
":=",
"getDebuggerRef",
"(",
"c",
")",
".",
"String",
"(",
")",
"\n\n",
"leaks",
".",
"Lock",
"(",
")",
"\n",
"// Keep track of bytes leaked, not objects.",
"leaks",
".",
"m",
"[",
"origin",
"]",
"+=",
"uint64",
"(",
"size",
")",
"\n",
"leaks",
".",
"Unlock",
"(",
")",
"\n",
"}",
")",
"\n",
"}"
] | // TrackObject sets up the initial internal state of the Ref for
// leak detection. | [
"TrackObject",
"sets",
"up",
"the",
"initial",
"internal",
"state",
"of",
"the",
"Ref",
"for",
"leak",
"detection",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/checked/ref.go#L159-L189 |
2,902 | m3db/m3x | config/listenaddress/listenaddress.go | Resolve | func (c Configuration) Resolve() (string, error) {
listenAddrType := c.ListenAddressType
var listenAddress string
switch listenAddrType {
case ConfigResolver:
if c.Value == nil {
err := fmt.Errorf("missing listen address value using: resolver=%s",
string(listenAddrType))
return "", err
}
listenAddress = *c.Value
case EnvironmentResolver:
// environment variable for port is required
if c.EnvVarListenPort == nil {
err := fmt.Errorf("missing port env var name using: resolver=%s",
string(listenAddrType))
return "", err
}
portStr := os.Getenv(*c.EnvVarListenPort)
port, err := strconv.Atoi(portStr)
if err != nil {
err := fmt.Errorf("invalid port env var value using: resolver=%s, name=%s",
string(listenAddrType), *c.EnvVarListenPort)
return "", err
}
// if environment variable for hostname is not set, use the default
if c.EnvVarListenHost == nil {
listenAddress = fmt.Sprintf("%s:%d", defaultHostname, port)
} else {
envHost := os.Getenv(*c.EnvVarListenHost)
listenAddress = fmt.Sprintf("%s:%d", envHost, port)
}
default:
return "", fmt.Errorf("unknown listen address type: resolver=%s",
string(listenAddrType))
}
return listenAddress, nil
} | go | func (c Configuration) Resolve() (string, error) {
listenAddrType := c.ListenAddressType
var listenAddress string
switch listenAddrType {
case ConfigResolver:
if c.Value == nil {
err := fmt.Errorf("missing listen address value using: resolver=%s",
string(listenAddrType))
return "", err
}
listenAddress = *c.Value
case EnvironmentResolver:
// environment variable for port is required
if c.EnvVarListenPort == nil {
err := fmt.Errorf("missing port env var name using: resolver=%s",
string(listenAddrType))
return "", err
}
portStr := os.Getenv(*c.EnvVarListenPort)
port, err := strconv.Atoi(portStr)
if err != nil {
err := fmt.Errorf("invalid port env var value using: resolver=%s, name=%s",
string(listenAddrType), *c.EnvVarListenPort)
return "", err
}
// if environment variable for hostname is not set, use the default
if c.EnvVarListenHost == nil {
listenAddress = fmt.Sprintf("%s:%d", defaultHostname, port)
} else {
envHost := os.Getenv(*c.EnvVarListenHost)
listenAddress = fmt.Sprintf("%s:%d", envHost, port)
}
default:
return "", fmt.Errorf("unknown listen address type: resolver=%s",
string(listenAddrType))
}
return listenAddress, nil
} | [
"func",
"(",
"c",
"Configuration",
")",
"Resolve",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"listenAddrType",
":=",
"c",
".",
"ListenAddressType",
"\n\n",
"var",
"listenAddress",
"string",
"\n",
"switch",
"listenAddrType",
"{",
"case",
"ConfigResolver",
":",
"if",
"c",
".",
"Value",
"==",
"nil",
"{",
"err",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"listenAddrType",
")",
")",
"\n",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"listenAddress",
"=",
"*",
"c",
".",
"Value",
"\n\n",
"case",
"EnvironmentResolver",
":",
"// environment variable for port is required",
"if",
"c",
".",
"EnvVarListenPort",
"==",
"nil",
"{",
"err",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"listenAddrType",
")",
")",
"\n",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"portStr",
":=",
"os",
".",
"Getenv",
"(",
"*",
"c",
".",
"EnvVarListenPort",
")",
"\n",
"port",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"portStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"listenAddrType",
")",
",",
"*",
"c",
".",
"EnvVarListenPort",
")",
"\n",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"// if environment variable for hostname is not set, use the default",
"if",
"c",
".",
"EnvVarListenHost",
"==",
"nil",
"{",
"listenAddress",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"defaultHostname",
",",
"port",
")",
"\n",
"}",
"else",
"{",
"envHost",
":=",
"os",
".",
"Getenv",
"(",
"*",
"c",
".",
"EnvVarListenHost",
")",
"\n",
"listenAddress",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"envHost",
",",
"port",
")",
"\n",
"}",
"\n\n",
"default",
":",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"listenAddrType",
")",
")",
"\n",
"}",
"\n\n",
"return",
"listenAddress",
",",
"nil",
"\n",
"}"
] | // Resolve returns the resolved listen address given the configuration. | [
"Resolve",
"returns",
"the",
"resolved",
"listen",
"address",
"given",
"the",
"configuration",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/config/listenaddress/listenaddress.go#L62-L103 |
2,903 | m3db/m3x | log/config.go | BuildLogger | func (cfg Configuration) BuildLogger() (Logger, error) {
writer := io.Writer(os.Stdout)
if cfg.File != "" {
fd, err := os.OpenFile(cfg.File, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return nil, err
}
writer = io.MultiWriter(writer, fd)
}
logger := NewLogger(writer)
if len(cfg.Level) != 0 {
level, err := ParseLevel(cfg.Level)
if err != nil {
return nil, err
}
logger = NewLevelLogger(logger, level)
}
if len(cfg.Fields) != 0 {
var fields []Field
for k, v := range cfg.Fields {
fields = append(fields, NewField(k, v))
}
logger = logger.WithFields(fields...)
}
return logger, nil
} | go | func (cfg Configuration) BuildLogger() (Logger, error) {
writer := io.Writer(os.Stdout)
if cfg.File != "" {
fd, err := os.OpenFile(cfg.File, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return nil, err
}
writer = io.MultiWriter(writer, fd)
}
logger := NewLogger(writer)
if len(cfg.Level) != 0 {
level, err := ParseLevel(cfg.Level)
if err != nil {
return nil, err
}
logger = NewLevelLogger(logger, level)
}
if len(cfg.Fields) != 0 {
var fields []Field
for k, v := range cfg.Fields {
fields = append(fields, NewField(k, v))
}
logger = logger.WithFields(fields...)
}
return logger, nil
} | [
"func",
"(",
"cfg",
"Configuration",
")",
"BuildLogger",
"(",
")",
"(",
"Logger",
",",
"error",
")",
"{",
"writer",
":=",
"io",
".",
"Writer",
"(",
"os",
".",
"Stdout",
")",
"\n\n",
"if",
"cfg",
".",
"File",
"!=",
"\"",
"\"",
"{",
"fd",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"cfg",
".",
"File",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_APPEND",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"writer",
"=",
"io",
".",
"MultiWriter",
"(",
"writer",
",",
"fd",
")",
"\n",
"}",
"\n\n",
"logger",
":=",
"NewLogger",
"(",
"writer",
")",
"\n\n",
"if",
"len",
"(",
"cfg",
".",
"Level",
")",
"!=",
"0",
"{",
"level",
",",
"err",
":=",
"ParseLevel",
"(",
"cfg",
".",
"Level",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"logger",
"=",
"NewLevelLogger",
"(",
"logger",
",",
"level",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"cfg",
".",
"Fields",
")",
"!=",
"0",
"{",
"var",
"fields",
"[",
"]",
"Field",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"cfg",
".",
"Fields",
"{",
"fields",
"=",
"append",
"(",
"fields",
",",
"NewField",
"(",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"logger",
"=",
"logger",
".",
"WithFields",
"(",
"fields",
"...",
")",
"\n",
"}",
"\n\n",
"return",
"logger",
",",
"nil",
"\n",
"}"
] | // BuildLogger builds a new Logger based on the configuration. | [
"BuildLogger",
"builds",
"a",
"new",
"Logger",
"based",
"on",
"the",
"configuration",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/log/config.go#L36-L68 |
2,904 | m3db/m3x | watch/value.go | NewValue | func NewValue(
opts Options,
) Value {
v := &value{
opts: opts,
log: opts.InstrumentOptions().Logger(),
newUpdatableFn: opts.NewUpdatableFn(),
getUpdateFn: opts.GetUpdateFn(),
processFn: opts.ProcessFn(),
}
v.processWithLockFn = v.processWithLock
return v
} | go | func NewValue(
opts Options,
) Value {
v := &value{
opts: opts,
log: opts.InstrumentOptions().Logger(),
newUpdatableFn: opts.NewUpdatableFn(),
getUpdateFn: opts.GetUpdateFn(),
processFn: opts.ProcessFn(),
}
v.processWithLockFn = v.processWithLock
return v
} | [
"func",
"NewValue",
"(",
"opts",
"Options",
",",
")",
"Value",
"{",
"v",
":=",
"&",
"value",
"{",
"opts",
":",
"opts",
",",
"log",
":",
"opts",
".",
"InstrumentOptions",
"(",
")",
".",
"Logger",
"(",
")",
",",
"newUpdatableFn",
":",
"opts",
".",
"NewUpdatableFn",
"(",
")",
",",
"getUpdateFn",
":",
"opts",
".",
"GetUpdateFn",
"(",
")",
",",
"processFn",
":",
"opts",
".",
"ProcessFn",
"(",
")",
",",
"}",
"\n",
"v",
".",
"processWithLockFn",
"=",
"v",
".",
"processWithLock",
"\n",
"return",
"v",
"\n",
"}"
] | // NewValue creates a new value. | [
"NewValue",
"creates",
"a",
"new",
"value",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/watch/value.go#L80-L92 |
2,905 | m3db/m3x | ident/tag_matcher.go | NewTagMatcher | func NewTagMatcher(name string, value string) TagMatcher {
return &tagMatcher{tag: StringTag(name, value)}
} | go | func NewTagMatcher(name string, value string) TagMatcher {
return &tagMatcher{tag: StringTag(name, value)}
} | [
"func",
"NewTagMatcher",
"(",
"name",
"string",
",",
"value",
"string",
")",
"TagMatcher",
"{",
"return",
"&",
"tagMatcher",
"{",
"tag",
":",
"StringTag",
"(",
"name",
",",
"value",
")",
"}",
"\n",
"}"
] | // NewTagMatcher returns a new TagMatcher | [
"NewTagMatcher",
"returns",
"a",
"new",
"TagMatcher"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/tag_matcher.go#L35-L37 |
2,906 | m3db/m3x | sampler/sampler.go | NewSampler | func NewSampler(sampleRate float64) (*Sampler, error) {
if sampleRate <= 0.0 || sampleRate >= 1.0 {
return nil, fmt.Errorf("invalid sample rate %f", sampleRate)
}
return &Sampler{numTried: atomic.NewInt32(0), sampleEvery: int32(1.0 / sampleRate)}, nil
} | go | func NewSampler(sampleRate float64) (*Sampler, error) {
if sampleRate <= 0.0 || sampleRate >= 1.0 {
return nil, fmt.Errorf("invalid sample rate %f", sampleRate)
}
return &Sampler{numTried: atomic.NewInt32(0), sampleEvery: int32(1.0 / sampleRate)}, nil
} | [
"func",
"NewSampler",
"(",
"sampleRate",
"float64",
")",
"(",
"*",
"Sampler",
",",
"error",
")",
"{",
"if",
"sampleRate",
"<=",
"0.0",
"||",
"sampleRate",
">=",
"1.0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sampleRate",
")",
"\n",
"}",
"\n",
"return",
"&",
"Sampler",
"{",
"numTried",
":",
"atomic",
".",
"NewInt32",
"(",
"0",
")",
",",
"sampleEvery",
":",
"int32",
"(",
"1.0",
"/",
"sampleRate",
")",
"}",
",",
"nil",
"\n",
"}"
] | // NewSampler creates a new sampler with a sample rate. | [
"NewSampler",
"creates",
"a",
"new",
"sampler",
"with",
"a",
"sample",
"rate",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/sampler/sampler.go#L37-L42 |
2,907 | m3db/m3x | pool/object.go | NewObjectPool | func NewObjectPool(opts ObjectPoolOptions) ObjectPool {
if opts == nil {
opts = NewObjectPoolOptions()
}
m := opts.InstrumentOptions().MetricsScope()
p := &objectPool{
opts: opts,
values: make(chan interface{}, opts.Size()),
size: opts.Size(),
refillLowWatermark: int(math.Ceil(
opts.RefillLowWatermark() * float64(opts.Size()))),
refillHighWatermark: int(math.Ceil(
opts.RefillHighWatermark() * float64(opts.Size()))),
metrics: objectPoolMetrics{
free: m.Gauge("free"),
total: m.Gauge("total"),
getOnEmpty: m.Counter("get-on-empty"),
putOnFull: m.Counter("put-on-full"),
},
}
p.setGauges()
return p
} | go | func NewObjectPool(opts ObjectPoolOptions) ObjectPool {
if opts == nil {
opts = NewObjectPoolOptions()
}
m := opts.InstrumentOptions().MetricsScope()
p := &objectPool{
opts: opts,
values: make(chan interface{}, opts.Size()),
size: opts.Size(),
refillLowWatermark: int(math.Ceil(
opts.RefillLowWatermark() * float64(opts.Size()))),
refillHighWatermark: int(math.Ceil(
opts.RefillHighWatermark() * float64(opts.Size()))),
metrics: objectPoolMetrics{
free: m.Gauge("free"),
total: m.Gauge("total"),
getOnEmpty: m.Counter("get-on-empty"),
putOnFull: m.Counter("put-on-full"),
},
}
p.setGauges()
return p
} | [
"func",
"NewObjectPool",
"(",
"opts",
"ObjectPoolOptions",
")",
"ObjectPool",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"NewObjectPoolOptions",
"(",
")",
"\n",
"}",
"\n\n",
"m",
":=",
"opts",
".",
"InstrumentOptions",
"(",
")",
".",
"MetricsScope",
"(",
")",
"\n\n",
"p",
":=",
"&",
"objectPool",
"{",
"opts",
":",
"opts",
",",
"values",
":",
"make",
"(",
"chan",
"interface",
"{",
"}",
",",
"opts",
".",
"Size",
"(",
")",
")",
",",
"size",
":",
"opts",
".",
"Size",
"(",
")",
",",
"refillLowWatermark",
":",
"int",
"(",
"math",
".",
"Ceil",
"(",
"opts",
".",
"RefillLowWatermark",
"(",
")",
"*",
"float64",
"(",
"opts",
".",
"Size",
"(",
")",
")",
")",
")",
",",
"refillHighWatermark",
":",
"int",
"(",
"math",
".",
"Ceil",
"(",
"opts",
".",
"RefillHighWatermark",
"(",
")",
"*",
"float64",
"(",
"opts",
".",
"Size",
"(",
")",
")",
")",
")",
",",
"metrics",
":",
"objectPoolMetrics",
"{",
"free",
":",
"m",
".",
"Gauge",
"(",
"\"",
"\"",
")",
",",
"total",
":",
"m",
".",
"Gauge",
"(",
"\"",
"\"",
")",
",",
"getOnEmpty",
":",
"m",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"putOnFull",
":",
"m",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"}",
",",
"}",
"\n\n",
"p",
".",
"setGauges",
"(",
")",
"\n\n",
"return",
"p",
"\n",
"}"
] | // NewObjectPool creates a new pool | [
"NewObjectPool",
"creates",
"a",
"new",
"pool"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/object.go#L63-L89 |
2,908 | m3db/m3x | time/range.go | Equal | func (r Range) Equal(other Range) bool {
return r.Start.Equal(other.Start) && r.End.Equal(other.End)
} | go | func (r Range) Equal(other Range) bool {
return r.Start.Equal(other.Start) && r.End.Equal(other.End)
} | [
"func",
"(",
"r",
"Range",
")",
"Equal",
"(",
"other",
"Range",
")",
"bool",
"{",
"return",
"r",
".",
"Start",
".",
"Equal",
"(",
"other",
".",
"Start",
")",
"&&",
"r",
".",
"End",
".",
"Equal",
"(",
"other",
".",
"End",
")",
"\n",
"}"
] | // Equal returns whether two time ranges are equal. | [
"Equal",
"returns",
"whether",
"two",
"time",
"ranges",
"are",
"equal",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L40-L42 |
2,909 | m3db/m3x | time/range.go | Before | func (r Range) Before(other Range) bool {
return !r.End.After(other.Start)
} | go | func (r Range) Before(other Range) bool {
return !r.End.After(other.Start)
} | [
"func",
"(",
"r",
"Range",
")",
"Before",
"(",
"other",
"Range",
")",
"bool",
"{",
"return",
"!",
"r",
".",
"End",
".",
"After",
"(",
"other",
".",
"Start",
")",
"\n",
"}"
] | // Before determines whether r is before other. | [
"Before",
"determines",
"whether",
"r",
"is",
"before",
"other",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L45-L47 |
2,910 | m3db/m3x | time/range.go | Contains | func (r Range) Contains(other Range) bool {
return !r.Start.After(other.Start) && !r.End.Before(other.End)
} | go | func (r Range) Contains(other Range) bool {
return !r.Start.After(other.Start) && !r.End.Before(other.End)
} | [
"func",
"(",
"r",
"Range",
")",
"Contains",
"(",
"other",
"Range",
")",
"bool",
"{",
"return",
"!",
"r",
".",
"Start",
".",
"After",
"(",
"other",
".",
"Start",
")",
"&&",
"!",
"r",
".",
"End",
".",
"Before",
"(",
"other",
".",
"End",
")",
"\n",
"}"
] | // Contains determines whether r contains other. | [
"Contains",
"determines",
"whether",
"r",
"contains",
"other",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L55-L57 |
2,911 | m3db/m3x | time/range.go | Duration | func (r Range) Duration() time.Duration {
return r.End.Sub(r.Start)
} | go | func (r Range) Duration() time.Duration {
return r.End.Sub(r.Start)
} | [
"func",
"(",
"r",
"Range",
")",
"Duration",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"r",
".",
"End",
".",
"Sub",
"(",
"r",
".",
"Start",
")",
"\n",
"}"
] | // Duration returns the duration of the range. | [
"Duration",
"returns",
"the",
"duration",
"of",
"the",
"range",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L65-L67 |
2,912 | m3db/m3x | time/range.go | Intersect | func (r Range) Intersect(other Range) (Range, bool) {
if !r.Overlaps(other) {
return Range{}, false
}
newRange := r
if newRange.Start.Before(other.Start) {
newRange.Start = other.Start
}
if newRange.End.After(other.End) {
newRange.End = other.End
}
return newRange, true
} | go | func (r Range) Intersect(other Range) (Range, bool) {
if !r.Overlaps(other) {
return Range{}, false
}
newRange := r
if newRange.Start.Before(other.Start) {
newRange.Start = other.Start
}
if newRange.End.After(other.End) {
newRange.End = other.End
}
return newRange, true
} | [
"func",
"(",
"r",
"Range",
")",
"Intersect",
"(",
"other",
"Range",
")",
"(",
"Range",
",",
"bool",
")",
"{",
"if",
"!",
"r",
".",
"Overlaps",
"(",
"other",
")",
"{",
"return",
"Range",
"{",
"}",
",",
"false",
"\n",
"}",
"\n",
"newRange",
":=",
"r",
"\n",
"if",
"newRange",
".",
"Start",
".",
"Before",
"(",
"other",
".",
"Start",
")",
"{",
"newRange",
".",
"Start",
"=",
"other",
".",
"Start",
"\n",
"}",
"\n",
"if",
"newRange",
".",
"End",
".",
"After",
"(",
"other",
".",
"End",
")",
"{",
"newRange",
".",
"End",
"=",
"other",
".",
"End",
"\n",
"}",
"\n",
"return",
"newRange",
",",
"true",
"\n",
"}"
] | // Intersect calculates the intersection of the receiver range against the
// provided argument range iff there is an overlap between the two. It also
// returns a bool indicating if there was a valid intersection. | [
"Intersect",
"calculates",
"the",
"intersection",
"of",
"the",
"receiver",
"range",
"against",
"the",
"provided",
"argument",
"range",
"iff",
"there",
"is",
"an",
"overlap",
"between",
"the",
"two",
".",
"It",
"also",
"returns",
"a",
"bool",
"indicating",
"if",
"there",
"was",
"a",
"valid",
"intersection",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L72-L84 |
2,913 | m3db/m3x | time/range.go | Since | func (r Range) Since(t time.Time) Range {
if t.Before(r.Start) {
return r
}
if t.After(r.End) {
return Range{}
}
return Range{Start: t, End: r.End}
} | go | func (r Range) Since(t time.Time) Range {
if t.Before(r.Start) {
return r
}
if t.After(r.End) {
return Range{}
}
return Range{Start: t, End: r.End}
} | [
"func",
"(",
"r",
"Range",
")",
"Since",
"(",
"t",
"time",
".",
"Time",
")",
"Range",
"{",
"if",
"t",
".",
"Before",
"(",
"r",
".",
"Start",
")",
"{",
"return",
"r",
"\n",
"}",
"\n",
"if",
"t",
".",
"After",
"(",
"r",
".",
"End",
")",
"{",
"return",
"Range",
"{",
"}",
"\n",
"}",
"\n",
"return",
"Range",
"{",
"Start",
":",
"t",
",",
"End",
":",
"r",
".",
"End",
"}",
"\n",
"}"
] | // Since returns the time range since a given point in time. | [
"Since",
"returns",
"the",
"time",
"range",
"since",
"a",
"given",
"point",
"in",
"time",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L87-L95 |
2,914 | m3db/m3x | time/range.go | Merge | func (r Range) Merge(other Range) Range {
start := MinTime(r.Start, other.Start)
end := MaxTime(r.End, other.End)
return Range{Start: start, End: end}
} | go | func (r Range) Merge(other Range) Range {
start := MinTime(r.Start, other.Start)
end := MaxTime(r.End, other.End)
return Range{Start: start, End: end}
} | [
"func",
"(",
"r",
"Range",
")",
"Merge",
"(",
"other",
"Range",
")",
"Range",
"{",
"start",
":=",
"MinTime",
"(",
"r",
".",
"Start",
",",
"other",
".",
"Start",
")",
"\n",
"end",
":=",
"MaxTime",
"(",
"r",
".",
"End",
",",
"other",
".",
"End",
")",
"\n",
"return",
"Range",
"{",
"Start",
":",
"start",
",",
"End",
":",
"end",
"}",
"\n",
"}"
] | // Merge merges the two ranges if they overlap. Otherwise,
// the gap between them is included. | [
"Merge",
"merges",
"the",
"two",
"ranges",
"if",
"they",
"overlap",
".",
"Otherwise",
"the",
"gap",
"between",
"them",
"is",
"included",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L99-L103 |
2,915 | m3db/m3x | time/range.go | Subtract | func (r Range) Subtract(other Range) []Range {
if !r.Overlaps(other) {
return []Range{r}
}
if other.Contains(r) {
return nil
}
var res []Range
left := Range{r.Start, other.Start}
right := Range{other.End, r.End}
if r.Contains(other) {
if !left.IsEmpty() {
res = append(res, left)
}
if !right.IsEmpty() {
res = append(res, right)
}
return res
}
if !r.Start.After(other.Start) {
if !left.IsEmpty() {
res = append(res, left)
}
return res
}
if !right.IsEmpty() {
res = append(res, right)
}
return res
} | go | func (r Range) Subtract(other Range) []Range {
if !r.Overlaps(other) {
return []Range{r}
}
if other.Contains(r) {
return nil
}
var res []Range
left := Range{r.Start, other.Start}
right := Range{other.End, r.End}
if r.Contains(other) {
if !left.IsEmpty() {
res = append(res, left)
}
if !right.IsEmpty() {
res = append(res, right)
}
return res
}
if !r.Start.After(other.Start) {
if !left.IsEmpty() {
res = append(res, left)
}
return res
}
if !right.IsEmpty() {
res = append(res, right)
}
return res
} | [
"func",
"(",
"r",
"Range",
")",
"Subtract",
"(",
"other",
"Range",
")",
"[",
"]",
"Range",
"{",
"if",
"!",
"r",
".",
"Overlaps",
"(",
"other",
")",
"{",
"return",
"[",
"]",
"Range",
"{",
"r",
"}",
"\n",
"}",
"\n",
"if",
"other",
".",
"Contains",
"(",
"r",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"res",
"[",
"]",
"Range",
"\n",
"left",
":=",
"Range",
"{",
"r",
".",
"Start",
",",
"other",
".",
"Start",
"}",
"\n",
"right",
":=",
"Range",
"{",
"other",
".",
"End",
",",
"r",
".",
"End",
"}",
"\n",
"if",
"r",
".",
"Contains",
"(",
"other",
")",
"{",
"if",
"!",
"left",
".",
"IsEmpty",
"(",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"left",
")",
"\n",
"}",
"\n",
"if",
"!",
"right",
".",
"IsEmpty",
"(",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"right",
")",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}",
"\n",
"if",
"!",
"r",
".",
"Start",
".",
"After",
"(",
"other",
".",
"Start",
")",
"{",
"if",
"!",
"left",
".",
"IsEmpty",
"(",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"left",
")",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}",
"\n",
"if",
"!",
"right",
".",
"IsEmpty",
"(",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"right",
")",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // Subtract removes the intersection between r and other
// from r, possibly splitting r into two smaller ranges. | [
"Subtract",
"removes",
"the",
"intersection",
"between",
"r",
"and",
"other",
"from",
"r",
"possibly",
"splitting",
"r",
"into",
"two",
"smaller",
"ranges",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range.go#L107-L136 |
2,916 | m3db/m3x | instrument/invariant.go | EmitAndLogInvariantViolation | func EmitAndLogInvariantViolation(opts Options, f func(l log.Logger)) {
EmitInvariantViolation(opts)
logger := opts.Logger().WithFields(
log.NewField(InvariantViolatedLogFieldName, InvariantViolatedLogFieldValue))
f(logger)
panicIfEnvSet()
} | go | func EmitAndLogInvariantViolation(opts Options, f func(l log.Logger)) {
EmitInvariantViolation(opts)
logger := opts.Logger().WithFields(
log.NewField(InvariantViolatedLogFieldName, InvariantViolatedLogFieldValue))
f(logger)
panicIfEnvSet()
} | [
"func",
"EmitAndLogInvariantViolation",
"(",
"opts",
"Options",
",",
"f",
"func",
"(",
"l",
"log",
".",
"Logger",
")",
")",
"{",
"EmitInvariantViolation",
"(",
"opts",
")",
"\n\n",
"logger",
":=",
"opts",
".",
"Logger",
"(",
")",
".",
"WithFields",
"(",
"log",
".",
"NewField",
"(",
"InvariantViolatedLogFieldName",
",",
"InvariantViolatedLogFieldValue",
")",
")",
"\n",
"f",
"(",
"logger",
")",
"\n\n",
"panicIfEnvSet",
"(",
")",
"\n",
"}"
] | // EmitAndLogInvariantViolation calls EmitInvariantViolation and then calls the provided function
// with a supplied logger that is pre-configured with an invariant violated field. Optionally panics
// if the ShouldPanicEnvironmentVariableName is set to "true". | [
"EmitAndLogInvariantViolation",
"calls",
"EmitInvariantViolation",
"and",
"then",
"calls",
"the",
"provided",
"function",
"with",
"a",
"supplied",
"logger",
"that",
"is",
"pre",
"-",
"configured",
"with",
"an",
"invariant",
"violated",
"field",
".",
"Optionally",
"panics",
"if",
"the",
"ShouldPanicEnvironmentVariableName",
"is",
"set",
"to",
"true",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/invariant.go#L71-L79 |
2,917 | m3db/m3x | instrument/invariant.go | InvariantErrorf | func InvariantErrorf(format string, a ...interface{}) error {
var (
invariantFormat = InvariantViolatedMetricName + ": " + format
err = fmt.Errorf(invariantFormat, a...)
)
panicIfEnvSetWithMessage(err.Error())
return err
} | go | func InvariantErrorf(format string, a ...interface{}) error {
var (
invariantFormat = InvariantViolatedMetricName + ": " + format
err = fmt.Errorf(invariantFormat, a...)
)
panicIfEnvSetWithMessage(err.Error())
return err
} | [
"func",
"InvariantErrorf",
"(",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"var",
"(",
"invariantFormat",
"=",
"InvariantViolatedMetricName",
"+",
"\"",
"\"",
"+",
"format",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"invariantFormat",
",",
"a",
"...",
")",
"\n",
")",
"\n\n",
"panicIfEnvSetWithMessage",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // InvariantErrorf constructs a new error, prefixed with a string indicating that an invariant
// violation occurred. Optionally panics if the ShouldPanicEnvironmentVariableName is set to "true". | [
"InvariantErrorf",
"constructs",
"a",
"new",
"error",
"prefixed",
"with",
"a",
"string",
"indicating",
"that",
"an",
"invariant",
"violation",
"occurred",
".",
"Optionally",
"panics",
"if",
"the",
"ShouldPanicEnvironmentVariableName",
"is",
"set",
"to",
"true",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/invariant.go#L83-L91 |
2,918 | m3db/m3x | time/time.go | ToNormalizedTime | func ToNormalizedTime(t time.Time, u time.Duration) int64 {
return t.UnixNano() / u.Nanoseconds()
} | go | func ToNormalizedTime(t time.Time, u time.Duration) int64 {
return t.UnixNano() / u.Nanoseconds()
} | [
"func",
"ToNormalizedTime",
"(",
"t",
"time",
".",
"Time",
",",
"u",
"time",
".",
"Duration",
")",
"int64",
"{",
"return",
"t",
".",
"UnixNano",
"(",
")",
"/",
"u",
".",
"Nanoseconds",
"(",
")",
"\n",
"}"
] | // ToNormalizedTime returns the normalized units of time given a time unit. | [
"ToNormalizedTime",
"returns",
"the",
"normalized",
"units",
"of",
"time",
"given",
"a",
"time",
"unit",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L31-L33 |
2,919 | m3db/m3x | time/time.go | FromNormalizedTime | func FromNormalizedTime(nt int64, u time.Duration) time.Time {
return time.Unix(0, int64(u/time.Nanosecond)*nt)
} | go | func FromNormalizedTime(nt int64, u time.Duration) time.Time {
return time.Unix(0, int64(u/time.Nanosecond)*nt)
} | [
"func",
"FromNormalizedTime",
"(",
"nt",
"int64",
",",
"u",
"time",
".",
"Duration",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"0",
",",
"int64",
"(",
"u",
"/",
"time",
".",
"Nanosecond",
")",
"*",
"nt",
")",
"\n",
"}"
] | // FromNormalizedTime returns the time given the normalized time units and the time unit. | [
"FromNormalizedTime",
"returns",
"the",
"time",
"given",
"the",
"normalized",
"time",
"units",
"and",
"the",
"time",
"unit",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L36-L38 |
2,920 | m3db/m3x | time/time.go | ToNormalizedDuration | func ToNormalizedDuration(d time.Duration, u time.Duration) int64 {
return int64(d / u)
} | go | func ToNormalizedDuration(d time.Duration, u time.Duration) int64 {
return int64(d / u)
} | [
"func",
"ToNormalizedDuration",
"(",
"d",
"time",
".",
"Duration",
",",
"u",
"time",
".",
"Duration",
")",
"int64",
"{",
"return",
"int64",
"(",
"d",
"/",
"u",
")",
"\n",
"}"
] | // ToNormalizedDuration returns the normalized units of duration given a time unit. | [
"ToNormalizedDuration",
"returns",
"the",
"normalized",
"units",
"of",
"duration",
"given",
"a",
"time",
"unit",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L41-L43 |
2,921 | m3db/m3x | time/time.go | FromNormalizedDuration | func FromNormalizedDuration(nd int64, u time.Duration) time.Duration {
return time.Duration(nd) * u
} | go | func FromNormalizedDuration(nd int64, u time.Duration) time.Duration {
return time.Duration(nd) * u
} | [
"func",
"FromNormalizedDuration",
"(",
"nd",
"int64",
",",
"u",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Duration",
"(",
"nd",
")",
"*",
"u",
"\n",
"}"
] | // FromNormalizedDuration returns the duration given the normalized time duration and a time unit. | [
"FromNormalizedDuration",
"returns",
"the",
"duration",
"given",
"the",
"normalized",
"time",
"duration",
"and",
"a",
"time",
"unit",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L46-L48 |
2,922 | m3db/m3x | time/time.go | Ceil | func Ceil(t time.Time, d time.Duration) time.Time {
res := t.Truncate(d)
if res.Before(t) {
res = res.Add(d)
}
return res
} | go | func Ceil(t time.Time, d time.Duration) time.Time {
res := t.Truncate(d)
if res.Before(t) {
res = res.Add(d)
}
return res
} | [
"func",
"Ceil",
"(",
"t",
"time",
".",
"Time",
",",
"d",
"time",
".",
"Duration",
")",
"time",
".",
"Time",
"{",
"res",
":=",
"t",
".",
"Truncate",
"(",
"d",
")",
"\n",
"if",
"res",
".",
"Before",
"(",
"t",
")",
"{",
"res",
"=",
"res",
".",
"Add",
"(",
"d",
")",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // Ceil returns the result of rounding t up to a multiple of d since
// the zero time. | [
"Ceil",
"returns",
"the",
"result",
"of",
"rounding",
"t",
"up",
"to",
"a",
"multiple",
"of",
"d",
"since",
"the",
"zero",
"time",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L72-L78 |
2,923 | m3db/m3x | time/time.go | MinTime | func MinTime(t1, t2 time.Time) time.Time {
if t1.Before(t2) {
return t1
}
return t2
} | go | func MinTime(t1, t2 time.Time) time.Time {
if t1.Before(t2) {
return t1
}
return t2
} | [
"func",
"MinTime",
"(",
"t1",
",",
"t2",
"time",
".",
"Time",
")",
"time",
".",
"Time",
"{",
"if",
"t1",
".",
"Before",
"(",
"t2",
")",
"{",
"return",
"t1",
"\n",
"}",
"\n",
"return",
"t2",
"\n",
"}"
] | // MinTime returns the earlier one of t1 and t2. | [
"MinTime",
"returns",
"the",
"earlier",
"one",
"of",
"t1",
"and",
"t2",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L81-L86 |
2,924 | m3db/m3x | time/time.go | MaxTime | func MaxTime(t1, t2 time.Time) time.Time {
if t1.After(t2) {
return t1
}
return t2
} | go | func MaxTime(t1, t2 time.Time) time.Time {
if t1.After(t2) {
return t1
}
return t2
} | [
"func",
"MaxTime",
"(",
"t1",
",",
"t2",
"time",
".",
"Time",
")",
"time",
".",
"Time",
"{",
"if",
"t1",
".",
"After",
"(",
"t2",
")",
"{",
"return",
"t1",
"\n",
"}",
"\n",
"return",
"t2",
"\n",
"}"
] | // MaxTime returns the later one of t1 and t2. | [
"MaxTime",
"returns",
"the",
"later",
"one",
"of",
"t1",
"and",
"t2",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/time.go#L89-L94 |
2,925 | m3db/m3x | pool/bucketized.go | NewBucketizedObjectPool | func NewBucketizedObjectPool(sizes []Bucket, opts ObjectPoolOptions) BucketizedObjectPool {
if opts == nil {
opts = NewObjectPoolOptions()
}
sizesAsc := make([]Bucket, len(sizes))
copy(sizesAsc, sizes)
sort.Sort(BucketByCapacity(sizesAsc))
var maxBucketCapacity int
if len(sizesAsc) != 0 {
maxBucketCapacity = sizesAsc[len(sizesAsc)-1].Capacity
}
iopts := opts.InstrumentOptions()
return &bucketizedObjectPool{
opts: opts,
sizesAsc: sizesAsc,
maxBucketCapacity: maxBucketCapacity,
maxAlloc: iopts.MetricsScope().Counter("alloc-max"),
}
} | go | func NewBucketizedObjectPool(sizes []Bucket, opts ObjectPoolOptions) BucketizedObjectPool {
if opts == nil {
opts = NewObjectPoolOptions()
}
sizesAsc := make([]Bucket, len(sizes))
copy(sizesAsc, sizes)
sort.Sort(BucketByCapacity(sizesAsc))
var maxBucketCapacity int
if len(sizesAsc) != 0 {
maxBucketCapacity = sizesAsc[len(sizesAsc)-1].Capacity
}
iopts := opts.InstrumentOptions()
return &bucketizedObjectPool{
opts: opts,
sizesAsc: sizesAsc,
maxBucketCapacity: maxBucketCapacity,
maxAlloc: iopts.MetricsScope().Counter("alloc-max"),
}
} | [
"func",
"NewBucketizedObjectPool",
"(",
"sizes",
"[",
"]",
"Bucket",
",",
"opts",
"ObjectPoolOptions",
")",
"BucketizedObjectPool",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"NewObjectPoolOptions",
"(",
")",
"\n",
"}",
"\n\n",
"sizesAsc",
":=",
"make",
"(",
"[",
"]",
"Bucket",
",",
"len",
"(",
"sizes",
")",
")",
"\n",
"copy",
"(",
"sizesAsc",
",",
"sizes",
")",
"\n",
"sort",
".",
"Sort",
"(",
"BucketByCapacity",
"(",
"sizesAsc",
")",
")",
"\n\n",
"var",
"maxBucketCapacity",
"int",
"\n",
"if",
"len",
"(",
"sizesAsc",
")",
"!=",
"0",
"{",
"maxBucketCapacity",
"=",
"sizesAsc",
"[",
"len",
"(",
"sizesAsc",
")",
"-",
"1",
"]",
".",
"Capacity",
"\n",
"}",
"\n\n",
"iopts",
":=",
"opts",
".",
"InstrumentOptions",
"(",
")",
"\n\n",
"return",
"&",
"bucketizedObjectPool",
"{",
"opts",
":",
"opts",
",",
"sizesAsc",
":",
"sizesAsc",
",",
"maxBucketCapacity",
":",
"maxBucketCapacity",
",",
"maxAlloc",
":",
"iopts",
".",
"MetricsScope",
"(",
")",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"}",
"\n",
"}"
] | // NewBucketizedObjectPool creates a bucketized object pool | [
"NewBucketizedObjectPool",
"creates",
"a",
"bucketized",
"object",
"pool"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/bucketized.go#L45-L67 |
2,926 | m3db/m3x | config/config.go | LoadFile | func LoadFile(config interface{}, file string, opts Options) error {
return LoadFiles(config, []string{file}, opts)
} | go | func LoadFile(config interface{}, file string, opts Options) error {
return LoadFiles(config, []string{file}, opts)
} | [
"func",
"LoadFile",
"(",
"config",
"interface",
"{",
"}",
",",
"file",
"string",
",",
"opts",
"Options",
")",
"error",
"{",
"return",
"LoadFiles",
"(",
"config",
",",
"[",
"]",
"string",
"{",
"file",
"}",
",",
"opts",
")",
"\n",
"}"
] | // LoadFile loads a config from a file. | [
"LoadFile",
"loads",
"a",
"config",
"from",
"a",
"file",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/config/config.go#L41-L43 |
2,927 | m3db/m3x | config/config.go | LoadFiles | func LoadFiles(config interface{}, files []string, opts Options) error {
if len(files) == 0 {
return errNoFilesToLoad
}
for _, name := range files {
data, err := ioutil.ReadFile(name)
if err != nil {
return err
}
unmarshal := yaml.UnmarshalStrict
if opts.DisableUnmarshalStrict {
unmarshal = yaml.Unmarshal
}
if err := unmarshal(data, config); err != nil {
return err
}
}
if opts.DisableValidate {
return nil
}
return validator.Validate(config)
} | go | func LoadFiles(config interface{}, files []string, opts Options) error {
if len(files) == 0 {
return errNoFilesToLoad
}
for _, name := range files {
data, err := ioutil.ReadFile(name)
if err != nil {
return err
}
unmarshal := yaml.UnmarshalStrict
if opts.DisableUnmarshalStrict {
unmarshal = yaml.Unmarshal
}
if err := unmarshal(data, config); err != nil {
return err
}
}
if opts.DisableValidate {
return nil
}
return validator.Validate(config)
} | [
"func",
"LoadFiles",
"(",
"config",
"interface",
"{",
"}",
",",
"files",
"[",
"]",
"string",
",",
"opts",
"Options",
")",
"error",
"{",
"if",
"len",
"(",
"files",
")",
"==",
"0",
"{",
"return",
"errNoFilesToLoad",
"\n",
"}",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"files",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"unmarshal",
":=",
"yaml",
".",
"UnmarshalStrict",
"\n",
"if",
"opts",
".",
"DisableUnmarshalStrict",
"{",
"unmarshal",
"=",
"yaml",
".",
"Unmarshal",
"\n",
"}",
"\n",
"if",
"err",
":=",
"unmarshal",
"(",
"data",
",",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"opts",
".",
"DisableValidate",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"validator",
".",
"Validate",
"(",
"config",
")",
"\n",
"}"
] | // LoadFiles loads a config from list of files. If value for a property is
// present in multiple files, the value from the last file will be applied.
// Validation is done after merging all values. | [
"LoadFiles",
"loads",
"a",
"config",
"from",
"list",
"of",
"files",
".",
"If",
"value",
"for",
"a",
"property",
"is",
"present",
"in",
"multiple",
"files",
"the",
"value",
"from",
"the",
"last",
"file",
"will",
"be",
"applied",
".",
"Validation",
"is",
"done",
"after",
"merging",
"all",
"values",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/config/config.go#L48-L69 |
2,928 | m3db/m3x | retry/retry.go | NewRetrier | func NewRetrier(opts Options) Retrier {
scope := opts.MetricsScope()
errorTags := struct {
retryable map[string]string
notRetryable map[string]string
}{
map[string]string{
"type": "retryable",
},
map[string]string{
"type": "not-retryable",
},
}
return &retrier{
initialBackoff: opts.InitialBackoff(),
backoffFactor: opts.BackoffFactor(),
maxBackoff: opts.MaxBackoff(),
maxRetries: opts.MaxRetries(),
forever: opts.Forever(),
jitter: opts.Jitter(),
rngFn: opts.RngFn(),
sleepFn: time.Sleep,
metrics: retrierMetrics{
success: scope.Counter("success"),
successLatency: scope.Timer("success-latency"),
errors: scope.Tagged(errorTags.retryable).Counter("errors"),
errorsNotRetryable: scope.Tagged(errorTags.notRetryable).Counter("errors"),
errorsFinal: scope.Counter("errors-final"),
errorsLatency: scope.Timer("errors-latency"),
retries: scope.Counter("retries"),
},
}
} | go | func NewRetrier(opts Options) Retrier {
scope := opts.MetricsScope()
errorTags := struct {
retryable map[string]string
notRetryable map[string]string
}{
map[string]string{
"type": "retryable",
},
map[string]string{
"type": "not-retryable",
},
}
return &retrier{
initialBackoff: opts.InitialBackoff(),
backoffFactor: opts.BackoffFactor(),
maxBackoff: opts.MaxBackoff(),
maxRetries: opts.MaxRetries(),
forever: opts.Forever(),
jitter: opts.Jitter(),
rngFn: opts.RngFn(),
sleepFn: time.Sleep,
metrics: retrierMetrics{
success: scope.Counter("success"),
successLatency: scope.Timer("success-latency"),
errors: scope.Tagged(errorTags.retryable).Counter("errors"),
errorsNotRetryable: scope.Tagged(errorTags.notRetryable).Counter("errors"),
errorsFinal: scope.Counter("errors-final"),
errorsLatency: scope.Timer("errors-latency"),
retries: scope.Counter("retries"),
},
}
} | [
"func",
"NewRetrier",
"(",
"opts",
"Options",
")",
"Retrier",
"{",
"scope",
":=",
"opts",
".",
"MetricsScope",
"(",
")",
"\n",
"errorTags",
":=",
"struct",
"{",
"retryable",
"map",
"[",
"string",
"]",
"string",
"\n",
"notRetryable",
"map",
"[",
"string",
"]",
"string",
"\n",
"}",
"{",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"}",
"\n",
"return",
"&",
"retrier",
"{",
"initialBackoff",
":",
"opts",
".",
"InitialBackoff",
"(",
")",
",",
"backoffFactor",
":",
"opts",
".",
"BackoffFactor",
"(",
")",
",",
"maxBackoff",
":",
"opts",
".",
"MaxBackoff",
"(",
")",
",",
"maxRetries",
":",
"opts",
".",
"MaxRetries",
"(",
")",
",",
"forever",
":",
"opts",
".",
"Forever",
"(",
")",
",",
"jitter",
":",
"opts",
".",
"Jitter",
"(",
")",
",",
"rngFn",
":",
"opts",
".",
"RngFn",
"(",
")",
",",
"sleepFn",
":",
"time",
".",
"Sleep",
",",
"metrics",
":",
"retrierMetrics",
"{",
"success",
":",
"scope",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"successLatency",
":",
"scope",
".",
"Timer",
"(",
"\"",
"\"",
")",
",",
"errors",
":",
"scope",
".",
"Tagged",
"(",
"errorTags",
".",
"retryable",
")",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"errorsNotRetryable",
":",
"scope",
".",
"Tagged",
"(",
"errorTags",
".",
"notRetryable",
")",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"errorsFinal",
":",
"scope",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"errorsLatency",
":",
"scope",
".",
"Timer",
"(",
"\"",
"\"",
")",
",",
"retries",
":",
"scope",
".",
"Counter",
"(",
"\"",
"\"",
")",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewRetrier creates a new retrier. | [
"NewRetrier",
"creates",
"a",
"new",
"retrier",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/retry/retry.go#L62-L94 |
2,929 | m3db/m3x | retry/retry.go | BackoffNanos | func BackoffNanos(
retry int,
jitter bool,
backoffFactor float64,
initialBackoff time.Duration,
maxBackoff time.Duration,
rngFn RngFn,
) int64 {
backoff := initialBackoff.Nanoseconds()
if retry >= 1 {
backoffFloat64 := float64(backoff) * math.Pow(backoffFactor, float64(retry-1))
// math.Inf is also larger than math.MaxInt64.
if backoffFloat64 > math.MaxInt64 {
return maxBackoff.Nanoseconds()
}
backoff = int64(backoffFloat64)
}
// Validate the value of backoff to make sure Int63n() does not panic.
if jitter && backoff >= 2 {
half := backoff / 2
backoff = half + rngFn(half)
}
if maxBackoff := maxBackoff.Nanoseconds(); backoff > maxBackoff {
backoff = maxBackoff
}
return backoff
} | go | func BackoffNanos(
retry int,
jitter bool,
backoffFactor float64,
initialBackoff time.Duration,
maxBackoff time.Duration,
rngFn RngFn,
) int64 {
backoff := initialBackoff.Nanoseconds()
if retry >= 1 {
backoffFloat64 := float64(backoff) * math.Pow(backoffFactor, float64(retry-1))
// math.Inf is also larger than math.MaxInt64.
if backoffFloat64 > math.MaxInt64 {
return maxBackoff.Nanoseconds()
}
backoff = int64(backoffFloat64)
}
// Validate the value of backoff to make sure Int63n() does not panic.
if jitter && backoff >= 2 {
half := backoff / 2
backoff = half + rngFn(half)
}
if maxBackoff := maxBackoff.Nanoseconds(); backoff > maxBackoff {
backoff = maxBackoff
}
return backoff
} | [
"func",
"BackoffNanos",
"(",
"retry",
"int",
",",
"jitter",
"bool",
",",
"backoffFactor",
"float64",
",",
"initialBackoff",
"time",
".",
"Duration",
",",
"maxBackoff",
"time",
".",
"Duration",
",",
"rngFn",
"RngFn",
",",
")",
"int64",
"{",
"backoff",
":=",
"initialBackoff",
".",
"Nanoseconds",
"(",
")",
"\n",
"if",
"retry",
">=",
"1",
"{",
"backoffFloat64",
":=",
"float64",
"(",
"backoff",
")",
"*",
"math",
".",
"Pow",
"(",
"backoffFactor",
",",
"float64",
"(",
"retry",
"-",
"1",
")",
")",
"\n",
"// math.Inf is also larger than math.MaxInt64.",
"if",
"backoffFloat64",
">",
"math",
".",
"MaxInt64",
"{",
"return",
"maxBackoff",
".",
"Nanoseconds",
"(",
")",
"\n",
"}",
"\n",
"backoff",
"=",
"int64",
"(",
"backoffFloat64",
")",
"\n",
"}",
"\n",
"// Validate the value of backoff to make sure Int63n() does not panic.",
"if",
"jitter",
"&&",
"backoff",
">=",
"2",
"{",
"half",
":=",
"backoff",
"/",
"2",
"\n",
"backoff",
"=",
"half",
"+",
"rngFn",
"(",
"half",
")",
"\n",
"}",
"\n",
"if",
"maxBackoff",
":=",
"maxBackoff",
".",
"Nanoseconds",
"(",
")",
";",
"backoff",
">",
"maxBackoff",
"{",
"backoff",
"=",
"maxBackoff",
"\n",
"}",
"\n",
"return",
"backoff",
"\n",
"}"
] | // BackoffNanos calculates the backoff for a retry in nanoseconds. | [
"BackoffNanos",
"calculates",
"the",
"backoff",
"for",
"a",
"retry",
"in",
"nanoseconds",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/retry/retry.go#L164-L190 |
2,930 | m3db/m3x | time/range_iter.go | Next | func (it *RangeIter) Next() bool {
if it.ranges == nil {
return false
}
if it.cur == nil {
it.cur = it.ranges.Front()
} else {
it.cur = it.cur.Next()
}
return it.cur != nil
} | go | func (it *RangeIter) Next() bool {
if it.ranges == nil {
return false
}
if it.cur == nil {
it.cur = it.ranges.Front()
} else {
it.cur = it.cur.Next()
}
return it.cur != nil
} | [
"func",
"(",
"it",
"*",
"RangeIter",
")",
"Next",
"(",
")",
"bool",
"{",
"if",
"it",
".",
"ranges",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"it",
".",
"cur",
"==",
"nil",
"{",
"it",
".",
"cur",
"=",
"it",
".",
"ranges",
".",
"Front",
"(",
")",
"\n",
"}",
"else",
"{",
"it",
".",
"cur",
"=",
"it",
".",
"cur",
".",
"Next",
"(",
")",
"\n",
"}",
"\n",
"return",
"it",
".",
"cur",
"!=",
"nil",
"\n",
"}"
] | // Next moves to the next item. | [
"Next",
"moves",
"to",
"the",
"next",
"item",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range_iter.go#L36-L46 |
2,931 | m3db/m3x | time/range_iter.go | Value | func (it *RangeIter) Value() Range {
if it.cur == nil {
return Range{}
}
return it.cur.Value.(Range)
} | go | func (it *RangeIter) Value() Range {
if it.cur == nil {
return Range{}
}
return it.cur.Value.(Range)
} | [
"func",
"(",
"it",
"*",
"RangeIter",
")",
"Value",
"(",
")",
"Range",
"{",
"if",
"it",
".",
"cur",
"==",
"nil",
"{",
"return",
"Range",
"{",
"}",
"\n",
"}",
"\n",
"return",
"it",
".",
"cur",
".",
"Value",
".",
"(",
"Range",
")",
"\n",
"}"
] | // Value returns the current time range. | [
"Value",
"returns",
"the",
"current",
"time",
"range",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/time/range_iter.go#L49-L54 |
2,932 | m3db/m3x | instrument/methods.go | NewSampledTimer | func NewSampledTimer(base tally.Timer, rate float64) (tally.Timer, error) {
if rate <= 0.0 || rate > 1.0 {
return nil, fmt.Errorf("sampling rate %f must be between 0.0 and 1.0", rate)
}
return &sampledTimer{
Timer: base,
rate: uint64(1.0 / rate),
}, nil
} | go | func NewSampledTimer(base tally.Timer, rate float64) (tally.Timer, error) {
if rate <= 0.0 || rate > 1.0 {
return nil, fmt.Errorf("sampling rate %f must be between 0.0 and 1.0", rate)
}
return &sampledTimer{
Timer: base,
rate: uint64(1.0 / rate),
}, nil
} | [
"func",
"NewSampledTimer",
"(",
"base",
"tally",
".",
"Timer",
",",
"rate",
"float64",
")",
"(",
"tally",
".",
"Timer",
",",
"error",
")",
"{",
"if",
"rate",
"<=",
"0.0",
"||",
"rate",
">",
"1.0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rate",
")",
"\n",
"}",
"\n",
"return",
"&",
"sampledTimer",
"{",
"Timer",
":",
"base",
",",
"rate",
":",
"uint64",
"(",
"1.0",
"/",
"rate",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewSampledTimer creates a new sampled timer. | [
"NewSampledTimer",
"creates",
"a",
"new",
"sampled",
"timer",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L45-L53 |
2,933 | m3db/m3x | instrument/methods.go | MustCreateSampledTimer | func MustCreateSampledTimer(base tally.Timer, rate float64) tally.Timer {
t, err := NewSampledTimer(base, rate)
if err != nil {
panic(err)
}
return t
} | go | func MustCreateSampledTimer(base tally.Timer, rate float64) tally.Timer {
t, err := NewSampledTimer(base, rate)
if err != nil {
panic(err)
}
return t
} | [
"func",
"MustCreateSampledTimer",
"(",
"base",
"tally",
".",
"Timer",
",",
"rate",
"float64",
")",
"tally",
".",
"Timer",
"{",
"t",
",",
"err",
":=",
"NewSampledTimer",
"(",
"base",
",",
"rate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] | // MustCreateSampledTimer creates a new sampled timer, and panics if an error
// is encountered. | [
"MustCreateSampledTimer",
"creates",
"a",
"new",
"sampled",
"timer",
"and",
"panics",
"if",
"an",
"error",
"is",
"encountered",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L57-L63 |
2,934 | m3db/m3x | instrument/methods.go | ReportSuccess | func (m *MethodMetrics) ReportSuccess(d time.Duration) {
m.Success.Inc(1)
m.SuccessLatency.Record(d)
} | go | func (m *MethodMetrics) ReportSuccess(d time.Duration) {
m.Success.Inc(1)
m.SuccessLatency.Record(d)
} | [
"func",
"(",
"m",
"*",
"MethodMetrics",
")",
"ReportSuccess",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"m",
".",
"Success",
".",
"Inc",
"(",
"1",
")",
"\n",
"m",
".",
"SuccessLatency",
".",
"Record",
"(",
"d",
")",
"\n",
"}"
] | // ReportSuccess reports a success. | [
"ReportSuccess",
"reports",
"a",
"success",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L100-L103 |
2,935 | m3db/m3x | instrument/methods.go | ReportError | func (m *MethodMetrics) ReportError(d time.Duration) {
m.Errors.Inc(1)
m.ErrorsLatency.Record(d)
} | go | func (m *MethodMetrics) ReportError(d time.Duration) {
m.Errors.Inc(1)
m.ErrorsLatency.Record(d)
} | [
"func",
"(",
"m",
"*",
"MethodMetrics",
")",
"ReportError",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"m",
".",
"Errors",
".",
"Inc",
"(",
"1",
")",
"\n",
"m",
".",
"ErrorsLatency",
".",
"Record",
"(",
"d",
")",
"\n",
"}"
] | // ReportError reports an error. | [
"ReportError",
"reports",
"an",
"error",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L106-L109 |
2,936 | m3db/m3x | instrument/methods.go | NewMethodMetrics | func NewMethodMetrics(scope tally.Scope, methodName string, samplingRate float64) MethodMetrics {
return MethodMetrics{
Errors: scope.Counter(methodName + ".errors"),
Success: scope.Counter(methodName + ".success"),
ErrorsLatency: MustCreateSampledTimer(scope.Timer(methodName+".errors-latency"), samplingRate),
SuccessLatency: MustCreateSampledTimer(scope.Timer(methodName+".success-latency"), samplingRate),
}
} | go | func NewMethodMetrics(scope tally.Scope, methodName string, samplingRate float64) MethodMetrics {
return MethodMetrics{
Errors: scope.Counter(methodName + ".errors"),
Success: scope.Counter(methodName + ".success"),
ErrorsLatency: MustCreateSampledTimer(scope.Timer(methodName+".errors-latency"), samplingRate),
SuccessLatency: MustCreateSampledTimer(scope.Timer(methodName+".success-latency"), samplingRate),
}
} | [
"func",
"NewMethodMetrics",
"(",
"scope",
"tally",
".",
"Scope",
",",
"methodName",
"string",
",",
"samplingRate",
"float64",
")",
"MethodMetrics",
"{",
"return",
"MethodMetrics",
"{",
"Errors",
":",
"scope",
".",
"Counter",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"Success",
":",
"scope",
".",
"Counter",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"ErrorsLatency",
":",
"MustCreateSampledTimer",
"(",
"scope",
".",
"Timer",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"samplingRate",
")",
",",
"SuccessLatency",
":",
"MustCreateSampledTimer",
"(",
"scope",
".",
"Timer",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"samplingRate",
")",
",",
"}",
"\n",
"}"
] | // NewMethodMetrics returns a new Method metrics for the given method name. | [
"NewMethodMetrics",
"returns",
"a",
"new",
"Method",
"metrics",
"for",
"the",
"given",
"method",
"name",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L121-L128 |
2,937 | m3db/m3x | instrument/methods.go | NewBatchMethodMetrics | func NewBatchMethodMetrics(
scope tally.Scope,
methodName string,
samplingRate float64,
) BatchMethodMetrics {
return BatchMethodMetrics{
RetryableErrors: scope.Counter(methodName + ".retryable-errors"),
NonRetryableErrors: scope.Counter(methodName + ".non-retryable-errors"),
Errors: scope.Counter(methodName + ".errors"),
Success: scope.Counter(methodName + ".success"),
Latency: MustCreateSampledTimer(scope.Timer(methodName+".latency"), samplingRate),
}
} | go | func NewBatchMethodMetrics(
scope tally.Scope,
methodName string,
samplingRate float64,
) BatchMethodMetrics {
return BatchMethodMetrics{
RetryableErrors: scope.Counter(methodName + ".retryable-errors"),
NonRetryableErrors: scope.Counter(methodName + ".non-retryable-errors"),
Errors: scope.Counter(methodName + ".errors"),
Success: scope.Counter(methodName + ".success"),
Latency: MustCreateSampledTimer(scope.Timer(methodName+".latency"), samplingRate),
}
} | [
"func",
"NewBatchMethodMetrics",
"(",
"scope",
"tally",
".",
"Scope",
",",
"methodName",
"string",
",",
"samplingRate",
"float64",
",",
")",
"BatchMethodMetrics",
"{",
"return",
"BatchMethodMetrics",
"{",
"RetryableErrors",
":",
"scope",
".",
"Counter",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"NonRetryableErrors",
":",
"scope",
".",
"Counter",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"Errors",
":",
"scope",
".",
"Counter",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"Success",
":",
"scope",
".",
"Counter",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"Latency",
":",
"MustCreateSampledTimer",
"(",
"scope",
".",
"Timer",
"(",
"methodName",
"+",
"\"",
"\"",
")",
",",
"samplingRate",
")",
",",
"}",
"\n",
"}"
] | // NewBatchMethodMetrics creates new batch method metrics. | [
"NewBatchMethodMetrics",
"creates",
"new",
"batch",
"method",
"metrics",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L140-L152 |
2,938 | m3db/m3x | instrument/methods.go | ReportSuccess | func (m *BatchMethodMetrics) ReportSuccess(n int) {
m.Success.Inc(int64(n))
} | go | func (m *BatchMethodMetrics) ReportSuccess(n int) {
m.Success.Inc(int64(n))
} | [
"func",
"(",
"m",
"*",
"BatchMethodMetrics",
")",
"ReportSuccess",
"(",
"n",
"int",
")",
"{",
"m",
".",
"Success",
".",
"Inc",
"(",
"int64",
"(",
"n",
")",
")",
"\n",
"}"
] | // ReportSuccess reports successess. | [
"ReportSuccess",
"reports",
"successess",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L155-L157 |
2,939 | m3db/m3x | instrument/methods.go | ReportRetryableErrors | func (m *BatchMethodMetrics) ReportRetryableErrors(n int) {
m.RetryableErrors.Inc(int64(n))
m.Errors.Inc(int64(n))
} | go | func (m *BatchMethodMetrics) ReportRetryableErrors(n int) {
m.RetryableErrors.Inc(int64(n))
m.Errors.Inc(int64(n))
} | [
"func",
"(",
"m",
"*",
"BatchMethodMetrics",
")",
"ReportRetryableErrors",
"(",
"n",
"int",
")",
"{",
"m",
".",
"RetryableErrors",
".",
"Inc",
"(",
"int64",
"(",
"n",
")",
")",
"\n",
"m",
".",
"Errors",
".",
"Inc",
"(",
"int64",
"(",
"n",
")",
")",
"\n",
"}"
] | // ReportRetryableErrors reports retryable errors. | [
"ReportRetryableErrors",
"reports",
"retryable",
"errors",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L160-L163 |
2,940 | m3db/m3x | instrument/methods.go | ReportNonRetryableErrors | func (m *BatchMethodMetrics) ReportNonRetryableErrors(n int) {
m.NonRetryableErrors.Inc(int64(n))
m.Errors.Inc(int64(n))
} | go | func (m *BatchMethodMetrics) ReportNonRetryableErrors(n int) {
m.NonRetryableErrors.Inc(int64(n))
m.Errors.Inc(int64(n))
} | [
"func",
"(",
"m",
"*",
"BatchMethodMetrics",
")",
"ReportNonRetryableErrors",
"(",
"n",
"int",
")",
"{",
"m",
".",
"NonRetryableErrors",
".",
"Inc",
"(",
"int64",
"(",
"n",
")",
")",
"\n",
"m",
".",
"Errors",
".",
"Inc",
"(",
"int64",
"(",
"n",
")",
")",
"\n",
"}"
] | // ReportNonRetryableErrors reports non-retryable errors. | [
"ReportNonRetryableErrors",
"reports",
"non",
"-",
"retryable",
"errors",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L166-L169 |
2,941 | m3db/m3x | instrument/methods.go | ReportLatency | func (m *BatchMethodMetrics) ReportLatency(d time.Duration) {
m.Latency.Record(d)
} | go | func (m *BatchMethodMetrics) ReportLatency(d time.Duration) {
m.Latency.Record(d)
} | [
"func",
"(",
"m",
"*",
"BatchMethodMetrics",
")",
"ReportLatency",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"m",
".",
"Latency",
".",
"Record",
"(",
"d",
")",
"\n",
"}"
] | // ReportLatency reports latency. | [
"ReportLatency",
"reports",
"latency",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/instrument/methods.go#L172-L174 |
2,942 | m3db/m3x | watch/source.go | NewSource | func NewSource(input SourceInput, logger log.Logger) Source {
s := &source{
input: input,
w: NewWatchable(),
logger: logger,
}
go s.run()
return s
} | go | func NewSource(input SourceInput, logger log.Logger) Source {
s := &source{
input: input,
w: NewWatchable(),
logger: logger,
}
go s.run()
return s
} | [
"func",
"NewSource",
"(",
"input",
"SourceInput",
",",
"logger",
"log",
".",
"Logger",
")",
"Source",
"{",
"s",
":=",
"&",
"source",
"{",
"input",
":",
"input",
",",
"w",
":",
"NewWatchable",
"(",
")",
",",
"logger",
":",
"logger",
",",
"}",
"\n\n",
"go",
"s",
".",
"run",
"(",
")",
"\n",
"return",
"s",
"\n",
"}"
] | // NewSource returns a new Source. | [
"NewSource",
"returns",
"a",
"new",
"Source",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/watch/source.go#L53-L62 |
2,943 | m3db/m3x | log/logger.go | NewLogger | func NewLogger(writer io.Writer, fields ...Field) Logger {
return &writerLogger{writer, Fields(fields)}
} | go | func NewLogger(writer io.Writer, fields ...Field) Logger {
return &writerLogger{writer, Fields(fields)}
} | [
"func",
"NewLogger",
"(",
"writer",
"io",
".",
"Writer",
",",
"fields",
"...",
"Field",
")",
"Logger",
"{",
"return",
"&",
"writerLogger",
"{",
"writer",
",",
"Fields",
"(",
"fields",
")",
"}",
"\n",
"}"
] | // NewLogger returns a Logger that writes to the given writer. | [
"NewLogger",
"returns",
"a",
"Logger",
"that",
"writes",
"to",
"the",
"given",
"writer",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/log/logger.go#L155-L157 |
2,944 | m3db/m3x | log/logger.go | ParseLevel | func ParseLevel(level string) (Level, error) {
level = strings.ToLower(level)
for _, l := range levels {
if strings.ToLower(l.String()) == level {
return l, nil
}
}
return Level(0), fmt.Errorf("unrecognized log level: %s", level)
} | go | func ParseLevel(level string) (Level, error) {
level = strings.ToLower(level)
for _, l := range levels {
if strings.ToLower(l.String()) == level {
return l, nil
}
}
return Level(0), fmt.Errorf("unrecognized log level: %s", level)
} | [
"func",
"ParseLevel",
"(",
"level",
"string",
")",
"(",
"Level",
",",
"error",
")",
"{",
"level",
"=",
"strings",
".",
"ToLower",
"(",
"level",
")",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"levels",
"{",
"if",
"strings",
".",
"ToLower",
"(",
"l",
".",
"String",
"(",
")",
")",
"==",
"level",
"{",
"return",
"l",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"Level",
"(",
"0",
")",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"level",
")",
"\n",
"}"
] | // ParseLevel parses a log level string to log level. | [
"ParseLevel",
"parses",
"a",
"log",
"level",
"string",
"to",
"log",
"level",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/log/logger.go#L243-L251 |
2,945 | m3db/m3x | clock/types.go | WaitUntil | func WaitUntil(fn ConditionFn, timeout time.Duration) bool {
deadline := time.Now().Add(timeout)
for time.Now().Before(deadline) {
if fn() {
return true
}
time.Sleep(100 * time.Millisecond)
}
return false
} | go | func WaitUntil(fn ConditionFn, timeout time.Duration) bool {
deadline := time.Now().Add(timeout)
for time.Now().Before(deadline) {
if fn() {
return true
}
time.Sleep(100 * time.Millisecond)
}
return false
} | [
"func",
"WaitUntil",
"(",
"fn",
"ConditionFn",
",",
"timeout",
"time",
".",
"Duration",
")",
"bool",
"{",
"deadline",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"timeout",
")",
"\n",
"for",
"time",
".",
"Now",
"(",
")",
".",
"Before",
"(",
"deadline",
")",
"{",
"if",
"fn",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // WaitUntil returns true if the condition specified evaluated to
// true before the timeout, false otherwise. | [
"WaitUntil",
"returns",
"true",
"if",
"the",
"condition",
"specified",
"evaluated",
"to",
"true",
"before",
"the",
"timeout",
"false",
"otherwise",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/clock/types.go#L61-L70 |
2,946 | m3db/m3x | net/server.go | StartAcceptLoop | func StartAcceptLoop(l net.Listener, rOpts retry.Options) (<-chan net.Conn, <-chan error) {
var (
connCh = make(chan net.Conn)
errCh = make(chan error)
retrier = retry.NewRetrier(rOpts)
)
go func() {
defer l.Close()
for {
var conn net.Conn
if err := retrier.Attempt(func() error {
var connErr error
conn, connErr = l.Accept()
if connErr == nil {
return nil
}
// If the error is a temporary network error, we consider it retryable.
if ne, ok := connErr.(net.Error); ok && ne.Temporary() {
return ne
}
// Otherwise it's a non-retryable error.
return errors.NewNonRetryableError(connErr)
}); err != nil {
close(connCh)
errCh <- err
close(errCh)
return
}
connCh <- conn
}
}()
return connCh, errCh
} | go | func StartAcceptLoop(l net.Listener, rOpts retry.Options) (<-chan net.Conn, <-chan error) {
var (
connCh = make(chan net.Conn)
errCh = make(chan error)
retrier = retry.NewRetrier(rOpts)
)
go func() {
defer l.Close()
for {
var conn net.Conn
if err := retrier.Attempt(func() error {
var connErr error
conn, connErr = l.Accept()
if connErr == nil {
return nil
}
// If the error is a temporary network error, we consider it retryable.
if ne, ok := connErr.(net.Error); ok && ne.Temporary() {
return ne
}
// Otherwise it's a non-retryable error.
return errors.NewNonRetryableError(connErr)
}); err != nil {
close(connCh)
errCh <- err
close(errCh)
return
}
connCh <- conn
}
}()
return connCh, errCh
} | [
"func",
"StartAcceptLoop",
"(",
"l",
"net",
".",
"Listener",
",",
"rOpts",
"retry",
".",
"Options",
")",
"(",
"<-",
"chan",
"net",
".",
"Conn",
",",
"<-",
"chan",
"error",
")",
"{",
"var",
"(",
"connCh",
"=",
"make",
"(",
"chan",
"net",
".",
"Conn",
")",
"\n",
"errCh",
"=",
"make",
"(",
"chan",
"error",
")",
"\n",
"retrier",
"=",
"retry",
".",
"NewRetrier",
"(",
"rOpts",
")",
"\n",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"defer",
"l",
".",
"Close",
"(",
")",
"\n\n",
"for",
"{",
"var",
"conn",
"net",
".",
"Conn",
"\n",
"if",
"err",
":=",
"retrier",
".",
"Attempt",
"(",
"func",
"(",
")",
"error",
"{",
"var",
"connErr",
"error",
"\n",
"conn",
",",
"connErr",
"=",
"l",
".",
"Accept",
"(",
")",
"\n",
"if",
"connErr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"// If the error is a temporary network error, we consider it retryable.",
"if",
"ne",
",",
"ok",
":=",
"connErr",
".",
"(",
"net",
".",
"Error",
")",
";",
"ok",
"&&",
"ne",
".",
"Temporary",
"(",
")",
"{",
"return",
"ne",
"\n",
"}",
"\n",
"// Otherwise it's a non-retryable error.",
"return",
"errors",
".",
"NewNonRetryableError",
"(",
"connErr",
")",
"\n",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"close",
"(",
"connCh",
")",
"\n",
"errCh",
"<-",
"err",
"\n",
"close",
"(",
"errCh",
")",
"\n",
"return",
"\n",
"}",
"\n",
"connCh",
"<-",
"conn",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"connCh",
",",
"errCh",
"\n",
"}"
] | // StartAcceptLoop starts an accept loop for the given listener,
// returning accepted connections via a channel while handling
// temporary network errors. Fatal errors are returned via the
// error channel with the listener closed on return. | [
"StartAcceptLoop",
"starts",
"an",
"accept",
"loop",
"for",
"the",
"given",
"listener",
"returning",
"accepted",
"connections",
"via",
"a",
"channel",
"while",
"handling",
"temporary",
"network",
"errors",
".",
"Fatal",
"errors",
"are",
"returned",
"via",
"the",
"error",
"channel",
"with",
"the",
"listener",
"closed",
"on",
"return",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/net/server.go#L35-L70 |
2,947 | m3db/m3x | net/server.go | StartForeverAcceptLoop | func StartForeverAcceptLoop(l net.Listener, rOpts retry.Options) (<-chan net.Conn, <-chan error) {
return StartAcceptLoop(l, rOpts.SetForever(true))
} | go | func StartForeverAcceptLoop(l net.Listener, rOpts retry.Options) (<-chan net.Conn, <-chan error) {
return StartAcceptLoop(l, rOpts.SetForever(true))
} | [
"func",
"StartForeverAcceptLoop",
"(",
"l",
"net",
".",
"Listener",
",",
"rOpts",
"retry",
".",
"Options",
")",
"(",
"<-",
"chan",
"net",
".",
"Conn",
",",
"<-",
"chan",
"error",
")",
"{",
"return",
"StartAcceptLoop",
"(",
"l",
",",
"rOpts",
".",
"SetForever",
"(",
"true",
")",
")",
"\n",
"}"
] | // StartForeverAcceptLoop starts an accept loop for the
// given listener that retries forever, returning
// accepted connections via a channel while handling
// temporary network errors. Fatal errors are returned via the
// error channel with the listener closed on return. | [
"StartForeverAcceptLoop",
"starts",
"an",
"accept",
"loop",
"for",
"the",
"given",
"listener",
"that",
"retries",
"forever",
"returning",
"accepted",
"connections",
"via",
"a",
"channel",
"while",
"handling",
"temporary",
"network",
"errors",
".",
"Fatal",
"errors",
"are",
"returned",
"via",
"the",
"error",
"channel",
"with",
"the",
"listener",
"closed",
"on",
"return",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/net/server.go#L77-L79 |
2,948 | m3db/m3x | pool/options.go | NewObjectPoolOptions | func NewObjectPoolOptions() ObjectPoolOptions {
return &objectPoolOptions{
size: defaultSize,
refillLowWatermark: defaultRefillLowWatermark,
refillHighWatermark: defaultRefillHighWatermark,
instrumentOpts: instrument.NewOptions(),
onPoolAccessErrorFn: func(err error) { panic(err) },
}
} | go | func NewObjectPoolOptions() ObjectPoolOptions {
return &objectPoolOptions{
size: defaultSize,
refillLowWatermark: defaultRefillLowWatermark,
refillHighWatermark: defaultRefillHighWatermark,
instrumentOpts: instrument.NewOptions(),
onPoolAccessErrorFn: func(err error) { panic(err) },
}
} | [
"func",
"NewObjectPoolOptions",
"(",
")",
"ObjectPoolOptions",
"{",
"return",
"&",
"objectPoolOptions",
"{",
"size",
":",
"defaultSize",
",",
"refillLowWatermark",
":",
"defaultRefillLowWatermark",
",",
"refillHighWatermark",
":",
"defaultRefillHighWatermark",
",",
"instrumentOpts",
":",
"instrument",
".",
"NewOptions",
"(",
")",
",",
"onPoolAccessErrorFn",
":",
"func",
"(",
"err",
"error",
")",
"{",
"panic",
"(",
"err",
")",
"}",
",",
"}",
"\n",
"}"
] | // NewObjectPoolOptions creates a new set of object pool options | [
"NewObjectPoolOptions",
"creates",
"a",
"new",
"set",
"of",
"object",
"pool",
"options"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/options.go#L40-L48 |
2,949 | m3db/m3x | ident/ident_mock.go | NewMockID | func NewMockID(ctrl *gomock.Controller) *MockID {
mock := &MockID{ctrl: ctrl}
mock.recorder = &MockIDMockRecorder{mock}
return mock
} | go | func NewMockID(ctrl *gomock.Controller) *MockID {
mock := &MockID{ctrl: ctrl}
mock.recorder = &MockIDMockRecorder{mock}
return mock
} | [
"func",
"NewMockID",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockID",
"{",
"mock",
":=",
"&",
"MockID",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockIDMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockID creates a new mock instance | [
"NewMockID",
"creates",
"a",
"new",
"mock",
"instance"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L45-L49 |
2,950 | m3db/m3x | ident/ident_mock.go | Bytes | func (mr *MockIDMockRecorder) Bytes() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bytes", reflect.TypeOf((*MockID)(nil).Bytes))
} | go | func (mr *MockIDMockRecorder) Bytes() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bytes", reflect.TypeOf((*MockID)(nil).Bytes))
} | [
"func",
"(",
"mr",
"*",
"MockIDMockRecorder",
")",
"Bytes",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockID",
")",
"(",
"nil",
")",
".",
"Bytes",
")",
")",
"\n",
"}"
] | // Bytes indicates an expected call of Bytes | [
"Bytes",
"indicates",
"an",
"expected",
"call",
"of",
"Bytes"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L64-L66 |
2,951 | m3db/m3x | ident/ident_mock.go | Equal | func (m *MockID) Equal(arg0 ID) bool {
ret := m.ctrl.Call(m, "Equal", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockID) Equal(arg0 ID) bool {
ret := m.ctrl.Call(m, "Equal", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockID",
")",
"Equal",
"(",
"arg0",
"ID",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Equal mocks base method | [
"Equal",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L69-L73 |
2,952 | m3db/m3x | ident/ident_mock.go | Equal | func (mr *MockIDMockRecorder) Equal(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockID)(nil).Equal), arg0)
} | go | func (mr *MockIDMockRecorder) Equal(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockID)(nil).Equal), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockIDMockRecorder",
")",
"Equal",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockID",
")",
"(",
"nil",
")",
".",
"Equal",
")",
",",
"arg0",
")",
"\n",
"}"
] | // Equal indicates an expected call of Equal | [
"Equal",
"indicates",
"an",
"expected",
"call",
"of",
"Equal"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L76-L78 |
2,953 | m3db/m3x | ident/ident_mock.go | IsNoFinalize | func (m *MockID) IsNoFinalize() bool {
ret := m.ctrl.Call(m, "IsNoFinalize")
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockID) IsNoFinalize() bool {
ret := m.ctrl.Call(m, "IsNoFinalize")
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockID",
")",
"IsNoFinalize",
"(",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // IsNoFinalize mocks base method | [
"IsNoFinalize",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L91-L95 |
2,954 | m3db/m3x | ident/ident_mock.go | NewMockTagIterator | func NewMockTagIterator(ctrl *gomock.Controller) *MockTagIterator {
mock := &MockTagIterator{ctrl: ctrl}
mock.recorder = &MockTagIteratorMockRecorder{mock}
return mock
} | go | func NewMockTagIterator(ctrl *gomock.Controller) *MockTagIterator {
mock := &MockTagIterator{ctrl: ctrl}
mock.recorder = &MockTagIteratorMockRecorder{mock}
return mock
} | [
"func",
"NewMockTagIterator",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockTagIterator",
"{",
"mock",
":=",
"&",
"MockTagIterator",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockTagIteratorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockTagIterator creates a new mock instance | [
"NewMockTagIterator",
"creates",
"a",
"new",
"mock",
"instance"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L136-L140 |
2,955 | m3db/m3x | ident/ident_mock.go | Current | func (m *MockTagIterator) Current() Tag {
ret := m.ctrl.Call(m, "Current")
ret0, _ := ret[0].(Tag)
return ret0
} | go | func (m *MockTagIterator) Current() Tag {
ret := m.ctrl.Call(m, "Current")
ret0, _ := ret[0].(Tag)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockTagIterator",
")",
"Current",
"(",
")",
"Tag",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"Tag",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Current mocks base method | [
"Current",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L158-L162 |
2,956 | m3db/m3x | ident/ident_mock.go | Duplicate | func (m *MockTagIterator) Duplicate() TagIterator {
ret := m.ctrl.Call(m, "Duplicate")
ret0, _ := ret[0].(TagIterator)
return ret0
} | go | func (m *MockTagIterator) Duplicate() TagIterator {
ret := m.ctrl.Call(m, "Duplicate")
ret0, _ := ret[0].(TagIterator)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockTagIterator",
")",
"Duplicate",
"(",
")",
"TagIterator",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"TagIterator",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Duplicate mocks base method | [
"Duplicate",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L182-L186 |
2,957 | m3db/m3x | ident/ident_mock.go | Len | func (mr *MockTagIteratorMockRecorder) Len() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockTagIterator)(nil).Len))
} | go | func (mr *MockTagIteratorMockRecorder) Len() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockTagIterator)(nil).Len))
} | [
"func",
"(",
"mr",
"*",
"MockTagIteratorMockRecorder",
")",
"Len",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockTagIterator",
")",
"(",
"nil",
")",
".",
"Len",
")",
")",
"\n",
"}"
] | // Len indicates an expected call of Len | [
"Len",
"indicates",
"an",
"expected",
"call",
"of",
"Len"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L213-L215 |
2,958 | m3db/m3x | ident/ident_mock.go | Next | func (m *MockTagIterator) Next() bool {
ret := m.ctrl.Call(m, "Next")
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockTagIterator) Next() bool {
ret := m.ctrl.Call(m, "Next")
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockTagIterator",
")",
"Next",
"(",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Next mocks base method | [
"Next",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L218-L222 |
2,959 | m3db/m3x | ident/ident_mock.go | Remaining | func (m *MockTagIterator) Remaining() int {
ret := m.ctrl.Call(m, "Remaining")
ret0, _ := ret[0].(int)
return ret0
} | go | func (m *MockTagIterator) Remaining() int {
ret := m.ctrl.Call(m, "Remaining")
ret0, _ := ret[0].(int)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockTagIterator",
")",
"Remaining",
"(",
")",
"int",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"int",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Remaining mocks base method | [
"Remaining",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/ident_mock.go#L230-L234 |
2,960 | m3db/m3x | checked/bytes.go | NewBytes | func NewBytes(value []byte, opts BytesOptions) Bytes {
if opts == nil {
opts = defaultBytesOptions
}
b := &bytesRef{
opts: opts,
value: value,
}
b.SetFinalizer(b)
// NB(r): Tracking objects causes interface allocation
// so avoid if we are not performing any leak detection.
if leakDetectionEnabled() {
b.TrackObject(b.value)
}
return b
} | go | func NewBytes(value []byte, opts BytesOptions) Bytes {
if opts == nil {
opts = defaultBytesOptions
}
b := &bytesRef{
opts: opts,
value: value,
}
b.SetFinalizer(b)
// NB(r): Tracking objects causes interface allocation
// so avoid if we are not performing any leak detection.
if leakDetectionEnabled() {
b.TrackObject(b.value)
}
return b
} | [
"func",
"NewBytes",
"(",
"value",
"[",
"]",
"byte",
",",
"opts",
"BytesOptions",
")",
"Bytes",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"defaultBytesOptions",
"\n",
"}",
"\n",
"b",
":=",
"&",
"bytesRef",
"{",
"opts",
":",
"opts",
",",
"value",
":",
"value",
",",
"}",
"\n",
"b",
".",
"SetFinalizer",
"(",
"b",
")",
"\n",
"// NB(r): Tracking objects causes interface allocation",
"// so avoid if we are not performing any leak detection.",
"if",
"leakDetectionEnabled",
"(",
")",
"{",
"b",
".",
"TrackObject",
"(",
"b",
".",
"value",
")",
"\n",
"}",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBytes returns a new checked byte slice. | [
"NewBytes",
"returns",
"a",
"new",
"checked",
"byte",
"slice",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/checked/bytes.go#L65-L80 |
2,961 | m3db/m3x | server/options.go | NewOptions | func NewOptions() Options {
return &options{
instrumentOpts: instrument.NewOptions(),
retryOpts: retry.NewOptions(),
tcpConnectionKeepAlive: defaultTCPConnectionKeepAlive,
tcpConnectionKeepAlivePeriod: defaultTCPConnectionKeepAlivePeriod,
}
} | go | func NewOptions() Options {
return &options{
instrumentOpts: instrument.NewOptions(),
retryOpts: retry.NewOptions(),
tcpConnectionKeepAlive: defaultTCPConnectionKeepAlive,
tcpConnectionKeepAlivePeriod: defaultTCPConnectionKeepAlivePeriod,
}
} | [
"func",
"NewOptions",
"(",
")",
"Options",
"{",
"return",
"&",
"options",
"{",
"instrumentOpts",
":",
"instrument",
".",
"NewOptions",
"(",
")",
",",
"retryOpts",
":",
"retry",
".",
"NewOptions",
"(",
")",
",",
"tcpConnectionKeepAlive",
":",
"defaultTCPConnectionKeepAlive",
",",
"tcpConnectionKeepAlivePeriod",
":",
"defaultTCPConnectionKeepAlivePeriod",
",",
"}",
"\n",
"}"
] | // NewOptions creates a new set of server options | [
"NewOptions",
"creates",
"a",
"new",
"set",
"of",
"server",
"options"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/server/options.go#L77-L84 |
2,962 | m3db/m3x | pool/pool_mock.go | NewMockCheckedBytesPool | func NewMockCheckedBytesPool(ctrl *gomock.Controller) *MockCheckedBytesPool {
mock := &MockCheckedBytesPool{ctrl: ctrl}
mock.recorder = &MockCheckedBytesPoolMockRecorder{mock}
return mock
} | go | func NewMockCheckedBytesPool(ctrl *gomock.Controller) *MockCheckedBytesPool {
mock := &MockCheckedBytesPool{ctrl: ctrl}
mock.recorder = &MockCheckedBytesPoolMockRecorder{mock}
return mock
} | [
"func",
"NewMockCheckedBytesPool",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCheckedBytesPool",
"{",
"mock",
":=",
"&",
"MockCheckedBytesPool",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCheckedBytesPoolMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockCheckedBytesPool creates a new mock instance | [
"NewMockCheckedBytesPool",
"creates",
"a",
"new",
"mock",
"instance"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/pool_mock.go#L47-L51 |
2,963 | m3db/m3x | pool/pool_mock.go | BytesPool | func (m *MockCheckedBytesPool) BytesPool() BytesPool {
ret := m.ctrl.Call(m, "BytesPool")
ret0, _ := ret[0].(BytesPool)
return ret0
} | go | func (m *MockCheckedBytesPool) BytesPool() BytesPool {
ret := m.ctrl.Call(m, "BytesPool")
ret0, _ := ret[0].(BytesPool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCheckedBytesPool",
")",
"BytesPool",
"(",
")",
"BytesPool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"BytesPool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // BytesPool mocks base method | [
"BytesPool",
"mocks",
"base",
"method"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/pool_mock.go#L59-L63 |
2,964 | m3db/m3x | pool/pool_mock.go | BytesPool | func (mr *MockCheckedBytesPoolMockRecorder) BytesPool() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BytesPool", reflect.TypeOf((*MockCheckedBytesPool)(nil).BytesPool))
} | go | func (mr *MockCheckedBytesPoolMockRecorder) BytesPool() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BytesPool", reflect.TypeOf((*MockCheckedBytesPool)(nil).BytesPool))
} | [
"func",
"(",
"mr",
"*",
"MockCheckedBytesPoolMockRecorder",
")",
"BytesPool",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCheckedBytesPool",
")",
"(",
"nil",
")",
".",
"BytesPool",
")",
")",
"\n",
"}"
] | // BytesPool indicates an expected call of BytesPool | [
"BytesPool",
"indicates",
"an",
"expected",
"call",
"of",
"BytesPool"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/pool_mock.go#L66-L68 |
2,965 | m3db/m3x | pool/pool_mock.go | NewMockBytesPool | func NewMockBytesPool(ctrl *gomock.Controller) *MockBytesPool {
mock := &MockBytesPool{ctrl: ctrl}
mock.recorder = &MockBytesPoolMockRecorder{mock}
return mock
} | go | func NewMockBytesPool(ctrl *gomock.Controller) *MockBytesPool {
mock := &MockBytesPool{ctrl: ctrl}
mock.recorder = &MockBytesPoolMockRecorder{mock}
return mock
} | [
"func",
"NewMockBytesPool",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockBytesPool",
"{",
"mock",
":=",
"&",
"MockBytesPool",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockBytesPoolMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockBytesPool creates a new mock instance | [
"NewMockBytesPool",
"creates",
"a",
"new",
"mock",
"instance"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/pool_mock.go#L104-L108 |
2,966 | m3db/m3x | ident/identifier.go | BinaryID | func BinaryID(v checked.Bytes) ID {
v.IncRef()
return &id{data: v}
} | go | func BinaryID(v checked.Bytes) ID {
v.IncRef()
return &id{data: v}
} | [
"func",
"BinaryID",
"(",
"v",
"checked",
".",
"Bytes",
")",
"ID",
"{",
"v",
".",
"IncRef",
"(",
")",
"\n",
"return",
"&",
"id",
"{",
"data",
":",
"v",
"}",
"\n",
"}"
] | // BinaryID constructs a new ID based on a binary value. | [
"BinaryID",
"constructs",
"a",
"new",
"ID",
"based",
"on",
"a",
"binary",
"value",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/identifier.go#L30-L33 |
2,967 | m3db/m3x | ident/identifier.go | Bytes | func (v *id) Bytes() []byte {
if v.data == nil {
return nil
}
return v.data.Bytes()
} | go | func (v *id) Bytes() []byte {
if v.data == nil {
return nil
}
return v.data.Bytes()
} | [
"func",
"(",
"v",
"*",
"id",
")",
"Bytes",
"(",
")",
"[",
"]",
"byte",
"{",
"if",
"v",
".",
"data",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"v",
".",
"data",
".",
"Bytes",
"(",
")",
"\n",
"}"
] | // Bytes directly returns the underlying bytes of an ID, it is not safe
// to hold a reference to this slice and is only valid during the lifetime
// of the the ID itself. | [
"Bytes",
"directly",
"returns",
"the",
"underlying",
"bytes",
"of",
"an",
"ID",
"it",
"is",
"not",
"safe",
"to",
"hold",
"a",
"reference",
"to",
"this",
"slice",
"and",
"is",
"only",
"valid",
"during",
"the",
"lifetime",
"of",
"the",
"the",
"ID",
"itself",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/ident/identifier.go#L49-L54 |
2,968 | m3db/m3x | close/close.go | TryClose | func TryClose(r interface{}) error {
if r, ok := r.(Closer); ok {
return r.Close()
}
if r, ok := r.(SimpleCloser); ok {
r.Close()
return nil
}
return ErrNotCloseable
} | go | func TryClose(r interface{}) error {
if r, ok := r.(Closer); ok {
return r.Close()
}
if r, ok := r.(SimpleCloser); ok {
r.Close()
return nil
}
return ErrNotCloseable
} | [
"func",
"TryClose",
"(",
"r",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"r",
",",
"ok",
":=",
"r",
".",
"(",
"Closer",
")",
";",
"ok",
"{",
"return",
"r",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
"r",
",",
"ok",
":=",
"r",
".",
"(",
"SimpleCloser",
")",
";",
"ok",
"{",
"r",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"ErrNotCloseable",
"\n",
"}"
] | // TryClose attempts to close a resource, the resource is expected to
// implement either Closeable or CloseableResult. | [
"TryClose",
"attempts",
"to",
"close",
"a",
"resource",
"the",
"resource",
"is",
"expected",
"to",
"implement",
"either",
"Closeable",
"or",
"CloseableResult",
"."
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/close/close.go#L47-L56 |
2,969 | m3db/m3x | pool/floats.go | NewFloatsPool | func NewFloatsPool(sizes []Bucket, opts ObjectPoolOptions) FloatsPool {
return &floatsPool{pool: NewBucketizedObjectPool(sizes, opts)}
} | go | func NewFloatsPool(sizes []Bucket, opts ObjectPoolOptions) FloatsPool {
return &floatsPool{pool: NewBucketizedObjectPool(sizes, opts)}
} | [
"func",
"NewFloatsPool",
"(",
"sizes",
"[",
"]",
"Bucket",
",",
"opts",
"ObjectPoolOptions",
")",
"FloatsPool",
"{",
"return",
"&",
"floatsPool",
"{",
"pool",
":",
"NewBucketizedObjectPool",
"(",
"sizes",
",",
"opts",
")",
"}",
"\n",
"}"
] | // NewFloatsPool creates a new floats pool | [
"NewFloatsPool",
"creates",
"a",
"new",
"floats",
"pool"
] | ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e | https://github.com/m3db/m3x/blob/ebf3c7b94afd62bad2aaa3ad20bb2d4142aa342e/pool/floats.go#L28-L30 |
2,970 | apcera/util | restclient/restclient.go | NewDisableKeepAlives | func NewDisableKeepAlives(baseurl string) (*Client, error) {
base, err := url.ParseRequestURI(baseurl)
if err != nil {
return nil, err
} else if !base.IsAbs() || base.Host == "" {
return nil, fmt.Errorf("URL is not absolute: %s", baseurl)
}
transport := http.DefaultTransport.(*http.Transport)
transport.DisableKeepAlives = true
// create the client
client := &Client{
Driver: &http.Client{
Transport: transport,
}, // Don't use default client; shares by reference
Headers: http.Header(make(map[string][]string)),
base: base,
KeepAlives: false,
}
return client, nil
} | go | func NewDisableKeepAlives(baseurl string) (*Client, error) {
base, err := url.ParseRequestURI(baseurl)
if err != nil {
return nil, err
} else if !base.IsAbs() || base.Host == "" {
return nil, fmt.Errorf("URL is not absolute: %s", baseurl)
}
transport := http.DefaultTransport.(*http.Transport)
transport.DisableKeepAlives = true
// create the client
client := &Client{
Driver: &http.Client{
Transport: transport,
}, // Don't use default client; shares by reference
Headers: http.Header(make(map[string][]string)),
base: base,
KeepAlives: false,
}
return client, nil
} | [
"func",
"NewDisableKeepAlives",
"(",
"baseurl",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"base",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"baseurl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"!",
"base",
".",
"IsAbs",
"(",
")",
"||",
"base",
".",
"Host",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"baseurl",
")",
"\n",
"}",
"\n\n",
"transport",
":=",
"http",
".",
"DefaultTransport",
".",
"(",
"*",
"http",
".",
"Transport",
")",
"\n",
"transport",
".",
"DisableKeepAlives",
"=",
"true",
"\n\n",
"// create the client",
"client",
":=",
"&",
"Client",
"{",
"Driver",
":",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"transport",
",",
"}",
",",
"// Don't use default client; shares by reference",
"Headers",
":",
"http",
".",
"Header",
"(",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
")",
",",
"base",
":",
"base",
",",
"KeepAlives",
":",
"false",
",",
"}",
"\n\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // NewWithoutKeepAlives returns a new client with keepalives disabled. | [
"NewWithoutKeepAlives",
"returns",
"a",
"new",
"client",
"with",
"keepalives",
"disabled",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L81-L103 |
2,971 | apcera/util | restclient/restclient.go | SetAccessToken | func (c *Client) SetAccessToken(token string) {
c.Headers.Set(http.CanonicalHeaderKey("Authorization"), "Bearer "+token)
} | go | func (c *Client) SetAccessToken(token string) {
c.Headers.Set(http.CanonicalHeaderKey("Authorization"), "Bearer "+token)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetAccessToken",
"(",
"token",
"string",
")",
"{",
"c",
".",
"Headers",
".",
"Set",
"(",
"http",
".",
"CanonicalHeaderKey",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
"+",
"token",
")",
"\n",
"}"
] | // Set the access Token | [
"Set",
"the",
"access",
"Token"
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L112-L114 |
2,972 | apcera/util | restclient/restclient.go | SetTimeout | func (c *Client) SetTimeout(duration time.Duration) {
c.Driver.Timeout = duration
} | go | func (c *Client) SetTimeout(duration time.Duration) {
c.Driver.Timeout = duration
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetTimeout",
"(",
"duration",
"time",
".",
"Duration",
")",
"{",
"c",
".",
"Driver",
".",
"Timeout",
"=",
"duration",
"\n",
"}"
] | // SetTimeout sets the timeout of a client to the given duration. | [
"SetTimeout",
"sets",
"the",
"timeout",
"of",
"a",
"client",
"to",
"the",
"given",
"duration",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L117-L119 |
2,973 | apcera/util | restclient/restclient.go | Result | func (c *Client) Result(req *Request, resp interface{}) error {
result, err := c.Do(req)
if err != nil {
return err
}
return unmarshal(result, resp)
} | go | func (c *Client) Result(req *Request, resp interface{}) error {
result, err := c.Do(req)
if err != nil {
return err
}
return unmarshal(result, resp)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Result",
"(",
"req",
"*",
"Request",
",",
"resp",
"interface",
"{",
"}",
")",
"error",
"{",
"result",
",",
"err",
":=",
"c",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"unmarshal",
"(",
"result",
",",
"resp",
")",
"\n",
"}"
] | // Result performs the request described by req and unmarshals a successful
// HTTP response into resp. If resp is nil, the response is discarded. | [
"Result",
"performs",
"the",
"request",
"described",
"by",
"req",
"and",
"unmarshals",
"a",
"successful",
"HTTP",
"response",
"into",
"resp",
".",
"If",
"resp",
"is",
"nil",
"the",
"response",
"is",
"discarded",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L155-L161 |
2,974 | apcera/util | restclient/restclient.go | NewRequest | func (c *Client) NewRequest(method Method, endpoint string, ctype string, body io.Reader) (req *Request) {
req = c.newRequest(method, endpoint)
if body == nil {
return
}
req.prepare = func(hr *http.Request) error {
rc, ok := body.(io.ReadCloser)
if !ok {
rc = ioutil.NopCloser(body)
}
hr.Body = rc
hr.Header.Set("Content-Type", ctype)
return nil
}
return
} | go | func (c *Client) NewRequest(method Method, endpoint string, ctype string, body io.Reader) (req *Request) {
req = c.newRequest(method, endpoint)
if body == nil {
return
}
req.prepare = func(hr *http.Request) error {
rc, ok := body.(io.ReadCloser)
if !ok {
rc = ioutil.NopCloser(body)
}
hr.Body = rc
hr.Header.Set("Content-Type", ctype)
return nil
}
return
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"NewRequest",
"(",
"method",
"Method",
",",
"endpoint",
"string",
",",
"ctype",
"string",
",",
"body",
"io",
".",
"Reader",
")",
"(",
"req",
"*",
"Request",
")",
"{",
"req",
"=",
"c",
".",
"newRequest",
"(",
"method",
",",
"endpoint",
")",
"\n",
"if",
"body",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"req",
".",
"prepare",
"=",
"func",
"(",
"hr",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"rc",
",",
"ok",
":=",
"body",
".",
"(",
"io",
".",
"ReadCloser",
")",
"\n",
"if",
"!",
"ok",
"{",
"rc",
"=",
"ioutil",
".",
"NopCloser",
"(",
"body",
")",
"\n",
"}",
"\n",
"hr",
".",
"Body",
"=",
"rc",
"\n",
"hr",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"ctype",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // NewRequest generates a new Request object that will send bytes read from body
// to the endpoint. | [
"NewRequest",
"generates",
"a",
"new",
"Request",
"object",
"that",
"will",
"send",
"bytes",
"read",
"from",
"body",
"to",
"the",
"endpoint",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L194-L210 |
2,975 | apcera/util | restclient/restclient.go | NewJsonRequest | func (c *Client) NewJsonRequest(method Method, endpoint string, obj interface{}) (req *Request) {
req = c.newRequest(method, endpoint)
if obj == nil {
return
}
req.prepare = func(httpReq *http.Request) error {
var buffer bytes.Buffer
encoder := json.NewEncoder(&buffer)
if err := encoder.Encode(obj); err != nil {
return err
}
// set to the request
httpReq.Body = ioutil.NopCloser(&buffer)
httpReq.ContentLength = int64(buffer.Len())
httpReq.Header.Set("Content-Type", "application/json")
return nil
}
return req
} | go | func (c *Client) NewJsonRequest(method Method, endpoint string, obj interface{}) (req *Request) {
req = c.newRequest(method, endpoint)
if obj == nil {
return
}
req.prepare = func(httpReq *http.Request) error {
var buffer bytes.Buffer
encoder := json.NewEncoder(&buffer)
if err := encoder.Encode(obj); err != nil {
return err
}
// set to the request
httpReq.Body = ioutil.NopCloser(&buffer)
httpReq.ContentLength = int64(buffer.Len())
httpReq.Header.Set("Content-Type", "application/json")
return nil
}
return req
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"NewJsonRequest",
"(",
"method",
"Method",
",",
"endpoint",
"string",
",",
"obj",
"interface",
"{",
"}",
")",
"(",
"req",
"*",
"Request",
")",
"{",
"req",
"=",
"c",
".",
"newRequest",
"(",
"method",
",",
"endpoint",
")",
"\n",
"if",
"obj",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"req",
".",
"prepare",
"=",
"func",
"(",
"httpReq",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"var",
"buffer",
"bytes",
".",
"Buffer",
"\n",
"encoder",
":=",
"json",
".",
"NewEncoder",
"(",
"&",
"buffer",
")",
"\n",
"if",
"err",
":=",
"encoder",
".",
"Encode",
"(",
"obj",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set to the request",
"httpReq",
".",
"Body",
"=",
"ioutil",
".",
"NopCloser",
"(",
"&",
"buffer",
")",
"\n",
"httpReq",
".",
"ContentLength",
"=",
"int64",
"(",
"buffer",
".",
"Len",
"(",
")",
")",
"\n",
"httpReq",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"req",
"\n",
"}"
] | // NewJsonRequest generates a new Request object and JSON encodes the provided
// obj. The JSON object will be set as the body and included in the request. | [
"NewJsonRequest",
"generates",
"a",
"new",
"Request",
"object",
"and",
"JSON",
"encodes",
"the",
"provided",
"obj",
".",
"The",
"JSON",
"object",
"will",
"be",
"set",
"as",
"the",
"body",
"and",
"included",
"in",
"the",
"request",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L214-L235 |
2,976 | apcera/util | restclient/restclient.go | NewFormRequest | func (c *Client) NewFormRequest(method Method, endpoint string, params map[string]string) *Request {
req := c.newRequest(method, endpoint)
// set how to generate the body
req.prepare = func(httpReq *http.Request) error {
form := url.Values{}
for k, v := range params {
form.Set(k, v)
}
encoded := form.Encode()
// set to the request
httpReq.Body = ioutil.NopCloser(bytes.NewReader([]byte(encoded)))
httpReq.ContentLength = int64(len(encoded))
httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
return nil
}
return req
} | go | func (c *Client) NewFormRequest(method Method, endpoint string, params map[string]string) *Request {
req := c.newRequest(method, endpoint)
// set how to generate the body
req.prepare = func(httpReq *http.Request) error {
form := url.Values{}
for k, v := range params {
form.Set(k, v)
}
encoded := form.Encode()
// set to the request
httpReq.Body = ioutil.NopCloser(bytes.NewReader([]byte(encoded)))
httpReq.ContentLength = int64(len(encoded))
httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
return nil
}
return req
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"NewFormRequest",
"(",
"method",
"Method",
",",
"endpoint",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"Request",
"{",
"req",
":=",
"c",
".",
"newRequest",
"(",
"method",
",",
"endpoint",
")",
"\n\n",
"// set how to generate the body",
"req",
".",
"prepare",
"=",
"func",
"(",
"httpReq",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"form",
":=",
"url",
".",
"Values",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"params",
"{",
"form",
".",
"Set",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"encoded",
":=",
"form",
".",
"Encode",
"(",
")",
"\n\n",
"// set to the request",
"httpReq",
".",
"Body",
"=",
"ioutil",
".",
"NopCloser",
"(",
"bytes",
".",
"NewReader",
"(",
"[",
"]",
"byte",
"(",
"encoded",
")",
")",
")",
"\n",
"httpReq",
".",
"ContentLength",
"=",
"int64",
"(",
"len",
"(",
"encoded",
")",
")",
"\n",
"httpReq",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"req",
"\n",
"}"
] | // NewFormRequest generates a new Request object with a form encoded body based
// on the params map. | [
"NewFormRequest",
"generates",
"a",
"new",
"Request",
"object",
"with",
"a",
"form",
"encoded",
"body",
"based",
"on",
"the",
"params",
"map",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/restclient/restclient.go#L239-L258 |
2,977 | apcera/util | hashutil/sha1util.go | NewSha1 | func NewSha1(r io.Reader) *Sha1Reader {
s := new(Sha1Reader)
s.hashReader = newHashReader(sha1.New(), r)
return s
} | go | func NewSha1(r io.Reader) *Sha1Reader {
s := new(Sha1Reader)
s.hashReader = newHashReader(sha1.New(), r)
return s
} | [
"func",
"NewSha1",
"(",
"r",
"io",
".",
"Reader",
")",
"*",
"Sha1Reader",
"{",
"s",
":=",
"new",
"(",
"Sha1Reader",
")",
"\n",
"s",
".",
"hashReader",
"=",
"newHashReader",
"(",
"sha1",
".",
"New",
"(",
")",
",",
"r",
")",
"\n",
"return",
"s",
"\n",
"}"
] | // Returns a new Sha1Reader. | [
"Returns",
"a",
"new",
"Sha1Reader",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/hashutil/sha1util.go#L34-L38 |
2,978 | apcera/util | hashutil/sha1util.go | Sha1 | func (s *Sha1Reader) Sha1() string {
return hex.EncodeToString(s.hash.Sum(nil))
} | go | func (s *Sha1Reader) Sha1() string {
return hex.EncodeToString(s.hash.Sum(nil))
} | [
"func",
"(",
"s",
"*",
"Sha1Reader",
")",
"Sha1",
"(",
")",
"string",
"{",
"return",
"hex",
".",
"EncodeToString",
"(",
"s",
".",
"hash",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"}"
] | // Returns the SHA1 for all data that has been passed through this Reader
// already. This should ideally be called after the Reader is Closed, but
// otherwise its safe to call any time. | [
"Returns",
"the",
"SHA1",
"for",
"all",
"data",
"that",
"has",
"been",
"passed",
"through",
"this",
"Reader",
"already",
".",
"This",
"should",
"ideally",
"be",
"called",
"after",
"the",
"Reader",
"is",
"Closed",
"but",
"otherwise",
"its",
"safe",
"to",
"call",
"any",
"time",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/hashutil/sha1util.go#L43-L45 |
2,979 | apcera/util | iprange/allocator.go | NewAllocator | func NewAllocator(ipr *IPRange) *IPRangeAllocator {
a := &IPRangeAllocator{
ipRange: ipr,
reserved: make(map[int64]bool),
startIsIPv4: bytes.Compare(ipr.Start.To16()[0:12], ipv6in4) == 0,
}
// calculate the size of the range
a.startBig = big.NewInt(0)
a.startBig.SetBytes(a.ipRange.Start)
endBig := big.NewInt(0)
endBig.SetBytes(a.ipRange.End)
sizeBig := endBig.Sub(endBig, a.startBig)
// 1 is added to the size because the end IP is inclusive
a.size = sizeBig.Int64() + 1
a.remaining = a.size
return a
} | go | func NewAllocator(ipr *IPRange) *IPRangeAllocator {
a := &IPRangeAllocator{
ipRange: ipr,
reserved: make(map[int64]bool),
startIsIPv4: bytes.Compare(ipr.Start.To16()[0:12], ipv6in4) == 0,
}
// calculate the size of the range
a.startBig = big.NewInt(0)
a.startBig.SetBytes(a.ipRange.Start)
endBig := big.NewInt(0)
endBig.SetBytes(a.ipRange.End)
sizeBig := endBig.Sub(endBig, a.startBig)
// 1 is added to the size because the end IP is inclusive
a.size = sizeBig.Int64() + 1
a.remaining = a.size
return a
} | [
"func",
"NewAllocator",
"(",
"ipr",
"*",
"IPRange",
")",
"*",
"IPRangeAllocator",
"{",
"a",
":=",
"&",
"IPRangeAllocator",
"{",
"ipRange",
":",
"ipr",
",",
"reserved",
":",
"make",
"(",
"map",
"[",
"int64",
"]",
"bool",
")",
",",
"startIsIPv4",
":",
"bytes",
".",
"Compare",
"(",
"ipr",
".",
"Start",
".",
"To16",
"(",
")",
"[",
"0",
":",
"12",
"]",
",",
"ipv6in4",
")",
"==",
"0",
",",
"}",
"\n\n",
"// calculate the size of the range",
"a",
".",
"startBig",
"=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"a",
".",
"startBig",
".",
"SetBytes",
"(",
"a",
".",
"ipRange",
".",
"Start",
")",
"\n",
"endBig",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"endBig",
".",
"SetBytes",
"(",
"a",
".",
"ipRange",
".",
"End",
")",
"\n",
"sizeBig",
":=",
"endBig",
".",
"Sub",
"(",
"endBig",
",",
"a",
".",
"startBig",
")",
"\n\n",
"// 1 is added to the size because the end IP is inclusive",
"a",
".",
"size",
"=",
"sizeBig",
".",
"Int64",
"(",
")",
"+",
"1",
"\n",
"a",
".",
"remaining",
"=",
"a",
".",
"size",
"\n\n",
"return",
"a",
"\n",
"}"
] | // NewAllocator creates a new IPRangeAllocator for the provided IPRange. | [
"NewAllocator",
"creates",
"a",
"new",
"IPRangeAllocator",
"for",
"the",
"provided",
"IPRange",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L29-L48 |
2,980 | apcera/util | iprange/allocator.go | Allocate | func (a *IPRangeAllocator) Allocate() net.IP {
a.mutex.Lock()
defer a.mutex.Unlock()
// ensure we have some IPs first
if a.remaining <= 0 {
return nil
}
// get a random number within the size to start with
idx := rand.Int63n(a.size)
// find the next available index after the random number that is available
idx = a.findNextAvailbleIndex(idx)
// if idx is now -1, then it couldn't find one, which is very unlikely,
// however if that is, treat it as no more remaining and ensure remaining is
// now 0
if idx == -1 {
a.remaining = 0
return nil
}
// reserve the idx, get the IP bytes
a.reserved[idx] = true
a.remaining--
newBig := big.NewInt(0).Add(a.startBig, big.NewInt(idx))
return a.bigIntToIP(newBig)
} | go | func (a *IPRangeAllocator) Allocate() net.IP {
a.mutex.Lock()
defer a.mutex.Unlock()
// ensure we have some IPs first
if a.remaining <= 0 {
return nil
}
// get a random number within the size to start with
idx := rand.Int63n(a.size)
// find the next available index after the random number that is available
idx = a.findNextAvailbleIndex(idx)
// if idx is now -1, then it couldn't find one, which is very unlikely,
// however if that is, treat it as no more remaining and ensure remaining is
// now 0
if idx == -1 {
a.remaining = 0
return nil
}
// reserve the idx, get the IP bytes
a.reserved[idx] = true
a.remaining--
newBig := big.NewInt(0).Add(a.startBig, big.NewInt(idx))
return a.bigIntToIP(newBig)
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"Allocate",
"(",
")",
"net",
".",
"IP",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// ensure we have some IPs first",
"if",
"a",
".",
"remaining",
"<=",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// get a random number within the size to start with",
"idx",
":=",
"rand",
".",
"Int63n",
"(",
"a",
".",
"size",
")",
"\n\n",
"// find the next available index after the random number that is available",
"idx",
"=",
"a",
".",
"findNextAvailbleIndex",
"(",
"idx",
")",
"\n\n",
"// if idx is now -1, then it couldn't find one, which is very unlikely,",
"// however if that is, treat it as no more remaining and ensure remaining is",
"// now 0",
"if",
"idx",
"==",
"-",
"1",
"{",
"a",
".",
"remaining",
"=",
"0",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// reserve the idx, get the IP bytes",
"a",
".",
"reserved",
"[",
"idx",
"]",
"=",
"true",
"\n",
"a",
".",
"remaining",
"--",
"\n",
"newBig",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Add",
"(",
"a",
".",
"startBig",
",",
"big",
".",
"NewInt",
"(",
"idx",
")",
")",
"\n\n",
"return",
"a",
".",
"bigIntToIP",
"(",
"newBig",
")",
"\n",
"}"
] | // Allocate can be used to allocate a new IP address within the provided
// range. It will ensure that it is unique. If the allocator has no additional
// IP addresses available, then it will return nil. | [
"Allocate",
"can",
"be",
"used",
"to",
"allocate",
"a",
"new",
"IP",
"address",
"within",
"the",
"provided",
"range",
".",
"It",
"will",
"ensure",
"that",
"it",
"is",
"unique",
".",
"If",
"the",
"allocator",
"has",
"no",
"additional",
"IP",
"addresses",
"available",
"then",
"it",
"will",
"return",
"nil",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L53-L82 |
2,981 | apcera/util | iprange/allocator.go | Reserve | func (a *IPRangeAllocator) Reserve(ip net.IP) {
a.mutex.Lock()
defer a.mutex.Unlock()
// ensure the specified IP is within the range
if !a.ipRange.Contains(ip) {
return
}
// calculate the idx from the start
ipBig := big.NewInt(0)
ipBig.SetBytes(ip)
idx := ipBig.Sub(ipBig, a.startBig).Int64()
// if it isn't already reserved, then mark it reserved and decrement the
// remaining count
if !a.reserved[idx] {
a.reserved[idx] = true
a.remaining--
}
} | go | func (a *IPRangeAllocator) Reserve(ip net.IP) {
a.mutex.Lock()
defer a.mutex.Unlock()
// ensure the specified IP is within the range
if !a.ipRange.Contains(ip) {
return
}
// calculate the idx from the start
ipBig := big.NewInt(0)
ipBig.SetBytes(ip)
idx := ipBig.Sub(ipBig, a.startBig).Int64()
// if it isn't already reserved, then mark it reserved and decrement the
// remaining count
if !a.reserved[idx] {
a.reserved[idx] = true
a.remaining--
}
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"Reserve",
"(",
"ip",
"net",
".",
"IP",
")",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// ensure the specified IP is within the range",
"if",
"!",
"a",
".",
"ipRange",
".",
"Contains",
"(",
"ip",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"// calculate the idx from the start",
"ipBig",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"ipBig",
".",
"SetBytes",
"(",
"ip",
")",
"\n",
"idx",
":=",
"ipBig",
".",
"Sub",
"(",
"ipBig",
",",
"a",
".",
"startBig",
")",
".",
"Int64",
"(",
")",
"\n\n",
"// if it isn't already reserved, then mark it reserved and decrement the",
"// remaining count",
"if",
"!",
"a",
".",
"reserved",
"[",
"idx",
"]",
"{",
"a",
".",
"reserved",
"[",
"idx",
"]",
"=",
"true",
"\n",
"a",
".",
"remaining",
"--",
"\n",
"}",
"\n",
"}"
] | // Reserve allows reserving a specific IP address within the specified range to
// ensure it is not allocated. | [
"Reserve",
"allows",
"reserving",
"a",
"specific",
"IP",
"address",
"within",
"the",
"specified",
"range",
"to",
"ensure",
"it",
"is",
"not",
"allocated",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L86-L106 |
2,982 | apcera/util | iprange/allocator.go | Release | func (a *IPRangeAllocator) Release(ip net.IP) {
a.mutex.Lock()
defer a.mutex.Unlock()
// calculate the idx from the start
ipBig := big.NewInt(0)
ipBig.SetBytes(ip)
idx := ipBig.Sub(ipBig, a.startBig).Int64()
// check if the idx is reserved
if a.reserved[idx] {
delete(a.reserved, idx)
a.remaining++
}
} | go | func (a *IPRangeAllocator) Release(ip net.IP) {
a.mutex.Lock()
defer a.mutex.Unlock()
// calculate the idx from the start
ipBig := big.NewInt(0)
ipBig.SetBytes(ip)
idx := ipBig.Sub(ipBig, a.startBig).Int64()
// check if the idx is reserved
if a.reserved[idx] {
delete(a.reserved, idx)
a.remaining++
}
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"Release",
"(",
"ip",
"net",
".",
"IP",
")",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// calculate the idx from the start",
"ipBig",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"ipBig",
".",
"SetBytes",
"(",
"ip",
")",
"\n",
"idx",
":=",
"ipBig",
".",
"Sub",
"(",
"ipBig",
",",
"a",
".",
"startBig",
")",
".",
"Int64",
"(",
")",
"\n\n",
"// check if the idx is reserved",
"if",
"a",
".",
"reserved",
"[",
"idx",
"]",
"{",
"delete",
"(",
"a",
".",
"reserved",
",",
"idx",
")",
"\n",
"a",
".",
"remaining",
"++",
"\n",
"}",
"\n",
"}"
] | // Release can be used to release an IP address that had previously been
// allocated or reserved. | [
"Release",
"can",
"be",
"used",
"to",
"release",
"an",
"IP",
"address",
"that",
"had",
"previously",
"been",
"allocated",
"or",
"reserved",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L110-L124 |
2,983 | apcera/util | iprange/allocator.go | Subtract | func (a *IPRangeAllocator) Subtract(iprange *IPRange) {
curBig := big.NewInt(0)
curBig.SetBytes(iprange.Start)
endBig := big.NewInt(0)
endBig.SetBytes(iprange.End)
for ; curBig.Cmp(endBig) < 1; curBig = curBig.Add(big.NewInt(1), curBig) {
ip := a.bigIntToIP(curBig)
if a.ipRange.Contains(ip) {
a.Reserve(ip)
}
}
} | go | func (a *IPRangeAllocator) Subtract(iprange *IPRange) {
curBig := big.NewInt(0)
curBig.SetBytes(iprange.Start)
endBig := big.NewInt(0)
endBig.SetBytes(iprange.End)
for ; curBig.Cmp(endBig) < 1; curBig = curBig.Add(big.NewInt(1), curBig) {
ip := a.bigIntToIP(curBig)
if a.ipRange.Contains(ip) {
a.Reserve(ip)
}
}
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"Subtract",
"(",
"iprange",
"*",
"IPRange",
")",
"{",
"curBig",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"curBig",
".",
"SetBytes",
"(",
"iprange",
".",
"Start",
")",
"\n",
"endBig",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"endBig",
".",
"SetBytes",
"(",
"iprange",
".",
"End",
")",
"\n\n",
"for",
";",
"curBig",
".",
"Cmp",
"(",
"endBig",
")",
"<",
"1",
";",
"curBig",
"=",
"curBig",
".",
"Add",
"(",
"big",
".",
"NewInt",
"(",
"1",
")",
",",
"curBig",
")",
"{",
"ip",
":=",
"a",
".",
"bigIntToIP",
"(",
"curBig",
")",
"\n",
"if",
"a",
".",
"ipRange",
".",
"Contains",
"(",
"ip",
")",
"{",
"a",
".",
"Reserve",
"(",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Subtract marks all of the IPs from another IPRange as reserved in the current
// allocator. | [
"Subtract",
"marks",
"all",
"of",
"the",
"IPs",
"from",
"another",
"IPRange",
"as",
"reserved",
"in",
"the",
"current",
"allocator",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L128-L140 |
2,984 | apcera/util | iprange/allocator.go | IPRange | func (a *IPRangeAllocator) IPRange() *IPRange {
a.mutex.Lock()
defer a.mutex.Unlock()
return &IPRange{
Start: a.ipRange.Start,
End: a.ipRange.End,
Mask: a.ipRange.Mask,
}
} | go | func (a *IPRangeAllocator) IPRange() *IPRange {
a.mutex.Lock()
defer a.mutex.Unlock()
return &IPRange{
Start: a.ipRange.Start,
End: a.ipRange.End,
Mask: a.ipRange.Mask,
}
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"IPRange",
"(",
")",
"*",
"IPRange",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"&",
"IPRange",
"{",
"Start",
":",
"a",
".",
"ipRange",
".",
"Start",
",",
"End",
":",
"a",
".",
"ipRange",
".",
"End",
",",
"Mask",
":",
"a",
".",
"ipRange",
".",
"Mask",
",",
"}",
"\n",
"}"
] | // IPRange returns a copy of the IPRange provided to the allocator. | [
"IPRange",
"returns",
"a",
"copy",
"of",
"the",
"IPRange",
"provided",
"to",
"the",
"allocator",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L143-L152 |
2,985 | apcera/util | iprange/allocator.go | Size | func (a *IPRangeAllocator) Size() int64 {
a.mutex.Lock()
defer a.mutex.Unlock()
return a.size
} | go | func (a *IPRangeAllocator) Size() int64 {
a.mutex.Lock()
defer a.mutex.Unlock()
return a.size
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"Size",
"(",
")",
"int64",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"a",
".",
"size",
"\n",
"}"
] | // Size returns the size of the allowable IP addresses specified by the range. | [
"Size",
"returns",
"the",
"size",
"of",
"the",
"allowable",
"IP",
"addresses",
"specified",
"by",
"the",
"range",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L155-L159 |
2,986 | apcera/util | iprange/allocator.go | Remaining | func (a *IPRangeAllocator) Remaining() int64 {
a.mutex.Lock()
defer a.mutex.Unlock()
return a.remaining
} | go | func (a *IPRangeAllocator) Remaining() int64 {
a.mutex.Lock()
defer a.mutex.Unlock()
return a.remaining
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"Remaining",
"(",
")",
"int64",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"a",
".",
"remaining",
"\n",
"}"
] | // Remaining returns the number of remaining IP addresses within the provided
// range that have not been already allocated. | [
"Remaining",
"returns",
"the",
"number",
"of",
"remaining",
"IP",
"addresses",
"within",
"the",
"provided",
"range",
"that",
"have",
"not",
"been",
"already",
"allocated",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L163-L167 |
2,987 | apcera/util | iprange/allocator.go | findNextAvailbleIndex | func (a *IPRangeAllocator) findNextAvailbleIndex(idx int64) int64 {
// walk up from the index
for i := idx; i < a.size; i++ {
if !a.reserved[i] {
return i
}
}
// nothing above that one... lets try to walk down to find something
for i := idx - 1; i >= 0; i-- {
if !a.reserved[i] {
return i
}
}
// ok, everything is probably taken
return -1
} | go | func (a *IPRangeAllocator) findNextAvailbleIndex(idx int64) int64 {
// walk up from the index
for i := idx; i < a.size; i++ {
if !a.reserved[i] {
return i
}
}
// nothing above that one... lets try to walk down to find something
for i := idx - 1; i >= 0; i-- {
if !a.reserved[i] {
return i
}
}
// ok, everything is probably taken
return -1
} | [
"func",
"(",
"a",
"*",
"IPRangeAllocator",
")",
"findNextAvailbleIndex",
"(",
"idx",
"int64",
")",
"int64",
"{",
"// walk up from the index",
"for",
"i",
":=",
"idx",
";",
"i",
"<",
"a",
".",
"size",
";",
"i",
"++",
"{",
"if",
"!",
"a",
".",
"reserved",
"[",
"i",
"]",
"{",
"return",
"i",
"\n",
"}",
"\n",
"}",
"\n\n",
"// nothing above that one... lets try to walk down to find something",
"for",
"i",
":=",
"idx",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"if",
"!",
"a",
".",
"reserved",
"[",
"i",
"]",
"{",
"return",
"i",
"\n",
"}",
"\n",
"}",
"\n\n",
"// ok, everything is probably taken",
"return",
"-",
"1",
"\n",
"}"
] | // findNextAvailableIndex finds the value of idx which is available and not in
// the reserved list. | [
"findNextAvailableIndex",
"finds",
"the",
"value",
"of",
"idx",
"which",
"is",
"available",
"and",
"not",
"in",
"the",
"reserved",
"list",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/iprange/allocator.go#L171-L188 |
2,988 | apcera/util | terminal/terminal_state_unix.go | Isatty | func Isatty(fd uintptr) bool {
var termios syscall.Termios
_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd,
uintptr(syscallGetTermios), uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
return err == 0
} | go | func Isatty(fd uintptr) bool {
var termios syscall.Termios
_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd,
uintptr(syscallGetTermios), uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
return err == 0
} | [
"func",
"Isatty",
"(",
"fd",
"uintptr",
")",
"bool",
"{",
"var",
"termios",
"syscall",
".",
"Termios",
"\n\n",
"_",
",",
"_",
",",
"err",
":=",
"syscall",
".",
"Syscall6",
"(",
"syscall",
".",
"SYS_IOCTL",
",",
"fd",
",",
"uintptr",
"(",
"syscallGetTermios",
")",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"termios",
")",
")",
",",
"0",
",",
"0",
",",
"0",
")",
"\n\n",
"return",
"err",
"==",
"0",
"\n",
"}"
] | // isatty checks whether FD is a tty. Doesn't work on Windows. | [
"isatty",
"checks",
"whether",
"FD",
"is",
"a",
"tty",
".",
"Doesn",
"t",
"work",
"on",
"Windows",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/terminal/terminal_state_unix.go#L20-L27 |
2,989 | apcera/util | proc/parser.go | ReadInt64 | func ReadInt64(file string) (int64, error) {
f, err := os.Open(file)
if err != nil {
return 0, err
}
defer f.Close()
buf := make([]byte, 19)
n, err := f.Read(buf)
if err != nil {
return 0, err
}
p := strings.Split(string(buf[0:n]), "\n")
v, err := strconv.ParseInt(p[0], 10, 64)
if err != nil {
return 0, err
}
return v, nil
} | go | func ReadInt64(file string) (int64, error) {
f, err := os.Open(file)
if err != nil {
return 0, err
}
defer f.Close()
buf := make([]byte, 19)
n, err := f.Read(buf)
if err != nil {
return 0, err
}
p := strings.Split(string(buf[0:n]), "\n")
v, err := strconv.ParseInt(p[0], 10, 64)
if err != nil {
return 0, err
}
return v, nil
} | [
"func",
"ReadInt64",
"(",
"file",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"19",
")",
"\n",
"n",
",",
"err",
":=",
"f",
".",
"Read",
"(",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"p",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"buf",
"[",
"0",
":",
"n",
"]",
")",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"v",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"p",
"[",
"0",
"]",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"v",
",",
"nil",
"\n",
"}"
] | // ReadInt64 reads one int64 number from the first line of a file. | [
"ReadInt64",
"reads",
"one",
"int64",
"number",
"from",
"the",
"first",
"line",
"of",
"a",
"file",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/proc/parser.go#L13-L33 |
2,990 | apcera/util | proc/parser.go | ParseSimpleProcFile | func ParseSimpleProcFile(
filename string,
lf func(index int, line string) error,
ef func(line, index int, elm string) error) error {
fd, err := os.Open(filename)
if err != nil {
return err
}
defer fd.Close()
contentsBytes, err := ioutil.ReadAll(fd)
if err != nil {
return err
}
// Setup base handlers if they were passed in as nil.
if lf == nil {
lf = func(index int, line string) error { return nil }
}
if ef == nil {
ef = func(line, index int, elm string) error { return nil }
}
contents := string(contentsBytes)
lines := strings.Split(contents, "\n")
for li, l := range lines {
for ei, e := range strings.Fields(l) {
if err := ef(li, ei, e); err != nil {
return err
}
}
if err := lf(li, l); err != nil {
return err
}
}
return nil
} | go | func ParseSimpleProcFile(
filename string,
lf func(index int, line string) error,
ef func(line, index int, elm string) error) error {
fd, err := os.Open(filename)
if err != nil {
return err
}
defer fd.Close()
contentsBytes, err := ioutil.ReadAll(fd)
if err != nil {
return err
}
// Setup base handlers if they were passed in as nil.
if lf == nil {
lf = func(index int, line string) error { return nil }
}
if ef == nil {
ef = func(line, index int, elm string) error { return nil }
}
contents := string(contentsBytes)
lines := strings.Split(contents, "\n")
for li, l := range lines {
for ei, e := range strings.Fields(l) {
if err := ef(li, ei, e); err != nil {
return err
}
}
if err := lf(li, l); err != nil {
return err
}
}
return nil
} | [
"func",
"ParseSimpleProcFile",
"(",
"filename",
"string",
",",
"lf",
"func",
"(",
"index",
"int",
",",
"line",
"string",
")",
"error",
",",
"ef",
"func",
"(",
"line",
",",
"index",
"int",
",",
"elm",
"string",
")",
"error",
")",
"error",
"{",
"fd",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"fd",
".",
"Close",
"(",
")",
"\n\n",
"contentsBytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"fd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Setup base handlers if they were passed in as nil.",
"if",
"lf",
"==",
"nil",
"{",
"lf",
"=",
"func",
"(",
"index",
"int",
",",
"line",
"string",
")",
"error",
"{",
"return",
"nil",
"}",
"\n",
"}",
"\n",
"if",
"ef",
"==",
"nil",
"{",
"ef",
"=",
"func",
"(",
"line",
",",
"index",
"int",
",",
"elm",
"string",
")",
"error",
"{",
"return",
"nil",
"}",
"\n",
"}",
"\n\n",
"contents",
":=",
"string",
"(",
"contentsBytes",
")",
"\n",
"lines",
":=",
"strings",
".",
"Split",
"(",
"contents",
",",
"\"",
"\\n",
"\"",
")",
"\n\n",
"for",
"li",
",",
"l",
":=",
"range",
"lines",
"{",
"for",
"ei",
",",
"e",
":=",
"range",
"strings",
".",
"Fields",
"(",
"l",
")",
"{",
"if",
"err",
":=",
"ef",
"(",
"li",
",",
"ei",
",",
"e",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"lf",
"(",
"li",
",",
"l",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Parses the given file into various elements. This function assumes basic
// white space semantics (' ' and '\t' for column splitting, and '\n' for
// row splitting. | [
"Parses",
"the",
"given",
"file",
"into",
"various",
"elements",
".",
"This",
"function",
"assumes",
"basic",
"white",
"space",
"semantics",
"(",
"and",
"\\",
"t",
"for",
"column",
"splitting",
"and",
"\\",
"n",
"for",
"row",
"splitting",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/proc/parser.go#L38-L77 |
2,991 | apcera/util | timeoutwg/timeoutwg.go | Add | func (twg *TimeoutWaitGroup) Add(delta int) {
twg.mutex.Lock()
defer twg.mutex.Unlock()
if twg.workers == 0 {
// waitgroups are reusable once workers is 0
twg.last = nil
} else if twg.workers > 0 && twg.last != nil {
// This mimics normal WG behavior. Cannot add after Wait() has been
// called, unless workers is 0. Prevents races on Wait()
panic("TimeoutWaitGroup misuse: Add called concurrently with Wait")
}
twg.workers += delta
} | go | func (twg *TimeoutWaitGroup) Add(delta int) {
twg.mutex.Lock()
defer twg.mutex.Unlock()
if twg.workers == 0 {
// waitgroups are reusable once workers is 0
twg.last = nil
} else if twg.workers > 0 && twg.last != nil {
// This mimics normal WG behavior. Cannot add after Wait() has been
// called, unless workers is 0. Prevents races on Wait()
panic("TimeoutWaitGroup misuse: Add called concurrently with Wait")
}
twg.workers += delta
} | [
"func",
"(",
"twg",
"*",
"TimeoutWaitGroup",
")",
"Add",
"(",
"delta",
"int",
")",
"{",
"twg",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"twg",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"twg",
".",
"workers",
"==",
"0",
"{",
"// waitgroups are reusable once workers is 0",
"twg",
".",
"last",
"=",
"nil",
"\n",
"}",
"else",
"if",
"twg",
".",
"workers",
">",
"0",
"&&",
"twg",
".",
"last",
"!=",
"nil",
"{",
"// This mimics normal WG behavior. Cannot add after Wait() has been",
"// called, unless workers is 0. Prevents races on Wait()",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"twg",
".",
"workers",
"+=",
"delta",
"\n",
"}"
] | // Add increments the wait group's count of active workers by delta. | [
"Add",
"increments",
"the",
"wait",
"group",
"s",
"count",
"of",
"active",
"workers",
"by",
"delta",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/timeoutwg/timeoutwg.go#L21-L33 |
2,992 | apcera/util | timeoutwg/timeoutwg.go | Done | func (twg *TimeoutWaitGroup) Done() {
twg.mutex.Lock()
defer twg.mutex.Unlock()
twg.workers--
if twg.workers < 0 {
panic("TimeoutWaitGroup: negative counter")
}
if twg.workers == 0 && twg.last != nil {
close(twg.last)
}
} | go | func (twg *TimeoutWaitGroup) Done() {
twg.mutex.Lock()
defer twg.mutex.Unlock()
twg.workers--
if twg.workers < 0 {
panic("TimeoutWaitGroup: negative counter")
}
if twg.workers == 0 && twg.last != nil {
close(twg.last)
}
} | [
"func",
"(",
"twg",
"*",
"TimeoutWaitGroup",
")",
"Done",
"(",
")",
"{",
"twg",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"twg",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"twg",
".",
"workers",
"--",
"\n",
"if",
"twg",
".",
"workers",
"<",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"twg",
".",
"workers",
"==",
"0",
"&&",
"twg",
".",
"last",
"!=",
"nil",
"{",
"close",
"(",
"twg",
".",
"last",
")",
"\n",
"}",
"\n",
"}"
] | // Done decrements the wait group count by one. | [
"Done",
"decrements",
"the",
"wait",
"group",
"count",
"by",
"one",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/timeoutwg/timeoutwg.go#L36-L46 |
2,993 | apcera/util | proc/proc.go | InterfaceStats | func InterfaceStats() (map[string]InterfaceStat, error) {
ret := make(map[string]InterfaceStat, 0)
var current InterfaceStat
lastline := -1
lastindex := -1
lf := func(index int, line string) error {
if lastline == index && lastindex == 16 {
ret[current.Device] = current
}
current = InterfaceStat{}
return nil
}
el := func(line int, index int, elm string) (err error) {
switch index {
case 0:
current.Device = strings.Split(elm, ":")[0]
case 1:
current.RxBytes, err = strconv.ParseUint(elm, 10, 64)
case 2:
current.RxPackets, err = strconv.ParseUint(elm, 10, 64)
case 3:
current.RxErrors, err = strconv.ParseUint(elm, 10, 64)
case 4:
current.RxDrop, err = strconv.ParseUint(elm, 10, 64)
case 5:
current.RxFifo, err = strconv.ParseUint(elm, 10, 64)
case 6:
current.RxFrame, err = strconv.ParseUint(elm, 10, 64)
case 7:
current.RxCompressed, err = strconv.ParseUint(elm, 10, 64)
case 8:
current.RxMulticast, err = strconv.ParseUint(elm, 10, 64)
case 9:
current.TxBytes, err = strconv.ParseUint(elm, 10, 64)
case 10:
current.TxPackets, err = strconv.ParseUint(elm, 10, 64)
case 11:
current.TxErrors, err = strconv.ParseUint(elm, 10, 64)
case 12:
current.TxDrop, err = strconv.ParseUint(elm, 10, 64)
case 13:
current.TxFifo, err = strconv.ParseUint(elm, 10, 64)
case 14:
current.TxFrame, err = strconv.ParseUint(elm, 10, 64)
case 15:
current.TxCompressed, err = strconv.ParseUint(elm, 10, 64)
case 16:
current.TxMulticast, err = strconv.ParseUint(elm, 10, 64)
}
lastline = line
lastindex = index
return
}
// Now actually attempt to parse the config
if err := ParseSimpleProcFile(DeviceStatsFile, lf, el); err != nil {
return nil, err
}
return ret, nil
} | go | func InterfaceStats() (map[string]InterfaceStat, error) {
ret := make(map[string]InterfaceStat, 0)
var current InterfaceStat
lastline := -1
lastindex := -1
lf := func(index int, line string) error {
if lastline == index && lastindex == 16 {
ret[current.Device] = current
}
current = InterfaceStat{}
return nil
}
el := func(line int, index int, elm string) (err error) {
switch index {
case 0:
current.Device = strings.Split(elm, ":")[0]
case 1:
current.RxBytes, err = strconv.ParseUint(elm, 10, 64)
case 2:
current.RxPackets, err = strconv.ParseUint(elm, 10, 64)
case 3:
current.RxErrors, err = strconv.ParseUint(elm, 10, 64)
case 4:
current.RxDrop, err = strconv.ParseUint(elm, 10, 64)
case 5:
current.RxFifo, err = strconv.ParseUint(elm, 10, 64)
case 6:
current.RxFrame, err = strconv.ParseUint(elm, 10, 64)
case 7:
current.RxCompressed, err = strconv.ParseUint(elm, 10, 64)
case 8:
current.RxMulticast, err = strconv.ParseUint(elm, 10, 64)
case 9:
current.TxBytes, err = strconv.ParseUint(elm, 10, 64)
case 10:
current.TxPackets, err = strconv.ParseUint(elm, 10, 64)
case 11:
current.TxErrors, err = strconv.ParseUint(elm, 10, 64)
case 12:
current.TxDrop, err = strconv.ParseUint(elm, 10, 64)
case 13:
current.TxFifo, err = strconv.ParseUint(elm, 10, 64)
case 14:
current.TxFrame, err = strconv.ParseUint(elm, 10, 64)
case 15:
current.TxCompressed, err = strconv.ParseUint(elm, 10, 64)
case 16:
current.TxMulticast, err = strconv.ParseUint(elm, 10, 64)
}
lastline = line
lastindex = index
return
}
// Now actually attempt to parse the config
if err := ParseSimpleProcFile(DeviceStatsFile, lf, el); err != nil {
return nil, err
}
return ret, nil
} | [
"func",
"InterfaceStats",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"InterfaceStat",
",",
"error",
")",
"{",
"ret",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"InterfaceStat",
",",
"0",
")",
"\n",
"var",
"current",
"InterfaceStat",
"\n",
"lastline",
":=",
"-",
"1",
"\n",
"lastindex",
":=",
"-",
"1",
"\n\n",
"lf",
":=",
"func",
"(",
"index",
"int",
",",
"line",
"string",
")",
"error",
"{",
"if",
"lastline",
"==",
"index",
"&&",
"lastindex",
"==",
"16",
"{",
"ret",
"[",
"current",
".",
"Device",
"]",
"=",
"current",
"\n",
"}",
"\n",
"current",
"=",
"InterfaceStat",
"{",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"el",
":=",
"func",
"(",
"line",
"int",
",",
"index",
"int",
",",
"elm",
"string",
")",
"(",
"err",
"error",
")",
"{",
"switch",
"index",
"{",
"case",
"0",
":",
"current",
".",
"Device",
"=",
"strings",
".",
"Split",
"(",
"elm",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"case",
"1",
":",
"current",
".",
"RxBytes",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"2",
":",
"current",
".",
"RxPackets",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"3",
":",
"current",
".",
"RxErrors",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"4",
":",
"current",
".",
"RxDrop",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"5",
":",
"current",
".",
"RxFifo",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"6",
":",
"current",
".",
"RxFrame",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"7",
":",
"current",
".",
"RxCompressed",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"8",
":",
"current",
".",
"RxMulticast",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"9",
":",
"current",
".",
"TxBytes",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"10",
":",
"current",
".",
"TxPackets",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"11",
":",
"current",
".",
"TxErrors",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"12",
":",
"current",
".",
"TxDrop",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"13",
":",
"current",
".",
"TxFifo",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"14",
":",
"current",
".",
"TxFrame",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"15",
":",
"current",
".",
"TxCompressed",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"case",
"16",
":",
"current",
".",
"TxMulticast",
",",
"err",
"=",
"strconv",
".",
"ParseUint",
"(",
"elm",
",",
"10",
",",
"64",
")",
"\n",
"}",
"\n",
"lastline",
"=",
"line",
"\n",
"lastindex",
"=",
"index",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Now actually attempt to parse the config",
"if",
"err",
":=",
"ParseSimpleProcFile",
"(",
"DeviceStatsFile",
",",
"lf",
",",
"el",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"ret",
",",
"nil",
"\n",
"}"
] | // Returns the interface statistics as a map keyed off the interface name. | [
"Returns",
"the",
"interface",
"statistics",
"as",
"a",
"map",
"keyed",
"off",
"the",
"interface",
"name",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/proc/proc.go#L103-L164 |
2,994 | apcera/util | s3util/s3util.go | NewS3Uploader | func NewS3Uploader(bucket, permission string, quiet bool) (*S3Uploader, error) {
u := &url.URL{
Scheme: scheme,
Host: fmt.Sprintf("%s.%s", bucket, S3_URL),
}
permission = strings.ToLower(permission)
if err := validatePermission(permission); err != nil {
return nil, err
}
uploader := &S3Uploader{
s3url: u,
bucketName: bucket,
permission: permission,
out: os.Stdout,
}
if quiet {
uploader.out = ioutil.Discard
}
return uploader, nil
} | go | func NewS3Uploader(bucket, permission string, quiet bool) (*S3Uploader, error) {
u := &url.URL{
Scheme: scheme,
Host: fmt.Sprintf("%s.%s", bucket, S3_URL),
}
permission = strings.ToLower(permission)
if err := validatePermission(permission); err != nil {
return nil, err
}
uploader := &S3Uploader{
s3url: u,
bucketName: bucket,
permission: permission,
out: os.Stdout,
}
if quiet {
uploader.out = ioutil.Discard
}
return uploader, nil
} | [
"func",
"NewS3Uploader",
"(",
"bucket",
",",
"permission",
"string",
",",
"quiet",
"bool",
")",
"(",
"*",
"S3Uploader",
",",
"error",
")",
"{",
"u",
":=",
"&",
"url",
".",
"URL",
"{",
"Scheme",
":",
"scheme",
",",
"Host",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"bucket",
",",
"S3_URL",
")",
",",
"}",
"\n\n",
"permission",
"=",
"strings",
".",
"ToLower",
"(",
"permission",
")",
"\n",
"if",
"err",
":=",
"validatePermission",
"(",
"permission",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"uploader",
":=",
"&",
"S3Uploader",
"{",
"s3url",
":",
"u",
",",
"bucketName",
":",
"bucket",
",",
"permission",
":",
"permission",
",",
"out",
":",
"os",
".",
"Stdout",
",",
"}",
"\n",
"if",
"quiet",
"{",
"uploader",
".",
"out",
"=",
"ioutil",
".",
"Discard",
"\n",
"}",
"\n",
"return",
"uploader",
",",
"nil",
"\n",
"}"
] | // NewS3Uploader configures a new S3 uploader from a uri. | [
"NewS3Uploader",
"configures",
"a",
"new",
"S3",
"uploader",
"from",
"a",
"uri",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/s3util/s3util.go#L46-L67 |
2,995 | apcera/util | s3util/s3util.go | UploadToS3 | func (s *S3Uploader) UploadToS3(fPath string, buf *bytes.Buffer) error {
fmt.Fprintf(s.out, "Preparing %q for upload to s3 bucket %q...", filepath.Base(fPath), s.s3url.String())
req, err := s.buildS3Request(filepath.Base(fPath), buf)
if err != nil {
fmt.Fprintln(s.out, " error")
return err
}
fmt.Fprintln(s.out, " done")
fmt.Fprint(s.out, "Uploading...")
resp, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Fprintln(s.out, " error")
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
fmt.Fprintln(s.out, " error")
if resp.StatusCode == 403 {
fmt.Fprintln(s.out, "Encountered authorization error! Are your keys set correctly?")
}
errMsg := fmt.Sprintf("received code %d, should have received %d", resp.StatusCode, http.StatusOK)
b, err := ioutil.ReadAll(resp.Body)
if err == nil {
errMsg = fmt.Sprintf("%s\n\nReceived S3 Response: %q", errMsg, string(b))
}
return fmt.Errorf(errMsg)
}
fmt.Fprintln(s.out, " done")
return nil
} | go | func (s *S3Uploader) UploadToS3(fPath string, buf *bytes.Buffer) error {
fmt.Fprintf(s.out, "Preparing %q for upload to s3 bucket %q...", filepath.Base(fPath), s.s3url.String())
req, err := s.buildS3Request(filepath.Base(fPath), buf)
if err != nil {
fmt.Fprintln(s.out, " error")
return err
}
fmt.Fprintln(s.out, " done")
fmt.Fprint(s.out, "Uploading...")
resp, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Fprintln(s.out, " error")
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
fmt.Fprintln(s.out, " error")
if resp.StatusCode == 403 {
fmt.Fprintln(s.out, "Encountered authorization error! Are your keys set correctly?")
}
errMsg := fmt.Sprintf("received code %d, should have received %d", resp.StatusCode, http.StatusOK)
b, err := ioutil.ReadAll(resp.Body)
if err == nil {
errMsg = fmt.Sprintf("%s\n\nReceived S3 Response: %q", errMsg, string(b))
}
return fmt.Errorf(errMsg)
}
fmt.Fprintln(s.out, " done")
return nil
} | [
"func",
"(",
"s",
"*",
"S3Uploader",
")",
"UploadToS3",
"(",
"fPath",
"string",
",",
"buf",
"*",
"bytes",
".",
"Buffer",
")",
"error",
"{",
"fmt",
".",
"Fprintf",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
",",
"filepath",
".",
"Base",
"(",
"fPath",
")",
",",
"s",
".",
"s3url",
".",
"String",
"(",
")",
")",
"\n\n",
"req",
",",
"err",
":=",
"s",
".",
"buildS3Request",
"(",
"filepath",
".",
"Base",
"(",
"fPath",
")",
",",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n\n",
"fmt",
".",
"Fprint",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n",
"resp",
",",
"err",
":=",
"http",
".",
"DefaultClient",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"fmt",
".",
"Fprintln",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"==",
"403",
"{",
"fmt",
".",
"Fprintln",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"errMsg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
",",
"http",
".",
"StatusOK",
")",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"errMsg",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"errMsg",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"errMsg",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"s",
".",
"out",
",",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UploadToS3 prepares a buffer for upload to S3. | [
"UploadToS3",
"prepares",
"a",
"buffer",
"for",
"upload",
"to",
"S3",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/s3util/s3util.go#L90-L122 |
2,996 | apcera/util | s3util/s3util.go | buildS3Request | func (s *S3Uploader) buildS3Request(fileBase string, buffer *bytes.Buffer) (*http.Request, error) {
u := &url.URL{
Scheme: s.s3url.Scheme,
Host: s.s3url.Host,
Path: fileBase,
}
// This is a PUT request containing the data buffer.
req, err := http.NewRequest("PUT", u.String(), buffer)
if err != nil {
return nil, err
}
// FIXME: Send 'Connection: close' header on HTTP requests
// as reusing the connection is still prone to EOF/Connection reset errors
// in certain network environments...
// See: ENGT-9670
// https://stackoverflow.com/questions/17714494/golang-http-request-results-in-eof-errors
req.Close = true
// Generate MD5 to ensure reliable delivery
h := md5.New()
if _, err := h.Write(buffer.Bytes()); err != nil {
return nil, err
}
md5 := base64.StdEncoding.EncodeToString(h.Sum(nil))
// Get current time in UTC format for Date header.
curTime := time.Now().UTC().Format(time.RFC1123)
req.Header.Add("Date", curTime)
req.Header.Add("Content-Md5", md5)
req.Header.Add("Content-Type", "application/x-gzip")
req.Header.Add("X-Amz-Acl", s.permission)
authHeader, err := s.buildAuthHeader(md5, curTime, fileBase)
if err != nil {
return nil, err
}
req.Header.Add("Authorization", authHeader)
// Set content length so we avoid chunked requests.
req.ContentLength = int64(buffer.Len())
return req, nil
} | go | func (s *S3Uploader) buildS3Request(fileBase string, buffer *bytes.Buffer) (*http.Request, error) {
u := &url.URL{
Scheme: s.s3url.Scheme,
Host: s.s3url.Host,
Path: fileBase,
}
// This is a PUT request containing the data buffer.
req, err := http.NewRequest("PUT", u.String(), buffer)
if err != nil {
return nil, err
}
// FIXME: Send 'Connection: close' header on HTTP requests
// as reusing the connection is still prone to EOF/Connection reset errors
// in certain network environments...
// See: ENGT-9670
// https://stackoverflow.com/questions/17714494/golang-http-request-results-in-eof-errors
req.Close = true
// Generate MD5 to ensure reliable delivery
h := md5.New()
if _, err := h.Write(buffer.Bytes()); err != nil {
return nil, err
}
md5 := base64.StdEncoding.EncodeToString(h.Sum(nil))
// Get current time in UTC format for Date header.
curTime := time.Now().UTC().Format(time.RFC1123)
req.Header.Add("Date", curTime)
req.Header.Add("Content-Md5", md5)
req.Header.Add("Content-Type", "application/x-gzip")
req.Header.Add("X-Amz-Acl", s.permission)
authHeader, err := s.buildAuthHeader(md5, curTime, fileBase)
if err != nil {
return nil, err
}
req.Header.Add("Authorization", authHeader)
// Set content length so we avoid chunked requests.
req.ContentLength = int64(buffer.Len())
return req, nil
} | [
"func",
"(",
"s",
"*",
"S3Uploader",
")",
"buildS3Request",
"(",
"fileBase",
"string",
",",
"buffer",
"*",
"bytes",
".",
"Buffer",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"u",
":=",
"&",
"url",
".",
"URL",
"{",
"Scheme",
":",
"s",
".",
"s3url",
".",
"Scheme",
",",
"Host",
":",
"s",
".",
"s3url",
".",
"Host",
",",
"Path",
":",
"fileBase",
",",
"}",
"\n",
"// This is a PUT request containing the data buffer.",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
",",
"buffer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// FIXME: Send 'Connection: close' header on HTTP requests",
"// as reusing the connection is still prone to EOF/Connection reset errors",
"// in certain network environments...",
"// See: ENGT-9670",
"// https://stackoverflow.com/questions/17714494/golang-http-request-results-in-eof-errors",
"req",
".",
"Close",
"=",
"true",
"\n\n",
"// Generate MD5 to ensure reliable delivery",
"h",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"h",
".",
"Write",
"(",
"buffer",
".",
"Bytes",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"md5",
":=",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n\n",
"// Get current time in UTC format for Date header.",
"curTime",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"time",
".",
"RFC1123",
")",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"curTime",
")",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"md5",
")",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"s",
".",
"permission",
")",
"\n\n",
"authHeader",
",",
"err",
":=",
"s",
".",
"buildAuthHeader",
"(",
"md5",
",",
"curTime",
",",
"fileBase",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"authHeader",
")",
"\n\n",
"// Set content length so we avoid chunked requests.",
"req",
".",
"ContentLength",
"=",
"int64",
"(",
"buffer",
".",
"Len",
"(",
")",
")",
"\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] | // buildS3Request constructs an http request for the upload | [
"buildS3Request",
"constructs",
"an",
"http",
"request",
"for",
"the",
"upload"
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/s3util/s3util.go#L125-L167 |
2,997 | apcera/util | s3util/s3util.go | buildAuthHeader | func (s *S3Uploader) buildAuthHeader(md5, headerTime, fileName string) (string, error) {
access, err := getAuthCredentials()
if err != nil {
return "", err
}
// Docs: http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html
verStr := fmt.Sprintf("PUT\n%s\napplication/x-gzip\n%s\nx-amz-acl:%s\n/%s", md5, headerTime, s.permission,
path.Join(s.bucketName, fileName))
encodedStr := hmac.ComputeHmacSha1(verStr, access.SecretKey)
return fmt.Sprintf("AWS %s:%s", access.AccessKey, encodedStr), nil
} | go | func (s *S3Uploader) buildAuthHeader(md5, headerTime, fileName string) (string, error) {
access, err := getAuthCredentials()
if err != nil {
return "", err
}
// Docs: http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html
verStr := fmt.Sprintf("PUT\n%s\napplication/x-gzip\n%s\nx-amz-acl:%s\n/%s", md5, headerTime, s.permission,
path.Join(s.bucketName, fileName))
encodedStr := hmac.ComputeHmacSha1(verStr, access.SecretKey)
return fmt.Sprintf("AWS %s:%s", access.AccessKey, encodedStr), nil
} | [
"func",
"(",
"s",
"*",
"S3Uploader",
")",
"buildAuthHeader",
"(",
"md5",
",",
"headerTime",
",",
"fileName",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"access",
",",
"err",
":=",
"getAuthCredentials",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Docs: http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html",
"verStr",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"md5",
",",
"headerTime",
",",
"s",
".",
"permission",
",",
"path",
".",
"Join",
"(",
"s",
".",
"bucketName",
",",
"fileName",
")",
")",
"\n",
"encodedStr",
":=",
"hmac",
".",
"ComputeHmacSha1",
"(",
"verStr",
",",
"access",
".",
"SecretKey",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"access",
".",
"AccessKey",
",",
"encodedStr",
")",
",",
"nil",
"\n",
"}"
] | // buildAuthHeader builds an authorization header for S3. | [
"buildAuthHeader",
"builds",
"an",
"authorization",
"header",
"for",
"S3",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/s3util/s3util.go#L170-L181 |
2,998 | apcera/util | procstat/procstat_linux.go | GetProcessStats | func GetProcessStats(pid int) (*ProcessStats, error) {
p := &ProcessStats{}
// Load and Parse /proc/{pid}/stat to get all the data we need
filename := fmt.Sprintf("/proc/%d/stat", pid)
b, err := ioutil.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("failed to read process stats: %v", err)
}
fields := strings.Fields(string(b))
// Magic number is the total fields in the file, as documented by proc.
if len(fields) != 52 {
return nil, fmt.Errorf("failed to parse proc stat file")
}
// Calculate the ticks for the process. Indexes based on the proc(5) manpage
// for user/kernel ticks, as well as its children's user/kernel ticks.
totalTicks, err := sum(fields[13], fields[14], fields[15], fields[16])
if err != nil {
return nil, fmt.Errorf("failed to calculate process CPU usage: %v", err)
}
// use float in going from ticks to time to ensure we preserve granularity
// below 1 second.
p.CpuNs = time.Duration(float64(totalTicks) / float64(ticks) * float64(time.Second))
// Calculate the total resident set pages/size. Index based on man proc(5).
totalPages, err := sum(fields[23])
if err != nil {
return nil, err
}
p.RssBytes = totalPages * pagesize
return p, nil
} | go | func GetProcessStats(pid int) (*ProcessStats, error) {
p := &ProcessStats{}
// Load and Parse /proc/{pid}/stat to get all the data we need
filename := fmt.Sprintf("/proc/%d/stat", pid)
b, err := ioutil.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("failed to read process stats: %v", err)
}
fields := strings.Fields(string(b))
// Magic number is the total fields in the file, as documented by proc.
if len(fields) != 52 {
return nil, fmt.Errorf("failed to parse proc stat file")
}
// Calculate the ticks for the process. Indexes based on the proc(5) manpage
// for user/kernel ticks, as well as its children's user/kernel ticks.
totalTicks, err := sum(fields[13], fields[14], fields[15], fields[16])
if err != nil {
return nil, fmt.Errorf("failed to calculate process CPU usage: %v", err)
}
// use float in going from ticks to time to ensure we preserve granularity
// below 1 second.
p.CpuNs = time.Duration(float64(totalTicks) / float64(ticks) * float64(time.Second))
// Calculate the total resident set pages/size. Index based on man proc(5).
totalPages, err := sum(fields[23])
if err != nil {
return nil, err
}
p.RssBytes = totalPages * pagesize
return p, nil
} | [
"func",
"GetProcessStats",
"(",
"pid",
"int",
")",
"(",
"*",
"ProcessStats",
",",
"error",
")",
"{",
"p",
":=",
"&",
"ProcessStats",
"{",
"}",
"\n\n",
"// Load and Parse /proc/{pid}/stat to get all the data we need",
"filename",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pid",
")",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"fields",
":=",
"strings",
".",
"Fields",
"(",
"string",
"(",
"b",
")",
")",
"\n",
"// Magic number is the total fields in the file, as documented by proc.",
"if",
"len",
"(",
"fields",
")",
"!=",
"52",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Calculate the ticks for the process. Indexes based on the proc(5) manpage",
"// for user/kernel ticks, as well as its children's user/kernel ticks.",
"totalTicks",
",",
"err",
":=",
"sum",
"(",
"fields",
"[",
"13",
"]",
",",
"fields",
"[",
"14",
"]",
",",
"fields",
"[",
"15",
"]",
",",
"fields",
"[",
"16",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// use float in going from ticks to time to ensure we preserve granularity",
"// below 1 second.",
"p",
".",
"CpuNs",
"=",
"time",
".",
"Duration",
"(",
"float64",
"(",
"totalTicks",
")",
"/",
"float64",
"(",
"ticks",
")",
"*",
"float64",
"(",
"time",
".",
"Second",
")",
")",
"\n\n",
"// Calculate the total resident set pages/size. Index based on man proc(5).",
"totalPages",
",",
"err",
":=",
"sum",
"(",
"fields",
"[",
"23",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"p",
".",
"RssBytes",
"=",
"totalPages",
"*",
"pagesize",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] | // GetProcessStats will return the ProcessStats object associated with the given
// PID. If it fails to load the stats, then it will return an error. | [
"GetProcessStats",
"will",
"return",
"the",
"ProcessStats",
"object",
"associated",
"with",
"the",
"given",
"PID",
".",
"If",
"it",
"fails",
"to",
"load",
"the",
"stats",
"then",
"it",
"will",
"return",
"an",
"error",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/procstat/procstat_linux.go#L25-L59 |
2,999 | apcera/util | procstat/procstat_linux.go | sum | func sum(s ...string) (int64, error) {
var total int64
for _, v := range s {
i, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return 0, err
}
total += i
}
return total, nil
} | go | func sum(s ...string) (int64, error) {
var total int64
for _, v := range s {
i, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return 0, err
}
total += i
}
return total, nil
} | [
"func",
"sum",
"(",
"s",
"...",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"total",
"int64",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"s",
"{",
"i",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"v",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"total",
"+=",
"i",
"\n",
"}",
"\n",
"return",
"total",
",",
"nil",
"\n",
"}"
] | // sum will convert the list of strings into int64s and total them together. | [
"sum",
"will",
"convert",
"the",
"list",
"of",
"strings",
"into",
"int64s",
"and",
"total",
"them",
"together",
"."
] | 7a50bc84ee48450f6838847f84fde2d806f8a33a | https://github.com/apcera/util/blob/7a50bc84ee48450f6838847f84fde2d806f8a33a/procstat/procstat_linux.go#L62-L72 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.