id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
10,100 | aerospike/aerospike-client-go | internal/atomic/int.go | CompareAndSet | func (ai *AtomicInt) CompareAndSet(expect int, update int) bool {
res := atomic.CompareAndSwapInt64(&ai.val, int64(expect), int64(update))
return res
} | go | func (ai *AtomicInt) CompareAndSet(expect int, update int) bool {
res := atomic.CompareAndSwapInt64(&ai.val, int64(expect), int64(update))
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"CompareAndSet",
"(",
"expect",
"int",
",",
"update",
"int",
")",
"bool",
"{",
"res",
":=",
"atomic",
".",
"CompareAndSwapInt64",
"(",
"&",
"ai",
".",
"val",
",",
"int64",
"(",
"expect",
")",
",",
"int64",
"(",
"update",
")",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // CompareAndSet atomically sets the value to the given updated value if the current value == expected value.
// Returns true if the expectation was met | [
"CompareAndSet",
"atomically",
"sets",
"the",
"value",
"to",
"the",
"given",
"updated",
"value",
"if",
"the",
"current",
"value",
"==",
"expected",
"value",
".",
"Returns",
"true",
"if",
"the",
"expectation",
"was",
"met"
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L40-L43 |
10,101 | aerospike/aerospike-client-go | internal/atomic/int.go | DecrementAndGet | func (ai *AtomicInt) DecrementAndGet() int {
res := int(atomic.AddInt64(&ai.val, -1))
return res
} | go | func (ai *AtomicInt) DecrementAndGet() int {
res := int(atomic.AddInt64(&ai.val, -1))
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"DecrementAndGet",
"(",
")",
"int",
"{",
"res",
":=",
"int",
"(",
"atomic",
".",
"AddInt64",
"(",
"&",
"ai",
".",
"val",
",",
"-",
"1",
")",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // DecrementAndGet atomically decrements current value by one and returns the result. | [
"DecrementAndGet",
"atomically",
"decrements",
"current",
"value",
"by",
"one",
"and",
"returns",
"the",
"result",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L46-L49 |
10,102 | aerospike/aerospike-client-go | internal/atomic/int.go | Get | func (ai *AtomicInt) Get() int {
res := int(atomic.LoadInt64(&ai.val))
return res
} | go | func (ai *AtomicInt) Get() int {
res := int(atomic.LoadInt64(&ai.val))
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"Get",
"(",
")",
"int",
"{",
"res",
":=",
"int",
"(",
"atomic",
".",
"LoadInt64",
"(",
"&",
"ai",
".",
"val",
")",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // Get atomically retrieves the current value. | [
"Get",
"atomically",
"retrieves",
"the",
"current",
"value",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L52-L55 |
10,103 | aerospike/aerospike-client-go | internal/atomic/int.go | GetAndAdd | func (ai *AtomicInt) GetAndAdd(delta int) int {
newVal := atomic.AddInt64(&ai.val, int64(delta))
res := int(newVal - int64(delta))
return res
} | go | func (ai *AtomicInt) GetAndAdd(delta int) int {
newVal := atomic.AddInt64(&ai.val, int64(delta))
res := int(newVal - int64(delta))
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"GetAndAdd",
"(",
"delta",
"int",
")",
"int",
"{",
"newVal",
":=",
"atomic",
".",
"AddInt64",
"(",
"&",
"ai",
".",
"val",
",",
"int64",
"(",
"delta",
")",
")",
"\n",
"res",
":=",
"int",
"(",
"newVal",
"-",
"int64",
"(",
"delta",
")",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // GetAndAdd atomically adds the given delta to the current value and returns the result. | [
"GetAndAdd",
"atomically",
"adds",
"the",
"given",
"delta",
"to",
"the",
"current",
"value",
"and",
"returns",
"the",
"result",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L58-L62 |
10,104 | aerospike/aerospike-client-go | internal/atomic/int.go | GetAndDecrement | func (ai *AtomicInt) GetAndDecrement() int {
newVal := atomic.AddInt64(&ai.val, -1)
res := int(newVal + 1)
return res
} | go | func (ai *AtomicInt) GetAndDecrement() int {
newVal := atomic.AddInt64(&ai.val, -1)
res := int(newVal + 1)
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"GetAndDecrement",
"(",
")",
"int",
"{",
"newVal",
":=",
"atomic",
".",
"AddInt64",
"(",
"&",
"ai",
".",
"val",
",",
"-",
"1",
")",
"\n",
"res",
":=",
"int",
"(",
"newVal",
"+",
"1",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // GetAndDecrement atomically decrements the current value by one and returns the result. | [
"GetAndDecrement",
"atomically",
"decrements",
"the",
"current",
"value",
"by",
"one",
"and",
"returns",
"the",
"result",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L65-L69 |
10,105 | aerospike/aerospike-client-go | internal/atomic/int.go | GetAndSet | func (ai *AtomicInt) GetAndSet(newValue int) int {
res := int(atomic.SwapInt64(&ai.val, int64(newValue)))
return res
} | go | func (ai *AtomicInt) GetAndSet(newValue int) int {
res := int(atomic.SwapInt64(&ai.val, int64(newValue)))
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"GetAndSet",
"(",
"newValue",
"int",
")",
"int",
"{",
"res",
":=",
"int",
"(",
"atomic",
".",
"SwapInt64",
"(",
"&",
"ai",
".",
"val",
",",
"int64",
"(",
"newValue",
")",
")",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // GetAndSet atomically sets current value to the given value and returns the old value. | [
"GetAndSet",
"atomically",
"sets",
"current",
"value",
"to",
"the",
"given",
"value",
"and",
"returns",
"the",
"old",
"value",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L79-L82 |
10,106 | aerospike/aerospike-client-go | internal/atomic/int.go | IncrementAndGet | func (ai *AtomicInt) IncrementAndGet() int {
res := int(atomic.AddInt64(&ai.val, 1))
return res
} | go | func (ai *AtomicInt) IncrementAndGet() int {
res := int(atomic.AddInt64(&ai.val, 1))
return res
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"IncrementAndGet",
"(",
")",
"int",
"{",
"res",
":=",
"int",
"(",
"atomic",
".",
"AddInt64",
"(",
"&",
"ai",
".",
"val",
",",
"1",
")",
")",
"\n",
"return",
"res",
"\n",
"}"
]
| // IncrementAndGet atomically increments current value by one and returns the result. | [
"IncrementAndGet",
"atomically",
"increments",
"current",
"value",
"by",
"one",
"and",
"returns",
"the",
"result",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L85-L88 |
10,107 | aerospike/aerospike-client-go | internal/atomic/int.go | Set | func (ai *AtomicInt) Set(newValue int) {
atomic.StoreInt64(&ai.val, int64(newValue))
} | go | func (ai *AtomicInt) Set(newValue int) {
atomic.StoreInt64(&ai.val, int64(newValue))
} | [
"func",
"(",
"ai",
"*",
"AtomicInt",
")",
"Set",
"(",
"newValue",
"int",
")",
"{",
"atomic",
".",
"StoreInt64",
"(",
"&",
"ai",
".",
"val",
",",
"int64",
"(",
"newValue",
")",
")",
"\n",
"}"
]
| // Set atomically sets current value to the given value. | [
"Set",
"atomically",
"sets",
"current",
"value",
"to",
"the",
"given",
"value",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/internal/atomic/int.go#L91-L93 |
10,108 | aerospike/aerospike-client-go | filter.go | NewEqualFilter | func NewEqualFilter(binName string, value interface{}) *Filter {
val := NewValue(value)
return newFilter(binName, ICT_DEFAULT, val.GetType(), val, val)
} | go | func NewEqualFilter(binName string, value interface{}) *Filter {
val := NewValue(value)
return newFilter(binName, ICT_DEFAULT, val.GetType(), val, val)
} | [
"func",
"NewEqualFilter",
"(",
"binName",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"*",
"Filter",
"{",
"val",
":=",
"NewValue",
"(",
"value",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"ICT_DEFAULT",
",",
"val",
".",
"GetType",
"(",
")",
",",
"val",
",",
"val",
")",
"\n",
"}"
]
| // NewEqualFilter creates a new equality filter instance for query. | [
"NewEqualFilter",
"creates",
"a",
"new",
"equality",
"filter",
"instance",
"for",
"query",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L33-L36 |
10,109 | aerospike/aerospike-client-go | filter.go | NewRangeFilter | func NewRangeFilter(binName string, begin int64, end int64) *Filter {
vBegin, vEnd := NewValue(begin), NewValue(end)
return newFilter(binName, ICT_DEFAULT, vBegin.GetType(), vBegin, vEnd)
} | go | func NewRangeFilter(binName string, begin int64, end int64) *Filter {
vBegin, vEnd := NewValue(begin), NewValue(end)
return newFilter(binName, ICT_DEFAULT, vBegin.GetType(), vBegin, vEnd)
} | [
"func",
"NewRangeFilter",
"(",
"binName",
"string",
",",
"begin",
"int64",
",",
"end",
"int64",
")",
"*",
"Filter",
"{",
"vBegin",
",",
"vEnd",
":=",
"NewValue",
"(",
"begin",
")",
",",
"NewValue",
"(",
"end",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"ICT_DEFAULT",
",",
"vBegin",
".",
"GetType",
"(",
")",
",",
"vBegin",
",",
"vEnd",
")",
"\n",
"}"
]
| // NewRangeFilter creates a range filter for query.
// Range arguments must be int64 values.
// String ranges are not supported. | [
"NewRangeFilter",
"creates",
"a",
"range",
"filter",
"for",
"query",
".",
"Range",
"arguments",
"must",
"be",
"int64",
"values",
".",
"String",
"ranges",
"are",
"not",
"supported",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L41-L44 |
10,110 | aerospike/aerospike-client-go | filter.go | NewContainsFilter | func NewContainsFilter(binName string, indexCollectionType IndexCollectionType, value interface{}) *Filter {
v := NewValue(value)
return newFilter(binName, indexCollectionType, v.GetType(), v, v)
} | go | func NewContainsFilter(binName string, indexCollectionType IndexCollectionType, value interface{}) *Filter {
v := NewValue(value)
return newFilter(binName, indexCollectionType, v.GetType(), v, v)
} | [
"func",
"NewContainsFilter",
"(",
"binName",
"string",
",",
"indexCollectionType",
"IndexCollectionType",
",",
"value",
"interface",
"{",
"}",
")",
"*",
"Filter",
"{",
"v",
":=",
"NewValue",
"(",
"value",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"indexCollectionType",
",",
"v",
".",
"GetType",
"(",
")",
",",
"v",
",",
"v",
")",
"\n",
"}"
]
| // NewContainsFilter creates a contains filter for query on collection index. | [
"NewContainsFilter",
"creates",
"a",
"contains",
"filter",
"for",
"query",
"on",
"collection",
"index",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L47-L50 |
10,111 | aerospike/aerospike-client-go | filter.go | NewContainsRangeFilter | func NewContainsRangeFilter(binName string, indexCollectionType IndexCollectionType, begin, end int64) *Filter {
vBegin, vEnd := NewValue(begin), NewValue(end)
return newFilter(binName, indexCollectionType, vBegin.GetType(), vBegin, vEnd)
} | go | func NewContainsRangeFilter(binName string, indexCollectionType IndexCollectionType, begin, end int64) *Filter {
vBegin, vEnd := NewValue(begin), NewValue(end)
return newFilter(binName, indexCollectionType, vBegin.GetType(), vBegin, vEnd)
} | [
"func",
"NewContainsRangeFilter",
"(",
"binName",
"string",
",",
"indexCollectionType",
"IndexCollectionType",
",",
"begin",
",",
"end",
"int64",
")",
"*",
"Filter",
"{",
"vBegin",
",",
"vEnd",
":=",
"NewValue",
"(",
"begin",
")",
",",
"NewValue",
"(",
"end",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"indexCollectionType",
",",
"vBegin",
".",
"GetType",
"(",
")",
",",
"vBegin",
",",
"vEnd",
")",
"\n",
"}"
]
| // NewContainsRangeFilter creates a contains filter for query on ranges of data in a collection index. | [
"NewContainsRangeFilter",
"creates",
"a",
"contains",
"filter",
"for",
"query",
"on",
"ranges",
"of",
"data",
"in",
"a",
"collection",
"index",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L53-L56 |
10,112 | aerospike/aerospike-client-go | filter.go | NewGeoWithinRegionFilter | func NewGeoWithinRegionFilter(binName, region string) *Filter {
v := NewStringValue(region)
return newFilter(binName, ICT_DEFAULT, ParticleType.GEOJSON, v, v)
} | go | func NewGeoWithinRegionFilter(binName, region string) *Filter {
v := NewStringValue(region)
return newFilter(binName, ICT_DEFAULT, ParticleType.GEOJSON, v, v)
} | [
"func",
"NewGeoWithinRegionFilter",
"(",
"binName",
",",
"region",
"string",
")",
"*",
"Filter",
"{",
"v",
":=",
"NewStringValue",
"(",
"region",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"ICT_DEFAULT",
",",
"ParticleType",
".",
"GEOJSON",
",",
"v",
",",
"v",
")",
"\n",
"}"
]
| // NewGeoWithinRegionFilter creates a geospatial "within region" filter for query.
// Argument must be a valid GeoJSON region. | [
"NewGeoWithinRegionFilter",
"creates",
"a",
"geospatial",
"within",
"region",
"filter",
"for",
"query",
".",
"Argument",
"must",
"be",
"a",
"valid",
"GeoJSON",
"region",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L60-L63 |
10,113 | aerospike/aerospike-client-go | filter.go | NewGeoWithinRegionForCollectionFilter | func NewGeoWithinRegionForCollectionFilter(binName string, collectionType IndexCollectionType, region string) *Filter {
v := NewStringValue(region)
return newFilter(binName, collectionType, ParticleType.GEOJSON, v, v)
} | go | func NewGeoWithinRegionForCollectionFilter(binName string, collectionType IndexCollectionType, region string) *Filter {
v := NewStringValue(region)
return newFilter(binName, collectionType, ParticleType.GEOJSON, v, v)
} | [
"func",
"NewGeoWithinRegionForCollectionFilter",
"(",
"binName",
"string",
",",
"collectionType",
"IndexCollectionType",
",",
"region",
"string",
")",
"*",
"Filter",
"{",
"v",
":=",
"NewStringValue",
"(",
"region",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"collectionType",
",",
"ParticleType",
".",
"GEOJSON",
",",
"v",
",",
"v",
")",
"\n",
"}"
]
| // NewGeoWithinRegionForCollectionFilter creates a geospatial "within region" filter for query on collection index.
// Argument must be a valid GeoJSON region. | [
"NewGeoWithinRegionForCollectionFilter",
"creates",
"a",
"geospatial",
"within",
"region",
"filter",
"for",
"query",
"on",
"collection",
"index",
".",
"Argument",
"must",
"be",
"a",
"valid",
"GeoJSON",
"region",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L67-L70 |
10,114 | aerospike/aerospike-client-go | filter.go | NewGeoRegionsContainingPointFilter | func NewGeoRegionsContainingPointFilter(binName, point string) *Filter {
v := NewStringValue(point)
return newFilter(binName, ICT_DEFAULT, ParticleType.GEOJSON, v, v)
} | go | func NewGeoRegionsContainingPointFilter(binName, point string) *Filter {
v := NewStringValue(point)
return newFilter(binName, ICT_DEFAULT, ParticleType.GEOJSON, v, v)
} | [
"func",
"NewGeoRegionsContainingPointFilter",
"(",
"binName",
",",
"point",
"string",
")",
"*",
"Filter",
"{",
"v",
":=",
"NewStringValue",
"(",
"point",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"ICT_DEFAULT",
",",
"ParticleType",
".",
"GEOJSON",
",",
"v",
",",
"v",
")",
"\n",
"}"
]
| // NewGeoRegionsContainingPointFilter creates a geospatial "containing point" filter for query.
// Argument must be a valid GeoJSON point. | [
"NewGeoRegionsContainingPointFilter",
"creates",
"a",
"geospatial",
"containing",
"point",
"filter",
"for",
"query",
".",
"Argument",
"must",
"be",
"a",
"valid",
"GeoJSON",
"point",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L74-L77 |
10,115 | aerospike/aerospike-client-go | filter.go | NewGeoRegionsContainingPointForCollectionFilter | func NewGeoRegionsContainingPointForCollectionFilter(binName string, collectionType IndexCollectionType, point string) *Filter {
v := NewStringValue(point)
return newFilter(binName, collectionType, ParticleType.GEOJSON, v, v)
} | go | func NewGeoRegionsContainingPointForCollectionFilter(binName string, collectionType IndexCollectionType, point string) *Filter {
v := NewStringValue(point)
return newFilter(binName, collectionType, ParticleType.GEOJSON, v, v)
} | [
"func",
"NewGeoRegionsContainingPointForCollectionFilter",
"(",
"binName",
"string",
",",
"collectionType",
"IndexCollectionType",
",",
"point",
"string",
")",
"*",
"Filter",
"{",
"v",
":=",
"NewStringValue",
"(",
"point",
")",
"\n",
"return",
"newFilter",
"(",
"binName",
",",
"collectionType",
",",
"ParticleType",
".",
"GEOJSON",
",",
"v",
",",
"v",
")",
"\n",
"}"
]
| // NewGeoRegionsContainingPointForCollectionFilter creates a geospatial "containing point" filter for query on collection index.
// Argument must be a valid GeoJSON point. | [
"NewGeoRegionsContainingPointForCollectionFilter",
"creates",
"a",
"geospatial",
"containing",
"point",
"filter",
"for",
"query",
"on",
"collection",
"index",
".",
"Argument",
"must",
"be",
"a",
"valid",
"GeoJSON",
"point",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L81-L84 |
10,116 | aerospike/aerospike-client-go | filter.go | newFilter | func newFilter(name string, indexCollectionType IndexCollectionType, valueParticleType int, begin Value, end Value) *Filter {
return &Filter{
name: name,
idxType: indexCollectionType,
valueParticleType: valueParticleType,
begin: begin,
end: end,
}
} | go | func newFilter(name string, indexCollectionType IndexCollectionType, valueParticleType int, begin Value, end Value) *Filter {
return &Filter{
name: name,
idxType: indexCollectionType,
valueParticleType: valueParticleType,
begin: begin,
end: end,
}
} | [
"func",
"newFilter",
"(",
"name",
"string",
",",
"indexCollectionType",
"IndexCollectionType",
",",
"valueParticleType",
"int",
",",
"begin",
"Value",
",",
"end",
"Value",
")",
"*",
"Filter",
"{",
"return",
"&",
"Filter",
"{",
"name",
":",
"name",
",",
"idxType",
":",
"indexCollectionType",
",",
"valueParticleType",
":",
"valueParticleType",
",",
"begin",
":",
"begin",
",",
"end",
":",
"end",
",",
"}",
"\n",
"}"
]
| // Create a filter for query.
// Range arguments must be longs or integers which can be cast to longs.
// String ranges are not supported. | [
"Create",
"a",
"filter",
"for",
"query",
".",
"Range",
"arguments",
"must",
"be",
"longs",
"or",
"integers",
"which",
"can",
"be",
"cast",
"to",
"longs",
".",
"String",
"ranges",
"are",
"not",
"supported",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/filter.go#L103-L111 |
10,117 | aerospike/aerospike-client-go | batch_command_get.go | parseKey | func (cmd *batchCommandGet) parseKey(fieldCount int) error {
// var digest [20]byte
// var namespace, setName string
// var userKey Value
var err error
for i := 0; i < fieldCount; i++ {
if err = cmd.readBytes(4); err != nil {
return err
}
fieldlen := int(Buffer.BytesToUint32(cmd.dataBuffer, 0))
if err = cmd.readBytes(fieldlen); err != nil {
return err
}
fieldtype := FieldType(cmd.dataBuffer[0])
size := fieldlen - 1
switch fieldtype {
case DIGEST_RIPE:
copy(cmd.key.digest[:], cmd.dataBuffer[1:size+1])
case NAMESPACE:
cmd.key.namespace = string(cmd.dataBuffer[1 : size+1])
case TABLE:
cmd.key.setName = string(cmd.dataBuffer[1 : size+1])
case KEY:
if cmd.key.userKey, err = bytesToKeyValue(int(cmd.dataBuffer[1]), cmd.dataBuffer, 2, size-1); err != nil {
return err
}
}
}
return nil
} | go | func (cmd *batchCommandGet) parseKey(fieldCount int) error {
// var digest [20]byte
// var namespace, setName string
// var userKey Value
var err error
for i := 0; i < fieldCount; i++ {
if err = cmd.readBytes(4); err != nil {
return err
}
fieldlen := int(Buffer.BytesToUint32(cmd.dataBuffer, 0))
if err = cmd.readBytes(fieldlen); err != nil {
return err
}
fieldtype := FieldType(cmd.dataBuffer[0])
size := fieldlen - 1
switch fieldtype {
case DIGEST_RIPE:
copy(cmd.key.digest[:], cmd.dataBuffer[1:size+1])
case NAMESPACE:
cmd.key.namespace = string(cmd.dataBuffer[1 : size+1])
case TABLE:
cmd.key.setName = string(cmd.dataBuffer[1 : size+1])
case KEY:
if cmd.key.userKey, err = bytesToKeyValue(int(cmd.dataBuffer[1]), cmd.dataBuffer, 2, size-1); err != nil {
return err
}
}
}
return nil
} | [
"func",
"(",
"cmd",
"*",
"batchCommandGet",
")",
"parseKey",
"(",
"fieldCount",
"int",
")",
"error",
"{",
"// var digest [20]byte",
"// var namespace, setName string",
"// var userKey Value",
"var",
"err",
"error",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"fieldCount",
";",
"i",
"++",
"{",
"if",
"err",
"=",
"cmd",
".",
"readBytes",
"(",
"4",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fieldlen",
":=",
"int",
"(",
"Buffer",
".",
"BytesToUint32",
"(",
"cmd",
".",
"dataBuffer",
",",
"0",
")",
")",
"\n",
"if",
"err",
"=",
"cmd",
".",
"readBytes",
"(",
"fieldlen",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fieldtype",
":=",
"FieldType",
"(",
"cmd",
".",
"dataBuffer",
"[",
"0",
"]",
")",
"\n",
"size",
":=",
"fieldlen",
"-",
"1",
"\n\n",
"switch",
"fieldtype",
"{",
"case",
"DIGEST_RIPE",
":",
"copy",
"(",
"cmd",
".",
"key",
".",
"digest",
"[",
":",
"]",
",",
"cmd",
".",
"dataBuffer",
"[",
"1",
":",
"size",
"+",
"1",
"]",
")",
"\n",
"case",
"NAMESPACE",
":",
"cmd",
".",
"key",
".",
"namespace",
"=",
"string",
"(",
"cmd",
".",
"dataBuffer",
"[",
"1",
":",
"size",
"+",
"1",
"]",
")",
"\n",
"case",
"TABLE",
":",
"cmd",
".",
"key",
".",
"setName",
"=",
"string",
"(",
"cmd",
".",
"dataBuffer",
"[",
"1",
":",
"size",
"+",
"1",
"]",
")",
"\n",
"case",
"KEY",
":",
"if",
"cmd",
".",
"key",
".",
"userKey",
",",
"err",
"=",
"bytesToKeyValue",
"(",
"int",
"(",
"cmd",
".",
"dataBuffer",
"[",
"1",
"]",
")",
",",
"cmd",
".",
"dataBuffer",
",",
"2",
",",
"size",
"-",
"1",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // On batch operations the key values are not returned from the server
// So we reuse the Key on the batch Object | [
"On",
"batch",
"operations",
"the",
"key",
"values",
"are",
"not",
"returned",
"from",
"the",
"server",
"So",
"we",
"reuse",
"the",
"Key",
"on",
"the",
"batch",
"Object"
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/batch_command_get.go#L102-L136 |
10,118 | aerospike/aerospike-client-go | batch_command_get.go | parseRecord | func (cmd *batchCommandGet) parseRecord(key *Key, opCount int, generation, expiration uint32) (*Record, error) {
bins := make(BinMap, opCount)
for i := 0; i < opCount; i++ {
if err := cmd.readBytes(8); err != nil {
return nil, err
}
opSize := int(Buffer.BytesToUint32(cmd.dataBuffer, 0))
particleType := int(cmd.dataBuffer[5])
nameSize := int(cmd.dataBuffer[7])
if err := cmd.readBytes(nameSize); err != nil {
return nil, err
}
name := string(cmd.dataBuffer[:nameSize])
particleBytesSize := opSize - (4 + nameSize)
if err := cmd.readBytes(particleBytesSize); err != nil {
return nil, err
}
value, err := bytesToParticle(particleType, cmd.dataBuffer, 0, particleBytesSize)
if err != nil {
return nil, err
}
bins[name] = value
}
return newRecord(cmd.node, key, bins, generation, expiration), nil
} | go | func (cmd *batchCommandGet) parseRecord(key *Key, opCount int, generation, expiration uint32) (*Record, error) {
bins := make(BinMap, opCount)
for i := 0; i < opCount; i++ {
if err := cmd.readBytes(8); err != nil {
return nil, err
}
opSize := int(Buffer.BytesToUint32(cmd.dataBuffer, 0))
particleType := int(cmd.dataBuffer[5])
nameSize := int(cmd.dataBuffer[7])
if err := cmd.readBytes(nameSize); err != nil {
return nil, err
}
name := string(cmd.dataBuffer[:nameSize])
particleBytesSize := opSize - (4 + nameSize)
if err := cmd.readBytes(particleBytesSize); err != nil {
return nil, err
}
value, err := bytesToParticle(particleType, cmd.dataBuffer, 0, particleBytesSize)
if err != nil {
return nil, err
}
bins[name] = value
}
return newRecord(cmd.node, key, bins, generation, expiration), nil
} | [
"func",
"(",
"cmd",
"*",
"batchCommandGet",
")",
"parseRecord",
"(",
"key",
"*",
"Key",
",",
"opCount",
"int",
",",
"generation",
",",
"expiration",
"uint32",
")",
"(",
"*",
"Record",
",",
"error",
")",
"{",
"bins",
":=",
"make",
"(",
"BinMap",
",",
"opCount",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"opCount",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"cmd",
".",
"readBytes",
"(",
"8",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"opSize",
":=",
"int",
"(",
"Buffer",
".",
"BytesToUint32",
"(",
"cmd",
".",
"dataBuffer",
",",
"0",
")",
")",
"\n",
"particleType",
":=",
"int",
"(",
"cmd",
".",
"dataBuffer",
"[",
"5",
"]",
")",
"\n",
"nameSize",
":=",
"int",
"(",
"cmd",
".",
"dataBuffer",
"[",
"7",
"]",
")",
"\n\n",
"if",
"err",
":=",
"cmd",
".",
"readBytes",
"(",
"nameSize",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"name",
":=",
"string",
"(",
"cmd",
".",
"dataBuffer",
"[",
":",
"nameSize",
"]",
")",
"\n\n",
"particleBytesSize",
":=",
"opSize",
"-",
"(",
"4",
"+",
"nameSize",
")",
"\n",
"if",
"err",
":=",
"cmd",
".",
"readBytes",
"(",
"particleBytesSize",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"bytesToParticle",
"(",
"particleType",
",",
"cmd",
".",
"dataBuffer",
",",
"0",
",",
"particleBytesSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bins",
"[",
"name",
"]",
"=",
"value",
"\n",
"}",
"\n\n",
"return",
"newRecord",
"(",
"cmd",
".",
"node",
",",
"key",
",",
"bins",
",",
"generation",
",",
"expiration",
")",
",",
"nil",
"\n",
"}"
]
| // Parses the given byte buffer and populate the result object.
// Returns the number of bytes that were parsed from the given buffer. | [
"Parses",
"the",
"given",
"byte",
"buffer",
"and",
"populate",
"the",
"result",
"object",
".",
"Returns",
"the",
"number",
"of",
"bytes",
"that",
"were",
"parsed",
"from",
"the",
"given",
"buffer",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/batch_command_get.go#L214-L243 |
10,119 | aerospike/aerospike-client-go | examples/expire.go | expireExample | func expireExample(client *as.Client) {
key, _ := as.NewKey(*shared.Namespace, *shared.Set, "expirekey ")
bin := as.NewBin("expirebin", "expirevalue")
log.Printf("Put: namespace=%s set=%s key=%s bin=%s value=%s expiration=2",
key.Namespace(), key.SetName(), key.Value(), bin.Name, bin.Value)
// Specify that record expires 2 seconds after it's written.
writePolicy := as.NewWritePolicy(0, 2)
client.PutBins(writePolicy, key, bin)
// Read the record before it expires, showing it is there.
log.Printf("Get: namespace=%s set=%s key=%s",
key.Namespace(), key.SetName(), key.Value())
record, err := client.Get(shared.Policy, key, bin.Name)
shared.PanicOnError(err)
if record == nil {
log.Fatalf(
"Failed to get record: namespace=%s set=%s key=%s",
key.Namespace(), key.SetName(), key.Value())
}
received := record.Bins[bin.Name]
expected := bin.Value.String()
if received == expected {
log.Printf("Get record successful: namespace=%s set=%s key=%s bin=%s value=%s",
key.Namespace(), key.SetName(), key.Value(), bin.Name, received)
} else {
log.Fatalf("Expire record mismatch: Expected %s. Received %s.",
expected, received)
}
// Read the record after it expires, showing it's gone.
log.Printf("Sleeping for 3 seconds ...")
time.Sleep(3 * time.Second)
record, err = client.Get(shared.Policy, key, bin.Name)
shared.PanicOnError(err)
if record == nil {
log.Printf("Expiry of record successful. Record not found.")
} else {
log.Fatalf("Found record when it should have expired.")
}
} | go | func expireExample(client *as.Client) {
key, _ := as.NewKey(*shared.Namespace, *shared.Set, "expirekey ")
bin := as.NewBin("expirebin", "expirevalue")
log.Printf("Put: namespace=%s set=%s key=%s bin=%s value=%s expiration=2",
key.Namespace(), key.SetName(), key.Value(), bin.Name, bin.Value)
// Specify that record expires 2 seconds after it's written.
writePolicy := as.NewWritePolicy(0, 2)
client.PutBins(writePolicy, key, bin)
// Read the record before it expires, showing it is there.
log.Printf("Get: namespace=%s set=%s key=%s",
key.Namespace(), key.SetName(), key.Value())
record, err := client.Get(shared.Policy, key, bin.Name)
shared.PanicOnError(err)
if record == nil {
log.Fatalf(
"Failed to get record: namespace=%s set=%s key=%s",
key.Namespace(), key.SetName(), key.Value())
}
received := record.Bins[bin.Name]
expected := bin.Value.String()
if received == expected {
log.Printf("Get record successful: namespace=%s set=%s key=%s bin=%s value=%s",
key.Namespace(), key.SetName(), key.Value(), bin.Name, received)
} else {
log.Fatalf("Expire record mismatch: Expected %s. Received %s.",
expected, received)
}
// Read the record after it expires, showing it's gone.
log.Printf("Sleeping for 3 seconds ...")
time.Sleep(3 * time.Second)
record, err = client.Get(shared.Policy, key, bin.Name)
shared.PanicOnError(err)
if record == nil {
log.Printf("Expiry of record successful. Record not found.")
} else {
log.Fatalf("Found record when it should have expired.")
}
} | [
"func",
"expireExample",
"(",
"client",
"*",
"as",
".",
"Client",
")",
"{",
"key",
",",
"_",
":=",
"as",
".",
"NewKey",
"(",
"*",
"shared",
".",
"Namespace",
",",
"*",
"shared",
".",
"Set",
",",
"\"",
"\"",
")",
"\n",
"bin",
":=",
"as",
".",
"NewBin",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"key",
".",
"Namespace",
"(",
")",
",",
"key",
".",
"SetName",
"(",
")",
",",
"key",
".",
"Value",
"(",
")",
",",
"bin",
".",
"Name",
",",
"bin",
".",
"Value",
")",
"\n\n",
"// Specify that record expires 2 seconds after it's written.",
"writePolicy",
":=",
"as",
".",
"NewWritePolicy",
"(",
"0",
",",
"2",
")",
"\n",
"client",
".",
"PutBins",
"(",
"writePolicy",
",",
"key",
",",
"bin",
")",
"\n\n",
"// Read the record before it expires, showing it is there.",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"key",
".",
"Namespace",
"(",
")",
",",
"key",
".",
"SetName",
"(",
")",
",",
"key",
".",
"Value",
"(",
")",
")",
"\n\n",
"record",
",",
"err",
":=",
"client",
".",
"Get",
"(",
"shared",
".",
"Policy",
",",
"key",
",",
"bin",
".",
"Name",
")",
"\n",
"shared",
".",
"PanicOnError",
"(",
"err",
")",
"\n",
"if",
"record",
"==",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"key",
".",
"Namespace",
"(",
")",
",",
"key",
".",
"SetName",
"(",
")",
",",
"key",
".",
"Value",
"(",
")",
")",
"\n",
"}",
"\n\n",
"received",
":=",
"record",
".",
"Bins",
"[",
"bin",
".",
"Name",
"]",
"\n",
"expected",
":=",
"bin",
".",
"Value",
".",
"String",
"(",
")",
"\n",
"if",
"received",
"==",
"expected",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"key",
".",
"Namespace",
"(",
")",
",",
"key",
".",
"SetName",
"(",
")",
",",
"key",
".",
"Value",
"(",
")",
",",
"bin",
".",
"Name",
",",
"received",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"expected",
",",
"received",
")",
"\n",
"}",
"\n\n",
"// Read the record after it expires, showing it's gone.",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"time",
".",
"Sleep",
"(",
"3",
"*",
"time",
".",
"Second",
")",
"\n",
"record",
",",
"err",
"=",
"client",
".",
"Get",
"(",
"shared",
".",
"Policy",
",",
"key",
",",
"bin",
".",
"Name",
")",
"\n",
"shared",
".",
"PanicOnError",
"(",
"err",
")",
"\n",
"if",
"record",
"==",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
]
| /**
* Write and twice read an expiration record.
*/ | [
"Write",
"and",
"twice",
"read",
"an",
"expiration",
"record",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/examples/expire.go#L39-L82 |
10,120 | aerospike/aerospike-client-go | task.go | onComplete | func (btsk *baseTask) onComplete(ifc Task) chan error {
ch := make(chan error, 1)
// goroutine will loop every <interval> until IsDone() returns true or error
go func() {
// always close the channel on return
defer close(ch)
var interval = 100 * time.Millisecond
for {
select {
case <-time.After(interval):
done, err := ifc.IsDone()
// Every 5 failed retries increase the interval
if btsk.retries.IncrementAndGet()%5 == 0 {
interval *= 2
println(interval)
if interval > 5*time.Second {
interval = 5 * time.Second
}
}
if err != nil {
ae, ok := err.(AerospikeError)
if ok && ae.ResultCode() == TIMEOUT {
ae.MarkInDoubt()
}
ch <- ae
return
} else if done {
ch <- nil
return
}
} // select
} // for
}()
return ch
} | go | func (btsk *baseTask) onComplete(ifc Task) chan error {
ch := make(chan error, 1)
// goroutine will loop every <interval> until IsDone() returns true or error
go func() {
// always close the channel on return
defer close(ch)
var interval = 100 * time.Millisecond
for {
select {
case <-time.After(interval):
done, err := ifc.IsDone()
// Every 5 failed retries increase the interval
if btsk.retries.IncrementAndGet()%5 == 0 {
interval *= 2
println(interval)
if interval > 5*time.Second {
interval = 5 * time.Second
}
}
if err != nil {
ae, ok := err.(AerospikeError)
if ok && ae.ResultCode() == TIMEOUT {
ae.MarkInDoubt()
}
ch <- ae
return
} else if done {
ch <- nil
return
}
} // select
} // for
}()
return ch
} | [
"func",
"(",
"btsk",
"*",
"baseTask",
")",
"onComplete",
"(",
"ifc",
"Task",
")",
"chan",
"error",
"{",
"ch",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n\n",
"// goroutine will loop every <interval> until IsDone() returns true or error",
"go",
"func",
"(",
")",
"{",
"// always close the channel on return",
"defer",
"close",
"(",
"ch",
")",
"\n\n",
"var",
"interval",
"=",
"100",
"*",
"time",
".",
"Millisecond",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"interval",
")",
":",
"done",
",",
"err",
":=",
"ifc",
".",
"IsDone",
"(",
")",
"\n",
"// Every 5 failed retries increase the interval",
"if",
"btsk",
".",
"retries",
".",
"IncrementAndGet",
"(",
")",
"%",
"5",
"==",
"0",
"{",
"interval",
"*=",
"2",
"\n",
"println",
"(",
"interval",
")",
"\n\n",
"if",
"interval",
">",
"5",
"*",
"time",
".",
"Second",
"{",
"interval",
"=",
"5",
"*",
"time",
".",
"Second",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ae",
",",
"ok",
":=",
"err",
".",
"(",
"AerospikeError",
")",
"\n",
"if",
"ok",
"&&",
"ae",
".",
"ResultCode",
"(",
")",
"==",
"TIMEOUT",
"{",
"ae",
".",
"MarkInDoubt",
"(",
")",
"\n",
"}",
"\n",
"ch",
"<-",
"ae",
"\n",
"return",
"\n",
"}",
"else",
"if",
"done",
"{",
"ch",
"<-",
"nil",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"// select",
"\n",
"}",
"// for",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"ch",
"\n",
"}"
]
| // Wait for asynchronous task to complete using default sleep interval. | [
"Wait",
"for",
"asynchronous",
"task",
"to",
"complete",
"using",
"default",
"sleep",
"interval",
"."
]
| f257953b1650505cf4c357fcc4f032d160ebb07e | https://github.com/aerospike/aerospike-client-go/blob/f257953b1650505cf4c357fcc4f032d160ebb07e/task.go#L46-L85 |
10,121 | ipfs/go-ds-badger | datastore.go | NewTransaction | func (d *Datastore) NewTransaction(readOnly bool) (ds.Txn, error) {
d.closeLk.RLock()
defer d.closeLk.RUnlock()
if d.closed {
return nil, ErrClosed
}
return &txn{d, d.DB.NewTransaction(!readOnly), false}, nil
} | go | func (d *Datastore) NewTransaction(readOnly bool) (ds.Txn, error) {
d.closeLk.RLock()
defer d.closeLk.RUnlock()
if d.closed {
return nil, ErrClosed
}
return &txn{d, d.DB.NewTransaction(!readOnly), false}, nil
} | [
"func",
"(",
"d",
"*",
"Datastore",
")",
"NewTransaction",
"(",
"readOnly",
"bool",
")",
"(",
"ds",
".",
"Txn",
",",
"error",
")",
"{",
"d",
".",
"closeLk",
".",
"RLock",
"(",
")",
"\n",
"defer",
"d",
".",
"closeLk",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"d",
".",
"closed",
"{",
"return",
"nil",
",",
"ErrClosed",
"\n",
"}",
"\n\n",
"return",
"&",
"txn",
"{",
"d",
",",
"d",
".",
"DB",
".",
"NewTransaction",
"(",
"!",
"readOnly",
")",
",",
"false",
"}",
",",
"nil",
"\n",
"}"
]
| // NewTransaction starts a new transaction. The resulting transaction object
// can be mutated without incurring changes to the underlying Datastore until
// the transaction is Committed. | [
"NewTransaction",
"starts",
"a",
"new",
"transaction",
".",
"The",
"resulting",
"transaction",
"object",
"can",
"be",
"mutated",
"without",
"incurring",
"changes",
"to",
"the",
"underlying",
"Datastore",
"until",
"the",
"transaction",
"is",
"Committed",
"."
]
| 7fe0af0808f565d460fa8d3851a5808d77f72628 | https://github.com/ipfs/go-ds-badger/blob/7fe0af0808f565d460fa8d3851a5808d77f72628/datastore.go#L103-L111 |
10,122 | ipfs/go-ds-badger | datastore.go | newImplicitTransaction | func (d *Datastore) newImplicitTransaction(readOnly bool) *txn {
return &txn{d, d.DB.NewTransaction(!readOnly), true}
} | go | func (d *Datastore) newImplicitTransaction(readOnly bool) *txn {
return &txn{d, d.DB.NewTransaction(!readOnly), true}
} | [
"func",
"(",
"d",
"*",
"Datastore",
")",
"newImplicitTransaction",
"(",
"readOnly",
"bool",
")",
"*",
"txn",
"{",
"return",
"&",
"txn",
"{",
"d",
",",
"d",
".",
"DB",
".",
"NewTransaction",
"(",
"!",
"readOnly",
")",
",",
"true",
"}",
"\n",
"}"
]
| // newImplicitTransaction creates a transaction marked as 'implicit'.
// Implicit transactions are created by Datastore methods performing single operations. | [
"newImplicitTransaction",
"creates",
"a",
"transaction",
"marked",
"as",
"implicit",
".",
"Implicit",
"transactions",
"are",
"created",
"by",
"Datastore",
"methods",
"performing",
"single",
"operations",
"."
]
| 7fe0af0808f565d460fa8d3851a5808d77f72628 | https://github.com/ipfs/go-ds-badger/blob/7fe0af0808f565d460fa8d3851a5808d77f72628/datastore.go#L115-L117 |
10,123 | ipfs/go-ds-badger | datastore.go | DiskUsage | func (d *Datastore) DiskUsage() (uint64, error) {
d.closeLk.RLock()
defer d.closeLk.RUnlock()
if d.closed {
return 0, ErrClosed
}
lsm, vlog := d.DB.Size()
return uint64(lsm + vlog), nil
} | go | func (d *Datastore) DiskUsage() (uint64, error) {
d.closeLk.RLock()
defer d.closeLk.RUnlock()
if d.closed {
return 0, ErrClosed
}
lsm, vlog := d.DB.Size()
return uint64(lsm + vlog), nil
} | [
"func",
"(",
"d",
"*",
"Datastore",
")",
"DiskUsage",
"(",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"d",
".",
"closeLk",
".",
"RLock",
"(",
")",
"\n",
"defer",
"d",
".",
"closeLk",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"d",
".",
"closed",
"{",
"return",
"0",
",",
"ErrClosed",
"\n",
"}",
"\n",
"lsm",
",",
"vlog",
":=",
"d",
".",
"DB",
".",
"Size",
"(",
")",
"\n",
"return",
"uint64",
"(",
"lsm",
"+",
"vlog",
")",
",",
"nil",
"\n",
"}"
]
| // DiskUsage implements the PersistentDatastore interface.
// It returns the sum of lsm and value log files sizes in bytes. | [
"DiskUsage",
"implements",
"the",
"PersistentDatastore",
"interface",
".",
"It",
"returns",
"the",
"sum",
"of",
"lsm",
"and",
"value",
"log",
"files",
"sizes",
"in",
"bytes",
"."
]
| 7fe0af0808f565d460fa8d3851a5808d77f72628 | https://github.com/ipfs/go-ds-badger/blob/7fe0af0808f565d460fa8d3851a5808d77f72628/datastore.go#L250-L258 |
10,124 | ipfs/go-ds-badger | datastore.go | Close | func (t *txn) Close() error {
t.ds.closeLk.RLock()
defer t.ds.closeLk.RUnlock()
if t.ds.closed {
return ErrClosed
}
return t.close()
} | go | func (t *txn) Close() error {
t.ds.closeLk.RLock()
defer t.ds.closeLk.RUnlock()
if t.ds.closed {
return ErrClosed
}
return t.close()
} | [
"func",
"(",
"t",
"*",
"txn",
")",
"Close",
"(",
")",
"error",
"{",
"t",
".",
"ds",
".",
"closeLk",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"ds",
".",
"closeLk",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
".",
"ds",
".",
"closed",
"{",
"return",
"ErrClosed",
"\n",
"}",
"\n",
"return",
"t",
".",
"close",
"(",
")",
"\n",
"}"
]
| // Alias to commit | [
"Alias",
"to",
"commit"
]
| 7fe0af0808f565d460fa8d3851a5808d77f72628 | https://github.com/ipfs/go-ds-badger/blob/7fe0af0808f565d460fa8d3851a5808d77f72628/datastore.go#L583-L590 |
10,125 | jcuga/golongpoll | priority_queue.go | updatePriority | func (pq *priorityQueue) updatePriority(item *expiringBuffer, priority int64) {
item.priority = priority
// NOTE: fix is a slightly more efficient version of calling Remove() and
// then Push()
heap.Fix(pq, item.index)
} | go | func (pq *priorityQueue) updatePriority(item *expiringBuffer, priority int64) {
item.priority = priority
// NOTE: fix is a slightly more efficient version of calling Remove() and
// then Push()
heap.Fix(pq, item.index)
} | [
"func",
"(",
"pq",
"*",
"priorityQueue",
")",
"updatePriority",
"(",
"item",
"*",
"expiringBuffer",
",",
"priority",
"int64",
")",
"{",
"item",
".",
"priority",
"=",
"priority",
"\n",
"// NOTE: fix is a slightly more efficient version of calling Remove() and",
"// then Push()",
"heap",
".",
"Fix",
"(",
"pq",
",",
"item",
".",
"index",
")",
"\n",
"}"
]
| // update modifies the priority of an item and updates the heap accordingly | [
"update",
"modifies",
"the",
"priority",
"of",
"an",
"item",
"and",
"updates",
"the",
"heap",
"accordingly"
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/priority_queue.go#L70-L75 |
10,126 | jcuga/golongpoll | priority_queue.go | peakTopPriority | func (pq *priorityQueue) peakTopPriority() (int64, error) {
if len(*pq) > 0 {
return (*pq)[0].priority, nil
} else {
return -1, fmt.Errorf("PriorityQueue is empty. No top priority.")
}
} | go | func (pq *priorityQueue) peakTopPriority() (int64, error) {
if len(*pq) > 0 {
return (*pq)[0].priority, nil
} else {
return -1, fmt.Errorf("PriorityQueue is empty. No top priority.")
}
} | [
"func",
"(",
"pq",
"*",
"priorityQueue",
")",
"peakTopPriority",
"(",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"*",
"pq",
")",
">",
"0",
"{",
"return",
"(",
"*",
"pq",
")",
"[",
"0",
"]",
".",
"priority",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
]
| // get the priority of the heap's top item. | [
"get",
"the",
"priority",
"of",
"the",
"heap",
"s",
"top",
"item",
"."
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/priority_queue.go#L78-L84 |
10,127 | jcuga/golongpoll | examples/advanced/advanced.go | getEventSubscriptionHandler | func getEventSubscriptionHandler(manager *golongpoll.LongpollManager) func(w http.ResponseWriter, r *http.Request) {
// Creates closure that captures the LongpollManager
// Wraps the manager.SubscriptionHandler with a layer of dummy access control validation
return func(w http.ResponseWriter, r *http.Request) {
category := r.URL.Query().Get("category")
user := r.URL.Query().Get("user")
// NOTE: real user authentication should be used in the real world!
// Dummy user access control in the event the client is requesting
// a user's private activity stream:
if category == "larry_actions" && user != "larry" {
w.WriteHeader(http.StatusForbidden)
w.Write([]byte("You're not Larry."))
return
}
if category == "moe_actions" && user != "moe" {
w.WriteHeader(http.StatusForbidden)
w.Write([]byte("You're not Moe."))
return
}
if category == "curly_actions" && user != "curly" {
w.WriteHeader(http.StatusForbidden)
w.Write([]byte("You're not Curly."))
return
}
// Only allow supported subscription categories:
if category != "public_actions" && category != "larry_actions" &&
category != "moe_actions" && category != "curly_actions" {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("Subscription channel does not exist."))
return
}
// Client is either requesting the public stream, or a private
// stream that they're allowed to see.
// Go ahead and let the subscription happen:
manager.SubscriptionHandler(w, r)
}
} | go | func getEventSubscriptionHandler(manager *golongpoll.LongpollManager) func(w http.ResponseWriter, r *http.Request) {
// Creates closure that captures the LongpollManager
// Wraps the manager.SubscriptionHandler with a layer of dummy access control validation
return func(w http.ResponseWriter, r *http.Request) {
category := r.URL.Query().Get("category")
user := r.URL.Query().Get("user")
// NOTE: real user authentication should be used in the real world!
// Dummy user access control in the event the client is requesting
// a user's private activity stream:
if category == "larry_actions" && user != "larry" {
w.WriteHeader(http.StatusForbidden)
w.Write([]byte("You're not Larry."))
return
}
if category == "moe_actions" && user != "moe" {
w.WriteHeader(http.StatusForbidden)
w.Write([]byte("You're not Moe."))
return
}
if category == "curly_actions" && user != "curly" {
w.WriteHeader(http.StatusForbidden)
w.Write([]byte("You're not Curly."))
return
}
// Only allow supported subscription categories:
if category != "public_actions" && category != "larry_actions" &&
category != "moe_actions" && category != "curly_actions" {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("Subscription channel does not exist."))
return
}
// Client is either requesting the public stream, or a private
// stream that they're allowed to see.
// Go ahead and let the subscription happen:
manager.SubscriptionHandler(w, r)
}
} | [
"func",
"getEventSubscriptionHandler",
"(",
"manager",
"*",
"golongpoll",
".",
"LongpollManager",
")",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"// Creates closure that captures the LongpollManager",
"// Wraps the manager.SubscriptionHandler with a layer of dummy access control validation",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"category",
":=",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"user",
":=",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"// NOTE: real user authentication should be used in the real world!",
"// Dummy user access control in the event the client is requesting",
"// a user's private activity stream:",
"if",
"category",
"==",
"\"",
"\"",
"&&",
"user",
"!=",
"\"",
"\"",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusForbidden",
")",
"\n",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"category",
"==",
"\"",
"\"",
"&&",
"user",
"!=",
"\"",
"\"",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusForbidden",
")",
"\n",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"category",
"==",
"\"",
"\"",
"&&",
"user",
"!=",
"\"",
"\"",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusForbidden",
")",
"\n",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Only allow supported subscription categories:",
"if",
"category",
"!=",
"\"",
"\"",
"&&",
"category",
"!=",
"\"",
"\"",
"&&",
"category",
"!=",
"\"",
"\"",
"&&",
"category",
"!=",
"\"",
"\"",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusBadRequest",
")",
"\n",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Client is either requesting the public stream, or a private",
"// stream that they're allowed to see.",
"// Go ahead and let the subscription happen:",
"manager",
".",
"SubscriptionHandler",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"\n",
"}"
]
| // Creates a closure function that is used as an http handler for browsers to
// subscribe to events via longpolling.
// Notice how we're wrapping LongpollManager.SubscriptionHandler in order to
// add our own logic and validation. | [
"Creates",
"a",
"closure",
"function",
"that",
"is",
"used",
"as",
"an",
"http",
"handler",
"for",
"browsers",
"to",
"subscribe",
"to",
"events",
"via",
"longpolling",
".",
"Notice",
"how",
"we",
"re",
"wrapping",
"LongpollManager",
".",
"SubscriptionHandler",
"in",
"order",
"to",
"add",
"our",
"own",
"logic",
"and",
"validation",
"."
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/examples/advanced/advanced.go#L121-L160 |
10,128 | jcuga/golongpoll | events.go | QueueEvent | func (eb *eventBuffer) QueueEvent(event *lpEvent) error {
if event == nil {
return errors.New("event was nil")
}
// Cull our buffer if we're at max capacity
if eb.List.Len() >= eb.MaxBufferSize {
oldestEvent := eb.List.Back()
if oldestEvent != nil {
eb.List.Remove(oldestEvent)
}
}
// Add event to front of our list
eb.List.PushFront(event)
// Update oldestEventTime with the time of our least recent event (at back)
// keeping track of this allows for more efficient event TTL expiration purges
if lastElement := eb.List.Back(); lastElement != nil {
lastEvent, ok := lastElement.Value.(*lpEvent)
if !ok {
return fmt.Errorf("Found non-event type in event buffer.")
}
eb.oldestEventTime = lastEvent.Timestamp
}
return nil
} | go | func (eb *eventBuffer) QueueEvent(event *lpEvent) error {
if event == nil {
return errors.New("event was nil")
}
// Cull our buffer if we're at max capacity
if eb.List.Len() >= eb.MaxBufferSize {
oldestEvent := eb.List.Back()
if oldestEvent != nil {
eb.List.Remove(oldestEvent)
}
}
// Add event to front of our list
eb.List.PushFront(event)
// Update oldestEventTime with the time of our least recent event (at back)
// keeping track of this allows for more efficient event TTL expiration purges
if lastElement := eb.List.Back(); lastElement != nil {
lastEvent, ok := lastElement.Value.(*lpEvent)
if !ok {
return fmt.Errorf("Found non-event type in event buffer.")
}
eb.oldestEventTime = lastEvent.Timestamp
}
return nil
} | [
"func",
"(",
"eb",
"*",
"eventBuffer",
")",
"QueueEvent",
"(",
"event",
"*",
"lpEvent",
")",
"error",
"{",
"if",
"event",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// Cull our buffer if we're at max capacity",
"if",
"eb",
".",
"List",
".",
"Len",
"(",
")",
">=",
"eb",
".",
"MaxBufferSize",
"{",
"oldestEvent",
":=",
"eb",
".",
"List",
".",
"Back",
"(",
")",
"\n",
"if",
"oldestEvent",
"!=",
"nil",
"{",
"eb",
".",
"List",
".",
"Remove",
"(",
"oldestEvent",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// Add event to front of our list",
"eb",
".",
"List",
".",
"PushFront",
"(",
"event",
")",
"\n",
"// Update oldestEventTime with the time of our least recent event (at back)",
"// keeping track of this allows for more efficient event TTL expiration purges",
"if",
"lastElement",
":=",
"eb",
".",
"List",
".",
"Back",
"(",
")",
";",
"lastElement",
"!=",
"nil",
"{",
"lastEvent",
",",
"ok",
":=",
"lastElement",
".",
"Value",
".",
"(",
"*",
"lpEvent",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"eb",
".",
"oldestEventTime",
"=",
"lastEvent",
".",
"Timestamp",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // QueueEvent adds a new longpoll Event to the front of our buffer and removes
// the oldest event from the back of the buffer if we're already at maximum
// capacity. | [
"QueueEvent",
"adds",
"a",
"new",
"longpoll",
"Event",
"to",
"the",
"front",
"of",
"our",
"buffer",
"and",
"removes",
"the",
"oldest",
"event",
"from",
"the",
"back",
"of",
"the",
"buffer",
"if",
"we",
"re",
"already",
"at",
"maximum",
"capacity",
"."
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/events.go#L51-L74 |
10,129 | jcuga/golongpoll | longpoll.go | getLongPollSubscriptionHandler | func getLongPollSubscriptionHandler(maxTimeoutSeconds int, subscriptionRequests chan clientSubscription,
clientTimeouts chan<- clientCategoryPair, loggingEnabled bool) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
timeout, err := strconv.Atoi(r.URL.Query().Get("timeout"))
if loggingEnabled {
log.Println("Handling HTTP request at ", r.URL)
}
// We are going to return json no matter what:
w.Header().Set("Content-Type", "application/json")
// Don't cache response:
w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate") // HTTP 1.1.
w.Header().Set("Pragma", "no-cache") // HTTP 1.0.
w.Header().Set("Expires", "0") // Proxies.
if err != nil || timeout > maxTimeoutSeconds || timeout < 1 {
if loggingEnabled {
log.Printf("Error: Invalid timeout param. Must be 1-%d. Got: %q.\n",
maxTimeoutSeconds, r.URL.Query().Get("timeout"))
}
io.WriteString(w, fmt.Sprintf("{\"error\": \"Invalid timeout arg. Must be 1-%d.\"}", maxTimeoutSeconds))
return
}
category := r.URL.Query().Get("category")
if len(category) == 0 || len(category) > 1024 {
if loggingEnabled {
log.Printf("Error: Invalid subscription category, must be 1-1024 characters long.\n")
}
io.WriteString(w, "{\"error\": \"Invalid subscription category, must be 1-1024 characters long.\"}")
return
}
// Default to only looking for current events
lastEventTime := time.Now()
// since_time is string of milliseconds since epoch
lastEventTimeParam := r.URL.Query().Get("since_time")
if len(lastEventTimeParam) > 0 {
// Client is requesting any event from given timestamp
// parse time
var parseError error
lastEventTime, parseError = millisecondStringToTime(lastEventTimeParam)
if parseError != nil {
if loggingEnabled {
log.Printf("Error parsing last_event_time arg. Parm Value: %s, Error: %s.\n",
lastEventTimeParam, err)
}
io.WriteString(w, "{\"error\": \"Invalid last_event_time arg.\"}")
return
}
}
subscription, err := newclientSubscription(category, lastEventTime)
if err != nil {
if loggingEnabled {
log.Printf("Error creating new Subscription: %s.\n", err)
}
io.WriteString(w, "{\"error\": \"Error creating new Subscription.\"}")
return
}
subscriptionRequests <- *subscription
// Listens for connection close and un-register subscription in the
// event that a client crashes or the connection goes down. We don't
// need to wait around to fulfill a subscription if no one is going to
// receive it
disconnectNotify := w.(http.CloseNotifier).CloseNotify()
select {
case <-time.After(time.Duration(timeout) * time.Second):
// Lets the subscription manager know it can discard this request's
// channel.
clientTimeouts <- subscription.clientCategoryPair
timeout_resp := makeTimeoutResponse(time.Now())
if jsonData, err := json.Marshal(timeout_resp); err == nil {
io.WriteString(w, string(jsonData))
} else {
io.WriteString(w, "{\"error\": \"json marshaller failed\"}")
}
case events := <-subscription.Events:
// Consume event. Subscription manager will automatically discard
// this client's channel upon sending event
// NOTE: event is actually []Event
if jsonData, err := json.Marshal(eventResponse{&events}); err == nil {
io.WriteString(w, string(jsonData))
} else {
io.WriteString(w, "{\"error\": \"json marshaller failed\"}")
}
case <-disconnectNotify:
// Client connection closed before any events occurred and before
// the timeout was exceeded. Tell manager to forget about this
// client.
clientTimeouts <- subscription.clientCategoryPair
}
}
} | go | func getLongPollSubscriptionHandler(maxTimeoutSeconds int, subscriptionRequests chan clientSubscription,
clientTimeouts chan<- clientCategoryPair, loggingEnabled bool) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
timeout, err := strconv.Atoi(r.URL.Query().Get("timeout"))
if loggingEnabled {
log.Println("Handling HTTP request at ", r.URL)
}
// We are going to return json no matter what:
w.Header().Set("Content-Type", "application/json")
// Don't cache response:
w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate") // HTTP 1.1.
w.Header().Set("Pragma", "no-cache") // HTTP 1.0.
w.Header().Set("Expires", "0") // Proxies.
if err != nil || timeout > maxTimeoutSeconds || timeout < 1 {
if loggingEnabled {
log.Printf("Error: Invalid timeout param. Must be 1-%d. Got: %q.\n",
maxTimeoutSeconds, r.URL.Query().Get("timeout"))
}
io.WriteString(w, fmt.Sprintf("{\"error\": \"Invalid timeout arg. Must be 1-%d.\"}", maxTimeoutSeconds))
return
}
category := r.URL.Query().Get("category")
if len(category) == 0 || len(category) > 1024 {
if loggingEnabled {
log.Printf("Error: Invalid subscription category, must be 1-1024 characters long.\n")
}
io.WriteString(w, "{\"error\": \"Invalid subscription category, must be 1-1024 characters long.\"}")
return
}
// Default to only looking for current events
lastEventTime := time.Now()
// since_time is string of milliseconds since epoch
lastEventTimeParam := r.URL.Query().Get("since_time")
if len(lastEventTimeParam) > 0 {
// Client is requesting any event from given timestamp
// parse time
var parseError error
lastEventTime, parseError = millisecondStringToTime(lastEventTimeParam)
if parseError != nil {
if loggingEnabled {
log.Printf("Error parsing last_event_time arg. Parm Value: %s, Error: %s.\n",
lastEventTimeParam, err)
}
io.WriteString(w, "{\"error\": \"Invalid last_event_time arg.\"}")
return
}
}
subscription, err := newclientSubscription(category, lastEventTime)
if err != nil {
if loggingEnabled {
log.Printf("Error creating new Subscription: %s.\n", err)
}
io.WriteString(w, "{\"error\": \"Error creating new Subscription.\"}")
return
}
subscriptionRequests <- *subscription
// Listens for connection close and un-register subscription in the
// event that a client crashes or the connection goes down. We don't
// need to wait around to fulfill a subscription if no one is going to
// receive it
disconnectNotify := w.(http.CloseNotifier).CloseNotify()
select {
case <-time.After(time.Duration(timeout) * time.Second):
// Lets the subscription manager know it can discard this request's
// channel.
clientTimeouts <- subscription.clientCategoryPair
timeout_resp := makeTimeoutResponse(time.Now())
if jsonData, err := json.Marshal(timeout_resp); err == nil {
io.WriteString(w, string(jsonData))
} else {
io.WriteString(w, "{\"error\": \"json marshaller failed\"}")
}
case events := <-subscription.Events:
// Consume event. Subscription manager will automatically discard
// this client's channel upon sending event
// NOTE: event is actually []Event
if jsonData, err := json.Marshal(eventResponse{&events}); err == nil {
io.WriteString(w, string(jsonData))
} else {
io.WriteString(w, "{\"error\": \"json marshaller failed\"}")
}
case <-disconnectNotify:
// Client connection closed before any events occurred and before
// the timeout was exceeded. Tell manager to forget about this
// client.
clientTimeouts <- subscription.clientCategoryPair
}
}
} | [
"func",
"getLongPollSubscriptionHandler",
"(",
"maxTimeoutSeconds",
"int",
",",
"subscriptionRequests",
"chan",
"clientSubscription",
",",
"clientTimeouts",
"chan",
"<-",
"clientCategoryPair",
",",
"loggingEnabled",
"bool",
")",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"timeout",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"loggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"r",
".",
"URL",
")",
"\n",
"}",
"\n",
"// We are going to return json no matter what:",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"// Don't cache response:",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"// HTTP 1.1.",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"// HTTP 1.0.",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"// Proxies.",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"timeout",
">",
"maxTimeoutSeconds",
"||",
"timeout",
"<",
"1",
"{",
"if",
"loggingEnabled",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"maxTimeoutSeconds",
",",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"io",
".",
"WriteString",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
",",
"maxTimeoutSeconds",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"category",
":=",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"category",
")",
"==",
"0",
"||",
"len",
"(",
"category",
")",
">",
"1024",
"{",
"if",
"loggingEnabled",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"// Default to only looking for current events",
"lastEventTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"// since_time is string of milliseconds since epoch",
"lastEventTimeParam",
":=",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"lastEventTimeParam",
")",
">",
"0",
"{",
"// Client is requesting any event from given timestamp",
"// parse time",
"var",
"parseError",
"error",
"\n",
"lastEventTime",
",",
"parseError",
"=",
"millisecondStringToTime",
"(",
"lastEventTimeParam",
")",
"\n",
"if",
"parseError",
"!=",
"nil",
"{",
"if",
"loggingEnabled",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"lastEventTimeParam",
",",
"err",
")",
"\n",
"}",
"\n",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"subscription",
",",
"err",
":=",
"newclientSubscription",
"(",
"category",
",",
"lastEventTime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"loggingEnabled",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"subscriptionRequests",
"<-",
"*",
"subscription",
"\n",
"// Listens for connection close and un-register subscription in the",
"// event that a client crashes or the connection goes down. We don't",
"// need to wait around to fulfill a subscription if no one is going to",
"// receive it",
"disconnectNotify",
":=",
"w",
".",
"(",
"http",
".",
"CloseNotifier",
")",
".",
"CloseNotify",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Duration",
"(",
"timeout",
")",
"*",
"time",
".",
"Second",
")",
":",
"// Lets the subscription manager know it can discard this request's",
"// channel.",
"clientTimeouts",
"<-",
"subscription",
".",
"clientCategoryPair",
"\n",
"timeout_resp",
":=",
"makeTimeoutResponse",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"if",
"jsonData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"timeout_resp",
")",
";",
"err",
"==",
"nil",
"{",
"io",
".",
"WriteString",
"(",
"w",
",",
"string",
"(",
"jsonData",
")",
")",
"\n",
"}",
"else",
"{",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"}",
"\n",
"case",
"events",
":=",
"<-",
"subscription",
".",
"Events",
":",
"// Consume event. Subscription manager will automatically discard",
"// this client's channel upon sending event",
"// NOTE: event is actually []Event",
"if",
"jsonData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"eventResponse",
"{",
"&",
"events",
"}",
")",
";",
"err",
"==",
"nil",
"{",
"io",
".",
"WriteString",
"(",
"w",
",",
"string",
"(",
"jsonData",
")",
")",
"\n",
"}",
"else",
"{",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"}",
"\n",
"case",
"<-",
"disconnectNotify",
":",
"// Client connection closed before any events occurred and before",
"// the timeout was exceeded. Tell manager to forget about this",
"// client.",
"clientTimeouts",
"<-",
"subscription",
".",
"clientCategoryPair",
"\n",
"}",
"\n",
"}",
"\n",
"}"
]
| // get web handler that has closure around sub chanel and clientTimeout channnel | [
"get",
"web",
"handler",
"that",
"has",
"closure",
"around",
"sub",
"chanel",
"and",
"clientTimeout",
"channnel"
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/longpoll.go#L213-L301 |
10,130 | jcuga/golongpoll | longpoll.go | run | func (sm *subscriptionManager) run() error {
if sm.LoggingEnabled {
log.Println("SubscriptionManager: Starting run.")
}
for {
// NOTE: we check to see if its time to purge old buffers whenever
// something happens or a period of inactivity has occurred.
// An alternative would be to have another goroutine with a
// select case time.After() but then you'd have concurrency issues
// with access to the sm.SubEventBuffer and sm.bufferPriorityQueue objs
// So instead of introducing mutexes we have this uglier manual time check calls
select {
case newClient := <-sm.clientSubscriptions:
sm.handleNewClient(&newClient)
sm.seeIfTimeToPurgeStaleCategories()
case disconnected := <-sm.ClientTimeouts:
sm.handleClientDisconnect(&disconnected)
sm.seeIfTimeToPurgeStaleCategories()
case event := <-sm.Events:
sm.handleNewEvent(&event)
sm.seeIfTimeToPurgeStaleCategories()
case <-time.After(time.Duration(5) * time.Second):
sm.seeIfTimeToPurgeStaleCategories()
case _ = <-sm.Quit:
if sm.LoggingEnabled {
log.Println("SubscriptionManager: received quit signal, stopping.")
}
// break out of our infinite loop/select
return nil
}
}
} | go | func (sm *subscriptionManager) run() error {
if sm.LoggingEnabled {
log.Println("SubscriptionManager: Starting run.")
}
for {
// NOTE: we check to see if its time to purge old buffers whenever
// something happens or a period of inactivity has occurred.
// An alternative would be to have another goroutine with a
// select case time.After() but then you'd have concurrency issues
// with access to the sm.SubEventBuffer and sm.bufferPriorityQueue objs
// So instead of introducing mutexes we have this uglier manual time check calls
select {
case newClient := <-sm.clientSubscriptions:
sm.handleNewClient(&newClient)
sm.seeIfTimeToPurgeStaleCategories()
case disconnected := <-sm.ClientTimeouts:
sm.handleClientDisconnect(&disconnected)
sm.seeIfTimeToPurgeStaleCategories()
case event := <-sm.Events:
sm.handleNewEvent(&event)
sm.seeIfTimeToPurgeStaleCategories()
case <-time.After(time.Duration(5) * time.Second):
sm.seeIfTimeToPurgeStaleCategories()
case _ = <-sm.Quit:
if sm.LoggingEnabled {
log.Println("SubscriptionManager: received quit signal, stopping.")
}
// break out of our infinite loop/select
return nil
}
}
} | [
"func",
"(",
"sm",
"*",
"subscriptionManager",
")",
"run",
"(",
")",
"error",
"{",
"if",
"sm",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"{",
"// NOTE: we check to see if its time to purge old buffers whenever",
"// something happens or a period of inactivity has occurred.",
"// An alternative would be to have another goroutine with a",
"// select case time.After() but then you'd have concurrency issues",
"// with access to the sm.SubEventBuffer and sm.bufferPriorityQueue objs",
"// So instead of introducing mutexes we have this uglier manual time check calls",
"select",
"{",
"case",
"newClient",
":=",
"<-",
"sm",
".",
"clientSubscriptions",
":",
"sm",
".",
"handleNewClient",
"(",
"&",
"newClient",
")",
"\n",
"sm",
".",
"seeIfTimeToPurgeStaleCategories",
"(",
")",
"\n",
"case",
"disconnected",
":=",
"<-",
"sm",
".",
"ClientTimeouts",
":",
"sm",
".",
"handleClientDisconnect",
"(",
"&",
"disconnected",
")",
"\n",
"sm",
".",
"seeIfTimeToPurgeStaleCategories",
"(",
")",
"\n",
"case",
"event",
":=",
"<-",
"sm",
".",
"Events",
":",
"sm",
".",
"handleNewEvent",
"(",
"&",
"event",
")",
"\n",
"sm",
".",
"seeIfTimeToPurgeStaleCategories",
"(",
")",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Duration",
"(",
"5",
")",
"*",
"time",
".",
"Second",
")",
":",
"sm",
".",
"seeIfTimeToPurgeStaleCategories",
"(",
")",
"\n",
"case",
"_",
"=",
"<-",
"sm",
".",
"Quit",
":",
"if",
"sm",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// break out of our infinite loop/select",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
]
| // This should be fired off in its own goroutine | [
"This",
"should",
"be",
"fired",
"off",
"in",
"its",
"own",
"goroutine"
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/longpoll.go#L350-L381 |
10,131 | jcuga/golongpoll | go-client/glpclient/client.go | Start | func (c *Client) Start() {
u := c.url
if c.LoggingEnabled {
log.Println("Now observing changes on", u.String())
}
atomic.AddUint64(&(c.runID), 1)
currentRunID := atomic.LoadUint64(&(c.runID))
go func(runID uint64, u *url.URL) {
since := time.Now().Unix() * 1000
for {
pr, err := c.fetchEvents(since)
if err != nil {
if c.LoggingEnabled {
log.Println(err)
log.Printf("Reattempting to connect to %s in %d seconds", u.String(), c.Reattempt)
}
time.Sleep(c.Reattempt)
continue
}
// We check that its still the same runID as when this goroutine was started
clientRunID := atomic.LoadUint64(&(c.runID))
if clientRunID != runID {
if c.LoggingEnabled {
log.Printf("Client on URL %s has been stopped, not sending events", u.String())
}
return
}
if len(pr.Events) > 0 {
if c.LoggingEnabled {
log.Println("Got", len(pr.Events), "event(s) from URL", u.String())
}
for _, event := range pr.Events {
since = event.Timestamp
c.EventsChan <- event
}
} else {
// Only push timestamp forward if its greater than the last we checked
if pr.Timestamp > since {
since = pr.Timestamp
}
}
}
}(currentRunID, u)
} | go | func (c *Client) Start() {
u := c.url
if c.LoggingEnabled {
log.Println("Now observing changes on", u.String())
}
atomic.AddUint64(&(c.runID), 1)
currentRunID := atomic.LoadUint64(&(c.runID))
go func(runID uint64, u *url.URL) {
since := time.Now().Unix() * 1000
for {
pr, err := c.fetchEvents(since)
if err != nil {
if c.LoggingEnabled {
log.Println(err)
log.Printf("Reattempting to connect to %s in %d seconds", u.String(), c.Reattempt)
}
time.Sleep(c.Reattempt)
continue
}
// We check that its still the same runID as when this goroutine was started
clientRunID := atomic.LoadUint64(&(c.runID))
if clientRunID != runID {
if c.LoggingEnabled {
log.Printf("Client on URL %s has been stopped, not sending events", u.String())
}
return
}
if len(pr.Events) > 0 {
if c.LoggingEnabled {
log.Println("Got", len(pr.Events), "event(s) from URL", u.String())
}
for _, event := range pr.Events {
since = event.Timestamp
c.EventsChan <- event
}
} else {
// Only push timestamp forward if its greater than the last we checked
if pr.Timestamp > since {
since = pr.Timestamp
}
}
}
}(currentRunID, u)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Start",
"(",
")",
"{",
"u",
":=",
"c",
".",
"url",
"\n",
"if",
"c",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"atomic",
".",
"AddUint64",
"(",
"&",
"(",
"c",
".",
"runID",
")",
",",
"1",
")",
"\n",
"currentRunID",
":=",
"atomic",
".",
"LoadUint64",
"(",
"&",
"(",
"c",
".",
"runID",
")",
")",
"\n\n",
"go",
"func",
"(",
"runID",
"uint64",
",",
"u",
"*",
"url",
".",
"URL",
")",
"{",
"since",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"*",
"1000",
"\n",
"for",
"{",
"pr",
",",
"err",
":=",
"c",
".",
"fetchEvents",
"(",
"since",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"c",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"err",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
",",
"c",
".",
"Reattempt",
")",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"c",
".",
"Reattempt",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// We check that its still the same runID as when this goroutine was started",
"clientRunID",
":=",
"atomic",
".",
"LoadUint64",
"(",
"&",
"(",
"c",
".",
"runID",
")",
")",
"\n",
"if",
"clientRunID",
"!=",
"runID",
"{",
"if",
"c",
".",
"LoggingEnabled",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"pr",
".",
"Events",
")",
">",
"0",
"{",
"if",
"c",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"len",
"(",
"pr",
".",
"Events",
")",
",",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"event",
":=",
"range",
"pr",
".",
"Events",
"{",
"since",
"=",
"event",
".",
"Timestamp",
"\n",
"c",
".",
"EventsChan",
"<-",
"event",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Only push timestamp forward if its greater than the last we checked",
"if",
"pr",
".",
"Timestamp",
">",
"since",
"{",
"since",
"=",
"pr",
".",
"Timestamp",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
"currentRunID",
",",
"u",
")",
"\n",
"}"
]
| // Start the polling of the events on the URL defined in the client
// Will send the events in the EventsChan of the client | [
"Start",
"the",
"polling",
"of",
"the",
"events",
"on",
"the",
"URL",
"defined",
"in",
"the",
"client",
"Will",
"send",
"the",
"events",
"in",
"the",
"EventsChan",
"of",
"the",
"client"
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/go-client/glpclient/client.go#L72-L120 |
10,132 | jcuga/golongpoll | go-client/glpclient/client.go | fetchEvents | func (c Client) fetchEvents(since int64) (PollResponse, error) {
u := c.url
if c.LoggingEnabled {
log.Println("Checking for changes events since", since, "on URL", u.String())
}
query := u.Query()
query.Set("category", c.category)
query.Set("since_time", fmt.Sprintf("%d", since))
query.Set("timeout", fmt.Sprintf("%d", c.Timeout))
u.RawQuery = query.Encode()
req, _ := http.NewRequest("GET", u.String(), nil)
if c.BasicAuthUsername != "" && c.BasicAuthPassword != "" {
req.SetBasicAuth(c.BasicAuthUsername, c.BasicAuthPassword)
}
resp, err := c.HttpClient.Do(req)
if err != nil {
msg := fmt.Sprintf("Error while connecting to %s to observe changes. Error was: %s", u, err)
return PollResponse{}, errors.New(msg)
}
if resp.StatusCode != http.StatusOK {
msg := fmt.Sprintf("Wrong status code received from longpoll server: %d", resp.StatusCode)
return PollResponse{}, errors.New(msg)
}
decoder := json.NewDecoder(resp.Body)
defer resp.Body.Close()
var pr PollResponse
err = decoder.Decode(&pr)
if err != nil {
if c.LoggingEnabled {
log.Println("Error while decoding poll response: %s", err)
}
return PollResponse{}, err
}
return pr, nil
} | go | func (c Client) fetchEvents(since int64) (PollResponse, error) {
u := c.url
if c.LoggingEnabled {
log.Println("Checking for changes events since", since, "on URL", u.String())
}
query := u.Query()
query.Set("category", c.category)
query.Set("since_time", fmt.Sprintf("%d", since))
query.Set("timeout", fmt.Sprintf("%d", c.Timeout))
u.RawQuery = query.Encode()
req, _ := http.NewRequest("GET", u.String(), nil)
if c.BasicAuthUsername != "" && c.BasicAuthPassword != "" {
req.SetBasicAuth(c.BasicAuthUsername, c.BasicAuthPassword)
}
resp, err := c.HttpClient.Do(req)
if err != nil {
msg := fmt.Sprintf("Error while connecting to %s to observe changes. Error was: %s", u, err)
return PollResponse{}, errors.New(msg)
}
if resp.StatusCode != http.StatusOK {
msg := fmt.Sprintf("Wrong status code received from longpoll server: %d", resp.StatusCode)
return PollResponse{}, errors.New(msg)
}
decoder := json.NewDecoder(resp.Body)
defer resp.Body.Close()
var pr PollResponse
err = decoder.Decode(&pr)
if err != nil {
if c.LoggingEnabled {
log.Println("Error while decoding poll response: %s", err)
}
return PollResponse{}, err
}
return pr, nil
} | [
"func",
"(",
"c",
"Client",
")",
"fetchEvents",
"(",
"since",
"int64",
")",
"(",
"PollResponse",
",",
"error",
")",
"{",
"u",
":=",
"c",
".",
"url",
"\n",
"if",
"c",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"since",
",",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"query",
":=",
"u",
".",
"Query",
"(",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"c",
".",
"category",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"since",
")",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"Timeout",
")",
")",
"\n",
"u",
".",
"RawQuery",
"=",
"query",
".",
"Encode",
"(",
")",
"\n\n",
"req",
",",
"_",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"c",
".",
"BasicAuthUsername",
"!=",
"\"",
"\"",
"&&",
"c",
".",
"BasicAuthPassword",
"!=",
"\"",
"\"",
"{",
"req",
".",
"SetBasicAuth",
"(",
"c",
".",
"BasicAuthUsername",
",",
"c",
".",
"BasicAuthPassword",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"HttpClient",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"u",
",",
"err",
")",
"\n",
"return",
"PollResponse",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"msg",
")",
"\n",
"}",
"\n\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"return",
"PollResponse",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"msg",
")",
"\n",
"}",
"\n\n",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"var",
"pr",
"PollResponse",
"\n",
"err",
"=",
"decoder",
".",
"Decode",
"(",
"&",
"pr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"c",
".",
"LoggingEnabled",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"PollResponse",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"pr",
",",
"nil",
"\n",
"}"
]
| // Call the longpoll server to get the events since a specific timestamp | [
"Call",
"the",
"longpoll",
"server",
"to",
"get",
"the",
"events",
"since",
"a",
"specific",
"timestamp"
]
| 939e3befd837556f948f5deff4f387c07cfe9df8 | https://github.com/jcuga/golongpoll/blob/939e3befd837556f948f5deff4f387c07cfe9df8/go-client/glpclient/client.go#L128-L169 |
10,133 | sethvargo/go-password | password/generate.go | NewGenerator | func NewGenerator(i *GeneratorInput) (*Generator, error) {
if i == nil {
i = new(GeneratorInput)
}
g := &Generator{
lowerLetters: i.LowerLetters,
upperLetters: i.UpperLetters,
digits: i.Digits,
symbols: i.Symbols,
}
if g.lowerLetters == "" {
g.lowerLetters = LowerLetters
}
if g.upperLetters == "" {
g.upperLetters = UpperLetters
}
if g.digits == "" {
g.digits = Digits
}
if g.symbols == "" {
g.symbols = Symbols
}
return g, nil
} | go | func NewGenerator(i *GeneratorInput) (*Generator, error) {
if i == nil {
i = new(GeneratorInput)
}
g := &Generator{
lowerLetters: i.LowerLetters,
upperLetters: i.UpperLetters,
digits: i.Digits,
symbols: i.Symbols,
}
if g.lowerLetters == "" {
g.lowerLetters = LowerLetters
}
if g.upperLetters == "" {
g.upperLetters = UpperLetters
}
if g.digits == "" {
g.digits = Digits
}
if g.symbols == "" {
g.symbols = Symbols
}
return g, nil
} | [
"func",
"NewGenerator",
"(",
"i",
"*",
"GeneratorInput",
")",
"(",
"*",
"Generator",
",",
"error",
")",
"{",
"if",
"i",
"==",
"nil",
"{",
"i",
"=",
"new",
"(",
"GeneratorInput",
")",
"\n",
"}",
"\n\n",
"g",
":=",
"&",
"Generator",
"{",
"lowerLetters",
":",
"i",
".",
"LowerLetters",
",",
"upperLetters",
":",
"i",
".",
"UpperLetters",
",",
"digits",
":",
"i",
".",
"Digits",
",",
"symbols",
":",
"i",
".",
"Symbols",
",",
"}",
"\n\n",
"if",
"g",
".",
"lowerLetters",
"==",
"\"",
"\"",
"{",
"g",
".",
"lowerLetters",
"=",
"LowerLetters",
"\n",
"}",
"\n\n",
"if",
"g",
".",
"upperLetters",
"==",
"\"",
"\"",
"{",
"g",
".",
"upperLetters",
"=",
"UpperLetters",
"\n",
"}",
"\n\n",
"if",
"g",
".",
"digits",
"==",
"\"",
"\"",
"{",
"g",
".",
"digits",
"=",
"Digits",
"\n",
"}",
"\n\n",
"if",
"g",
".",
"symbols",
"==",
"\"",
"\"",
"{",
"g",
".",
"symbols",
"=",
"Symbols",
"\n",
"}",
"\n\n",
"return",
"g",
",",
"nil",
"\n",
"}"
]
| // NewGenerator creates a new Generator from the specified configuration. If no
// input is given, all the default values are used. This function is safe for
// concurrent use. | [
"NewGenerator",
"creates",
"a",
"new",
"Generator",
"from",
"the",
"specified",
"configuration",
".",
"If",
"no",
"input",
"is",
"given",
"all",
"the",
"default",
"values",
"are",
"used",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"use",
"."
]
| 68ac5879751a7105834296859f8c1bf70b064675 | https://github.com/sethvargo/go-password/blob/68ac5879751a7105834296859f8c1bf70b064675/password/generate.go#L72-L101 |
10,134 | sethvargo/go-password | password/generate.go | Generate | func (g *Generator) Generate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) (string, error) {
letters := g.lowerLetters
if !noUpper {
letters += g.upperLetters
}
chars := length - numDigits - numSymbols
if chars < 0 {
return "", ErrExceedsTotalLength
}
if !allowRepeat && chars > len(letters) {
return "", ErrLettersExceedsAvailable
}
if !allowRepeat && numDigits > len(g.digits) {
return "", ErrDigitsExceedsAvailable
}
if !allowRepeat && numSymbols > len(g.symbols) {
return "", ErrSymbolsExceedsAvailable
}
var result string
// Characters
for i := 0; i < chars; i++ {
ch, err := randomElement(letters)
if err != nil {
return "", err
}
if !allowRepeat && strings.Contains(result, ch) {
i--
continue
}
result, err = randomInsert(result, ch)
if err != nil {
return "", err
}
}
// Digits
for i := 0; i < numDigits; i++ {
d, err := randomElement(g.digits)
if err != nil {
return "", err
}
if !allowRepeat && strings.Contains(result, d) {
i--
continue
}
result, err = randomInsert(result, d)
if err != nil {
return "", err
}
}
// Symbols
for i := 0; i < numSymbols; i++ {
sym, err := randomElement(g.symbols)
if err != nil {
return "", err
}
if !allowRepeat && strings.Contains(result, sym) {
i--
continue
}
result, err = randomInsert(result, sym)
if err != nil {
return "", err
}
}
return result, nil
} | go | func (g *Generator) Generate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) (string, error) {
letters := g.lowerLetters
if !noUpper {
letters += g.upperLetters
}
chars := length - numDigits - numSymbols
if chars < 0 {
return "", ErrExceedsTotalLength
}
if !allowRepeat && chars > len(letters) {
return "", ErrLettersExceedsAvailable
}
if !allowRepeat && numDigits > len(g.digits) {
return "", ErrDigitsExceedsAvailable
}
if !allowRepeat && numSymbols > len(g.symbols) {
return "", ErrSymbolsExceedsAvailable
}
var result string
// Characters
for i := 0; i < chars; i++ {
ch, err := randomElement(letters)
if err != nil {
return "", err
}
if !allowRepeat && strings.Contains(result, ch) {
i--
continue
}
result, err = randomInsert(result, ch)
if err != nil {
return "", err
}
}
// Digits
for i := 0; i < numDigits; i++ {
d, err := randomElement(g.digits)
if err != nil {
return "", err
}
if !allowRepeat && strings.Contains(result, d) {
i--
continue
}
result, err = randomInsert(result, d)
if err != nil {
return "", err
}
}
// Symbols
for i := 0; i < numSymbols; i++ {
sym, err := randomElement(g.symbols)
if err != nil {
return "", err
}
if !allowRepeat && strings.Contains(result, sym) {
i--
continue
}
result, err = randomInsert(result, sym)
if err != nil {
return "", err
}
}
return result, nil
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"Generate",
"(",
"length",
",",
"numDigits",
",",
"numSymbols",
"int",
",",
"noUpper",
",",
"allowRepeat",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"letters",
":=",
"g",
".",
"lowerLetters",
"\n",
"if",
"!",
"noUpper",
"{",
"letters",
"+=",
"g",
".",
"upperLetters",
"\n",
"}",
"\n\n",
"chars",
":=",
"length",
"-",
"numDigits",
"-",
"numSymbols",
"\n",
"if",
"chars",
"<",
"0",
"{",
"return",
"\"",
"\"",
",",
"ErrExceedsTotalLength",
"\n",
"}",
"\n\n",
"if",
"!",
"allowRepeat",
"&&",
"chars",
">",
"len",
"(",
"letters",
")",
"{",
"return",
"\"",
"\"",
",",
"ErrLettersExceedsAvailable",
"\n",
"}",
"\n\n",
"if",
"!",
"allowRepeat",
"&&",
"numDigits",
">",
"len",
"(",
"g",
".",
"digits",
")",
"{",
"return",
"\"",
"\"",
",",
"ErrDigitsExceedsAvailable",
"\n",
"}",
"\n\n",
"if",
"!",
"allowRepeat",
"&&",
"numSymbols",
">",
"len",
"(",
"g",
".",
"symbols",
")",
"{",
"return",
"\"",
"\"",
",",
"ErrSymbolsExceedsAvailable",
"\n",
"}",
"\n\n",
"var",
"result",
"string",
"\n\n",
"// Characters",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"chars",
";",
"i",
"++",
"{",
"ch",
",",
"err",
":=",
"randomElement",
"(",
"letters",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"allowRepeat",
"&&",
"strings",
".",
"Contains",
"(",
"result",
",",
"ch",
")",
"{",
"i",
"--",
"\n",
"continue",
"\n",
"}",
"\n\n",
"result",
",",
"err",
"=",
"randomInsert",
"(",
"result",
",",
"ch",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Digits",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numDigits",
";",
"i",
"++",
"{",
"d",
",",
"err",
":=",
"randomElement",
"(",
"g",
".",
"digits",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"allowRepeat",
"&&",
"strings",
".",
"Contains",
"(",
"result",
",",
"d",
")",
"{",
"i",
"--",
"\n",
"continue",
"\n",
"}",
"\n\n",
"result",
",",
"err",
"=",
"randomInsert",
"(",
"result",
",",
"d",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Symbols",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numSymbols",
";",
"i",
"++",
"{",
"sym",
",",
"err",
":=",
"randomElement",
"(",
"g",
".",
"symbols",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"allowRepeat",
"&&",
"strings",
".",
"Contains",
"(",
"result",
",",
"sym",
")",
"{",
"i",
"--",
"\n",
"continue",
"\n",
"}",
"\n\n",
"result",
",",
"err",
"=",
"randomInsert",
"(",
"result",
",",
"sym",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
]
| // Generate generates a password with the given requirements. length is the
// total number of characters in the password. numDigits is the number of digits
// to include in the result. numSymbols is the number of symbols to include in
// the result. noUpper excludes uppercase letters from the results. allowRepeat
// allows characters to repeat.
//
// The algorithm is fast, but it's not designed to be performant; it favors
// entropy over speed. This function is safe for concurrent use. | [
"Generate",
"generates",
"a",
"password",
"with",
"the",
"given",
"requirements",
".",
"length",
"is",
"the",
"total",
"number",
"of",
"characters",
"in",
"the",
"password",
".",
"numDigits",
"is",
"the",
"number",
"of",
"digits",
"to",
"include",
"in",
"the",
"result",
".",
"numSymbols",
"is",
"the",
"number",
"of",
"symbols",
"to",
"include",
"in",
"the",
"result",
".",
"noUpper",
"excludes",
"uppercase",
"letters",
"from",
"the",
"results",
".",
"allowRepeat",
"allows",
"characters",
"to",
"repeat",
".",
"The",
"algorithm",
"is",
"fast",
"but",
"it",
"s",
"not",
"designed",
"to",
"be",
"performant",
";",
"it",
"favors",
"entropy",
"over",
"speed",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"use",
"."
]
| 68ac5879751a7105834296859f8c1bf70b064675 | https://github.com/sethvargo/go-password/blob/68ac5879751a7105834296859f8c1bf70b064675/password/generate.go#L111-L191 |
10,135 | sethvargo/go-password | password/generate.go | MustGenerate | func (g *Generator) MustGenerate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) string {
res, err := g.Generate(length, numDigits, numSymbols, noUpper, allowRepeat)
if err != nil {
panic(err)
}
return res
} | go | func (g *Generator) MustGenerate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) string {
res, err := g.Generate(length, numDigits, numSymbols, noUpper, allowRepeat)
if err != nil {
panic(err)
}
return res
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"MustGenerate",
"(",
"length",
",",
"numDigits",
",",
"numSymbols",
"int",
",",
"noUpper",
",",
"allowRepeat",
"bool",
")",
"string",
"{",
"res",
",",
"err",
":=",
"g",
".",
"Generate",
"(",
"length",
",",
"numDigits",
",",
"numSymbols",
",",
"noUpper",
",",
"allowRepeat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
]
| // MustGenerate is the same as Generate, but panics on error. | [
"MustGenerate",
"is",
"the",
"same",
"as",
"Generate",
"but",
"panics",
"on",
"error",
"."
]
| 68ac5879751a7105834296859f8c1bf70b064675 | https://github.com/sethvargo/go-password/blob/68ac5879751a7105834296859f8c1bf70b064675/password/generate.go#L194-L200 |
10,136 | sethvargo/go-password | password/generate.go | Generate | func Generate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) (string, error) {
gen, err := NewGenerator(nil)
if err != nil {
return "", err
}
return gen.Generate(length, numDigits, numSymbols, noUpper, allowRepeat)
} | go | func Generate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) (string, error) {
gen, err := NewGenerator(nil)
if err != nil {
return "", err
}
return gen.Generate(length, numDigits, numSymbols, noUpper, allowRepeat)
} | [
"func",
"Generate",
"(",
"length",
",",
"numDigits",
",",
"numSymbols",
"int",
",",
"noUpper",
",",
"allowRepeat",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"gen",
",",
"err",
":=",
"NewGenerator",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"gen",
".",
"Generate",
"(",
"length",
",",
"numDigits",
",",
"numSymbols",
",",
"noUpper",
",",
"allowRepeat",
")",
"\n",
"}"
]
| // Generate is the package shortcut for Generator.Generate. | [
"Generate",
"is",
"the",
"package",
"shortcut",
"for",
"Generator",
".",
"Generate",
"."
]
| 68ac5879751a7105834296859f8c1bf70b064675 | https://github.com/sethvargo/go-password/blob/68ac5879751a7105834296859f8c1bf70b064675/password/generate.go#L203-L210 |
10,137 | sethvargo/go-password | password/generate.go | randomInsert | func randomInsert(s, val string) (string, error) {
if s == "" {
return val, nil
}
n, err := rand.Int(rand.Reader, big.NewInt(int64(len(s)+1)))
if err != nil {
return "", err
}
i := n.Int64()
return s[0:i] + val + s[i:len(s)], nil
} | go | func randomInsert(s, val string) (string, error) {
if s == "" {
return val, nil
}
n, err := rand.Int(rand.Reader, big.NewInt(int64(len(s)+1)))
if err != nil {
return "", err
}
i := n.Int64()
return s[0:i] + val + s[i:len(s)], nil
} | [
"func",
"randomInsert",
"(",
"s",
",",
"val",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"val",
",",
"nil",
"\n",
"}",
"\n\n",
"n",
",",
"err",
":=",
"rand",
".",
"Int",
"(",
"rand",
".",
"Reader",
",",
"big",
".",
"NewInt",
"(",
"int64",
"(",
"len",
"(",
"s",
")",
"+",
"1",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"i",
":=",
"n",
".",
"Int64",
"(",
")",
"\n",
"return",
"s",
"[",
"0",
":",
"i",
"]",
"+",
"val",
"+",
"s",
"[",
"i",
":",
"len",
"(",
"s",
")",
"]",
",",
"nil",
"\n",
"}"
]
| // randomInsert randomly inserts the given value into the given string. | [
"randomInsert",
"randomly",
"inserts",
"the",
"given",
"value",
"into",
"the",
"given",
"string",
"."
]
| 68ac5879751a7105834296859f8c1bf70b064675 | https://github.com/sethvargo/go-password/blob/68ac5879751a7105834296859f8c1bf70b064675/password/generate.go#L222-L233 |
10,138 | sethvargo/go-password | password/generate.go | randomElement | func randomElement(s string) (string, error) {
n, err := rand.Int(rand.Reader, big.NewInt(int64(len(s))))
if err != nil {
return "", err
}
return string(s[n.Int64()]), nil
} | go | func randomElement(s string) (string, error) {
n, err := rand.Int(rand.Reader, big.NewInt(int64(len(s))))
if err != nil {
return "", err
}
return string(s[n.Int64()]), nil
} | [
"func",
"randomElement",
"(",
"s",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"rand",
".",
"Int",
"(",
"rand",
".",
"Reader",
",",
"big",
".",
"NewInt",
"(",
"int64",
"(",
"len",
"(",
"s",
")",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"s",
"[",
"n",
".",
"Int64",
"(",
")",
"]",
")",
",",
"nil",
"\n",
"}"
]
| // randomElement extracts a random element from the given string. | [
"randomElement",
"extracts",
"a",
"random",
"element",
"from",
"the",
"given",
"string",
"."
]
| 68ac5879751a7105834296859f8c1bf70b064675 | https://github.com/sethvargo/go-password/blob/68ac5879751a7105834296859f8c1bf70b064675/password/generate.go#L236-L242 |
10,139 | harlow/kinesis-consumer | examples/consumer/cp-dynamo/main.go | init | func init() {
sock, err := net.Listen("tcp", "localhost:8080")
if err != nil {
log.Printf("net listen error: %v", err)
}
go func() {
fmt.Println("Metrics available at http://localhost:8080/debug/vars")
http.Serve(sock, nil)
}()
} | go | func init() {
sock, err := net.Listen("tcp", "localhost:8080")
if err != nil {
log.Printf("net listen error: %v", err)
}
go func() {
fmt.Println("Metrics available at http://localhost:8080/debug/vars")
http.Serve(sock, nil)
}()
} | [
"func",
"init",
"(",
")",
"{",
"sock",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"http",
".",
"Serve",
"(",
"sock",
",",
"nil",
")",
"\n",
"}",
"(",
")",
"\n",
"}"
]
| // kick off a server for exposing scan metrics | [
"kick",
"off",
"a",
"server",
"for",
"exposing",
"scan",
"metrics"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/examples/consumer/cp-dynamo/main.go#L26-L35 |
10,140 | harlow/kinesis-consumer | examples/consumer/cp-dynamo/main.go | ShouldRetry | func (r *MyRetryer) ShouldRetry(err error) bool {
if awsErr, ok := err.(awserr.Error); ok {
switch awsErr.Code() {
case dynamodb.ErrCodeProvisionedThroughputExceededException, dynamodb.ErrCodeLimitExceededException:
return true
default:
return false
}
}
return false
} | go | func (r *MyRetryer) ShouldRetry(err error) bool {
if awsErr, ok := err.(awserr.Error); ok {
switch awsErr.Code() {
case dynamodb.ErrCodeProvisionedThroughputExceededException, dynamodb.ErrCodeLimitExceededException:
return true
default:
return false
}
}
return false
} | [
"func",
"(",
"r",
"*",
"MyRetryer",
")",
"ShouldRetry",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"awsErr",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"switch",
"awsErr",
".",
"Code",
"(",
")",
"{",
"case",
"dynamodb",
".",
"ErrCodeProvisionedThroughputExceededException",
",",
"dynamodb",
".",
"ErrCodeLimitExceededException",
":",
"return",
"true",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
]
| // ShouldRetry implements custom logic for when a checkpont should retry | [
"ShouldRetry",
"implements",
"custom",
"logic",
"for",
"when",
"a",
"checkpont",
"should",
"retry"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/examples/consumer/cp-dynamo/main.go#L125-L135 |
10,141 | harlow/kinesis-consumer | broker.go | start | func (b *broker) start(ctx context.Context) {
b.findNewShards()
ticker := time.NewTicker(30 * time.Second)
// Note: while ticker is a rather naive approach to this problem,
// it actually simplies a few things. i.e. If we miss a new shard while
// AWS is resharding we'll pick it up max 30 seconds later.
// It might be worth refactoring this flow to allow the consumer to
// to notify the broker when a shard is closed. However, shards don't
// necessarily close at the same time, so we could potentially get a
// thundering heard of notifications from the consumer.
for {
select {
case <-ctx.Done():
ticker.Stop()
return
case <-ticker.C:
b.findNewShards()
}
}
} | go | func (b *broker) start(ctx context.Context) {
b.findNewShards()
ticker := time.NewTicker(30 * time.Second)
// Note: while ticker is a rather naive approach to this problem,
// it actually simplies a few things. i.e. If we miss a new shard while
// AWS is resharding we'll pick it up max 30 seconds later.
// It might be worth refactoring this flow to allow the consumer to
// to notify the broker when a shard is closed. However, shards don't
// necessarily close at the same time, so we could potentially get a
// thundering heard of notifications from the consumer.
for {
select {
case <-ctx.Done():
ticker.Stop()
return
case <-ticker.C:
b.findNewShards()
}
}
} | [
"func",
"(",
"b",
"*",
"broker",
")",
"start",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"b",
".",
"findNewShards",
"(",
")",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"30",
"*",
"time",
".",
"Second",
")",
"\n\n",
"// Note: while ticker is a rather naive approach to this problem,",
"// it actually simplies a few things. i.e. If we miss a new shard while",
"// AWS is resharding we'll pick it up max 30 seconds later.",
"// It might be worth refactoring this flow to allow the consumer to",
"// to notify the broker when a shard is closed. However, shards don't",
"// necessarily close at the same time, so we could potentially get a",
"// thundering heard of notifications from the consumer.",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"return",
"\n",
"case",
"<-",
"ticker",
".",
"C",
":",
"b",
".",
"findNewShards",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
]
| // start is a blocking operation which will loop and attempt to find new
// shards on a regular cadence. | [
"start",
"is",
"a",
"blocking",
"operation",
"which",
"will",
"loop",
"and",
"attempt",
"to",
"find",
"new",
"shards",
"on",
"a",
"regular",
"cadence",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/broker.go#L43-L65 |
10,142 | harlow/kinesis-consumer | broker.go | findNewShards | func (b *broker) findNewShards() {
b.shardMu.Lock()
defer b.shardMu.Unlock()
b.logger.Log("[BROKER]", "fetching shards")
shards, err := b.listShards()
if err != nil {
b.logger.Log("[BROKER]", err)
return
}
for _, shard := range shards {
if _, ok := b.shards[*shard.ShardId]; ok {
continue
}
b.shards[*shard.ShardId] = shard
b.shardc <- shard
}
} | go | func (b *broker) findNewShards() {
b.shardMu.Lock()
defer b.shardMu.Unlock()
b.logger.Log("[BROKER]", "fetching shards")
shards, err := b.listShards()
if err != nil {
b.logger.Log("[BROKER]", err)
return
}
for _, shard := range shards {
if _, ok := b.shards[*shard.ShardId]; ok {
continue
}
b.shards[*shard.ShardId] = shard
b.shardc <- shard
}
} | [
"func",
"(",
"b",
"*",
"broker",
")",
"findNewShards",
"(",
")",
"{",
"b",
".",
"shardMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"shardMu",
".",
"Unlock",
"(",
")",
"\n\n",
"b",
".",
"logger",
".",
"Log",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"shards",
",",
"err",
":=",
"b",
".",
"listShards",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"b",
".",
"logger",
".",
"Log",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"shard",
":=",
"range",
"shards",
"{",
"if",
"_",
",",
"ok",
":=",
"b",
".",
"shards",
"[",
"*",
"shard",
".",
"ShardId",
"]",
";",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"b",
".",
"shards",
"[",
"*",
"shard",
".",
"ShardId",
"]",
"=",
"shard",
"\n",
"b",
".",
"shardc",
"<-",
"shard",
"\n",
"}",
"\n",
"}"
]
| // findNewShards pulls the list of shards from the Kinesis API
// and uses a local cache to determine if we are already processing
// a particular shard. | [
"findNewShards",
"pulls",
"the",
"list",
"of",
"shards",
"from",
"the",
"Kinesis",
"API",
"and",
"uses",
"a",
"local",
"cache",
"to",
"determine",
"if",
"we",
"are",
"already",
"processing",
"a",
"particular",
"shard",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/broker.go#L70-L89 |
10,143 | harlow/kinesis-consumer | broker.go | listShards | func (b *broker) listShards() ([]*kinesis.Shard, error) {
var ss []*kinesis.Shard
var listShardsInput = &kinesis.ListShardsInput{
StreamName: aws.String(b.streamName),
}
for {
resp, err := b.client.ListShards(listShardsInput)
if err != nil {
return nil, fmt.Errorf("ListShards error: %v", err)
}
ss = append(ss, resp.Shards...)
if resp.NextToken == nil {
return ss, nil
}
listShardsInput = &kinesis.ListShardsInput{
NextToken: resp.NextToken,
StreamName: aws.String(b.streamName),
}
}
} | go | func (b *broker) listShards() ([]*kinesis.Shard, error) {
var ss []*kinesis.Shard
var listShardsInput = &kinesis.ListShardsInput{
StreamName: aws.String(b.streamName),
}
for {
resp, err := b.client.ListShards(listShardsInput)
if err != nil {
return nil, fmt.Errorf("ListShards error: %v", err)
}
ss = append(ss, resp.Shards...)
if resp.NextToken == nil {
return ss, nil
}
listShardsInput = &kinesis.ListShardsInput{
NextToken: resp.NextToken,
StreamName: aws.String(b.streamName),
}
}
} | [
"func",
"(",
"b",
"*",
"broker",
")",
"listShards",
"(",
")",
"(",
"[",
"]",
"*",
"kinesis",
".",
"Shard",
",",
"error",
")",
"{",
"var",
"ss",
"[",
"]",
"*",
"kinesis",
".",
"Shard",
"\n",
"var",
"listShardsInput",
"=",
"&",
"kinesis",
".",
"ListShardsInput",
"{",
"StreamName",
":",
"aws",
".",
"String",
"(",
"b",
".",
"streamName",
")",
",",
"}",
"\n\n",
"for",
"{",
"resp",
",",
"err",
":=",
"b",
".",
"client",
".",
"ListShards",
"(",
"listShardsInput",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"ss",
"=",
"append",
"(",
"ss",
",",
"resp",
".",
"Shards",
"...",
")",
"\n\n",
"if",
"resp",
".",
"NextToken",
"==",
"nil",
"{",
"return",
"ss",
",",
"nil",
"\n",
"}",
"\n\n",
"listShardsInput",
"=",
"&",
"kinesis",
".",
"ListShardsInput",
"{",
"NextToken",
":",
"resp",
".",
"NextToken",
",",
"StreamName",
":",
"aws",
".",
"String",
"(",
"b",
".",
"streamName",
")",
",",
"}",
"\n",
"}",
"\n",
"}"
]
| // listShards pulls a list of shard IDs from the kinesis api | [
"listShards",
"pulls",
"a",
"list",
"of",
"shard",
"IDs",
"from",
"the",
"kinesis",
"api"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/broker.go#L92-L114 |
10,144 | harlow/kinesis-consumer | checkpoint/ddb/ddb.go | WithMaxInterval | func WithMaxInterval(maxInterval time.Duration) Option {
return func(c *Checkpoint) {
c.maxInterval = maxInterval
}
} | go | func WithMaxInterval(maxInterval time.Duration) Option {
return func(c *Checkpoint) {
c.maxInterval = maxInterval
}
} | [
"func",
"WithMaxInterval",
"(",
"maxInterval",
"time",
".",
"Duration",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"Checkpoint",
")",
"{",
"c",
".",
"maxInterval",
"=",
"maxInterval",
"\n",
"}",
"\n",
"}"
]
| // WithMaxInterval sets the flush interval | [
"WithMaxInterval",
"sets",
"the",
"flush",
"interval"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/ddb/ddb.go#L20-L24 |
10,145 | harlow/kinesis-consumer | checkpoint/ddb/ddb.go | WithDynamoClient | func WithDynamoClient(svc dynamodbiface.DynamoDBAPI) Option {
return func(c *Checkpoint) {
c.client = svc
}
} | go | func WithDynamoClient(svc dynamodbiface.DynamoDBAPI) Option {
return func(c *Checkpoint) {
c.client = svc
}
} | [
"func",
"WithDynamoClient",
"(",
"svc",
"dynamodbiface",
".",
"DynamoDBAPI",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"Checkpoint",
")",
"{",
"c",
".",
"client",
"=",
"svc",
"\n",
"}",
"\n",
"}"
]
| // WithDynamoClient sets the dynamoDb client | [
"WithDynamoClient",
"sets",
"the",
"dynamoDb",
"client"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/ddb/ddb.go#L27-L31 |
10,146 | harlow/kinesis-consumer | checkpoint/ddb/ddb.go | New | func New(appName, tableName string, opts ...Option) (*Checkpoint, error) {
client := dynamodb.New(session.New(aws.NewConfig()))
ck := &Checkpoint{
tableName: tableName,
appName: appName,
client: client,
maxInterval: time.Duration(1 * time.Minute),
done: make(chan struct{}),
mu: &sync.Mutex{},
checkpoints: map[key]string{},
retryer: &DefaultRetryer{},
}
for _, opt := range opts {
opt(ck)
}
go ck.loop()
return ck, nil
} | go | func New(appName, tableName string, opts ...Option) (*Checkpoint, error) {
client := dynamodb.New(session.New(aws.NewConfig()))
ck := &Checkpoint{
tableName: tableName,
appName: appName,
client: client,
maxInterval: time.Duration(1 * time.Minute),
done: make(chan struct{}),
mu: &sync.Mutex{},
checkpoints: map[key]string{},
retryer: &DefaultRetryer{},
}
for _, opt := range opts {
opt(ck)
}
go ck.loop()
return ck, nil
} | [
"func",
"New",
"(",
"appName",
",",
"tableName",
"string",
",",
"opts",
"...",
"Option",
")",
"(",
"*",
"Checkpoint",
",",
"error",
")",
"{",
"client",
":=",
"dynamodb",
".",
"New",
"(",
"session",
".",
"New",
"(",
"aws",
".",
"NewConfig",
"(",
")",
")",
")",
"\n\n",
"ck",
":=",
"&",
"Checkpoint",
"{",
"tableName",
":",
"tableName",
",",
"appName",
":",
"appName",
",",
"client",
":",
"client",
",",
"maxInterval",
":",
"time",
".",
"Duration",
"(",
"1",
"*",
"time",
".",
"Minute",
")",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"mu",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"checkpoints",
":",
"map",
"[",
"key",
"]",
"string",
"{",
"}",
",",
"retryer",
":",
"&",
"DefaultRetryer",
"{",
"}",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"ck",
")",
"\n",
"}",
"\n\n",
"go",
"ck",
".",
"loop",
"(",
")",
"\n\n",
"return",
"ck",
",",
"nil",
"\n",
"}"
]
| // New returns a checkpoint that uses DynamoDB for underlying storage | [
"New",
"returns",
"a",
"checkpoint",
"that",
"uses",
"DynamoDB",
"for",
"underlying",
"storage"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/ddb/ddb.go#L41-L62 |
10,147 | harlow/kinesis-consumer | options.go | WithClient | func WithClient(client kinesisiface.KinesisAPI) Option {
return func(c *Consumer) {
c.client = client
}
} | go | func WithClient(client kinesisiface.KinesisAPI) Option {
return func(c *Consumer) {
c.client = client
}
} | [
"func",
"WithClient",
"(",
"client",
"kinesisiface",
".",
"KinesisAPI",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"Consumer",
")",
"{",
"c",
".",
"client",
"=",
"client",
"\n",
"}",
"\n",
"}"
]
| // WithClient overrides the default client | [
"WithClient",
"overrides",
"the",
"default",
"client"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/options.go#L30-L34 |
10,148 | harlow/kinesis-consumer | consumer.go | New | func New(streamName string, opts ...Option) (*Consumer, error) {
if streamName == "" {
return nil, fmt.Errorf("must provide stream name")
}
// new consumer with no-op checkpoint, counter, and logger
c := &Consumer{
streamName: streamName,
initialShardIteratorType: kinesis.ShardIteratorTypeLatest,
checkpoint: &noopCheckpoint{},
counter: &noopCounter{},
logger: &noopLogger{
logger: log.New(ioutil.Discard, "", log.LstdFlags),
},
}
// override defaults
for _, opt := range opts {
opt(c)
}
// default client if none provided
if c.client == nil {
newSession, err := session.NewSession(aws.NewConfig())
if err != nil {
return nil, err
}
c.client = kinesis.New(newSession)
}
return c, nil
} | go | func New(streamName string, opts ...Option) (*Consumer, error) {
if streamName == "" {
return nil, fmt.Errorf("must provide stream name")
}
// new consumer with no-op checkpoint, counter, and logger
c := &Consumer{
streamName: streamName,
initialShardIteratorType: kinesis.ShardIteratorTypeLatest,
checkpoint: &noopCheckpoint{},
counter: &noopCounter{},
logger: &noopLogger{
logger: log.New(ioutil.Discard, "", log.LstdFlags),
},
}
// override defaults
for _, opt := range opts {
opt(c)
}
// default client if none provided
if c.client == nil {
newSession, err := session.NewSession(aws.NewConfig())
if err != nil {
return nil, err
}
c.client = kinesis.New(newSession)
}
return c, nil
} | [
"func",
"New",
"(",
"streamName",
"string",
",",
"opts",
"...",
"Option",
")",
"(",
"*",
"Consumer",
",",
"error",
")",
"{",
"if",
"streamName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// new consumer with no-op checkpoint, counter, and logger",
"c",
":=",
"&",
"Consumer",
"{",
"streamName",
":",
"streamName",
",",
"initialShardIteratorType",
":",
"kinesis",
".",
"ShardIteratorTypeLatest",
",",
"checkpoint",
":",
"&",
"noopCheckpoint",
"{",
"}",
",",
"counter",
":",
"&",
"noopCounter",
"{",
"}",
",",
"logger",
":",
"&",
"noopLogger",
"{",
"logger",
":",
"log",
".",
"New",
"(",
"ioutil",
".",
"Discard",
",",
"\"",
"\"",
",",
"log",
".",
"LstdFlags",
")",
",",
"}",
",",
"}",
"\n\n",
"// override defaults",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"c",
")",
"\n",
"}",
"\n\n",
"// default client if none provided",
"if",
"c",
".",
"client",
"==",
"nil",
"{",
"newSession",
",",
"err",
":=",
"session",
".",
"NewSession",
"(",
"aws",
".",
"NewConfig",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"c",
".",
"client",
"=",
"kinesis",
".",
"New",
"(",
"newSession",
")",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
]
| // New creates a kinesis consumer with default settings. Use Option to override
// any of the optional attributes. | [
"New",
"creates",
"a",
"kinesis",
"consumer",
"with",
"default",
"settings",
".",
"Use",
"Option",
"to",
"override",
"any",
"of",
"the",
"optional",
"attributes",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/consumer.go#L21-L52 |
10,149 | harlow/kinesis-consumer | consumer.go | Scan | func (c *Consumer) Scan(ctx context.Context, fn ScanFunc) error {
var (
errc = make(chan error, 1)
shardc = make(chan *kinesis.Shard, 1)
broker = newBroker(c.client, c.streamName, shardc, c.logger)
)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
go broker.start(ctx)
go func() {
<-ctx.Done()
close(shardc)
}()
// process each of the shards
for shard := range shardc {
go func(shardID string) {
if err := c.ScanShard(ctx, shardID, fn); err != nil {
select {
case errc <- fmt.Errorf("shard %s error: %v", shardID, err):
// first error to occur
cancel()
default:
// error has already occured
}
}
}(aws.StringValue(shard.ShardId))
}
close(errc)
return <-errc
} | go | func (c *Consumer) Scan(ctx context.Context, fn ScanFunc) error {
var (
errc = make(chan error, 1)
shardc = make(chan *kinesis.Shard, 1)
broker = newBroker(c.client, c.streamName, shardc, c.logger)
)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
go broker.start(ctx)
go func() {
<-ctx.Done()
close(shardc)
}()
// process each of the shards
for shard := range shardc {
go func(shardID string) {
if err := c.ScanShard(ctx, shardID, fn); err != nil {
select {
case errc <- fmt.Errorf("shard %s error: %v", shardID, err):
// first error to occur
cancel()
default:
// error has already occured
}
}
}(aws.StringValue(shard.ShardId))
}
close(errc)
return <-errc
} | [
"func",
"(",
"c",
"*",
"Consumer",
")",
"Scan",
"(",
"ctx",
"context",
".",
"Context",
",",
"fn",
"ScanFunc",
")",
"error",
"{",
"var",
"(",
"errc",
"=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"shardc",
"=",
"make",
"(",
"chan",
"*",
"kinesis",
".",
"Shard",
",",
"1",
")",
"\n",
"broker",
"=",
"newBroker",
"(",
"c",
".",
"client",
",",
"c",
".",
"streamName",
",",
"shardc",
",",
"c",
".",
"logger",
")",
"\n",
")",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"go",
"broker",
".",
"start",
"(",
"ctx",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"close",
"(",
"shardc",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// process each of the shards",
"for",
"shard",
":=",
"range",
"shardc",
"{",
"go",
"func",
"(",
"shardID",
"string",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ScanShard",
"(",
"ctx",
",",
"shardID",
",",
"fn",
")",
";",
"err",
"!=",
"nil",
"{",
"select",
"{",
"case",
"errc",
"<-",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"shardID",
",",
"err",
")",
":",
"// first error to occur",
"cancel",
"(",
")",
"\n",
"default",
":",
"// error has already occured",
"}",
"\n",
"}",
"\n",
"}",
"(",
"aws",
".",
"StringValue",
"(",
"shard",
".",
"ShardId",
")",
")",
"\n",
"}",
"\n\n",
"close",
"(",
"errc",
")",
"\n\n",
"return",
"<-",
"errc",
"\n",
"}"
]
| // Scan launches a goroutine to process each of the shards in the stream. The ScanFunc
// is passed through to each of the goroutines and called with each message pulled from
// the stream. | [
"Scan",
"launches",
"a",
"goroutine",
"to",
"process",
"each",
"of",
"the",
"shards",
"in",
"the",
"stream",
".",
"The",
"ScanFunc",
"is",
"passed",
"through",
"to",
"each",
"of",
"the",
"goroutines",
"and",
"called",
"with",
"each",
"message",
"pulled",
"from",
"the",
"stream",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/consumer.go#L80-L115 |
10,150 | harlow/kinesis-consumer | consumer.go | ScanShard | func (c *Consumer) ScanShard(ctx context.Context, shardID string, fn ScanFunc) error {
// get last seq number from checkpoint
lastSeqNum, err := c.checkpoint.Get(c.streamName, shardID)
if err != nil {
return fmt.Errorf("get checkpoint error: %v", err)
}
// get shard iterator
shardIterator, err := c.getShardIterator(c.streamName, shardID, lastSeqNum)
if err != nil {
return fmt.Errorf("get shard iterator error: %v", err)
}
c.logger.Log("[START]\t", shardID, lastSeqNum)
defer func() {
c.logger.Log("[STOP]\t", shardID)
}()
for {
select {
case <-ctx.Done():
return nil
default:
resp, err := c.client.GetRecords(&kinesis.GetRecordsInput{
ShardIterator: shardIterator,
})
// attempt to recover from GetRecords error by getting new shard iterator
if err != nil {
shardIterator, err = c.getShardIterator(c.streamName, shardID, lastSeqNum)
if err != nil {
return fmt.Errorf("get shard iterator error: %v", err)
}
continue
}
// loop over records, call callback func
for _, r := range resp.Records {
select {
case <-ctx.Done():
return nil
default:
err := fn(r)
if err != nil && err != SkipCheckpoint {
return err
}
if err != SkipCheckpoint {
if err := c.checkpoint.Set(c.streamName, shardID, *r.SequenceNumber); err != nil {
return err
}
}
c.counter.Add("records", 1)
lastSeqNum = *r.SequenceNumber
}
}
if isShardClosed(resp.NextShardIterator, shardIterator) {
c.logger.Log("[CLOSED]\t", shardID)
return nil
}
shardIterator = resp.NextShardIterator
}
}
} | go | func (c *Consumer) ScanShard(ctx context.Context, shardID string, fn ScanFunc) error {
// get last seq number from checkpoint
lastSeqNum, err := c.checkpoint.Get(c.streamName, shardID)
if err != nil {
return fmt.Errorf("get checkpoint error: %v", err)
}
// get shard iterator
shardIterator, err := c.getShardIterator(c.streamName, shardID, lastSeqNum)
if err != nil {
return fmt.Errorf("get shard iterator error: %v", err)
}
c.logger.Log("[START]\t", shardID, lastSeqNum)
defer func() {
c.logger.Log("[STOP]\t", shardID)
}()
for {
select {
case <-ctx.Done():
return nil
default:
resp, err := c.client.GetRecords(&kinesis.GetRecordsInput{
ShardIterator: shardIterator,
})
// attempt to recover from GetRecords error by getting new shard iterator
if err != nil {
shardIterator, err = c.getShardIterator(c.streamName, shardID, lastSeqNum)
if err != nil {
return fmt.Errorf("get shard iterator error: %v", err)
}
continue
}
// loop over records, call callback func
for _, r := range resp.Records {
select {
case <-ctx.Done():
return nil
default:
err := fn(r)
if err != nil && err != SkipCheckpoint {
return err
}
if err != SkipCheckpoint {
if err := c.checkpoint.Set(c.streamName, shardID, *r.SequenceNumber); err != nil {
return err
}
}
c.counter.Add("records", 1)
lastSeqNum = *r.SequenceNumber
}
}
if isShardClosed(resp.NextShardIterator, shardIterator) {
c.logger.Log("[CLOSED]\t", shardID)
return nil
}
shardIterator = resp.NextShardIterator
}
}
} | [
"func",
"(",
"c",
"*",
"Consumer",
")",
"ScanShard",
"(",
"ctx",
"context",
".",
"Context",
",",
"shardID",
"string",
",",
"fn",
"ScanFunc",
")",
"error",
"{",
"// get last seq number from checkpoint",
"lastSeqNum",
",",
"err",
":=",
"c",
".",
"checkpoint",
".",
"Get",
"(",
"c",
".",
"streamName",
",",
"shardID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// get shard iterator",
"shardIterator",
",",
"err",
":=",
"c",
".",
"getShardIterator",
"(",
"c",
".",
"streamName",
",",
"shardID",
",",
"lastSeqNum",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"logger",
".",
"Log",
"(",
"\"",
"\\t",
"\"",
",",
"shardID",
",",
"lastSeqNum",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"c",
".",
"logger",
".",
"Log",
"(",
"\"",
"\\t",
"\"",
",",
"shardID",
")",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"default",
":",
"resp",
",",
"err",
":=",
"c",
".",
"client",
".",
"GetRecords",
"(",
"&",
"kinesis",
".",
"GetRecordsInput",
"{",
"ShardIterator",
":",
"shardIterator",
",",
"}",
")",
"\n\n",
"// attempt to recover from GetRecords error by getting new shard iterator",
"if",
"err",
"!=",
"nil",
"{",
"shardIterator",
",",
"err",
"=",
"c",
".",
"getShardIterator",
"(",
"c",
".",
"streamName",
",",
"shardID",
",",
"lastSeqNum",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// loop over records, call callback func",
"for",
"_",
",",
"r",
":=",
"range",
"resp",
".",
"Records",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"default",
":",
"err",
":=",
"fn",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"SkipCheckpoint",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"SkipCheckpoint",
"{",
"if",
"err",
":=",
"c",
".",
"checkpoint",
".",
"Set",
"(",
"c",
".",
"streamName",
",",
"shardID",
",",
"*",
"r",
".",
"SequenceNumber",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"c",
".",
"counter",
".",
"Add",
"(",
"\"",
"\"",
",",
"1",
")",
"\n",
"lastSeqNum",
"=",
"*",
"r",
".",
"SequenceNumber",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"isShardClosed",
"(",
"resp",
".",
"NextShardIterator",
",",
"shardIterator",
")",
"{",
"c",
".",
"logger",
".",
"Log",
"(",
"\"",
"\\t",
"\"",
",",
"shardID",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"shardIterator",
"=",
"resp",
".",
"NextShardIterator",
"\n",
"}",
"\n",
"}",
"\n",
"}"
]
| // ScanShard loops over records on a specific shard, calls the callback func
// for each record and checkpoints the progress of scan. | [
"ScanShard",
"loops",
"over",
"records",
"on",
"a",
"specific",
"shard",
"calls",
"the",
"callback",
"func",
"for",
"each",
"record",
"and",
"checkpoints",
"the",
"progress",
"of",
"scan",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/consumer.go#L119-L185 |
10,151 | harlow/kinesis-consumer | checkpoint/redis/redis.go | New | func New(appName string) (*Checkpoint, error) {
addr := os.Getenv("REDIS_URL")
if addr == "" {
addr = localhost
}
client := redis.NewClient(&redis.Options{Addr: addr})
// verify we can ping server
_, err := client.Ping().Result()
if err != nil {
return nil, err
}
return &Checkpoint{
appName: appName,
client: client,
}, nil
} | go | func New(appName string) (*Checkpoint, error) {
addr := os.Getenv("REDIS_URL")
if addr == "" {
addr = localhost
}
client := redis.NewClient(&redis.Options{Addr: addr})
// verify we can ping server
_, err := client.Ping().Result()
if err != nil {
return nil, err
}
return &Checkpoint{
appName: appName,
client: client,
}, nil
} | [
"func",
"New",
"(",
"appName",
"string",
")",
"(",
"*",
"Checkpoint",
",",
"error",
")",
"{",
"addr",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"addr",
"==",
"\"",
"\"",
"{",
"addr",
"=",
"localhost",
"\n",
"}",
"\n\n",
"client",
":=",
"redis",
".",
"NewClient",
"(",
"&",
"redis",
".",
"Options",
"{",
"Addr",
":",
"addr",
"}",
")",
"\n\n",
"// verify we can ping server",
"_",
",",
"err",
":=",
"client",
".",
"Ping",
"(",
")",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Checkpoint",
"{",
"appName",
":",
"appName",
",",
"client",
":",
"client",
",",
"}",
",",
"nil",
"\n",
"}"
]
| // New returns a checkpoint that uses Redis for underlying storage | [
"New",
"returns",
"a",
"checkpoint",
"that",
"uses",
"Redis",
"for",
"underlying",
"storage"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/redis/redis.go#L13-L31 |
10,152 | harlow/kinesis-consumer | checkpoint/redis/redis.go | Get | func (c *Checkpoint) Get(streamName, shardID string) (string, error) {
val, _ := c.client.Get(c.key(streamName, shardID)).Result()
return val, nil
} | go | func (c *Checkpoint) Get(streamName, shardID string) (string, error) {
val, _ := c.client.Get(c.key(streamName, shardID)).Result()
return val, nil
} | [
"func",
"(",
"c",
"*",
"Checkpoint",
")",
"Get",
"(",
"streamName",
",",
"shardID",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"val",
",",
"_",
":=",
"c",
".",
"client",
".",
"Get",
"(",
"c",
".",
"key",
"(",
"streamName",
",",
"shardID",
")",
")",
".",
"Result",
"(",
")",
"\n",
"return",
"val",
",",
"nil",
"\n",
"}"
]
| // Get fetches the checkpoint for a particular Shard. | [
"Get",
"fetches",
"the",
"checkpoint",
"for",
"a",
"particular",
"Shard",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/redis/redis.go#L40-L43 |
10,153 | harlow/kinesis-consumer | checkpoint/redis/redis.go | key | func (c *Checkpoint) key(streamName, shardID string) string {
return fmt.Sprintf("%v:checkpoint:%v:%v", c.appName, streamName, shardID)
} | go | func (c *Checkpoint) key(streamName, shardID string) string {
return fmt.Sprintf("%v:checkpoint:%v:%v", c.appName, streamName, shardID)
} | [
"func",
"(",
"c",
"*",
"Checkpoint",
")",
"key",
"(",
"streamName",
",",
"shardID",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"appName",
",",
"streamName",
",",
"shardID",
")",
"\n",
"}"
]
| // key generates a unique Redis key for storage of Checkpoint. | [
"key",
"generates",
"a",
"unique",
"Redis",
"key",
"for",
"storage",
"of",
"Checkpoint",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/redis/redis.go#L59-L61 |
10,154 | harlow/kinesis-consumer | checkpoint/postgres/postgres.go | New | func New(appName, tableName, connectionStr string, opts ...Option) (*Checkpoint, error) {
if appName == "" {
return nil, errors.New("application name not defined")
}
if tableName == "" {
return nil, errors.New("table name not defined")
}
conn, err := sql.Open("postgres", connectionStr)
if err != nil {
return nil, err
}
ck := &Checkpoint{
conn: conn,
appName: appName,
tableName: tableName,
done: make(chan struct{}),
maxInterval: 1 * time.Minute,
mu: new(sync.Mutex),
checkpoints: map[key]string{},
}
for _, opt := range opts {
opt(ck)
}
go ck.loop()
return ck, nil
} | go | func New(appName, tableName, connectionStr string, opts ...Option) (*Checkpoint, error) {
if appName == "" {
return nil, errors.New("application name not defined")
}
if tableName == "" {
return nil, errors.New("table name not defined")
}
conn, err := sql.Open("postgres", connectionStr)
if err != nil {
return nil, err
}
ck := &Checkpoint{
conn: conn,
appName: appName,
tableName: tableName,
done: make(chan struct{}),
maxInterval: 1 * time.Minute,
mu: new(sync.Mutex),
checkpoints: map[key]string{},
}
for _, opt := range opts {
opt(ck)
}
go ck.loop()
return ck, nil
} | [
"func",
"New",
"(",
"appName",
",",
"tableName",
",",
"connectionStr",
"string",
",",
"opts",
"...",
"Option",
")",
"(",
"*",
"Checkpoint",
",",
"error",
")",
"{",
"if",
"appName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"tableName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"\"",
"\"",
",",
"connectionStr",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ck",
":=",
"&",
"Checkpoint",
"{",
"conn",
":",
"conn",
",",
"appName",
":",
"appName",
",",
"tableName",
":",
"tableName",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"maxInterval",
":",
"1",
"*",
"time",
".",
"Minute",
",",
"mu",
":",
"new",
"(",
"sync",
".",
"Mutex",
")",
",",
"checkpoints",
":",
"map",
"[",
"key",
"]",
"string",
"{",
"}",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"ck",
")",
"\n",
"}",
"\n\n",
"go",
"ck",
".",
"loop",
"(",
")",
"\n\n",
"return",
"ck",
",",
"nil",
"\n",
"}"
]
| // New returns a checkpoint that uses PostgresDB for underlying storage
// Using connectionStr turn it more flexible to use specific db configs | [
"New",
"returns",
"a",
"checkpoint",
"that",
"uses",
"PostgresDB",
"for",
"underlying",
"storage",
"Using",
"connectionStr",
"turn",
"it",
"more",
"flexible",
"to",
"use",
"specific",
"db",
"configs"
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/postgres/postgres.go#L41-L73 |
10,155 | harlow/kinesis-consumer | checkpoint/postgres/postgres.go | Shutdown | func (c *Checkpoint) Shutdown() error {
defer c.conn.Close()
c.done <- struct{}{}
return c.save()
} | go | func (c *Checkpoint) Shutdown() error {
defer c.conn.Close()
c.done <- struct{}{}
return c.save()
} | [
"func",
"(",
"c",
"*",
"Checkpoint",
")",
"Shutdown",
"(",
")",
"error",
"{",
"defer",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"c",
".",
"done",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"return",
"c",
".",
"save",
"(",
")",
"\n",
"}"
]
| // Shutdown the checkpoint. Save any in-flight data. | [
"Shutdown",
"the",
"checkpoint",
".",
"Save",
"any",
"in",
"-",
"flight",
"data",
"."
]
| b48acfa5d47ba3615bfa39bc681deb18cf16cea1 | https://github.com/harlow/kinesis-consumer/blob/b48acfa5d47ba3615bfa39bc681deb18cf16cea1/checkpoint/postgres/postgres.go#L121-L127 |
10,156 | fatih/set | set_nots.go | newNonTS | func newNonTS() *SetNonTS {
s := &SetNonTS{}
s.m = make(map[interface{}]struct{})
// Ensure interface compliance
var _ Interface = s
return s
} | go | func newNonTS() *SetNonTS {
s := &SetNonTS{}
s.m = make(map[interface{}]struct{})
// Ensure interface compliance
var _ Interface = s
return s
} | [
"func",
"newNonTS",
"(",
")",
"*",
"SetNonTS",
"{",
"s",
":=",
"&",
"SetNonTS",
"{",
"}",
"\n",
"s",
".",
"m",
"=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"struct",
"{",
"}",
")",
"\n\n",
"// Ensure interface compliance",
"var",
"_",
"Interface",
"=",
"s",
"\n\n",
"return",
"s",
"\n",
"}"
]
| // NewNonTS creates and initializes a new non-threadsafe Set. | [
"NewNonTS",
"creates",
"and",
"initializes",
"a",
"new",
"non",
"-",
"threadsafe",
"Set",
"."
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set_nots.go#L19-L27 |
10,157 | fatih/set | set_nots.go | IsEqual | func (s *set) IsEqual(t Interface) bool {
// Force locking only if given set is threadsafe.
if conv, ok := t.(*Set); ok {
conv.l.RLock()
defer conv.l.RUnlock()
}
// return false if they are no the same size
if sameSize := len(s.m) == t.Size(); !sameSize {
return false
}
equal := true
t.Each(func(item interface{}) bool {
_, equal = s.m[item]
return equal // if false, Each() will end
})
return equal
} | go | func (s *set) IsEqual(t Interface) bool {
// Force locking only if given set is threadsafe.
if conv, ok := t.(*Set); ok {
conv.l.RLock()
defer conv.l.RUnlock()
}
// return false if they are no the same size
if sameSize := len(s.m) == t.Size(); !sameSize {
return false
}
equal := true
t.Each(func(item interface{}) bool {
_, equal = s.m[item]
return equal // if false, Each() will end
})
return equal
} | [
"func",
"(",
"s",
"*",
"set",
")",
"IsEqual",
"(",
"t",
"Interface",
")",
"bool",
"{",
"// Force locking only if given set is threadsafe.",
"if",
"conv",
",",
"ok",
":=",
"t",
".",
"(",
"*",
"Set",
")",
";",
"ok",
"{",
"conv",
".",
"l",
".",
"RLock",
"(",
")",
"\n",
"defer",
"conv",
".",
"l",
".",
"RUnlock",
"(",
")",
"\n",
"}",
"\n\n",
"// return false if they are no the same size",
"if",
"sameSize",
":=",
"len",
"(",
"s",
".",
"m",
")",
"==",
"t",
".",
"Size",
"(",
")",
";",
"!",
"sameSize",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"equal",
":=",
"true",
"\n",
"t",
".",
"Each",
"(",
"func",
"(",
"item",
"interface",
"{",
"}",
")",
"bool",
"{",
"_",
",",
"equal",
"=",
"s",
".",
"m",
"[",
"item",
"]",
"\n",
"return",
"equal",
"// if false, Each() will end",
"\n",
"}",
")",
"\n\n",
"return",
"equal",
"\n",
"}"
]
| // IsEqual test whether s and t are the same in size and have the same items. | [
"IsEqual",
"test",
"whether",
"s",
"and",
"t",
"are",
"the",
"same",
"in",
"size",
"and",
"have",
"the",
"same",
"items",
"."
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set_nots.go#L96-L115 |
10,158 | fatih/set | set_nots.go | String | func (s *set) String() string {
t := make([]string, 0, len(s.List()))
for _, item := range s.List() {
t = append(t, fmt.Sprintf("%v", item))
}
return fmt.Sprintf("[%s]", strings.Join(t, ", "))
} | go | func (s *set) String() string {
t := make([]string, 0, len(s.List()))
for _, item := range s.List() {
t = append(t, fmt.Sprintf("%v", item))
}
return fmt.Sprintf("[%s]", strings.Join(t, ", "))
} | [
"func",
"(",
"s",
"*",
"set",
")",
"String",
"(",
")",
"string",
"{",
"t",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"s",
".",
"List",
"(",
")",
")",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"s",
".",
"List",
"(",
")",
"{",
"t",
"=",
"append",
"(",
"t",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"item",
")",
")",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"t",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
]
| // String returns a string representation of s | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"s"
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set_nots.go#L155-L162 |
10,159 | fatih/set | set.go | Intersection | func Intersection(set1, set2 Interface, sets ...Interface) Interface {
all := Union(set1, set2, sets...)
result := Union(set1, set2, sets...)
all.Each(func(item interface{}) bool {
if !set1.Has(item) || !set2.Has(item) {
result.Remove(item)
}
for _, set := range sets {
if !set.Has(item) {
result.Remove(item)
}
}
return true
})
return result
} | go | func Intersection(set1, set2 Interface, sets ...Interface) Interface {
all := Union(set1, set2, sets...)
result := Union(set1, set2, sets...)
all.Each(func(item interface{}) bool {
if !set1.Has(item) || !set2.Has(item) {
result.Remove(item)
}
for _, set := range sets {
if !set.Has(item) {
result.Remove(item)
}
}
return true
})
return result
} | [
"func",
"Intersection",
"(",
"set1",
",",
"set2",
"Interface",
",",
"sets",
"...",
"Interface",
")",
"Interface",
"{",
"all",
":=",
"Union",
"(",
"set1",
",",
"set2",
",",
"sets",
"...",
")",
"\n",
"result",
":=",
"Union",
"(",
"set1",
",",
"set2",
",",
"sets",
"...",
")",
"\n\n",
"all",
".",
"Each",
"(",
"func",
"(",
"item",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"!",
"set1",
".",
"Has",
"(",
"item",
")",
"||",
"!",
"set2",
".",
"Has",
"(",
"item",
")",
"{",
"result",
".",
"Remove",
"(",
"item",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"set",
":=",
"range",
"sets",
"{",
"if",
"!",
"set",
".",
"Has",
"(",
"item",
")",
"{",
"result",
".",
"Remove",
"(",
"item",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
")",
"\n",
"return",
"result",
"\n",
"}"
]
| // Intersection returns a new set which contains items that only exist in all given sets. | [
"Intersection",
"returns",
"a",
"new",
"set",
"which",
"contains",
"items",
"that",
"only",
"exist",
"in",
"all",
"given",
"sets",
"."
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set.go#L93-L110 |
10,160 | fatih/set | set.go | SymmetricDifference | func SymmetricDifference(s Interface, t Interface) Interface {
u := Difference(s, t)
v := Difference(t, s)
return Union(u, v)
} | go | func SymmetricDifference(s Interface, t Interface) Interface {
u := Difference(s, t)
v := Difference(t, s)
return Union(u, v)
} | [
"func",
"SymmetricDifference",
"(",
"s",
"Interface",
",",
"t",
"Interface",
")",
"Interface",
"{",
"u",
":=",
"Difference",
"(",
"s",
",",
"t",
")",
"\n",
"v",
":=",
"Difference",
"(",
"t",
",",
"s",
")",
"\n",
"return",
"Union",
"(",
"u",
",",
"v",
")",
"\n",
"}"
]
| // SymmetricDifference returns a new set which s is the difference of items which are in
// one of either, but not in both. | [
"SymmetricDifference",
"returns",
"a",
"new",
"set",
"which",
"s",
"is",
"the",
"difference",
"of",
"items",
"which",
"are",
"in",
"one",
"of",
"either",
"but",
"not",
"in",
"both",
"."
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set.go#L114-L118 |
10,161 | fatih/set | set.go | StringSlice | func StringSlice(s Interface) []string {
slice := make([]string, 0)
for _, item := range s.List() {
v, ok := item.(string)
if !ok {
continue
}
slice = append(slice, v)
}
return slice
} | go | func StringSlice(s Interface) []string {
slice := make([]string, 0)
for _, item := range s.List() {
v, ok := item.(string)
if !ok {
continue
}
slice = append(slice, v)
}
return slice
} | [
"func",
"StringSlice",
"(",
"s",
"Interface",
")",
"[",
"]",
"string",
"{",
"slice",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"s",
".",
"List",
"(",
")",
"{",
"v",
",",
"ok",
":=",
"item",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n\n",
"slice",
"=",
"append",
"(",
"slice",
",",
"v",
")",
"\n",
"}",
"\n",
"return",
"slice",
"\n",
"}"
]
| // StringSlice is a helper function that returns a slice of strings of s. If
// the set contains mixed types of items only items of type string are returned. | [
"StringSlice",
"is",
"a",
"helper",
"function",
"that",
"returns",
"a",
"slice",
"of",
"strings",
"of",
"s",
".",
"If",
"the",
"set",
"contains",
"mixed",
"types",
"of",
"items",
"only",
"items",
"of",
"type",
"string",
"are",
"returned",
"."
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set.go#L122-L133 |
10,162 | fatih/set | set.go | IntSlice | func IntSlice(s Interface) []int {
slice := make([]int, 0)
for _, item := range s.List() {
v, ok := item.(int)
if !ok {
continue
}
slice = append(slice, v)
}
return slice
} | go | func IntSlice(s Interface) []int {
slice := make([]int, 0)
for _, item := range s.List() {
v, ok := item.(int)
if !ok {
continue
}
slice = append(slice, v)
}
return slice
} | [
"func",
"IntSlice",
"(",
"s",
"Interface",
")",
"[",
"]",
"int",
"{",
"slice",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"0",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"s",
".",
"List",
"(",
")",
"{",
"v",
",",
"ok",
":=",
"item",
".",
"(",
"int",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n\n",
"slice",
"=",
"append",
"(",
"slice",
",",
"v",
")",
"\n",
"}",
"\n",
"return",
"slice",
"\n",
"}"
]
| // IntSlice is a helper function that returns a slice of ints of s. If
// the set contains mixed types of items only items of type int are returned. | [
"IntSlice",
"is",
"a",
"helper",
"function",
"that",
"returns",
"a",
"slice",
"of",
"ints",
"of",
"s",
".",
"If",
"the",
"set",
"contains",
"mixed",
"types",
"of",
"items",
"only",
"items",
"of",
"type",
"int",
"are",
"returned",
"."
]
| 2c768e3c5489976167bfc42b5c7c92ca783f4389 | https://github.com/fatih/set/blob/2c768e3c5489976167bfc42b5c7c92ca783f4389/set.go#L137-L148 |
10,163 | zalando/gin-oauth2 | zalando/zalando.go | RequestTeamInfo | func RequestTeamInfo(tc *ginoauth2.TokenContainer, uri string) ([]byte, error) {
var uv = make(url.Values)
uv.Set("member", tc.Scopes["uid"].(string))
info_url := uri + "?" + uv.Encode()
client := &http.Client{Transport: &ginoauth2.Transport}
req, err := http.NewRequest("GET", info_url, nil)
if err != nil {
return nil, err
}
req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", tc.Token.AccessToken))
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
} | go | func RequestTeamInfo(tc *ginoauth2.TokenContainer, uri string) ([]byte, error) {
var uv = make(url.Values)
uv.Set("member", tc.Scopes["uid"].(string))
info_url := uri + "?" + uv.Encode()
client := &http.Client{Transport: &ginoauth2.Transport}
req, err := http.NewRequest("GET", info_url, nil)
if err != nil {
return nil, err
}
req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", tc.Token.AccessToken))
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
} | [
"func",
"RequestTeamInfo",
"(",
"tc",
"*",
"ginoauth2",
".",
"TokenContainer",
",",
"uri",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"uv",
"=",
"make",
"(",
"url",
".",
"Values",
")",
"\n",
"uv",
".",
"Set",
"(",
"\"",
"\"",
",",
"tc",
".",
"Scopes",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
")",
"\n",
"info_url",
":=",
"uri",
"+",
"\"",
"\"",
"+",
"uv",
".",
"Encode",
"(",
")",
"\n",
"client",
":=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"&",
"ginoauth2",
".",
"Transport",
"}",
"\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"info_url",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tc",
".",
"Token",
".",
"AccessToken",
")",
")",
"\n\n",
"resp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"return",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"}"
]
| // RequestTeamInfo is a function that returns team information for a
// given token. | [
"RequestTeamInfo",
"is",
"a",
"function",
"that",
"returns",
"team",
"information",
"for",
"a",
"given",
"token",
"."
]
| 405fac2d081c9faee4b56aabae642685a5335ee7 | https://github.com/zalando/gin-oauth2/blob/405fac2d081c9faee4b56aabae642685a5335ee7/zalando/zalando.go#L49-L67 |
10,164 | zalando/gin-oauth2 | zalando/zalando.go | GroupCheck | func GroupCheck(at []AccessTuple) func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
ats := at
return func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
blob, err := RequestTeamInfo(tc, TeamAPI)
if err != nil {
glog.Errorf("[Gin-OAuth] failed to get team info, caused by: %s", err)
return false
}
var data []TeamInfo
err = json.Unmarshal(blob, &data)
if err != nil {
glog.Errorf("[Gin-OAuth] JSON.Unmarshal failed, caused by: %s", err)
return false
}
granted := false
for _, teamInfo := range data {
for idx := range ats {
at := ats[idx]
if teamInfo.Id == at.Uid {
granted = true
glog.Infof("[Gin-OAuth] Grant access to %s as team member of \"%s\"\n", tc.Scopes["uid"].(string), teamInfo.Id)
}
if teamInfo.Type == "official" {
ctx.Set("uid", tc.Scopes["uid"].(string))
ctx.Set("team", teamInfo.Id)
}
}
}
return granted
}
} | go | func GroupCheck(at []AccessTuple) func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
ats := at
return func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
blob, err := RequestTeamInfo(tc, TeamAPI)
if err != nil {
glog.Errorf("[Gin-OAuth] failed to get team info, caused by: %s", err)
return false
}
var data []TeamInfo
err = json.Unmarshal(blob, &data)
if err != nil {
glog.Errorf("[Gin-OAuth] JSON.Unmarshal failed, caused by: %s", err)
return false
}
granted := false
for _, teamInfo := range data {
for idx := range ats {
at := ats[idx]
if teamInfo.Id == at.Uid {
granted = true
glog.Infof("[Gin-OAuth] Grant access to %s as team member of \"%s\"\n", tc.Scopes["uid"].(string), teamInfo.Id)
}
if teamInfo.Type == "official" {
ctx.Set("uid", tc.Scopes["uid"].(string))
ctx.Set("team", teamInfo.Id)
}
}
}
return granted
}
} | [
"func",
"GroupCheck",
"(",
"at",
"[",
"]",
"AccessTuple",
")",
"func",
"(",
"tc",
"*",
"ginoauth2",
".",
"TokenContainer",
",",
"ctx",
"*",
"gin",
".",
"Context",
")",
"bool",
"{",
"ats",
":=",
"at",
"\n",
"return",
"func",
"(",
"tc",
"*",
"ginoauth2",
".",
"TokenContainer",
",",
"ctx",
"*",
"gin",
".",
"Context",
")",
"bool",
"{",
"blob",
",",
"err",
":=",
"RequestTeamInfo",
"(",
"tc",
",",
"TeamAPI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"var",
"data",
"[",
"]",
"TeamInfo",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"blob",
",",
"&",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"granted",
":=",
"false",
"\n",
"for",
"_",
",",
"teamInfo",
":=",
"range",
"data",
"{",
"for",
"idx",
":=",
"range",
"ats",
"{",
"at",
":=",
"ats",
"[",
"idx",
"]",
"\n",
"if",
"teamInfo",
".",
"Id",
"==",
"at",
".",
"Uid",
"{",
"granted",
"=",
"true",
"\n",
"glog",
".",
"Infof",
"(",
"\"",
"\\\"",
"\\\"",
"\\n",
"\"",
",",
"tc",
".",
"Scopes",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
",",
"teamInfo",
".",
"Id",
")",
"\n",
"}",
"\n",
"if",
"teamInfo",
".",
"Type",
"==",
"\"",
"\"",
"{",
"ctx",
".",
"Set",
"(",
"\"",
"\"",
",",
"tc",
".",
"Scopes",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
")",
"\n",
"ctx",
".",
"Set",
"(",
"\"",
"\"",
",",
"teamInfo",
".",
"Id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"granted",
"\n",
"}",
"\n",
"}"
]
| // GroupCheck is an authorization function that checks, if the Token
// was issued for an employee of a specified team. The given
// TokenContainer must be valid. As side effect it sets "uid" and
// "team" in the gin.Context to the "official" team. | [
"GroupCheck",
"is",
"an",
"authorization",
"function",
"that",
"checks",
"if",
"the",
"Token",
"was",
"issued",
"for",
"an",
"employee",
"of",
"a",
"specified",
"team",
".",
"The",
"given",
"TokenContainer",
"must",
"be",
"valid",
".",
"As",
"side",
"effect",
"it",
"sets",
"uid",
"and",
"team",
"in",
"the",
"gin",
".",
"Context",
"to",
"the",
"official",
"team",
"."
]
| 405fac2d081c9faee4b56aabae642685a5335ee7 | https://github.com/zalando/gin-oauth2/blob/405fac2d081c9faee4b56aabae642685a5335ee7/zalando/zalando.go#L73-L103 |
10,165 | zalando/gin-oauth2 | zalando/zalando.go | ScopeCheck | func ScopeCheck(name string, scopes ...string) func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
glog.Infof("ScopeCheck %s configured to grant access for scopes: %v", name, scopes)
configuredScopes := scopes
return func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
scopesFromToken := make([]string, 0)
for _, s := range configuredScopes {
if cur, ok := tc.Scopes[s]; ok {
glog.V(2).Infof("Found configured scope %s", s)
scopesFromToken = append(scopesFromToken, s)
ctx.Set(s, cur) // set value from token of configured scope to the context, which you can use in your application.
}
}
//Getting the uid for identification of the service calling
if cur, ok := tc.Scopes["uid"]; ok {
ctx.Set("uid", cur)
}
return len(scopesFromToken) > 0
}
} | go | func ScopeCheck(name string, scopes ...string) func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
glog.Infof("ScopeCheck %s configured to grant access for scopes: %v", name, scopes)
configuredScopes := scopes
return func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
scopesFromToken := make([]string, 0)
for _, s := range configuredScopes {
if cur, ok := tc.Scopes[s]; ok {
glog.V(2).Infof("Found configured scope %s", s)
scopesFromToken = append(scopesFromToken, s)
ctx.Set(s, cur) // set value from token of configured scope to the context, which you can use in your application.
}
}
//Getting the uid for identification of the service calling
if cur, ok := tc.Scopes["uid"]; ok {
ctx.Set("uid", cur)
}
return len(scopesFromToken) > 0
}
} | [
"func",
"ScopeCheck",
"(",
"name",
"string",
",",
"scopes",
"...",
"string",
")",
"func",
"(",
"tc",
"*",
"ginoauth2",
".",
"TokenContainer",
",",
"ctx",
"*",
"gin",
".",
"Context",
")",
"bool",
"{",
"glog",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"scopes",
")",
"\n",
"configuredScopes",
":=",
"scopes",
"\n",
"return",
"func",
"(",
"tc",
"*",
"ginoauth2",
".",
"TokenContainer",
",",
"ctx",
"*",
"gin",
".",
"Context",
")",
"bool",
"{",
"scopesFromToken",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"configuredScopes",
"{",
"if",
"cur",
",",
"ok",
":=",
"tc",
".",
"Scopes",
"[",
"s",
"]",
";",
"ok",
"{",
"glog",
".",
"V",
"(",
"2",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"scopesFromToken",
"=",
"append",
"(",
"scopesFromToken",
",",
"s",
")",
"\n",
"ctx",
".",
"Set",
"(",
"s",
",",
"cur",
")",
"// set value from token of configured scope to the context, which you can use in your application.",
"\n",
"}",
"\n",
"}",
"\n",
"//Getting the uid for identification of the service calling",
"if",
"cur",
",",
"ok",
":=",
"tc",
".",
"Scopes",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"ctx",
".",
"Set",
"(",
"\"",
"\"",
",",
"cur",
")",
"\n",
"}",
"\n",
"return",
"len",
"(",
"scopesFromToken",
")",
">",
"0",
"\n",
"}",
"\n",
"}"
]
| // ScopeCheck does an OR check of scopes given from token of the
// request to all provided scopes. If one of provided scopes is in the
// Scopes of the token it grants access to the resource. | [
"ScopeCheck",
"does",
"an",
"OR",
"check",
"of",
"scopes",
"given",
"from",
"token",
"of",
"the",
"request",
"to",
"all",
"provided",
"scopes",
".",
"If",
"one",
"of",
"provided",
"scopes",
"is",
"in",
"the",
"Scopes",
"of",
"the",
"token",
"it",
"grants",
"access",
"to",
"the",
"resource",
"."
]
| 405fac2d081c9faee4b56aabae642685a5335ee7 | https://github.com/zalando/gin-oauth2/blob/405fac2d081c9faee4b56aabae642685a5335ee7/zalando/zalando.go#L128-L146 |
10,166 | zalando/gin-oauth2 | ginoauth2.go | Valid | func (t *TokenContainer) Valid() bool {
if t.Token == nil {
return false
}
return t.Token.Valid()
} | go | func (t *TokenContainer) Valid() bool {
if t.Token == nil {
return false
}
return t.Token.Valid()
} | [
"func",
"(",
"t",
"*",
"TokenContainer",
")",
"Valid",
"(",
")",
"bool",
"{",
"if",
"t",
".",
"Token",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"t",
".",
"Token",
".",
"Valid",
"(",
")",
"\n",
"}"
]
| //
// TokenContainer
//
// Validates that the AccessToken within TokenContainer is not expired and not empty. | [
"TokenContainer",
"Validates",
"that",
"the",
"AccessToken",
"within",
"TokenContainer",
"is",
"not",
"expired",
"and",
"not",
"empty",
"."
]
| 405fac2d081c9faee4b56aabae642685a5335ee7 | https://github.com/zalando/gin-oauth2/blob/405fac2d081c9faee4b56aabae642685a5335ee7/ginoauth2.go#L209-L214 |
10,167 | zalando/gin-oauth2 | google/google.go | Setup | func Setup(redirectURL, credFile string, scopes []string, secret []byte) {
store = sessions.NewCookieStore(secret)
var c Credentials
file, err := ioutil.ReadFile(credFile)
if err != nil {
glog.Fatalf("[Gin-OAuth] File error: %v\n", err)
}
json.Unmarshal(file, &c)
conf = &oauth2.Config{
ClientID: c.ClientID,
ClientSecret: c.ClientSecret,
RedirectURL: redirectURL,
Scopes: scopes,
Endpoint: google.Endpoint,
}
} | go | func Setup(redirectURL, credFile string, scopes []string, secret []byte) {
store = sessions.NewCookieStore(secret)
var c Credentials
file, err := ioutil.ReadFile(credFile)
if err != nil {
glog.Fatalf("[Gin-OAuth] File error: %v\n", err)
}
json.Unmarshal(file, &c)
conf = &oauth2.Config{
ClientID: c.ClientID,
ClientSecret: c.ClientSecret,
RedirectURL: redirectURL,
Scopes: scopes,
Endpoint: google.Endpoint,
}
} | [
"func",
"Setup",
"(",
"redirectURL",
",",
"credFile",
"string",
",",
"scopes",
"[",
"]",
"string",
",",
"secret",
"[",
"]",
"byte",
")",
"{",
"store",
"=",
"sessions",
".",
"NewCookieStore",
"(",
"secret",
")",
"\n",
"var",
"c",
"Credentials",
"\n",
"file",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"credFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Fatalf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"json",
".",
"Unmarshal",
"(",
"file",
",",
"&",
"c",
")",
"\n\n",
"conf",
"=",
"&",
"oauth2",
".",
"Config",
"{",
"ClientID",
":",
"c",
".",
"ClientID",
",",
"ClientSecret",
":",
"c",
".",
"ClientSecret",
",",
"RedirectURL",
":",
"redirectURL",
",",
"Scopes",
":",
"scopes",
",",
"Endpoint",
":",
"google",
".",
"Endpoint",
",",
"}",
"\n",
"}"
]
| // Setup the authorization path | [
"Setup",
"the",
"authorization",
"path"
]
| 405fac2d081c9faee4b56aabae642685a5335ee7 | https://github.com/zalando/gin-oauth2/blob/405fac2d081c9faee4b56aabae642685a5335ee7/google/google.go#L54-L70 |
10,168 | blang/vfs | prefixfs/prefixfs.go | Create | func Create(root vfs.Filesystem, prefix string) *FS {
return &FS{root, prefix}
} | go | func Create(root vfs.Filesystem, prefix string) *FS {
return &FS{root, prefix}
} | [
"func",
"Create",
"(",
"root",
"vfs",
".",
"Filesystem",
",",
"prefix",
"string",
")",
"*",
"FS",
"{",
"return",
"&",
"FS",
"{",
"root",
",",
"prefix",
"}",
"\n",
"}"
]
| // Create returns a file system that prefixes all paths and forwards to root. | [
"Create",
"returns",
"a",
"file",
"system",
"that",
"prefixes",
"all",
"paths",
"and",
"forwards",
"to",
"root",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L18-L20 |
10,169 | blang/vfs | prefixfs/prefixfs.go | PrefixPath | func (fs *FS) PrefixPath(path string) string {
return fs.Prefix + string(fs.PathSeparator()) + path
} | go | func (fs *FS) PrefixPath(path string) string {
return fs.Prefix + string(fs.PathSeparator()) + path
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"PrefixPath",
"(",
"path",
"string",
")",
"string",
"{",
"return",
"fs",
".",
"Prefix",
"+",
"string",
"(",
"fs",
".",
"PathSeparator",
"(",
")",
")",
"+",
"path",
"\n",
"}"
]
| // PrefixPath returns path with the prefix prefixed. | [
"PrefixPath",
"returns",
"path",
"with",
"the",
"prefix",
"prefixed",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L23-L25 |
10,170 | blang/vfs | prefixfs/prefixfs.go | OpenFile | func (fs *FS) OpenFile(name string, flag int, perm os.FileMode) (vfs.File, error) {
return fs.Filesystem.OpenFile(fs.PrefixPath(name), flag, perm)
} | go | func (fs *FS) OpenFile(name string, flag int, perm os.FileMode) (vfs.File, error) {
return fs.Filesystem.OpenFile(fs.PrefixPath(name), flag, perm)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"OpenFile",
"(",
"name",
"string",
",",
"flag",
"int",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"vfs",
".",
"File",
",",
"error",
")",
"{",
"return",
"fs",
".",
"Filesystem",
".",
"OpenFile",
"(",
"fs",
".",
"PrefixPath",
"(",
"name",
")",
",",
"flag",
",",
"perm",
")",
"\n",
"}"
]
| // OpenFile implements vfs.Filesystem. | [
"OpenFile",
"implements",
"vfs",
".",
"Filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L31-L33 |
10,171 | blang/vfs | prefixfs/prefixfs.go | Remove | func (fs *FS) Remove(name string) error {
return fs.Filesystem.Remove(fs.PrefixPath(name))
} | go | func (fs *FS) Remove(name string) error {
return fs.Filesystem.Remove(fs.PrefixPath(name))
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Remove",
"(",
"name",
"string",
")",
"error",
"{",
"return",
"fs",
".",
"Filesystem",
".",
"Remove",
"(",
"fs",
".",
"PrefixPath",
"(",
"name",
")",
")",
"\n",
"}"
]
| // Remove implements vfs.Filesystem. | [
"Remove",
"implements",
"vfs",
".",
"Filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L36-L38 |
10,172 | blang/vfs | prefixfs/prefixfs.go | Rename | func (fs *FS) Rename(oldpath, newpath string) error {
return fs.Filesystem.Rename(fs.PrefixPath(oldpath), fs.PrefixPath(newpath))
} | go | func (fs *FS) Rename(oldpath, newpath string) error {
return fs.Filesystem.Rename(fs.PrefixPath(oldpath), fs.PrefixPath(newpath))
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Rename",
"(",
"oldpath",
",",
"newpath",
"string",
")",
"error",
"{",
"return",
"fs",
".",
"Filesystem",
".",
"Rename",
"(",
"fs",
".",
"PrefixPath",
"(",
"oldpath",
")",
",",
"fs",
".",
"PrefixPath",
"(",
"newpath",
")",
")",
"\n",
"}"
]
| // Rename implements vfs.Filesystem. | [
"Rename",
"implements",
"vfs",
".",
"Filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L41-L43 |
10,173 | blang/vfs | prefixfs/prefixfs.go | Mkdir | func (fs *FS) Mkdir(name string, perm os.FileMode) error {
return fs.Filesystem.Mkdir(fs.PrefixPath(name), perm)
} | go | func (fs *FS) Mkdir(name string, perm os.FileMode) error {
return fs.Filesystem.Mkdir(fs.PrefixPath(name), perm)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Mkdir",
"(",
"name",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"fs",
".",
"Filesystem",
".",
"Mkdir",
"(",
"fs",
".",
"PrefixPath",
"(",
"name",
")",
",",
"perm",
")",
"\n",
"}"
]
| // Mkdir implements vfs.Filesystem. | [
"Mkdir",
"implements",
"vfs",
".",
"Filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L46-L48 |
10,174 | blang/vfs | prefixfs/prefixfs.go | Stat | func (fs *FS) Stat(name string) (os.FileInfo, error) {
return fs.Filesystem.Stat(fs.PrefixPath(name))
} | go | func (fs *FS) Stat(name string) (os.FileInfo, error) {
return fs.Filesystem.Stat(fs.PrefixPath(name))
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Stat",
"(",
"name",
"string",
")",
"(",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"return",
"fs",
".",
"Filesystem",
".",
"Stat",
"(",
"fs",
".",
"PrefixPath",
"(",
"name",
")",
")",
"\n",
"}"
]
| // Stat implements vfs.Filesystem. | [
"Stat",
"implements",
"vfs",
".",
"Filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L51-L53 |
10,175 | blang/vfs | prefixfs/prefixfs.go | ReadDir | func (fs *FS) ReadDir(path string) ([]os.FileInfo, error) {
return fs.Filesystem.ReadDir(fs.PrefixPath(path))
} | go | func (fs *FS) ReadDir(path string) ([]os.FileInfo, error) {
return fs.Filesystem.ReadDir(fs.PrefixPath(path))
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"ReadDir",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"return",
"fs",
".",
"Filesystem",
".",
"ReadDir",
"(",
"fs",
".",
"PrefixPath",
"(",
"path",
")",
")",
"\n",
"}"
]
| // ReadDir implements vfs.Filesystem. | [
"ReadDir",
"implements",
"vfs",
".",
"Filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/prefixfs/prefixfs.go#L61-L63 |
10,176 | blang/vfs | memfs/memfile.go | NewMemFile | func NewMemFile(name string, rwMutex *sync.RWMutex, buf *[]byte) *MemFile {
return &MemFile{
Buffer: NewBuffer(buf),
mutex: rwMutex,
name: name,
}
} | go | func NewMemFile(name string, rwMutex *sync.RWMutex, buf *[]byte) *MemFile {
return &MemFile{
Buffer: NewBuffer(buf),
mutex: rwMutex,
name: name,
}
} | [
"func",
"NewMemFile",
"(",
"name",
"string",
",",
"rwMutex",
"*",
"sync",
".",
"RWMutex",
",",
"buf",
"*",
"[",
"]",
"byte",
")",
"*",
"MemFile",
"{",
"return",
"&",
"MemFile",
"{",
"Buffer",
":",
"NewBuffer",
"(",
"buf",
")",
",",
"mutex",
":",
"rwMutex",
",",
"name",
":",
"name",
",",
"}",
"\n",
"}"
]
| // NewMemFile creates a Buffer which byte slice is safe from concurrent access,
// the file itself is not thread-safe.
//
// This means multiple files can work safely on the same byte slice,
// but multiple go routines working on the same file may corrupt the internal pointer structure. | [
"NewMemFile",
"creates",
"a",
"Buffer",
"which",
"byte",
"slice",
"is",
"safe",
"from",
"concurrent",
"access",
"the",
"file",
"itself",
"is",
"not",
"thread",
"-",
"safe",
".",
"This",
"means",
"multiple",
"files",
"can",
"work",
"safely",
"on",
"the",
"same",
"byte",
"slice",
"but",
"multiple",
"go",
"routines",
"working",
"on",
"the",
"same",
"file",
"may",
"corrupt",
"the",
"internal",
"pointer",
"structure",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/memfile.go#L19-L25 |
10,177 | blang/vfs | memfs/memfile.go | Truncate | func (b MemFile) Truncate(size int64) (err error) {
b.mutex.Lock()
err = b.Buffer.Truncate(size)
b.mutex.Unlock()
return
} | go | func (b MemFile) Truncate(size int64) (err error) {
b.mutex.Lock()
err = b.Buffer.Truncate(size)
b.mutex.Unlock()
return
} | [
"func",
"(",
"b",
"MemFile",
")",
"Truncate",
"(",
"size",
"int64",
")",
"(",
"err",
"error",
")",
"{",
"b",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"err",
"=",
"b",
".",
"Buffer",
".",
"Truncate",
"(",
"size",
")",
"\n",
"b",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
]
| // Truncate changes the size of the file | [
"Truncate",
"changes",
"the",
"size",
"of",
"the",
"file"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/memfile.go#L38-L43 |
10,178 | blang/vfs | ioutil.go | ReadFile | func ReadFile(fs Filesystem, filename string) ([]byte, error) {
f, err := fs.OpenFile(filename, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
defer f.Close()
// It's a good but not certain bet that FileInfo will tell us exactly how
// much to read, so let's try it but be prepared for the answer to be wrong.
var n int64
if fi, err := fs.Stat(filename); err == nil {
if size := fi.Size(); size < 1e9 {
n = size
}
}
// As initial capacity for readAll, use n + a little extra in case Size is
// zero, and to avoid another allocation after Read has filled the buffer.
// The readAll call will read into its allocated internal buffer cheaply. If
// the size was wrong, we'll either waste some space off the end or
// reallocate as needed, but in the overwhelmingly common case we'll get it
// just right.
return readAll(f, n+bytes.MinRead)
} | go | func ReadFile(fs Filesystem, filename string) ([]byte, error) {
f, err := fs.OpenFile(filename, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
defer f.Close()
// It's a good but not certain bet that FileInfo will tell us exactly how
// much to read, so let's try it but be prepared for the answer to be wrong.
var n int64
if fi, err := fs.Stat(filename); err == nil {
if size := fi.Size(); size < 1e9 {
n = size
}
}
// As initial capacity for readAll, use n + a little extra in case Size is
// zero, and to avoid another allocation after Read has filled the buffer.
// The readAll call will read into its allocated internal buffer cheaply. If
// the size was wrong, we'll either waste some space off the end or
// reallocate as needed, but in the overwhelmingly common case we'll get it
// just right.
return readAll(f, n+bytes.MinRead)
} | [
"func",
"ReadFile",
"(",
"fs",
"Filesystem",
",",
"filename",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"fs",
".",
"OpenFile",
"(",
"filename",
",",
"os",
".",
"O_RDONLY",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"// It's a good but not certain bet that FileInfo will tell us exactly how",
"// much to read, so let's try it but be prepared for the answer to be wrong.",
"var",
"n",
"int64",
"\n",
"if",
"fi",
",",
"err",
":=",
"fs",
".",
"Stat",
"(",
"filename",
")",
";",
"err",
"==",
"nil",
"{",
"if",
"size",
":=",
"fi",
".",
"Size",
"(",
")",
";",
"size",
"<",
"1e9",
"{",
"n",
"=",
"size",
"\n",
"}",
"\n",
"}",
"\n\n",
"// As initial capacity for readAll, use n + a little extra in case Size is",
"// zero, and to avoid another allocation after Read has filled the buffer.",
"// The readAll call will read into its allocated internal buffer cheaply. If",
"// the size was wrong, we'll either waste some space off the end or",
"// reallocate as needed, but in the overwhelmingly common case we'll get it",
"// just right.",
"return",
"readAll",
"(",
"f",
",",
"n",
"+",
"bytes",
".",
"MinRead",
")",
"\n",
"}"
]
| // ReadFile reads the file named by filename and returns the contents. A
// successful call returns err == nil, not err == EOF. Because ReadFile reads
// the whole file, it does not treat an EOF from Read as an error to be
// reported.
//
// This is a port of the stdlib ioutil.ReadFile function. | [
"ReadFile",
"reads",
"the",
"file",
"named",
"by",
"filename",
"and",
"returns",
"the",
"contents",
".",
"A",
"successful",
"call",
"returns",
"err",
"==",
"nil",
"not",
"err",
"==",
"EOF",
".",
"Because",
"ReadFile",
"reads",
"the",
"whole",
"file",
"it",
"does",
"not",
"treat",
"an",
"EOF",
"from",
"Read",
"as",
"an",
"error",
"to",
"be",
"reported",
".",
"This",
"is",
"a",
"port",
"of",
"the",
"stdlib",
"ioutil",
".",
"ReadFile",
"function",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/ioutil.go#L35-L58 |
10,179 | blang/vfs | readonly.go | Mkdir | func (fs RoFS) Mkdir(name string, perm os.FileMode) error {
return ErrReadOnly
} | go | func (fs RoFS) Mkdir(name string, perm os.FileMode) error {
return ErrReadOnly
} | [
"func",
"(",
"fs",
"RoFS",
")",
"Mkdir",
"(",
"name",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"ErrReadOnly",
"\n",
"}"
]
| // Mkdir is disabled and returns ErrorReadOnly | [
"Mkdir",
"is",
"disabled",
"and",
"returns",
"ErrorReadOnly"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/readonly.go#L43-L45 |
10,180 | blang/vfs | memfs/memfs.go | Create | func Create() *MemFS {
root := &fileInfo{
name: "/",
dir: true,
}
return &MemFS{
root: root,
wd: root,
lock: &sync.RWMutex{},
}
} | go | func Create() *MemFS {
root := &fileInfo{
name: "/",
dir: true,
}
return &MemFS{
root: root,
wd: root,
lock: &sync.RWMutex{},
}
} | [
"func",
"Create",
"(",
")",
"*",
"MemFS",
"{",
"root",
":=",
"&",
"fileInfo",
"{",
"name",
":",
"\"",
"\"",
",",
"dir",
":",
"true",
",",
"}",
"\n",
"return",
"&",
"MemFS",
"{",
"root",
":",
"root",
",",
"wd",
":",
"root",
",",
"lock",
":",
"&",
"sync",
".",
"RWMutex",
"{",
"}",
",",
"}",
"\n",
"}"
]
| // Create a new MemFS filesystem which entirely resides in memory | [
"Create",
"a",
"new",
"MemFS",
"filesystem",
"which",
"entirely",
"resides",
"in",
"memory"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/memfs.go#L35-L45 |
10,181 | blang/vfs | memfs/memfs.go | Mkdir | func (fs *MemFS) Mkdir(name string, perm os.FileMode) error {
fs.lock.Lock()
defer fs.lock.Unlock()
name = filepath.Clean(name)
base := filepath.Base(name)
parent, fi, err := fs.fileInfo(name)
if err != nil {
return &os.PathError{"mkdir", name, err}
}
if fi != nil {
return &os.PathError{"mkdir", name, fmt.Errorf("Directory %q already exists", name)}
}
fi = &fileInfo{
name: base,
dir: true,
mode: perm,
parent: parent,
modTime: time.Now(),
fs: fs,
}
parent.childs[base] = fi
return nil
} | go | func (fs *MemFS) Mkdir(name string, perm os.FileMode) error {
fs.lock.Lock()
defer fs.lock.Unlock()
name = filepath.Clean(name)
base := filepath.Base(name)
parent, fi, err := fs.fileInfo(name)
if err != nil {
return &os.PathError{"mkdir", name, err}
}
if fi != nil {
return &os.PathError{"mkdir", name, fmt.Errorf("Directory %q already exists", name)}
}
fi = &fileInfo{
name: base,
dir: true,
mode: perm,
parent: parent,
modTime: time.Now(),
fs: fs,
}
parent.childs[base] = fi
return nil
} | [
"func",
"(",
"fs",
"*",
"MemFS",
")",
"Mkdir",
"(",
"name",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"fs",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fs",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"name",
"=",
"filepath",
".",
"Clean",
"(",
"name",
")",
"\n",
"base",
":=",
"filepath",
".",
"Base",
"(",
"name",
")",
"\n",
"parent",
",",
"fi",
",",
"err",
":=",
"fs",
".",
"fileInfo",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"err",
"}",
"\n",
"}",
"\n",
"if",
"fi",
"!=",
"nil",
"{",
"return",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"}",
"\n",
"}",
"\n\n",
"fi",
"=",
"&",
"fileInfo",
"{",
"name",
":",
"base",
",",
"dir",
":",
"true",
",",
"mode",
":",
"perm",
",",
"parent",
":",
"parent",
",",
"modTime",
":",
"time",
".",
"Now",
"(",
")",
",",
"fs",
":",
"fs",
",",
"}",
"\n",
"parent",
".",
"childs",
"[",
"base",
"]",
"=",
"fi",
"\n",
"return",
"nil",
"\n",
"}"
]
| // Mkdir creates a new directory with given permissions | [
"Mkdir",
"creates",
"a",
"new",
"directory",
"with",
"given",
"permissions"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/memfs.go#L108-L131 |
10,182 | blang/vfs | memfs/memfs.go | Write | func (f *roFile) Write(p []byte) (n int, err error) {
return 0, ErrReadOnly
} | go | func (f *roFile) Write(p []byte) (n int, err error) {
return 0, ErrReadOnly
} | [
"func",
"(",
"f",
"*",
"roFile",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"0",
",",
"ErrReadOnly",
"\n",
"}"
]
| // Write is disabled and returns ErrorReadOnly | [
"Write",
"is",
"disabled",
"and",
"returns",
"ErrorReadOnly"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/memfs.go#L287-L289 |
10,183 | blang/vfs | memfs/memfs.go | Read | func (f *woFile) Read(p []byte) (n int, err error) {
return 0, ErrWriteOnly
} | go | func (f *woFile) Read(p []byte) (n int, err error) {
return 0, ErrWriteOnly
} | [
"func",
"(",
"f",
"*",
"woFile",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"0",
",",
"ErrWriteOnly",
"\n",
"}"
]
| // Read is disabled and returns ErrorWroteOnly | [
"Read",
"is",
"disabled",
"and",
"returns",
"ErrorWroteOnly"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/memfs.go#L297-L299 |
10,184 | blang/vfs | memfs/buffer.go | makeSlice | func makeSlice(n int) (b []byte, err error) {
// If the make fails, give a known error.
defer func() {
if recover() != nil {
b = nil
err = ErrTooLarge
return
}
}()
b = make([]byte, n)
return
} | go | func makeSlice(n int) (b []byte, err error) {
// If the make fails, give a known error.
defer func() {
if recover() != nil {
b = nil
err = ErrTooLarge
return
}
}()
b = make([]byte, n)
return
} | [
"func",
"makeSlice",
"(",
"n",
"int",
")",
"(",
"b",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"// If the make fails, give a known error.",
"defer",
"func",
"(",
")",
"{",
"if",
"recover",
"(",
")",
"!=",
"nil",
"{",
"b",
"=",
"nil",
"\n",
"err",
"=",
"ErrTooLarge",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"b",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"n",
")",
"\n",
"return",
"\n",
"}"
]
| // makeSlice allocates a slice of size n. If the allocation fails, it panics
// with ErrTooLarge. | [
"makeSlice",
"allocates",
"a",
"slice",
"of",
"size",
"n",
".",
"If",
"the",
"allocation",
"fails",
"it",
"panics",
"with",
"ErrTooLarge",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/memfs/buffer.go#L166-L177 |
10,185 | blang/vfs | dummy.go | OpenFile | func (fs DummyFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
return nil, fs.err
} | go | func (fs DummyFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
return nil, fs.err
} | [
"func",
"(",
"fs",
"DummyFS",
")",
"OpenFile",
"(",
"name",
"string",
",",
"flag",
"int",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"File",
",",
"error",
")",
"{",
"return",
"nil",
",",
"fs",
".",
"err",
"\n",
"}"
]
| // OpenFile returns dummy error | [
"OpenFile",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L25-L27 |
10,186 | blang/vfs | dummy.go | Mkdir | func (fs DummyFS) Mkdir(name string, perm os.FileMode) error {
return fs.err
} | go | func (fs DummyFS) Mkdir(name string, perm os.FileMode) error {
return fs.err
} | [
"func",
"(",
"fs",
"DummyFS",
")",
"Mkdir",
"(",
"name",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"fs",
".",
"err",
"\n",
"}"
]
| // Mkdir returns dummy error | [
"Mkdir",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L40-L42 |
10,187 | blang/vfs | dummy.go | Stat | func (fs DummyFS) Stat(name string) (os.FileInfo, error) {
return nil, fs.err
} | go | func (fs DummyFS) Stat(name string) (os.FileInfo, error) {
return nil, fs.err
} | [
"func",
"(",
"fs",
"DummyFS",
")",
"Stat",
"(",
"name",
"string",
")",
"(",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"return",
"nil",
",",
"fs",
".",
"err",
"\n",
"}"
]
| // Stat returns dummy error | [
"Stat",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L45-L47 |
10,188 | blang/vfs | dummy.go | ReadDir | func (fs DummyFS) ReadDir(path string) ([]os.FileInfo, error) {
return nil, fs.err
} | go | func (fs DummyFS) ReadDir(path string) ([]os.FileInfo, error) {
return nil, fs.err
} | [
"func",
"(",
"fs",
"DummyFS",
")",
"ReadDir",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"return",
"nil",
",",
"fs",
".",
"err",
"\n",
"}"
]
| // ReadDir returns dummy error | [
"ReadDir",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L55-L57 |
10,189 | blang/vfs | dummy.go | Write | func (f DumFile) Write(p []byte) (n int, err error) {
return 0, f.err
} | go | func (f DumFile) Write(p []byte) (n int, err error) {
return 0, f.err
} | [
"func",
"(",
"f",
"DumFile",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"0",
",",
"f",
".",
"err",
"\n",
"}"
]
| // Write returns dummy error | [
"Write",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L100-L102 |
10,190 | blang/vfs | dummy.go | ReadAt | func (f DumFile) ReadAt(p []byte, off int64) (n int, err error) {
return 0, f.err
} | go | func (f DumFile) ReadAt(p []byte, off int64) (n int, err error) {
return 0, f.err
} | [
"func",
"(",
"f",
"DumFile",
")",
"ReadAt",
"(",
"p",
"[",
"]",
"byte",
",",
"off",
"int64",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"0",
",",
"f",
".",
"err",
"\n",
"}"
]
| // ReadAt returns dummy error | [
"ReadAt",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L110-L112 |
10,191 | blang/vfs | dummy.go | Seek | func (f DumFile) Seek(offset int64, whence int) (int64, error) {
return 0, f.err
} | go | func (f DumFile) Seek(offset int64, whence int) (int64, error) {
return 0, f.err
} | [
"func",
"(",
"f",
"DumFile",
")",
"Seek",
"(",
"offset",
"int64",
",",
"whence",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"0",
",",
"f",
".",
"err",
"\n",
"}"
]
| // Seek returns dummy error | [
"Seek",
"returns",
"dummy",
"error"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/dummy.go#L115-L117 |
10,192 | blang/vfs | os.go | OpenFile | func (fs OsFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
return os.OpenFile(name, flag, perm)
} | go | func (fs OsFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
return os.OpenFile(name, flag, perm)
} | [
"func",
"(",
"fs",
"OsFS",
")",
"OpenFile",
"(",
"name",
"string",
",",
"flag",
"int",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"File",
",",
"error",
")",
"{",
"return",
"os",
".",
"OpenFile",
"(",
"name",
",",
"flag",
",",
"perm",
")",
"\n",
"}"
]
| // OpenFile wraps os.OpenFile | [
"OpenFile",
"wraps",
"os",
".",
"OpenFile"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/os.go#L22-L24 |
10,193 | blang/vfs | os.go | Mkdir | func (fs OsFS) Mkdir(name string, perm os.FileMode) error {
return os.Mkdir(name, perm)
} | go | func (fs OsFS) Mkdir(name string, perm os.FileMode) error {
return os.Mkdir(name, perm)
} | [
"func",
"(",
"fs",
"OsFS",
")",
"Mkdir",
"(",
"name",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"os",
".",
"Mkdir",
"(",
"name",
",",
"perm",
")",
"\n",
"}"
]
| // Mkdir wraps os.Mkdir | [
"Mkdir",
"wraps",
"os",
".",
"Mkdir"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/os.go#L32-L34 |
10,194 | blang/vfs | os.go | Rename | func (fs OsFS) Rename(oldpath, newpath string) error {
return os.Rename(oldpath, newpath)
} | go | func (fs OsFS) Rename(oldpath, newpath string) error {
return os.Rename(oldpath, newpath)
} | [
"func",
"(",
"fs",
"OsFS",
")",
"Rename",
"(",
"oldpath",
",",
"newpath",
"string",
")",
"error",
"{",
"return",
"os",
".",
"Rename",
"(",
"oldpath",
",",
"newpath",
")",
"\n",
"}"
]
| // Rename wraps os.Rename | [
"Rename",
"wraps",
"os",
".",
"Rename"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/os.go#L37-L39 |
10,195 | blang/vfs | os.go | ReadDir | func (fs OsFS) ReadDir(path string) ([]os.FileInfo, error) {
return ioutil.ReadDir(path)
} | go | func (fs OsFS) ReadDir(path string) ([]os.FileInfo, error) {
return ioutil.ReadDir(path)
} | [
"func",
"(",
"fs",
"OsFS",
")",
"ReadDir",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"return",
"ioutil",
".",
"ReadDir",
"(",
"path",
")",
"\n",
"}"
]
| // ReadDir wraps ioutil.ReadDir | [
"ReadDir",
"wraps",
"ioutil",
".",
"ReadDir"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/os.go#L52-L54 |
10,196 | blang/vfs | mountfs/mountfs.go | Create | func Create(rootFS vfs.Filesystem) *MountFS {
return &MountFS{
rootFS: rootFS,
mounts: make(map[string]vfs.Filesystem),
parents: make(map[string][]string),
}
} | go | func Create(rootFS vfs.Filesystem) *MountFS {
return &MountFS{
rootFS: rootFS,
mounts: make(map[string]vfs.Filesystem),
parents: make(map[string][]string),
}
} | [
"func",
"Create",
"(",
"rootFS",
"vfs",
".",
"Filesystem",
")",
"*",
"MountFS",
"{",
"return",
"&",
"MountFS",
"{",
"rootFS",
":",
"rootFS",
",",
"mounts",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"vfs",
".",
"Filesystem",
")",
",",
"parents",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
",",
"}",
"\n",
"}"
]
| // Create a new MountFS based on a root filesystem. | [
"Create",
"a",
"new",
"MountFS",
"based",
"on",
"a",
"root",
"filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/mountfs/mountfs.go#L16-L22 |
10,197 | blang/vfs | mountfs/mountfs.go | findMount | func findMount(path string, mounts map[string]vfs.Filesystem, fallback vfs.Filesystem, pathSeparator string) (vfs.Filesystem, string) {
path = filepath.Clean(path)
segs := vfs.SplitPath(path, pathSeparator)
l := len(segs)
for i := l; i > 0; i-- {
mountPath := strings.Join(segs[0:i], pathSeparator)
if fs, ok := mounts[mountPath]; ok {
return fs, "/" + strings.Join(segs[i:l], pathSeparator)
}
}
return fallback, path
} | go | func findMount(path string, mounts map[string]vfs.Filesystem, fallback vfs.Filesystem, pathSeparator string) (vfs.Filesystem, string) {
path = filepath.Clean(path)
segs := vfs.SplitPath(path, pathSeparator)
l := len(segs)
for i := l; i > 0; i-- {
mountPath := strings.Join(segs[0:i], pathSeparator)
if fs, ok := mounts[mountPath]; ok {
return fs, "/" + strings.Join(segs[i:l], pathSeparator)
}
}
return fallback, path
} | [
"func",
"findMount",
"(",
"path",
"string",
",",
"mounts",
"map",
"[",
"string",
"]",
"vfs",
".",
"Filesystem",
",",
"fallback",
"vfs",
".",
"Filesystem",
",",
"pathSeparator",
"string",
")",
"(",
"vfs",
".",
"Filesystem",
",",
"string",
")",
"{",
"path",
"=",
"filepath",
".",
"Clean",
"(",
"path",
")",
"\n",
"segs",
":=",
"vfs",
".",
"SplitPath",
"(",
"path",
",",
"pathSeparator",
")",
"\n",
"l",
":=",
"len",
"(",
"segs",
")",
"\n",
"for",
"i",
":=",
"l",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"mountPath",
":=",
"strings",
".",
"Join",
"(",
"segs",
"[",
"0",
":",
"i",
"]",
",",
"pathSeparator",
")",
"\n",
"if",
"fs",
",",
"ok",
":=",
"mounts",
"[",
"mountPath",
"]",
";",
"ok",
"{",
"return",
"fs",
",",
"\"",
"\"",
"+",
"strings",
".",
"Join",
"(",
"segs",
"[",
"i",
":",
"l",
"]",
",",
"pathSeparator",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fallback",
",",
"path",
"\n",
"}"
]
| // findMount finds a valid mountpoint for the given path.
// It returns the corresponding filesystem and the path inside of this filesystem. | [
"findMount",
"finds",
"a",
"valid",
"mountpoint",
"for",
"the",
"given",
"path",
".",
"It",
"returns",
"the",
"corresponding",
"filesystem",
"and",
"the",
"path",
"inside",
"of",
"this",
"filesystem",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/mountfs/mountfs.go#L75-L86 |
10,198 | blang/vfs | mountfs/mountfs.go | Remove | func (fs MountFS) Remove(name string) error {
mount, innerPath := findMount(name, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
return mount.Remove(innerPath)
} | go | func (fs MountFS) Remove(name string) error {
mount, innerPath := findMount(name, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
return mount.Remove(innerPath)
} | [
"func",
"(",
"fs",
"MountFS",
")",
"Remove",
"(",
"name",
"string",
")",
"error",
"{",
"mount",
",",
"innerPath",
":=",
"findMount",
"(",
"name",
",",
"fs",
".",
"mounts",
",",
"fs",
".",
"rootFS",
",",
"string",
"(",
"fs",
".",
"PathSeparator",
"(",
")",
")",
")",
"\n",
"return",
"mount",
".",
"Remove",
"(",
"innerPath",
")",
"\n",
"}"
]
| // Remove removes a file or directory | [
"Remove",
"removes",
"a",
"file",
"or",
"directory"
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/mountfs/mountfs.go#L108-L111 |
10,199 | blang/vfs | mountfs/mountfs.go | Rename | func (fs MountFS) Rename(oldpath, newpath string) error {
oldMount, oldInnerPath := findMount(oldpath, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
newMount, newInnerPath := findMount(newpath, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
if oldMount != newMount {
return ErrBoundary
}
return oldMount.Rename(oldInnerPath, newInnerPath)
} | go | func (fs MountFS) Rename(oldpath, newpath string) error {
oldMount, oldInnerPath := findMount(oldpath, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
newMount, newInnerPath := findMount(newpath, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
if oldMount != newMount {
return ErrBoundary
}
return oldMount.Rename(oldInnerPath, newInnerPath)
} | [
"func",
"(",
"fs",
"MountFS",
")",
"Rename",
"(",
"oldpath",
",",
"newpath",
"string",
")",
"error",
"{",
"oldMount",
",",
"oldInnerPath",
":=",
"findMount",
"(",
"oldpath",
",",
"fs",
".",
"mounts",
",",
"fs",
".",
"rootFS",
",",
"string",
"(",
"fs",
".",
"PathSeparator",
"(",
")",
")",
")",
"\n",
"newMount",
",",
"newInnerPath",
":=",
"findMount",
"(",
"newpath",
",",
"fs",
".",
"mounts",
",",
"fs",
".",
"rootFS",
",",
"string",
"(",
"fs",
".",
"PathSeparator",
"(",
")",
")",
")",
"\n",
"if",
"oldMount",
"!=",
"newMount",
"{",
"return",
"ErrBoundary",
"\n",
"}",
"\n",
"return",
"oldMount",
".",
"Rename",
"(",
"oldInnerPath",
",",
"newInnerPath",
")",
"\n",
"}"
]
| // Rename renames a file.
// Renames across filesystems are not allowed. | [
"Rename",
"renames",
"a",
"file",
".",
"Renames",
"across",
"filesystems",
"are",
"not",
"allowed",
"."
]
| 2c3e2278e174a74f31ff8bf6f47b43ecb358a870 | https://github.com/blang/vfs/blob/2c3e2278e174a74f31ff8bf6f47b43ecb358a870/mountfs/mountfs.go#L115-L122 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.