repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
perkeep/perkeep | pkg/importer/importer.go | ForeachAttr | func (o *Object) ForeachAttr(fn func(key, value string)) {
o.mu.RLock()
defer o.mu.RUnlock()
for k, vv := range o.attr {
for _, v := range vv {
fn(k, v)
}
}
} | go | func (o *Object) ForeachAttr(fn func(key, value string)) {
o.mu.RLock()
defer o.mu.RUnlock()
for k, vv := range o.attr {
for _, v := range vv {
fn(k, v)
}
}
} | [
"func",
"(",
"o",
"*",
"Object",
")",
"ForeachAttr",
"(",
"fn",
"func",
"(",
"key",
",",
"value",
"string",
")",
")",
"{",
"o",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"o",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"k",
",",
"vv",
":=",
"range",
"o",
".",
"attr",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"vv",
"{",
"fn",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // ForeachAttr runs fn for each of the object's attributes & values.
// There might be multiple values for the same attribute.
// The internal lock is held while running, so no mutations should be
// made or it will deadlock. | [
"ForeachAttr",
"runs",
"fn",
"for",
"each",
"of",
"the",
"object",
"s",
"attributes",
"&",
"values",
".",
"There",
"might",
"be",
"multiple",
"values",
"for",
"the",
"same",
"attribute",
".",
"The",
"internal",
"lock",
"is",
"held",
"while",
"running",
"so",
"no",
"mutations",
"should",
"be",
"made",
"or",
"it",
"will",
"deadlock",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/importer.go#L1416-L1424 | train |
perkeep/perkeep | pkg/importer/importer.go | DelAttr | func (o *Object) DelAttr(key, value string) error {
ctx := context.TODO()
o.mu.Lock()
defer o.mu.Unlock()
_, err := o.h.upload(ctx, schema.NewDelAttributeClaim(o.pn, key, value))
if err != nil {
return err
}
if o.attr == nil {
o.attr = make(map[string][]string)
return nil
}
if value == "" {
delete(o.attr, key)
return nil
}
var values []string
for _, v := range o.attr[key] {
if v != value {
values = append(values, v)
}
}
o.attr[key] = values
return nil
} | go | func (o *Object) DelAttr(key, value string) error {
ctx := context.TODO()
o.mu.Lock()
defer o.mu.Unlock()
_, err := o.h.upload(ctx, schema.NewDelAttributeClaim(o.pn, key, value))
if err != nil {
return err
}
if o.attr == nil {
o.attr = make(map[string][]string)
return nil
}
if value == "" {
delete(o.attr, key)
return nil
}
var values []string
for _, v := range o.attr[key] {
if v != value {
values = append(values, v)
}
}
o.attr[key] = values
return nil
} | [
"func",
"(",
"o",
"*",
"Object",
")",
"DelAttr",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"o",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"o",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"o",
".",
"h",
".",
"upload",
"(",
"ctx",
",",
"schema",
".",
"NewDelAttributeClaim",
"(",
"o",
".",
"pn",
",",
"key",
",",
"value",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"o",
".",
"attr",
"==",
"nil",
"{",
"o",
".",
"attr",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"value",
"==",
"\"\"",
"{",
"delete",
"(",
"o",
".",
"attr",
",",
"key",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"values",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"o",
".",
"attr",
"[",
"key",
"]",
"{",
"if",
"v",
"!=",
"value",
"{",
"values",
"=",
"append",
"(",
"values",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"o",
".",
"attr",
"[",
"key",
"]",
"=",
"values",
"\n",
"return",
"nil",
"\n",
"}"
] | // DelAttr removes value from the values set for the attribute attr of
// permaNode. If value is empty then all the values for attribute are cleared. | [
"DelAttr",
"removes",
"value",
"from",
"the",
"values",
"set",
"for",
"the",
"attribute",
"attr",
"of",
"permaNode",
".",
"If",
"value",
"is",
"empty",
"then",
"all",
"the",
"values",
"for",
"attribute",
"are",
"cleared",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/importer.go#L1428-L1452 | train |
perkeep/perkeep | pkg/importer/importer.go | SetAttr | func (o *Object) SetAttr(key, value string) error {
ctx := context.TODO() // TODO: make it possible to get a context via Object; either new context field, or via some "ImportRun" field?
if o.Attr(key) == value {
return nil
}
_, err := o.h.upload(ctx, schema.NewSetAttributeClaim(o.pn, key, value))
if err != nil {
return err
}
o.mu.Lock()
defer o.mu.Unlock()
if o.attr == nil {
o.attr = make(map[string][]string)
}
o.attr[key] = []string{value}
return nil
} | go | func (o *Object) SetAttr(key, value string) error {
ctx := context.TODO() // TODO: make it possible to get a context via Object; either new context field, or via some "ImportRun" field?
if o.Attr(key) == value {
return nil
}
_, err := o.h.upload(ctx, schema.NewSetAttributeClaim(o.pn, key, value))
if err != nil {
return err
}
o.mu.Lock()
defer o.mu.Unlock()
if o.attr == nil {
o.attr = make(map[string][]string)
}
o.attr[key] = []string{value}
return nil
} | [
"func",
"(",
"o",
"*",
"Object",
")",
"SetAttr",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"if",
"o",
".",
"Attr",
"(",
"key",
")",
"==",
"value",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"o",
".",
"h",
".",
"upload",
"(",
"ctx",
",",
"schema",
".",
"NewSetAttributeClaim",
"(",
"o",
".",
"pn",
",",
"key",
",",
"value",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"o",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"o",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"o",
".",
"attr",
"==",
"nil",
"{",
"o",
".",
"attr",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"}",
"\n",
"o",
".",
"attr",
"[",
"key",
"]",
"=",
"[",
"]",
"string",
"{",
"value",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetAttr sets the attribute key to value. | [
"SetAttr",
"sets",
"the",
"attribute",
"key",
"to",
"value",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/importer.go#L1455-L1471 | train |
perkeep/perkeep | pkg/importer/importer.go | SetAttrValues | func (o *Object) SetAttrValues(key string, attrs []string) error {
ctx := context.TODO() // TODO: make it possible to get a context via Object; either new context field, or via some "ImportRun" field?
exists := asSet(o.Attrs(key))
actual := asSet(attrs)
o.mu.Lock()
defer o.mu.Unlock()
// add new values
for v := range actual {
if exists[v] {
delete(exists, v)
continue
}
_, err := o.h.upload(ctx, schema.NewAddAttributeClaim(o.pn, key, v))
if err != nil {
return err
}
}
// delete unneeded values
for v := range exists {
_, err := o.h.upload(ctx, schema.NewDelAttributeClaim(o.pn, key, v))
if err != nil {
return err
}
}
if o.attr == nil {
o.attr = make(map[string][]string)
}
o.attr[key] = attrs
return nil
} | go | func (o *Object) SetAttrValues(key string, attrs []string) error {
ctx := context.TODO() // TODO: make it possible to get a context via Object; either new context field, or via some "ImportRun" field?
exists := asSet(o.Attrs(key))
actual := asSet(attrs)
o.mu.Lock()
defer o.mu.Unlock()
// add new values
for v := range actual {
if exists[v] {
delete(exists, v)
continue
}
_, err := o.h.upload(ctx, schema.NewAddAttributeClaim(o.pn, key, v))
if err != nil {
return err
}
}
// delete unneeded values
for v := range exists {
_, err := o.h.upload(ctx, schema.NewDelAttributeClaim(o.pn, key, v))
if err != nil {
return err
}
}
if o.attr == nil {
o.attr = make(map[string][]string)
}
o.attr[key] = attrs
return nil
} | [
"func",
"(",
"o",
"*",
"Object",
")",
"SetAttrValues",
"(",
"key",
"string",
",",
"attrs",
"[",
"]",
"string",
")",
"error",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"exists",
":=",
"asSet",
"(",
"o",
".",
"Attrs",
"(",
"key",
")",
")",
"\n",
"actual",
":=",
"asSet",
"(",
"attrs",
")",
"\n",
"o",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"o",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"for",
"v",
":=",
"range",
"actual",
"{",
"if",
"exists",
"[",
"v",
"]",
"{",
"delete",
"(",
"exists",
",",
"v",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"o",
".",
"h",
".",
"upload",
"(",
"ctx",
",",
"schema",
".",
"NewAddAttributeClaim",
"(",
"o",
".",
"pn",
",",
"key",
",",
"v",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"v",
":=",
"range",
"exists",
"{",
"_",
",",
"err",
":=",
"o",
".",
"h",
".",
"upload",
"(",
"ctx",
",",
"schema",
".",
"NewDelAttributeClaim",
"(",
"o",
".",
"pn",
",",
"key",
",",
"v",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"o",
".",
"attr",
"==",
"nil",
"{",
"o",
".",
"attr",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"}",
"\n",
"o",
".",
"attr",
"[",
"key",
"]",
"=",
"attrs",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetAttrValues sets multi-valued attribute. | [
"SetAttrValues",
"sets",
"multi",
"-",
"valued",
"attribute",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/importer.go#L1502-L1532 | train |
perkeep/perkeep | pkg/importer/importer.go | ObjectFromRef | func (h *Host) ObjectFromRef(permanodeRef blob.Ref) (*Object, error) {
ctx := context.TODO()
res, err := h.search.Describe(ctx, &search.DescribeRequest{
BlobRef: permanodeRef,
Depth: 1,
})
if err != nil {
return nil, err
}
db, ok := res.Meta[permanodeRef.String()]
if !ok {
return nil, fmt.Errorf("permanode %v wasn't in Describe response", permanodeRef)
}
if db.Permanode == nil {
return nil, fmt.Errorf("permanode %v had no DescribedPermanode in Describe response", permanodeRef)
}
return &Object{
h: h,
pn: permanodeRef,
attr: map[string][]string(db.Permanode.Attr),
modtime: db.Permanode.ModTime,
}, nil
} | go | func (h *Host) ObjectFromRef(permanodeRef blob.Ref) (*Object, error) {
ctx := context.TODO()
res, err := h.search.Describe(ctx, &search.DescribeRequest{
BlobRef: permanodeRef,
Depth: 1,
})
if err != nil {
return nil, err
}
db, ok := res.Meta[permanodeRef.String()]
if !ok {
return nil, fmt.Errorf("permanode %v wasn't in Describe response", permanodeRef)
}
if db.Permanode == nil {
return nil, fmt.Errorf("permanode %v had no DescribedPermanode in Describe response", permanodeRef)
}
return &Object{
h: h,
pn: permanodeRef,
attr: map[string][]string(db.Permanode.Attr),
modtime: db.Permanode.ModTime,
}, nil
} | [
"func",
"(",
"h",
"*",
"Host",
")",
"ObjectFromRef",
"(",
"permanodeRef",
"blob",
".",
"Ref",
")",
"(",
"*",
"Object",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"res",
",",
"err",
":=",
"h",
".",
"search",
".",
"Describe",
"(",
"ctx",
",",
"&",
"search",
".",
"DescribeRequest",
"{",
"BlobRef",
":",
"permanodeRef",
",",
"Depth",
":",
"1",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"db",
",",
"ok",
":=",
"res",
".",
"Meta",
"[",
"permanodeRef",
".",
"String",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"permanode %v wasn't in Describe response\"",
",",
"permanodeRef",
")",
"\n",
"}",
"\n",
"if",
"db",
".",
"Permanode",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"permanode %v had no DescribedPermanode in Describe response\"",
",",
"permanodeRef",
")",
"\n",
"}",
"\n",
"return",
"&",
"Object",
"{",
"h",
":",
"h",
",",
"pn",
":",
"permanodeRef",
",",
"attr",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"(",
"db",
".",
"Permanode",
".",
"Attr",
")",
",",
"modtime",
":",
"db",
".",
"Permanode",
".",
"ModTime",
",",
"}",
",",
"nil",
"\n",
"}"
] | // ObjectFromRef returns the object given by the named permanode | [
"ObjectFromRef",
"returns",
"the",
"object",
"given",
"by",
"the",
"named",
"permanode"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/importer.go#L1577-L1599 | train |
perkeep/perkeep | pkg/blobserver/memory/mem.go | NewCache | func NewCache(size int64) *Storage {
return &Storage{
maxSize: size,
lru: lru.New(0), // infinite items; we evict by size, not count
}
} | go | func NewCache(size int64) *Storage {
return &Storage{
maxSize: size,
lru: lru.New(0), // infinite items; we evict by size, not count
}
} | [
"func",
"NewCache",
"(",
"size",
"int64",
")",
"*",
"Storage",
"{",
"return",
"&",
"Storage",
"{",
"maxSize",
":",
"size",
",",
"lru",
":",
"lru",
".",
"New",
"(",
"0",
")",
",",
"}",
"\n",
"}"
] | // NewCache returns a cache that won't store more than size bytes.
// Blobs are evicted in LRU order. | [
"NewCache",
"returns",
"a",
"cache",
"that",
"won",
"t",
"store",
"more",
"than",
"size",
"bytes",
".",
"Blobs",
"are",
"evicted",
"in",
"LRU",
"order",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/memory/mem.go#L75-L80 | train |
perkeep/perkeep | pkg/blobserver/memory/mem.go | NumBlobs | func (s *Storage) NumBlobs() int {
s.mu.RLock()
defer s.mu.RUnlock()
return len(s.m)
} | go | func (s *Storage) NumBlobs() int {
s.mu.RLock()
defer s.mu.RUnlock()
return len(s.m)
} | [
"func",
"(",
"s",
"*",
"Storage",
")",
"NumBlobs",
"(",
")",
"int",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"len",
"(",
"s",
".",
"m",
")",
"\n",
"}"
] | // NumBlobs returns the number of blobs stored in s. | [
"NumBlobs",
"returns",
"the",
"number",
"of",
"blobs",
"stored",
"in",
"s",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/memory/mem.go#L287-L291 | train |
perkeep/perkeep | pkg/blobserver/memory/mem.go | SumBlobSize | func (s *Storage) SumBlobSize() int64 {
s.mu.RLock()
defer s.mu.RUnlock()
return s.size
} | go | func (s *Storage) SumBlobSize() int64 {
s.mu.RLock()
defer s.mu.RUnlock()
return s.size
} | [
"func",
"(",
"s",
"*",
"Storage",
")",
"SumBlobSize",
"(",
")",
"int64",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"s",
".",
"size",
"\n",
"}"
] | // SumBlobSize returns the total size in bytes of all the blobs in s. | [
"SumBlobSize",
"returns",
"the",
"total",
"size",
"in",
"bytes",
"of",
"all",
"the",
"blobs",
"in",
"s",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/memory/mem.go#L294-L298 | train |
perkeep/perkeep | pkg/blobserver/memory/mem.go | BlobrefStrings | func (s *Storage) BlobrefStrings() []string {
s.mu.RLock()
defer s.mu.RUnlock()
sorted := make([]string, 0, len(s.m))
for br := range s.m {
sorted = append(sorted, br.String())
}
sort.Strings(sorted)
return sorted
} | go | func (s *Storage) BlobrefStrings() []string {
s.mu.RLock()
defer s.mu.RUnlock()
sorted := make([]string, 0, len(s.m))
for br := range s.m {
sorted = append(sorted, br.String())
}
sort.Strings(sorted)
return sorted
} | [
"func",
"(",
"s",
"*",
"Storage",
")",
"BlobrefStrings",
"(",
")",
"[",
"]",
"string",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"sorted",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"s",
".",
"m",
")",
")",
"\n",
"for",
"br",
":=",
"range",
"s",
".",
"m",
"{",
"sorted",
"=",
"append",
"(",
"sorted",
",",
"br",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"sorted",
")",
"\n",
"return",
"sorted",
"\n",
"}"
] | // BlobrefStrings returns the sorted stringified blobrefs stored in s. | [
"BlobrefStrings",
"returns",
"the",
"sorted",
"stringified",
"blobrefs",
"stored",
"in",
"s",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/memory/mem.go#L301-L310 | train |
perkeep/perkeep | pkg/blobserver/memory/mem.go | Stats | func (s *Storage) Stats() (blobsFetched, bytesFetched int64) {
return atomic.LoadInt64(&s.blobsFetched), atomic.LoadInt64(&s.bytesFetched)
} | go | func (s *Storage) Stats() (blobsFetched, bytesFetched int64) {
return atomic.LoadInt64(&s.blobsFetched), atomic.LoadInt64(&s.bytesFetched)
} | [
"func",
"(",
"s",
"*",
"Storage",
")",
"Stats",
"(",
")",
"(",
"blobsFetched",
",",
"bytesFetched",
"int64",
")",
"{",
"return",
"atomic",
".",
"LoadInt64",
"(",
"&",
"s",
".",
"blobsFetched",
")",
",",
"atomic",
".",
"LoadInt64",
"(",
"&",
"s",
".",
"bytesFetched",
")",
"\n",
"}"
] | // Stats returns the number of blobs and number of bytes that were fetched from s. | [
"Stats",
"returns",
"the",
"number",
"of",
"blobs",
"and",
"number",
"of",
"bytes",
"that",
"were",
"fetched",
"from",
"s",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/memory/mem.go#L313-L315 | train |
perkeep/perkeep | internal/netutil/ident.go | ConnUserid | func ConnUserid(conn net.Conn) (uid int, err error) {
return AddrPairUserid(conn.LocalAddr(), conn.RemoteAddr())
} | go | func ConnUserid(conn net.Conn) (uid int, err error) {
return AddrPairUserid(conn.LocalAddr(), conn.RemoteAddr())
} | [
"func",
"ConnUserid",
"(",
"conn",
"net",
".",
"Conn",
")",
"(",
"uid",
"int",
",",
"err",
"error",
")",
"{",
"return",
"AddrPairUserid",
"(",
"conn",
".",
"LocalAddr",
"(",
")",
",",
"conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}"
] | // ConnUserid returns the uid that owns the given localhost connection.
// The returned error is ErrNotFound if the connection wasn't found. | [
"ConnUserid",
"returns",
"the",
"uid",
"that",
"owns",
"the",
"given",
"localhost",
"connection",
".",
"The",
"returned",
"error",
"is",
"ErrNotFound",
"if",
"the",
"connection",
"wasn",
"t",
"found",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/ident.go#L44-L46 | train |
perkeep/perkeep | website/pk-web/godoc.go | writeNode | func writeNode(w io.Writer, fset *token.FileSet, x interface{}) {
// convert trailing tabs into spaces using a tconv filter
// to ensure a good outcome in most browsers (there may still
// be tabs in comments and strings, but converting those into
// the right number of spaces is much harder)
//
// TODO(gri) rethink printer flags - perhaps tconv can be eliminated
// with an another printer mode (which is more efficiently
// implemented in the printer than here with another layer)
mode := printer.TabIndent | printer.UseSpaces
err := (&printer.Config{Mode: mode, Tabwidth: tabwidth}).Fprint(&tconv{output: w}, fset, x)
if err != nil {
log.Print(err)
}
} | go | func writeNode(w io.Writer, fset *token.FileSet, x interface{}) {
// convert trailing tabs into spaces using a tconv filter
// to ensure a good outcome in most browsers (there may still
// be tabs in comments and strings, but converting those into
// the right number of spaces is much harder)
//
// TODO(gri) rethink printer flags - perhaps tconv can be eliminated
// with an another printer mode (which is more efficiently
// implemented in the printer than here with another layer)
mode := printer.TabIndent | printer.UseSpaces
err := (&printer.Config{Mode: mode, Tabwidth: tabwidth}).Fprint(&tconv{output: w}, fset, x)
if err != nil {
log.Print(err)
}
} | [
"func",
"writeNode",
"(",
"w",
"io",
".",
"Writer",
",",
"fset",
"*",
"token",
".",
"FileSet",
",",
"x",
"interface",
"{",
"}",
")",
"{",
"mode",
":=",
"printer",
".",
"TabIndent",
"|",
"printer",
".",
"UseSpaces",
"\n",
"err",
":=",
"(",
"&",
"printer",
".",
"Config",
"{",
"Mode",
":",
"mode",
",",
"Tabwidth",
":",
"tabwidth",
"}",
")",
".",
"Fprint",
"(",
"&",
"tconv",
"{",
"output",
":",
"w",
"}",
",",
"fset",
",",
"x",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // Write an AST node to w. | [
"Write",
"an",
"AST",
"node",
"to",
"w",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/godoc.go#L138-L152 | train |
perkeep/perkeep | server/perkeepd/ui/goui/selectallbutton/selectall.go | getQuery | func (d SelectAllBtnDef) getQuery() *search.SearchQuery {
predicate := d.Props().callbacks.GetQuery()
if !strings.HasPrefix(predicate, "ref:") {
return &search.SearchQuery{
Limit: -1,
Expression: predicate,
}
}
// If we've got a ref: predicate, assume the given blobRef is a container, and
// find its children.
blobRef := strings.TrimPrefix(predicate, "ref:")
br, ok := blob.Parse(blobRef)
if !ok {
println(`Invalid blobRef in "ref:" predicate: ` + blobRef)
return nil
}
return &search.SearchQuery{
Limit: -1,
Constraint: &search.Constraint{Permanode: &search.PermanodeConstraint{
Relation: &search.RelationConstraint{
Relation: "parent",
Any: &search.Constraint{
BlobRefPrefix: br.String(),
},
},
}},
}
} | go | func (d SelectAllBtnDef) getQuery() *search.SearchQuery {
predicate := d.Props().callbacks.GetQuery()
if !strings.HasPrefix(predicate, "ref:") {
return &search.SearchQuery{
Limit: -1,
Expression: predicate,
}
}
// If we've got a ref: predicate, assume the given blobRef is a container, and
// find its children.
blobRef := strings.TrimPrefix(predicate, "ref:")
br, ok := blob.Parse(blobRef)
if !ok {
println(`Invalid blobRef in "ref:" predicate: ` + blobRef)
return nil
}
return &search.SearchQuery{
Limit: -1,
Constraint: &search.Constraint{Permanode: &search.PermanodeConstraint{
Relation: &search.RelationConstraint{
Relation: "parent",
Any: &search.Constraint{
BlobRefPrefix: br.String(),
},
},
}},
}
} | [
"func",
"(",
"d",
"SelectAllBtnDef",
")",
"getQuery",
"(",
")",
"*",
"search",
".",
"SearchQuery",
"{",
"predicate",
":=",
"d",
".",
"Props",
"(",
")",
".",
"callbacks",
".",
"GetQuery",
"(",
")",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"predicate",
",",
"\"ref:\"",
")",
"{",
"return",
"&",
"search",
".",
"SearchQuery",
"{",
"Limit",
":",
"-",
"1",
",",
"Expression",
":",
"predicate",
",",
"}",
"\n",
"}",
"\n",
"blobRef",
":=",
"strings",
".",
"TrimPrefix",
"(",
"predicate",
",",
"\"ref:\"",
")",
"\n",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"blobRef",
")",
"\n",
"if",
"!",
"ok",
"{",
"println",
"(",
"`Invalid blobRef in \"ref:\" predicate: `",
"+",
"blobRef",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"search",
".",
"SearchQuery",
"{",
"Limit",
":",
"-",
"1",
",",
"Constraint",
":",
"&",
"search",
".",
"Constraint",
"{",
"Permanode",
":",
"&",
"search",
".",
"PermanodeConstraint",
"{",
"Relation",
":",
"&",
"search",
".",
"RelationConstraint",
"{",
"Relation",
":",
"\"parent\"",
",",
"Any",
":",
"&",
"search",
".",
"Constraint",
"{",
"BlobRefPrefix",
":",
"br",
".",
"String",
"(",
")",
",",
"}",
",",
"}",
",",
"}",
"}",
",",
"}",
"\n",
"}"
] | // getQuery returns the query corresponding to the current search in the web UI. | [
"getQuery",
"returns",
"the",
"query",
"corresponding",
"to",
"the",
"current",
"search",
"in",
"the",
"web",
"UI",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/selectallbutton/selectall.go#L145-L173 | train |
perkeep/perkeep | server/perkeepd/ui/goui/selectallbutton/selectall.go | findAll | func (d SelectAllBtnDef) findAll() (map[string]bool, error) {
query := d.getQuery()
if query == nil {
return nil, nil
}
authToken := d.Props().authToken
am, err := auth.TokenOrNone(authToken)
if err != nil {
return nil, fmt.Errorf("Error setting up auth: %v", err)
}
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return nil, err
}
res, err := cl.Query(context.TODO(), query)
if err != nil {
return nil, err
}
blobs := make(map[string]bool, len(res.Blobs))
for _, v := range res.Blobs {
blobs[v.Blob.String()] = true
}
return blobs, nil
} | go | func (d SelectAllBtnDef) findAll() (map[string]bool, error) {
query := d.getQuery()
if query == nil {
return nil, nil
}
authToken := d.Props().authToken
am, err := auth.TokenOrNone(authToken)
if err != nil {
return nil, fmt.Errorf("Error setting up auth: %v", err)
}
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return nil, err
}
res, err := cl.Query(context.TODO(), query)
if err != nil {
return nil, err
}
blobs := make(map[string]bool, len(res.Blobs))
for _, v := range res.Blobs {
blobs[v.Blob.String()] = true
}
return blobs, nil
} | [
"func",
"(",
"d",
"SelectAllBtnDef",
")",
"findAll",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"query",
":=",
"d",
".",
"getQuery",
"(",
")",
"\n",
"if",
"query",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"authToken",
":=",
"d",
".",
"Props",
"(",
")",
".",
"authToken",
"\n",
"am",
",",
"err",
":=",
"auth",
".",
"TokenOrNone",
"(",
"authToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Error setting up auth: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"cl",
",",
"err",
":=",
"client",
".",
"New",
"(",
"client",
".",
"OptionAuthMode",
"(",
"am",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
",",
"err",
":=",
"cl",
".",
"Query",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"blobs",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
",",
"len",
"(",
"res",
".",
"Blobs",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"res",
".",
"Blobs",
"{",
"blobs",
"[",
"v",
".",
"Blob",
".",
"String",
"(",
")",
"]",
"=",
"true",
"\n",
"}",
"\n",
"return",
"blobs",
",",
"nil",
"\n",
"}"
] | // findAll returns all the permanodes matching the current web UI search
// session. The javascript UI code uses a javascript object with blobRefs as
// properties to represent a user's selection of permanodes. Since gopherjs
// converts a Go map to a javascript object, findAll returns such a map so it
// matches directly what the UI code wants as a selection object. | [
"findAll",
"returns",
"all",
"the",
"permanodes",
"matching",
"the",
"current",
"web",
"UI",
"search",
"session",
".",
"The",
"javascript",
"UI",
"code",
"uses",
"a",
"javascript",
"object",
"with",
"blobRefs",
"as",
"properties",
"to",
"represent",
"a",
"user",
"s",
"selection",
"of",
"permanodes",
".",
"Since",
"gopherjs",
"converts",
"a",
"Go",
"map",
"to",
"a",
"javascript",
"object",
"findAll",
"returns",
"such",
"a",
"map",
"so",
"it",
"matches",
"directly",
"what",
"the",
"UI",
"code",
"wants",
"as",
"a",
"selection",
"object",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/selectallbutton/selectall.go#L180-L203 | train |
perkeep/perkeep | pkg/app/app.go | Client | func Client() (*client.Client, error) {
server := os.Getenv("CAMLI_API_HOST")
if server == "" {
return nil, errors.New("CAMLI_API_HOST var not set")
}
am, err := basicAuth()
if err != nil {
return nil, err
}
return client.New(
client.OptionNoExternalConfig(),
client.OptionServer(server),
client.OptionAuthMode(am),
)
} | go | func Client() (*client.Client, error) {
server := os.Getenv("CAMLI_API_HOST")
if server == "" {
return nil, errors.New("CAMLI_API_HOST var not set")
}
am, err := basicAuth()
if err != nil {
return nil, err
}
return client.New(
client.OptionNoExternalConfig(),
client.OptionServer(server),
client.OptionAuthMode(am),
)
} | [
"func",
"Client",
"(",
")",
"(",
"*",
"client",
".",
"Client",
",",
"error",
")",
"{",
"server",
":=",
"os",
".",
"Getenv",
"(",
"\"CAMLI_API_HOST\"",
")",
"\n",
"if",
"server",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"CAMLI_API_HOST var not set\"",
")",
"\n",
"}",
"\n",
"am",
",",
"err",
":=",
"basicAuth",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"client",
".",
"New",
"(",
"client",
".",
"OptionNoExternalConfig",
"(",
")",
",",
"client",
".",
"OptionServer",
"(",
"server",
")",
",",
"client",
".",
"OptionAuthMode",
"(",
"am",
")",
",",
")",
"\n",
"}"
] | // Client returns a Perkeep client as defined by environment variables
// automatically supplied by the Perkeep server host. | [
"Client",
"returns",
"a",
"Perkeep",
"client",
"as",
"defined",
"by",
"environment",
"variables",
"automatically",
"supplied",
"by",
"the",
"Perkeep",
"server",
"host",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/app/app.go#L55-L69 | train |
perkeep/perkeep | cmd/pk/sync.go | storageFromParam | func (c *syncCmd) storageFromParam(which storageType, val string) (blobserver.Storage, error) {
var httpClient *http.Client
if val == "" {
switch which {
case storageThird:
return nil, nil
case storageSource:
discl := c.discoClient()
src, err := discl.BlobRoot()
if err != nil {
return nil, fmt.Errorf("Failed to discover source server's blob path: %v", err)
}
val = src
httpClient = discl.HTTPClient()
}
if val == "" {
return nil, cmdmain.UsageError("No --" + string(which) + " flag value specified")
}
}
if which == storageDest && val == "stdout" {
return nil, nil
}
if looksLikePath(val) {
disk, err := localdisk.New(val)
if err != nil {
return nil, fmt.Errorf("Interpreted --%v=%q as a local disk path, but got error: %v", which, val, err)
}
c.oneIsDisk = true
return disk, nil
}
cl, err := client.New(client.OptionServer(val), client.OptionInsecure(c.insecureTLS))
if err != nil {
return nil, fmt.Errorf("creating client for %q: %v", val, err)
}
if httpClient != nil {
cl.SetHTTPClient(httpClient)
}
if err := cl.SetupAuth(); err != nil {
return nil, fmt.Errorf("could not setup auth for connecting to %v: %v", val, err)
}
cl.Verbose = *cmdmain.FlagVerbose
cl.Logger = log.New(cmdmain.Stderr, "", log.LstdFlags)
serverKeyID, err := cl.ServerKeyID()
if err != nil && err != client.ErrNoSigning {
fmt.Fprintf(cmdmain.Stderr, "Failed to discover keyId for server %v: %v", val, err)
} else {
if which == storageSource {
c.srcKeyID = serverKeyID
} else if which == storageDest {
c.destKeyID = serverKeyID
}
}
return cl, nil
} | go | func (c *syncCmd) storageFromParam(which storageType, val string) (blobserver.Storage, error) {
var httpClient *http.Client
if val == "" {
switch which {
case storageThird:
return nil, nil
case storageSource:
discl := c.discoClient()
src, err := discl.BlobRoot()
if err != nil {
return nil, fmt.Errorf("Failed to discover source server's blob path: %v", err)
}
val = src
httpClient = discl.HTTPClient()
}
if val == "" {
return nil, cmdmain.UsageError("No --" + string(which) + " flag value specified")
}
}
if which == storageDest && val == "stdout" {
return nil, nil
}
if looksLikePath(val) {
disk, err := localdisk.New(val)
if err != nil {
return nil, fmt.Errorf("Interpreted --%v=%q as a local disk path, but got error: %v", which, val, err)
}
c.oneIsDisk = true
return disk, nil
}
cl, err := client.New(client.OptionServer(val), client.OptionInsecure(c.insecureTLS))
if err != nil {
return nil, fmt.Errorf("creating client for %q: %v", val, err)
}
if httpClient != nil {
cl.SetHTTPClient(httpClient)
}
if err := cl.SetupAuth(); err != nil {
return nil, fmt.Errorf("could not setup auth for connecting to %v: %v", val, err)
}
cl.Verbose = *cmdmain.FlagVerbose
cl.Logger = log.New(cmdmain.Stderr, "", log.LstdFlags)
serverKeyID, err := cl.ServerKeyID()
if err != nil && err != client.ErrNoSigning {
fmt.Fprintf(cmdmain.Stderr, "Failed to discover keyId for server %v: %v", val, err)
} else {
if which == storageSource {
c.srcKeyID = serverKeyID
} else if which == storageDest {
c.destKeyID = serverKeyID
}
}
return cl, nil
} | [
"func",
"(",
"c",
"*",
"syncCmd",
")",
"storageFromParam",
"(",
"which",
"storageType",
",",
"val",
"string",
")",
"(",
"blobserver",
".",
"Storage",
",",
"error",
")",
"{",
"var",
"httpClient",
"*",
"http",
".",
"Client",
"\n",
"if",
"val",
"==",
"\"\"",
"{",
"switch",
"which",
"{",
"case",
"storageThird",
":",
"return",
"nil",
",",
"nil",
"\n",
"case",
"storageSource",
":",
"discl",
":=",
"c",
".",
"discoClient",
"(",
")",
"\n",
"src",
",",
"err",
":=",
"discl",
".",
"BlobRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Failed to discover source server's blob path: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"val",
"=",
"src",
"\n",
"httpClient",
"=",
"discl",
".",
"HTTPClient",
"(",
")",
"\n",
"}",
"\n",
"if",
"val",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"cmdmain",
".",
"UsageError",
"(",
"\"No --\"",
"+",
"string",
"(",
"which",
")",
"+",
"\" flag value specified\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"which",
"==",
"storageDest",
"&&",
"val",
"==",
"\"stdout\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"if",
"looksLikePath",
"(",
"val",
")",
"{",
"disk",
",",
"err",
":=",
"localdisk",
".",
"New",
"(",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Interpreted --%v=%q as a local disk path, but got error: %v\"",
",",
"which",
",",
"val",
",",
"err",
")",
"\n",
"}",
"\n",
"c",
".",
"oneIsDisk",
"=",
"true",
"\n",
"return",
"disk",
",",
"nil",
"\n",
"}",
"\n",
"cl",
",",
"err",
":=",
"client",
".",
"New",
"(",
"client",
".",
"OptionServer",
"(",
"val",
")",
",",
"client",
".",
"OptionInsecure",
"(",
"c",
".",
"insecureTLS",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"creating client for %q: %v\"",
",",
"val",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"httpClient",
"!=",
"nil",
"{",
"cl",
".",
"SetHTTPClient",
"(",
"httpClient",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"cl",
".",
"SetupAuth",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not setup auth for connecting to %v: %v\"",
",",
"val",
",",
"err",
")",
"\n",
"}",
"\n",
"cl",
".",
"Verbose",
"=",
"*",
"cmdmain",
".",
"FlagVerbose",
"\n",
"cl",
".",
"Logger",
"=",
"log",
".",
"New",
"(",
"cmdmain",
".",
"Stderr",
",",
"\"\"",
",",
"log",
".",
"LstdFlags",
")",
"\n",
"serverKeyID",
",",
"err",
":=",
"cl",
".",
"ServerKeyID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"client",
".",
"ErrNoSigning",
"{",
"fmt",
".",
"Fprintf",
"(",
"cmdmain",
".",
"Stderr",
",",
"\"Failed to discover keyId for server %v: %v\"",
",",
"val",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"if",
"which",
"==",
"storageSource",
"{",
"c",
".",
"srcKeyID",
"=",
"serverKeyID",
"\n",
"}",
"else",
"if",
"which",
"==",
"storageDest",
"{",
"c",
".",
"destKeyID",
"=",
"serverKeyID",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"cl",
",",
"nil",
"\n",
"}"
] | // which is one of "src", "dest", or "thirdleg" | [
"which",
"is",
"one",
"of",
"src",
"dest",
"or",
"thirdleg"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk/sync.go#L160-L214 | train |
perkeep/perkeep | pkg/client/remove.go | RemoveBlobs | func (c *Client) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if c.sto != nil {
return c.sto.RemoveBlobs(ctx, blobs)
}
pfx, err := c.prefix()
if err != nil {
return err
}
url_ := fmt.Sprintf("%s/camli/remove", pfx)
params := make(url.Values) // "blobN" -> BlobRefStr
needsDelete := make(map[blob.Ref]bool) // BlobRefStr -> true
for n, b := range blobs {
if !b.Valid() {
return errors.New("Cannot delete invalid blobref")
}
key := fmt.Sprintf("blob%v", n+1)
params.Add(key, b.String())
needsDelete[b] = true
}
req, err := http.NewRequest("POST", url_, strings.NewReader(params.Encode()))
if err != nil {
return fmt.Errorf("Error creating RemoveBlobs POST request: %v", err)
}
req = req.WithContext(ctx)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
c.authMode.AddAuthHeader(req)
resp, err := c.httpClient.Do(req)
if err != nil {
resp.Body.Close()
return fmt.Errorf("Got status code %d from blobserver for remove %s", resp.StatusCode, params.Encode())
}
var remResp handlers.RemoveResponse
decodeErr := httputil.DecodeJSON(resp, &remResp)
if resp.StatusCode != 200 {
resp.Body.Close()
if decodeErr == nil {
return fmt.Errorf("invalid http response %d in remove response: %v", resp.StatusCode, remResp.Error)
} else {
return fmt.Errorf("invalid http response %d in remove response", resp.StatusCode)
}
}
if decodeErr != nil {
return fmt.Errorf("failed to parse remove response: %v", err)
}
for _, br := range remResp.Removed {
delete(needsDelete, br)
}
if len(needsDelete) > 0 {
return fmt.Errorf("failed to remove blobs %s", strings.Join(stringKeys(needsDelete), ", "))
}
return nil
} | go | func (c *Client) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if c.sto != nil {
return c.sto.RemoveBlobs(ctx, blobs)
}
pfx, err := c.prefix()
if err != nil {
return err
}
url_ := fmt.Sprintf("%s/camli/remove", pfx)
params := make(url.Values) // "blobN" -> BlobRefStr
needsDelete := make(map[blob.Ref]bool) // BlobRefStr -> true
for n, b := range blobs {
if !b.Valid() {
return errors.New("Cannot delete invalid blobref")
}
key := fmt.Sprintf("blob%v", n+1)
params.Add(key, b.String())
needsDelete[b] = true
}
req, err := http.NewRequest("POST", url_, strings.NewReader(params.Encode()))
if err != nil {
return fmt.Errorf("Error creating RemoveBlobs POST request: %v", err)
}
req = req.WithContext(ctx)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
c.authMode.AddAuthHeader(req)
resp, err := c.httpClient.Do(req)
if err != nil {
resp.Body.Close()
return fmt.Errorf("Got status code %d from blobserver for remove %s", resp.StatusCode, params.Encode())
}
var remResp handlers.RemoveResponse
decodeErr := httputil.DecodeJSON(resp, &remResp)
if resp.StatusCode != 200 {
resp.Body.Close()
if decodeErr == nil {
return fmt.Errorf("invalid http response %d in remove response: %v", resp.StatusCode, remResp.Error)
} else {
return fmt.Errorf("invalid http response %d in remove response", resp.StatusCode)
}
}
if decodeErr != nil {
return fmt.Errorf("failed to parse remove response: %v", err)
}
for _, br := range remResp.Removed {
delete(needsDelete, br)
}
if len(needsDelete) > 0 {
return fmt.Errorf("failed to remove blobs %s", strings.Join(stringKeys(needsDelete), ", "))
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"if",
"c",
".",
"sto",
"!=",
"nil",
"{",
"return",
"c",
".",
"sto",
".",
"RemoveBlobs",
"(",
"ctx",
",",
"blobs",
")",
"\n",
"}",
"\n",
"pfx",
",",
"err",
":=",
"c",
".",
"prefix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"url_",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s/camli/remove\"",
",",
"pfx",
")",
"\n",
"params",
":=",
"make",
"(",
"url",
".",
"Values",
")",
"\n",
"needsDelete",
":=",
"make",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"bool",
")",
"\n",
"for",
"n",
",",
"b",
":=",
"range",
"blobs",
"{",
"if",
"!",
"b",
".",
"Valid",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Cannot delete invalid blobref\"",
")",
"\n",
"}",
"\n",
"key",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"blob%v\"",
",",
"n",
"+",
"1",
")",
"\n",
"params",
".",
"Add",
"(",
"key",
",",
"b",
".",
"String",
"(",
")",
")",
"\n",
"needsDelete",
"[",
"b",
"]",
"=",
"true",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"POST\"",
",",
"url_",
",",
"strings",
".",
"NewReader",
"(",
"params",
".",
"Encode",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Error creating RemoveBlobs POST request: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"req",
"=",
"req",
".",
"WithContext",
"(",
"ctx",
")",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"Content-Type\"",
",",
"\"application/x-www-form-urlencoded\"",
")",
"\n",
"c",
".",
"authMode",
".",
"AddAuthHeader",
"(",
"req",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"httpClient",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Got status code %d from blobserver for remove %s\"",
",",
"resp",
".",
"StatusCode",
",",
"params",
".",
"Encode",
"(",
")",
")",
"\n",
"}",
"\n",
"var",
"remResp",
"handlers",
".",
"RemoveResponse",
"\n",
"decodeErr",
":=",
"httputil",
".",
"DecodeJSON",
"(",
"resp",
",",
"&",
"remResp",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"200",
"{",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"decodeErr",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"invalid http response %d in remove response: %v\"",
",",
"resp",
".",
"StatusCode",
",",
"remResp",
".",
"Error",
")",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"invalid http response %d in remove response\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"decodeErr",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"failed to parse remove response: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"br",
":=",
"range",
"remResp",
".",
"Removed",
"{",
"delete",
"(",
"needsDelete",
",",
"br",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"needsDelete",
")",
">",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"failed to remove blobs %s\"",
",",
"strings",
".",
"Join",
"(",
"stringKeys",
"(",
"needsDelete",
")",
",",
"\", \"",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RemoveBlobs removes the list of blobs. An error is returned if the
// server failed to remove a blob. Removing a non-existent blob isn't
// an error. | [
"RemoveBlobs",
"removes",
"the",
"list",
"of",
"blobs",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"server",
"failed",
"to",
"remove",
"a",
"blob",
".",
"Removing",
"a",
"non",
"-",
"existent",
"blob",
"isn",
"t",
"an",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/remove.go#L35-L87 | train |
perkeep/perkeep | pkg/client/remove.go | RemoveBlob | func (c *Client) RemoveBlob(ctx context.Context, b blob.Ref) error {
return c.RemoveBlobs(ctx, []blob.Ref{b})
} | go | func (c *Client) RemoveBlob(ctx context.Context, b blob.Ref) error {
return c.RemoveBlobs(ctx, []blob.Ref{b})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RemoveBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"error",
"{",
"return",
"c",
".",
"RemoveBlobs",
"(",
"ctx",
",",
"[",
"]",
"blob",
".",
"Ref",
"{",
"b",
"}",
")",
"\n",
"}"
] | // RemoveBlob removes the provided blob. An error is returned if the server failed to remove
// the blob. Removing a non-existent blob isn't an error. | [
"RemoveBlob",
"removes",
"the",
"provided",
"blob",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"server",
"failed",
"to",
"remove",
"the",
"blob",
".",
"Removing",
"a",
"non",
"-",
"existent",
"blob",
"isn",
"t",
"an",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/remove.go#L91-L93 | train |
perkeep/perkeep | cmd/pk/list.go | setClient | func (c *listCmd) setClient() error {
ss, err := c.syncCmd.storageFromParam("src", c.syncCmd.src)
if err != nil {
fmt.Errorf("Could not set client for describe requests: %v", err)
}
var ok bool
c.cl, ok = ss.(*client.Client)
if !ok {
return fmt.Errorf("storageFromParam returned a %T, was expecting a *client.Client", ss)
}
return nil
} | go | func (c *listCmd) setClient() error {
ss, err := c.syncCmd.storageFromParam("src", c.syncCmd.src)
if err != nil {
fmt.Errorf("Could not set client for describe requests: %v", err)
}
var ok bool
c.cl, ok = ss.(*client.Client)
if !ok {
return fmt.Errorf("storageFromParam returned a %T, was expecting a *client.Client", ss)
}
return nil
} | [
"func",
"(",
"c",
"*",
"listCmd",
")",
"setClient",
"(",
")",
"error",
"{",
"ss",
",",
"err",
":=",
"c",
".",
"syncCmd",
".",
"storageFromParam",
"(",
"\"src\"",
",",
"c",
".",
"syncCmd",
".",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Errorf",
"(",
"\"Could not set client for describe requests: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"ok",
"bool",
"\n",
"c",
".",
"cl",
",",
"ok",
"=",
"ss",
".",
"(",
"*",
"client",
".",
"Client",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"storageFromParam returned a %T, was expecting a *client.Client\"",
",",
"ss",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // setClient configures a client for c, for the describe requests. | [
"setClient",
"configures",
"a",
"client",
"for",
"c",
"for",
"the",
"describe",
"requests",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk/list.go#L147-L158 | train |
perkeep/perkeep | internal/httputil/faketransport.go | NewRegexpFakeTransport | func NewRegexpFakeTransport(allMatchers []*Matcher) (http.RoundTripper, error) {
var result regexpFakeTransport = []*regexPair{}
for _, matcher := range allMatchers {
r, err := regexp.Compile(matcher.URLRegex)
if err != nil {
return nil, err
}
pair := regexPair{r, matcher.Fn}
result = append(result, &pair)
}
return result, nil
} | go | func NewRegexpFakeTransport(allMatchers []*Matcher) (http.RoundTripper, error) {
var result regexpFakeTransport = []*regexPair{}
for _, matcher := range allMatchers {
r, err := regexp.Compile(matcher.URLRegex)
if err != nil {
return nil, err
}
pair := regexPair{r, matcher.Fn}
result = append(result, &pair)
}
return result, nil
} | [
"func",
"NewRegexpFakeTransport",
"(",
"allMatchers",
"[",
"]",
"*",
"Matcher",
")",
"(",
"http",
".",
"RoundTripper",
",",
"error",
")",
"{",
"var",
"result",
"regexpFakeTransport",
"=",
"[",
"]",
"*",
"regexPair",
"{",
"}",
"\n",
"for",
"_",
",",
"matcher",
":=",
"range",
"allMatchers",
"{",
"r",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"matcher",
".",
"URLRegex",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"pair",
":=",
"regexPair",
"{",
"r",
",",
"matcher",
".",
"Fn",
"}",
"\n",
"result",
"=",
"append",
"(",
"result",
",",
"&",
"pair",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // NewRegexpFakeTransport takes a slice of Matchers and returns an
// http.RoundTripper that will apply the function associated with the
// first UrlRegex that matches. | [
"NewRegexpFakeTransport",
"takes",
"a",
"slice",
"of",
"Matchers",
"and",
"returns",
"an",
"http",
".",
"RoundTripper",
"that",
"will",
"apply",
"the",
"function",
"associated",
"with",
"the",
"first",
"UrlRegex",
"that",
"matches",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/faketransport.go#L57-L68 | train |
perkeep/perkeep | internal/httputil/faketransport.go | FileResponder | func FileResponder(filename string) func() *http.Response {
return func() *http.Response {
f, err := os.Open(filename)
if err != nil {
return &http.Response{StatusCode: 404, Status: "404 Not Found", Body: types.EmptyBody}
}
return &http.Response{StatusCode: 200, Status: "200 OK", Body: f}
}
} | go | func FileResponder(filename string) func() *http.Response {
return func() *http.Response {
f, err := os.Open(filename)
if err != nil {
return &http.Response{StatusCode: 404, Status: "404 Not Found", Body: types.EmptyBody}
}
return &http.Response{StatusCode: 200, Status: "200 OK", Body: f}
}
} | [
"func",
"FileResponder",
"(",
"filename",
"string",
")",
"func",
"(",
")",
"*",
"http",
".",
"Response",
"{",
"return",
"func",
"(",
")",
"*",
"http",
".",
"Response",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"http",
".",
"Response",
"{",
"StatusCode",
":",
"404",
",",
"Status",
":",
"\"404 Not Found\"",
",",
"Body",
":",
"types",
".",
"EmptyBody",
"}",
"\n",
"}",
"\n",
"return",
"&",
"http",
".",
"Response",
"{",
"StatusCode",
":",
"200",
",",
"Status",
":",
"\"200 OK\"",
",",
"Body",
":",
"f",
"}",
"\n",
"}",
"\n",
"}"
] | // FileResponder returns an HTTP response generator that returns the
// contents of the named file. | [
"FileResponder",
"returns",
"an",
"HTTP",
"response",
"generator",
"that",
"returns",
"the",
"contents",
"of",
"the",
"named",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/faketransport.go#L89-L97 | train |
perkeep/perkeep | internal/httputil/faketransport.go | StaticResponder | func StaticResponder(res string) func() *http.Response {
_, err := http.ReadResponse(bufio.NewReader(strings.NewReader(res)), nil)
if err != nil {
panic("Invalid response given to StaticResponder: " + err.Error())
}
return func() *http.Response {
res, _ := http.ReadResponse(bufio.NewReader(strings.NewReader(res)), nil)
return res
}
} | go | func StaticResponder(res string) func() *http.Response {
_, err := http.ReadResponse(bufio.NewReader(strings.NewReader(res)), nil)
if err != nil {
panic("Invalid response given to StaticResponder: " + err.Error())
}
return func() *http.Response {
res, _ := http.ReadResponse(bufio.NewReader(strings.NewReader(res)), nil)
return res
}
} | [
"func",
"StaticResponder",
"(",
"res",
"string",
")",
"func",
"(",
")",
"*",
"http",
".",
"Response",
"{",
"_",
",",
"err",
":=",
"http",
".",
"ReadResponse",
"(",
"bufio",
".",
"NewReader",
"(",
"strings",
".",
"NewReader",
"(",
"res",
")",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"Invalid response given to StaticResponder: \"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
")",
"*",
"http",
".",
"Response",
"{",
"res",
",",
"_",
":=",
"http",
".",
"ReadResponse",
"(",
"bufio",
".",
"NewReader",
"(",
"strings",
".",
"NewReader",
"(",
"res",
")",
")",
",",
"nil",
")",
"\n",
"return",
"res",
"\n",
"}",
"\n",
"}"
] | // StaticResponder returns an HTTP response generator that parses res
// for an entire HTTP response, including headers and body. | [
"StaticResponder",
"returns",
"an",
"HTTP",
"response",
"generator",
"that",
"parses",
"res",
"for",
"an",
"entire",
"HTTP",
"response",
"including",
"headers",
"and",
"body",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/faketransport.go#L101-L110 | train |
perkeep/perkeep | internal/video/thumbnail/thumbnailer.go | Command | func (f FFmpegThumbnailer) Command(uri *url.URL) (string, []string) {
return "ffmpeg", []string{
"-seekable", "1",
"-i", uri.String(),
"-vf", "thumbnail",
"-frames:v", "1",
"-f", "image2pipe",
"-c:v", "png",
"pipe:1",
}
} | go | func (f FFmpegThumbnailer) Command(uri *url.URL) (string, []string) {
return "ffmpeg", []string{
"-seekable", "1",
"-i", uri.String(),
"-vf", "thumbnail",
"-frames:v", "1",
"-f", "image2pipe",
"-c:v", "png",
"pipe:1",
}
} | [
"func",
"(",
"f",
"FFmpegThumbnailer",
")",
"Command",
"(",
"uri",
"*",
"url",
".",
"URL",
")",
"(",
"string",
",",
"[",
"]",
"string",
")",
"{",
"return",
"\"ffmpeg\"",
",",
"[",
"]",
"string",
"{",
"\"-seekable\"",
",",
"\"1\"",
",",
"\"-i\"",
",",
"uri",
".",
"String",
"(",
")",
",",
"\"-vf\"",
",",
"\"thumbnail\"",
",",
"\"-frames:v\"",
",",
"\"1\"",
",",
"\"-f\"",
",",
"\"image2pipe\"",
",",
"\"-c:v\"",
",",
"\"png\"",
",",
"\"pipe:1\"",
",",
"}",
"\n",
"}"
] | // Command implements the Command method for the Thumbnailer interface. | [
"Command",
"implements",
"the",
"Command",
"method",
"for",
"the",
"Thumbnailer",
"interface",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/video/thumbnail/thumbnailer.go#L48-L58 | train |
perkeep/perkeep | pkg/sorted/kv.go | NewKeyValue | func NewKeyValue(cfg jsonconfig.Obj) (KeyValue, error) {
var s KeyValue
var err error
typ := cfg.RequiredString("type")
ctor, ok := ctors[typ]
if typ != "" && !ok {
return nil, fmt.Errorf("Invalid sorted.KeyValue type %q", typ)
}
if ok {
s, err = ctor(cfg)
if err != nil {
we, ok := err.(NeedWipeError)
if !ok {
return nil, fmt.Errorf("error from %q KeyValue: %v", typ, err)
}
if err := cfg.Validate(); err != nil {
return nil, err
}
we.Msg = fmt.Sprintf("error from %q KeyValue: %v", typ, err)
return s, we
}
}
return s, cfg.Validate()
} | go | func NewKeyValue(cfg jsonconfig.Obj) (KeyValue, error) {
var s KeyValue
var err error
typ := cfg.RequiredString("type")
ctor, ok := ctors[typ]
if typ != "" && !ok {
return nil, fmt.Errorf("Invalid sorted.KeyValue type %q", typ)
}
if ok {
s, err = ctor(cfg)
if err != nil {
we, ok := err.(NeedWipeError)
if !ok {
return nil, fmt.Errorf("error from %q KeyValue: %v", typ, err)
}
if err := cfg.Validate(); err != nil {
return nil, err
}
we.Msg = fmt.Sprintf("error from %q KeyValue: %v", typ, err)
return s, we
}
}
return s, cfg.Validate()
} | [
"func",
"NewKeyValue",
"(",
"cfg",
"jsonconfig",
".",
"Obj",
")",
"(",
"KeyValue",
",",
"error",
")",
"{",
"var",
"s",
"KeyValue",
"\n",
"var",
"err",
"error",
"\n",
"typ",
":=",
"cfg",
".",
"RequiredString",
"(",
"\"type\"",
")",
"\n",
"ctor",
",",
"ok",
":=",
"ctors",
"[",
"typ",
"]",
"\n",
"if",
"typ",
"!=",
"\"\"",
"&&",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Invalid sorted.KeyValue type %q\"",
",",
"typ",
")",
"\n",
"}",
"\n",
"if",
"ok",
"{",
"s",
",",
"err",
"=",
"ctor",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"we",
",",
"ok",
":=",
"err",
".",
"(",
"NeedWipeError",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"error from %q KeyValue: %v\"",
",",
"typ",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"cfg",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"we",
".",
"Msg",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"error from %q KeyValue: %v\"",
",",
"typ",
",",
"err",
")",
"\n",
"return",
"s",
",",
"we",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"s",
",",
"cfg",
".",
"Validate",
"(",
")",
"\n",
"}"
] | // NewKeyValue returns a KeyValue as defined by cfg.
// It returns an error of type NeedWipeError when the returned KeyValue should
// be fixed with Wipe. | [
"NewKeyValue",
"returns",
"a",
"KeyValue",
"as",
"defined",
"by",
"cfg",
".",
"It",
"returns",
"an",
"error",
"of",
"type",
"NeedWipeError",
"when",
"the",
"returned",
"KeyValue",
"should",
"be",
"fixed",
"with",
"Wipe",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/kv.go#L204-L227 | train |
perkeep/perkeep | pkg/sorted/kv.go | NewKeyValueMaybeWipe | func NewKeyValueMaybeWipe(cfg jsonconfig.Obj) (KeyValue, error) {
kv, err := NewKeyValue(cfg)
if err == nil {
return kv, nil
}
if _, ok := err.(NeedWipeError); !ok {
return nil, err
}
wiper, ok := kv.(Wiper)
if !ok {
return nil, fmt.Errorf("storage type %T needs wiping because %v. But it doesn't support sorted.Wiper", err, kv)
}
we := err
if err := wiper.Wipe(); err != nil {
return nil, fmt.Errorf("sorted key/value type %T needed wiping because %v. But could not wipe: %v", kv, we, err)
}
return kv, nil
} | go | func NewKeyValueMaybeWipe(cfg jsonconfig.Obj) (KeyValue, error) {
kv, err := NewKeyValue(cfg)
if err == nil {
return kv, nil
}
if _, ok := err.(NeedWipeError); !ok {
return nil, err
}
wiper, ok := kv.(Wiper)
if !ok {
return nil, fmt.Errorf("storage type %T needs wiping because %v. But it doesn't support sorted.Wiper", err, kv)
}
we := err
if err := wiper.Wipe(); err != nil {
return nil, fmt.Errorf("sorted key/value type %T needed wiping because %v. But could not wipe: %v", kv, we, err)
}
return kv, nil
} | [
"func",
"NewKeyValueMaybeWipe",
"(",
"cfg",
"jsonconfig",
".",
"Obj",
")",
"(",
"KeyValue",
",",
"error",
")",
"{",
"kv",
",",
"err",
":=",
"NewKeyValue",
"(",
"cfg",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"kv",
",",
"nil",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"NeedWipeError",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"wiper",
",",
"ok",
":=",
"kv",
".",
"(",
"Wiper",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"storage type %T needs wiping because %v. But it doesn't support sorted.Wiper\"",
",",
"err",
",",
"kv",
")",
"\n",
"}",
"\n",
"we",
":=",
"err",
"\n",
"if",
"err",
":=",
"wiper",
".",
"Wipe",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"sorted key/value type %T needed wiping because %v. But could not wipe: %v\"",
",",
"kv",
",",
"we",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"kv",
",",
"nil",
"\n",
"}"
] | // NewKeyValueMaybeWipe calls NewKeyValue and wipes the KeyValue if, and only
// if, NewKeyValue has returned a NeedWipeError. | [
"NewKeyValueMaybeWipe",
"calls",
"NewKeyValue",
"and",
"wipes",
"the",
"KeyValue",
"if",
"and",
"only",
"if",
"NewKeyValue",
"has",
"returned",
"a",
"NeedWipeError",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/kv.go#L231-L248 | train |
perkeep/perkeep | pkg/sorted/kv.go | CheckSizes | func CheckSizes(key, value string) error {
if len(key) > MaxKeySize {
return ErrKeyTooLarge
}
if len(value) > MaxValueSize {
return ErrValueTooLarge
}
return nil
} | go | func CheckSizes(key, value string) error {
if len(key) > MaxKeySize {
return ErrKeyTooLarge
}
if len(value) > MaxValueSize {
return ErrValueTooLarge
}
return nil
} | [
"func",
"CheckSizes",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"key",
")",
">",
"MaxKeySize",
"{",
"return",
"ErrKeyTooLarge",
"\n",
"}",
"\n",
"if",
"len",
"(",
"value",
")",
">",
"MaxValueSize",
"{",
"return",
"ErrValueTooLarge",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckSizes returns ErrKeyTooLarge if key does not respect KeyMaxSize or
// ErrValueTooLarge if value does not respect ValueMaxSize | [
"CheckSizes",
"returns",
"ErrKeyTooLarge",
"if",
"key",
"does",
"not",
"respect",
"KeyMaxSize",
"or",
"ErrValueTooLarge",
"if",
"value",
"does",
"not",
"respect",
"ValueMaxSize"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/kv.go#L273-L281 | train |
perkeep/perkeep | pkg/search/query.go | addContinueConstraint | func (q *SearchQuery) addContinueConstraint() error {
cont := q.Continue
if cont == "" {
return nil
}
if q.Constraint.onlyMatchesPermanode() {
tokent, lastbr, ok := parsePermanodeContinueToken(cont)
if !ok {
return errors.New("Unexpected continue token")
}
if q.Sort == LastModifiedDesc || q.Sort == CreatedDesc {
var lastMod, lastCreated time.Time
switch q.Sort {
case LastModifiedDesc:
lastMod = tokent
case CreatedDesc:
lastCreated = tokent
}
baseConstraint := q.Constraint
q.Constraint = &Constraint{
Logical: &LogicalConstraint{
Op: "and",
A: &Constraint{
Permanode: &PermanodeConstraint{
Continue: &PermanodeContinueConstraint{
LastCreated: lastCreated,
LastMod: lastMod,
Last: lastbr,
},
},
},
B: baseConstraint,
},
}
}
return nil
}
return errors.New("token not valid for query type")
} | go | func (q *SearchQuery) addContinueConstraint() error {
cont := q.Continue
if cont == "" {
return nil
}
if q.Constraint.onlyMatchesPermanode() {
tokent, lastbr, ok := parsePermanodeContinueToken(cont)
if !ok {
return errors.New("Unexpected continue token")
}
if q.Sort == LastModifiedDesc || q.Sort == CreatedDesc {
var lastMod, lastCreated time.Time
switch q.Sort {
case LastModifiedDesc:
lastMod = tokent
case CreatedDesc:
lastCreated = tokent
}
baseConstraint := q.Constraint
q.Constraint = &Constraint{
Logical: &LogicalConstraint{
Op: "and",
A: &Constraint{
Permanode: &PermanodeConstraint{
Continue: &PermanodeContinueConstraint{
LastCreated: lastCreated,
LastMod: lastMod,
Last: lastbr,
},
},
},
B: baseConstraint,
},
}
}
return nil
}
return errors.New("token not valid for query type")
} | [
"func",
"(",
"q",
"*",
"SearchQuery",
")",
"addContinueConstraint",
"(",
")",
"error",
"{",
"cont",
":=",
"q",
".",
"Continue",
"\n",
"if",
"cont",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"q",
".",
"Constraint",
".",
"onlyMatchesPermanode",
"(",
")",
"{",
"tokent",
",",
"lastbr",
",",
"ok",
":=",
"parsePermanodeContinueToken",
"(",
"cont",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Unexpected continue token\"",
")",
"\n",
"}",
"\n",
"if",
"q",
".",
"Sort",
"==",
"LastModifiedDesc",
"||",
"q",
".",
"Sort",
"==",
"CreatedDesc",
"{",
"var",
"lastMod",
",",
"lastCreated",
"time",
".",
"Time",
"\n",
"switch",
"q",
".",
"Sort",
"{",
"case",
"LastModifiedDesc",
":",
"lastMod",
"=",
"tokent",
"\n",
"case",
"CreatedDesc",
":",
"lastCreated",
"=",
"tokent",
"\n",
"}",
"\n",
"baseConstraint",
":=",
"q",
".",
"Constraint",
"\n",
"q",
".",
"Constraint",
"=",
"&",
"Constraint",
"{",
"Logical",
":",
"&",
"LogicalConstraint",
"{",
"Op",
":",
"\"and\"",
",",
"A",
":",
"&",
"Constraint",
"{",
"Permanode",
":",
"&",
"PermanodeConstraint",
"{",
"Continue",
":",
"&",
"PermanodeContinueConstraint",
"{",
"LastCreated",
":",
"lastCreated",
",",
"LastMod",
":",
"lastMod",
",",
"Last",
":",
"lastbr",
",",
"}",
",",
"}",
",",
"}",
",",
"B",
":",
"baseConstraint",
",",
"}",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"token not valid for query type\"",
")",
"\n",
"}"
] | // addContinueConstraint conditionally modifies q.Constraint to scroll
// past the results as indicated by q.Continue. | [
"addContinueConstraint",
"conditionally",
"modifies",
"q",
".",
"Constraint",
"to",
"scroll",
"past",
"the",
"results",
"as",
"indicated",
"by",
"q",
".",
"Continue",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L195-L233 | train |
perkeep/perkeep | pkg/search/query.go | matchesPermanodeTypes | func (c *Constraint) matchesPermanodeTypes() []string {
if c == nil {
return nil
}
if pc := c.Permanode; pc != nil && pc.Attr == "camliNodeType" && pc.Value != "" {
return []string{pc.Value}
}
if lc := c.Logical; lc != nil {
sa := lc.A.matchesPermanodeTypes()
sb := lc.B.matchesPermanodeTypes()
switch lc.Op {
case "and":
if len(sa) != 0 {
return sa
}
return sb
case "or":
return append(sa, sb...)
}
}
return nil
} | go | func (c *Constraint) matchesPermanodeTypes() []string {
if c == nil {
return nil
}
if pc := c.Permanode; pc != nil && pc.Attr == "camliNodeType" && pc.Value != "" {
return []string{pc.Value}
}
if lc := c.Logical; lc != nil {
sa := lc.A.matchesPermanodeTypes()
sb := lc.B.matchesPermanodeTypes()
switch lc.Op {
case "and":
if len(sa) != 0 {
return sa
}
return sb
case "or":
return append(sa, sb...)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Constraint",
")",
"matchesPermanodeTypes",
"(",
")",
"[",
"]",
"string",
"{",
"if",
"c",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"pc",
":=",
"c",
".",
"Permanode",
";",
"pc",
"!=",
"nil",
"&&",
"pc",
".",
"Attr",
"==",
"\"camliNodeType\"",
"&&",
"pc",
".",
"Value",
"!=",
"\"\"",
"{",
"return",
"[",
"]",
"string",
"{",
"pc",
".",
"Value",
"}",
"\n",
"}",
"\n",
"if",
"lc",
":=",
"c",
".",
"Logical",
";",
"lc",
"!=",
"nil",
"{",
"sa",
":=",
"lc",
".",
"A",
".",
"matchesPermanodeTypes",
"(",
")",
"\n",
"sb",
":=",
"lc",
".",
"B",
".",
"matchesPermanodeTypes",
"(",
")",
"\n",
"switch",
"lc",
".",
"Op",
"{",
"case",
"\"and\"",
":",
"if",
"len",
"(",
"sa",
")",
"!=",
"0",
"{",
"return",
"sa",
"\n",
"}",
"\n",
"return",
"sb",
"\n",
"case",
"\"or\"",
":",
"return",
"append",
"(",
"sa",
",",
"sb",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // matchesPermanodeTypes returns a set of valid permanode types that a matching
// permanode must have as its "camliNodeType" attribute.
// It returns a zero-length slice if this constraint might include things other
// things. | [
"matchesPermanodeTypes",
"returns",
"a",
"set",
"of",
"valid",
"permanode",
"types",
"that",
"a",
"matching",
"permanode",
"must",
"have",
"as",
"its",
"camliNodeType",
"attribute",
".",
"It",
"returns",
"a",
"zero",
"-",
"length",
"slice",
"if",
"this",
"constraint",
"might",
"include",
"things",
"other",
"things",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L338-L360 | train |
perkeep/perkeep | pkg/search/query.go | matchesAtMostOneBlob | func (c *Constraint) matchesAtMostOneBlob() blob.Ref {
if c == nil {
return blob.Ref{}
}
if c.BlobRefPrefix != "" {
br, ok := blob.Parse(c.BlobRefPrefix)
if ok {
return br
}
}
if c.Logical != nil && c.Logical.Op == "and" {
if br := c.Logical.A.matchesAtMostOneBlob(); br.Valid() {
return br
}
if br := c.Logical.B.matchesAtMostOneBlob(); br.Valid() {
return br
}
}
return blob.Ref{}
} | go | func (c *Constraint) matchesAtMostOneBlob() blob.Ref {
if c == nil {
return blob.Ref{}
}
if c.BlobRefPrefix != "" {
br, ok := blob.Parse(c.BlobRefPrefix)
if ok {
return br
}
}
if c.Logical != nil && c.Logical.Op == "and" {
if br := c.Logical.A.matchesAtMostOneBlob(); br.Valid() {
return br
}
if br := c.Logical.B.matchesAtMostOneBlob(); br.Valid() {
return br
}
}
return blob.Ref{}
} | [
"func",
"(",
"c",
"*",
"Constraint",
")",
"matchesAtMostOneBlob",
"(",
")",
"blob",
".",
"Ref",
"{",
"if",
"c",
"==",
"nil",
"{",
"return",
"blob",
".",
"Ref",
"{",
"}",
"\n",
"}",
"\n",
"if",
"c",
".",
"BlobRefPrefix",
"!=",
"\"\"",
"{",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"c",
".",
"BlobRefPrefix",
")",
"\n",
"if",
"ok",
"{",
"return",
"br",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"c",
".",
"Logical",
"!=",
"nil",
"&&",
"c",
".",
"Logical",
".",
"Op",
"==",
"\"and\"",
"{",
"if",
"br",
":=",
"c",
".",
"Logical",
".",
"A",
".",
"matchesAtMostOneBlob",
"(",
")",
";",
"br",
".",
"Valid",
"(",
")",
"{",
"return",
"br",
"\n",
"}",
"\n",
"if",
"br",
":=",
"c",
".",
"Logical",
".",
"B",
".",
"matchesAtMostOneBlob",
"(",
")",
";",
"br",
".",
"Valid",
"(",
")",
"{",
"return",
"br",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"blob",
".",
"Ref",
"{",
"}",
"\n",
"}"
] | // matchesAtMostOneBlob reports whether this constraint matches at most a single blob.
// If so, it returns that blob. Otherwise it returns a zero, invalid blob.Ref. | [
"matchesAtMostOneBlob",
"reports",
"whether",
"this",
"constraint",
"matches",
"at",
"most",
"a",
"single",
"blob",
".",
"If",
"so",
"it",
"returns",
"that",
"blob",
".",
"Otherwise",
"it",
"returns",
"a",
"zero",
"invalid",
"blob",
".",
"Ref",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L364-L383 | train |
perkeep/perkeep | pkg/search/query.go | setResultContinue | func (q *SearchQuery) setResultContinue(corpus *index.Corpus, res *SearchResult) {
if !q.Constraint.onlyMatchesPermanode() {
return
}
var pnTimeFunc func(blob.Ref) (t time.Time, ok bool)
switch q.Sort {
case LastModifiedDesc:
pnTimeFunc = corpus.PermanodeModtime
case CreatedDesc:
pnTimeFunc = corpus.PermanodeAnyTime
default:
return
}
if q.Limit <= 0 || len(res.Blobs) != q.Limit {
return
}
lastpn := res.Blobs[len(res.Blobs)-1].Blob
t, ok := pnTimeFunc(lastpn)
if !ok {
return
}
res.Continue = fmt.Sprintf("pn:%d:%v", t.UnixNano(), lastpn)
} | go | func (q *SearchQuery) setResultContinue(corpus *index.Corpus, res *SearchResult) {
if !q.Constraint.onlyMatchesPermanode() {
return
}
var pnTimeFunc func(blob.Ref) (t time.Time, ok bool)
switch q.Sort {
case LastModifiedDesc:
pnTimeFunc = corpus.PermanodeModtime
case CreatedDesc:
pnTimeFunc = corpus.PermanodeAnyTime
default:
return
}
if q.Limit <= 0 || len(res.Blobs) != q.Limit {
return
}
lastpn := res.Blobs[len(res.Blobs)-1].Blob
t, ok := pnTimeFunc(lastpn)
if !ok {
return
}
res.Continue = fmt.Sprintf("pn:%d:%v", t.UnixNano(), lastpn)
} | [
"func",
"(",
"q",
"*",
"SearchQuery",
")",
"setResultContinue",
"(",
"corpus",
"*",
"index",
".",
"Corpus",
",",
"res",
"*",
"SearchResult",
")",
"{",
"if",
"!",
"q",
".",
"Constraint",
".",
"onlyMatchesPermanode",
"(",
")",
"{",
"return",
"\n",
"}",
"\n",
"var",
"pnTimeFunc",
"func",
"(",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"\n",
"switch",
"q",
".",
"Sort",
"{",
"case",
"LastModifiedDesc",
":",
"pnTimeFunc",
"=",
"corpus",
".",
"PermanodeModtime",
"\n",
"case",
"CreatedDesc",
":",
"pnTimeFunc",
"=",
"corpus",
".",
"PermanodeAnyTime",
"\n",
"default",
":",
"return",
"\n",
"}",
"\n",
"if",
"q",
".",
"Limit",
"<=",
"0",
"||",
"len",
"(",
"res",
".",
"Blobs",
")",
"!=",
"q",
".",
"Limit",
"{",
"return",
"\n",
"}",
"\n",
"lastpn",
":=",
"res",
".",
"Blobs",
"[",
"len",
"(",
"res",
".",
"Blobs",
")",
"-",
"1",
"]",
".",
"Blob",
"\n",
"t",
",",
"ok",
":=",
"pnTimeFunc",
"(",
"lastpn",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"res",
".",
"Continue",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"pn:%d:%v\"",
",",
"t",
".",
"UnixNano",
"(",
")",
",",
"lastpn",
")",
"\n",
"}"
] | // setResultContinue sets res.Continue if q is suitable for having a continue token.
// The corpus is locked for reads. | [
"setResultContinue",
"sets",
"res",
".",
"Continue",
"if",
"q",
"is",
"suitable",
"for",
"having",
"a",
"continue",
"token",
".",
"The",
"corpus",
"is",
"locked",
"for",
"reads",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L1359-L1382 | train |
perkeep/perkeep | pkg/search/query.go | hasValueConstraint | func (c *PermanodeConstraint) hasValueConstraint() bool {
// If a field has been added or removed, update this after adding the new field to the return statement if necessary.
const expectedFields = 15
if numPermanodeFields != expectedFields {
panic(fmt.Sprintf("PermanodeConstraint field count changed (now %v rather than %v)", numPermanodeFields, expectedFields))
}
return c.Value != "" ||
c.ValueMatches != nil ||
c.ValueMatchesInt != nil ||
c.ValueMatchesFloat != nil ||
c.ValueInSet != nil
} | go | func (c *PermanodeConstraint) hasValueConstraint() bool {
// If a field has been added or removed, update this after adding the new field to the return statement if necessary.
const expectedFields = 15
if numPermanodeFields != expectedFields {
panic(fmt.Sprintf("PermanodeConstraint field count changed (now %v rather than %v)", numPermanodeFields, expectedFields))
}
return c.Value != "" ||
c.ValueMatches != nil ||
c.ValueMatchesInt != nil ||
c.ValueMatchesFloat != nil ||
c.ValueInSet != nil
} | [
"func",
"(",
"c",
"*",
"PermanodeConstraint",
")",
"hasValueConstraint",
"(",
")",
"bool",
"{",
"const",
"expectedFields",
"=",
"15",
"\n",
"if",
"numPermanodeFields",
"!=",
"expectedFields",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"PermanodeConstraint field count changed (now %v rather than %v)\"",
",",
"numPermanodeFields",
",",
"expectedFields",
")",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"Value",
"!=",
"\"\"",
"||",
"c",
".",
"ValueMatches",
"!=",
"nil",
"||",
"c",
".",
"ValueMatchesInt",
"!=",
"nil",
"||",
"c",
".",
"ValueMatchesFloat",
"!=",
"nil",
"||",
"c",
".",
"ValueInSet",
"!=",
"nil",
"\n",
"}"
] | // hasValueConstraint returns true if one or more constraints that check an attribute's value are set. | [
"hasValueConstraint",
"returns",
"true",
"if",
"one",
"or",
"more",
"constraints",
"that",
"check",
"an",
"attribute",
"s",
"value",
"are",
"set",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L1668-L1679 | train |
perkeep/perkeep | pkg/search/query.go | permanodeMatchesAttrVals | func (c *PermanodeConstraint) permanodeMatchesAttrVals(ctx context.Context, s *search, vals []string) (bool, error) {
if c.NumValue != nil && !c.NumValue.intMatches(int64(len(vals))) {
return false, nil
}
if c.hasValueConstraint() {
nmatch := 0
for _, val := range vals {
match, err := c.permanodeMatchesAttrVal(ctx, s, val)
if err != nil {
return false, err
}
if match {
nmatch++
}
}
if nmatch == 0 {
return false, nil
}
if c.ValueAll {
return nmatch == len(vals), nil
}
}
return true, nil
} | go | func (c *PermanodeConstraint) permanodeMatchesAttrVals(ctx context.Context, s *search, vals []string) (bool, error) {
if c.NumValue != nil && !c.NumValue.intMatches(int64(len(vals))) {
return false, nil
}
if c.hasValueConstraint() {
nmatch := 0
for _, val := range vals {
match, err := c.permanodeMatchesAttrVal(ctx, s, val)
if err != nil {
return false, err
}
if match {
nmatch++
}
}
if nmatch == 0 {
return false, nil
}
if c.ValueAll {
return nmatch == len(vals), nil
}
}
return true, nil
} | [
"func",
"(",
"c",
"*",
"PermanodeConstraint",
")",
"permanodeMatchesAttrVals",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
"*",
"search",
",",
"vals",
"[",
"]",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"c",
".",
"NumValue",
"!=",
"nil",
"&&",
"!",
"c",
".",
"NumValue",
".",
"intMatches",
"(",
"int64",
"(",
"len",
"(",
"vals",
")",
")",
")",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"if",
"c",
".",
"hasValueConstraint",
"(",
")",
"{",
"nmatch",
":=",
"0",
"\n",
"for",
"_",
",",
"val",
":=",
"range",
"vals",
"{",
"match",
",",
"err",
":=",
"c",
".",
"permanodeMatchesAttrVal",
"(",
"ctx",
",",
"s",
",",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"match",
"{",
"nmatch",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"nmatch",
"==",
"0",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"if",
"c",
".",
"ValueAll",
"{",
"return",
"nmatch",
"==",
"len",
"(",
"vals",
")",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // permanodeMatchesAttrVals checks that the values in vals - all of them, if c.ValueAll is set -
// match the values for c.Attr.
// vals are the current permanode values of c.Attr. | [
"permanodeMatchesAttrVals",
"checks",
"that",
"the",
"values",
"in",
"vals",
"-",
"all",
"of",
"them",
"if",
"c",
".",
"ValueAll",
"is",
"set",
"-",
"match",
"the",
"values",
"for",
"c",
".",
"Attr",
".",
"vals",
"are",
"the",
"current",
"permanode",
"values",
"of",
"c",
".",
"Attr",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L1822-L1845 | train |
perkeep/perkeep | pkg/search/query.go | hasMatchingParent | func (c *DirConstraint) hasMatchingParent(ctx context.Context, s *search, parents map[blob.Ref]struct{}) (bool, error) {
for parent := range parents {
meta, err := s.blobMeta(ctx, parent)
if err != nil {
if os.IsNotExist(err) {
continue
}
return false, err
}
ok, err := c.blobMatches(ctx, s, parent, meta)
if err != nil {
return false, err
}
if ok {
return true, nil
}
}
return false, nil
} | go | func (c *DirConstraint) hasMatchingParent(ctx context.Context, s *search, parents map[blob.Ref]struct{}) (bool, error) {
for parent := range parents {
meta, err := s.blobMeta(ctx, parent)
if err != nil {
if os.IsNotExist(err) {
continue
}
return false, err
}
ok, err := c.blobMatches(ctx, s, parent, meta)
if err != nil {
return false, err
}
if ok {
return true, nil
}
}
return false, nil
} | [
"func",
"(",
"c",
"*",
"DirConstraint",
")",
"hasMatchingParent",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
"*",
"search",
",",
"parents",
"map",
"[",
"blob",
".",
"Ref",
"]",
"struct",
"{",
"}",
")",
"(",
"bool",
",",
"error",
")",
"{",
"for",
"parent",
":=",
"range",
"parents",
"{",
"meta",
",",
"err",
":=",
"s",
".",
"blobMeta",
"(",
"ctx",
",",
"parent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"ok",
",",
"err",
":=",
"c",
".",
"blobMatches",
"(",
"ctx",
",",
"s",
",",
"parent",
",",
"meta",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"ok",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // hasMatchingParent checks all parents against c and returns true as soon as one of
// them matches, or returns false if none of them is a match. | [
"hasMatchingParent",
"checks",
"all",
"parents",
"against",
"c",
"and",
"returns",
"true",
"as",
"soon",
"as",
"one",
"of",
"them",
"matches",
"or",
"returns",
"false",
"if",
"none",
"of",
"them",
"is",
"a",
"match",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L2185-L2203 | train |
perkeep/perkeep | pkg/search/query.go | hasMatchingChild | func (c *DirConstraint) hasMatchingChild(ctx context.Context, s *search, children map[blob.Ref]struct{},
matcher func(context.Context, *search, blob.Ref, camtypes.BlobMeta) (bool, error)) (bool, error) {
// TODO(mpl): See if we're guaranteed to be CPU-bound (i.e. all resources are in
// corpus), and if not, add some concurrency to spread costly index lookups.
for child, _ := range children {
meta, err := s.blobMeta(ctx, child)
if err != nil {
if os.IsNotExist(err) {
continue
}
return false, err
}
ok, err := matcher(ctx, s, child, meta)
if err != nil {
return false, err
}
if ok {
return true, nil
}
}
return false, nil
} | go | func (c *DirConstraint) hasMatchingChild(ctx context.Context, s *search, children map[blob.Ref]struct{},
matcher func(context.Context, *search, blob.Ref, camtypes.BlobMeta) (bool, error)) (bool, error) {
// TODO(mpl): See if we're guaranteed to be CPU-bound (i.e. all resources are in
// corpus), and if not, add some concurrency to spread costly index lookups.
for child, _ := range children {
meta, err := s.blobMeta(ctx, child)
if err != nil {
if os.IsNotExist(err) {
continue
}
return false, err
}
ok, err := matcher(ctx, s, child, meta)
if err != nil {
return false, err
}
if ok {
return true, nil
}
}
return false, nil
} | [
"func",
"(",
"c",
"*",
"DirConstraint",
")",
"hasMatchingChild",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
"*",
"search",
",",
"children",
"map",
"[",
"blob",
".",
"Ref",
"]",
"struct",
"{",
"}",
",",
"matcher",
"func",
"(",
"context",
".",
"Context",
",",
"*",
"search",
",",
"blob",
".",
"Ref",
",",
"camtypes",
".",
"BlobMeta",
")",
"(",
"bool",
",",
"error",
")",
")",
"(",
"bool",
",",
"error",
")",
"{",
"for",
"child",
",",
"_",
":=",
"range",
"children",
"{",
"meta",
",",
"err",
":=",
"s",
".",
"blobMeta",
"(",
"ctx",
",",
"child",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"ok",
",",
"err",
":=",
"matcher",
"(",
"ctx",
",",
"s",
",",
"child",
",",
"meta",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"ok",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // hasMatchingChild runs matcher against each child and returns true as soon as
// there is a match, of false if none of them is a match. | [
"hasMatchingChild",
"runs",
"matcher",
"against",
"each",
"child",
"and",
"returns",
"true",
"as",
"soon",
"as",
"there",
"is",
"a",
"match",
"of",
"false",
"if",
"none",
"of",
"them",
"is",
"a",
"match",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/query.go#L2207-L2228 | train |
perkeep/perkeep | pkg/blobserver/localdisk/generation.go | StorageGeneration | func (ds *DiskStorage) StorageGeneration() (initTime time.Time, random string, err error) {
return ds.gen.StorageGeneration()
} | go | func (ds *DiskStorage) StorageGeneration() (initTime time.Time, random string, err error) {
return ds.gen.StorageGeneration()
} | [
"func",
"(",
"ds",
"*",
"DiskStorage",
")",
"StorageGeneration",
"(",
")",
"(",
"initTime",
"time",
".",
"Time",
",",
"random",
"string",
",",
"err",
"error",
")",
"{",
"return",
"ds",
".",
"gen",
".",
"StorageGeneration",
"(",
")",
"\n",
"}"
] | // StorageGeneration returns the generation's initialization time,
// and the random string. | [
"StorageGeneration",
"returns",
"the",
"generation",
"s",
"initialization",
"time",
"and",
"the",
"random",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/localdisk/generation.go#L30-L32 | train |
perkeep/perkeep | internal/osutil/gce/gce.go | LogWriter | func LogWriter() (w io.WriteCloser, err error) {
w = multiWriteCloser{
w: os.Stderr,
// Because we don't actually want to close os.Stderr (which we could).
closer: types.NopCloser,
}
if !env.OnGCE() {
return
}
projID, err := metadata.ProjectID()
if projID == "" {
log.Printf("Error getting project ID: %v", err)
return
}
scopes, _ := metadata.Scopes("default")
haveScope := func(scope string) bool {
for _, x := range scopes {
if x == scope {
return true
}
}
return false
}
if !haveScope(logging.WriteScope) {
return nil, fmt.Errorf("when this Google Compute Engine VM instance was created, it wasn't granted enough access to use Google Cloud Logging (Scope URL: %v)", logging.WriteScope)
}
ctx := context.Background()
logc, err := logging.NewClient(ctx, projID)
if err != nil {
return nil, fmt.Errorf("error creating Google logging client: %v", err)
}
if err := logc.Ping(ctx); err != nil {
return nil, fmt.Errorf("Google logging client not ready (ping failed): %v", err)
}
logw := writer{
severity: logging.Debug,
logger: logc.Logger("perkeepd-stderr"),
}
return multiWriteCloser{
w: io.MultiWriter(w, logw),
closer: logc,
}, nil
} | go | func LogWriter() (w io.WriteCloser, err error) {
w = multiWriteCloser{
w: os.Stderr,
// Because we don't actually want to close os.Stderr (which we could).
closer: types.NopCloser,
}
if !env.OnGCE() {
return
}
projID, err := metadata.ProjectID()
if projID == "" {
log.Printf("Error getting project ID: %v", err)
return
}
scopes, _ := metadata.Scopes("default")
haveScope := func(scope string) bool {
for _, x := range scopes {
if x == scope {
return true
}
}
return false
}
if !haveScope(logging.WriteScope) {
return nil, fmt.Errorf("when this Google Compute Engine VM instance was created, it wasn't granted enough access to use Google Cloud Logging (Scope URL: %v)", logging.WriteScope)
}
ctx := context.Background()
logc, err := logging.NewClient(ctx, projID)
if err != nil {
return nil, fmt.Errorf("error creating Google logging client: %v", err)
}
if err := logc.Ping(ctx); err != nil {
return nil, fmt.Errorf("Google logging client not ready (ping failed): %v", err)
}
logw := writer{
severity: logging.Debug,
logger: logc.Logger("perkeepd-stderr"),
}
return multiWriteCloser{
w: io.MultiWriter(w, logw),
closer: logc,
}, nil
} | [
"func",
"LogWriter",
"(",
")",
"(",
"w",
"io",
".",
"WriteCloser",
",",
"err",
"error",
")",
"{",
"w",
"=",
"multiWriteCloser",
"{",
"w",
":",
"os",
".",
"Stderr",
",",
"closer",
":",
"types",
".",
"NopCloser",
",",
"}",
"\n",
"if",
"!",
"env",
".",
"OnGCE",
"(",
")",
"{",
"return",
"\n",
"}",
"\n",
"projID",
",",
"err",
":=",
"metadata",
".",
"ProjectID",
"(",
")",
"\n",
"if",
"projID",
"==",
"\"\"",
"{",
"log",
".",
"Printf",
"(",
"\"Error getting project ID: %v\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"scopes",
",",
"_",
":=",
"metadata",
".",
"Scopes",
"(",
"\"default\"",
")",
"\n",
"haveScope",
":=",
"func",
"(",
"scope",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"x",
":=",
"range",
"scopes",
"{",
"if",
"x",
"==",
"scope",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"haveScope",
"(",
"logging",
".",
"WriteScope",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"when this Google Compute Engine VM instance was created, it wasn't granted enough access to use Google Cloud Logging (Scope URL: %v)\"",
",",
"logging",
".",
"WriteScope",
")",
"\n",
"}",
"\n",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"logc",
",",
"err",
":=",
"logging",
".",
"NewClient",
"(",
"ctx",
",",
"projID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"error creating Google logging client: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"logc",
".",
"Ping",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Google logging client not ready (ping failed): %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"logw",
":=",
"writer",
"{",
"severity",
":",
"logging",
".",
"Debug",
",",
"logger",
":",
"logc",
".",
"Logger",
"(",
"\"perkeepd-stderr\"",
")",
",",
"}",
"\n",
"return",
"multiWriteCloser",
"{",
"w",
":",
"io",
".",
"MultiWriter",
"(",
"w",
",",
"logw",
")",
",",
"closer",
":",
"logc",
",",
"}",
",",
"nil",
"\n",
"}"
] | // LogWriter returns an environment-specific io.WriteCloser suitable for passing
// to log.SetOutput. It will also include writing to os.Stderr as well.
// Since it might be writing to a Google Cloud Logger, it is the responsibility
// of the caller to Close it when needed, to flush the last log entries. | [
"LogWriter",
"returns",
"an",
"environment",
"-",
"specific",
"io",
".",
"WriteCloser",
"suitable",
"for",
"passing",
"to",
"log",
".",
"SetOutput",
".",
"It",
"will",
"also",
"include",
"writing",
"to",
"os",
".",
"Stderr",
"as",
"well",
".",
"Since",
"it",
"might",
"be",
"writing",
"to",
"a",
"Google",
"Cloud",
"Logger",
"it",
"is",
"the",
"responsibility",
"of",
"the",
"caller",
"to",
"Close",
"it",
"when",
"needed",
"to",
"flush",
"the",
"last",
"log",
"entries",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/gce/gce.go#L102-L145 | train |
perkeep/perkeep | internal/osutil/gce/gce.go | resetInstance | func resetInstance() error {
if !env.OnGCE() {
return errors.New("cannot reset instance if not on GCE")
}
ctx := context.Background()
inst, err := gceInstance()
if err != nil {
return err
}
cs, projectID, zone, name := inst.cis, inst.projectID, inst.zone, inst.name
call := cs.Reset(projectID, zone, name).Context(ctx)
op, err := call.Do()
if err != nil {
if googleapi.IsNotModified(err) {
return nil
}
return fmt.Errorf("error resetting instance: %v", err)
}
// TODO(mpl): refactor this whole pattern below into a func
opName := op.Name
for {
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(500 * time.Millisecond):
}
op, err := inst.cs.ZoneOperations.Get(projectID, zone, opName).Context(ctx).Do()
if err != nil {
return fmt.Errorf("failed to get op %s: %v", opName, err)
}
switch op.Status {
case "PENDING", "RUNNING":
continue
case "DONE":
if op.Error != nil {
for _, operr := range op.Error.Errors {
log.Printf("operation error: %+v", operr)
}
return fmt.Errorf("operation error: %v", op.Error.Errors[0])
}
log.Print("Successfully reset instance")
return nil
default:
return fmt.Errorf("unknown operation status %q: %+v", op.Status, op)
}
}
} | go | func resetInstance() error {
if !env.OnGCE() {
return errors.New("cannot reset instance if not on GCE")
}
ctx := context.Background()
inst, err := gceInstance()
if err != nil {
return err
}
cs, projectID, zone, name := inst.cis, inst.projectID, inst.zone, inst.name
call := cs.Reset(projectID, zone, name).Context(ctx)
op, err := call.Do()
if err != nil {
if googleapi.IsNotModified(err) {
return nil
}
return fmt.Errorf("error resetting instance: %v", err)
}
// TODO(mpl): refactor this whole pattern below into a func
opName := op.Name
for {
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(500 * time.Millisecond):
}
op, err := inst.cs.ZoneOperations.Get(projectID, zone, opName).Context(ctx).Do()
if err != nil {
return fmt.Errorf("failed to get op %s: %v", opName, err)
}
switch op.Status {
case "PENDING", "RUNNING":
continue
case "DONE":
if op.Error != nil {
for _, operr := range op.Error.Errors {
log.Printf("operation error: %+v", operr)
}
return fmt.Errorf("operation error: %v", op.Error.Errors[0])
}
log.Print("Successfully reset instance")
return nil
default:
return fmt.Errorf("unknown operation status %q: %+v", op.Status, op)
}
}
} | [
"func",
"resetInstance",
"(",
")",
"error",
"{",
"if",
"!",
"env",
".",
"OnGCE",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"cannot reset instance if not on GCE\"",
")",
"\n",
"}",
"\n",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"inst",
",",
"err",
":=",
"gceInstance",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cs",
",",
"projectID",
",",
"zone",
",",
"name",
":=",
"inst",
".",
"cis",
",",
"inst",
".",
"projectID",
",",
"inst",
".",
"zone",
",",
"inst",
".",
"name",
"\n",
"call",
":=",
"cs",
".",
"Reset",
"(",
"projectID",
",",
"zone",
",",
"name",
")",
".",
"Context",
"(",
"ctx",
")",
"\n",
"op",
",",
"err",
":=",
"call",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"googleapi",
".",
"IsNotModified",
"(",
"err",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"error resetting instance: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"opName",
":=",
"op",
".",
"Name",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"ctx",
".",
"Err",
"(",
")",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"500",
"*",
"time",
".",
"Millisecond",
")",
":",
"}",
"\n",
"op",
",",
"err",
":=",
"inst",
".",
"cs",
".",
"ZoneOperations",
".",
"Get",
"(",
"projectID",
",",
"zone",
",",
"opName",
")",
".",
"Context",
"(",
"ctx",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"failed to get op %s: %v\"",
",",
"opName",
",",
"err",
")",
"\n",
"}",
"\n",
"switch",
"op",
".",
"Status",
"{",
"case",
"\"PENDING\"",
",",
"\"RUNNING\"",
":",
"continue",
"\n",
"case",
"\"DONE\"",
":",
"if",
"op",
".",
"Error",
"!=",
"nil",
"{",
"for",
"_",
",",
"operr",
":=",
"range",
"op",
".",
"Error",
".",
"Errors",
"{",
"log",
".",
"Printf",
"(",
"\"operation error: %+v\"",
",",
"operr",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"operation error: %v\"",
",",
"op",
".",
"Error",
".",
"Errors",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"log",
".",
"Print",
"(",
"\"Successfully reset instance\"",
")",
"\n",
"return",
"nil",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"unknown operation status %q: %+v\"",
",",
"op",
".",
"Status",
",",
"op",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // resetInstance reboots the GCE VM that this process is running in. | [
"resetInstance",
"reboots",
"the",
"GCE",
"VM",
"that",
"this",
"process",
"is",
"running",
"in",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/gce/gce.go#L188-L237 | train |
perkeep/perkeep | server/perkeepd/ui/goui/sharebutton/sharebutton.go | OnClick | func (d ShareItemsBtnDef) OnClick(e *react.SyntheticMouseEvent) {
go func() {
sharedURL, err := d.shareSelection()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
return
}
prefix, err := d.urlPrefix()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("Cannot display full share URL: %v", err))
return
}
sharedURL = prefix + sharedURL
anchorText := sharedURL[:20] + "..." + sharedURL[len(sharedURL)-20:]
// TODO(mpl): move some of the Dialog code to Go.
d.Props().callbacks.ShowSharedURL(sharedURL, anchorText)
}()
} | go | func (d ShareItemsBtnDef) OnClick(e *react.SyntheticMouseEvent) {
go func() {
sharedURL, err := d.shareSelection()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
return
}
prefix, err := d.urlPrefix()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("Cannot display full share URL: %v", err))
return
}
sharedURL = prefix + sharedURL
anchorText := sharedURL[:20] + "..." + sharedURL[len(sharedURL)-20:]
// TODO(mpl): move some of the Dialog code to Go.
d.Props().callbacks.ShowSharedURL(sharedURL, anchorText)
}()
} | [
"func",
"(",
"d",
"ShareItemsBtnDef",
")",
"OnClick",
"(",
"e",
"*",
"react",
".",
"SyntheticMouseEvent",
")",
"{",
"go",
"func",
"(",
")",
"{",
"sharedURL",
",",
"err",
":=",
"d",
".",
"shareSelection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"dom",
".",
"GetWindow",
"(",
")",
".",
"Alert",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"prefix",
",",
"err",
":=",
"d",
".",
"urlPrefix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"dom",
".",
"GetWindow",
"(",
")",
".",
"Alert",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"Cannot display full share URL: %v\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"sharedURL",
"=",
"prefix",
"+",
"sharedURL",
"\n",
"anchorText",
":=",
"sharedURL",
"[",
":",
"20",
"]",
"+",
"\"...\"",
"+",
"sharedURL",
"[",
"len",
"(",
"sharedURL",
")",
"-",
"20",
":",
"]",
"\n",
"d",
".",
"Props",
"(",
")",
".",
"callbacks",
".",
"ShowSharedURL",
"(",
"sharedURL",
",",
"anchorText",
")",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // On success, handleShareSelection calls d.showSharedURL with the URL that can
// be used to share the item. If the item is a file, the URL can be used directly
// to fetch the file. If the item is a directory, the URL should be used with
// pk-get -shared. | [
"On",
"success",
"handleShareSelection",
"calls",
"d",
".",
"showSharedURL",
"with",
"the",
"URL",
"that",
"can",
"be",
"used",
"to",
"share",
"the",
"item",
".",
"If",
"the",
"item",
"is",
"a",
"file",
"the",
"URL",
"can",
"be",
"used",
"directly",
"to",
"fetch",
"the",
"file",
".",
"If",
"the",
"item",
"is",
"a",
"directory",
"the",
"URL",
"should",
"be",
"used",
"with",
"pk",
"-",
"get",
"-",
"shared",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/sharebutton/sharebutton.go#L166-L183 | train |
perkeep/perkeep | server/perkeepd/ui/goui/sharebutton/sharebutton.go | mkdir | func mkdir(am auth.AuthMode, children []blob.Ref) (blob.Ref, error) {
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return blob.Ref{}, err
}
var newdir blob.Ref
ss := schema.NewStaticSet()
subsets := ss.SetStaticSetMembers(children)
for _, v := range subsets {
// TODO(mpl): make them concurrent
if _, err := cl.UploadBlob(context.TODO(), v); err != nil {
return newdir, err
}
}
ssb := ss.Blob()
if _, err := cl.UploadBlob(context.TODO(), ssb); err != nil {
return newdir, err
}
const fileNameLayout = "20060102150405"
fileName := "shared-" + time.Now().Format(fileNameLayout)
dir := schema.NewDirMap(fileName).PopulateDirectoryMap(ssb.BlobRef())
dirBlob := dir.Blob()
if _, err := cl.UploadBlob(context.TODO(), dirBlob); err != nil {
return newdir, err
}
return dirBlob.BlobRef(), nil
} | go | func mkdir(am auth.AuthMode, children []blob.Ref) (blob.Ref, error) {
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return blob.Ref{}, err
}
var newdir blob.Ref
ss := schema.NewStaticSet()
subsets := ss.SetStaticSetMembers(children)
for _, v := range subsets {
// TODO(mpl): make them concurrent
if _, err := cl.UploadBlob(context.TODO(), v); err != nil {
return newdir, err
}
}
ssb := ss.Blob()
if _, err := cl.UploadBlob(context.TODO(), ssb); err != nil {
return newdir, err
}
const fileNameLayout = "20060102150405"
fileName := "shared-" + time.Now().Format(fileNameLayout)
dir := schema.NewDirMap(fileName).PopulateDirectoryMap(ssb.BlobRef())
dirBlob := dir.Blob()
if _, err := cl.UploadBlob(context.TODO(), dirBlob); err != nil {
return newdir, err
}
return dirBlob.BlobRef(), nil
} | [
"func",
"mkdir",
"(",
"am",
"auth",
".",
"AuthMode",
",",
"children",
"[",
"]",
"blob",
".",
"Ref",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"cl",
",",
"err",
":=",
"client",
".",
"New",
"(",
"client",
".",
"OptionAuthMode",
"(",
"am",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"blob",
".",
"Ref",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"var",
"newdir",
"blob",
".",
"Ref",
"\n",
"ss",
":=",
"schema",
".",
"NewStaticSet",
"(",
")",
"\n",
"subsets",
":=",
"ss",
".",
"SetStaticSetMembers",
"(",
"children",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"subsets",
"{",
"if",
"_",
",",
"err",
":=",
"cl",
".",
"UploadBlob",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"newdir",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"ssb",
":=",
"ss",
".",
"Blob",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"cl",
".",
"UploadBlob",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"ssb",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"newdir",
",",
"err",
"\n",
"}",
"\n",
"const",
"fileNameLayout",
"=",
"\"20060102150405\"",
"\n",
"fileName",
":=",
"\"shared-\"",
"+",
"time",
".",
"Now",
"(",
")",
".",
"Format",
"(",
"fileNameLayout",
")",
"\n",
"dir",
":=",
"schema",
".",
"NewDirMap",
"(",
"fileName",
")",
".",
"PopulateDirectoryMap",
"(",
"ssb",
".",
"BlobRef",
"(",
")",
")",
"\n",
"dirBlob",
":=",
"dir",
".",
"Blob",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"cl",
".",
"UploadBlob",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"dirBlob",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"newdir",
",",
"err",
"\n",
"}",
"\n",
"return",
"dirBlob",
".",
"BlobRef",
"(",
")",
",",
"nil",
"\n",
"}"
] | // mkdir creates a new directory blob, with children composing its static-set,
// and uploads it. It returns the blobRef of the new directory. | [
"mkdir",
"creates",
"a",
"new",
"directory",
"blob",
"with",
"children",
"composing",
"its",
"static",
"-",
"set",
"and",
"uploads",
"it",
".",
"It",
"returns",
"the",
"blobRef",
"of",
"the",
"new",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/sharebutton/sharebutton.go#L225-L252 | train |
perkeep/perkeep | server/perkeepd/ui/goui/sharebutton/sharebutton.go | shareFile | func shareFile(am auth.AuthMode, target blob.Ref, isDir bool) (string, error) {
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return "", err
}
claim, err := newShareClaim(cl, target)
if err != nil {
return "", err
}
shareRoot, err := cl.ShareRoot()
if err != nil {
return "", err
}
if isDir {
return fmt.Sprintf("%s%s", shareRoot, claim), nil
}
return fmt.Sprintf("%s%s?via=%s&assemble=1", shareRoot, target, claim), nil
} | go | func shareFile(am auth.AuthMode, target blob.Ref, isDir bool) (string, error) {
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return "", err
}
claim, err := newShareClaim(cl, target)
if err != nil {
return "", err
}
shareRoot, err := cl.ShareRoot()
if err != nil {
return "", err
}
if isDir {
return fmt.Sprintf("%s%s", shareRoot, claim), nil
}
return fmt.Sprintf("%s%s?via=%s&assemble=1", shareRoot, target, claim), nil
} | [
"func",
"shareFile",
"(",
"am",
"auth",
".",
"AuthMode",
",",
"target",
"blob",
".",
"Ref",
",",
"isDir",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"cl",
",",
"err",
":=",
"client",
".",
"New",
"(",
"client",
".",
"OptionAuthMode",
"(",
"am",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"claim",
",",
"err",
":=",
"newShareClaim",
"(",
"cl",
",",
"target",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"shareRoot",
",",
"err",
":=",
"cl",
".",
"ShareRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"isDir",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s%s\"",
",",
"shareRoot",
",",
"claim",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s%s?via=%s&assemble=1\"",
",",
"shareRoot",
",",
"target",
",",
"claim",
")",
",",
"nil",
"\n",
"}"
] | // shareFile returns the URL that can be used to share the target item. If the
// item is a file, the URL can be used directly to fetch the file. If the item is a
// directory, the URL should be used with pk-get -shared. | [
"shareFile",
"returns",
"the",
"URL",
"that",
"can",
"be",
"used",
"to",
"share",
"the",
"target",
"item",
".",
"If",
"the",
"item",
"is",
"a",
"file",
"the",
"URL",
"can",
"be",
"used",
"directly",
"to",
"fetch",
"the",
"file",
".",
"If",
"the",
"item",
"is",
"a",
"directory",
"the",
"URL",
"should",
"be",
"used",
"with",
"pk",
"-",
"get",
"-",
"shared",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/sharebutton/sharebutton.go#L257-L274 | train |
perkeep/perkeep | server/perkeepd/ui/goui/sharebutton/sharebutton.go | newShareClaim | func newShareClaim(cl *client.Client, target blob.Ref) (blob.Ref, error) {
var claim blob.Ref
signer, err := cl.ServerPublicKeyBlobRef()
if err != nil {
return claim, fmt.Errorf("could not get signer: %v", err)
}
shareSchema := schema.NewShareRef(schema.ShareHaveRef, true)
shareSchema.SetShareTarget(target)
unsignedClaim, err := shareSchema.SetSigner(signer).JSON()
if err != nil {
return claim, fmt.Errorf("could not create unsigned share claim: %v", err)
}
signedClaim, err := cl.Sign(context.TODO(), "", strings.NewReader("json="+unsignedClaim))
if err != nil {
return claim, fmt.Errorf("could not get signed share claim: %v", err)
}
sbr, err := cl.Upload(context.TODO(), client.NewUploadHandleFromString(string(signedClaim)))
if err != nil {
return claim, fmt.Errorf("could not upload share claim: %v", err)
}
return sbr.BlobRef, nil
} | go | func newShareClaim(cl *client.Client, target blob.Ref) (blob.Ref, error) {
var claim blob.Ref
signer, err := cl.ServerPublicKeyBlobRef()
if err != nil {
return claim, fmt.Errorf("could not get signer: %v", err)
}
shareSchema := schema.NewShareRef(schema.ShareHaveRef, true)
shareSchema.SetShareTarget(target)
unsignedClaim, err := shareSchema.SetSigner(signer).JSON()
if err != nil {
return claim, fmt.Errorf("could not create unsigned share claim: %v", err)
}
signedClaim, err := cl.Sign(context.TODO(), "", strings.NewReader("json="+unsignedClaim))
if err != nil {
return claim, fmt.Errorf("could not get signed share claim: %v", err)
}
sbr, err := cl.Upload(context.TODO(), client.NewUploadHandleFromString(string(signedClaim)))
if err != nil {
return claim, fmt.Errorf("could not upload share claim: %v", err)
}
return sbr.BlobRef, nil
} | [
"func",
"newShareClaim",
"(",
"cl",
"*",
"client",
".",
"Client",
",",
"target",
"blob",
".",
"Ref",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"var",
"claim",
"blob",
".",
"Ref",
"\n",
"signer",
",",
"err",
":=",
"cl",
".",
"ServerPublicKeyBlobRef",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"claim",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not get signer: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"shareSchema",
":=",
"schema",
".",
"NewShareRef",
"(",
"schema",
".",
"ShareHaveRef",
",",
"true",
")",
"\n",
"shareSchema",
".",
"SetShareTarget",
"(",
"target",
")",
"\n",
"unsignedClaim",
",",
"err",
":=",
"shareSchema",
".",
"SetSigner",
"(",
"signer",
")",
".",
"JSON",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"claim",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not create unsigned share claim: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"signedClaim",
",",
"err",
":=",
"cl",
".",
"Sign",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"\"\"",
",",
"strings",
".",
"NewReader",
"(",
"\"json=\"",
"+",
"unsignedClaim",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"claim",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not get signed share claim: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"sbr",
",",
"err",
":=",
"cl",
".",
"Upload",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"client",
".",
"NewUploadHandleFromString",
"(",
"string",
"(",
"signedClaim",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"claim",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not upload share claim: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"sbr",
".",
"BlobRef",
",",
"nil",
"\n",
"}"
] | // newShareClaim creates, signs, and uploads a transitive haveref share claim
// for sharing the target item. It returns the ref of the claim. | [
"newShareClaim",
"creates",
"signs",
"and",
"uploads",
"a",
"transitive",
"haveref",
"share",
"claim",
"for",
"sharing",
"the",
"target",
"item",
".",
"It",
"returns",
"the",
"ref",
"of",
"the",
"claim",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/sharebutton/sharebutton.go#L278-L299 | train |
perkeep/perkeep | pkg/importer/gphotos/download.go | fileAsPhoto | func (dl *downloader) fileAsPhoto(f *drive.File) *photo {
if f == nil {
return nil
}
if f.Size == 0 {
// anything non-binary can't be a photo, so skip it.
return nil
}
if !inPhotoSpace(f) {
// not a photo
return nil
}
p := &photo{
ID: f.Id,
Name: f.Name,
Starred: f.Starred,
Version: f.Version,
MimeType: f.MimeType,
Properties: f.Properties,
Description: f.Description,
WebContentLink: f.WebContentLink,
OriginalFilename: f.OriginalFilename,
}
if f.ImageMediaMetadata != nil {
p.FileImageMediaMetadata = *f.ImageMediaMetadata
}
if f.CreatedTime != "" {
p.CreatedTime, _ = time.Parse(time.RFC3339, f.CreatedTime)
}
if f.ModifiedTime != "" {
p.ModifiedTime, _ = time.Parse(time.RFC3339, f.ModifiedTime)
}
return p
} | go | func (dl *downloader) fileAsPhoto(f *drive.File) *photo {
if f == nil {
return nil
}
if f.Size == 0 {
// anything non-binary can't be a photo, so skip it.
return nil
}
if !inPhotoSpace(f) {
// not a photo
return nil
}
p := &photo{
ID: f.Id,
Name: f.Name,
Starred: f.Starred,
Version: f.Version,
MimeType: f.MimeType,
Properties: f.Properties,
Description: f.Description,
WebContentLink: f.WebContentLink,
OriginalFilename: f.OriginalFilename,
}
if f.ImageMediaMetadata != nil {
p.FileImageMediaMetadata = *f.ImageMediaMetadata
}
if f.CreatedTime != "" {
p.CreatedTime, _ = time.Parse(time.RFC3339, f.CreatedTime)
}
if f.ModifiedTime != "" {
p.ModifiedTime, _ = time.Parse(time.RFC3339, f.ModifiedTime)
}
return p
} | [
"func",
"(",
"dl",
"*",
"downloader",
")",
"fileAsPhoto",
"(",
"f",
"*",
"drive",
".",
"File",
")",
"*",
"photo",
"{",
"if",
"f",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"f",
".",
"Size",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"inPhotoSpace",
"(",
"f",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"p",
":=",
"&",
"photo",
"{",
"ID",
":",
"f",
".",
"Id",
",",
"Name",
":",
"f",
".",
"Name",
",",
"Starred",
":",
"f",
".",
"Starred",
",",
"Version",
":",
"f",
".",
"Version",
",",
"MimeType",
":",
"f",
".",
"MimeType",
",",
"Properties",
":",
"f",
".",
"Properties",
",",
"Description",
":",
"f",
".",
"Description",
",",
"WebContentLink",
":",
"f",
".",
"WebContentLink",
",",
"OriginalFilename",
":",
"f",
".",
"OriginalFilename",
",",
"}",
"\n",
"if",
"f",
".",
"ImageMediaMetadata",
"!=",
"nil",
"{",
"p",
".",
"FileImageMediaMetadata",
"=",
"*",
"f",
".",
"ImageMediaMetadata",
"\n",
"}",
"\n",
"if",
"f",
".",
"CreatedTime",
"!=",
"\"\"",
"{",
"p",
".",
"CreatedTime",
",",
"_",
"=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"f",
".",
"CreatedTime",
")",
"\n",
"}",
"\n",
"if",
"f",
".",
"ModifiedTime",
"!=",
"\"\"",
"{",
"p",
".",
"ModifiedTime",
",",
"_",
"=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"f",
".",
"ModifiedTime",
")",
"\n",
"}",
"\n",
"return",
"p",
"\n",
"}"
] | // fileAsPhoto returns a photo populated with the information found about f,
// or nil if f is not actually a photo from Google Photos.
//
// The returned photo contains only the metadata;
// the content of the photo can be downloaded with dl.openPhoto. | [
"fileAsPhoto",
"returns",
"a",
"photo",
"populated",
"with",
"the",
"information",
"found",
"about",
"f",
"or",
"nil",
"if",
"f",
"is",
"not",
"actually",
"a",
"photo",
"from",
"Google",
"Photos",
".",
"The",
"returned",
"photo",
"contains",
"only",
"the",
"metadata",
";",
"the",
"content",
"of",
"the",
"photo",
"can",
"be",
"downloaded",
"with",
"dl",
".",
"openPhoto",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/gphotos/download.go#L281-L315 | train |
perkeep/perkeep | pkg/importer/gphotos/download.go | rateLimit | func (dl *downloader) rateLimit(ctx context.Context, f func() error) error {
const (
msgRateLimitExceeded = "Rate Limit Exceeded"
msgUserRateLimitExceeded = "User Rate Limit Exceeded"
msgUserRateLimitExceededShort = "userRateLimitExceeded"
)
// Ensure a 1 minute try limit.
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
for {
if err := dl.rate.Wait(ctx); err != nil {
log.Printf("gphotos: rate limit failure: %v", err)
return err
}
err := f()
if err == nil {
return nil
}
ge, ok := err.(*googleapi.Error)
if !ok || ge.Code != 403 {
return err
}
if ge.Message == "" {
var ok bool
for _, e := range ge.Errors {
if ok = e.Reason == msgUserRateLimitExceededShort; ok {
break
}
}
// For some cases, googleapi does not parse the returned JSON
// properly, so we have to fall back to check the original text.
//
// Usually this is a "User Rate Limit Exceeded", but that's
// also a "Rate Limit Exceeded", and we're interested just in the
// fact, not the cause.
if !ok && !strings.Contains(ge.Body, msgRateLimitExceeded) {
return err
}
}
// Some arbitrary sleep.
log.Printf("gphotos: sleeping for 5s after 403 error, presumably due to a rate limit")
time.Sleep(5 * time.Second)
log.Printf("gphotos: retrying after sleep...")
}
} | go | func (dl *downloader) rateLimit(ctx context.Context, f func() error) error {
const (
msgRateLimitExceeded = "Rate Limit Exceeded"
msgUserRateLimitExceeded = "User Rate Limit Exceeded"
msgUserRateLimitExceededShort = "userRateLimitExceeded"
)
// Ensure a 1 minute try limit.
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
for {
if err := dl.rate.Wait(ctx); err != nil {
log.Printf("gphotos: rate limit failure: %v", err)
return err
}
err := f()
if err == nil {
return nil
}
ge, ok := err.(*googleapi.Error)
if !ok || ge.Code != 403 {
return err
}
if ge.Message == "" {
var ok bool
for _, e := range ge.Errors {
if ok = e.Reason == msgUserRateLimitExceededShort; ok {
break
}
}
// For some cases, googleapi does not parse the returned JSON
// properly, so we have to fall back to check the original text.
//
// Usually this is a "User Rate Limit Exceeded", but that's
// also a "Rate Limit Exceeded", and we're interested just in the
// fact, not the cause.
if !ok && !strings.Contains(ge.Body, msgRateLimitExceeded) {
return err
}
}
// Some arbitrary sleep.
log.Printf("gphotos: sleeping for 5s after 403 error, presumably due to a rate limit")
time.Sleep(5 * time.Second)
log.Printf("gphotos: retrying after sleep...")
}
} | [
"func",
"(",
"dl",
"*",
"downloader",
")",
"rateLimit",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
"func",
"(",
")",
"error",
")",
"error",
"{",
"const",
"(",
"msgRateLimitExceeded",
"=",
"\"Rate Limit Exceeded\"",
"\n",
"msgUserRateLimitExceeded",
"=",
"\"User Rate Limit Exceeded\"",
"\n",
"msgUserRateLimitExceededShort",
"=",
"\"userRateLimitExceeded\"",
"\n",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"time",
".",
"Minute",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"for",
"{",
"if",
"err",
":=",
"dl",
".",
"rate",
".",
"Wait",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"gphotos: rate limit failure: %v\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"err",
":=",
"f",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"ge",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"googleapi",
".",
"Error",
")",
"\n",
"if",
"!",
"ok",
"||",
"ge",
".",
"Code",
"!=",
"403",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"ge",
".",
"Message",
"==",
"\"\"",
"{",
"var",
"ok",
"bool",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"ge",
".",
"Errors",
"{",
"if",
"ok",
"=",
"e",
".",
"Reason",
"==",
"msgUserRateLimitExceededShort",
";",
"ok",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"&&",
"!",
"strings",
".",
"Contains",
"(",
"ge",
".",
"Body",
",",
"msgRateLimitExceeded",
")",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"Printf",
"(",
"\"gphotos: sleeping for 5s after 403 error, presumably due to a rate limit\"",
")",
"\n",
"time",
".",
"Sleep",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"gphotos: retrying after sleep...\"",
")",
"\n",
"}",
"\n",
"}"
] | // rateLimit calls f obeying the global Rate limit.
// On "Rate Limit Exceeded" error, it sleeps and tries later. | [
"rateLimit",
"calls",
"f",
"obeying",
"the",
"global",
"Rate",
"limit",
".",
"On",
"Rate",
"Limit",
"Exceeded",
"error",
"it",
"sleeps",
"and",
"tries",
"later",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/gphotos/download.go#L319-L364 | train |
perkeep/perkeep | internal/magic/magic.go | MIMEType | func MIMEType(hdr []byte) string {
hlen := len(hdr)
for _, pte := range matchTable {
if pte.fn != nil {
if pte.fn(hdr) {
return pte.mtype
}
continue
}
plen := pte.offset + len(pte.prefix)
if hlen > plen && bytes.Equal(hdr[pte.offset:plen], pte.prefix) {
return pte.mtype
}
}
t := http.DetectContentType(hdr)
t = strings.Replace(t, "; charset=utf-8", "", 1)
if t != "application/octet-stream" && t != "text/plain" {
return t
}
return ""
} | go | func MIMEType(hdr []byte) string {
hlen := len(hdr)
for _, pte := range matchTable {
if pte.fn != nil {
if pte.fn(hdr) {
return pte.mtype
}
continue
}
plen := pte.offset + len(pte.prefix)
if hlen > plen && bytes.Equal(hdr[pte.offset:plen], pte.prefix) {
return pte.mtype
}
}
t := http.DetectContentType(hdr)
t = strings.Replace(t, "; charset=utf-8", "", 1)
if t != "application/octet-stream" && t != "text/plain" {
return t
}
return ""
} | [
"func",
"MIMEType",
"(",
"hdr",
"[",
"]",
"byte",
")",
"string",
"{",
"hlen",
":=",
"len",
"(",
"hdr",
")",
"\n",
"for",
"_",
",",
"pte",
":=",
"range",
"matchTable",
"{",
"if",
"pte",
".",
"fn",
"!=",
"nil",
"{",
"if",
"pte",
".",
"fn",
"(",
"hdr",
")",
"{",
"return",
"pte",
".",
"mtype",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"plen",
":=",
"pte",
".",
"offset",
"+",
"len",
"(",
"pte",
".",
"prefix",
")",
"\n",
"if",
"hlen",
">",
"plen",
"&&",
"bytes",
".",
"Equal",
"(",
"hdr",
"[",
"pte",
".",
"offset",
":",
"plen",
"]",
",",
"pte",
".",
"prefix",
")",
"{",
"return",
"pte",
".",
"mtype",
"\n",
"}",
"\n",
"}",
"\n",
"t",
":=",
"http",
".",
"DetectContentType",
"(",
"hdr",
")",
"\n",
"t",
"=",
"strings",
".",
"Replace",
"(",
"t",
",",
"\"; charset=utf-8\"",
",",
"\"\"",
",",
"1",
")",
"\n",
"if",
"t",
"!=",
"\"application/octet-stream\"",
"&&",
"t",
"!=",
"\"text/plain\"",
"{",
"return",
"t",
"\n",
"}",
"\n",
"return",
"\"\"",
"\n",
"}"
] | // MIMEType returns the MIME type from the data in the provided header
// of the data.
// It returns the empty string if the MIME type can't be determined. | [
"MIMEType",
"returns",
"the",
"MIME",
"type",
"from",
"the",
"data",
"in",
"the",
"provided",
"header",
"of",
"the",
"data",
".",
"It",
"returns",
"the",
"empty",
"string",
"if",
"the",
"MIME",
"type",
"can",
"t",
"be",
"determined",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/magic/magic.go#L173-L193 | train |
perkeep/perkeep | internal/magic/magic.go | MIMETypeFromReaderAt | func MIMETypeFromReaderAt(ra io.ReaderAt) (mime string) {
var buf [1024]byte
n, _ := ra.ReadAt(buf[:], 0)
return MIMEType(buf[:n])
} | go | func MIMETypeFromReaderAt(ra io.ReaderAt) (mime string) {
var buf [1024]byte
n, _ := ra.ReadAt(buf[:], 0)
return MIMEType(buf[:n])
} | [
"func",
"MIMETypeFromReaderAt",
"(",
"ra",
"io",
".",
"ReaderAt",
")",
"(",
"mime",
"string",
")",
"{",
"var",
"buf",
"[",
"1024",
"]",
"byte",
"\n",
"n",
",",
"_",
":=",
"ra",
".",
"ReadAt",
"(",
"buf",
"[",
":",
"]",
",",
"0",
")",
"\n",
"return",
"MIMEType",
"(",
"buf",
"[",
":",
"n",
"]",
")",
"\n",
"}"
] | // MIMETypeFromReaderAt takes a ReaderAt, sniffs the beginning of it,
// and returns the MIME type if sniffed, else the empty string. | [
"MIMETypeFromReaderAt",
"takes",
"a",
"ReaderAt",
"sniffs",
"the",
"beginning",
"of",
"it",
"and",
"returns",
"the",
"MIME",
"type",
"if",
"sniffed",
"else",
"the",
"empty",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/magic/magic.go#L211-L215 | train |
perkeep/perkeep | internal/magic/magic.go | HasExtension | func HasExtension(filename string, extensions map[string]bool) bool {
var ext string
if e := filepath.Ext(filename); strings.HasPrefix(e, ".") {
ext = e[1:]
} else {
return false
}
// Case-insensitive lookup.
// Optimistically assume a short ASCII extension and be
// allocation-free in that case.
var buf [10]byte
lower := buf[:0]
const utf8RuneSelf = 0x80 // from utf8 package, but not importing it.
for i := 0; i < len(ext); i++ {
c := ext[i]
if c >= utf8RuneSelf {
// Slow path.
return extensions[strings.ToLower(ext)]
}
if 'A' <= c && c <= 'Z' {
lower = append(lower, c+('a'-'A'))
} else {
lower = append(lower, c)
}
}
// The conversion from []byte to string doesn't allocate in
// a map lookup.
return extensions[string(lower)]
} | go | func HasExtension(filename string, extensions map[string]bool) bool {
var ext string
if e := filepath.Ext(filename); strings.HasPrefix(e, ".") {
ext = e[1:]
} else {
return false
}
// Case-insensitive lookup.
// Optimistically assume a short ASCII extension and be
// allocation-free in that case.
var buf [10]byte
lower := buf[:0]
const utf8RuneSelf = 0x80 // from utf8 package, but not importing it.
for i := 0; i < len(ext); i++ {
c := ext[i]
if c >= utf8RuneSelf {
// Slow path.
return extensions[strings.ToLower(ext)]
}
if 'A' <= c && c <= 'Z' {
lower = append(lower, c+('a'-'A'))
} else {
lower = append(lower, c)
}
}
// The conversion from []byte to string doesn't allocate in
// a map lookup.
return extensions[string(lower)]
} | [
"func",
"HasExtension",
"(",
"filename",
"string",
",",
"extensions",
"map",
"[",
"string",
"]",
"bool",
")",
"bool",
"{",
"var",
"ext",
"string",
"\n",
"if",
"e",
":=",
"filepath",
".",
"Ext",
"(",
"filename",
")",
";",
"strings",
".",
"HasPrefix",
"(",
"e",
",",
"\".\"",
")",
"{",
"ext",
"=",
"e",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"return",
"false",
"\n",
"}",
"\n",
"var",
"buf",
"[",
"10",
"]",
"byte",
"\n",
"lower",
":=",
"buf",
"[",
":",
"0",
"]",
"\n",
"const",
"utf8RuneSelf",
"=",
"0x80",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"ext",
")",
";",
"i",
"++",
"{",
"c",
":=",
"ext",
"[",
"i",
"]",
"\n",
"if",
"c",
">=",
"utf8RuneSelf",
"{",
"return",
"extensions",
"[",
"strings",
".",
"ToLower",
"(",
"ext",
")",
"]",
"\n",
"}",
"\n",
"if",
"'A'",
"<=",
"c",
"&&",
"c",
"<=",
"'Z'",
"{",
"lower",
"=",
"append",
"(",
"lower",
",",
"c",
"+",
"(",
"'a'",
"-",
"'A'",
")",
")",
"\n",
"}",
"else",
"{",
"lower",
"=",
"append",
"(",
"lower",
",",
"c",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"extensions",
"[",
"string",
"(",
"lower",
")",
"]",
"\n",
"}"
] | // HasExtension returns whether the file extension of filename is among
// extensions. It is a case-insensitive lookup, optimized for the ASCII case. | [
"HasExtension",
"returns",
"whether",
"the",
"file",
"extension",
"of",
"filename",
"is",
"among",
"extensions",
".",
"It",
"is",
"a",
"case",
"-",
"insensitive",
"lookup",
"optimized",
"for",
"the",
"ASCII",
"case",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/magic/magic.go#L235-L264 | train |
perkeep/perkeep | internal/magic/magic.go | MIMETypeByExtension | func MIMETypeByExtension(ext string) string {
mimeParts := strings.SplitN(mime.TypeByExtension(ext), ";", 2)
return strings.TrimSpace(mimeParts[0])
} | go | func MIMETypeByExtension(ext string) string {
mimeParts := strings.SplitN(mime.TypeByExtension(ext), ";", 2)
return strings.TrimSpace(mimeParts[0])
} | [
"func",
"MIMETypeByExtension",
"(",
"ext",
"string",
")",
"string",
"{",
"mimeParts",
":=",
"strings",
".",
"SplitN",
"(",
"mime",
".",
"TypeByExtension",
"(",
"ext",
")",
",",
"\";\"",
",",
"2",
")",
"\n",
"return",
"strings",
".",
"TrimSpace",
"(",
"mimeParts",
"[",
"0",
"]",
")",
"\n",
"}"
] | // MIMETypeByExtension calls mime.TypeByExtension, and removes optional parameters,
// to keep only the type and subtype. | [
"MIMETypeByExtension",
"calls",
"mime",
".",
"TypeByExtension",
"and",
"removes",
"optional",
"parameters",
"to",
"keep",
"only",
"the",
"type",
"and",
"subtype",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/magic/magic.go#L268-L271 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/blobpacked.go | checkLargeIntegrity | func (s *storage) checkLargeIntegrity() (RecoveryMode, error) {
inLarge := 0
var missing []blob.Ref // blobs in large but not in meta
var extra []blob.Ref // blobs in meta but not in large
t := s.meta.Find(zipMetaPrefix, zipMetaPrefixLimit)
defer t.Close()
iterate := true
var enumFunc func(sb blob.SizedRef) error
enumFunc = func(sb blob.SizedRef) error {
if iterate && !t.Next() {
// all of the yet to be enumerated are missing from meta
missing = append(missing, sb.Ref)
return nil
}
iterate = true
wantMetaKey := zipMetaPrefix + sb.Ref.String()
metaKey := t.Key()
if metaKey != wantMetaKey {
if metaKey > wantMetaKey {
// zipRef missing from meta
missing = append(missing, sb.Ref)
iterate = false
return nil
}
// zipRef in meta that actually does not exist in s.large.
xbr, ok := blob.Parse(strings.TrimPrefix(metaKey, zipMetaPrefix))
if !ok {
return fmt.Errorf("boggus key in z: row: %q", metaKey)
}
extra = append(extra, xbr)
// iterate meta once more at the same storage enumeration point
return enumFunc(sb)
}
if _, err := parseZipMetaRow(t.ValueBytes()); err != nil {
return fmt.Errorf("error parsing row from meta: %v", err)
}
inLarge++
return nil
}
log.Printf("blobpacked: checking integrity of packed blobs against index...")
if err := blobserver.EnumerateAllFrom(context.Background(), s.large, "", enumFunc); err != nil {
return FullRecovery, err
}
log.Printf("blobpacked: %d large blobs found in index, %d missing from index", inLarge, len(missing))
if len(missing) > 0 {
printSample(missing, "missing")
}
if len(extra) > 0 {
printSample(extra, "extra")
return FullRecovery, fmt.Errorf("%d large blobs in index but not actually in storage", len(extra))
}
if err := t.Close(); err != nil {
return FullRecovery, fmt.Errorf("error reading or closing index: %v", err)
}
if len(missing) > 0 {
return FastRecovery, fmt.Errorf("%d large blobs missing from index", len(missing))
}
return NoRecovery, nil
} | go | func (s *storage) checkLargeIntegrity() (RecoveryMode, error) {
inLarge := 0
var missing []blob.Ref // blobs in large but not in meta
var extra []blob.Ref // blobs in meta but not in large
t := s.meta.Find(zipMetaPrefix, zipMetaPrefixLimit)
defer t.Close()
iterate := true
var enumFunc func(sb blob.SizedRef) error
enumFunc = func(sb blob.SizedRef) error {
if iterate && !t.Next() {
// all of the yet to be enumerated are missing from meta
missing = append(missing, sb.Ref)
return nil
}
iterate = true
wantMetaKey := zipMetaPrefix + sb.Ref.String()
metaKey := t.Key()
if metaKey != wantMetaKey {
if metaKey > wantMetaKey {
// zipRef missing from meta
missing = append(missing, sb.Ref)
iterate = false
return nil
}
// zipRef in meta that actually does not exist in s.large.
xbr, ok := blob.Parse(strings.TrimPrefix(metaKey, zipMetaPrefix))
if !ok {
return fmt.Errorf("boggus key in z: row: %q", metaKey)
}
extra = append(extra, xbr)
// iterate meta once more at the same storage enumeration point
return enumFunc(sb)
}
if _, err := parseZipMetaRow(t.ValueBytes()); err != nil {
return fmt.Errorf("error parsing row from meta: %v", err)
}
inLarge++
return nil
}
log.Printf("blobpacked: checking integrity of packed blobs against index...")
if err := blobserver.EnumerateAllFrom(context.Background(), s.large, "", enumFunc); err != nil {
return FullRecovery, err
}
log.Printf("blobpacked: %d large blobs found in index, %d missing from index", inLarge, len(missing))
if len(missing) > 0 {
printSample(missing, "missing")
}
if len(extra) > 0 {
printSample(extra, "extra")
return FullRecovery, fmt.Errorf("%d large blobs in index but not actually in storage", len(extra))
}
if err := t.Close(); err != nil {
return FullRecovery, fmt.Errorf("error reading or closing index: %v", err)
}
if len(missing) > 0 {
return FastRecovery, fmt.Errorf("%d large blobs missing from index", len(missing))
}
return NoRecovery, nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"checkLargeIntegrity",
"(",
")",
"(",
"RecoveryMode",
",",
"error",
")",
"{",
"inLarge",
":=",
"0",
"\n",
"var",
"missing",
"[",
"]",
"blob",
".",
"Ref",
"\n",
"var",
"extra",
"[",
"]",
"blob",
".",
"Ref",
"\n",
"t",
":=",
"s",
".",
"meta",
".",
"Find",
"(",
"zipMetaPrefix",
",",
"zipMetaPrefixLimit",
")",
"\n",
"defer",
"t",
".",
"Close",
"(",
")",
"\n",
"iterate",
":=",
"true",
"\n",
"var",
"enumFunc",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"\n",
"enumFunc",
"=",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"if",
"iterate",
"&&",
"!",
"t",
".",
"Next",
"(",
")",
"{",
"missing",
"=",
"append",
"(",
"missing",
",",
"sb",
".",
"Ref",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"iterate",
"=",
"true",
"\n",
"wantMetaKey",
":=",
"zipMetaPrefix",
"+",
"sb",
".",
"Ref",
".",
"String",
"(",
")",
"\n",
"metaKey",
":=",
"t",
".",
"Key",
"(",
")",
"\n",
"if",
"metaKey",
"!=",
"wantMetaKey",
"{",
"if",
"metaKey",
">",
"wantMetaKey",
"{",
"missing",
"=",
"append",
"(",
"missing",
",",
"sb",
".",
"Ref",
")",
"\n",
"iterate",
"=",
"false",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"xbr",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"strings",
".",
"TrimPrefix",
"(",
"metaKey",
",",
"zipMetaPrefix",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"boggus key in z: row: %q\"",
",",
"metaKey",
")",
"\n",
"}",
"\n",
"extra",
"=",
"append",
"(",
"extra",
",",
"xbr",
")",
"\n",
"return",
"enumFunc",
"(",
"sb",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"parseZipMetaRow",
"(",
"t",
".",
"ValueBytes",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"error parsing row from meta: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"inLarge",
"++",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Printf",
"(",
"\"blobpacked: checking integrity of packed blobs against index...\"",
")",
"\n",
"if",
"err",
":=",
"blobserver",
".",
"EnumerateAllFrom",
"(",
"context",
".",
"Background",
"(",
")",
",",
"s",
".",
"large",
",",
"\"\"",
",",
"enumFunc",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"FullRecovery",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"Printf",
"(",
"\"blobpacked: %d large blobs found in index, %d missing from index\"",
",",
"inLarge",
",",
"len",
"(",
"missing",
")",
")",
"\n",
"if",
"len",
"(",
"missing",
")",
">",
"0",
"{",
"printSample",
"(",
"missing",
",",
"\"missing\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"extra",
")",
">",
"0",
"{",
"printSample",
"(",
"extra",
",",
"\"extra\"",
")",
"\n",
"return",
"FullRecovery",
",",
"fmt",
".",
"Errorf",
"(",
"\"%d large blobs in index but not actually in storage\"",
",",
"len",
"(",
"extra",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"t",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"FullRecovery",
",",
"fmt",
".",
"Errorf",
"(",
"\"error reading or closing index: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"missing",
")",
">",
"0",
"{",
"return",
"FastRecovery",
",",
"fmt",
".",
"Errorf",
"(",
"\"%d large blobs missing from index\"",
",",
"len",
"(",
"missing",
")",
")",
"\n",
"}",
"\n",
"return",
"NoRecovery",
",",
"nil",
"\n",
"}"
] | // checkLargeIntegrity verifies that all large blobs in the large storage are
// indexed in meta, and vice-versa, that all rows in meta referring to a large blob
// correspond to an existing large blob in the large storage. If any of the above
// is not true, it returns the recovery mode that should be used to fix the
// problem, as well as the error detailing the problem. It does not perform any
// check about the contents of the large blobs themselves. | [
"checkLargeIntegrity",
"verifies",
"that",
"all",
"large",
"blobs",
"in",
"the",
"large",
"storage",
"are",
"indexed",
"in",
"meta",
"and",
"vice",
"-",
"versa",
"that",
"all",
"rows",
"in",
"meta",
"referring",
"to",
"a",
"large",
"blob",
"correspond",
"to",
"an",
"existing",
"large",
"blob",
"in",
"the",
"large",
"storage",
".",
"If",
"any",
"of",
"the",
"above",
"is",
"not",
"true",
"it",
"returns",
"the",
"recovery",
"mode",
"that",
"should",
"be",
"used",
"to",
"fix",
"the",
"problem",
"as",
"well",
"as",
"the",
"error",
"detailing",
"the",
"problem",
".",
"It",
"does",
"not",
"perform",
"any",
"check",
"about",
"the",
"contents",
"of",
"the",
"large",
"blobs",
"themselves",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/blobpacked.go#L383-L441 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/blobpacked.go | getMetaRow | func (s *storage) getMetaRow(br blob.Ref) (meta, error) {
v, err := s.meta.Get(blobMetaPrefix + br.String())
if err == sorted.ErrNotFound {
return meta{}, nil
}
if err != nil {
return meta{}, fmt.Errorf("blobpacked.getMetaRow(%v) = %v", br, err)
}
return parseMetaRow([]byte(v))
} | go | func (s *storage) getMetaRow(br blob.Ref) (meta, error) {
v, err := s.meta.Get(blobMetaPrefix + br.String())
if err == sorted.ErrNotFound {
return meta{}, nil
}
if err != nil {
return meta{}, fmt.Errorf("blobpacked.getMetaRow(%v) = %v", br, err)
}
return parseMetaRow([]byte(v))
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"getMetaRow",
"(",
"br",
"blob",
".",
"Ref",
")",
"(",
"meta",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"s",
".",
"meta",
".",
"Get",
"(",
"blobMetaPrefix",
"+",
"br",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"sorted",
".",
"ErrNotFound",
"{",
"return",
"meta",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"meta",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"blobpacked.getMetaRow(%v) = %v\"",
",",
"br",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"parseMetaRow",
"(",
"[",
"]",
"byte",
"(",
"v",
")",
")",
"\n",
"}"
] | // if not found, err == nil. | [
"if",
"not",
"found",
"err",
"==",
"nil",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/blobpacked.go#L841-L850 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/blobpacked.go | check | func check(err error) {
if err != nil {
b := make([]byte, 2<<10)
b = b[:runtime.Stack(b, false)]
log.Printf("Unlikely error condition triggered: %v at %s", err, b)
panic(err)
}
} | go | func check(err error) {
if err != nil {
b := make([]byte, 2<<10)
b = b[:runtime.Stack(b, false)]
log.Printf("Unlikely error condition triggered: %v at %s", err, b)
panic(err)
}
} | [
"func",
"check",
"(",
"err",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
"<<",
"10",
")",
"\n",
"b",
"=",
"b",
"[",
":",
"runtime",
".",
"Stack",
"(",
"b",
",",
"false",
")",
"]",
"\n",
"log",
".",
"Printf",
"(",
"\"Unlikely error condition triggered: %v at %s\"",
",",
"err",
",",
"b",
")",
"\n",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // check should only be used for things which really shouldn't ever happen, but should
// still be checked. If there is interesting logic in the 'else', then don't use this. | [
"check",
"should",
"only",
"be",
"used",
"for",
"things",
"which",
"really",
"shouldn",
"t",
"ever",
"happen",
"but",
"should",
"still",
"be",
"checked",
".",
"If",
"there",
"is",
"interesting",
"logic",
"in",
"the",
"else",
"then",
"don",
"t",
"use",
"this",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/blobpacked.go#L1297-L1304 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/blobpacked.go | foreachZipBlob | func (s *storage) foreachZipBlob(ctx context.Context, zipRef blob.Ref, fn func(BlobAndPos) error) error {
sb, err := blobserver.StatBlob(ctx, s.large, zipRef)
if err != nil {
return err
}
zr, err := zip.NewReader(blob.ReaderAt(ctx, s.large, zipRef), int64(sb.Size))
if err != nil {
return zipOpenError{zipRef, err}
}
var maniFile *zip.File // or nil if not found
var firstOff int64 // offset of first file (the packed data chunks)
for i, f := range zr.File {
if i == 0 {
firstOff, err = f.DataOffset()
if err != nil {
return err
}
}
if f.Name == zipManifestPath {
maniFile = f
break
}
}
if maniFile == nil {
return errors.New("no camlistore manifest file found in zip")
}
// apply fn to all the schema blobs
for _, f := range zr.File {
if !strings.HasPrefix(f.Name, "camlistore/") || f.Name == zipManifestPath ||
!strings.HasSuffix(f.Name, ".json") {
continue
}
brStr := strings.TrimSuffix(strings.TrimPrefix(f.Name, "camlistore/"), ".json")
br, ok := blob.Parse(brStr)
if ok {
off, err := f.DataOffset()
if err != nil {
return err
}
if err := fn(BlobAndPos{
SizedRef: blob.SizedRef{Ref: br, Size: uint32(f.UncompressedSize64)},
Offset: off,
}); err != nil {
return err
}
}
}
maniRC, err := maniFile.Open()
if err != nil {
return err
}
defer maniRC.Close()
var mf Manifest
if err := json.NewDecoder(maniRC).Decode(&mf); err != nil {
return err
}
if !mf.WholeRef.Valid() || mf.WholeSize == 0 || !mf.DataBlobsOrigin.Valid() {
return errors.New("incomplete blobpack manifest JSON")
}
// apply fn to all the data blobs
for _, bap := range mf.DataBlobs {
bap.Offset += firstOff
if err := fn(bap); err != nil {
return err
}
}
return nil
} | go | func (s *storage) foreachZipBlob(ctx context.Context, zipRef blob.Ref, fn func(BlobAndPos) error) error {
sb, err := blobserver.StatBlob(ctx, s.large, zipRef)
if err != nil {
return err
}
zr, err := zip.NewReader(blob.ReaderAt(ctx, s.large, zipRef), int64(sb.Size))
if err != nil {
return zipOpenError{zipRef, err}
}
var maniFile *zip.File // or nil if not found
var firstOff int64 // offset of first file (the packed data chunks)
for i, f := range zr.File {
if i == 0 {
firstOff, err = f.DataOffset()
if err != nil {
return err
}
}
if f.Name == zipManifestPath {
maniFile = f
break
}
}
if maniFile == nil {
return errors.New("no camlistore manifest file found in zip")
}
// apply fn to all the schema blobs
for _, f := range zr.File {
if !strings.HasPrefix(f.Name, "camlistore/") || f.Name == zipManifestPath ||
!strings.HasSuffix(f.Name, ".json") {
continue
}
brStr := strings.TrimSuffix(strings.TrimPrefix(f.Name, "camlistore/"), ".json")
br, ok := blob.Parse(brStr)
if ok {
off, err := f.DataOffset()
if err != nil {
return err
}
if err := fn(BlobAndPos{
SizedRef: blob.SizedRef{Ref: br, Size: uint32(f.UncompressedSize64)},
Offset: off,
}); err != nil {
return err
}
}
}
maniRC, err := maniFile.Open()
if err != nil {
return err
}
defer maniRC.Close()
var mf Manifest
if err := json.NewDecoder(maniRC).Decode(&mf); err != nil {
return err
}
if !mf.WholeRef.Valid() || mf.WholeSize == 0 || !mf.DataBlobsOrigin.Valid() {
return errors.New("incomplete blobpack manifest JSON")
}
// apply fn to all the data blobs
for _, bap := range mf.DataBlobs {
bap.Offset += firstOff
if err := fn(bap); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"foreachZipBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"zipRef",
"blob",
".",
"Ref",
",",
"fn",
"func",
"(",
"BlobAndPos",
")",
"error",
")",
"error",
"{",
"sb",
",",
"err",
":=",
"blobserver",
".",
"StatBlob",
"(",
"ctx",
",",
"s",
".",
"large",
",",
"zipRef",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"zr",
",",
"err",
":=",
"zip",
".",
"NewReader",
"(",
"blob",
".",
"ReaderAt",
"(",
"ctx",
",",
"s",
".",
"large",
",",
"zipRef",
")",
",",
"int64",
"(",
"sb",
".",
"Size",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"zipOpenError",
"{",
"zipRef",
",",
"err",
"}",
"\n",
"}",
"\n",
"var",
"maniFile",
"*",
"zip",
".",
"File",
"\n",
"var",
"firstOff",
"int64",
"\n",
"for",
"i",
",",
"f",
":=",
"range",
"zr",
".",
"File",
"{",
"if",
"i",
"==",
"0",
"{",
"firstOff",
",",
"err",
"=",
"f",
".",
"DataOffset",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"f",
".",
"Name",
"==",
"zipManifestPath",
"{",
"maniFile",
"=",
"f",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"maniFile",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"no camlistore manifest file found in zip\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"zr",
".",
"File",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"f",
".",
"Name",
",",
"\"camlistore/\"",
")",
"||",
"f",
".",
"Name",
"==",
"zipManifestPath",
"||",
"!",
"strings",
".",
"HasSuffix",
"(",
"f",
".",
"Name",
",",
"\".json\"",
")",
"{",
"continue",
"\n",
"}",
"\n",
"brStr",
":=",
"strings",
".",
"TrimSuffix",
"(",
"strings",
".",
"TrimPrefix",
"(",
"f",
".",
"Name",
",",
"\"camlistore/\"",
")",
",",
"\".json\"",
")",
"\n",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"brStr",
")",
"\n",
"if",
"ok",
"{",
"off",
",",
"err",
":=",
"f",
".",
"DataOffset",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"fn",
"(",
"BlobAndPos",
"{",
"SizedRef",
":",
"blob",
".",
"SizedRef",
"{",
"Ref",
":",
"br",
",",
"Size",
":",
"uint32",
"(",
"f",
".",
"UncompressedSize64",
")",
"}",
",",
"Offset",
":",
"off",
",",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"maniRC",
",",
"err",
":=",
"maniFile",
".",
"Open",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"maniRC",
".",
"Close",
"(",
")",
"\n",
"var",
"mf",
"Manifest",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"maniRC",
")",
".",
"Decode",
"(",
"&",
"mf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"mf",
".",
"WholeRef",
".",
"Valid",
"(",
")",
"||",
"mf",
".",
"WholeSize",
"==",
"0",
"||",
"!",
"mf",
".",
"DataBlobsOrigin",
".",
"Valid",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"incomplete blobpack manifest JSON\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"bap",
":=",
"range",
"mf",
".",
"DataBlobs",
"{",
"bap",
".",
"Offset",
"+=",
"firstOff",
"\n",
"if",
"err",
":=",
"fn",
"(",
"bap",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // foreachZipBlob calls fn for each blob in the zip pack blob
// identified by zipRef. If fn returns a non-nil error,
// foreachZipBlob stops enumerating with that error. | [
"foreachZipBlob",
"calls",
"fn",
"for",
"each",
"blob",
"in",
"the",
"zip",
"pack",
"blob",
"identified",
"by",
"zipRef",
".",
"If",
"fn",
"returns",
"a",
"non",
"-",
"nil",
"error",
"foreachZipBlob",
"stops",
"enumerating",
"with",
"that",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/blobpacked.go#L1522-L1590 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/blobpacked.go | deleteZipPack | func (s *storage) deleteZipPack(ctx context.Context, br blob.Ref) error {
inUse, err := s.zipPartsInUse(ctx, br)
if err != nil {
return err
}
if len(inUse) > 0 {
return fmt.Errorf("can't delete zip pack %v: %d parts in use: %v", br, len(inUse), inUse)
}
if err := s.large.RemoveBlobs(ctx, []blob.Ref{br}); err != nil {
return err
}
return s.meta.Delete("d:" + br.String())
} | go | func (s *storage) deleteZipPack(ctx context.Context, br blob.Ref) error {
inUse, err := s.zipPartsInUse(ctx, br)
if err != nil {
return err
}
if len(inUse) > 0 {
return fmt.Errorf("can't delete zip pack %v: %d parts in use: %v", br, len(inUse), inUse)
}
if err := s.large.RemoveBlobs(ctx, []blob.Ref{br}); err != nil {
return err
}
return s.meta.Delete("d:" + br.String())
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"deleteZipPack",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
")",
"error",
"{",
"inUse",
",",
"err",
":=",
"s",
".",
"zipPartsInUse",
"(",
"ctx",
",",
"br",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"inUse",
")",
">",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"can't delete zip pack %v: %d parts in use: %v\"",
",",
"br",
",",
"len",
"(",
"inUse",
")",
",",
"inUse",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"large",
".",
"RemoveBlobs",
"(",
"ctx",
",",
"[",
"]",
"blob",
".",
"Ref",
"{",
"br",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"s",
".",
"meta",
".",
"Delete",
"(",
"\"d:\"",
"+",
"br",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // deleteZipPack deletes the zip pack file br, but only if that zip
// file's parts are deleted already from the meta index. | [
"deleteZipPack",
"deletes",
"the",
"zip",
"pack",
"file",
"br",
"but",
"only",
"if",
"that",
"zip",
"file",
"s",
"parts",
"are",
"deleted",
"already",
"from",
"the",
"meta",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/blobpacked.go#L1594-L1606 | train |
perkeep/perkeep | internal/video/thumbnail/service.go | NewService | func NewService(th Thumbnailer, timeout time.Duration, maxProcs int) *Service {
var g *syncutil.Gate
if maxProcs > 0 {
g = syncutil.NewGate(maxProcs)
}
return &Service{
thumbnailer: th,
timeout: timeout,
gate: g,
}
} | go | func NewService(th Thumbnailer, timeout time.Duration, maxProcs int) *Service {
var g *syncutil.Gate
if maxProcs > 0 {
g = syncutil.NewGate(maxProcs)
}
return &Service{
thumbnailer: th,
timeout: timeout,
gate: g,
}
} | [
"func",
"NewService",
"(",
"th",
"Thumbnailer",
",",
"timeout",
"time",
".",
"Duration",
",",
"maxProcs",
"int",
")",
"*",
"Service",
"{",
"var",
"g",
"*",
"syncutil",
".",
"Gate",
"\n",
"if",
"maxProcs",
">",
"0",
"{",
"g",
"=",
"syncutil",
".",
"NewGate",
"(",
"maxProcs",
")",
"\n",
"}",
"\n",
"return",
"&",
"Service",
"{",
"thumbnailer",
":",
"th",
",",
"timeout",
":",
"timeout",
",",
"gate",
":",
"g",
",",
"}",
"\n",
"}"
] | // NewService builds a new Service. Zero timeout or maxProcs means no limit. | [
"NewService",
"builds",
"a",
"new",
"Service",
".",
"Zero",
"timeout",
"or",
"maxProcs",
"means",
"no",
"limit",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/video/thumbnail/service.go#L82-L94 | train |
perkeep/perkeep | internal/video/thumbnail/service.go | Generate | func (s *Service) Generate(videoRef blob.Ref, w io.Writer, src blob.Fetcher) error {
if s.gate != nil {
s.gate.Start()
defer s.gate.Done()
}
ln, err := netutil.ListenOnLocalRandomPort()
if err != nil {
return err
}
defer ln.Close()
videoURI := &url.URL{
Scheme: "http",
Host: ln.Addr().String(),
Path: videoRef.String(),
}
cmdErrc := make(chan error, 1)
cmd := buildCmd(s.thumbnailer, videoURI, w)
cmdErrOut, err := cmd.StderrPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
defer cmd.Process.Kill()
go func() {
out, err := ioutil.ReadAll(cmdErrOut)
if err != nil {
cmdErrc <- err
return
}
cmd.Wait()
if cmd.ProcessState.Success() {
cmdErrc <- nil
return
}
cmdErrc <- fmt.Errorf("thumbnail subprocess failed:\n%s", out)
}()
servErrc := make(chan error, 1)
go func() {
servErrc <- http.Serve(ln, createVideothumbnailHandler(videoRef, src))
}()
select {
case err := <-cmdErrc:
return err
case err := <-servErrc:
return err
case <-s.timer():
return errTimeout
}
} | go | func (s *Service) Generate(videoRef blob.Ref, w io.Writer, src blob.Fetcher) error {
if s.gate != nil {
s.gate.Start()
defer s.gate.Done()
}
ln, err := netutil.ListenOnLocalRandomPort()
if err != nil {
return err
}
defer ln.Close()
videoURI := &url.URL{
Scheme: "http",
Host: ln.Addr().String(),
Path: videoRef.String(),
}
cmdErrc := make(chan error, 1)
cmd := buildCmd(s.thumbnailer, videoURI, w)
cmdErrOut, err := cmd.StderrPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
defer cmd.Process.Kill()
go func() {
out, err := ioutil.ReadAll(cmdErrOut)
if err != nil {
cmdErrc <- err
return
}
cmd.Wait()
if cmd.ProcessState.Success() {
cmdErrc <- nil
return
}
cmdErrc <- fmt.Errorf("thumbnail subprocess failed:\n%s", out)
}()
servErrc := make(chan error, 1)
go func() {
servErrc <- http.Serve(ln, createVideothumbnailHandler(videoRef, src))
}()
select {
case err := <-cmdErrc:
return err
case err := <-servErrc:
return err
case <-s.timer():
return errTimeout
}
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Generate",
"(",
"videoRef",
"blob",
".",
"Ref",
",",
"w",
"io",
".",
"Writer",
",",
"src",
"blob",
".",
"Fetcher",
")",
"error",
"{",
"if",
"s",
".",
"gate",
"!=",
"nil",
"{",
"s",
".",
"gate",
".",
"Start",
"(",
")",
"\n",
"defer",
"s",
".",
"gate",
".",
"Done",
"(",
")",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"netutil",
".",
"ListenOnLocalRandomPort",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"ln",
".",
"Close",
"(",
")",
"\n",
"videoURI",
":=",
"&",
"url",
".",
"URL",
"{",
"Scheme",
":",
"\"http\"",
",",
"Host",
":",
"ln",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
",",
"Path",
":",
"videoRef",
".",
"String",
"(",
")",
",",
"}",
"\n",
"cmdErrc",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"cmd",
":=",
"buildCmd",
"(",
"s",
".",
"thumbnailer",
",",
"videoURI",
",",
"w",
")",
"\n",
"cmdErrOut",
",",
"err",
":=",
"cmd",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"cmd",
".",
"Process",
".",
"Kill",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"out",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"cmdErrOut",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cmdErrc",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"cmd",
".",
"Wait",
"(",
")",
"\n",
"if",
"cmd",
".",
"ProcessState",
".",
"Success",
"(",
")",
"{",
"cmdErrc",
"<-",
"nil",
"\n",
"return",
"\n",
"}",
"\n",
"cmdErrc",
"<-",
"fmt",
".",
"Errorf",
"(",
"\"thumbnail subprocess failed:\\n%s\"",
",",
"\\n",
")",
"\n",
"}",
"out",
"\n",
"(",
")",
"\n",
"servErrc",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"servErrc",
"<-",
"http",
".",
"Serve",
"(",
"ln",
",",
"createVideothumbnailHandler",
"(",
"videoRef",
",",
"src",
")",
")",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // Generate reads the video given by videoRef from src and writes its thumbnail image to w. | [
"Generate",
"reads",
"the",
"video",
"given",
"by",
"videoRef",
"from",
"src",
"and",
"writes",
"its",
"thumbnail",
"image",
"to",
"w",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/video/thumbnail/service.go#L99-L155 | train |
perkeep/perkeep | server/perkeepd/ui/goui/downloadbutton/gen_DownloadItemsBtn_reactGen.go | Props | func (d DownloadItemsBtnDef) Props() DownloadItemsBtnProps {
uprops := d.ComponentDef.Props()
return uprops.(DownloadItemsBtnProps)
} | go | func (d DownloadItemsBtnDef) Props() DownloadItemsBtnProps {
uprops := d.ComponentDef.Props()
return uprops.(DownloadItemsBtnProps)
} | [
"func",
"(",
"d",
"DownloadItemsBtnDef",
")",
"Props",
"(",
")",
"DownloadItemsBtnProps",
"{",
"uprops",
":=",
"d",
".",
"ComponentDef",
".",
"Props",
"(",
")",
"\n",
"return",
"uprops",
".",
"(",
"DownloadItemsBtnProps",
")",
"\n",
"}"
] | // Props is an auto-generated proxy to the current props of DownloadItemsBtn | [
"Props",
"is",
"an",
"auto",
"-",
"generated",
"proxy",
"to",
"the",
"current",
"props",
"of",
"DownloadItemsBtn"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/downloadbutton/gen_DownloadItemsBtn_reactGen.go#L30-L33 | train |
perkeep/perkeep | pkg/server/import_share.go | importAll | func (si *shareImporter) importAll(ctx context.Context) error {
src, shared, err := client.NewFromShareRoot(ctx, si.shareURL, client.OptionNoExternalConfig())
if err != nil {
return err
}
si.src = src
si.br = shared
si.workc = make(chan work, 2*numWorkers)
defer close(si.workc)
// fan out over a pool of numWorkers workers overall
for i := 0; i < numWorkers; i++ {
go func() {
for wi := range si.workc {
wi.errc <- si.imprt(ctx, wi.br)
}
}()
}
// work assignment is done asynchronously, so imprt returns before all the work is finished.
err = si.imprt(ctx, shared)
si.wg.Wait()
if err == nil {
si.mu.RLock()
err = si.err
si.mu.RUnlock()
}
log.Print("share importer: all workers done")
if err != nil {
return err
}
return nil
} | go | func (si *shareImporter) importAll(ctx context.Context) error {
src, shared, err := client.NewFromShareRoot(ctx, si.shareURL, client.OptionNoExternalConfig())
if err != nil {
return err
}
si.src = src
si.br = shared
si.workc = make(chan work, 2*numWorkers)
defer close(si.workc)
// fan out over a pool of numWorkers workers overall
for i := 0; i < numWorkers; i++ {
go func() {
for wi := range si.workc {
wi.errc <- si.imprt(ctx, wi.br)
}
}()
}
// work assignment is done asynchronously, so imprt returns before all the work is finished.
err = si.imprt(ctx, shared)
si.wg.Wait()
if err == nil {
si.mu.RLock()
err = si.err
si.mu.RUnlock()
}
log.Print("share importer: all workers done")
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"si",
"*",
"shareImporter",
")",
"importAll",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"src",
",",
"shared",
",",
"err",
":=",
"client",
".",
"NewFromShareRoot",
"(",
"ctx",
",",
"si",
".",
"shareURL",
",",
"client",
".",
"OptionNoExternalConfig",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"si",
".",
"src",
"=",
"src",
"\n",
"si",
".",
"br",
"=",
"shared",
"\n",
"si",
".",
"workc",
"=",
"make",
"(",
"chan",
"work",
",",
"2",
"*",
"numWorkers",
")",
"\n",
"defer",
"close",
"(",
"si",
".",
"workc",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numWorkers",
";",
"i",
"++",
"{",
"go",
"func",
"(",
")",
"{",
"for",
"wi",
":=",
"range",
"si",
".",
"workc",
"{",
"wi",
".",
"errc",
"<-",
"si",
".",
"imprt",
"(",
"ctx",
",",
"wi",
".",
"br",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"err",
"=",
"si",
".",
"imprt",
"(",
"ctx",
",",
"shared",
")",
"\n",
"si",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"si",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"err",
"=",
"si",
".",
"err",
"\n",
"si",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"}",
"\n",
"log",
".",
"Print",
"(",
"\"share importer: all workers done\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // importAll imports all the shared contents transitively reachable under
// si.shareURL. | [
"importAll",
"imports",
"all",
"the",
"shared",
"contents",
"transitively",
"reachable",
"under",
"si",
".",
"shareURL",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/import_share.go#L176-L207 | train |
perkeep/perkeep | pkg/server/import_share.go | importAssembled | func (si *shareImporter) importAssembled(ctx context.Context) {
res, err := http.Get(si.shareURL)
if err != nil {
return
}
defer res.Body.Close()
br, err := schema.WriteFileFromReader(ctx, si.dest, "", res.Body)
if err != nil {
return
}
si.mu.Lock()
si.br = br
si.mu.Unlock()
return
} | go | func (si *shareImporter) importAssembled(ctx context.Context) {
res, err := http.Get(si.shareURL)
if err != nil {
return
}
defer res.Body.Close()
br, err := schema.WriteFileFromReader(ctx, si.dest, "", res.Body)
if err != nil {
return
}
si.mu.Lock()
si.br = br
si.mu.Unlock()
return
} | [
"func",
"(",
"si",
"*",
"shareImporter",
")",
"importAssembled",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"res",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"si",
".",
"shareURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"br",
",",
"err",
":=",
"schema",
".",
"WriteFileFromReader",
"(",
"ctx",
",",
"si",
".",
"dest",
",",
"\"\"",
",",
"res",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"si",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"si",
".",
"br",
"=",
"br",
"\n",
"si",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] | // importAssembled imports the assembled file shared at si.shareURL. | [
"importAssembled",
"imports",
"the",
"assembled",
"file",
"shared",
"at",
"si",
".",
"shareURL",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/import_share.go#L210-L224 | train |
perkeep/perkeep | pkg/server/import_share.go | isAssembled | func (si *shareImporter) isAssembled() (bool, error) {
u, err := url.Parse(si.shareURL)
if err != nil {
return false, err
}
isAs, _ := strconv.ParseBool(u.Query().Get("assemble"))
return isAs, nil
} | go | func (si *shareImporter) isAssembled() (bool, error) {
u, err := url.Parse(si.shareURL)
if err != nil {
return false, err
}
isAs, _ := strconv.ParseBool(u.Query().Get("assemble"))
return isAs, nil
} | [
"func",
"(",
"si",
"*",
"shareImporter",
")",
"isAssembled",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"si",
".",
"shareURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"isAs",
",",
"_",
":=",
"strconv",
".",
"ParseBool",
"(",
"u",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"assemble\"",
")",
")",
"\n",
"return",
"isAs",
",",
"nil",
"\n",
"}"
] | // isAssembled reports whether si.shareURL is of a shared assembled file. | [
"isAssembled",
"reports",
"whether",
"si",
".",
"shareURL",
"is",
"of",
"a",
"shared",
"assembled",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/import_share.go#L227-L234 | train |
perkeep/perkeep | pkg/server/import_share.go | serveProgress | func (si *shareImporter) serveProgress(w http.ResponseWriter, r *http.Request) {
si.mu.RLock()
defer si.mu.RUnlock()
httputil.ReturnJSON(w, camtypes.ShareImportProgress{
FilesSeen: si.seen,
FilesCopied: si.copied,
Running: si.running,
Assembled: si.assembled,
BlobRef: si.br,
})
} | go | func (si *shareImporter) serveProgress(w http.ResponseWriter, r *http.Request) {
si.mu.RLock()
defer si.mu.RUnlock()
httputil.ReturnJSON(w, camtypes.ShareImportProgress{
FilesSeen: si.seen,
FilesCopied: si.copied,
Running: si.running,
Assembled: si.assembled,
BlobRef: si.br,
})
} | [
"func",
"(",
"si",
"*",
"shareImporter",
")",
"serveProgress",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"si",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"si",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"httputil",
".",
"ReturnJSON",
"(",
"w",
",",
"camtypes",
".",
"ShareImportProgress",
"{",
"FilesSeen",
":",
"si",
".",
"seen",
",",
"FilesCopied",
":",
"si",
".",
"copied",
",",
"Running",
":",
"si",
".",
"running",
",",
"Assembled",
":",
"si",
".",
"assembled",
",",
"BlobRef",
":",
"si",
".",
"br",
",",
"}",
")",
"\n",
"}"
] | // serveProgress serves the state of the currently running importing process | [
"serveProgress",
"serves",
"the",
"state",
"of",
"the",
"currently",
"running",
"importing",
"process"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/import_share.go#L304-L314 | train |
perkeep/perkeep | internal/httputil/certs.go | GenSelfTLS | func GenSelfTLS(hostname string) (certPEM, keyPEM []byte, err error) {
priv, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return certPEM, keyPEM, fmt.Errorf("failed to generate private key: %s", err)
}
now := time.Now()
if hostname == "" {
hostname = "localhost"
}
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
if err != nil {
log.Fatalf("failed to generate serial number: %s", err)
}
template := x509.Certificate{
SerialNumber: serialNumber,
Subject: pkix.Name{
CommonName: hostname,
Organization: []string{hostname},
},
NotBefore: now.Add(-5 * time.Minute).UTC(),
NotAfter: now.AddDate(1, 0, 0).UTC(),
SubjectKeyId: []byte{1, 2, 3, 4},
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
IsCA: true,
BasicConstraintsValid: true,
}
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
if err != nil {
return certPEM, keyPEM, fmt.Errorf("failed to create certificate: %s", err)
}
var buf bytes.Buffer
if err := pem.Encode(&buf, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
return certPEM, keyPEM, fmt.Errorf("error writing self-signed HTTPS cert: %v", err)
}
certPEM = []byte(buf.String())
buf.Reset()
if err := pem.Encode(&buf, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)}); err != nil {
return certPEM, keyPEM, fmt.Errorf("error writing self-signed HTTPS private key: %v", err)
}
keyPEM = buf.Bytes()
return certPEM, keyPEM, nil
} | go | func GenSelfTLS(hostname string) (certPEM, keyPEM []byte, err error) {
priv, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return certPEM, keyPEM, fmt.Errorf("failed to generate private key: %s", err)
}
now := time.Now()
if hostname == "" {
hostname = "localhost"
}
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
if err != nil {
log.Fatalf("failed to generate serial number: %s", err)
}
template := x509.Certificate{
SerialNumber: serialNumber,
Subject: pkix.Name{
CommonName: hostname,
Organization: []string{hostname},
},
NotBefore: now.Add(-5 * time.Minute).UTC(),
NotAfter: now.AddDate(1, 0, 0).UTC(),
SubjectKeyId: []byte{1, 2, 3, 4},
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
IsCA: true,
BasicConstraintsValid: true,
}
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
if err != nil {
return certPEM, keyPEM, fmt.Errorf("failed to create certificate: %s", err)
}
var buf bytes.Buffer
if err := pem.Encode(&buf, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
return certPEM, keyPEM, fmt.Errorf("error writing self-signed HTTPS cert: %v", err)
}
certPEM = []byte(buf.String())
buf.Reset()
if err := pem.Encode(&buf, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)}); err != nil {
return certPEM, keyPEM, fmt.Errorf("error writing self-signed HTTPS private key: %v", err)
}
keyPEM = buf.Bytes()
return certPEM, keyPEM, nil
} | [
"func",
"GenSelfTLS",
"(",
"hostname",
"string",
")",
"(",
"certPEM",
",",
"keyPEM",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"priv",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"2048",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"certPEM",
",",
"keyPEM",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to generate private key: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"if",
"hostname",
"==",
"\"\"",
"{",
"hostname",
"=",
"\"localhost\"",
"\n",
"}",
"\n",
"serialNumberLimit",
":=",
"new",
"(",
"big",
".",
"Int",
")",
".",
"Lsh",
"(",
"big",
".",
"NewInt",
"(",
"1",
")",
",",
"128",
")",
"\n",
"serialNumber",
",",
"err",
":=",
"rand",
".",
"Int",
"(",
"rand",
".",
"Reader",
",",
"serialNumberLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"failed to generate serial number: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"template",
":=",
"x509",
".",
"Certificate",
"{",
"SerialNumber",
":",
"serialNumber",
",",
"Subject",
":",
"pkix",
".",
"Name",
"{",
"CommonName",
":",
"hostname",
",",
"Organization",
":",
"[",
"]",
"string",
"{",
"hostname",
"}",
",",
"}",
",",
"NotBefore",
":",
"now",
".",
"Add",
"(",
"-",
"5",
"*",
"time",
".",
"Minute",
")",
".",
"UTC",
"(",
")",
",",
"NotAfter",
":",
"now",
".",
"AddDate",
"(",
"1",
",",
"0",
",",
"0",
")",
".",
"UTC",
"(",
")",
",",
"SubjectKeyId",
":",
"[",
"]",
"byte",
"{",
"1",
",",
"2",
",",
"3",
",",
"4",
"}",
",",
"KeyUsage",
":",
"x509",
".",
"KeyUsageKeyEncipherment",
"|",
"x509",
".",
"KeyUsageDigitalSignature",
"|",
"x509",
".",
"KeyUsageCertSign",
",",
"IsCA",
":",
"true",
",",
"BasicConstraintsValid",
":",
"true",
",",
"}",
"\n",
"derBytes",
",",
"err",
":=",
"x509",
".",
"CreateCertificate",
"(",
"rand",
".",
"Reader",
",",
"&",
"template",
",",
"&",
"template",
",",
"&",
"priv",
".",
"PublicKey",
",",
"priv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"certPEM",
",",
"keyPEM",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to create certificate: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"err",
":=",
"pem",
".",
"Encode",
"(",
"&",
"buf",
",",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"CERTIFICATE\"",
",",
"Bytes",
":",
"derBytes",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"certPEM",
",",
"keyPEM",
",",
"fmt",
".",
"Errorf",
"(",
"\"error writing self-signed HTTPS cert: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"certPEM",
"=",
"[",
"]",
"byte",
"(",
"buf",
".",
"String",
"(",
")",
")",
"\n",
"buf",
".",
"Reset",
"(",
")",
"\n",
"if",
"err",
":=",
"pem",
".",
"Encode",
"(",
"&",
"buf",
",",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"RSA PRIVATE KEY\"",
",",
"Bytes",
":",
"x509",
".",
"MarshalPKCS1PrivateKey",
"(",
"priv",
")",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"certPEM",
",",
"keyPEM",
",",
"fmt",
".",
"Errorf",
"(",
"\"error writing self-signed HTTPS private key: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"keyPEM",
"=",
"buf",
".",
"Bytes",
"(",
")",
"\n",
"return",
"certPEM",
",",
"keyPEM",
",",
"nil",
"\n",
"}"
] | // GenSelfTLS generates a self-signed certificate and key for hostname. | [
"GenSelfTLS",
"generates",
"a",
"self",
"-",
"signed",
"certificate",
"and",
"key",
"for",
"hostname",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/certs.go#L54-L100 | train |
perkeep/perkeep | internal/httputil/certs.go | CertFingerprint | func CertFingerprint(certPEM []byte) (string, error) {
p, _ := pem.Decode(certPEM)
if p == nil {
return "", errors.New("no valid PEM data found")
}
cert, err := x509.ParseCertificate(p.Bytes)
if err != nil {
return "", fmt.Errorf("failed to parse certificate: %v", err)
}
return hashutil.SHA256Prefix(cert.Raw), nil
} | go | func CertFingerprint(certPEM []byte) (string, error) {
p, _ := pem.Decode(certPEM)
if p == nil {
return "", errors.New("no valid PEM data found")
}
cert, err := x509.ParseCertificate(p.Bytes)
if err != nil {
return "", fmt.Errorf("failed to parse certificate: %v", err)
}
return hashutil.SHA256Prefix(cert.Raw), nil
} | [
"func",
"CertFingerprint",
"(",
"certPEM",
"[",
"]",
"byte",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"certPEM",
")",
"\n",
"if",
"p",
"==",
"nil",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"no valid PEM data found\"",
")",
"\n",
"}",
"\n",
"cert",
",",
"err",
":=",
"x509",
".",
"ParseCertificate",
"(",
"p",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to parse certificate: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"hashutil",
".",
"SHA256Prefix",
"(",
"cert",
".",
"Raw",
")",
",",
"nil",
"\n",
"}"
] | // CertFingerprint returns the SHA-256 prefix of the x509 certificate encoded in certPEM. | [
"CertFingerprint",
"returns",
"the",
"SHA",
"-",
"256",
"prefix",
"of",
"the",
"x509",
"certificate",
"encoded",
"in",
"certPEM",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/certs.go#L103-L113 | train |
perkeep/perkeep | internal/httputil/certs.go | GenSelfTLSFiles | func GenSelfTLSFiles(hostname, certPath, keyPath string) (fingerprint string, err error) {
cert, key, err := GenSelfTLS(hostname)
if err != nil {
return "", err
}
sig, err := CertFingerprint(cert)
if err != nil {
return "", fmt.Errorf("could not get SHA-256 fingerprint of certificate: %v", err)
}
if err := wkfs.WriteFile(certPath, cert, 0666); err != nil {
return "", fmt.Errorf("failed to write self-signed TLS cert: %v", err)
}
if err := wkfs.WriteFile(keyPath, key, 0600); err != nil {
return "", fmt.Errorf("failed to write self-signed TLS key: %v", err)
}
return sig, nil
} | go | func GenSelfTLSFiles(hostname, certPath, keyPath string) (fingerprint string, err error) {
cert, key, err := GenSelfTLS(hostname)
if err != nil {
return "", err
}
sig, err := CertFingerprint(cert)
if err != nil {
return "", fmt.Errorf("could not get SHA-256 fingerprint of certificate: %v", err)
}
if err := wkfs.WriteFile(certPath, cert, 0666); err != nil {
return "", fmt.Errorf("failed to write self-signed TLS cert: %v", err)
}
if err := wkfs.WriteFile(keyPath, key, 0600); err != nil {
return "", fmt.Errorf("failed to write self-signed TLS key: %v", err)
}
return sig, nil
} | [
"func",
"GenSelfTLSFiles",
"(",
"hostname",
",",
"certPath",
",",
"keyPath",
"string",
")",
"(",
"fingerprint",
"string",
",",
"err",
"error",
")",
"{",
"cert",
",",
"key",
",",
"err",
":=",
"GenSelfTLS",
"(",
"hostname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"sig",
",",
"err",
":=",
"CertFingerprint",
"(",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not get SHA-256 fingerprint of certificate: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"wkfs",
".",
"WriteFile",
"(",
"certPath",
",",
"cert",
",",
"0666",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to write self-signed TLS cert: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"wkfs",
".",
"WriteFile",
"(",
"keyPath",
",",
"key",
",",
"0600",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to write self-signed TLS key: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"sig",
",",
"nil",
"\n",
"}"
] | // GenSelfTLSFiles generates a self-signed certificate and key for hostname,
// and writes them to the given paths. If it succeeds it also returns
// the SHA256 prefix of the new cert. | [
"GenSelfTLSFiles",
"generates",
"a",
"self",
"-",
"signed",
"certificate",
"and",
"key",
"for",
"hostname",
"and",
"writes",
"them",
"to",
"the",
"given",
"paths",
".",
"If",
"it",
"succeeds",
"it",
"also",
"returns",
"the",
"SHA256",
"prefix",
"of",
"the",
"new",
"cert",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/certs.go#L118-L134 | train |
perkeep/perkeep | pkg/types/camtypes/search.go | Contains | func (b LocationBounds) Contains(loc Location) bool {
if b.SpansDateLine() {
return loc.Longitude >= b.West || loc.Longitude <= b.East
}
return loc.Longitude >= b.West && loc.Longitude <= b.East
} | go | func (b LocationBounds) Contains(loc Location) bool {
if b.SpansDateLine() {
return loc.Longitude >= b.West || loc.Longitude <= b.East
}
return loc.Longitude >= b.West && loc.Longitude <= b.East
} | [
"func",
"(",
"b",
"LocationBounds",
")",
"Contains",
"(",
"loc",
"Location",
")",
"bool",
"{",
"if",
"b",
".",
"SpansDateLine",
"(",
")",
"{",
"return",
"loc",
".",
"Longitude",
">=",
"b",
".",
"West",
"||",
"loc",
".",
"Longitude",
"<=",
"b",
".",
"East",
"\n",
"}",
"\n",
"return",
"loc",
".",
"Longitude",
">=",
"b",
".",
"West",
"&&",
"loc",
".",
"Longitude",
"<=",
"b",
".",
"East",
"\n",
"}"
] | // Contains reports whether loc is in the bounds b. | [
"Contains",
"reports",
"whether",
"loc",
"is",
"in",
"the",
"bounds",
"b",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/types/camtypes/search.go#L285-L290 | train |
perkeep/perkeep | pkg/types/camtypes/search.go | Expand | func (b LocationBounds) Expand(loc Location) LocationBounds {
if b == (LocationBounds{}) {
return LocationBounds{
North: loc.Latitude,
South: loc.Latitude,
West: loc.Longitude,
East: loc.Longitude,
}
}
nb := LocationBounds{
North: b.North,
South: b.South,
West: b.West,
East: b.East,
}
if loc.Latitude > nb.North {
nb.North = loc.Latitude
} else if loc.Latitude < nb.South {
nb.South = loc.Latitude
}
if nb.Contains(loc) {
return nb
}
center := nb.center()
dToCenter := center.Longitude - loc.Longitude
if math.Abs(dToCenter) <= 180 {
if dToCenter > 0 {
// expand Westwards
nb.West = loc.Longitude
} else {
// expand Eastwards
nb.East = loc.Longitude
}
return nb
}
if dToCenter > 0 {
// expand Eastwards
nb.East = loc.Longitude
} else {
// expand Westwards
nb.West = loc.Longitude
}
return nb
} | go | func (b LocationBounds) Expand(loc Location) LocationBounds {
if b == (LocationBounds{}) {
return LocationBounds{
North: loc.Latitude,
South: loc.Latitude,
West: loc.Longitude,
East: loc.Longitude,
}
}
nb := LocationBounds{
North: b.North,
South: b.South,
West: b.West,
East: b.East,
}
if loc.Latitude > nb.North {
nb.North = loc.Latitude
} else if loc.Latitude < nb.South {
nb.South = loc.Latitude
}
if nb.Contains(loc) {
return nb
}
center := nb.center()
dToCenter := center.Longitude - loc.Longitude
if math.Abs(dToCenter) <= 180 {
if dToCenter > 0 {
// expand Westwards
nb.West = loc.Longitude
} else {
// expand Eastwards
nb.East = loc.Longitude
}
return nb
}
if dToCenter > 0 {
// expand Eastwards
nb.East = loc.Longitude
} else {
// expand Westwards
nb.West = loc.Longitude
}
return nb
} | [
"func",
"(",
"b",
"LocationBounds",
")",
"Expand",
"(",
"loc",
"Location",
")",
"LocationBounds",
"{",
"if",
"b",
"==",
"(",
"LocationBounds",
"{",
"}",
")",
"{",
"return",
"LocationBounds",
"{",
"North",
":",
"loc",
".",
"Latitude",
",",
"South",
":",
"loc",
".",
"Latitude",
",",
"West",
":",
"loc",
".",
"Longitude",
",",
"East",
":",
"loc",
".",
"Longitude",
",",
"}",
"\n",
"}",
"\n",
"nb",
":=",
"LocationBounds",
"{",
"North",
":",
"b",
".",
"North",
",",
"South",
":",
"b",
".",
"South",
",",
"West",
":",
"b",
".",
"West",
",",
"East",
":",
"b",
".",
"East",
",",
"}",
"\n",
"if",
"loc",
".",
"Latitude",
">",
"nb",
".",
"North",
"{",
"nb",
".",
"North",
"=",
"loc",
".",
"Latitude",
"\n",
"}",
"else",
"if",
"loc",
".",
"Latitude",
"<",
"nb",
".",
"South",
"{",
"nb",
".",
"South",
"=",
"loc",
".",
"Latitude",
"\n",
"}",
"\n",
"if",
"nb",
".",
"Contains",
"(",
"loc",
")",
"{",
"return",
"nb",
"\n",
"}",
"\n",
"center",
":=",
"nb",
".",
"center",
"(",
")",
"\n",
"dToCenter",
":=",
"center",
".",
"Longitude",
"-",
"loc",
".",
"Longitude",
"\n",
"if",
"math",
".",
"Abs",
"(",
"dToCenter",
")",
"<=",
"180",
"{",
"if",
"dToCenter",
">",
"0",
"{",
"nb",
".",
"West",
"=",
"loc",
".",
"Longitude",
"\n",
"}",
"else",
"{",
"nb",
".",
"East",
"=",
"loc",
".",
"Longitude",
"\n",
"}",
"\n",
"return",
"nb",
"\n",
"}",
"\n",
"if",
"dToCenter",
">",
"0",
"{",
"nb",
".",
"East",
"=",
"loc",
".",
"Longitude",
"\n",
"}",
"else",
"{",
"nb",
".",
"West",
"=",
"loc",
".",
"Longitude",
"\n",
"}",
"\n",
"return",
"nb",
"\n",
"}"
] | // Expand returns a new LocationBounds nb. If either of loc coordinates is
// outside of b, nb is the dimensions of b expanded as little as possible in
// order to include loc. Otherwise, nb is just a copy of b. | [
"Expand",
"returns",
"a",
"new",
"LocationBounds",
"nb",
".",
"If",
"either",
"of",
"loc",
"coordinates",
"is",
"outside",
"of",
"b",
"nb",
"is",
"the",
"dimensions",
"of",
"b",
"expanded",
"as",
"little",
"as",
"possible",
"in",
"order",
"to",
"include",
"loc",
".",
"Otherwise",
"nb",
"is",
"just",
"a",
"copy",
"of",
"b",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/types/camtypes/search.go#L302-L345 | train |
perkeep/perkeep | internal/osutil/restart_windows.go | SelfPath | func SelfPath() (string, error) {
kernel32, err := syscall.LoadDLL("kernel32.dll")
if err != nil {
return "", err
}
sysproc, err := kernel32.FindProc("GetModuleFileNameW")
if err != nil {
return "", err
}
b := make([]uint16, syscall.MAX_PATH)
r, _, err := sysproc.Call(0, uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)))
n := uint32(r)
if n == 0 {
return "", err
}
return string(utf16.Decode(b[0:n])), nil
} | go | func SelfPath() (string, error) {
kernel32, err := syscall.LoadDLL("kernel32.dll")
if err != nil {
return "", err
}
sysproc, err := kernel32.FindProc("GetModuleFileNameW")
if err != nil {
return "", err
}
b := make([]uint16, syscall.MAX_PATH)
r, _, err := sysproc.Call(0, uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)))
n := uint32(r)
if n == 0 {
return "", err
}
return string(utf16.Decode(b[0:n])), nil
} | [
"func",
"SelfPath",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"kernel32",
",",
"err",
":=",
"syscall",
".",
"LoadDLL",
"(",
"\"kernel32.dll\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"sysproc",
",",
"err",
":=",
"kernel32",
".",
"FindProc",
"(",
"\"GetModuleFileNameW\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"b",
":=",
"make",
"(",
"[",
"]",
"uint16",
",",
"syscall",
".",
"MAX_PATH",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"sysproc",
".",
"Call",
"(",
"0",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"b",
"[",
"0",
"]",
")",
")",
",",
"uintptr",
"(",
"len",
"(",
"b",
")",
")",
")",
"\n",
"n",
":=",
"uint32",
"(",
"r",
")",
"\n",
"if",
"n",
"==",
"0",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"utf16",
".",
"Decode",
"(",
"b",
"[",
"0",
":",
"n",
"]",
")",
")",
",",
"nil",
"\n",
"}"
] | // SelfPath returns the path of the executable for the currently running
// process. | [
"SelfPath",
"returns",
"the",
"path",
"of",
"the",
"executable",
"for",
"the",
"currently",
"running",
"process",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/restart_windows.go#L30-L46 | train |
perkeep/perkeep | cmd/pk/googinit.go | prompt | func prompt(promptText string) string {
fmt.Fprint(cmdmain.Stdout, promptText)
sc := bufio.NewScanner(cmdmain.Stdin)
sc.Scan()
return strings.TrimSpace(sc.Text())
} | go | func prompt(promptText string) string {
fmt.Fprint(cmdmain.Stdout, promptText)
sc := bufio.NewScanner(cmdmain.Stdin)
sc.Scan()
return strings.TrimSpace(sc.Text())
} | [
"func",
"prompt",
"(",
"promptText",
"string",
")",
"string",
"{",
"fmt",
".",
"Fprint",
"(",
"cmdmain",
".",
"Stdout",
",",
"promptText",
")",
"\n",
"sc",
":=",
"bufio",
".",
"NewScanner",
"(",
"cmdmain",
".",
"Stdin",
")",
"\n",
"sc",
".",
"Scan",
"(",
")",
"\n",
"return",
"strings",
".",
"TrimSpace",
"(",
"sc",
".",
"Text",
"(",
")",
")",
"\n",
"}"
] | // Prompt the user for an input line. Return the given input. | [
"Prompt",
"the",
"user",
"for",
"an",
"input",
"line",
".",
"Return",
"the",
"given",
"input",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk/googinit.go#L116-L121 | train |
perkeep/perkeep | pkg/fs/xattr.go | load | func (x *xattr) load(p *search.DescribedPermanode) {
x.mu.Lock()
defer x.mu.Unlock()
*x.xattrs = map[string][]byte{}
for k, v := range p.Attr {
if strings.HasPrefix(k, xattrPrefix) {
name := k[len(xattrPrefix):]
val, err := base64.StdEncoding.DecodeString(v[0])
if err != nil {
Logger.Printf("Base64 decoding error on attribute %v: %v", name, err)
continue
}
(*x.xattrs)[name] = val
}
}
} | go | func (x *xattr) load(p *search.DescribedPermanode) {
x.mu.Lock()
defer x.mu.Unlock()
*x.xattrs = map[string][]byte{}
for k, v := range p.Attr {
if strings.HasPrefix(k, xattrPrefix) {
name := k[len(xattrPrefix):]
val, err := base64.StdEncoding.DecodeString(v[0])
if err != nil {
Logger.Printf("Base64 decoding error on attribute %v: %v", name, err)
continue
}
(*x.xattrs)[name] = val
}
}
} | [
"func",
"(",
"x",
"*",
"xattr",
")",
"load",
"(",
"p",
"*",
"search",
".",
"DescribedPermanode",
")",
"{",
"x",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"x",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"*",
"x",
".",
"xattrs",
"=",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"p",
".",
"Attr",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"k",
",",
"xattrPrefix",
")",
"{",
"name",
":=",
"k",
"[",
"len",
"(",
"xattrPrefix",
")",
":",
"]",
"\n",
"val",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"v",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"Base64 decoding error on attribute %v: %v\"",
",",
"name",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"(",
"*",
"x",
".",
"xattrs",
")",
"[",
"name",
"]",
"=",
"val",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // load is invoked after the creation of a fuse.Node that may contain extended
// attributes. This creates the node's xattr map as well as fills it with any
// extended attributes found in the permanode's claims. | [
"load",
"is",
"invoked",
"after",
"the",
"creation",
"of",
"a",
"fuse",
".",
"Node",
"that",
"may",
"contain",
"extended",
"attributes",
".",
"This",
"creates",
"the",
"node",
"s",
"xattr",
"map",
"as",
"well",
"as",
"fills",
"it",
"with",
"any",
"extended",
"attributes",
"found",
"in",
"the",
"permanode",
"s",
"claims",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/fs/xattr.go#L58-L74 | train |
perkeep/perkeep | pkg/blobserver/stat.go | StatBlob | func StatBlob(ctx context.Context, bs BlobStatter, br blob.Ref) (blob.SizedRef, error) {
var ret blob.SizedRef
err := bs.StatBlobs(ctx, []blob.Ref{br}, func(sb blob.SizedRef) error {
ret = sb
return nil
})
if err == nil && !ret.Ref.Valid() {
err = os.ErrNotExist
}
return ret, err
} | go | func StatBlob(ctx context.Context, bs BlobStatter, br blob.Ref) (blob.SizedRef, error) {
var ret blob.SizedRef
err := bs.StatBlobs(ctx, []blob.Ref{br}, func(sb blob.SizedRef) error {
ret = sb
return nil
})
if err == nil && !ret.Ref.Valid() {
err = os.ErrNotExist
}
return ret, err
} | [
"func",
"StatBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"BlobStatter",
",",
"br",
"blob",
".",
"Ref",
")",
"(",
"blob",
".",
"SizedRef",
",",
"error",
")",
"{",
"var",
"ret",
"blob",
".",
"SizedRef",
"\n",
"err",
":=",
"bs",
".",
"StatBlobs",
"(",
"ctx",
",",
"[",
"]",
"blob",
".",
"Ref",
"{",
"br",
"}",
",",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"ret",
"=",
"sb",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"!",
"ret",
".",
"Ref",
".",
"Valid",
"(",
")",
"{",
"err",
"=",
"os",
".",
"ErrNotExist",
"\n",
"}",
"\n",
"return",
"ret",
",",
"err",
"\n",
"}"
] | // StatBlob calls bs.StatBlobs to stat a single blob.
// If the blob is not found, the error is os.ErrNotExist. | [
"StatBlob",
"calls",
"bs",
".",
"StatBlobs",
"to",
"stat",
"a",
"single",
"blob",
".",
"If",
"the",
"blob",
"is",
"not",
"found",
"the",
"error",
"is",
"os",
".",
"ErrNotExist",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/stat.go#L31-L41 | train |
perkeep/perkeep | pkg/blobserver/stat.go | StatBlobs | func StatBlobs(ctx context.Context, bs BlobStatter, blobs []blob.Ref) (map[blob.Ref]blob.SizedRef, error) {
var m map[blob.Ref]blob.SizedRef
err := bs.StatBlobs(ctx, blobs, func(sb blob.SizedRef) error {
if m == nil {
m = make(map[blob.Ref]blob.SizedRef)
}
m[sb.Ref] = sb
return nil
})
return m, err
} | go | func StatBlobs(ctx context.Context, bs BlobStatter, blobs []blob.Ref) (map[blob.Ref]blob.SizedRef, error) {
var m map[blob.Ref]blob.SizedRef
err := bs.StatBlobs(ctx, blobs, func(sb blob.SizedRef) error {
if m == nil {
m = make(map[blob.Ref]blob.SizedRef)
}
m[sb.Ref] = sb
return nil
})
return m, err
} | [
"func",
"StatBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"BlobStatter",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"blob",
".",
"SizedRef",
",",
"error",
")",
"{",
"var",
"m",
"map",
"[",
"blob",
".",
"Ref",
"]",
"blob",
".",
"SizedRef",
"\n",
"err",
":=",
"bs",
".",
"StatBlobs",
"(",
"ctx",
",",
"blobs",
",",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"if",
"m",
"==",
"nil",
"{",
"m",
"=",
"make",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"blob",
".",
"SizedRef",
")",
"\n",
"}",
"\n",
"m",
"[",
"sb",
".",
"Ref",
"]",
"=",
"sb",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] | // StatBlobs stats multiple blobs and returns a map
// of the found refs to their sizes. | [
"StatBlobs",
"stats",
"multiple",
"blobs",
"and",
"returns",
"a",
"map",
"of",
"the",
"found",
"refs",
"to",
"their",
"sizes",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/stat.go#L45-L55 | train |
perkeep/perkeep | website/pk-web/contributors.go | add | func (a *author) add(src *author) {
if src == nil {
return
}
a.Emails = append(a.Emails, src.Emails...)
a.Names = append(a.Names, src.Names...)
a.Commits += src.Commits
if src.Role != "" {
a.Role = src.Role
}
if src.URL != "" {
a.URL = src.URL
}
} | go | func (a *author) add(src *author) {
if src == nil {
return
}
a.Emails = append(a.Emails, src.Emails...)
a.Names = append(a.Names, src.Names...)
a.Commits += src.Commits
if src.Role != "" {
a.Role = src.Role
}
if src.URL != "" {
a.URL = src.URL
}
} | [
"func",
"(",
"a",
"*",
"author",
")",
"add",
"(",
"src",
"*",
"author",
")",
"{",
"if",
"src",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"a",
".",
"Emails",
"=",
"append",
"(",
"a",
".",
"Emails",
",",
"src",
".",
"Emails",
"...",
")",
"\n",
"a",
".",
"Names",
"=",
"append",
"(",
"a",
".",
"Names",
",",
"src",
".",
"Names",
"...",
")",
"\n",
"a",
".",
"Commits",
"+=",
"src",
".",
"Commits",
"\n",
"if",
"src",
".",
"Role",
"!=",
"\"\"",
"{",
"a",
".",
"Role",
"=",
"src",
".",
"Role",
"\n",
"}",
"\n",
"if",
"src",
".",
"URL",
"!=",
"\"\"",
"{",
"a",
".",
"URL",
"=",
"src",
".",
"URL",
"\n",
"}",
"\n",
"}"
] | // add merges src's fields into a's. | [
"add",
"merges",
"src",
"s",
"fields",
"into",
"a",
"s",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/contributors.go#L45-L58 | train |
perkeep/perkeep | website/pk-web/contributors.go | contribHandler | func contribHandler() http.HandlerFunc {
c, err := genContribPage()
if err != nil {
log.Printf("Couldn't generate contributors page: %v", err)
log.Printf("Using static contributors page")
return mainHandler
}
title := ""
if m := h1TitlePattern.FindSubmatch(c); len(m) > 1 {
title = string(m[1])
}
return func(w http.ResponseWriter, r *http.Request) {
servePage(w, r, pageParams{
title: title,
content: c,
})
}
} | go | func contribHandler() http.HandlerFunc {
c, err := genContribPage()
if err != nil {
log.Printf("Couldn't generate contributors page: %v", err)
log.Printf("Using static contributors page")
return mainHandler
}
title := ""
if m := h1TitlePattern.FindSubmatch(c); len(m) > 1 {
title = string(m[1])
}
return func(w http.ResponseWriter, r *http.Request) {
servePage(w, r, pageParams{
title: title,
content: c,
})
}
} | [
"func",
"contribHandler",
"(",
")",
"http",
".",
"HandlerFunc",
"{",
"c",
",",
"err",
":=",
"genContribPage",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"Couldn't generate contributors page: %v\"",
",",
"err",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"Using static contributors page\"",
")",
"\n",
"return",
"mainHandler",
"\n",
"}",
"\n",
"title",
":=",
"\"\"",
"\n",
"if",
"m",
":=",
"h1TitlePattern",
".",
"FindSubmatch",
"(",
"c",
")",
";",
"len",
"(",
"m",
")",
">",
"1",
"{",
"title",
"=",
"string",
"(",
"m",
"[",
"1",
"]",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"servePage",
"(",
"w",
",",
"r",
",",
"pageParams",
"{",
"title",
":",
"title",
",",
"content",
":",
"c",
",",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // contribHandler returns a handler that serves the generated contributors page,
// or the static file handler if it couldn't run git for any reason. | [
"contribHandler",
"returns",
"a",
"handler",
"that",
"serves",
"the",
"generated",
"contributors",
"page",
"or",
"the",
"static",
"file",
"handler",
"if",
"it",
"couldn",
"t",
"run",
"git",
"for",
"any",
"reason",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/contributors.go#L184-L202 | train |
perkeep/perkeep | pkg/schema/sign.go | SignJSON | func (s *Signer) SignJSON(ctx context.Context, json string, t time.Time) (string, error) {
sr := s.baseSigReq
sr.UnsignedJSON = json
sr.SignatureTime = t
return sr.Sign(ctx)
} | go | func (s *Signer) SignJSON(ctx context.Context, json string, t time.Time) (string, error) {
sr := s.baseSigReq
sr.UnsignedJSON = json
sr.SignatureTime = t
return sr.Sign(ctx)
} | [
"func",
"(",
"s",
"*",
"Signer",
")",
"SignJSON",
"(",
"ctx",
"context",
".",
"Context",
",",
"json",
"string",
",",
"t",
"time",
".",
"Time",
")",
"(",
"string",
",",
"error",
")",
"{",
"sr",
":=",
"s",
".",
"baseSigReq",
"\n",
"sr",
".",
"UnsignedJSON",
"=",
"json",
"\n",
"sr",
".",
"SignatureTime",
"=",
"t",
"\n",
"return",
"sr",
".",
"Sign",
"(",
"ctx",
")",
"\n",
"}"
] | // SignJSON signs the provided json at the optional time t.
// If t is the zero Time, the current time is used. | [
"SignJSON",
"signs",
"the",
"provided",
"json",
"at",
"the",
"optional",
"time",
"t",
".",
"If",
"t",
"is",
"the",
"zero",
"Time",
"the",
"current",
"time",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/sign.go#L120-L125 | train |
perkeep/perkeep | pkg/server/ui.go | InitHandler | func (ui *UIHandler) InitHandler(hl blobserver.FindHandlerByTyper) error {
// InitHandler is called after all handlers have been setup, so the bootstrap
// of the camliRoot node for publishers in dev-mode is already done.
searchPrefix, _, err := hl.FindHandlerByType("search")
if err != nil {
return errors.New("No search handler configured, which is necessary for the ui handler")
}
var sh *search.Handler
htype, hi := hl.AllHandlers()
if h, ok := hi[searchPrefix]; !ok {
return errors.New("failed to find the \"search\" handler")
} else {
sh = h.(*search.Handler)
ui.search = sh
}
camliRootQuery := func(camliRoot string) (*search.SearchResult, error) {
return sh.Query(context.TODO(), &search.SearchQuery{
Limit: 1,
Constraint: &search.Constraint{
Permanode: &search.PermanodeConstraint{
Attr: "camliRoot",
Value: camliRoot,
},
},
})
}
for prefix, typ := range htype {
if typ != "app" {
continue
}
ah, ok := hi[prefix].(*app.Handler)
if !ok {
panic(fmt.Sprintf("UI: handler for %v has type \"app\" but is not app.Handler", prefix))
}
// TODO(mpl): this check is weak, as the user could very well
// use another binary name for the publisher app. We should
// introduce/use another identifier.
if ah.ProgramName() != "publisher" {
continue
}
appConfig := ah.AppConfig()
if appConfig == nil {
log.Printf("UI: app handler for %v has no appConfig", prefix)
continue
}
camliRoot, ok := appConfig["camliRoot"].(string)
if !ok {
log.Printf("UI: camliRoot in appConfig is %T, want string", appConfig["camliRoot"])
continue
}
result, err := camliRootQuery(camliRoot)
if err != nil {
log.Printf("UI: could not find permanode for camliRoot %v: %v", camliRoot, err)
continue
}
if len(result.Blobs) == 0 || !result.Blobs[0].Blob.Valid() {
log.Printf("UI: no valid permanode for camliRoot %v", camliRoot)
continue
}
if ui.publishRoots == nil {
ui.publishRoots = make(map[string]*publishRoot)
}
ui.publishRoots[prefix] = &publishRoot{
Name: camliRoot,
Prefix: prefix,
Permanode: result.Blobs[0].Blob,
}
}
return nil
} | go | func (ui *UIHandler) InitHandler(hl blobserver.FindHandlerByTyper) error {
// InitHandler is called after all handlers have been setup, so the bootstrap
// of the camliRoot node for publishers in dev-mode is already done.
searchPrefix, _, err := hl.FindHandlerByType("search")
if err != nil {
return errors.New("No search handler configured, which is necessary for the ui handler")
}
var sh *search.Handler
htype, hi := hl.AllHandlers()
if h, ok := hi[searchPrefix]; !ok {
return errors.New("failed to find the \"search\" handler")
} else {
sh = h.(*search.Handler)
ui.search = sh
}
camliRootQuery := func(camliRoot string) (*search.SearchResult, error) {
return sh.Query(context.TODO(), &search.SearchQuery{
Limit: 1,
Constraint: &search.Constraint{
Permanode: &search.PermanodeConstraint{
Attr: "camliRoot",
Value: camliRoot,
},
},
})
}
for prefix, typ := range htype {
if typ != "app" {
continue
}
ah, ok := hi[prefix].(*app.Handler)
if !ok {
panic(fmt.Sprintf("UI: handler for %v has type \"app\" but is not app.Handler", prefix))
}
// TODO(mpl): this check is weak, as the user could very well
// use another binary name for the publisher app. We should
// introduce/use another identifier.
if ah.ProgramName() != "publisher" {
continue
}
appConfig := ah.AppConfig()
if appConfig == nil {
log.Printf("UI: app handler for %v has no appConfig", prefix)
continue
}
camliRoot, ok := appConfig["camliRoot"].(string)
if !ok {
log.Printf("UI: camliRoot in appConfig is %T, want string", appConfig["camliRoot"])
continue
}
result, err := camliRootQuery(camliRoot)
if err != nil {
log.Printf("UI: could not find permanode for camliRoot %v: %v", camliRoot, err)
continue
}
if len(result.Blobs) == 0 || !result.Blobs[0].Blob.Valid() {
log.Printf("UI: no valid permanode for camliRoot %v", camliRoot)
continue
}
if ui.publishRoots == nil {
ui.publishRoots = make(map[string]*publishRoot)
}
ui.publishRoots[prefix] = &publishRoot{
Name: camliRoot,
Prefix: prefix,
Permanode: result.Blobs[0].Blob,
}
}
return nil
} | [
"func",
"(",
"ui",
"*",
"UIHandler",
")",
"InitHandler",
"(",
"hl",
"blobserver",
".",
"FindHandlerByTyper",
")",
"error",
"{",
"searchPrefix",
",",
"_",
",",
"err",
":=",
"hl",
".",
"FindHandlerByType",
"(",
"\"search\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"No search handler configured, which is necessary for the ui handler\"",
")",
"\n",
"}",
"\n",
"var",
"sh",
"*",
"search",
".",
"Handler",
"\n",
"htype",
",",
"hi",
":=",
"hl",
".",
"AllHandlers",
"(",
")",
"\n",
"if",
"h",
",",
"ok",
":=",
"hi",
"[",
"searchPrefix",
"]",
";",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"failed to find the \\\"search\\\" handler\"",
")",
"\n",
"}",
"else",
"\\\"",
"\n",
"\\\"",
"\n",
"{",
"sh",
"=",
"h",
".",
"(",
"*",
"search",
".",
"Handler",
")",
"\n",
"ui",
".",
"search",
"=",
"sh",
"\n",
"}",
"\n",
"camliRootQuery",
":=",
"func",
"(",
"camliRoot",
"string",
")",
"(",
"*",
"search",
".",
"SearchResult",
",",
"error",
")",
"{",
"return",
"sh",
".",
"Query",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"&",
"search",
".",
"SearchQuery",
"{",
"Limit",
":",
"1",
",",
"Constraint",
":",
"&",
"search",
".",
"Constraint",
"{",
"Permanode",
":",
"&",
"search",
".",
"PermanodeConstraint",
"{",
"Attr",
":",
"\"camliRoot\"",
",",
"Value",
":",
"camliRoot",
",",
"}",
",",
"}",
",",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // InitHandler goes through all the other configured handlers to discover
// the publisher ones, and uses them to populate ui.publishRoots. | [
"InitHandler",
"goes",
"through",
"all",
"the",
"other",
"configured",
"handlers",
"to",
"discover",
"the",
"publisher",
"ones",
"and",
"uses",
"them",
"to",
"populate",
"ui",
".",
"publishRoots",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/ui.go#L253-L322 | train |
perkeep/perkeep | pkg/server/ui.go | ServeStaticFile | func ServeStaticFile(rw http.ResponseWriter, req *http.Request, root http.FileSystem, file string) {
f, err := root.Open("/" + file)
if err != nil {
http.NotFound(rw, req)
log.Printf("Failed to open file %q from embedded resources: %v", file, err)
return
}
defer f.Close()
var modTime time.Time
if fi, err := f.Stat(); err == nil {
modTime = fi.ModTime()
}
// TODO(wathiede): should pkg/magic be leveraged here somehow? It has a
// slightly different purpose.
if strings.HasSuffix(file, ".svg") {
rw.Header().Set("Content-Type", "image/svg+xml")
}
http.ServeContent(rw, req, file, modTime, f)
} | go | func ServeStaticFile(rw http.ResponseWriter, req *http.Request, root http.FileSystem, file string) {
f, err := root.Open("/" + file)
if err != nil {
http.NotFound(rw, req)
log.Printf("Failed to open file %q from embedded resources: %v", file, err)
return
}
defer f.Close()
var modTime time.Time
if fi, err := f.Stat(); err == nil {
modTime = fi.ModTime()
}
// TODO(wathiede): should pkg/magic be leveraged here somehow? It has a
// slightly different purpose.
if strings.HasSuffix(file, ".svg") {
rw.Header().Set("Content-Type", "image/svg+xml")
}
http.ServeContent(rw, req, file, modTime, f)
} | [
"func",
"ServeStaticFile",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"root",
"http",
".",
"FileSystem",
",",
"file",
"string",
")",
"{",
"f",
",",
"err",
":=",
"root",
".",
"Open",
"(",
"\"/\"",
"+",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"NotFound",
"(",
"rw",
",",
"req",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"Failed to open file %q from embedded resources: %v\"",
",",
"file",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"var",
"modTime",
"time",
".",
"Time",
"\n",
"if",
"fi",
",",
"err",
":=",
"f",
".",
"Stat",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"modTime",
"=",
"fi",
".",
"ModTime",
"(",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"file",
",",
"\".svg\"",
")",
"{",
"rw",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"image/svg+xml\"",
")",
"\n",
"}",
"\n",
"http",
".",
"ServeContent",
"(",
"rw",
",",
"req",
",",
"file",
",",
"modTime",
",",
"f",
")",
"\n",
"}"
] | // ServeStaticFile serves file from the root virtual filesystem. | [
"ServeStaticFile",
"serves",
"file",
"from",
"the",
"root",
"virtual",
"filesystem",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/ui.go#L488-L506 | train |
perkeep/perkeep | pkg/server/ui.go | serveDepsJS | func serveDepsJS(rw http.ResponseWriter, req *http.Request, dir string) {
var root http.FileSystem
if dir == "" {
root = uistatic.Files
} else {
root = http.Dir(dir)
}
b, err := closure.GenDeps(root)
if err != nil {
log.Print(err)
http.Error(rw, "Server error", 500)
return
}
rw.Header().Set("Content-Type", "text/javascript; charset=utf-8")
rw.Write([]byte("// auto-generated from perkeepd\n"))
rw.Write(b)
} | go | func serveDepsJS(rw http.ResponseWriter, req *http.Request, dir string) {
var root http.FileSystem
if dir == "" {
root = uistatic.Files
} else {
root = http.Dir(dir)
}
b, err := closure.GenDeps(root)
if err != nil {
log.Print(err)
http.Error(rw, "Server error", 500)
return
}
rw.Header().Set("Content-Type", "text/javascript; charset=utf-8")
rw.Write([]byte("// auto-generated from perkeepd\n"))
rw.Write(b)
} | [
"func",
"serveDepsJS",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"dir",
"string",
")",
"{",
"var",
"root",
"http",
".",
"FileSystem",
"\n",
"if",
"dir",
"==",
"\"\"",
"{",
"root",
"=",
"uistatic",
".",
"Files",
"\n",
"}",
"else",
"{",
"root",
"=",
"http",
".",
"Dir",
"(",
"dir",
")",
"\n",
"}",
"\n",
"b",
",",
"err",
":=",
"closure",
".",
"GenDeps",
"(",
"root",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"http",
".",
"Error",
"(",
"rw",
",",
"\"Server error\"",
",",
"500",
")",
"\n",
"return",
"\n",
"}",
"\n",
"rw",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"text/javascript; charset=utf-8\"",
")",
"\n",
"rw",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"// auto-generated from perkeepd\\n\"",
")",
")",
"\n",
"\\n",
"\n",
"}"
] | // serveDepsJS serves an auto-generated Closure deps.js file. | [
"serveDepsJS",
"serves",
"an",
"auto",
"-",
"generated",
"Closure",
"deps",
".",
"js",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/ui.go#L672-L689 | train |
perkeep/perkeep | pkg/sorted/kvfile/kvfile.go | NewStorage | func NewStorage(file string) (sorted.KeyValue, error) {
return newKeyValueFromJSONConfig(jsonconfig.Obj{"file": file})
} | go | func NewStorage(file string) (sorted.KeyValue, error) {
return newKeyValueFromJSONConfig(jsonconfig.Obj{"file": file})
} | [
"func",
"NewStorage",
"(",
"file",
"string",
")",
"(",
"sorted",
".",
"KeyValue",
",",
"error",
")",
"{",
"return",
"newKeyValueFromJSONConfig",
"(",
"jsonconfig",
".",
"Obj",
"{",
"\"file\"",
":",
"file",
"}",
")",
"\n",
"}"
] | // NewStorage is a convenience that calls newKeyValueFromJSONConfig
// with file as the kv storage file. | [
"NewStorage",
"is",
"a",
"convenience",
"that",
"calls",
"newKeyValueFromJSONConfig",
"with",
"file",
"as",
"the",
"kv",
"storage",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/kvfile/kvfile.go#L46-L48 | train |
perkeep/perkeep | pkg/client/upload.go | NewUploadHandleFromString | func NewUploadHandleFromString(data string) *UploadHandle {
bref := blob.RefFromString(data)
r := strings.NewReader(data)
return &UploadHandle{BlobRef: bref, Size: uint32(len(data)), Contents: r}
} | go | func NewUploadHandleFromString(data string) *UploadHandle {
bref := blob.RefFromString(data)
r := strings.NewReader(data)
return &UploadHandle{BlobRef: bref, Size: uint32(len(data)), Contents: r}
} | [
"func",
"NewUploadHandleFromString",
"(",
"data",
"string",
")",
"*",
"UploadHandle",
"{",
"bref",
":=",
"blob",
".",
"RefFromString",
"(",
"data",
")",
"\n",
"r",
":=",
"strings",
".",
"NewReader",
"(",
"data",
")",
"\n",
"return",
"&",
"UploadHandle",
"{",
"BlobRef",
":",
"bref",
",",
"Size",
":",
"uint32",
"(",
"len",
"(",
"data",
")",
")",
",",
"Contents",
":",
"r",
"}",
"\n",
"}"
] | // NewUploadHandleFromString returns an upload handle | [
"NewUploadHandleFromString",
"returns",
"an",
"upload",
"handle"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/upload.go#L132-L136 | train |
perkeep/perkeep | pkg/client/upload.go | doStat | func (c *Client) doStat(ctx context.Context, blobs []blob.Ref, wait time.Duration, gated bool, fn func(blob.SizedRef) error) error {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camliversion=1")
if wait > 0 {
secs := int(wait.Seconds())
if secs == 0 {
secs = 1
}
fmt.Fprintf(&buf, "&maxwaitsec=%d", secs)
}
for i, blob := range blobs {
fmt.Fprintf(&buf, "&blob%d=%s", i+1, blob)
}
pfx, err := c.prefix()
if err != nil {
return err
}
req := c.newRequest(ctx, "POST", fmt.Sprintf("%s/camli/stat", pfx), &buf)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
var resp *http.Response
if gated {
resp, err = c.doReqGated(req)
} else {
resp, err = c.httpClient.Do(req)
}
if err != nil {
return fmt.Errorf("stat HTTP error: %v", err)
}
if resp.Body != nil {
defer resp.Body.Close()
}
if resp.StatusCode != 200 {
return fmt.Errorf("stat response had http status %d", resp.StatusCode)
}
stat, err := parseStatResponse(resp)
if err != nil {
return err
}
for _, sb := range stat.HaveMap {
if err := fn(sb); err != nil {
return err
}
}
return nil
} | go | func (c *Client) doStat(ctx context.Context, blobs []blob.Ref, wait time.Duration, gated bool, fn func(blob.SizedRef) error) error {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camliversion=1")
if wait > 0 {
secs := int(wait.Seconds())
if secs == 0 {
secs = 1
}
fmt.Fprintf(&buf, "&maxwaitsec=%d", secs)
}
for i, blob := range blobs {
fmt.Fprintf(&buf, "&blob%d=%s", i+1, blob)
}
pfx, err := c.prefix()
if err != nil {
return err
}
req := c.newRequest(ctx, "POST", fmt.Sprintf("%s/camli/stat", pfx), &buf)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
var resp *http.Response
if gated {
resp, err = c.doReqGated(req)
} else {
resp, err = c.httpClient.Do(req)
}
if err != nil {
return fmt.Errorf("stat HTTP error: %v", err)
}
if resp.Body != nil {
defer resp.Body.Close()
}
if resp.StatusCode != 200 {
return fmt.Errorf("stat response had http status %d", resp.StatusCode)
}
stat, err := parseStatResponse(resp)
if err != nil {
return err
}
for _, sb := range stat.HaveMap {
if err := fn(sb); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"doStat",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
",",
"wait",
"time",
".",
"Duration",
",",
"gated",
"bool",
",",
"fn",
"func",
"(",
"blob",
".",
"SizedRef",
")",
"error",
")",
"error",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"camliversion=1\"",
")",
"\n",
"if",
"wait",
">",
"0",
"{",
"secs",
":=",
"int",
"(",
"wait",
".",
"Seconds",
"(",
")",
")",
"\n",
"if",
"secs",
"==",
"0",
"{",
"secs",
"=",
"1",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"&maxwaitsec=%d\"",
",",
"secs",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"blob",
":=",
"range",
"blobs",
"{",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"&blob%d=%s\"",
",",
"i",
"+",
"1",
",",
"blob",
")",
"\n",
"}",
"\n",
"pfx",
",",
"err",
":=",
"c",
".",
"prefix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"req",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"POST\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%s/camli/stat\"",
",",
"pfx",
")",
",",
"&",
"buf",
")",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"application/x-www-form-urlencoded\"",
")",
"\n",
"var",
"resp",
"*",
"http",
".",
"Response",
"\n",
"if",
"gated",
"{",
"resp",
",",
"err",
"=",
"c",
".",
"doReqGated",
"(",
"req",
")",
"\n",
"}",
"else",
"{",
"resp",
",",
"err",
"=",
"c",
".",
"httpClient",
".",
"Do",
"(",
"req",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"stat HTTP error: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"resp",
".",
"Body",
"!=",
"nil",
"{",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"200",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"stat response had http status %d\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"stat",
",",
"err",
":=",
"parseStatResponse",
"(",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"sb",
":=",
"range",
"stat",
".",
"HaveMap",
"{",
"if",
"err",
":=",
"fn",
"(",
"sb",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // doStat does an HTTP request for the stat. the number of blobs is used verbatim. No extra splitting
// or batching is done at this layer.
// The semantics are the same as blobserver.BlobStatter.
// gate controls whether it uses httpGate to pause on requests. | [
"doStat",
"does",
"an",
"HTTP",
"request",
"for",
"the",
"stat",
".",
"the",
"number",
"of",
"blobs",
"is",
"used",
"verbatim",
".",
"No",
"extra",
"splitting",
"or",
"batching",
"is",
"done",
"at",
"this",
"layer",
".",
"The",
"semantics",
"are",
"the",
"same",
"as",
"blobserver",
".",
"BlobStatter",
".",
"gate",
"controls",
"whether",
"it",
"uses",
"httpGate",
"to",
"pause",
"on",
"requests",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/upload.go#L194-L242 | train |
perkeep/perkeep | pkg/client/upload.go | readerAndSize | func (h *UploadHandle) readerAndSize() (io.Reader, int64, error) {
if h.Size > 0 {
return h.Contents, int64(h.Size), nil
}
var b bytes.Buffer
n, err := io.Copy(&b, h.Contents)
if err != nil {
return nil, 0, err
}
return &b, n, nil
} | go | func (h *UploadHandle) readerAndSize() (io.Reader, int64, error) {
if h.Size > 0 {
return h.Contents, int64(h.Size), nil
}
var b bytes.Buffer
n, err := io.Copy(&b, h.Contents)
if err != nil {
return nil, 0, err
}
return &b, n, nil
} | [
"func",
"(",
"h",
"*",
"UploadHandle",
")",
"readerAndSize",
"(",
")",
"(",
"io",
".",
"Reader",
",",
"int64",
",",
"error",
")",
"{",
"if",
"h",
".",
"Size",
">",
"0",
"{",
"return",
"h",
".",
"Contents",
",",
"int64",
"(",
"h",
".",
"Size",
")",
",",
"nil",
"\n",
"}",
"\n",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"n",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"&",
"b",
",",
"h",
".",
"Contents",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"b",
",",
"n",
",",
"nil",
"\n",
"}"
] | // Figure out the size of the contents.
// If the size was provided, trust it. | [
"Figure",
"out",
"the",
"size",
"of",
"the",
"contents",
".",
"If",
"the",
"size",
"was",
"provided",
"trust",
"it",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/upload.go#L246-L256 | train |
perkeep/perkeep | pkg/search/expr.go | readInternal | func (p *parser) readInternal() *token {
for t := range p.tokens {
return &t
}
return &token{tokenEOF, "", -1}
} | go | func (p *parser) readInternal() *token {
for t := range p.tokens {
return &t
}
return &token{tokenEOF, "", -1}
} | [
"func",
"(",
"p",
"*",
"parser",
")",
"readInternal",
"(",
")",
"*",
"token",
"{",
"for",
"t",
":=",
"range",
"p",
".",
"tokens",
"{",
"return",
"&",
"t",
"\n",
"}",
"\n",
"return",
"&",
"token",
"{",
"tokenEOF",
",",
"\"\"",
",",
"-",
"1",
"}",
"\n",
"}"
] | // ReadInternal should not be called directly, use 'next' or 'peek' | [
"ReadInternal",
"should",
"not",
"be",
"called",
"directly",
"use",
"next",
"or",
"peek"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/expr.go#L109-L114 | train |
perkeep/perkeep | pkg/search/expr.go | atomWords | func (p *parser) atomWords() (a atom, start int, err error) {
i := p.peek()
start = i.start
a = atom{}
switch i.typ {
case tokenLiteral:
err = newParseExpError(noLiteralSupport, *i)
return
case tokenQuotedLiteral:
err = newParseExpError(noQuotedLiteralSupport, *i)
return
case tokenColon:
err = newParseExpError(predicateError, *i)
return
case tokenPredicate:
i := p.next()
a.predicate = i.val
}
for {
switch p.peek().typ {
case tokenColon:
p.next()
continue
case tokenArg:
i := p.next()
a.args = append(a.args, i.val)
continue
case tokenQuotedArg:
i := p.next()
var uq string
uq, err = strconv.Unquote(i.val)
if err != nil {
return
}
a.args = append(a.args, uq)
continue
}
return
}
} | go | func (p *parser) atomWords() (a atom, start int, err error) {
i := p.peek()
start = i.start
a = atom{}
switch i.typ {
case tokenLiteral:
err = newParseExpError(noLiteralSupport, *i)
return
case tokenQuotedLiteral:
err = newParseExpError(noQuotedLiteralSupport, *i)
return
case tokenColon:
err = newParseExpError(predicateError, *i)
return
case tokenPredicate:
i := p.next()
a.predicate = i.val
}
for {
switch p.peek().typ {
case tokenColon:
p.next()
continue
case tokenArg:
i := p.next()
a.args = append(a.args, i.val)
continue
case tokenQuotedArg:
i := p.next()
var uq string
uq, err = strconv.Unquote(i.val)
if err != nil {
return
}
a.args = append(a.args, uq)
continue
}
return
}
} | [
"func",
"(",
"p",
"*",
"parser",
")",
"atomWords",
"(",
")",
"(",
"a",
"atom",
",",
"start",
"int",
",",
"err",
"error",
")",
"{",
"i",
":=",
"p",
".",
"peek",
"(",
")",
"\n",
"start",
"=",
"i",
".",
"start",
"\n",
"a",
"=",
"atom",
"{",
"}",
"\n",
"switch",
"i",
".",
"typ",
"{",
"case",
"tokenLiteral",
":",
"err",
"=",
"newParseExpError",
"(",
"noLiteralSupport",
",",
"*",
"i",
")",
"\n",
"return",
"\n",
"case",
"tokenQuotedLiteral",
":",
"err",
"=",
"newParseExpError",
"(",
"noQuotedLiteralSupport",
",",
"*",
"i",
")",
"\n",
"return",
"\n",
"case",
"tokenColon",
":",
"err",
"=",
"newParseExpError",
"(",
"predicateError",
",",
"*",
"i",
")",
"\n",
"return",
"\n",
"case",
"tokenPredicate",
":",
"i",
":=",
"p",
".",
"next",
"(",
")",
"\n",
"a",
".",
"predicate",
"=",
"i",
".",
"val",
"\n",
"}",
"\n",
"for",
"{",
"switch",
"p",
".",
"peek",
"(",
")",
".",
"typ",
"{",
"case",
"tokenColon",
":",
"p",
".",
"next",
"(",
")",
"\n",
"continue",
"\n",
"case",
"tokenArg",
":",
"i",
":=",
"p",
".",
"next",
"(",
")",
"\n",
"a",
".",
"args",
"=",
"append",
"(",
"a",
".",
"args",
",",
"i",
".",
"val",
")",
"\n",
"continue",
"\n",
"case",
"tokenQuotedArg",
":",
"i",
":=",
"p",
".",
"next",
"(",
")",
"\n",
"var",
"uq",
"string",
"\n",
"uq",
",",
"err",
"=",
"strconv",
".",
"Unquote",
"(",
"i",
".",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"a",
".",
"args",
"=",
"append",
"(",
"a",
".",
"args",
",",
"uq",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // AtomWords returns the parsed atom, the starting position of this
// atom and an error. | [
"AtomWords",
"returns",
"the",
"parsed",
"atom",
"the",
"starting",
"position",
"of",
"this",
"atom",
"and",
"an",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/expr.go#L256-L295 | train |
perkeep/perkeep | pkg/blobserver/mongo/mongo.go | configFromJSON | func configFromJSON(cfg jsonconfig.Obj) (config, error) {
conf := config{
server: cfg.OptionalString("host", "localhost"),
database: cfg.RequiredString("database"),
collection: cfg.OptionalString("collection", "blobs"),
user: cfg.OptionalString("user", ""),
password: cfg.OptionalString("password", ""),
}
if err := cfg.Validate(); err != nil {
return config{}, err
}
return conf, nil
} | go | func configFromJSON(cfg jsonconfig.Obj) (config, error) {
conf := config{
server: cfg.OptionalString("host", "localhost"),
database: cfg.RequiredString("database"),
collection: cfg.OptionalString("collection", "blobs"),
user: cfg.OptionalString("user", ""),
password: cfg.OptionalString("password", ""),
}
if err := cfg.Validate(); err != nil {
return config{}, err
}
return conf, nil
} | [
"func",
"configFromJSON",
"(",
"cfg",
"jsonconfig",
".",
"Obj",
")",
"(",
"config",
",",
"error",
")",
"{",
"conf",
":=",
"config",
"{",
"server",
":",
"cfg",
".",
"OptionalString",
"(",
"\"host\"",
",",
"\"localhost\"",
")",
",",
"database",
":",
"cfg",
".",
"RequiredString",
"(",
"\"database\"",
")",
",",
"collection",
":",
"cfg",
".",
"OptionalString",
"(",
"\"collection\"",
",",
"\"blobs\"",
")",
",",
"user",
":",
"cfg",
".",
"OptionalString",
"(",
"\"user\"",
",",
"\"\"",
")",
",",
"password",
":",
"cfg",
".",
"OptionalString",
"(",
"\"password\"",
",",
"\"\"",
")",
",",
"}",
"\n",
"if",
"err",
":=",
"cfg",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"config",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"conf",
",",
"nil",
"\n",
"}"
] | // ConfigFromJSON populates Config from cfg, and validates
// cfg. It returns an error if cfg fails to validate. | [
"ConfigFromJSON",
"populates",
"Config",
"from",
"cfg",
"and",
"validates",
"cfg",
".",
"It",
"returns",
"an",
"error",
"if",
"cfg",
"fails",
"to",
"validate",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/mongo/mongo.go#L119-L131 | train |
perkeep/perkeep | server/perkeepd/perkeepd.go | certHostname | func certHostname(listen, baseURL string) (string, error) {
hostPort, err := netutil.HostPort(baseURL)
if err != nil {
hostPort = listen
}
hostname, _, err := net.SplitHostPort(hostPort)
if err != nil {
return "", fmt.Errorf("failed to find hostname for cert from address %q: %v", hostPort, err)
}
return hostname, nil
} | go | func certHostname(listen, baseURL string) (string, error) {
hostPort, err := netutil.HostPort(baseURL)
if err != nil {
hostPort = listen
}
hostname, _, err := net.SplitHostPort(hostPort)
if err != nil {
return "", fmt.Errorf("failed to find hostname for cert from address %q: %v", hostPort, err)
}
return hostname, nil
} | [
"func",
"certHostname",
"(",
"listen",
",",
"baseURL",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"hostPort",
",",
"err",
":=",
"netutil",
".",
"HostPort",
"(",
"baseURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"hostPort",
"=",
"listen",
"\n",
"}",
"\n",
"hostname",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"hostPort",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to find hostname for cert from address %q: %v\"",
",",
"hostPort",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"hostname",
",",
"nil",
"\n",
"}"
] | // certHostname figures out the name to use for the TLS certificates, using baseURL
// and falling back to the listen address if baseURL is empty or invalid. | [
"certHostname",
"figures",
"out",
"the",
"name",
"to",
"use",
"for",
"the",
"TLS",
"certificates",
"using",
"baseURL",
"and",
"falling",
"back",
"to",
"the",
"listen",
"address",
"if",
"baseURL",
"is",
"empty",
"or",
"invalid",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/perkeepd.go#L352-L362 | train |
perkeep/perkeep | server/perkeepd/perkeepd.go | checkGeoKey | func checkGeoKey() error {
if _, err := geocode.GetAPIKey(); err == nil {
return nil
}
keyPath, err := geocode.GetAPIKeyPath()
if err != nil {
return fmt.Errorf("error getting Geocoding API key path: %v", err)
}
if env.OnGCE() {
keyPath = strings.TrimPrefix(keyPath, "/gcs/")
return fmt.Errorf("for location related requests to properly work, you need to create a Google Geocoding API Key (see https://developers.google.com/maps/documentation/geocoding/get-api-key ), and save it in your VM's configuration bucket as: %v", keyPath)
}
return fmt.Errorf("for location related requests to properly work, you need to create a Google Geocoding API Key (see https://developers.google.com/maps/documentation/geocoding/get-api-key ), and save it in Perkeep's configuration directory as: %v", keyPath)
} | go | func checkGeoKey() error {
if _, err := geocode.GetAPIKey(); err == nil {
return nil
}
keyPath, err := geocode.GetAPIKeyPath()
if err != nil {
return fmt.Errorf("error getting Geocoding API key path: %v", err)
}
if env.OnGCE() {
keyPath = strings.TrimPrefix(keyPath, "/gcs/")
return fmt.Errorf("for location related requests to properly work, you need to create a Google Geocoding API Key (see https://developers.google.com/maps/documentation/geocoding/get-api-key ), and save it in your VM's configuration bucket as: %v", keyPath)
}
return fmt.Errorf("for location related requests to properly work, you need to create a Google Geocoding API Key (see https://developers.google.com/maps/documentation/geocoding/get-api-key ), and save it in Perkeep's configuration directory as: %v", keyPath)
} | [
"func",
"checkGeoKey",
"(",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"geocode",
".",
"GetAPIKey",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"keyPath",
",",
"err",
":=",
"geocode",
".",
"GetAPIKeyPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"error getting Geocoding API key path: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"env",
".",
"OnGCE",
"(",
")",
"{",
"keyPath",
"=",
"strings",
".",
"TrimPrefix",
"(",
"keyPath",
",",
"\"/gcs/\"",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"for location related requests to properly work, you need to create a Google Geocoding API Key (see https://developers.google.com/maps/documentation/geocoding/get-api-key ), and save it in your VM's configuration bucket as: %v\"",
",",
"keyPath",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"for location related requests to properly work, you need to create a Google Geocoding API Key (see https://developers.google.com/maps/documentation/geocoding/get-api-key ), and save it in Perkeep's configuration directory as: %v\"",
",",
"keyPath",
")",
"\n",
"}"
] | // checkGeoKey returns nil if we have a Google Geocoding API key file stored
// in the config dir. Otherwise it returns instruction about it as the error. | [
"checkGeoKey",
"returns",
"nil",
"if",
"we",
"have",
"a",
"Google",
"Geocoding",
"API",
"key",
"file",
"stored",
"in",
"the",
"config",
"dir",
".",
"Otherwise",
"it",
"returns",
"instruction",
"about",
"it",
"as",
"the",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/perkeepd.go#L375-L388 | train |
perkeep/perkeep | pkg/index/util.go | Dup | func (s *dupSkipper) Dup(v string) bool {
if s.m == nil {
s.m = make(map[string]bool)
}
if s.m[v] {
return true
}
s.m[v] = true
return false
} | go | func (s *dupSkipper) Dup(v string) bool {
if s.m == nil {
s.m = make(map[string]bool)
}
if s.m[v] {
return true
}
s.m[v] = true
return false
} | [
"func",
"(",
"s",
"*",
"dupSkipper",
")",
"Dup",
"(",
"v",
"string",
")",
"bool",
"{",
"if",
"s",
".",
"m",
"==",
"nil",
"{",
"s",
".",
"m",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"m",
"[",
"v",
"]",
"{",
"return",
"true",
"\n",
"}",
"\n",
"s",
".",
"m",
"[",
"v",
"]",
"=",
"true",
"\n",
"return",
"false",
"\n",
"}"
] | // not thread safe. | [
"not",
"thread",
"safe",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/util.go#L39-L48 | train |
perkeep/perkeep | pkg/index/util.go | claimPtrsAttrValue | func claimPtrsAttrValue(claims []*camtypes.Claim, attr string, at time.Time, signerFilter SignerRefSet) string {
return claimsIntfAttrValue(claimPtrSlice(claims), attr, at, signerFilter)
} | go | func claimPtrsAttrValue(claims []*camtypes.Claim, attr string, at time.Time, signerFilter SignerRefSet) string {
return claimsIntfAttrValue(claimPtrSlice(claims), attr, at, signerFilter)
} | [
"func",
"claimPtrsAttrValue",
"(",
"claims",
"[",
"]",
"*",
"camtypes",
".",
"Claim",
",",
"attr",
"string",
",",
"at",
"time",
".",
"Time",
",",
"signerFilter",
"SignerRefSet",
")",
"string",
"{",
"return",
"claimsIntfAttrValue",
"(",
"claimPtrSlice",
"(",
"claims",
")",
",",
"attr",
",",
"at",
",",
"signerFilter",
")",
"\n",
"}"
] | // claimPtrsAttrValue returns the value of attr from claims,
// or the empty string if not found.
// Claims should be sorted by claim.Date. | [
"claimPtrsAttrValue",
"returns",
"the",
"value",
"of",
"attr",
"from",
"claims",
"or",
"the",
"empty",
"string",
"if",
"not",
"found",
".",
"Claims",
"should",
"be",
"sorted",
"by",
"claim",
".",
"Date",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/util.go#L53-L55 | train |
perkeep/perkeep | pkg/index/util.go | claimsIntfAttrValue | func claimsIntfAttrValue(claims claimsIntf, attr string, at time.Time, signerFilter SignerRefSet) string {
if claims == nil {
panic("nil claims argument in claimsIntfAttrValue")
}
if at.IsZero() {
at = time.Now()
}
// use a small static buffer as it speeds up
// search.BenchmarkQueryPermanodeLocation by 6-7%
// with go 1.7.1
var buf [8]string
v := buf[:][:0]
for i := 0; i < claims.Len(); i++ {
cl := claims.Claim(i)
if cl.Attr != attr || cl.Date.After(at) {
continue
}
if len(signerFilter) > 0 {
if !signerFilter.blobMatches(cl.Signer) {
continue
}
}
switch cl.Type {
case string(schema.DelAttributeClaim):
if cl.Value == "" {
v = v[:0]
} else {
i := 0
for _, w := range v {
if w != cl.Value {
v[i] = w
i++
}
}
v = v[:i]
}
case string(schema.SetAttributeClaim):
v = append(v[:0], cl.Value)
case string(schema.AddAttributeClaim):
v = append(v, cl.Value)
}
}
if len(v) != 0 {
return v[0]
}
return ""
} | go | func claimsIntfAttrValue(claims claimsIntf, attr string, at time.Time, signerFilter SignerRefSet) string {
if claims == nil {
panic("nil claims argument in claimsIntfAttrValue")
}
if at.IsZero() {
at = time.Now()
}
// use a small static buffer as it speeds up
// search.BenchmarkQueryPermanodeLocation by 6-7%
// with go 1.7.1
var buf [8]string
v := buf[:][:0]
for i := 0; i < claims.Len(); i++ {
cl := claims.Claim(i)
if cl.Attr != attr || cl.Date.After(at) {
continue
}
if len(signerFilter) > 0 {
if !signerFilter.blobMatches(cl.Signer) {
continue
}
}
switch cl.Type {
case string(schema.DelAttributeClaim):
if cl.Value == "" {
v = v[:0]
} else {
i := 0
for _, w := range v {
if w != cl.Value {
v[i] = w
i++
}
}
v = v[:i]
}
case string(schema.SetAttributeClaim):
v = append(v[:0], cl.Value)
case string(schema.AddAttributeClaim):
v = append(v, cl.Value)
}
}
if len(v) != 0 {
return v[0]
}
return ""
} | [
"func",
"claimsIntfAttrValue",
"(",
"claims",
"claimsIntf",
",",
"attr",
"string",
",",
"at",
"time",
".",
"Time",
",",
"signerFilter",
"SignerRefSet",
")",
"string",
"{",
"if",
"claims",
"==",
"nil",
"{",
"panic",
"(",
"\"nil claims argument in claimsIntfAttrValue\"",
")",
"\n",
"}",
"\n",
"if",
"at",
".",
"IsZero",
"(",
")",
"{",
"at",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"var",
"buf",
"[",
"8",
"]",
"string",
"\n",
"v",
":=",
"buf",
"[",
":",
"]",
"[",
":",
"0",
"]",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"claims",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"cl",
":=",
"claims",
".",
"Claim",
"(",
"i",
")",
"\n",
"if",
"cl",
".",
"Attr",
"!=",
"attr",
"||",
"cl",
".",
"Date",
".",
"After",
"(",
"at",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"len",
"(",
"signerFilter",
")",
">",
"0",
"{",
"if",
"!",
"signerFilter",
".",
"blobMatches",
"(",
"cl",
".",
"Signer",
")",
"{",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"switch",
"cl",
".",
"Type",
"{",
"case",
"string",
"(",
"schema",
".",
"DelAttributeClaim",
")",
":",
"if",
"cl",
".",
"Value",
"==",
"\"\"",
"{",
"v",
"=",
"v",
"[",
":",
"0",
"]",
"\n",
"}",
"else",
"{",
"i",
":=",
"0",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"v",
"{",
"if",
"w",
"!=",
"cl",
".",
"Value",
"{",
"v",
"[",
"i",
"]",
"=",
"w",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"v",
"=",
"v",
"[",
":",
"i",
"]",
"\n",
"}",
"\n",
"case",
"string",
"(",
"schema",
".",
"SetAttributeClaim",
")",
":",
"v",
"=",
"append",
"(",
"v",
"[",
":",
"0",
"]",
",",
"cl",
".",
"Value",
")",
"\n",
"case",
"string",
"(",
"schema",
".",
"AddAttributeClaim",
")",
":",
"v",
"=",
"append",
"(",
"v",
",",
"cl",
".",
"Value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"v",
")",
"!=",
"0",
"{",
"return",
"v",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"\"\"",
"\n",
"}"
] | // claimsIntfAttrValue finds the value of an attribute in a list of claims
// or empty string if not found. claims must be non-nil.
// If signerFilter contains any refs, a claim is only taken into account if it
// has been signed by one of the given signer refs. | [
"claimsIntfAttrValue",
"finds",
"the",
"value",
"of",
"an",
"attribute",
"in",
"a",
"list",
"of",
"claims",
"or",
"empty",
"string",
"if",
"not",
"found",
".",
"claims",
"must",
"be",
"non",
"-",
"nil",
".",
"If",
"signerFilter",
"contains",
"any",
"refs",
"a",
"claim",
"is",
"only",
"taken",
"into",
"account",
"if",
"it",
"has",
"been",
"signed",
"by",
"one",
"of",
"the",
"given",
"signer",
"refs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/util.go#L76-L127 | train |
perkeep/perkeep | pkg/blobserver/blobhub.go | GetHub | func GetHub(storage interface{}) BlobHub {
if h, ok := getHub(storage); ok {
return h
}
hubmu.Lock()
defer hubmu.Unlock()
h, ok := stohub[storage]
if ok {
return h
}
h = new(memHub)
stohub[storage] = h
return h
} | go | func GetHub(storage interface{}) BlobHub {
if h, ok := getHub(storage); ok {
return h
}
hubmu.Lock()
defer hubmu.Unlock()
h, ok := stohub[storage]
if ok {
return h
}
h = new(memHub)
stohub[storage] = h
return h
} | [
"func",
"GetHub",
"(",
"storage",
"interface",
"{",
"}",
")",
"BlobHub",
"{",
"if",
"h",
",",
"ok",
":=",
"getHub",
"(",
"storage",
")",
";",
"ok",
"{",
"return",
"h",
"\n",
"}",
"\n",
"hubmu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"hubmu",
".",
"Unlock",
"(",
")",
"\n",
"h",
",",
"ok",
":=",
"stohub",
"[",
"storage",
"]",
"\n",
"if",
"ok",
"{",
"return",
"h",
"\n",
"}",
"\n",
"h",
"=",
"new",
"(",
"memHub",
")",
"\n",
"stohub",
"[",
"storage",
"]",
"=",
"h",
"\n",
"return",
"h",
"\n",
"}"
] | // GetHub return a BlobHub for the given storage implementation. | [
"GetHub",
"return",
"a",
"BlobHub",
"for",
"the",
"given",
"storage",
"implementation",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobhub.go#L59-L72 | train |
perkeep/perkeep | pkg/blobserver/blobhub.go | WaitForBlob | func WaitForBlob(storage interface{}, deadline time.Time, blobs []blob.Ref) {
hub := GetHub(storage)
ch := make(chan blob.Ref, 1)
if len(blobs) == 0 {
hub.RegisterListener(ch)
defer hub.UnregisterListener(ch)
}
for _, br := range blobs {
hub.RegisterBlobListener(br, ch)
defer hub.UnregisterBlobListener(br, ch)
}
var tc <-chan time.Time
if !canLongPoll {
tc = time.After(2 * time.Second)
}
t := time.NewTimer(time.Until(deadline))
defer t.Stop()
select {
case <-ch:
case <-tc:
case <-t.C:
}
} | go | func WaitForBlob(storage interface{}, deadline time.Time, blobs []blob.Ref) {
hub := GetHub(storage)
ch := make(chan blob.Ref, 1)
if len(blobs) == 0 {
hub.RegisterListener(ch)
defer hub.UnregisterListener(ch)
}
for _, br := range blobs {
hub.RegisterBlobListener(br, ch)
defer hub.UnregisterBlobListener(br, ch)
}
var tc <-chan time.Time
if !canLongPoll {
tc = time.After(2 * time.Second)
}
t := time.NewTimer(time.Until(deadline))
defer t.Stop()
select {
case <-ch:
case <-tc:
case <-t.C:
}
} | [
"func",
"WaitForBlob",
"(",
"storage",
"interface",
"{",
"}",
",",
"deadline",
"time",
".",
"Time",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"{",
"hub",
":=",
"GetHub",
"(",
"storage",
")",
"\n",
"ch",
":=",
"make",
"(",
"chan",
"blob",
".",
"Ref",
",",
"1",
")",
"\n",
"if",
"len",
"(",
"blobs",
")",
"==",
"0",
"{",
"hub",
".",
"RegisterListener",
"(",
"ch",
")",
"\n",
"defer",
"hub",
".",
"UnregisterListener",
"(",
"ch",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"br",
":=",
"range",
"blobs",
"{",
"hub",
".",
"RegisterBlobListener",
"(",
"br",
",",
"ch",
")",
"\n",
"defer",
"hub",
".",
"UnregisterBlobListener",
"(",
"br",
",",
"ch",
")",
"\n",
"}",
"\n",
"var",
"tc",
"<-",
"chan",
"time",
".",
"Time",
"\n",
"if",
"!",
"canLongPoll",
"{",
"tc",
"=",
"time",
".",
"After",
"(",
"2",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"t",
":=",
"time",
".",
"NewTimer",
"(",
"time",
".",
"Until",
"(",
"deadline",
")",
")",
"\n",
"defer",
"t",
".",
"Stop",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"ch",
":",
"case",
"<-",
"tc",
":",
"case",
"<-",
"t",
".",
"C",
":",
"}",
"\n",
"}"
] | // WaitForBlob waits until deadline for blobs to arrive. If blobs is empty, any
// blobs are waited on. Otherwise, those specific blobs are waited on.
// When WaitForBlob returns, nothing may have happened. | [
"WaitForBlob",
"waits",
"until",
"deadline",
"for",
"blobs",
"to",
"arrive",
".",
"If",
"blobs",
"is",
"empty",
"any",
"blobs",
"are",
"waited",
"on",
".",
"Otherwise",
"those",
"specific",
"blobs",
"are",
"waited",
"on",
".",
"When",
"WaitForBlob",
"returns",
"nothing",
"may",
"have",
"happened",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobhub.go#L87-L111 | train |
perkeep/perkeep | pkg/index/receive.go | indexReadyBlobs | func (ix *Index) indexReadyBlobs(ctx context.Context) {
defer ix.reindexWg.Done()
ix.RLock()
// For tests
if ix.oooDisabled {
ix.RUnlock()
return
}
ix.RUnlock()
failed := make(map[blob.Ref]bool)
for {
ix.Lock()
if len(ix.readyReindex) == 0 {
ix.Unlock()
return
}
var br blob.Ref
for br = range ix.readyReindex {
break
}
delete(ix.readyReindex, br)
ix.Unlock()
if err := ix.indexBlob(ctx, br); err != nil {
log.Printf("out-of-order indexBlob(%v) = %v", br, err)
failed[br] = true
}
}
ix.Lock()
defer ix.Unlock()
for br := range failed {
ix.readyReindex[br] = true
}
} | go | func (ix *Index) indexReadyBlobs(ctx context.Context) {
defer ix.reindexWg.Done()
ix.RLock()
// For tests
if ix.oooDisabled {
ix.RUnlock()
return
}
ix.RUnlock()
failed := make(map[blob.Ref]bool)
for {
ix.Lock()
if len(ix.readyReindex) == 0 {
ix.Unlock()
return
}
var br blob.Ref
for br = range ix.readyReindex {
break
}
delete(ix.readyReindex, br)
ix.Unlock()
if err := ix.indexBlob(ctx, br); err != nil {
log.Printf("out-of-order indexBlob(%v) = %v", br, err)
failed[br] = true
}
}
ix.Lock()
defer ix.Unlock()
for br := range failed {
ix.readyReindex[br] = true
}
} | [
"func",
"(",
"ix",
"*",
"Index",
")",
"indexReadyBlobs",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"defer",
"ix",
".",
"reindexWg",
".",
"Done",
"(",
")",
"\n",
"ix",
".",
"RLock",
"(",
")",
"\n",
"if",
"ix",
".",
"oooDisabled",
"{",
"ix",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"ix",
".",
"RUnlock",
"(",
")",
"\n",
"failed",
":=",
"make",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"bool",
")",
"\n",
"for",
"{",
"ix",
".",
"Lock",
"(",
")",
"\n",
"if",
"len",
"(",
"ix",
".",
"readyReindex",
")",
"==",
"0",
"{",
"ix",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"br",
"blob",
".",
"Ref",
"\n",
"for",
"br",
"=",
"range",
"ix",
".",
"readyReindex",
"{",
"break",
"\n",
"}",
"\n",
"delete",
"(",
"ix",
".",
"readyReindex",
",",
"br",
")",
"\n",
"ix",
".",
"Unlock",
"(",
")",
"\n",
"if",
"err",
":=",
"ix",
".",
"indexBlob",
"(",
"ctx",
",",
"br",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"out-of-order indexBlob(%v) = %v\"",
",",
"br",
",",
"err",
")",
"\n",
"failed",
"[",
"br",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"ix",
".",
"Lock",
"(",
")",
"\n",
"defer",
"ix",
".",
"Unlock",
"(",
")",
"\n",
"for",
"br",
":=",
"range",
"failed",
"{",
"ix",
".",
"readyReindex",
"[",
"br",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}"
] | // indexReadyBlobs indexes blobs that have been recently marked as ready to be
// reindexed, after the blobs they depend on eventually were indexed. | [
"indexReadyBlobs",
"indexes",
"blobs",
"that",
"have",
"been",
"recently",
"marked",
"as",
"ready",
"to",
"be",
"reindexed",
"after",
"the",
"blobs",
"they",
"depend",
"on",
"eventually",
"were",
"indexed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L132-L164 | train |
perkeep/perkeep | pkg/index/receive.go | noteBlobIndexed | func (ix *Index) noteBlobIndexed(br blob.Ref) {
for _, needer := range ix.neededBy[br] {
newNeeds := blobsFilteringOut(ix.needs[needer], br)
if len(newNeeds) == 0 {
ix.readyReindex[needer] = true
delete(ix.needs, needer)
ix.reindexWg.Add(1)
go ix.indexReadyBlobs(context.Background())
} else {
ix.needs[needer] = newNeeds
}
}
delete(ix.neededBy, br)
} | go | func (ix *Index) noteBlobIndexed(br blob.Ref) {
for _, needer := range ix.neededBy[br] {
newNeeds := blobsFilteringOut(ix.needs[needer], br)
if len(newNeeds) == 0 {
ix.readyReindex[needer] = true
delete(ix.needs, needer)
ix.reindexWg.Add(1)
go ix.indexReadyBlobs(context.Background())
} else {
ix.needs[needer] = newNeeds
}
}
delete(ix.neededBy, br)
} | [
"func",
"(",
"ix",
"*",
"Index",
")",
"noteBlobIndexed",
"(",
"br",
"blob",
".",
"Ref",
")",
"{",
"for",
"_",
",",
"needer",
":=",
"range",
"ix",
".",
"neededBy",
"[",
"br",
"]",
"{",
"newNeeds",
":=",
"blobsFilteringOut",
"(",
"ix",
".",
"needs",
"[",
"needer",
"]",
",",
"br",
")",
"\n",
"if",
"len",
"(",
"newNeeds",
")",
"==",
"0",
"{",
"ix",
".",
"readyReindex",
"[",
"needer",
"]",
"=",
"true",
"\n",
"delete",
"(",
"ix",
".",
"needs",
",",
"needer",
")",
"\n",
"ix",
".",
"reindexWg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"ix",
".",
"indexReadyBlobs",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"ix",
".",
"needs",
"[",
"needer",
"]",
"=",
"newNeeds",
"\n",
"}",
"\n",
"}",
"\n",
"delete",
"(",
"ix",
".",
"neededBy",
",",
"br",
")",
"\n",
"}"
] | // noteBlobIndexed checks if the recent indexing of br now allows the blobs that
// were depending on br, to be indexed in turn. If yes, they're reindexed
// asynchronously by indexReadyBlobs. | [
"noteBlobIndexed",
"checks",
"if",
"the",
"recent",
"indexing",
"of",
"br",
"now",
"allows",
"the",
"blobs",
"that",
"were",
"depending",
"on",
"br",
"to",
"be",
"indexed",
"in",
"turn",
".",
"If",
"yes",
"they",
"re",
"reindexed",
"asynchronously",
"by",
"indexReadyBlobs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L169-L182 | train |
perkeep/perkeep | pkg/index/receive.go | commit | func (ix *Index) commit(mm *mutationMap) error {
// We want the update of the deletes cache to be atomic
// with the transaction commit, so we lock here instead
// of within updateDeletesCache.
ix.deletes.Lock()
defer ix.deletes.Unlock()
bm := ix.s.BeginBatch()
for k, v := range mm.kv {
bm.Set(k, v)
}
err := ix.s.CommitBatch(bm)
if err != nil {
return err
}
for _, cl := range mm.deletes {
if err := ix.updateDeletesCache(cl); err != nil {
return fmt.Errorf("Could not update the deletes cache after deletion from %v: %v", cl, err)
}
}
return nil
} | go | func (ix *Index) commit(mm *mutationMap) error {
// We want the update of the deletes cache to be atomic
// with the transaction commit, so we lock here instead
// of within updateDeletesCache.
ix.deletes.Lock()
defer ix.deletes.Unlock()
bm := ix.s.BeginBatch()
for k, v := range mm.kv {
bm.Set(k, v)
}
err := ix.s.CommitBatch(bm)
if err != nil {
return err
}
for _, cl := range mm.deletes {
if err := ix.updateDeletesCache(cl); err != nil {
return fmt.Errorf("Could not update the deletes cache after deletion from %v: %v", cl, err)
}
}
return nil
} | [
"func",
"(",
"ix",
"*",
"Index",
")",
"commit",
"(",
"mm",
"*",
"mutationMap",
")",
"error",
"{",
"ix",
".",
"deletes",
".",
"Lock",
"(",
")",
"\n",
"defer",
"ix",
".",
"deletes",
".",
"Unlock",
"(",
")",
"\n",
"bm",
":=",
"ix",
".",
"s",
".",
"BeginBatch",
"(",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"mm",
".",
"kv",
"{",
"bm",
".",
"Set",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"err",
":=",
"ix",
".",
"s",
".",
"CommitBatch",
"(",
"bm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"cl",
":=",
"range",
"mm",
".",
"deletes",
"{",
"if",
"err",
":=",
"ix",
".",
"updateDeletesCache",
"(",
"cl",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Could not update the deletes cache after deletion from %v: %v\"",
",",
"cl",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // commit writes the contents of the mutationMap on a batch
// mutation and commits that batch. It also updates the deletes
// cache. | [
"commit",
"writes",
"the",
"contents",
"of",
"the",
"mutationMap",
"on",
"a",
"batch",
"mutation",
"and",
"commits",
"that",
"batch",
".",
"It",
"also",
"updates",
"the",
"deletes",
"cache",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L303-L323 | train |
perkeep/perkeep | pkg/index/receive.go | hasErrNotExist | func (tf *trackErrorsFetcher) hasErrNotExist() bool {
tf.mu.RLock()
defer tf.mu.RUnlock()
if len(tf.errs) == 0 {
return false
}
for _, v := range tf.errs {
if v != os.ErrNotExist {
return false
}
}
return true
} | go | func (tf *trackErrorsFetcher) hasErrNotExist() bool {
tf.mu.RLock()
defer tf.mu.RUnlock()
if len(tf.errs) == 0 {
return false
}
for _, v := range tf.errs {
if v != os.ErrNotExist {
return false
}
}
return true
} | [
"func",
"(",
"tf",
"*",
"trackErrorsFetcher",
")",
"hasErrNotExist",
"(",
")",
"bool",
"{",
"tf",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"tf",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"len",
"(",
"tf",
".",
"errs",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"tf",
".",
"errs",
"{",
"if",
"v",
"!=",
"os",
".",
"ErrNotExist",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // hasErrNotExist reports whether tf recorded any error and if all of them are
// os.ErrNotExist errors. | [
"hasErrNotExist",
"reports",
"whether",
"tf",
"recorded",
"any",
"error",
"and",
"if",
"all",
"of",
"them",
"are",
"os",
".",
"ErrNotExist",
"errors",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L423-L435 | train |
perkeep/perkeep | pkg/index/receive.go | readPrefixOrFile | func readPrefixOrFile(prefix []byte, fetcher blob.Fetcher, b *schema.Blob, fn func(filePrefixReader) error) (err error) {
pr := bytes.NewReader(prefix)
err = fn(pr)
if err == io.EOF || err == io.ErrUnexpectedEOF {
var fr *schema.FileReader
fr, err = b.NewFileReader(fetcher)
if err == nil {
err = fn(fr)
fr.Close()
}
}
return err
} | go | func readPrefixOrFile(prefix []byte, fetcher blob.Fetcher, b *schema.Blob, fn func(filePrefixReader) error) (err error) {
pr := bytes.NewReader(prefix)
err = fn(pr)
if err == io.EOF || err == io.ErrUnexpectedEOF {
var fr *schema.FileReader
fr, err = b.NewFileReader(fetcher)
if err == nil {
err = fn(fr)
fr.Close()
}
}
return err
} | [
"func",
"readPrefixOrFile",
"(",
"prefix",
"[",
"]",
"byte",
",",
"fetcher",
"blob",
".",
"Fetcher",
",",
"b",
"*",
"schema",
".",
"Blob",
",",
"fn",
"func",
"(",
"filePrefixReader",
")",
"error",
")",
"(",
"err",
"error",
")",
"{",
"pr",
":=",
"bytes",
".",
"NewReader",
"(",
"prefix",
")",
"\n",
"err",
"=",
"fn",
"(",
"pr",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"||",
"err",
"==",
"io",
".",
"ErrUnexpectedEOF",
"{",
"var",
"fr",
"*",
"schema",
".",
"FileReader",
"\n",
"fr",
",",
"err",
"=",
"b",
".",
"NewFileReader",
"(",
"fetcher",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"fn",
"(",
"fr",
")",
"\n",
"fr",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // readPrefixOrFile executes a given func with a reader on the passed prefix and
// falls back to passing a reader on the whole file if the func returns an error. | [
"readPrefixOrFile",
"executes",
"a",
"given",
"func",
"with",
"a",
"reader",
"on",
"the",
"passed",
"prefix",
"and",
"falls",
"back",
"to",
"passing",
"a",
"reader",
"on",
"the",
"whole",
"file",
"if",
"the",
"func",
"returns",
"an",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L445-L457 | train |
perkeep/perkeep | pkg/index/receive.go | indexMusic | func indexMusic(r readerutil.SizeReaderAt, wholeRef blob.Ref, mm *mutationMap) {
tag, err := taglib.Decode(r, r.Size())
if err != nil {
log.Print("index: error parsing tag: ", err)
return
}
var footerLength int64 = 0
if hasTag, err := media.HasID3v1Tag(r); err != nil {
log.Print("index: unable to check for ID3v1 tag: ", err)
return
} else if hasTag {
footerLength = media.ID3v1TagLength
}
// Generate a hash of the audio portion of the file (i.e. excluding ID3v1 and v2 tags).
audioStart := int64(tag.TagSize())
audioSize := r.Size() - audioStart - footerLength
hash := blob.NewHash()
if _, err := io.Copy(hash, io.NewSectionReader(r, audioStart, audioSize)); err != nil {
log.Print("index: error generating hash of audio data: ", err)
return
}
mediaRef := blob.RefFromHash(hash)
duration, err := media.GetMPEGAudioDuration(io.NewSectionReader(r, audioStart, audioSize))
if err != nil {
log.Print("index: unable to calculate audio duration: ", err)
duration = 0
}
var yearStr, trackStr, discStr, durationStr string
if !tag.Year().IsZero() {
const justYearLayout = "2006"
yearStr = tag.Year().Format(justYearLayout)
}
if tag.Track() != 0 {
trackStr = fmt.Sprintf("%d", tag.Track())
}
if tag.Disc() != 0 {
discStr = fmt.Sprintf("%d", tag.Disc())
}
if duration != 0 {
durationStr = fmt.Sprintf("%d", duration/time.Millisecond)
}
// Note: if you add to this map, please update
// pkg/search/query.go's MediaTagConstraint Tag docs.
tags := map[string]string{
"title": tag.Title(),
"artist": tag.Artist(),
"album": tag.Album(),
"genre": tag.Genre(),
"musicbrainzalbumid": tag.CustomFrames()["MusicBrainz Album Id"],
"year": yearStr,
"track": trackStr,
"disc": discStr,
"mediaref": mediaRef.String(),
"durationms": durationStr,
}
for tag, value := range tags {
if value != "" {
mm.Set(keyMediaTag.Key(wholeRef, tag), keyMediaTag.Val(value))
}
}
} | go | func indexMusic(r readerutil.SizeReaderAt, wholeRef blob.Ref, mm *mutationMap) {
tag, err := taglib.Decode(r, r.Size())
if err != nil {
log.Print("index: error parsing tag: ", err)
return
}
var footerLength int64 = 0
if hasTag, err := media.HasID3v1Tag(r); err != nil {
log.Print("index: unable to check for ID3v1 tag: ", err)
return
} else if hasTag {
footerLength = media.ID3v1TagLength
}
// Generate a hash of the audio portion of the file (i.e. excluding ID3v1 and v2 tags).
audioStart := int64(tag.TagSize())
audioSize := r.Size() - audioStart - footerLength
hash := blob.NewHash()
if _, err := io.Copy(hash, io.NewSectionReader(r, audioStart, audioSize)); err != nil {
log.Print("index: error generating hash of audio data: ", err)
return
}
mediaRef := blob.RefFromHash(hash)
duration, err := media.GetMPEGAudioDuration(io.NewSectionReader(r, audioStart, audioSize))
if err != nil {
log.Print("index: unable to calculate audio duration: ", err)
duration = 0
}
var yearStr, trackStr, discStr, durationStr string
if !tag.Year().IsZero() {
const justYearLayout = "2006"
yearStr = tag.Year().Format(justYearLayout)
}
if tag.Track() != 0 {
trackStr = fmt.Sprintf("%d", tag.Track())
}
if tag.Disc() != 0 {
discStr = fmt.Sprintf("%d", tag.Disc())
}
if duration != 0 {
durationStr = fmt.Sprintf("%d", duration/time.Millisecond)
}
// Note: if you add to this map, please update
// pkg/search/query.go's MediaTagConstraint Tag docs.
tags := map[string]string{
"title": tag.Title(),
"artist": tag.Artist(),
"album": tag.Album(),
"genre": tag.Genre(),
"musicbrainzalbumid": tag.CustomFrames()["MusicBrainz Album Id"],
"year": yearStr,
"track": trackStr,
"disc": discStr,
"mediaref": mediaRef.String(),
"durationms": durationStr,
}
for tag, value := range tags {
if value != "" {
mm.Set(keyMediaTag.Key(wholeRef, tag), keyMediaTag.Val(value))
}
}
} | [
"func",
"indexMusic",
"(",
"r",
"readerutil",
".",
"SizeReaderAt",
",",
"wholeRef",
"blob",
".",
"Ref",
",",
"mm",
"*",
"mutationMap",
")",
"{",
"tag",
",",
"err",
":=",
"taglib",
".",
"Decode",
"(",
"r",
",",
"r",
".",
"Size",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"\"index: error parsing tag: \"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"footerLength",
"int64",
"=",
"0",
"\n",
"if",
"hasTag",
",",
"err",
":=",
"media",
".",
"HasID3v1Tag",
"(",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"\"index: unable to check for ID3v1 tag: \"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"hasTag",
"{",
"footerLength",
"=",
"media",
".",
"ID3v1TagLength",
"\n",
"}",
"\n",
"audioStart",
":=",
"int64",
"(",
"tag",
".",
"TagSize",
"(",
")",
")",
"\n",
"audioSize",
":=",
"r",
".",
"Size",
"(",
")",
"-",
"audioStart",
"-",
"footerLength",
"\n",
"hash",
":=",
"blob",
".",
"NewHash",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"hash",
",",
"io",
".",
"NewSectionReader",
"(",
"r",
",",
"audioStart",
",",
"audioSize",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"\"index: error generating hash of audio data: \"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"mediaRef",
":=",
"blob",
".",
"RefFromHash",
"(",
"hash",
")",
"\n",
"duration",
",",
"err",
":=",
"media",
".",
"GetMPEGAudioDuration",
"(",
"io",
".",
"NewSectionReader",
"(",
"r",
",",
"audioStart",
",",
"audioSize",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"\"index: unable to calculate audio duration: \"",
",",
"err",
")",
"\n",
"duration",
"=",
"0",
"\n",
"}",
"\n",
"var",
"yearStr",
",",
"trackStr",
",",
"discStr",
",",
"durationStr",
"string",
"\n",
"if",
"!",
"tag",
".",
"Year",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"const",
"justYearLayout",
"=",
"\"2006\"",
"\n",
"yearStr",
"=",
"tag",
".",
"Year",
"(",
")",
".",
"Format",
"(",
"justYearLayout",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Track",
"(",
")",
"!=",
"0",
"{",
"trackStr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%d\"",
",",
"tag",
".",
"Track",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Disc",
"(",
")",
"!=",
"0",
"{",
"discStr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%d\"",
",",
"tag",
".",
"Disc",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"duration",
"!=",
"0",
"{",
"durationStr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%d\"",
",",
"duration",
"/",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"tags",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"title\"",
":",
"tag",
".",
"Title",
"(",
")",
",",
"\"artist\"",
":",
"tag",
".",
"Artist",
"(",
")",
",",
"\"album\"",
":",
"tag",
".",
"Album",
"(",
")",
",",
"\"genre\"",
":",
"tag",
".",
"Genre",
"(",
")",
",",
"\"musicbrainzalbumid\"",
":",
"tag",
".",
"CustomFrames",
"(",
")",
"[",
"\"MusicBrainz Album Id\"",
"]",
",",
"\"year\"",
":",
"yearStr",
",",
"\"track\"",
":",
"trackStr",
",",
"\"disc\"",
":",
"discStr",
",",
"\"mediaref\"",
":",
"mediaRef",
".",
"String",
"(",
")",
",",
"\"durationms\"",
":",
"durationStr",
",",
"}",
"\n",
"for",
"tag",
",",
"value",
":=",
"range",
"tags",
"{",
"if",
"value",
"!=",
"\"\"",
"{",
"mm",
".",
"Set",
"(",
"keyMediaTag",
".",
"Key",
"(",
"wholeRef",
",",
"tag",
")",
",",
"keyMediaTag",
".",
"Val",
"(",
"value",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // indexMusic adds mutations to index the wholeRef by attached metadata and other properties. | [
"indexMusic",
"adds",
"mutations",
"to",
"index",
"the",
"wholeRef",
"by",
"attached",
"metadata",
"and",
"other",
"properties",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L707-L773 | train |
perkeep/perkeep | pkg/index/receive.go | populateDeleteClaim | func (ix *Index) populateDeleteClaim(ctx context.Context, cl schema.Claim, vr *jsonsign.VerifyRequest, mm *mutationMap) error {
br := cl.Blob().BlobRef()
target := cl.Target()
if !target.Valid() {
log.Print(fmt.Errorf("no valid target for delete claim %v", br))
return nil
}
meta, err := ix.GetBlobMeta(ctx, target)
if err != nil {
if err == os.ErrNotExist {
if err := ix.noteNeeded(br, target); err != nil {
return fmt.Errorf("could not note that delete claim %v depends on %v: %v", br, target, err)
}
return errMissingDep
}
log.Print(fmt.Errorf("Could not get mime type of target blob %v: %v", target, err))
return nil
}
// TODO(mpl): create consts somewhere for "claim" and "permanode" as camliTypes, and use them,
// instead of hardcoding. Unless they already exist ? (didn't find them).
if meta.CamliType != "permanode" && meta.CamliType != "claim" {
log.Print(fmt.Errorf("delete claim target in %v is neither a permanode nor a claim: %v", br, meta.CamliType))
return nil
}
mm.Set(keyDeleted.Key(target, cl.ClaimDateString(), br), "")
if meta.CamliType == "claim" {
return nil
}
recentKey := keyRecentPermanode.Key(vr.SignerKeyId, cl.ClaimDateString(), br)
mm.Set(recentKey, target.String())
attr, value := cl.Attribute(), cl.Value()
claimKey := keyPermanodeClaim.Key(target, vr.SignerKeyId, cl.ClaimDateString(), br)
mm.Set(claimKey, keyPermanodeClaim.Val(cl.ClaimType(), attr, value, vr.CamliSigner))
return nil
} | go | func (ix *Index) populateDeleteClaim(ctx context.Context, cl schema.Claim, vr *jsonsign.VerifyRequest, mm *mutationMap) error {
br := cl.Blob().BlobRef()
target := cl.Target()
if !target.Valid() {
log.Print(fmt.Errorf("no valid target for delete claim %v", br))
return nil
}
meta, err := ix.GetBlobMeta(ctx, target)
if err != nil {
if err == os.ErrNotExist {
if err := ix.noteNeeded(br, target); err != nil {
return fmt.Errorf("could not note that delete claim %v depends on %v: %v", br, target, err)
}
return errMissingDep
}
log.Print(fmt.Errorf("Could not get mime type of target blob %v: %v", target, err))
return nil
}
// TODO(mpl): create consts somewhere for "claim" and "permanode" as camliTypes, and use them,
// instead of hardcoding. Unless they already exist ? (didn't find them).
if meta.CamliType != "permanode" && meta.CamliType != "claim" {
log.Print(fmt.Errorf("delete claim target in %v is neither a permanode nor a claim: %v", br, meta.CamliType))
return nil
}
mm.Set(keyDeleted.Key(target, cl.ClaimDateString(), br), "")
if meta.CamliType == "claim" {
return nil
}
recentKey := keyRecentPermanode.Key(vr.SignerKeyId, cl.ClaimDateString(), br)
mm.Set(recentKey, target.String())
attr, value := cl.Attribute(), cl.Value()
claimKey := keyPermanodeClaim.Key(target, vr.SignerKeyId, cl.ClaimDateString(), br)
mm.Set(claimKey, keyPermanodeClaim.Val(cl.ClaimType(), attr, value, vr.CamliSigner))
return nil
} | [
"func",
"(",
"ix",
"*",
"Index",
")",
"populateDeleteClaim",
"(",
"ctx",
"context",
".",
"Context",
",",
"cl",
"schema",
".",
"Claim",
",",
"vr",
"*",
"jsonsign",
".",
"VerifyRequest",
",",
"mm",
"*",
"mutationMap",
")",
"error",
"{",
"br",
":=",
"cl",
".",
"Blob",
"(",
")",
".",
"BlobRef",
"(",
")",
"\n",
"target",
":=",
"cl",
".",
"Target",
"(",
")",
"\n",
"if",
"!",
"target",
".",
"Valid",
"(",
")",
"{",
"log",
".",
"Print",
"(",
"fmt",
".",
"Errorf",
"(",
"\"no valid target for delete claim %v\"",
",",
"br",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"meta",
",",
"err",
":=",
"ix",
".",
"GetBlobMeta",
"(",
"ctx",
",",
"target",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"os",
".",
"ErrNotExist",
"{",
"if",
"err",
":=",
"ix",
".",
"noteNeeded",
"(",
"br",
",",
"target",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not note that delete claim %v depends on %v: %v\"",
",",
"br",
",",
"target",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"errMissingDep",
"\n",
"}",
"\n",
"log",
".",
"Print",
"(",
"fmt",
".",
"Errorf",
"(",
"\"Could not get mime type of target blob %v: %v\"",
",",
"target",
",",
"err",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"meta",
".",
"CamliType",
"!=",
"\"permanode\"",
"&&",
"meta",
".",
"CamliType",
"!=",
"\"claim\"",
"{",
"log",
".",
"Print",
"(",
"fmt",
".",
"Errorf",
"(",
"\"delete claim target in %v is neither a permanode nor a claim: %v\"",
",",
"br",
",",
"meta",
".",
"CamliType",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"mm",
".",
"Set",
"(",
"keyDeleted",
".",
"Key",
"(",
"target",
",",
"cl",
".",
"ClaimDateString",
"(",
")",
",",
"br",
")",
",",
"\"\"",
")",
"\n",
"if",
"meta",
".",
"CamliType",
"==",
"\"claim\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"recentKey",
":=",
"keyRecentPermanode",
".",
"Key",
"(",
"vr",
".",
"SignerKeyId",
",",
"cl",
".",
"ClaimDateString",
"(",
")",
",",
"br",
")",
"\n",
"mm",
".",
"Set",
"(",
"recentKey",
",",
"target",
".",
"String",
"(",
")",
")",
"\n",
"attr",
",",
"value",
":=",
"cl",
".",
"Attribute",
"(",
")",
",",
"cl",
".",
"Value",
"(",
")",
"\n",
"claimKey",
":=",
"keyPermanodeClaim",
".",
"Key",
"(",
"target",
",",
"vr",
".",
"SignerKeyId",
",",
"cl",
".",
"ClaimDateString",
"(",
")",
",",
"br",
")",
"\n",
"mm",
".",
"Set",
"(",
"claimKey",
",",
"keyPermanodeClaim",
".",
"Val",
"(",
"cl",
".",
"ClaimType",
"(",
")",
",",
"attr",
",",
"value",
",",
"vr",
".",
"CamliSigner",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // populateDeleteClaim adds to mm the entries resulting from the delete claim cl.
// It is assumed cl is a valid claim, and vr has already been verified. | [
"populateDeleteClaim",
"adds",
"to",
"mm",
"the",
"entries",
"resulting",
"from",
"the",
"delete",
"claim",
"cl",
".",
"It",
"is",
"assumed",
"cl",
"is",
"a",
"valid",
"claim",
"and",
"vr",
"has",
"already",
"been",
"verified",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L811-L846 | train |
perkeep/perkeep | pkg/index/receive.go | updateDeletesCache | func (ix *Index) updateDeletesCache(deleteClaim schema.Claim) error {
target := deleteClaim.Target()
deleter := deleteClaim.Blob()
when, err := deleter.ClaimDate()
if err != nil {
return fmt.Errorf("Could not get date of delete claim %v: %v", deleteClaim, err)
}
targetDeletions := append(ix.deletes.m[target],
deletion{
deleter: deleter.BlobRef(),
when: when,
})
sort.Sort(sort.Reverse(byDeletionDate(targetDeletions)))
ix.deletes.m[target] = targetDeletions
return nil
} | go | func (ix *Index) updateDeletesCache(deleteClaim schema.Claim) error {
target := deleteClaim.Target()
deleter := deleteClaim.Blob()
when, err := deleter.ClaimDate()
if err != nil {
return fmt.Errorf("Could not get date of delete claim %v: %v", deleteClaim, err)
}
targetDeletions := append(ix.deletes.m[target],
deletion{
deleter: deleter.BlobRef(),
when: when,
})
sort.Sort(sort.Reverse(byDeletionDate(targetDeletions)))
ix.deletes.m[target] = targetDeletions
return nil
} | [
"func",
"(",
"ix",
"*",
"Index",
")",
"updateDeletesCache",
"(",
"deleteClaim",
"schema",
".",
"Claim",
")",
"error",
"{",
"target",
":=",
"deleteClaim",
".",
"Target",
"(",
")",
"\n",
"deleter",
":=",
"deleteClaim",
".",
"Blob",
"(",
")",
"\n",
"when",
",",
"err",
":=",
"deleter",
".",
"ClaimDate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Could not get date of delete claim %v: %v\"",
",",
"deleteClaim",
",",
"err",
")",
"\n",
"}",
"\n",
"targetDeletions",
":=",
"append",
"(",
"ix",
".",
"deletes",
".",
"m",
"[",
"target",
"]",
",",
"deletion",
"{",
"deleter",
":",
"deleter",
".",
"BlobRef",
"(",
")",
",",
"when",
":",
"when",
",",
"}",
")",
"\n",
"sort",
".",
"Sort",
"(",
"sort",
".",
"Reverse",
"(",
"byDeletionDate",
"(",
"targetDeletions",
")",
")",
")",
"\n",
"ix",
".",
"deletes",
".",
"m",
"[",
"target",
"]",
"=",
"targetDeletions",
"\n",
"return",
"nil",
"\n",
"}"
] | // updateDeletesCache updates the index deletes cache with the cl delete claim.
// deleteClaim is trusted to be a valid delete Claim. | [
"updateDeletesCache",
"updates",
"the",
"index",
"deletes",
"cache",
"with",
"the",
"cl",
"delete",
"claim",
".",
"deleteClaim",
"is",
"trusted",
"to",
"be",
"a",
"valid",
"delete",
"Claim",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/receive.go#L937-L952 | train |
perkeep/perkeep | cmd/pk-devimport/devimport.go | getCredentials | func getCredentials(sh search.QueryDescriber, importerType string) (string, string, error) {
var clientID, clientSecret string
res, err := sh.Query(context.TODO(), &search.SearchQuery{
Expression: "attr:camliNodeType:importer and attr:importerType:" + importerType,
Describe: &search.DescribeRequest{
Depth: 1,
},
})
if err != nil {
return clientID, clientSecret, err
}
if res.Describe == nil {
return clientID, clientSecret, errors.New("no importer node found")
}
var attrs url.Values
for _, resBlob := range res.Blobs {
blob := resBlob.Blob
desBlob, ok := res.Describe.Meta[blob.String()]
if !ok || desBlob.Permanode == nil {
continue
}
attrs = desBlob.Permanode.Attr
if attrs.Get("camliNodeType") != "importer" {
return clientID, clientSecret, errors.New("search result returned non importer node")
}
if t := attrs.Get("importerType"); t != importerType {
return clientID, clientSecret, fmt.Errorf("search result returned importer node of the wrong type: %v", t)
}
break
}
attrClientID, attrClientSecret := "authClientID", "authClientSecret"
attr := attrs[attrClientID]
if len(attr) != 1 {
return clientID, clientSecret, fmt.Errorf("no %v attribute", attrClientID)
}
clientID = attr[0]
attr = attrs[attrClientSecret]
if len(attr) != 1 {
return clientID, clientSecret, fmt.Errorf("no %v attribute", attrClientSecret)
}
clientSecret = attr[0]
return clientID, clientSecret, nil
} | go | func getCredentials(sh search.QueryDescriber, importerType string) (string, string, error) {
var clientID, clientSecret string
res, err := sh.Query(context.TODO(), &search.SearchQuery{
Expression: "attr:camliNodeType:importer and attr:importerType:" + importerType,
Describe: &search.DescribeRequest{
Depth: 1,
},
})
if err != nil {
return clientID, clientSecret, err
}
if res.Describe == nil {
return clientID, clientSecret, errors.New("no importer node found")
}
var attrs url.Values
for _, resBlob := range res.Blobs {
blob := resBlob.Blob
desBlob, ok := res.Describe.Meta[blob.String()]
if !ok || desBlob.Permanode == nil {
continue
}
attrs = desBlob.Permanode.Attr
if attrs.Get("camliNodeType") != "importer" {
return clientID, clientSecret, errors.New("search result returned non importer node")
}
if t := attrs.Get("importerType"); t != importerType {
return clientID, clientSecret, fmt.Errorf("search result returned importer node of the wrong type: %v", t)
}
break
}
attrClientID, attrClientSecret := "authClientID", "authClientSecret"
attr := attrs[attrClientID]
if len(attr) != 1 {
return clientID, clientSecret, fmt.Errorf("no %v attribute", attrClientID)
}
clientID = attr[0]
attr = attrs[attrClientSecret]
if len(attr) != 1 {
return clientID, clientSecret, fmt.Errorf("no %v attribute", attrClientSecret)
}
clientSecret = attr[0]
return clientID, clientSecret, nil
} | [
"func",
"getCredentials",
"(",
"sh",
"search",
".",
"QueryDescriber",
",",
"importerType",
"string",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"var",
"clientID",
",",
"clientSecret",
"string",
"\n",
"res",
",",
"err",
":=",
"sh",
".",
"Query",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"&",
"search",
".",
"SearchQuery",
"{",
"Expression",
":",
"\"attr:camliNodeType:importer and attr:importerType:\"",
"+",
"importerType",
",",
"Describe",
":",
"&",
"search",
".",
"DescribeRequest",
"{",
"Depth",
":",
"1",
",",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"clientID",
",",
"clientSecret",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"Describe",
"==",
"nil",
"{",
"return",
"clientID",
",",
"clientSecret",
",",
"errors",
".",
"New",
"(",
"\"no importer node found\"",
")",
"\n",
"}",
"\n",
"var",
"attrs",
"url",
".",
"Values",
"\n",
"for",
"_",
",",
"resBlob",
":=",
"range",
"res",
".",
"Blobs",
"{",
"blob",
":=",
"resBlob",
".",
"Blob",
"\n",
"desBlob",
",",
"ok",
":=",
"res",
".",
"Describe",
".",
"Meta",
"[",
"blob",
".",
"String",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"||",
"desBlob",
".",
"Permanode",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"attrs",
"=",
"desBlob",
".",
"Permanode",
".",
"Attr",
"\n",
"if",
"attrs",
".",
"Get",
"(",
"\"camliNodeType\"",
")",
"!=",
"\"importer\"",
"{",
"return",
"clientID",
",",
"clientSecret",
",",
"errors",
".",
"New",
"(",
"\"search result returned non importer node\"",
")",
"\n",
"}",
"\n",
"if",
"t",
":=",
"attrs",
".",
"Get",
"(",
"\"importerType\"",
")",
";",
"t",
"!=",
"importerType",
"{",
"return",
"clientID",
",",
"clientSecret",
",",
"fmt",
".",
"Errorf",
"(",
"\"search result returned importer node of the wrong type: %v\"",
",",
"t",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"attrClientID",
",",
"attrClientSecret",
":=",
"\"authClientID\"",
",",
"\"authClientSecret\"",
"\n",
"attr",
":=",
"attrs",
"[",
"attrClientID",
"]",
"\n",
"if",
"len",
"(",
"attr",
")",
"!=",
"1",
"{",
"return",
"clientID",
",",
"clientSecret",
",",
"fmt",
".",
"Errorf",
"(",
"\"no %v attribute\"",
",",
"attrClientID",
")",
"\n",
"}",
"\n",
"clientID",
"=",
"attr",
"[",
"0",
"]",
"\n",
"attr",
"=",
"attrs",
"[",
"attrClientSecret",
"]",
"\n",
"if",
"len",
"(",
"attr",
")",
"!=",
"1",
"{",
"return",
"clientID",
",",
"clientSecret",
",",
"fmt",
".",
"Errorf",
"(",
"\"no %v attribute\"",
",",
"attrClientSecret",
")",
"\n",
"}",
"\n",
"clientSecret",
"=",
"attr",
"[",
"0",
"]",
"\n",
"return",
"clientID",
",",
"clientSecret",
",",
"nil",
"\n",
"}"
] | // getCredentials returns the OAuth clientID and clientSecret found in the
// importer node of the given importerType. | [
"getCredentials",
"returns",
"the",
"OAuth",
"clientID",
"and",
"clientSecret",
"found",
"in",
"the",
"importer",
"node",
"of",
"the",
"given",
"importerType",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-devimport/devimport.go#L112-L154 | train |
perkeep/perkeep | pkg/schema/filewriter.go | WriteFileFromReaderWithModTime | func WriteFileFromReaderWithModTime(ctx context.Context, bs blobserver.StatReceiver, filename string, modTime time.Time, r io.Reader) (blob.Ref, error) {
if strings.Contains(filename, "/") {
return blob.Ref{}, fmt.Errorf("schema.WriteFileFromReader: filename %q shouldn't contain a slash", filename)
}
m := NewFileMap(filename)
if !modTime.IsZero() {
m.SetModTime(modTime)
}
return WriteFileMap(ctx, bs, m, r)
} | go | func WriteFileFromReaderWithModTime(ctx context.Context, bs blobserver.StatReceiver, filename string, modTime time.Time, r io.Reader) (blob.Ref, error) {
if strings.Contains(filename, "/") {
return blob.Ref{}, fmt.Errorf("schema.WriteFileFromReader: filename %q shouldn't contain a slash", filename)
}
m := NewFileMap(filename)
if !modTime.IsZero() {
m.SetModTime(modTime)
}
return WriteFileMap(ctx, bs, m, r)
} | [
"func",
"WriteFileFromReaderWithModTime",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"blobserver",
".",
"StatReceiver",
",",
"filename",
"string",
",",
"modTime",
"time",
".",
"Time",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"if",
"strings",
".",
"Contains",
"(",
"filename",
",",
"\"/\"",
")",
"{",
"return",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"schema.WriteFileFromReader: filename %q shouldn't contain a slash\"",
",",
"filename",
")",
"\n",
"}",
"\n",
"m",
":=",
"NewFileMap",
"(",
"filename",
")",
"\n",
"if",
"!",
"modTime",
".",
"IsZero",
"(",
")",
"{",
"m",
".",
"SetModTime",
"(",
"modTime",
")",
"\n",
"}",
"\n",
"return",
"WriteFileMap",
"(",
"ctx",
",",
"bs",
",",
"m",
",",
"r",
")",
"\n",
"}"
] | // WriteFileFromReaderWithModTime creates and uploads a "file" JSON schema
// composed of chunks of r, also uploading the chunks. The returned
// BlobRef is of the JSON file schema blob.
// Both filename and modTime are optional. | [
"WriteFileFromReaderWithModTime",
"creates",
"and",
"uploads",
"a",
"file",
"JSON",
"schema",
"composed",
"of",
"chunks",
"of",
"r",
"also",
"uploading",
"the",
"chunks",
".",
"The",
"returned",
"BlobRef",
"is",
"of",
"the",
"JSON",
"file",
"schema",
"blob",
".",
"Both",
"filename",
"and",
"modTime",
"are",
"optional",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filewriter.go#L69-L79 | train |
perkeep/perkeep | pkg/schema/filewriter.go | WriteFileFromReader | func WriteFileFromReader(ctx context.Context, bs blobserver.StatReceiver, filename string, r io.Reader) (blob.Ref, error) {
return WriteFileFromReaderWithModTime(ctx, bs, filename, time.Time{}, r)
} | go | func WriteFileFromReader(ctx context.Context, bs blobserver.StatReceiver, filename string, r io.Reader) (blob.Ref, error) {
return WriteFileFromReaderWithModTime(ctx, bs, filename, time.Time{}, r)
} | [
"func",
"WriteFileFromReader",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"blobserver",
".",
"StatReceiver",
",",
"filename",
"string",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"return",
"WriteFileFromReaderWithModTime",
"(",
"ctx",
",",
"bs",
",",
"filename",
",",
"time",
".",
"Time",
"{",
"}",
",",
"r",
")",
"\n",
"}"
] | // WriteFileFromReader creates and uploads a "file" JSON schema
// composed of chunks of r, also uploading the chunks. The returned
// BlobRef is of the JSON file schema blob.
// The filename is optional. | [
"WriteFileFromReader",
"creates",
"and",
"uploads",
"a",
"file",
"JSON",
"schema",
"composed",
"of",
"chunks",
"of",
"r",
"also",
"uploading",
"the",
"chunks",
".",
"The",
"returned",
"BlobRef",
"is",
"of",
"the",
"JSON",
"file",
"schema",
"blob",
".",
"The",
"filename",
"is",
"optional",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filewriter.go#L85-L87 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.