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/schema/filewriter.go | WriteFileMap | func WriteFileMap(ctx context.Context, bs blobserver.StatReceiver, file *Builder, r io.Reader) (blob.Ref, error) {
return writeFileMapRolling(ctx, bs, file, r)
} | go | func WriteFileMap(ctx context.Context, bs blobserver.StatReceiver, file *Builder, r io.Reader) (blob.Ref, error) {
return writeFileMapRolling(ctx, bs, file, r)
} | [
"func",
"WriteFileMap",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"blobserver",
".",
"StatReceiver",
",",
"file",
"*",
"Builder",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"return",
"writeFileMapRolling"... | // WriteFileMap uploads chunks of r to bs while populating file and
// finally uploading file's Blob. The returned blobref is of file's
// JSON blob. | [
"WriteFileMap",
"uploads",
"chunks",
"of",
"r",
"to",
"bs",
"while",
"populating",
"file",
"and",
"finally",
"uploading",
"file",
"s",
"Blob",
".",
"The",
"returned",
"blobref",
"is",
"of",
"file",
"s",
"JSON",
"blob",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filewriter.go#L92-L94 | train |
perkeep/perkeep | pkg/schema/filewriter.go | Get | func (f *uploadBytesFuture) Get() (blob.Ref, error) {
for _, f := range f.children {
if _, err := f.Get(); err != nil {
return blob.Ref{}, err
}
}
return f.br, <-f.errc
} | go | func (f *uploadBytesFuture) Get() (blob.Ref, error) {
for _, f := range f.children {
if _, err := f.Get(); err != nil {
return blob.Ref{}, err
}
}
return f.br, <-f.errc
} | [
"func",
"(",
"f",
"*",
"uploadBytesFuture",
")",
"Get",
"(",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"f",
".",
"children",
"{",
"if",
"_",
",",
"err",
":=",
"f",
".",
"Get",
"(",
")",
";",
... | // Get blocks for all children and returns any final error. | [
"Get",
"blocks",
"for",
"all",
"children",
"and",
"returns",
"any",
"final",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filewriter.go#L216-L223 | train |
perkeep/perkeep | pkg/schema/filewriter.go | writeFileMapRolling | func writeFileMapRolling(ctx context.Context, bs blobserver.StatReceiver, file *Builder, r io.Reader) (blob.Ref, error) {
n, spans, err := writeFileChunks(ctx, bs, file, r)
if err != nil {
return blob.Ref{}, err
}
// The top-level content parts
return uploadBytes(ctx, bs, file, n, spans).Get()
} | go | func writeFileMapRolling(ctx context.Context, bs blobserver.StatReceiver, file *Builder, r io.Reader) (blob.Ref, error) {
n, spans, err := writeFileChunks(ctx, bs, file, r)
if err != nil {
return blob.Ref{}, err
}
// The top-level content parts
return uploadBytes(ctx, bs, file, n, spans).Get()
} | [
"func",
"writeFileMapRolling",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"blobserver",
".",
"StatReceiver",
",",
"file",
"*",
"Builder",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"n",
",",
"spans",
"... | // writeFileMap uploads chunks of r to bs while populating fileMap and
// finally uploading fileMap. The returned blobref is of fileMap's
// JSON blob. It uses rolling checksum for the chunks sizes. | [
"writeFileMap",
"uploads",
"chunks",
"of",
"r",
"to",
"bs",
"while",
"populating",
"fileMap",
"and",
"finally",
"uploading",
"fileMap",
".",
"The",
"returned",
"blobref",
"is",
"of",
"fileMap",
"s",
"JSON",
"blob",
".",
"It",
"uses",
"rolling",
"checksum",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filewriter.go#L265-L272 | train |
perkeep/perkeep | pkg/schema/filewriter.go | WriteFileChunks | func WriteFileChunks(ctx context.Context, bs blobserver.StatReceiver, file *Builder, r io.Reader) error {
size, spans, err := writeFileChunks(ctx, bs, file, r)
if err != nil {
return err
}
parts := []BytesPart{}
future := newUploadBytesFuture()
addBytesParts(ctx, bs, &parts, spans, future)
future.errc <- nil // Get will still block on addBytesParts' children
if _, err := future.Get(); err != nil {
return err
}
return file.PopulateParts(size, parts)
} | go | func WriteFileChunks(ctx context.Context, bs blobserver.StatReceiver, file *Builder, r io.Reader) error {
size, spans, err := writeFileChunks(ctx, bs, file, r)
if err != nil {
return err
}
parts := []BytesPart{}
future := newUploadBytesFuture()
addBytesParts(ctx, bs, &parts, spans, future)
future.errc <- nil // Get will still block on addBytesParts' children
if _, err := future.Get(); err != nil {
return err
}
return file.PopulateParts(size, parts)
} | [
"func",
"WriteFileChunks",
"(",
"ctx",
"context",
".",
"Context",
",",
"bs",
"blobserver",
".",
"StatReceiver",
",",
"file",
"*",
"Builder",
",",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"size",
",",
"spans",
",",
"err",
":=",
"writeFileChunks",
"(",... | // WriteFileChunks uploads chunks of r to bs while populating file.
// It does not upload file. | [
"WriteFileChunks",
"uploads",
"chunks",
"of",
"r",
"to",
"bs",
"while",
"populating",
"file",
".",
"It",
"does",
"not",
"upload",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filewriter.go#L276-L289 | train |
perkeep/perkeep | internal/pools/pools.go | BytesBuffer | func BytesBuffer() *bytes.Buffer {
buf := bytesBuffer.Get().(*bytes.Buffer)
buf.Reset()
return buf
} | go | func BytesBuffer() *bytes.Buffer {
buf := bytesBuffer.Get().(*bytes.Buffer)
buf.Reset()
return buf
} | [
"func",
"BytesBuffer",
"(",
")",
"*",
"bytes",
".",
"Buffer",
"{",
"buf",
":=",
"bytesBuffer",
".",
"Get",
"(",
")",
".",
"(",
"*",
"bytes",
".",
"Buffer",
")",
"\n",
"buf",
".",
"Reset",
"(",
")",
"\n",
"return",
"buf",
"\n",
"}"
] | // BytesBuffer returns an empty bytes.Buffer.
// It should be returned with PutBuffer. | [
"BytesBuffer",
"returns",
"an",
"empty",
"bytes",
".",
"Buffer",
".",
"It",
"should",
"be",
"returned",
"with",
"PutBuffer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/pools/pools.go#L32-L36 | train |
perkeep/perkeep | pkg/auth/auth.go | RegisterAuth | func RegisterAuth(name string, ctor AuthConfigParser) {
if _, dup := authConstructor[name]; dup {
panic("Dup registration of auth mode " + name)
}
authConstructor[name] = ctor
} | go | func RegisterAuth(name string, ctor AuthConfigParser) {
if _, dup := authConstructor[name]; dup {
panic("Dup registration of auth mode " + name)
}
authConstructor[name] = ctor
} | [
"func",
"RegisterAuth",
"(",
"name",
"string",
",",
"ctor",
"AuthConfigParser",
")",
"{",
"if",
"_",
",",
"dup",
":=",
"authConstructor",
"[",
"name",
"]",
";",
"dup",
"{",
"panic",
"(",
"\"Dup registration of auth mode \"",
"+",
"name",
")",
"\n",
"}",
"\... | // RegisterAuth registers a new authentication scheme. | [
"RegisterAuth",
"registers",
"a",
"new",
"authentication",
"scheme",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L100-L105 | train |
perkeep/perkeep | pkg/auth/auth.go | NewBasicAuth | func NewBasicAuth(username, password string) AuthMode {
return &UserPass{
Username: username,
Password: password,
}
} | go | func NewBasicAuth(username, password string) AuthMode {
return &UserPass{
Username: username,
Password: password,
}
} | [
"func",
"NewBasicAuth",
"(",
"username",
",",
"password",
"string",
")",
"AuthMode",
"{",
"return",
"&",
"UserPass",
"{",
"Username",
":",
"username",
",",
"Password",
":",
"password",
",",
"}",
"\n",
"}"
] | // NewBasicAuth returns a UserPass Authmode, adequate to support HTTP
// basic authentication. | [
"NewBasicAuth",
"returns",
"a",
"UserPass",
"Authmode",
"adequate",
"to",
"support",
"HTTP",
"basic",
"authentication",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L157-L162 | train |
perkeep/perkeep | pkg/auth/auth.go | AllowedWithAuth | func AllowedWithAuth(am AuthMode, req *http.Request, op Operation) bool {
if op&OpUpload != 0 {
// upload (at least from pk-put) requires stat and get too
op = op | OpVivify
}
return am.AllowedAccess(req)&op == op
} | go | func AllowedWithAuth(am AuthMode, req *http.Request, op Operation) bool {
if op&OpUpload != 0 {
// upload (at least from pk-put) requires stat and get too
op = op | OpVivify
}
return am.AllowedAccess(req)&op == op
} | [
"func",
"AllowedWithAuth",
"(",
"am",
"AuthMode",
",",
"req",
"*",
"http",
".",
"Request",
",",
"op",
"Operation",
")",
"bool",
"{",
"if",
"op",
"&",
"OpUpload",
"!=",
"0",
"{",
"op",
"=",
"op",
"|",
"OpVivify",
"\n",
"}",
"\n",
"return",
"am",
"."... | // AllowedWithAuth returns whether the given request
// has access to perform all the operations in op
// against am. | [
"AllowedWithAuth",
"returns",
"whether",
"the",
"given",
"request",
"has",
"access",
"to",
"perform",
"all",
"the",
"operations",
"in",
"op",
"against",
"am",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L341-L347 | train |
perkeep/perkeep | pkg/auth/auth.go | Allowed | func Allowed(req *http.Request, op Operation) bool {
for _, m := range modes {
if AllowedWithAuth(m, req, op) {
return true
}
}
return false
} | go | func Allowed(req *http.Request, op Operation) bool {
for _, m := range modes {
if AllowedWithAuth(m, req, op) {
return true
}
}
return false
} | [
"func",
"Allowed",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"op",
"Operation",
")",
"bool",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"modes",
"{",
"if",
"AllowedWithAuth",
"(",
"m",
",",
"req",
",",
"op",
")",
"{",
"return",
"true",
"\n",
"... | // Allowed returns whether the given request
// has access to perform all the operations in op. | [
"Allowed",
"returns",
"whether",
"the",
"given",
"request",
"has",
"access",
"to",
"perform",
"all",
"the",
"operations",
"in",
"op",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L351-L358 | train |
perkeep/perkeep | pkg/auth/auth.go | ServeHTTP | func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
h.serveHTTPForOp(w, r, OpAll)
} | go | func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
h.serveHTTPForOp(w, r, OpAll)
} | [
"func",
"(",
"h",
"Handler",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"h",
".",
"serveHTTPForOp",
"(",
"w",
",",
"r",
",",
"OpAll",
")",
"\n",
"}"
] | // ServeHTTP serves only if this request and auth mode are allowed all Operations. | [
"ServeHTTP",
"serves",
"only",
"if",
"this",
"request",
"and",
"auth",
"mode",
"are",
"allowed",
"all",
"Operations",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L418-L420 | train |
perkeep/perkeep | pkg/auth/auth.go | serveHTTPForOp | func (h Handler) serveHTTPForOp(w http.ResponseWriter, r *http.Request, op Operation) {
if Allowed(r, op) {
h.Handler.ServeHTTP(w, r)
} else {
SendUnauthorized(w, r)
}
} | go | func (h Handler) serveHTTPForOp(w http.ResponseWriter, r *http.Request, op Operation) {
if Allowed(r, op) {
h.Handler.ServeHTTP(w, r)
} else {
SendUnauthorized(w, r)
}
} | [
"func",
"(",
"h",
"Handler",
")",
"serveHTTPForOp",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"op",
"Operation",
")",
"{",
"if",
"Allowed",
"(",
"r",
",",
"op",
")",
"{",
"h",
".",
"Handler",
".",
"ServeHT... | // serveHTTPForOp serves only if op is allowed for this request and auth mode. | [
"serveHTTPForOp",
"serves",
"only",
"if",
"op",
"is",
"allowed",
"for",
"this",
"request",
"and",
"auth",
"mode",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L423-L429 | train |
perkeep/perkeep | pkg/auth/auth.go | RequireAuth | func RequireAuth(h http.Handler, op Operation) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
if Allowed(req, op) {
h.ServeHTTP(rw, req)
} else {
SendUnauthorized(rw, req)
}
})
} | go | func RequireAuth(h http.Handler, op Operation) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
if Allowed(req, op) {
h.ServeHTTP(rw, req)
} else {
SendUnauthorized(rw, req)
}
})
} | [
"func",
"RequireAuth",
"(",
"h",
"http",
".",
"Handler",
",",
"op",
"Operation",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")"... | // RequireAuth wraps a function with another function that enforces
// HTTP Basic Auth and checks if the operations in op are all permitted. | [
"RequireAuth",
"wraps",
"a",
"function",
"with",
"another",
"function",
"that",
"enforces",
"HTTP",
"Basic",
"Auth",
"and",
"checks",
"if",
"the",
"operations",
"in",
"op",
"are",
"all",
"permitted",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L433-L441 | train |
perkeep/perkeep | pkg/auth/auth.go | TokenOrNone | func TokenOrNone(token string) (AuthMode, error) {
if token == OmitAuthToken {
return None{}, nil
}
return NewTokenAuth(token)
} | go | func TokenOrNone(token string) (AuthMode, error) {
if token == OmitAuthToken {
return None{}, nil
}
return NewTokenAuth(token)
} | [
"func",
"TokenOrNone",
"(",
"token",
"string",
")",
"(",
"AuthMode",
",",
"error",
")",
"{",
"if",
"token",
"==",
"OmitAuthToken",
"{",
"return",
"None",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"NewTokenAuth",
"(",
"token",
")",
"\n",
"}"
] | // TokenOrNone returns a token auth mode if token is not OmitAuthToken, and
// otherwise a None auth mode. | [
"TokenOrNone",
"returns",
"a",
"token",
"auth",
"mode",
"if",
"token",
"is",
"not",
"OmitAuthToken",
"and",
"otherwise",
"a",
"None",
"auth",
"mode",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/auth/auth.go#L470-L475 | train |
perkeep/perkeep | pkg/index/corpus.go | blobMatches | func (srs SignerRefSet) blobMatches(br blob.Ref) bool {
for _, v := range srs {
if br.EqualString(v) {
return true
}
}
return false
} | go | func (srs SignerRefSet) blobMatches(br blob.Ref) bool {
for _, v := range srs {
if br.EqualString(v) {
return true
}
}
return false
} | [
"func",
"(",
"srs",
"SignerRefSet",
")",
"blobMatches",
"(",
"br",
"blob",
".",
"Ref",
")",
"bool",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"srs",
"{",
"if",
"br",
".",
"EqualString",
"(",
"v",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
... | // blobMatches reports whether br is in the set. | [
"blobMatches",
"reports",
"whether",
"br",
"is",
"in",
"the",
"set",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L127-L134 | train |
perkeep/perkeep | pkg/index/corpus.go | cacheAttrClaim | func (m attrValues) cacheAttrClaim(cl *camtypes.Claim) {
switch cl.Type {
case string(schema.SetAttributeClaim):
m[cl.Attr] = []string{cl.Value}
case string(schema.AddAttributeClaim):
m[cl.Attr] = append(m[cl.Attr], cl.Value)
case string(schema.DelAttributeClaim):
if cl.Value == "" {
delete(m, cl.Attr)
} else {
a, i := m[cl.Attr], 0
for _, v := range a {
if v != cl.Value {
a[i] = v
i++
}
}
m[cl.Attr] = a[:i]
}
}
} | go | func (m attrValues) cacheAttrClaim(cl *camtypes.Claim) {
switch cl.Type {
case string(schema.SetAttributeClaim):
m[cl.Attr] = []string{cl.Value}
case string(schema.AddAttributeClaim):
m[cl.Attr] = append(m[cl.Attr], cl.Value)
case string(schema.DelAttributeClaim):
if cl.Value == "" {
delete(m, cl.Attr)
} else {
a, i := m[cl.Attr], 0
for _, v := range a {
if v != cl.Value {
a[i] = v
i++
}
}
m[cl.Attr] = a[:i]
}
}
} | [
"func",
"(",
"m",
"attrValues",
")",
"cacheAttrClaim",
"(",
"cl",
"*",
"camtypes",
".",
"Claim",
")",
"{",
"switch",
"cl",
".",
"Type",
"{",
"case",
"string",
"(",
"schema",
".",
"SetAttributeClaim",
")",
":",
"m",
"[",
"cl",
".",
"Attr",
"]",
"=",
... | // cacheAttrClaim applies attribute changes from cl. | [
"cacheAttrClaim",
"applies",
"attribute",
"changes",
"from",
"cl",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L172-L192 | train |
perkeep/perkeep | pkg/index/corpus.go | restoreInvariants | func (pm *PermanodeMeta) restoreInvariants(signers signerFromBlobrefMap) error {
sort.Sort(camtypes.ClaimPtrsByDate(pm.Claims))
pm.attr = make(attrValues)
pm.signer = make(map[string]attrValues)
for _, cl := range pm.Claims {
if err := pm.appendAttrClaim(cl, signers); err != nil {
return err
}
}
return nil
} | go | func (pm *PermanodeMeta) restoreInvariants(signers signerFromBlobrefMap) error {
sort.Sort(camtypes.ClaimPtrsByDate(pm.Claims))
pm.attr = make(attrValues)
pm.signer = make(map[string]attrValues)
for _, cl := range pm.Claims {
if err := pm.appendAttrClaim(cl, signers); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"pm",
"*",
"PermanodeMeta",
")",
"restoreInvariants",
"(",
"signers",
"signerFromBlobrefMap",
")",
"error",
"{",
"sort",
".",
"Sort",
"(",
"camtypes",
".",
"ClaimPtrsByDate",
"(",
"pm",
".",
"Claims",
")",
")",
"\n",
"pm",
".",
"attr",
"=",
... | // restoreInvariants sorts claims by date and
// recalculates latest attributes. | [
"restoreInvariants",
"sorts",
"claims",
"by",
"date",
"and",
"recalculates",
"latest",
"attributes",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L196-L206 | train |
perkeep/perkeep | pkg/index/corpus.go | fixupLastClaim | func (pm *PermanodeMeta) fixupLastClaim(signers signerFromBlobrefMap) error {
if pm.attr != nil {
n := len(pm.Claims)
if n < 2 || camtypes.ClaimPtrsByDate(pm.Claims).Less(n-2, n-1) {
// already sorted, update Attrs from new Claim
return pm.appendAttrClaim(pm.Claims[n-1], signers)
}
}
return pm.restoreInvariants(signers)
} | go | func (pm *PermanodeMeta) fixupLastClaim(signers signerFromBlobrefMap) error {
if pm.attr != nil {
n := len(pm.Claims)
if n < 2 || camtypes.ClaimPtrsByDate(pm.Claims).Less(n-2, n-1) {
// already sorted, update Attrs from new Claim
return pm.appendAttrClaim(pm.Claims[n-1], signers)
}
}
return pm.restoreInvariants(signers)
} | [
"func",
"(",
"pm",
"*",
"PermanodeMeta",
")",
"fixupLastClaim",
"(",
"signers",
"signerFromBlobrefMap",
")",
"error",
"{",
"if",
"pm",
".",
"attr",
"!=",
"nil",
"{",
"n",
":=",
"len",
"(",
"pm",
".",
"Claims",
")",
"\n",
"if",
"n",
"<",
"2",
"||",
... | // fixupLastClaim fixes invariants on the assumption
// that the all but the last element in Claims are sorted by date
// and the last element is the only one not yet included in Attrs. | [
"fixupLastClaim",
"fixes",
"invariants",
"on",
"the",
"assumption",
"that",
"the",
"all",
"but",
"the",
"last",
"element",
"in",
"Claims",
"are",
"sorted",
"by",
"date",
"and",
"the",
"last",
"element",
"is",
"the",
"only",
"one",
"not",
"yet",
"included",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L211-L220 | train |
perkeep/perkeep | pkg/index/corpus.go | initDeletes | func (c *Corpus) initDeletes(s sorted.KeyValue) (err error) {
it := queryPrefix(s, keyDeleted)
defer closeIterator(it, &err)
for it.Next() {
cl, ok := kvDeleted(it.Key())
if !ok {
return fmt.Errorf("Bogus keyDeleted entry key: want |\"deleted\"|<deleted blobref>|<reverse claimdate>|<deleter claim>|, got %q", it.Key())
}
targetDeletions := append(c.deletes[cl.Target],
deletion{
deleter: cl.BlobRef,
when: cl.Date,
})
sort.Sort(sort.Reverse(byDeletionDate(targetDeletions)))
c.deletes[cl.Target] = targetDeletions
}
return err
} | go | func (c *Corpus) initDeletes(s sorted.KeyValue) (err error) {
it := queryPrefix(s, keyDeleted)
defer closeIterator(it, &err)
for it.Next() {
cl, ok := kvDeleted(it.Key())
if !ok {
return fmt.Errorf("Bogus keyDeleted entry key: want |\"deleted\"|<deleted blobref>|<reverse claimdate>|<deleter claim>|, got %q", it.Key())
}
targetDeletions := append(c.deletes[cl.Target],
deletion{
deleter: cl.BlobRef,
when: cl.Date,
})
sort.Sort(sort.Reverse(byDeletionDate(targetDeletions)))
c.deletes[cl.Target] = targetDeletions
}
return err
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"initDeletes",
"(",
"s",
"sorted",
".",
"KeyValue",
")",
"(",
"err",
"error",
")",
"{",
"it",
":=",
"queryPrefix",
"(",
"s",
",",
"keyDeleted",
")",
"\n",
"defer",
"closeIterator",
"(",
"it",
",",
"&",
"err",
"... | // initDeletes populates the corpus deletes from the delete entries in s. | [
"initDeletes",
"populates",
"the",
"corpus",
"deletes",
"from",
"the",
"delete",
"entries",
"in",
"s",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L528-L545 | train |
perkeep/perkeep | pkg/index/corpus.go | updateDeletes | func (c *Corpus) updateDeletes(deleteClaim schema.Claim) error {
target := c.br(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)
}
del := deletion{
deleter: c.br(deleter.BlobRef()),
when: when,
}
for _, v := range c.deletes[target] {
if v == del {
return nil
}
}
targetDeletions := append(c.deletes[target], del)
sort.Sort(sort.Reverse(byDeletionDate(targetDeletions)))
c.deletes[target] = targetDeletions
return nil
} | go | func (c *Corpus) updateDeletes(deleteClaim schema.Claim) error {
target := c.br(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)
}
del := deletion{
deleter: c.br(deleter.BlobRef()),
when: when,
}
for _, v := range c.deletes[target] {
if v == del {
return nil
}
}
targetDeletions := append(c.deletes[target], del)
sort.Sort(sort.Reverse(byDeletionDate(targetDeletions)))
c.deletes[target] = targetDeletions
return nil
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"updateDeletes",
"(",
"deleteClaim",
"schema",
".",
"Claim",
")",
"error",
"{",
"target",
":=",
"c",
".",
"br",
"(",
"deleteClaim",
".",
"Target",
"(",
")",
")",
"\n",
"deleter",
":=",
"deleteClaim",
".",
"Blob",
... | // updateDeletes updates the corpus deletes with the delete claim deleteClaim.
// deleteClaim is trusted to be a valid delete Claim. | [
"updateDeletes",
"updates",
"the",
"corpus",
"deletes",
"with",
"the",
"delete",
"claim",
"deleteClaim",
".",
"deleteClaim",
"is",
"trusted",
"to",
"be",
"a",
"valid",
"delete",
"Claim",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L644-L664 | train |
perkeep/perkeep | pkg/index/corpus.go | mergeWholeToFileRow | func (c *Corpus) mergeWholeToFileRow(k, v []byte) error {
pair := k[len("wholetofile|"):]
pipe := bytes.IndexByte(pair, '|')
if pipe < 0 {
return fmt.Errorf("bogus row %q = %q", k, v)
}
wholeRef, ok1 := blob.ParseBytes(pair[:pipe])
fileRef, ok2 := blob.ParseBytes(pair[pipe+1:])
if !ok1 || !ok2 {
return fmt.Errorf("bogus row %q = %q", k, v)
}
c.fileWholeRef[fileRef] = wholeRef
if c.building && !c.hasLegacySHA1 {
if bytes.HasPrefix(pair, sha1Prefix) {
c.hasLegacySHA1 = true
}
}
return nil
} | go | func (c *Corpus) mergeWholeToFileRow(k, v []byte) error {
pair := k[len("wholetofile|"):]
pipe := bytes.IndexByte(pair, '|')
if pipe < 0 {
return fmt.Errorf("bogus row %q = %q", k, v)
}
wholeRef, ok1 := blob.ParseBytes(pair[:pipe])
fileRef, ok2 := blob.ParseBytes(pair[pipe+1:])
if !ok1 || !ok2 {
return fmt.Errorf("bogus row %q = %q", k, v)
}
c.fileWholeRef[fileRef] = wholeRef
if c.building && !c.hasLegacySHA1 {
if bytes.HasPrefix(pair, sha1Prefix) {
c.hasLegacySHA1 = true
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"mergeWholeToFileRow",
"(",
"k",
",",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"pair",
":=",
"k",
"[",
"len",
"(",
"\"wholetofile|\"",
")",
":",
"]",
"\n",
"pipe",
":=",
"bytes",
".",
"IndexByte",
"(",
"pair",... | // "wholetofile|sha1-17b53c7c3e664d3613dfdce50ef1f2a09e8f04b5|sha1-fb88f3eab3acfcf3cfc8cd77ae4366f6f975d227" -> "1" | [
"wholetofile|sha1",
"-",
"17b53c7c3e664d3613dfdce50ef1f2a09e8f04b5|sha1",
"-",
"fb88f3eab3acfcf3cfc8cd77ae4366f6f975d227",
"-",
">",
"1"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L854-L872 | train |
perkeep/perkeep | pkg/index/corpus.go | mergeMediaTag | func (c *Corpus) mergeMediaTag(k, v []byte) error {
f := strings.Split(string(k), "|")
if len(f) != 3 {
return fmt.Errorf("unexpected key %q", k)
}
wholeRef, ok := blob.Parse(f[1])
if !ok {
return fmt.Errorf("failed to parse wholeref from key %q", k)
}
tm, ok := c.mediaTags[wholeRef]
if !ok {
tm = make(map[string]string)
c.mediaTags[wholeRef] = tm
}
tm[c.str(f[2])] = c.str(urld(string(v)))
return nil
} | go | func (c *Corpus) mergeMediaTag(k, v []byte) error {
f := strings.Split(string(k), "|")
if len(f) != 3 {
return fmt.Errorf("unexpected key %q", k)
}
wholeRef, ok := blob.Parse(f[1])
if !ok {
return fmt.Errorf("failed to parse wholeref from key %q", k)
}
tm, ok := c.mediaTags[wholeRef]
if !ok {
tm = make(map[string]string)
c.mediaTags[wholeRef] = tm
}
tm[c.str(f[2])] = c.str(urld(string(v)))
return nil
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"mergeMediaTag",
"(",
"k",
",",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"f",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"k",
")",
",",
"\"|\"",
")",
"\n",
"if",
"len",
"(",
"f",
")",
"!=",
"3",
... | // "mediatag|sha1-2b219be9d9691b4f8090e7ee2690098097f59566|album" = "Some+Album+Name" | [
"mediatag|sha1",
"-",
"2b219be9d9691b4f8090e7ee2690098097f59566|album",
"=",
"Some",
"+",
"Album",
"+",
"Name"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L875-L891 | train |
perkeep/perkeep | pkg/index/corpus.go | mergeEXIFGPSRow | func (c *Corpus) mergeEXIFGPSRow(k, v []byte) error {
wholeRef, ok := blob.ParseBytes(k[len("exifgps|"):])
pipe := bytes.IndexByte(v, '|')
if pipe < 0 || !ok {
return fmt.Errorf("bogus row %q = %q", k, v)
}
lat, err := strconv.ParseFloat(string(v[:pipe]), 64)
long, err1 := strconv.ParseFloat(string(v[pipe+1:]), 64)
if err != nil || err1 != nil {
if err != nil {
log.Printf("index: bogus latitude in value of row %q = %q", k, v)
} else {
log.Printf("index: bogus longitude in value of row %q = %q", k, v)
}
return nil
}
c.gps[wholeRef] = latLong{lat, long}
return nil
} | go | func (c *Corpus) mergeEXIFGPSRow(k, v []byte) error {
wholeRef, ok := blob.ParseBytes(k[len("exifgps|"):])
pipe := bytes.IndexByte(v, '|')
if pipe < 0 || !ok {
return fmt.Errorf("bogus row %q = %q", k, v)
}
lat, err := strconv.ParseFloat(string(v[:pipe]), 64)
long, err1 := strconv.ParseFloat(string(v[pipe+1:]), 64)
if err != nil || err1 != nil {
if err != nil {
log.Printf("index: bogus latitude in value of row %q = %q", k, v)
} else {
log.Printf("index: bogus longitude in value of row %q = %q", k, v)
}
return nil
}
c.gps[wholeRef] = latLong{lat, long}
return nil
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"mergeEXIFGPSRow",
"(",
"k",
",",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"wholeRef",
",",
"ok",
":=",
"blob",
".",
"ParseBytes",
"(",
"k",
"[",
"len",
"(",
"\"exifgps|\"",
")",
":",
"]",
")",
"\n",
"pipe",... | // "exifgps|sha1-17b53c7c3e664d3613dfdce50ef1f2a09e8f04b5" -> "-122.39897155555556|37.61952208333334" | [
"exifgps|sha1",
"-",
"17b53c7c3e664d3613dfdce50ef1f2a09e8f04b5",
"-",
">",
"-",
"122",
".",
"39897155555556|37",
".",
"61952208333334"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L894-L912 | train |
perkeep/perkeep | pkg/index/corpus.go | str | func (c *Corpus) str(s string) string {
if s == "" {
return ""
}
if s, ok := c.strs[s]; ok {
return s
}
if c.strs == nil {
c.strs = make(map[string]string)
}
c.strs[s] = s
return s
} | go | func (c *Corpus) str(s string) string {
if s == "" {
return ""
}
if s, ok := c.strs[s]; ok {
return s
}
if c.strs == nil {
c.strs = make(map[string]string)
}
c.strs[s] = s
return s
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"str",
"(",
"s",
"string",
")",
"string",
"{",
"if",
"s",
"==",
"\"\"",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"if",
"s",
",",
"ok",
":=",
"c",
".",
"strs",
"[",
"s",
"]",
";",
"ok",
"{",
"return",
"s"... | // str returns s, interned. | [
"str",
"returns",
"s",
"interned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L933-L945 | train |
perkeep/perkeep | pkg/index/corpus.go | br | func (c *Corpus) br(br blob.Ref) blob.Ref {
if bm, ok := c.blobs[br]; ok {
c.brInterns++
return bm.Ref
}
return br
} | go | func (c *Corpus) br(br blob.Ref) blob.Ref {
if bm, ok := c.blobs[br]; ok {
c.brInterns++
return bm.Ref
}
return br
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"br",
"(",
"br",
"blob",
".",
"Ref",
")",
"blob",
".",
"Ref",
"{",
"if",
"bm",
",",
"ok",
":=",
"c",
".",
"blobs",
"[",
"br",
"]",
";",
"ok",
"{",
"c",
".",
"brInterns",
"++",
"\n",
"return",
"bm",
".",... | // br returns br, interned. | [
"br",
"returns",
"br",
"interned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L948-L954 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumerateBlobMeta | func (c *Corpus) EnumerateBlobMeta(fn func(camtypes.BlobMeta) bool) {
for _, bm := range c.blobs {
if !fn(*bm) {
return
}
}
} | go | func (c *Corpus) EnumerateBlobMeta(fn func(camtypes.BlobMeta) bool) {
for _, bm := range c.blobs {
if !fn(*bm) {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumerateBlobMeta",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
")",
"{",
"for",
"_",
",",
"bm",
":=",
"range",
"c",
".",
"blobs",
"{",
"if",
"!",
"fn",
"(",
"*",
"bm",
")",
"{",
"ret... | // EnumerateBlobMeta calls fn for all known meta blobs in an undefined
// order.
// If fn returns false, iteration ends. | [
"EnumerateBlobMeta",
"calls",
"fn",
"for",
"all",
"known",
"meta",
"blobs",
"in",
"an",
"undefined",
"order",
".",
"If",
"fn",
"returns",
"false",
"iteration",
"ends",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L985-L991 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumeratePermanodesLastModified | func (c *Corpus) EnumeratePermanodesLastModified(fn func(camtypes.BlobMeta) bool) {
c.enumeratePermanodes(fn, c.permanodesByModtime.sorted(true))
} | go | func (c *Corpus) EnumeratePermanodesLastModified(fn func(camtypes.BlobMeta) bool) {
c.enumeratePermanodes(fn, c.permanodesByModtime.sorted(true))
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumeratePermanodesLastModified",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
")",
"{",
"c",
".",
"enumeratePermanodes",
"(",
"fn",
",",
"c",
".",
"permanodesByModtime",
".",
"sorted",
"(",
"true... | // EnumeratePermanodesLastModified calls fn for all permanodes, sorted by most recently modified first.
// Iteration ends prematurely if fn returns false. | [
"EnumeratePermanodesLastModified",
"calls",
"fn",
"for",
"all",
"permanodes",
"sorted",
"by",
"most",
"recently",
"modified",
"first",
".",
"Iteration",
"ends",
"prematurely",
"if",
"fn",
"returns",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1094-L1096 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumeratePermanodesCreated | func (c *Corpus) EnumeratePermanodesCreated(fn func(camtypes.BlobMeta) bool, newestFirst bool) {
c.enumeratePermanodes(fn, c.permanodesByTime.sorted(newestFirst))
} | go | func (c *Corpus) EnumeratePermanodesCreated(fn func(camtypes.BlobMeta) bool, newestFirst bool) {
c.enumeratePermanodes(fn, c.permanodesByTime.sorted(newestFirst))
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumeratePermanodesCreated",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
",",
"newestFirst",
"bool",
")",
"{",
"c",
".",
"enumeratePermanodes",
"(",
"fn",
",",
"c",
".",
"permanodesByTime",
".",
... | // EnumeratePermanodesCreated calls fn for all permanodes.
// They are sorted using the contents creation date if any, the permanode modtime
// otherwise, and in the order specified by newestFirst.
// Iteration ends prematurely if fn returns false. | [
"EnumeratePermanodesCreated",
"calls",
"fn",
"for",
"all",
"permanodes",
".",
"They",
"are",
"sorted",
"using",
"the",
"contents",
"creation",
"date",
"if",
"any",
"the",
"permanode",
"modtime",
"otherwise",
"and",
"in",
"the",
"order",
"specified",
"by",
"newes... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1102-L1104 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumerateSingleBlob | func (c *Corpus) EnumerateSingleBlob(fn func(camtypes.BlobMeta) bool, br blob.Ref) {
if bm := c.blobs[br]; bm != nil {
fn(*bm)
}
} | go | func (c *Corpus) EnumerateSingleBlob(fn func(camtypes.BlobMeta) bool, br blob.Ref) {
if bm := c.blobs[br]; bm != nil {
fn(*bm)
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumerateSingleBlob",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
",",
"br",
"blob",
".",
"Ref",
")",
"{",
"if",
"bm",
":=",
"c",
".",
"blobs",
"[",
"br",
"]",
";",
"bm",
"!=",
"nil",
... | // EnumerateSingleBlob calls fn with br's BlobMeta if br exists in the corpus. | [
"EnumerateSingleBlob",
"calls",
"fn",
"with",
"br",
"s",
"BlobMeta",
"if",
"br",
"exists",
"in",
"the",
"corpus",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1107-L1111 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumeratePermanodesByNodeTypes | func (c *Corpus) EnumeratePermanodesByNodeTypes(fn func(camtypes.BlobMeta) bool, camliNodeTypes []string) {
for _, t := range camliNodeTypes {
set := c.permanodesSetByNodeType[t]
for br := range set {
if bm := c.blobs[br]; bm != nil {
if !fn(*bm) {
return
}
}
}
}
} | go | func (c *Corpus) EnumeratePermanodesByNodeTypes(fn func(camtypes.BlobMeta) bool, camliNodeTypes []string) {
for _, t := range camliNodeTypes {
set := c.permanodesSetByNodeType[t]
for br := range set {
if bm := c.blobs[br]; bm != nil {
if !fn(*bm) {
return
}
}
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumeratePermanodesByNodeTypes",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
",",
"camliNodeTypes",
"[",
"]",
"string",
")",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"camliNodeTypes",
"{",
"se... | // EnumeratePermanodesByNodeTypes enumerates over all permanodes that might
// have one of the provided camliNodeType values, calling fn for each. If fn returns false,
// enumeration ends. | [
"EnumeratePermanodesByNodeTypes",
"enumerates",
"over",
"all",
"permanodes",
"that",
"might",
"have",
"one",
"of",
"the",
"provided",
"camliNodeType",
"values",
"calling",
"fn",
"for",
"each",
".",
"If",
"fn",
"returns",
"false",
"enumeration",
"ends",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1116-L1127 | train |
perkeep/perkeep | pkg/index/corpus.go | PermanodeTime | func (c *Corpus) PermanodeTime(pn blob.Ref) (t time.Time, ok bool) {
// TODO(bradfitz): keep this time property cached on the permanode / files
// TODO(bradfitz): finish implmenting all these
// Priorities:
// -- Permanode explicit "camliTime" property
// -- EXIF GPS time
// -- Exif camera time - this one is actually already in the FileInfo,
// because we use schema.FileTime (which returns the EXIF time, if available)
// to index the time when receiving a file.
// -- File time
// -- File modtime
// -- camliContent claim set time
if t, ok = c.pnTimeAttr(pn, nodeattr.PaymentDueDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.StartDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateCreated); ok {
return
}
var fi camtypes.FileInfo
ccRef, ccTime, ok := c.pnCamliContent(pn)
if ok {
fi, _ = c.files[ccRef]
}
if fi.Time != nil {
return time.Time(*fi.Time), true
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DatePublished); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateModified); ok {
return
}
if fi.ModTime != nil {
return time.Time(*fi.ModTime), true
}
if ok {
return ccTime, true
}
return time.Time{}, false
} | go | func (c *Corpus) PermanodeTime(pn blob.Ref) (t time.Time, ok bool) {
// TODO(bradfitz): keep this time property cached on the permanode / files
// TODO(bradfitz): finish implmenting all these
// Priorities:
// -- Permanode explicit "camliTime" property
// -- EXIF GPS time
// -- Exif camera time - this one is actually already in the FileInfo,
// because we use schema.FileTime (which returns the EXIF time, if available)
// to index the time when receiving a file.
// -- File time
// -- File modtime
// -- camliContent claim set time
if t, ok = c.pnTimeAttr(pn, nodeattr.PaymentDueDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.StartDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateCreated); ok {
return
}
var fi camtypes.FileInfo
ccRef, ccTime, ok := c.pnCamliContent(pn)
if ok {
fi, _ = c.files[ccRef]
}
if fi.Time != nil {
return time.Time(*fi.Time), true
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DatePublished); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateModified); ok {
return
}
if fi.ModTime != nil {
return time.Time(*fi.ModTime), true
}
if ok {
return ccTime, true
}
return time.Time{}, false
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeTime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"if",
"t",
",",
"ok",
"=",
"c",
".",
"pnTimeAttr",
"(",
"pn",
",",
"nodeattr",
".",
"PaymentD... | // PermanodeTime returns the time of the content in permanode. | [
"PermanodeTime",
"returns",
"the",
"time",
"of",
"the",
"content",
"in",
"permanode",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1154-L1199 | train |
perkeep/perkeep | pkg/index/corpus.go | PermanodeAnyTime | func (c *Corpus) PermanodeAnyTime(pn blob.Ref) (t time.Time, ok bool) {
if t, ok := c.PermanodeTime(pn); ok {
return t, ok
}
return c.PermanodeModtime(pn)
} | go | func (c *Corpus) PermanodeAnyTime(pn blob.Ref) (t time.Time, ok bool) {
if t, ok := c.PermanodeTime(pn); ok {
return t, ok
}
return c.PermanodeModtime(pn)
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeAnyTime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"if",
"t",
",",
"ok",
":=",
"c",
".",
"PermanodeTime",
"(",
"pn",
")",
";",
"ok",
"{",
"... | // PermanodeAnyTime returns the time that best qualifies the permanode.
// It tries content-specific times first, the permanode modtime otherwise. | [
"PermanodeAnyTime",
"returns",
"the",
"time",
"that",
"best",
"qualifies",
"the",
"permanode",
".",
"It",
"tries",
"content",
"-",
"specific",
"times",
"first",
"the",
"permanode",
"modtime",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1203-L1208 | train |
perkeep/perkeep | pkg/index/corpus.go | PermanodeModtime | func (c *Corpus) PermanodeModtime(pn blob.Ref) (t time.Time, ok bool) {
pm, ok := c.permanodes[pn]
if !ok {
return
}
// Note: We intentionally don't try to derive any information
// (except the owner, elsewhere) from the permanode blob
// itself. Even though the permanode blob sometimes has the
// GPG signature time, we intentionally ignore it.
for _, cl := range pm.Claims {
if c.IsDeleted(cl.BlobRef) {
continue
}
if cl.Date.After(t) {
t = cl.Date
}
}
return t, !t.IsZero()
} | go | func (c *Corpus) PermanodeModtime(pn blob.Ref) (t time.Time, ok bool) {
pm, ok := c.permanodes[pn]
if !ok {
return
}
// Note: We intentionally don't try to derive any information
// (except the owner, elsewhere) from the permanode blob
// itself. Even though the permanode blob sometimes has the
// GPG signature time, we intentionally ignore it.
for _, cl := range pm.Claims {
if c.IsDeleted(cl.BlobRef) {
continue
}
if cl.Date.After(t) {
t = cl.Date
}
}
return t, !t.IsZero()
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeModtime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"pm",
",",
"ok",
":=",
"c",
".",
"permanodes",
"[",
"pn",
"]",
"\n",
"if",
"!",
"ok",
"{... | // PermanodeModtime returns the latest modification time of the given
// permanode.
//
// The ok value is true only if the permanode is known and has any
// non-deleted claims. A deleted claim is ignored and neither its
// claim date nor the date of the delete claim affect the modtime of
// the permanode. | [
"PermanodeModtime",
"returns",
"the",
"latest",
"modification",
"time",
"of",
"the",
"given",
"permanode",
".",
"The",
"ok",
"value",
"is",
"true",
"only",
"if",
"the",
"permanode",
"is",
"known",
"and",
"has",
"any",
"non",
"-",
"deleted",
"claims",
".",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1241-L1260 | train |
perkeep/perkeep | pkg/index/corpus.go | ForeachClaim | func (c *Corpus) ForeachClaim(permaNode blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
pm, ok := c.permanodes[permaNode]
if !ok {
return
}
for _, cl := range pm.Claims {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | go | func (c *Corpus) ForeachClaim(permaNode blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
pm, ok := c.permanodes[permaNode]
if !ok {
return
}
for _, cl := range pm.Claims {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"ForeachClaim",
"(",
"permaNode",
"blob",
".",
"Ref",
",",
"at",
"time",
".",
"Time",
",",
"fn",
"func",
"(",
"*",
"camtypes",
".",
"Claim",
")",
"bool",
")",
"{",
"pm",
",",
"ok",
":=",
"c",
".",
"permanodes... | // ForeachClaim calls fn for each claim of permaNode.
// If at is zero, all claims are yielded.
// If at is non-zero, claims after that point are skipped.
// If fn returns false, iteration ends.
// Iteration is in an undefined order. | [
"ForeachClaim",
"calls",
"fn",
"for",
"each",
"claim",
"of",
"permaNode",
".",
"If",
"at",
"is",
"zero",
"all",
"claims",
"are",
"yielded",
".",
"If",
"at",
"is",
"non",
"-",
"zero",
"claims",
"after",
"that",
"point",
"are",
"skipped",
".",
"If",
"fn"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1495-L1508 | train |
perkeep/perkeep | pkg/index/corpus.go | ForeachClaimBack | func (c *Corpus) ForeachClaimBack(value blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
for _, cl := range c.claimBack[value] {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | go | func (c *Corpus) ForeachClaimBack(value blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
for _, cl := range c.claimBack[value] {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"ForeachClaimBack",
"(",
"value",
"blob",
".",
"Ref",
",",
"at",
"time",
".",
"Time",
",",
"fn",
"func",
"(",
"*",
"camtypes",
".",
"Claim",
")",
"bool",
")",
"{",
"for",
"_",
",",
"cl",
":=",
"range",
"c",
... | // ForeachClaimBack calls fn for each claim with a value referencing br.
// If at is zero, all claims are yielded.
// If at is non-zero, claims after that point are skipped.
// If fn returns false, iteration ends.
// Iteration is in an undefined order. | [
"ForeachClaimBack",
"calls",
"fn",
"for",
"each",
"claim",
"with",
"a",
"value",
"referencing",
"br",
".",
"If",
"at",
"is",
"zero",
"all",
"claims",
"are",
"yielded",
".",
"If",
"at",
"is",
"non",
"-",
"zero",
"claims",
"after",
"that",
"point",
"are",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1515-L1524 | train |
perkeep/perkeep | pkg/blobserver/local/generation.go | ResetStorageGeneration | func (g Generationer) ResetStorageGeneration() error {
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rand.Reader, 20); err != nil {
return err
}
hex := fmt.Sprintf("%x", buf.Bytes())
buf.Reset()
buf.WriteString(hex)
buf.WriteString(`
This file's random string on the first line is an optimization and
paranoia facility for clients.
If the client sees the same random string in multiple upload sessions,
it assumes that the blobserver still has all the same blobs, and also
it's the same server. This mechanism is not fundamental to
Perkeep's operation: the client could also check each blob before
uploading, or enumerate all blobs from the server too. This is purely
an optimization so clients can mix this value into their "is this file
uploaded?" local cache keys.
If you deleted any blobs (or suspect any were corrupted), it's best to
delete this file so clients can safely re-upload them.
`)
return ioutil.WriteFile(g.generationFile(), buf.Bytes(), 0644)
} | go | func (g Generationer) ResetStorageGeneration() error {
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rand.Reader, 20); err != nil {
return err
}
hex := fmt.Sprintf("%x", buf.Bytes())
buf.Reset()
buf.WriteString(hex)
buf.WriteString(`
This file's random string on the first line is an optimization and
paranoia facility for clients.
If the client sees the same random string in multiple upload sessions,
it assumes that the blobserver still has all the same blobs, and also
it's the same server. This mechanism is not fundamental to
Perkeep's operation: the client could also check each blob before
uploading, or enumerate all blobs from the server too. This is purely
an optimization so clients can mix this value into their "is this file
uploaded?" local cache keys.
If you deleted any blobs (or suspect any were corrupted), it's best to
delete this file so clients can safely re-upload them.
`)
return ioutil.WriteFile(g.generationFile(), buf.Bytes(), 0644)
} | [
"func",
"(",
"g",
"Generationer",
")",
"ResetStorageGeneration",
"(",
")",
"error",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"CopyN",
"(",
"&",
"buf",
",",
"rand",
".",
"Reader",
",",
"20",
")",
";",
... | // ResetStorageGeneration reinitializes the generation by recreating the
// GENERATION.dat file with a new random string | [
"ResetStorageGeneration",
"reinitializes",
"the",
"generation",
"by",
"recreating",
"the",
"GENERATION",
".",
"dat",
"file",
"with",
"a",
"new",
"random",
"string"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/local/generation.go#L78-L105 | train |
perkeep/perkeep | internal/gpgagent/gpgagent.go | NewConn | func NewConn() (*Conn, error) {
sp := strings.SplitN(os.Getenv("GPG_AGENT_INFO"), ":", 3)
if len(sp) == 0 || len(sp[0]) == 0 {
return nil, ErrNoAgent
}
addr := &net.UnixAddr{Net: "unix", Name: sp[0]}
uc, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, err
}
br := bufio.NewReader(uc)
lineb, err := br.ReadSlice('\n')
if err != nil {
return nil, err
}
line := string(lineb)
if !strings.HasPrefix(line, "OK") {
return nil, fmt.Errorf("gpgagent: didn't get OK; got %q", line)
}
return &Conn{uc, br}, nil
} | go | func NewConn() (*Conn, error) {
sp := strings.SplitN(os.Getenv("GPG_AGENT_INFO"), ":", 3)
if len(sp) == 0 || len(sp[0]) == 0 {
return nil, ErrNoAgent
}
addr := &net.UnixAddr{Net: "unix", Name: sp[0]}
uc, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, err
}
br := bufio.NewReader(uc)
lineb, err := br.ReadSlice('\n')
if err != nil {
return nil, err
}
line := string(lineb)
if !strings.HasPrefix(line, "OK") {
return nil, fmt.Errorf("gpgagent: didn't get OK; got %q", line)
}
return &Conn{uc, br}, nil
} | [
"func",
"NewConn",
"(",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"sp",
":=",
"strings",
".",
"SplitN",
"(",
"os",
".",
"Getenv",
"(",
"\"GPG_AGENT_INFO\"",
")",
",",
"\":\"",
",",
"3",
")",
"\n",
"if",
"len",
"(",
"sp",
")",
"==",
"0",
"|... | // NewConn connects to the GPG Agent as described in the
// GPG_AGENT_INFO environment variable. | [
"NewConn",
"connects",
"to",
"the",
"GPG",
"Agent",
"as",
"described",
"in",
"the",
"GPG_AGENT_INFO",
"environment",
"variable",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/gpgagent/gpgagent.go#L49-L69 | train |
perkeep/perkeep | pkg/search/describe.go | Describe | func (sh *Handler) Describe(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
sh.index.RLock()
defer sh.index.RUnlock()
return sh.DescribeLocked(ctx, dr)
} | go | func (sh *Handler) Describe(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
sh.index.RLock()
defer sh.index.RUnlock()
return sh.DescribeLocked(ctx, dr)
} | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"Describe",
"(",
"ctx",
"context",
".",
"Context",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"dres",
"*",
"DescribeResponse",
",",
"err",
"error",
")",
"{",
"sh",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
... | // Describe returns a response for the given describe request. It acquires RLock
// on the Handler's index. | [
"Describe",
"returns",
"a",
"response",
"for",
"the",
"given",
"describe",
"request",
".",
"It",
"acquires",
"RLock",
"on",
"the",
"Handler",
"s",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L58-L63 | train |
perkeep/perkeep | pkg/search/describe.go | DescribeLocked | func (sh *Handler) DescribeLocked(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
if verboseDescribe {
t0 := time.Now()
defer func() {
td := time.Since(t0)
var num int
if dres != nil {
num = len(dres.Meta)
}
log.Printf("Described %d blobs in %v", num, td)
}()
}
sh.initDescribeRequest(dr)
if dr.BlobRef.Valid() {
dr.StartDescribe(ctx, dr.BlobRef, dr.depth())
}
for _, br := range dr.BlobRefs {
dr.StartDescribe(ctx, br, dr.depth())
}
if err := dr.expandRules(ctx); err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
return &DescribeResponse{metaMap}, nil
} | go | func (sh *Handler) DescribeLocked(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
if verboseDescribe {
t0 := time.Now()
defer func() {
td := time.Since(t0)
var num int
if dres != nil {
num = len(dres.Meta)
}
log.Printf("Described %d blobs in %v", num, td)
}()
}
sh.initDescribeRequest(dr)
if dr.BlobRef.Valid() {
dr.StartDescribe(ctx, dr.BlobRef, dr.depth())
}
for _, br := range dr.BlobRefs {
dr.StartDescribe(ctx, br, dr.depth())
}
if err := dr.expandRules(ctx); err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
return &DescribeResponse{metaMap}, nil
} | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"DescribeLocked",
"(",
"ctx",
"context",
".",
"Context",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"dres",
"*",
"DescribeResponse",
",",
"err",
"error",
")",
"{",
"if",
"verboseDescribe",
"{",
"t0",
":=",
"time"... | // DescribeLocked returns a response for the given describe request. It is the
// caller's responsibility to lock the search handler's index. | [
"DescribeLocked",
"returns",
"a",
"response",
"for",
"the",
"given",
"describe",
"request",
".",
"It",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"lock",
"the",
"search",
"handler",
"s",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L67-L94 | train |
perkeep/perkeep | pkg/search/describe.go | flatRules | func (dr *DescribeRequest) flatRules() []*DescribeRule {
if dr.flatRuleCache == nil {
dr.flatRuleCache = make([]*DescribeRule, 0)
for _, rule := range dr.Rules {
rule.appendToFlatCache(dr)
}
}
return dr.flatRuleCache
} | go | func (dr *DescribeRequest) flatRules() []*DescribeRule {
if dr.flatRuleCache == nil {
dr.flatRuleCache = make([]*DescribeRule, 0)
for _, rule := range dr.Rules {
rule.appendToFlatCache(dr)
}
}
return dr.flatRuleCache
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"flatRules",
"(",
")",
"[",
"]",
"*",
"DescribeRule",
"{",
"if",
"dr",
".",
"flatRuleCache",
"==",
"nil",
"{",
"dr",
".",
"flatRuleCache",
"=",
"make",
"(",
"[",
"]",
"*",
"DescribeRule",
",",
"0",
")",... | // Requires dr.mu is held | [
"Requires",
"dr",
".",
"mu",
"is",
"held"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L146-L154 | train |
perkeep/perkeep | pkg/search/describe.go | URLSuffix | func (dr *DescribeRequest) URLSuffix() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camli/search/describe?depth=%d&maxdirchildren=%d",
dr.depth(), dr.maxDirChildren())
for _, br := range dr.BlobRefs {
buf.WriteString("&blobref=")
buf.WriteString(br.String())
}
if len(dr.BlobRefs) == 0 && dr.BlobRef.Valid() {
buf.WriteString("&blobref=")
buf.WriteString(dr.BlobRef.String())
}
if !dr.At.IsAnyZero() {
buf.WriteString("&at=")
buf.WriteString(dr.At.String())
}
return buf.String()
} | go | func (dr *DescribeRequest) URLSuffix() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camli/search/describe?depth=%d&maxdirchildren=%d",
dr.depth(), dr.maxDirChildren())
for _, br := range dr.BlobRefs {
buf.WriteString("&blobref=")
buf.WriteString(br.String())
}
if len(dr.BlobRefs) == 0 && dr.BlobRef.Valid() {
buf.WriteString("&blobref=")
buf.WriteString(dr.BlobRef.String())
}
if !dr.At.IsAnyZero() {
buf.WriteString("&at=")
buf.WriteString(dr.At.String())
}
return buf.String()
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"URLSuffix",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"camli/search/describe?depth=%d&maxdirchildren=%d\"",
",",
"dr",
".",
"depth",
"(... | // URLSuffix returns the URL suffix for GET requests.
// This is deprecated. | [
"URLSuffix",
"returns",
"the",
"URL",
"suffix",
"for",
"GET",
"requests",
".",
"This",
"is",
"deprecated",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L279-L296 | train |
perkeep/perkeep | pkg/search/describe.go | PermanodeFile | func (b *DescribedBlob) PermanodeFile() (path []blob.Ref, fi *camtypes.FileInfo, ok bool) {
if b == nil || b.Permanode == nil {
return
}
if contentRef := b.Permanode.Attr.Get("camliContent"); contentRef != "" {
if cdes := b.Request.DescribedBlobStr(contentRef); cdes != nil && cdes.File != nil {
return []blob.Ref{b.BlobRef, cdes.BlobRef}, cdes.File, true
}
}
return
} | go | func (b *DescribedBlob) PermanodeFile() (path []blob.Ref, fi *camtypes.FileInfo, ok bool) {
if b == nil || b.Permanode == nil {
return
}
if contentRef := b.Permanode.Attr.Get("camliContent"); contentRef != "" {
if cdes := b.Request.DescribedBlobStr(contentRef); cdes != nil && cdes.File != nil {
return []blob.Ref{b.BlobRef, cdes.BlobRef}, cdes.File, true
}
}
return
} | [
"func",
"(",
"b",
"*",
"DescribedBlob",
")",
"PermanodeFile",
"(",
")",
"(",
"path",
"[",
"]",
"blob",
".",
"Ref",
",",
"fi",
"*",
"camtypes",
".",
"FileInfo",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"Permanode",
"=="... | // PermanodeFile returns in path the blobref of the described permanode
// and the blobref of its File camliContent.
// If b isn't a permanode, or doesn't have a camliContent that
// is a file blob, ok is false. | [
"PermanodeFile",
"returns",
"in",
"path",
"the",
"blobref",
"of",
"the",
"described",
"permanode",
"and",
"the",
"blobref",
"of",
"its",
"File",
"camliContent",
".",
"If",
"b",
"isn",
"t",
"a",
"permanode",
"or",
"doesn",
"t",
"have",
"a",
"camliContent",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L339-L349 | train |
perkeep/perkeep | pkg/search/describe.go | DescribedBlobStr | func (dr *DescribeRequest) DescribedBlobStr(blobstr string) *DescribedBlob {
if dr == nil {
return nil
}
dr.mu.Lock()
defer dr.mu.Unlock()
return dr.m[blobstr]
} | go | func (dr *DescribeRequest) DescribedBlobStr(blobstr string) *DescribedBlob {
if dr == nil {
return nil
}
dr.mu.Lock()
defer dr.mu.Unlock()
return dr.m[blobstr]
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"DescribedBlobStr",
"(",
"blobstr",
"string",
")",
"*",
"DescribedBlob",
"{",
"if",
"dr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"dr",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dr",... | // DescribedBlobStr when given a blobref string returns a Description
// or nil. dr may be nil itself. | [
"DescribedBlobStr",
"when",
"given",
"a",
"blobref",
"string",
"returns",
"a",
"Description",
"or",
"nil",
".",
"dr",
"may",
"be",
"nil",
"itself",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L452-L459 | train |
perkeep/perkeep | pkg/search/describe.go | peerBlob | func (b *DescribedBlob) peerBlob(br blob.Ref) *DescribedBlob {
if peer, ok := b.Request.m[br.String()]; ok {
return peer
}
return &DescribedBlob{Request: b.Request, BlobRef: br, Stub: true}
} | go | func (b *DescribedBlob) peerBlob(br blob.Ref) *DescribedBlob {
if peer, ok := b.Request.m[br.String()]; ok {
return peer
}
return &DescribedBlob{Request: b.Request, BlobRef: br, Stub: true}
} | [
"func",
"(",
"b",
"*",
"DescribedBlob",
")",
"peerBlob",
"(",
"br",
"blob",
".",
"Ref",
")",
"*",
"DescribedBlob",
"{",
"if",
"peer",
",",
"ok",
":=",
"b",
".",
"Request",
".",
"m",
"[",
"br",
".",
"String",
"(",
")",
"]",
";",
"ok",
"{",
"retu... | // version of PeerBlob when b.Request.mu is already held. | [
"version",
"of",
"PeerBlob",
"when",
"b",
".",
"Request",
".",
"mu",
"is",
"already",
"held",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L478-L483 | train |
perkeep/perkeep | pkg/search/describe.go | NewDescribeRequest | func (sh *Handler) NewDescribeRequest() *DescribeRequest {
dr := new(DescribeRequest)
sh.initDescribeRequest(dr)
return dr
} | go | func (sh *Handler) NewDescribeRequest() *DescribeRequest {
dr := new(DescribeRequest)
sh.initDescribeRequest(dr)
return dr
} | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"NewDescribeRequest",
"(",
")",
"*",
"DescribeRequest",
"{",
"dr",
":=",
"new",
"(",
"DescribeRequest",
")",
"\n",
"sh",
".",
"initDescribeRequest",
"(",
"dr",
")",
"\n",
"return",
"dr",
"\n",
"}"
] | // NewDescribeRequest returns a new DescribeRequest holding the state
// of blobs and their summarized descriptions. Use DescribeBlob
// one or more times before calling Result. | [
"NewDescribeRequest",
"returns",
"a",
"new",
"DescribeRequest",
"holding",
"the",
"state",
"of",
"blobs",
"and",
"their",
"summarized",
"descriptions",
".",
"Use",
"DescribeBlob",
"one",
"or",
"more",
"times",
"before",
"calling",
"Result",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L507-L511 | train |
perkeep/perkeep | pkg/search/describe.go | StartDescribe | func (dr *DescribeRequest) StartDescribe(ctx context.Context, br blob.Ref, depth int) {
if depth <= 0 {
return
}
dr.mu.Lock()
defer dr.mu.Unlock()
if dr.blobDesLock == nil {
dr.blobDesLock = make(map[blob.Ref]*sync.Mutex)
}
desBlobMu, ok := dr.blobDesLock[br]
if !ok {
desBlobMu = new(sync.Mutex)
dr.blobDesLock[br] = desBlobMu
}
if dr.started == nil {
dr.started = make(map[blobrefAndDepth]bool)
}
key := blobrefAndDepth{br, depth}
if dr.started[key] {
return
}
dr.started[key] = true
dr.wg.Add(1)
go func() {
defer dr.wg.Done()
desBlobMu.Lock()
defer desBlobMu.Unlock()
dr.doDescribe(ctx, br, depth)
}()
} | go | func (dr *DescribeRequest) StartDescribe(ctx context.Context, br blob.Ref, depth int) {
if depth <= 0 {
return
}
dr.mu.Lock()
defer dr.mu.Unlock()
if dr.blobDesLock == nil {
dr.blobDesLock = make(map[blob.Ref]*sync.Mutex)
}
desBlobMu, ok := dr.blobDesLock[br]
if !ok {
desBlobMu = new(sync.Mutex)
dr.blobDesLock[br] = desBlobMu
}
if dr.started == nil {
dr.started = make(map[blobrefAndDepth]bool)
}
key := blobrefAndDepth{br, depth}
if dr.started[key] {
return
}
dr.started[key] = true
dr.wg.Add(1)
go func() {
defer dr.wg.Done()
desBlobMu.Lock()
defer desBlobMu.Unlock()
dr.doDescribe(ctx, br, depth)
}()
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"StartDescribe",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"depth",
"int",
")",
"{",
"if",
"depth",
"<=",
"0",
"{",
"return",
"\n",
"}",
"\n",
"dr",
".",
"mu",
".",
... | // StartDescribe starts a lookup of br, down to the provided depth.
// It returns immediately. One should call Result to wait for the description to
// be completed. | [
"StartDescribe",
"starts",
"a",
"lookup",
"of",
"br",
"down",
"to",
"the",
"provided",
"depth",
".",
"It",
"returns",
"immediately",
".",
"One",
"should",
"call",
"Result",
"to",
"wait",
"for",
"the",
"description",
"to",
"be",
"completed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L597-L626 | train |
perkeep/perkeep | pkg/search/describe.go | newMatches | func (r *DescribeRule) newMatches(br blob.Ref, dr *DescribeRequest) (brs []blob.Ref) {
if r.IfResultRoot {
if !dr.blobInitiallyRequested(br) {
return nil
}
}
if r.parentRule != nil {
if _, ok := dr.resFromRule[r.parentRule][br]; !ok {
return nil
}
}
db, ok := dr.m[br.String()]
if !ok || db.Permanode == nil {
return nil
}
if t := r.IfCamliNodeType; t != "" {
gotType := db.Permanode.Attr.Get("camliNodeType")
if gotType != t {
return nil
}
}
for attr, vv := range db.Permanode.Attr {
matches := false
for _, matchAttr := range r.Attrs {
if attr == matchAttr {
matches = true
break
}
if strings.HasSuffix(matchAttr, "*") && strings.HasPrefix(attr, strings.TrimSuffix(matchAttr, "*")) {
matches = true
break
}
}
if !matches {
continue
}
for _, v := range vv {
if br, ok := blob.Parse(v); ok {
brs = append(brs, br)
}
}
}
return brs
} | go | func (r *DescribeRule) newMatches(br blob.Ref, dr *DescribeRequest) (brs []blob.Ref) {
if r.IfResultRoot {
if !dr.blobInitiallyRequested(br) {
return nil
}
}
if r.parentRule != nil {
if _, ok := dr.resFromRule[r.parentRule][br]; !ok {
return nil
}
}
db, ok := dr.m[br.String()]
if !ok || db.Permanode == nil {
return nil
}
if t := r.IfCamliNodeType; t != "" {
gotType := db.Permanode.Attr.Get("camliNodeType")
if gotType != t {
return nil
}
}
for attr, vv := range db.Permanode.Attr {
matches := false
for _, matchAttr := range r.Attrs {
if attr == matchAttr {
matches = true
break
}
if strings.HasSuffix(matchAttr, "*") && strings.HasPrefix(attr, strings.TrimSuffix(matchAttr, "*")) {
matches = true
break
}
}
if !matches {
continue
}
for _, v := range vv {
if br, ok := blob.Parse(v); ok {
brs = append(brs, br)
}
}
}
return brs
} | [
"func",
"(",
"r",
"*",
"DescribeRule",
")",
"newMatches",
"(",
"br",
"blob",
".",
"Ref",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"brs",
"[",
"]",
"blob",
".",
"Ref",
")",
"{",
"if",
"r",
".",
"IfResultRoot",
"{",
"if",
"!",
"dr",
".",
"blobI... | // requires dr.mu be held. | [
"requires",
"dr",
".",
"mu",
"be",
"held",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L629-L672 | train |
perkeep/perkeep | pkg/search/describe.go | noteResultFromRule | func (dr *DescribeRequest) noteResultFromRule(rule *DescribeRule, br blob.Ref) {
if dr.resFromRule == nil {
dr.resFromRule = make(map[*DescribeRule]map[blob.Ref]bool)
}
m, ok := dr.resFromRule[rule]
if !ok {
m = make(map[blob.Ref]bool)
dr.resFromRule[rule] = m
}
m[br] = true
} | go | func (dr *DescribeRequest) noteResultFromRule(rule *DescribeRule, br blob.Ref) {
if dr.resFromRule == nil {
dr.resFromRule = make(map[*DescribeRule]map[blob.Ref]bool)
}
m, ok := dr.resFromRule[rule]
if !ok {
m = make(map[blob.Ref]bool)
dr.resFromRule[rule] = m
}
m[br] = true
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"noteResultFromRule",
"(",
"rule",
"*",
"DescribeRule",
",",
"br",
"blob",
".",
"Ref",
")",
"{",
"if",
"dr",
".",
"resFromRule",
"==",
"nil",
"{",
"dr",
".",
"resFromRule",
"=",
"make",
"(",
"map",
"[",
... | // dr.mu just be locked. | [
"dr",
".",
"mu",
"just",
"be",
"locked",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L675-L685 | train |
perkeep/perkeep | clients/web/embed/closure/updatelibrary.go | fileList | func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closure", "goog", "deps.js")
f, err := os.Open(closureDepsFile)
if err != nil {
return nil, err
}
defer f.Close()
allClosureDeps, err := closure.DeepParseDeps(f)
if err != nil {
return nil, err
}
uiDeps, err := closure.GenDeps(http.Dir(uiDir))
if err != nil {
return nil, err
}
_, requ, err := closure.ParseDeps(bytes.NewReader(uiDeps))
if err != nil {
return nil, err
}
nameDone := make(map[string]bool)
jsfilesDone := make(map[string]bool)
for _, deps := range requ {
for _, dep := range deps {
if _, ok := nameDone[dep]; ok {
continue
}
jsfiles := allClosureDeps[dep]
for _, filename := range jsfiles {
if _, ok := jsfilesDone[filename]; ok {
continue
}
jsfilesDone[filename] = true
}
nameDone[dep] = true
}
}
jsfiles := []string{
"AUTHORS",
"LICENSE",
"README.md",
filepath.Join("closure", "goog", "base.js"),
filepath.Join("closure", "goog", "bootstrap", "nodejs.js"),
filepath.Join("closure", "goog", "bootstrap", "webworkers.js"),
filepath.Join("closure", "goog", "css", "common.css"),
filepath.Join("closure", "goog", "css", "toolbar.css"),
filepath.Join("closure", "goog", "deps.js"),
}
prefix := filepath.Join("closure", "goog")
for k := range jsfilesDone {
jsfiles = append(jsfiles, filepath.Join(prefix, k))
}
sort.Strings(jsfiles)
return jsfiles, nil
} | go | func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closure", "goog", "deps.js")
f, err := os.Open(closureDepsFile)
if err != nil {
return nil, err
}
defer f.Close()
allClosureDeps, err := closure.DeepParseDeps(f)
if err != nil {
return nil, err
}
uiDeps, err := closure.GenDeps(http.Dir(uiDir))
if err != nil {
return nil, err
}
_, requ, err := closure.ParseDeps(bytes.NewReader(uiDeps))
if err != nil {
return nil, err
}
nameDone := make(map[string]bool)
jsfilesDone := make(map[string]bool)
for _, deps := range requ {
for _, dep := range deps {
if _, ok := nameDone[dep]; ok {
continue
}
jsfiles := allClosureDeps[dep]
for _, filename := range jsfiles {
if _, ok := jsfilesDone[filename]; ok {
continue
}
jsfilesDone[filename] = true
}
nameDone[dep] = true
}
}
jsfiles := []string{
"AUTHORS",
"LICENSE",
"README.md",
filepath.Join("closure", "goog", "base.js"),
filepath.Join("closure", "goog", "bootstrap", "nodejs.js"),
filepath.Join("closure", "goog", "bootstrap", "webworkers.js"),
filepath.Join("closure", "goog", "css", "common.css"),
filepath.Join("closure", "goog", "css", "toolbar.css"),
filepath.Join("closure", "goog", "deps.js"),
}
prefix := filepath.Join("closure", "goog")
for k := range jsfilesDone {
jsfiles = append(jsfiles, filepath.Join(prefix, k))
}
sort.Strings(jsfiles)
return jsfiles, nil
} | [
"func",
"fileList",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"camliRootPath",
",",
"err",
":=",
"osutil",
".",
"GoPackagePath",
"(",
"\"perkeep.org\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"\"Package per... | // fileList parses deps.js from the closure repo, as well as the similar
// dependencies generated for the UI js files, and compiles the list of
// js files from the closure lib required for the UI. | [
"fileList",
"parses",
"deps",
".",
"js",
"from",
"the",
"closure",
"repo",
"as",
"well",
"as",
"the",
"similar",
"dependencies",
"generated",
"for",
"the",
"UI",
"js",
"files",
"and",
"compiles",
"the",
"list",
"of",
"js",
"files",
"from",
"the",
"closure"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/clients/web/embed/closure/updatelibrary.go#L65-L126 | train |
perkeep/perkeep | clients/web/embed/closure/updatelibrary.go | run | func (c *command) run() []byte {
cmd := exec.Command(c.program, c.args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
out := stdout.Bytes()
if err != nil {
log.Fatalf("Could not run %v: %v: %v: %v", c, err, string(out), stderr.String())
}
return out
} | go | func (c *command) run() []byte {
cmd := exec.Command(c.program, c.args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
out := stdout.Bytes()
if err != nil {
log.Fatalf("Could not run %v: %v: %v: %v", c, err, string(out), stderr.String())
}
return out
} | [
"func",
"(",
"c",
"*",
"command",
")",
"run",
"(",
")",
"[",
"]",
"byte",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"c",
".",
"program",
",",
"c",
".",
"args",
"...",
")",
"\n",
"var",
"stdout",
",",
"stderr",
"bytes",
".",
"Buffer",
"\n",... | // run runs the command and returns the output if it succeeds.
// On error, the process dies. | [
"run",
"runs",
"the",
"command",
"and",
"returns",
"the",
"output",
"if",
"it",
"succeeds",
".",
"On",
"error",
"the",
"process",
"dies",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/clients/web/embed/closure/updatelibrary.go#L143-L154 | train |
perkeep/perkeep | pkg/sorted/mongo/mongokv.go | Delete | func (kv *keyValue) Delete(key string) error {
kv.mu.Lock()
defer kv.mu.Unlock()
err := kv.db.Remove(&bson.M{mgoKey: key})
if err == mgo.ErrNotFound {
return nil
}
return err
} | go | func (kv *keyValue) Delete(key string) error {
kv.mu.Lock()
defer kv.mu.Unlock()
err := kv.db.Remove(&bson.M{mgoKey: key})
if err == mgo.ErrNotFound {
return nil
}
return err
} | [
"func",
"(",
"kv",
"*",
"keyValue",
")",
"Delete",
"(",
"key",
"string",
")",
"error",
"{",
"kv",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kv",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"kv",
".",
"db",
".",
"Remove",
"(... | // Delete removes the document with the matching key. | [
"Delete",
"removes",
"the",
"document",
"with",
"the",
"matching",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/mongo/mongokv.go#L159-L167 | train |
perkeep/perkeep | pkg/sorted/mongo/mongokv.go | Wipe | func (kv *keyValue) Wipe() error {
kv.mu.Lock()
defer kv.mu.Unlock()
_, err := kv.db.RemoveAll(nil)
return err
} | go | func (kv *keyValue) Wipe() error {
kv.mu.Lock()
defer kv.mu.Unlock()
_, err := kv.db.RemoveAll(nil)
return err
} | [
"func",
"(",
"kv",
"*",
"keyValue",
")",
"Wipe",
"(",
")",
"error",
"{",
"kv",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kv",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"kv",
".",
"db",
".",
"RemoveAll",
"(",
"... | // Wipe removes all documents from the collection. | [
"Wipe",
"removes",
"all",
"documents",
"from",
"the",
"collection",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/mongo/mongokv.go#L170-L175 | train |
perkeep/perkeep | pkg/sorted/mongo/mongokv.go | Ping | func Ping(host string, timeout time.Duration) bool {
return (&instance{server: host}).ping(timeout)
} | go | func Ping(host string, timeout time.Duration) bool {
return (&instance{server: host}).ping(timeout)
} | [
"func",
"Ping",
"(",
"host",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"bool",
"{",
"return",
"(",
"&",
"instance",
"{",
"server",
":",
"host",
"}",
")",
".",
"ping",
"(",
"timeout",
")",
"\n",
"}"
] | // Ping tests if MongoDB on host can be dialed. | [
"Ping",
"tests",
"if",
"MongoDB",
"on",
"host",
"can",
"be",
"dialed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/mongo/mongokv.go#L217-L219 | train |
perkeep/perkeep | pkg/search/handler.go | SendStatusUpdate | func (h *Handler) SendStatusUpdate(status json.RawMessage) {
h.wsHub.statusUpdate <- status
} | go | func (h *Handler) SendStatusUpdate(status json.RawMessage) {
h.wsHub.statusUpdate <- status
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"SendStatusUpdate",
"(",
"status",
"json",
".",
"RawMessage",
")",
"{",
"h",
".",
"wsHub",
".",
"statusUpdate",
"<-",
"status",
"\n",
"}"
] | // SendStatusUpdate sends a JSON status map to any connected WebSocket clients. | [
"SendStatusUpdate",
"sends",
"a",
"JSON",
"status",
"map",
"to",
"any",
"connected",
"WebSocket",
"clients",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L137-L139 | train |
perkeep/perkeep | pkg/search/handler.go | HasLegacySHA1 | func (h *Handler) HasLegacySHA1() bool {
idx, ok := h.index.(*index.Index)
if !ok {
log.Printf("Cannot guess for legacy SHA1 because we don't have an *index.Index")
return false
}
ok, err := idx.HasLegacySHA1()
if err != nil {
log.Printf("Cannot guess for legacy SHA1: %v", err)
return false
}
return ok
} | go | func (h *Handler) HasLegacySHA1() bool {
idx, ok := h.index.(*index.Index)
if !ok {
log.Printf("Cannot guess for legacy SHA1 because we don't have an *index.Index")
return false
}
ok, err := idx.HasLegacySHA1()
if err != nil {
log.Printf("Cannot guess for legacy SHA1: %v", err)
return false
}
return ok
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"HasLegacySHA1",
"(",
")",
"bool",
"{",
"idx",
",",
"ok",
":=",
"h",
".",
"index",
".",
"(",
"*",
"index",
".",
"Index",
")",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"Printf",
"(",
"\"Cannot guess for legacy S... | // HasLegacySHA1 reports whether the server has legacy SHA-1 blobs indexed. | [
"HasLegacySHA1",
"reports",
"whether",
"the",
"server",
"has",
"legacy",
"SHA",
"-",
"1",
"blobs",
"indexed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L220-L232 | train |
perkeep/perkeep | pkg/search/handler.go | GetRecentPermanodes | func (h *Handler) GetRecentPermanodes(ctx context.Context, req *RecentRequest) (*RecentResponse, error) {
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan camtypes.RecentPermanode)
errch := make(chan error, 1)
before := time.Now()
if !req.Before.IsZero() {
before = req.Before
}
go func() {
// TODO(mpl): change index funcs to take signer keyID. dont care for now, just
// fixing the essential search and describe ones.
errch <- h.index.GetRecentPermanodes(ctx, ch, h.owner.BlobRef(), req.n(), before)
}()
dr := h.NewDescribeRequest()
var recent []*RecentItem
for res := range ch {
dr.StartDescribe(ctx, res.Permanode, 2)
recent = append(recent, &RecentItem{
BlobRef: res.Permanode,
Owner: res.Signer,
ModTime: types.Time3339(res.LastModTime),
})
testHookBug121() // http://perkeep.org/issue/121
}
if err := <-errch; err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &RecentResponse{
Recent: recent,
Meta: metaMap,
}
return res, nil
} | go | func (h *Handler) GetRecentPermanodes(ctx context.Context, req *RecentRequest) (*RecentResponse, error) {
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan camtypes.RecentPermanode)
errch := make(chan error, 1)
before := time.Now()
if !req.Before.IsZero() {
before = req.Before
}
go func() {
// TODO(mpl): change index funcs to take signer keyID. dont care for now, just
// fixing the essential search and describe ones.
errch <- h.index.GetRecentPermanodes(ctx, ch, h.owner.BlobRef(), req.n(), before)
}()
dr := h.NewDescribeRequest()
var recent []*RecentItem
for res := range ch {
dr.StartDescribe(ctx, res.Permanode, 2)
recent = append(recent, &RecentItem{
BlobRef: res.Permanode,
Owner: res.Signer,
ModTime: types.Time3339(res.LastModTime),
})
testHookBug121() // http://perkeep.org/issue/121
}
if err := <-errch; err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &RecentResponse{
Recent: recent,
Meta: metaMap,
}
return res, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetRecentPermanodes",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"RecentRequest",
")",
"(",
"*",
"RecentResponse",
",",
"error",
")",
"{",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
... | // GetRecentPermanodes returns recently-modified permanodes. | [
"GetRecentPermanodes",
"returns",
"recently",
"-",
"modified",
"permanodes",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L514-L557 | train |
perkeep/perkeep | pkg/search/handler.go | GetPermanodesWithAttr | func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
errch <- h.index.SearchPermanodesWithAttr(ctx, ch,
&camtypes.PermanodeByAttrRequest{
Attribute: req.Attr,
Query: req.Value,
Signer: signer,
FuzzyMatch: req.Fuzzy,
MaxResults: req.N,
At: req.At,
})
}()
dr := h.NewDescribeRequest()
var withAttr []*WithAttrItem
for res := range ch {
dr.StartDescribe(ctx, res, 2)
withAttr = append(withAttr, &WithAttrItem{
Permanode: res,
})
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
if err := <-errch; err != nil {
return nil, err
}
res := &WithAttrResponse{
WithAttr: withAttr,
Meta: metaMap,
}
return res, nil
} | go | func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
errch <- h.index.SearchPermanodesWithAttr(ctx, ch,
&camtypes.PermanodeByAttrRequest{
Attribute: req.Attr,
Query: req.Value,
Signer: signer,
FuzzyMatch: req.Fuzzy,
MaxResults: req.N,
At: req.At,
})
}()
dr := h.NewDescribeRequest()
var withAttr []*WithAttrItem
for res := range ch {
dr.StartDescribe(ctx, res, 2)
withAttr = append(withAttr, &WithAttrItem{
Permanode: res,
})
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
if err := <-errch; err != nil {
return nil, err
}
res := &WithAttrResponse{
WithAttr: withAttr,
Meta: metaMap,
}
return res, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetPermanodesWithAttr",
"(",
"req",
"*",
"WithAttrRequest",
")",
"(",
"*",
"WithAttrResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"h",
".",
"index",
".",
"RLock",
"(",
... | // GetPermanodesWithAttr returns permanodes with attribute req.Attr
// having the req.Value as a value.
// See WithAttrRequest for more details about the query. | [
"GetPermanodesWithAttr",
"returns",
"permanodes",
"with",
"attribute",
"req",
".",
"Attr",
"having",
"the",
"req",
".",
"Value",
"as",
"a",
"value",
".",
"See",
"WithAttrRequest",
"for",
"more",
"details",
"about",
"the",
"query",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L574-L622 | train |
perkeep/perkeep | pkg/search/handler.go | GetClaims | func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.Permanode, h.owner.KeyID(), req.AttrFilter)
if err != nil {
return nil, fmt.Errorf("Error getting claims of %s: %v", req.Permanode.String(), err)
}
sort.Sort(camtypes.ClaimsByDate(claims))
var jclaims []*ClaimsItem
for _, claim := range claims {
jclaim := &ClaimsItem{
BlobRef: claim.BlobRef,
Signer: claim.Signer,
Permanode: claim.Permanode,
Date: types.Time3339(claim.Date),
Type: claim.Type,
Attr: claim.Attr,
Value: claim.Value,
}
jclaims = append(jclaims, jclaim)
}
res := &ClaimsResponse{
Claims: jclaims,
}
return res, nil
} | go | func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.Permanode, h.owner.KeyID(), req.AttrFilter)
if err != nil {
return nil, fmt.Errorf("Error getting claims of %s: %v", req.Permanode.String(), err)
}
sort.Sort(camtypes.ClaimsByDate(claims))
var jclaims []*ClaimsItem
for _, claim := range claims {
jclaim := &ClaimsItem{
BlobRef: claim.BlobRef,
Signer: claim.Signer,
Permanode: claim.Permanode,
Date: types.Time3339(claim.Date),
Type: claim.Type,
Attr: claim.Attr,
Value: claim.Value,
}
jclaims = append(jclaims, jclaim)
}
res := &ClaimsResponse{
Claims: jclaims,
}
return res, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetClaims",
"(",
"req",
"*",
"ClaimsRequest",
")",
"(",
"*",
"ClaimsResponse",
",",
"error",
")",
"{",
"if",
"!",
"req",
".",
"Permanode",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"Ne... | // GetClaims returns the claims on req.Permanode signed by h.owner. | [
"GetClaims",
"returns",
"the",
"claims",
"on",
"req",
".",
"Permanode",
"signed",
"by",
"h",
".",
"owner",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L641-L673 | train |
perkeep/perkeep | pkg/search/handler.go | EdgesTo | func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
edge *EdgeItem // or nil
err error
}
resc := make(chan edgeOrError)
verify := func(edge *camtypes.Edge) {
db, err := h.NewDescribeRequest().DescribeSync(ctx, edge.From)
if err != nil {
resc <- edgeOrError{err: err}
return
}
found := false
if db.Permanode != nil {
for attr, vv := range db.Permanode.Attr {
if index.IsBlobReferenceAttribute(attr) {
for _, v := range vv {
if v == toRefStr {
found = true
}
}
}
}
}
var ei *EdgeItem
if found {
ei = &EdgeItem{
From: edge.From,
FromType: "permanode",
}
}
resc <- edgeOrError{edge: ei}
}
verifying := 0
for _, edge := range edges {
if edge.FromType == "permanode" {
verifying++
go verify(edge)
continue
}
ei := &EdgeItem{
From: edge.From,
FromType: edge.FromType,
}
edgeItems = append(edgeItems, ei)
}
for i := 0; i < verifying; i++ {
res := <-resc
if res.err != nil {
return nil, res.err
}
if res.edge != nil {
edgeItems = append(edgeItems, res.edge)
}
}
return &EdgesResponse{
ToRef: toRef,
EdgesTo: edgeItems,
}, nil
} | go | func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
edge *EdgeItem // or nil
err error
}
resc := make(chan edgeOrError)
verify := func(edge *camtypes.Edge) {
db, err := h.NewDescribeRequest().DescribeSync(ctx, edge.From)
if err != nil {
resc <- edgeOrError{err: err}
return
}
found := false
if db.Permanode != nil {
for attr, vv := range db.Permanode.Attr {
if index.IsBlobReferenceAttribute(attr) {
for _, v := range vv {
if v == toRefStr {
found = true
}
}
}
}
}
var ei *EdgeItem
if found {
ei = &EdgeItem{
From: edge.From,
FromType: "permanode",
}
}
resc <- edgeOrError{edge: ei}
}
verifying := 0
for _, edge := range edges {
if edge.FromType == "permanode" {
verifying++
go verify(edge)
continue
}
ei := &EdgeItem{
From: edge.From,
FromType: edge.FromType,
}
edgeItems = append(edgeItems, ei)
}
for i := 0; i < verifying; i++ {
res := <-resc
if res.err != nil {
return nil, res.err
}
if res.edge != nil {
edgeItems = append(edgeItems, res.edge)
}
}
return &EdgesResponse{
ToRef: toRef,
EdgesTo: edgeItems,
}, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"EdgesTo",
"(",
"req",
"*",
"EdgesRequest",
")",
"(",
"*",
"EdgesResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defe... | // EdgesTo returns edges that reference req.RefTo.
// It filters out since-deleted permanode edges. | [
"EdgesTo",
"returns",
"edges",
"that",
"reference",
"req",
".",
"RefTo",
".",
"It",
"filters",
"out",
"since",
"-",
"deleted",
"permanode",
"edges",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L770-L843 | train |
perkeep/perkeep | pkg/search/handler.go | serveEdgesTo | func (h *Handler) serveEdgesTo(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var er EdgesRequest
er.fromHTTP(req)
res, err := h.EdgesTo(&er)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
} | go | func (h *Handler) serveEdgesTo(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var er EdgesRequest
er.fromHTTP(req)
res, err := h.EdgesTo(&er)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveEdgesTo",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"defer",
"httputil",
".",
"RecoverJSON",
"(",
"rw",
",",
"req",
")",
"\n",
"var",
"er",
"EdgesRequest",
... | // Unlike the index interface's EdgesTo method, the "edgesto" Handler
// here additionally filters out since-deleted permanode edges. | [
"Unlike",
"the",
"index",
"interface",
"s",
"EdgesTo",
"method",
"the",
"edgesto",
"Handler",
"here",
"additionally",
"filters",
"out",
"since",
"-",
"deleted",
"permanode",
"edges",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L847-L857 | train |
perkeep/perkeep | pkg/search/handler.go | GetSignerPaths | func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock()
defer h.index.RUnlock()
paths, err := h.index.PathsOfSignerTarget(ctx, req.Signer, req.Target)
if err != nil {
return nil, fmt.Errorf("Error getting paths of %s: %v", req.Target.String(), err)
}
var jpaths []*SignerPathsItem
for _, path := range paths {
jpaths = append(jpaths, &SignerPathsItem{
ClaimRef: path.Claim,
BaseRef: path.Base,
Suffix: path.Suffix,
})
}
dr := h.NewDescribeRequest()
for _, path := range paths {
dr.StartDescribe(ctx, path.Base, 2)
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &SignerPathsResponse{
Paths: jpaths,
Meta: metaMap,
}
return res, nil
} | go | func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock()
defer h.index.RUnlock()
paths, err := h.index.PathsOfSignerTarget(ctx, req.Signer, req.Target)
if err != nil {
return nil, fmt.Errorf("Error getting paths of %s: %v", req.Target.String(), err)
}
var jpaths []*SignerPathsItem
for _, path := range paths {
jpaths = append(jpaths, &SignerPathsItem{
ClaimRef: path.Claim,
BaseRef: path.Base,
Suffix: path.Suffix,
})
}
dr := h.NewDescribeRequest()
for _, path := range paths {
dr.StartDescribe(ctx, path.Base, 2)
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &SignerPathsResponse{
Paths: jpaths,
Meta: metaMap,
}
return res, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetSignerPaths",
"(",
"req",
"*",
"SignerPathsRequest",
")",
"(",
"*",
"SignerPathsResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"if",
"!",
"req",
".",
"Signer",
".",
"... | // GetSignerPaths returns paths with a target of req.Target. | [
"GetSignerPaths",
"returns",
"paths",
"with",
"a",
"target",
"of",
"req",
".",
"Target",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L878-L916 | train |
perkeep/perkeep | pkg/search/handler.go | evalSearchInput | func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs, nil
} else {
sq, err := parseExpression(context.TODO(), in)
if err != nil {
return nil, err
}
return sq.Constraint.Logical.B, nil
}
} | go | func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs, nil
} else {
sq, err := parseExpression(context.TODO(), in)
if err != nil {
return nil, err
}
return sq.Constraint.Logical.B, nil
}
} | [
"func",
"evalSearchInput",
"(",
"in",
"string",
")",
"(",
"*",
"Constraint",
",",
"error",
")",
"{",
"if",
"len",
"(",
"in",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"empty expression\"",
")",
"\n",
"}",
"\n",
"if",
"... | // EvalSearchInput checks if its input is JSON. If so it returns a Constraint constructed from that JSON. Otherwise
// it assumes the input to be a search expression. It parses the expression and returns the parsed Constraint. | [
"EvalSearchInput",
"checks",
"if",
"its",
"input",
"is",
"JSON",
".",
"If",
"so",
"it",
"returns",
"a",
"Constraint",
"constructed",
"from",
"that",
"JSON",
".",
"Otherwise",
"it",
"assumes",
"the",
"input",
"to",
"be",
"a",
"search",
"expression",
".",
"I... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L933-L950 | train |
perkeep/perkeep | pkg/search/handler.go | getNamed | func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search found for: %s", name)
}
permaRef := sr.Blobs[0].Blob
substRefS := sr.Describe.Meta.Get(permaRef).Permanode.Attr.Get("camliContent")
br, ok := blob.Parse(substRefS)
if !ok {
return "", fmt.Errorf("Invalid blob ref: %s", substRefS)
}
reader, _, err := sh.fetcher.Fetch(ctx, br)
if err != nil {
return "", err
}
result, err := ioutil.ReadAll(reader)
if err != nil {
return "", err
}
return string(result), nil
} | go | func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search found for: %s", name)
}
permaRef := sr.Blobs[0].Blob
substRefS := sr.Describe.Meta.Get(permaRef).Permanode.Attr.Get("camliContent")
br, ok := blob.Parse(substRefS)
if !ok {
return "", fmt.Errorf("Invalid blob ref: %s", substRefS)
}
reader, _, err := sh.fetcher.Fetch(ctx, br)
if err != nil {
return "", err
}
result, err := ioutil.ReadAll(reader)
if err != nil {
return "", err
}
return string(result), nil
} | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"getNamed",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"sh",
".",
"fetcher",
"==",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",... | // getNamed displays the search expression or constraint json for the requested alias. | [
"getNamed",
"displays",
"the",
"search",
"expression",
"or",
"constraint",
"json",
"for",
"the",
"requested",
"alias",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L953-L981 | train |
perkeep/perkeep | app/scanningcabinet/tags.go | newSeparatedString | func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sort.StringsAreSorted(ss) {
sort.Strings(ss)
}
return ss
} | go | func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sort.StringsAreSorted(ss) {
sort.Strings(ss)
}
return ss
} | [
"func",
"newSeparatedString",
"(",
"commaSeparated",
"string",
")",
"separatedString",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"commaSeparated",
")",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"split",
":=",
"strings",
".",
"Split",
"(",
"comm... | // newSeparatedString returns a newly created SeparatedString value from the string given.
// There is no error if the string does not include a comma. | [
"newSeparatedString",
"returns",
"a",
"newly",
"created",
"SeparatedString",
"value",
"from",
"the",
"string",
"given",
".",
"There",
"is",
"no",
"error",
"if",
"the",
"string",
"does",
"not",
"include",
"a",
"comma",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L28-L44 | train |
perkeep/perkeep | app/scanningcabinet/tags.go | Minus | func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || css2[k] != s {
keep = append(keep, s)
}
}
return keep
} | go | func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || css2[k] != s {
keep = append(keep, s)
}
}
return keep
} | [
"func",
"(",
"css",
"separatedString",
")",
"Minus",
"(",
"css2",
"separatedString",
")",
"separatedString",
"{",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"(",
"css",
")",
"{",
"sort",
".",
"Strings",
"(",
"css",
")",
"\n",
"}",
"\n",
"if",
"!",
"so... | // Minus returns a newly created SeparatedString containing all the elements from css that did
// not appear in css2 | [
"Minus",
"returns",
"a",
"newly",
"created",
"SeparatedString",
"containing",
"all",
"the",
"elements",
"from",
"css",
"that",
"did",
"not",
"appear",
"in",
"css2"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L63-L82 | train |
perkeep/perkeep | app/scanningcabinet/tags.go | equal | func (css separatedString) equal(css2 separatedString) bool {
if len(css) != len(css2) {
return false
}
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
for k, s := range css {
if s != css2[k] {
return false
}
}
return true
} | go | func (css separatedString) equal(css2 separatedString) bool {
if len(css) != len(css2) {
return false
}
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
for k, s := range css {
if s != css2[k] {
return false
}
}
return true
} | [
"func",
"(",
"css",
"separatedString",
")",
"equal",
"(",
"css2",
"separatedString",
")",
"bool",
"{",
"if",
"len",
"(",
"css",
")",
"!=",
"len",
"(",
"css2",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"... | // equal compares css with css2. Both css and css2 are sorted in place before being compared. | [
"equal",
"compares",
"css",
"with",
"css2",
".",
"Both",
"css",
"and",
"css2",
"are",
"sorted",
"in",
"place",
"before",
"being",
"compared",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L85-L101 | train |
perkeep/perkeep | pkg/fs/util.go | Unmount | func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go func() {
if err := exec.Command("umount", point).Run(); err == nil {
errc <- err
}
// retry to unmount with the fallback cmd
errc <- cmd.Run()
}()
select {
case <-time.After(1 * time.Second):
return errors.New("umount timeout")
case err := <-errc:
return err
}
} | go | func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go func() {
if err := exec.Command("umount", point).Run(); err == nil {
errc <- err
}
// retry to unmount with the fallback cmd
errc <- cmd.Run()
}()
select {
case <-time.After(1 * time.Second):
return errors.New("umount timeout")
case err := <-errc:
return err
}
} | [
"func",
"Unmount",
"(",
"point",
"string",
")",
"error",
"{",
"var",
"cmd",
"*",
"exec",
".",
"Cmd",
"\n",
"switch",
"runtime",
".",
"GOOS",
"{",
"case",
"\"darwin\"",
":",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"/usr/sbin/diskutil\"",
",",
"\"umount... | // Unmount attempts to unmount the provided FUSE mount point, forcibly
// if necessary. | [
"Unmount",
"attempts",
"to",
"unmount",
"the",
"provided",
"FUSE",
"mount",
"point",
"forcibly",
"if",
"necessary",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/fs/util.go#L28-L53 | train |
perkeep/perkeep | pkg/blobserver/sftp/sftp.go | markConnDead | func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
} | go | func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
} | [
"func",
"(",
"s",
"*",
"Storage",
")",
"markConnDead",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"markConnDeadLocked",
"(",
")",
"\n",
"}"
] | // markConnDead clears the cached SFTP connection after the caller detects
// a connection failure. | [
"markConnDead",
"clears",
"the",
"cached",
"SFTP",
"connection",
"after",
"the",
"caller",
"detects",
"a",
"connection",
"failure",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/sftp/sftp.go#L194-L198 | train |
perkeep/perkeep | make.go | fetchJS | func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io.Copy(h, f); err != nil {
return err
}
currentSum = fmt.Sprintf("%x", h.Sum(nil))
}
// fetch the hash of the remote
resp, err := http.Get(jsURL + ".sha256")
if err != nil {
return err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
upstreamSum := strings.TrimSuffix(string(data), "\n")
if currentSum != "" &&
currentSum == upstreamSum {
// We already have the latest version
return nil
}
resp, err = http.Get(jsURL)
if err != nil {
return err
}
defer resp.Body.Close()
js := filepath.Join(pkRoot, filepath.FromSlash(jsOnDisk))
f, err := os.Create(js)
if err != nil {
return err
}
h := sha256.New()
mr := io.MultiWriter(f, h)
if _, err := io.Copy(mr, resp.Body); err != nil {
f.Close()
return err
}
if err := f.Close(); err != nil {
return err
}
sum := fmt.Sprintf("%x", h.Sum(nil))
if upstreamSum != sum {
return fmt.Errorf("checksum mismatch for %q: got %q, want %q", jsURL, sum, upstreamSum)
}
return nil
} | go | func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io.Copy(h, f); err != nil {
return err
}
currentSum = fmt.Sprintf("%x", h.Sum(nil))
}
// fetch the hash of the remote
resp, err := http.Get(jsURL + ".sha256")
if err != nil {
return err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
upstreamSum := strings.TrimSuffix(string(data), "\n")
if currentSum != "" &&
currentSum == upstreamSum {
// We already have the latest version
return nil
}
resp, err = http.Get(jsURL)
if err != nil {
return err
}
defer resp.Body.Close()
js := filepath.Join(pkRoot, filepath.FromSlash(jsOnDisk))
f, err := os.Create(js)
if err != nil {
return err
}
h := sha256.New()
mr := io.MultiWriter(f, h)
if _, err := io.Copy(mr, resp.Body); err != nil {
f.Close()
return err
}
if err := f.Close(); err != nil {
return err
}
sum := fmt.Sprintf("%x", h.Sum(nil))
if upstreamSum != sum {
return fmt.Errorf("checksum mismatch for %q: got %q, want %q", jsURL, sum, upstreamSum)
}
return nil
} | [
"func",
"fetchJS",
"(",
"jsURL",
",",
"jsOnDisk",
"string",
")",
"error",
"{",
"var",
"currentSum",
"string",
"\n",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"jsOnDisk",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"os",
".",
"IsNotExi... | // fetchJS gets the javascript resource at jsURL and writes it to jsOnDisk.
// Since said resource can be quite large, it first fetches the hashsum contained
// in the file at jsURL+".sha256", and if we already have the file on disk, with a
// matching hashsum, it does not actually fetch jsURL. If it does, it checks that
// the newly written file does match the hashsum. | [
"fetchJS",
"gets",
"the",
"javascript",
"resource",
"at",
"jsURL",
"and",
"writes",
"it",
"to",
"jsOnDisk",
".",
"Since",
"said",
"resource",
"can",
"be",
"quite",
"large",
"it",
"first",
"fetches",
"the",
"hashsum",
"contained",
"in",
"the",
"file",
"at",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L525-L589 | train |
perkeep/perkeep | make.go | fullSrcPath | func fullSrcPath(fromSrc string) string {
return filepath.Join(pkRoot, filepath.FromSlash(fromSrc))
} | go | func fullSrcPath(fromSrc string) string {
return filepath.Join(pkRoot, filepath.FromSlash(fromSrc))
} | [
"func",
"fullSrcPath",
"(",
"fromSrc",
"string",
")",
"string",
"{",
"return",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"filepath",
".",
"FromSlash",
"(",
"fromSrc",
")",
")",
"\n",
"}"
] | // fullSrcPath returns the full path concatenation
// of pkRoot with fromSrc. | [
"fullSrcPath",
"returns",
"the",
"full",
"path",
"concatenation",
"of",
"pkRoot",
"with",
"fromSrc",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L687-L689 | train |
perkeep/perkeep | make.go | getVersion | func getVersion() string {
slurp, err := ioutil.ReadFile(filepath.Join(pkRoot, "VERSION"))
v := strings.TrimSpace(string(slurp))
if err != nil && !os.IsNotExist(err) {
log.Fatal(err)
}
if v == "" {
return "unknown"
}
return v
} | go | func getVersion() string {
slurp, err := ioutil.ReadFile(filepath.Join(pkRoot, "VERSION"))
v := strings.TrimSpace(string(slurp))
if err != nil && !os.IsNotExist(err) {
log.Fatal(err)
}
if v == "" {
return "unknown"
}
return v
} | [
"func",
"getVersion",
"(",
")",
"string",
"{",
"slurp",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"\"VERSION\"",
")",
")",
"\n",
"v",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"slurp",
... | // getVersion returns the version of Perkeep found in a VERSION file at the root. | [
"getVersion",
"returns",
"the",
"version",
"of",
"Perkeep",
"found",
"in",
"a",
"VERSION",
"file",
"at",
"the",
"root",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L765-L775 | train |
perkeep/perkeep | make.go | getGitVersion | func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir = pkRoot
out, err := cmd.Output()
if err != nil {
log.Fatalf("Error running git rev-list in %s: %v", pkRoot, err)
}
v := strings.TrimSpace(string(out))
if m := gitVersionRx.FindStringSubmatch(v); m != nil {
v = m[0]
} else {
panic("Failed to find git version in " + v)
}
cmd = exec.Command("git", "diff", "--exit-code")
cmd.Dir = pkRoot
if err := cmd.Run(); err != nil {
v += "+"
}
return v
} | go | func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir = pkRoot
out, err := cmd.Output()
if err != nil {
log.Fatalf("Error running git rev-list in %s: %v", pkRoot, err)
}
v := strings.TrimSpace(string(out))
if m := gitVersionRx.FindStringSubmatch(v); m != nil {
v = m[0]
} else {
panic("Failed to find git version in " + v)
}
cmd = exec.Command("git", "diff", "--exit-code")
cmd.Dir = pkRoot
if err := cmd.Run(); err != nil {
v += "+"
}
return v
} | [
"func",
"getGitVersion",
"(",
")",
"string",
"{",
"if",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"git\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"... | // getGitVersion returns the git version of the git repo at pkRoot as a
// string of the form "yyyy-mm-dd-xxxxxxx", with an optional trailing
// '+' if there are any local uncommitted modifications to the tree. | [
"getGitVersion",
"returns",
"the",
"git",
"version",
"of",
"the",
"git",
"repo",
"at",
"pkRoot",
"as",
"a",
"string",
"of",
"the",
"form",
"yyyy",
"-",
"mm",
"-",
"dd",
"-",
"xxxxxxx",
"with",
"an",
"optional",
"trailing",
"+",
"if",
"there",
"are",
"a... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L782-L808 | train |
perkeep/perkeep | make.go | verifyPerkeepRoot | func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory (where make.go is). Current working directory is %s", pkRoot)
}
// we can't rely on perkeep.org/cmd/pk with modules on as we have no assurance
// the current dir is $GOPATH/src/perkeep.org, so we use ./cmd/pk instead.
cmd := exec.Command("go", "list", "-f", "{{.Target}}", "./cmd/pk")
if os.Getenv("GO111MODULE") == "off" || *buildWebUI {
// if we're building the webUI we need to be in "legacy" GOPATH mode, so in
// $GOPATH/src/perkeep.org
if err := validateDirInGOPATH(pkRoot); err != nil {
log.Fatalf("We're running in GO111MODULE=off mode, either because you set it, or because you want to build the Web UI, so we need to be in a GOPATH, but: %v", err)
}
cmd = exec.Command("go", "list", "-f", "{{.Target}}", "perkeep.org/cmd/pk")
}
cmd.Stderr = os.Stderr
out, err := cmd.Output()
if err != nil {
log.Fatalf("Could not run go list to find install dir: %v, %s", err, out)
}
binDir = filepath.Dir(strings.TrimSpace(string(out)))
} | go | func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory (where make.go is). Current working directory is %s", pkRoot)
}
// we can't rely on perkeep.org/cmd/pk with modules on as we have no assurance
// the current dir is $GOPATH/src/perkeep.org, so we use ./cmd/pk instead.
cmd := exec.Command("go", "list", "-f", "{{.Target}}", "./cmd/pk")
if os.Getenv("GO111MODULE") == "off" || *buildWebUI {
// if we're building the webUI we need to be in "legacy" GOPATH mode, so in
// $GOPATH/src/perkeep.org
if err := validateDirInGOPATH(pkRoot); err != nil {
log.Fatalf("We're running in GO111MODULE=off mode, either because you set it, or because you want to build the Web UI, so we need to be in a GOPATH, but: %v", err)
}
cmd = exec.Command("go", "list", "-f", "{{.Target}}", "perkeep.org/cmd/pk")
}
cmd.Stderr = os.Stderr
out, err := cmd.Output()
if err != nil {
log.Fatalf("Could not run go list to find install dir: %v, %s", err, out)
}
binDir = filepath.Dir(strings.TrimSpace(string(out)))
} | [
"func",
"verifyPerkeepRoot",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"pkRoot",
",",
"err",
"=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"Failed to get current directory: %v\"",
",",
"err",
")",
... | // verifyPerkeepRoot sets pkRoot and crashes if dir isn't the Perkeep root directory. | [
"verifyPerkeepRoot",
"sets",
"pkRoot",
"and",
"crashes",
"if",
"dir",
"isn",
"t",
"the",
"Perkeep",
"root",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L811-L839 | train |
perkeep/perkeep | make.go | verifyGoVersion | func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' command: %v", err)
}
version := string(out)
// Handle non-versioned binaries
// ex: "go version devel +c26fac8 Thu Feb 15 21:41:39 2018 +0000 linux/amd64"
if strings.HasPrefix(version, "go version devel ") {
verifyGopherjsGoroot(" devel")
return
}
m := validVersionRx.FindStringSubmatch(version)
if m == nil {
log.Fatalf("Unexpected output while checking 'go version': %q", version)
}
minorVersion, err := strconv.Atoi(m[1])
if err != nil {
log.Fatalf("Unexpected error while parsing version string %q: %v", m[1], err)
}
if minorVersion < goVersionMinor {
log.Fatalf("Your version of Go (%s) is too old. Perkeep requires Go 1.%d or later.", string(out), goVersionMinor)
}
if *website || *camnetdns {
return
}
if minorVersion != gopherJSGoMinor {
verifyGopherjsGoroot(fmt.Sprintf("1.%d", minorVersion))
}
} | go | func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' command: %v", err)
}
version := string(out)
// Handle non-versioned binaries
// ex: "go version devel +c26fac8 Thu Feb 15 21:41:39 2018 +0000 linux/amd64"
if strings.HasPrefix(version, "go version devel ") {
verifyGopherjsGoroot(" devel")
return
}
m := validVersionRx.FindStringSubmatch(version)
if m == nil {
log.Fatalf("Unexpected output while checking 'go version': %q", version)
}
minorVersion, err := strconv.Atoi(m[1])
if err != nil {
log.Fatalf("Unexpected error while parsing version string %q: %v", m[1], err)
}
if minorVersion < goVersionMinor {
log.Fatalf("Your version of Go (%s) is too old. Perkeep requires Go 1.%d or later.", string(out), goVersionMinor)
}
if *website || *camnetdns {
return
}
if minorVersion != gopherJSGoMinor {
verifyGopherjsGoroot(fmt.Sprintf("1.%d", minorVersion))
}
} | [
"func",
"verifyGoVersion",
"(",
")",
"{",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"go\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.\""... | // verifyGoVersion runs "go version" and parses the output. If the version is
// acceptable a check for gopherjs versions are also done. If problems
// are found a message is logged and we abort. | [
"verifyGoVersion",
"runs",
"go",
"version",
"and",
"parses",
"the",
"output",
".",
"If",
"the",
"version",
"is",
"acceptable",
"a",
"check",
"for",
"gopherjs",
"versions",
"are",
"also",
"done",
".",
"If",
"problems",
"are",
"found",
"a",
"message",
"is",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L888-L927 | train |
perkeep/perkeep | make.go | quote | func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.WriteByte(b)
continue
}
fmt.Fprintf(dest, "\\x%02x", b)
}
dest.WriteByte('"')
} | go | func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.WriteByte(b)
continue
}
fmt.Fprintf(dest, "\\x%02x", b)
}
dest.WriteByte('"')
} | [
"func",
"quote",
"(",
"dest",
"*",
"bytes",
".",
"Buffer",
",",
"bs",
"[",
"]",
"byte",
")",
"{",
"dest",
".",
"WriteByte",
"(",
"'\"'",
")",
"\n",
"for",
"_",
",",
"b",
":=",
"range",
"bs",
"{",
"if",
"b",
"==",
"'\\n'",
"{",
"dest",
".",
"W... | // quote escapes and quotes the bytes from bs and writes
// them to dest. | [
"quote",
"escapes",
"and",
"quotes",
"the",
"bytes",
"from",
"bs",
"and",
"writes",
"them",
"to",
"dest",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L1155-L1177 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | ReceiveBlob | func (sto *unionStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
return blob.SizedRef{}, blobserver.ErrReadonly
} | go | func (sto *unionStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
return blob.SizedRef{}, blobserver.ErrReadonly
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"ReceiveBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"src",
"io",
".",
"Reader",
")",
"(",
"sb",
"blob",
".",
"SizedRef",
",",
"err",
"error",
")",
"{",
"return",
"b... | // ReceiveBlob would receive the blobs, but now just returns ErrReadonly. | [
"ReceiveBlob",
"would",
"receive",
"the",
"blobs",
"but",
"now",
"just",
"returns",
"ErrReadonly",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L56-L58 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | RemoveBlobs | func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
} | go | func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"return",
"blobserver",
".",
"ErrReadonly",
"\n",
"}"
] | // RemoveBlobs would remove the given blobs, but now just returns ErrReadonly. | [
"RemoveBlobs",
"would",
"remove",
"the",
"given",
"blobs",
"but",
"now",
"just",
"returns",
"ErrReadonly",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L61-L63 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | Fetch | func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go func() {
defer wg.Done()
var res result
res.file, res.size, res.err = bs.Fetch(ctx, b)
results <- res
}()
}
go func() {
wg.Wait()
close(results)
}()
var firstErr error
var firstRes result
for r := range results {
if r.err != nil {
if firstErr == nil {
firstErr = r.err
}
continue
}
if firstRes.file != nil {
if r.file != nil {
r.file.Close() // don't need, we already have a successful Fetch
}
continue
}
firstRes = r
}
if firstRes.file != nil {
return firstRes.file, firstRes.size, nil
}
return nil, 0, firstErr
} | go | func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go func() {
defer wg.Done()
var res result
res.file, res.size, res.err = bs.Fetch(ctx, b)
results <- res
}()
}
go func() {
wg.Wait()
close(results)
}()
var firstErr error
var firstRes result
for r := range results {
if r.err != nil {
if firstErr == nil {
firstErr = r.err
}
continue
}
if firstRes.file != nil {
if r.file != nil {
r.file.Close() // don't need, we already have a successful Fetch
}
continue
}
firstRes = r
}
if firstRes.file != nil {
return firstRes.file, firstRes.size, nil
}
return nil, 0, firstErr
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"(",
"file",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"type",
"result",
"struct",
... | // Fetch the blob by trying all configured read Storage concurrently,
// returning the first successful response, or the first error if there's no match. | [
"Fetch",
"the",
"blob",
"by",
"trying",
"all",
"configured",
"read",
"Storage",
"concurrently",
"returning",
"the",
"first",
"successful",
"response",
"or",
"the",
"first",
"error",
"if",
"there",
"s",
"no",
"match",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L67-L111 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | EnumerateBlobs | func (sto *unionStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
return blobserver.MergedEnumerateStorage(ctx, dest, sto.subsets, after, limit)
} | go | func (sto *unionStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
return blobserver.MergedEnumerateStorage(ctx, dest, sto.subsets, after, limit)
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"EnumerateBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"after",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"return",
"blobserver",
".",
"Merge... | // EnumerateBlobs concurrently on the readers, returning one of the errors. | [
"EnumerateBlobs",
"concurrently",
"on",
"the",
"readers",
"returning",
"one",
"of",
"the",
"errors",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L171-L173 | train |
perkeep/perkeep | server/camnetdns/camnetdns.go | Set | func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("error checking if record exists for %q from datastore: %v", key, err)
}
// record does not exist, write it.
return cs.put(ctx, key, value)
}
// record already exists
if oldValue.Record != value {
// new record is different, overwrite old one.
return cs.put(ctx, key, value)
}
// record is the same as before
if oldValue.Updated.Add(staleRecord).After(time.Now()) {
// record is still fresh, nothing to do.
return nil
}
// record is older than 30 days, so we rewrite it, for analytics.
return cs.put(ctx, key, value)
} | go | func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("error checking if record exists for %q from datastore: %v", key, err)
}
// record does not exist, write it.
return cs.put(ctx, key, value)
}
// record already exists
if oldValue.Record != value {
// new record is different, overwrite old one.
return cs.put(ctx, key, value)
}
// record is the same as before
if oldValue.Updated.Add(staleRecord).After(time.Now()) {
// record is still fresh, nothing to do.
return nil
}
// record is older than 30 days, so we rewrite it, for analytics.
return cs.put(ctx, key, value)
} | [
"func",
"(",
"cs",
"cachedStore",
")",
"Set",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"dk",
":=",
"datastore",
".",
"NewKey",
"(",
"ctx",
",",
"\"camnetdns\"",
",",
"key",
",",... | // Set writes the key, value pair to cs. But it does not actually write if the
// value already exists, is up to date, and is more recent than 30 days. | [
"Set",
"writes",
"the",
"key",
"value",
"pair",
"to",
"cs",
".",
"But",
"it",
"does",
"not",
"actually",
"write",
"if",
"the",
"value",
"already",
"exists",
"is",
"up",
"to",
"date",
"and",
"is",
"more",
"recent",
"than",
"30",
"days",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/camnetdns/camnetdns.go#L159-L183 | train |
perkeep/perkeep | pkg/blobserver/s3/s3.go | newFromConfigWithTransport | func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.NewConfig().WithCredentials(credentials.NewStaticCredentials(
config.RequiredString("aws_access_key"),
config.RequiredString("aws_secret_access_key"),
"",
))
if hostname != "" {
s3Cfg.WithEndpoint(hostname)
}
s3Cfg.WithRegion(region)
if transport != nil {
httpClient := *http.DefaultClient
httpClient.Transport = transport
s3Cfg.WithHTTPClient(&httpClient)
}
awsSession := session.New(s3Cfg)
bucket := config.RequiredString("bucket")
var dirPrefix string
if parts := strings.SplitN(bucket, "/", 2); len(parts) > 1 {
dirPrefix = parts[1]
bucket = parts[0]
}
if dirPrefix != "" && !strings.HasSuffix(dirPrefix, "/") {
dirPrefix += "/"
}
skipStartupCheck := config.OptionalBool("skipStartupCheck", false)
if err := config.Validate(); err != nil {
return nil, err
}
ctx := context.TODO() // TODO: 5 min timeout or something?
if !skipStartupCheck {
info, err := normalizeBucketLocation(ctx, awsSession, hostname, bucket)
if err != nil {
return nil, err
}
awsSession.Config.WithRegion(info.region)
awsSession.Config.WithEndpoint(info.endpoint)
if !info.isAWS {
awsSession.Config.WithS3ForcePathStyle(true)
}
} else {
// safer default if we can't determine more info
awsSession.Config.WithS3ForcePathStyle(true)
}
sto := &s3Storage{
client: s3.New(awsSession),
bucket: bucket,
dirPrefix: dirPrefix,
hostname: hostname,
}
if cacheSize != 0 {
// This has two layers of LRU caching (proxycache and memory).
// We make the outer one 4x the size so that it doesn't evict from the
// underlying one when it's about to perform its own eviction.
return proxycache.New(cacheSize<<2, memory.NewCache(cacheSize), sto), nil
}
return sto, nil
} | go | func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.NewConfig().WithCredentials(credentials.NewStaticCredentials(
config.RequiredString("aws_access_key"),
config.RequiredString("aws_secret_access_key"),
"",
))
if hostname != "" {
s3Cfg.WithEndpoint(hostname)
}
s3Cfg.WithRegion(region)
if transport != nil {
httpClient := *http.DefaultClient
httpClient.Transport = transport
s3Cfg.WithHTTPClient(&httpClient)
}
awsSession := session.New(s3Cfg)
bucket := config.RequiredString("bucket")
var dirPrefix string
if parts := strings.SplitN(bucket, "/", 2); len(parts) > 1 {
dirPrefix = parts[1]
bucket = parts[0]
}
if dirPrefix != "" && !strings.HasSuffix(dirPrefix, "/") {
dirPrefix += "/"
}
skipStartupCheck := config.OptionalBool("skipStartupCheck", false)
if err := config.Validate(); err != nil {
return nil, err
}
ctx := context.TODO() // TODO: 5 min timeout or something?
if !skipStartupCheck {
info, err := normalizeBucketLocation(ctx, awsSession, hostname, bucket)
if err != nil {
return nil, err
}
awsSession.Config.WithRegion(info.region)
awsSession.Config.WithEndpoint(info.endpoint)
if !info.isAWS {
awsSession.Config.WithS3ForcePathStyle(true)
}
} else {
// safer default if we can't determine more info
awsSession.Config.WithS3ForcePathStyle(true)
}
sto := &s3Storage{
client: s3.New(awsSession),
bucket: bucket,
dirPrefix: dirPrefix,
hostname: hostname,
}
if cacheSize != 0 {
// This has two layers of LRU caching (proxycache and memory).
// We make the outer one 4x the size so that it doesn't evict from the
// underlying one when it's about to perform its own eviction.
return proxycache.New(cacheSize<<2, memory.NewCache(cacheSize), sto), nil
}
return sto, nil
} | [
"func",
"newFromConfigWithTransport",
"(",
"_",
"blobserver",
".",
"Loader",
",",
"config",
"jsonconfig",
".",
"Obj",
",",
"transport",
"http",
".",
"RoundTripper",
")",
"(",
"blobserver",
".",
"Storage",
",",
"error",
")",
"{",
"hostname",
":=",
"config",
"... | // newFromConfigWithTransport constructs a s3 blobserver using the given
// transport for all s3 requests. The transport may be set to 'nil' to use a
// default transport.
// This is used for unit tests. | [
"newFromConfigWithTransport",
"constructs",
"a",
"s3",
"blobserver",
"using",
"the",
"given",
"transport",
"for",
"all",
"s3",
"requests",
".",
"The",
"transport",
"may",
"be",
"set",
"to",
"nil",
"to",
"use",
"a",
"default",
"transport",
".",
"This",
"is",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/s3/s3.go#L103-L169 | train |
perkeep/perkeep | pkg/blobserver/s3/s3.go | isNotFound | func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrCodeNotFound' for comparison)
aerr.Code() == "NotFound"
}
return false
} | go | func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrCodeNotFound' for comparison)
aerr.Code() == "NotFound"
}
return false
} | [
"func",
"isNotFound",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"aerr",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"return",
"aerr",
".",
... | // isNotFound checks for s3 errors which indicate the object doesn't exist. | [
"isNotFound",
"checks",
"for",
"s3",
"errors",
"which",
"indicate",
"the",
"object",
"doesn",
"t",
"exist",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/s3/s3.go#L176-L188 | train |
perkeep/perkeep | pkg/server/share.go | bytesHaveSchemaLink | func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, bp := range b.ByteParts() {
if bp.BlobRef.Valid() {
if bp.BlobRef == target {
return true
}
}
if bp.BytesRef.Valid() {
if bp.BytesRef == target {
return true
}
}
}
case "directory":
if d, ok := b.DirectoryEntries(); ok {
return d == target
}
case "static-set":
for _, m := range b.StaticSetMembers() {
if m == target {
return true
}
}
}
return false
} | go | func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, bp := range b.ByteParts() {
if bp.BlobRef.Valid() {
if bp.BlobRef == target {
return true
}
}
if bp.BytesRef.Valid() {
if bp.BytesRef == target {
return true
}
}
}
case "directory":
if d, ok := b.DirectoryEntries(); ok {
return d == target
}
case "static-set":
for _, m := range b.StaticSetMembers() {
if m == target {
return true
}
}
}
return false
} | [
"func",
"bytesHaveSchemaLink",
"(",
"br",
"blob",
".",
"Ref",
",",
"bb",
"[",
"]",
"byte",
",",
"target",
"blob",
".",
"Ref",
")",
"bool",
"{",
"if",
"!",
"bytes",
".",
"Contains",
"(",
"bb",
",",
"[",
"]",
"byte",
"(",
"target",
".",
"String",
"... | // bytesHaveSchemaLink reports whether bb is a valid Perkeep schema
// blob and has target somewhere in a schema field used to represent a
// Merkle-tree-ish file or directory. | [
"bytesHaveSchemaLink",
"reports",
"whether",
"bb",
"is",
"a",
"valid",
"Perkeep",
"schema",
"blob",
"and",
"has",
"target",
"somewhere",
"in",
"a",
"schema",
"field",
"used",
"to",
"represent",
"a",
"Merkle",
"-",
"tree",
"-",
"ish",
"file",
"or",
"directory... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/share.go#L316-L352 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/reindex.go | Reindex | func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the first error - if the index or disk is corrupt
// and can't close, it's very likely these two errors are related and
// have the same root cause.
if err == nil {
err = closeErr
}
}()
ctx := context.TODO() // TODO(tgulacsi): get the verbosity from context
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
err = s.reindexOne(ctx, index, overwrite, i)
fh.Close()
if err != nil {
return err
}
}
return nil
} | go | func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the first error - if the index or disk is corrupt
// and can't close, it's very likely these two errors are related and
// have the same root cause.
if err == nil {
err = closeErr
}
}()
ctx := context.TODO() // TODO(tgulacsi): get the verbosity from context
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
err = s.reindexOne(ctx, index, overwrite, i)
fh.Close()
if err != nil {
return err
}
}
return nil
} | [
"func",
"Reindex",
"(",
"root",
"string",
",",
"overwrite",
"bool",
",",
"indexConf",
"jsonconfig",
".",
"Obj",
")",
"(",
"err",
"error",
")",
"{",
"var",
"s",
"=",
"&",
"storage",
"{",
"root",
":",
"root",
"}",
"\n",
"index",
",",
"err",
":=",
"ne... | // Reindex rewrites the index files of the diskpacked .pack files | [
"Reindex",
"rewrites",
"the",
"index",
"files",
"of",
"the",
"diskpacked",
".",
"pack",
"files"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/reindex.go#L42-L75 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/reindex.go | Walk | func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
fh.Close()
if err = s.walkPack(verbose, i, walker); err != nil {
return err
}
}
return nil
} | go | func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
fh.Close()
if err = s.walkPack(verbose, i, walker); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"Walk",
"(",
"ctx",
"context",
".",
"Context",
",",
"walker",
"func",
"(",
"packID",
"int",
",",
"ref",
"blob",
".",
"Ref",
",",
"offset",
"int64",
",",
"size",
"uint32",
")",
"error",
")",
"error",
"{",
"verb... | // Walk walks the storage and calls the walker callback with each blobref
// stops if walker returns non-nil error, and returns that | [
"Walk",
"walks",
"the",
"storage",
"and",
"calls",
"the",
"walker",
"callback",
"with",
"each",
"blobref",
"stops",
"if",
"walker",
"returns",
"non",
"-",
"nil",
"error",
"and",
"returns",
"that"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/reindex.go#L143-L163 | train |
perkeep/perkeep | pkg/blobserver/encrypt/meta.go | makeSingleMetaBlob | func (s *storage) makeSingleMetaBlob(plainBR, encBR blob.Ref, plainSize uint32) []byte {
plain := fmt.Sprintf("#camlistore/encmeta=2\n%s/%d/%s\n", plainBR, plainSize, encBR)
return s.encryptBlob(nil, []byte(plain))
} | go | func (s *storage) makeSingleMetaBlob(plainBR, encBR blob.Ref, plainSize uint32) []byte {
plain := fmt.Sprintf("#camlistore/encmeta=2\n%s/%d/%s\n", plainBR, plainSize, encBR)
return s.encryptBlob(nil, []byte(plain))
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"makeSingleMetaBlob",
"(",
"plainBR",
",",
"encBR",
"blob",
".",
"Ref",
",",
"plainSize",
"uint32",
")",
"[",
"]",
"byte",
"{",
"plain",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"#camlistore/encmeta=2\\n%s/%d/%s\\n\"",
",",
... | // makeSingleMetaBlob makes and encrypts a metaBlob with one entry. | [
"makeSingleMetaBlob",
"makes",
"and",
"encrypts",
"a",
"metaBlob",
"with",
"one",
"entry",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/meta.go#L148-L151 | train |
perkeep/perkeep | pkg/blobserver/encrypt/meta.go | fetchMeta | func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
} | go | func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"fetchMeta",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"(",
"plainSize",
"uint32",
",",
"encBR",
"blob",
".",
"Ref",
",",
"err",
"error",
")",
"{",
"v",
",",
"err",
":=",
"s",... | // fetchMeta returns os.ErrNotExist if the plaintext blob is not in the index. | [
"fetchMeta",
"returns",
"os",
".",
"ErrNotExist",
"if",
"the",
"plaintext",
"blob",
"is",
"not",
"in",
"the",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/meta.go#L177-L186 | train |
perkeep/perkeep | server/perkeepd/ui/goui/aboutdialog/gen_AboutMenuItem_reactGen.go | Props | func (a AboutMenuItemDef) Props() AboutMenuItemProps {
uprops := a.ComponentDef.Props()
return uprops.(AboutMenuItemProps)
} | go | func (a AboutMenuItemDef) Props() AboutMenuItemProps {
uprops := a.ComponentDef.Props()
return uprops.(AboutMenuItemProps)
} | [
"func",
"(",
"a",
"AboutMenuItemDef",
")",
"Props",
"(",
")",
"AboutMenuItemProps",
"{",
"uprops",
":=",
"a",
".",
"ComponentDef",
".",
"Props",
"(",
")",
"\n",
"return",
"uprops",
".",
"(",
"AboutMenuItemProps",
")",
"\n",
"}"
] | // Props is an auto-generated proxy to the current props of AboutMenuItem | [
"Props",
"is",
"an",
"auto",
"-",
"generated",
"proxy",
"to",
"the",
"current",
"props",
"of",
"AboutMenuItem"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/aboutdialog/gen_AboutMenuItem_reactGen.go#L30-L33 | train |
perkeep/perkeep | internal/netutil/netutil.go | AwaitReachable | func AwaitReachable(addr string, maxWait time.Duration) error {
done := time.Now().Add(maxWait)
for time.Now().Before(done) {
c, err := net.Dial("tcp", addr)
if err == nil {
c.Close()
return nil
}
time.Sleep(100 * time.Millisecond)
}
return fmt.Errorf("%v unreachable for %v", addr, maxWait)
} | go | func AwaitReachable(addr string, maxWait time.Duration) error {
done := time.Now().Add(maxWait)
for time.Now().Before(done) {
c, err := net.Dial("tcp", addr)
if err == nil {
c.Close()
return nil
}
time.Sleep(100 * time.Millisecond)
}
return fmt.Errorf("%v unreachable for %v", addr, maxWait)
} | [
"func",
"AwaitReachable",
"(",
"addr",
"string",
",",
"maxWait",
"time",
".",
"Duration",
")",
"error",
"{",
"done",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"maxWait",
")",
"\n",
"for",
"time",
".",
"Now",
"(",
")",
".",
"Before",
"(",... | // AwaitReachable tries to make a TCP connection to addr regularly.
// It returns an error if it's unable to make a connection before maxWait. | [
"AwaitReachable",
"tries",
"to",
"make",
"a",
"TCP",
"connection",
"to",
"addr",
"regularly",
".",
"It",
"returns",
"an",
"error",
"if",
"it",
"s",
"unable",
"to",
"make",
"a",
"connection",
"before",
"maxWait",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L30-L41 | train |
perkeep/perkeep | internal/netutil/netutil.go | ListenOnLocalRandomPort | func ListenOnLocalRandomPort() (net.Listener, error) {
ip, err := Localhost()
if err != nil {
return nil, err
}
return net.ListenTCP("tcp", &net.TCPAddr{IP: ip, Port: 0})
} | go | func ListenOnLocalRandomPort() (net.Listener, error) {
ip, err := Localhost()
if err != nil {
return nil, err
}
return net.ListenTCP("tcp", &net.TCPAddr{IP: ip, Port: 0})
} | [
"func",
"ListenOnLocalRandomPort",
"(",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"ip",
",",
"err",
":=",
"Localhost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"net",
"."... | // ListenOnLocalRandomPort returns a TCP listener on a random
// localhost port. | [
"ListenOnLocalRandomPort",
"returns",
"a",
"TCP",
"listener",
"on",
"a",
"random",
"localhost",
"port",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L92-L98 | train |
perkeep/perkeep | internal/netutil/netutil.go | Localhost | func Localhost() (net.IP, error) {
if ip := localhostLookup(); ip != nil {
return ip, nil
}
if ip := loopbackIP(); ip != nil {
return ip, nil
}
return nil, errors.New("no loopback ip found")
} | go | func Localhost() (net.IP, error) {
if ip := localhostLookup(); ip != nil {
return ip, nil
}
if ip := loopbackIP(); ip != nil {
return ip, nil
}
return nil, errors.New("no loopback ip found")
} | [
"func",
"Localhost",
"(",
")",
"(",
"net",
".",
"IP",
",",
"error",
")",
"{",
"if",
"ip",
":=",
"localhostLookup",
"(",
")",
";",
"ip",
"!=",
"nil",
"{",
"return",
"ip",
",",
"nil",
"\n",
"}",
"\n",
"if",
"ip",
":=",
"loopbackIP",
"(",
")",
";"... | // Localhost returns the first address found when
// doing a lookup of "localhost". If not successful,
// it looks for an ip on the loopback interfaces. | [
"Localhost",
"returns",
"the",
"first",
"address",
"found",
"when",
"doing",
"a",
"lookup",
"of",
"localhost",
".",
"If",
"not",
"successful",
"it",
"looks",
"for",
"an",
"ip",
"on",
"the",
"loopback",
"interfaces",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L103-L111 | train |
perkeep/perkeep | internal/netutil/netutil.go | localhostLookup | func localhostLookup() net.IP {
if ips, err := net.LookupIP("localhost"); err == nil && len(ips) > 0 {
return ips[0]
}
return nil
} | go | func localhostLookup() net.IP {
if ips, err := net.LookupIP("localhost"); err == nil && len(ips) > 0 {
return ips[0]
}
return nil
} | [
"func",
"localhostLookup",
"(",
")",
"net",
".",
"IP",
"{",
"if",
"ips",
",",
"err",
":=",
"net",
".",
"LookupIP",
"(",
"\"localhost\"",
")",
";",
"err",
"==",
"nil",
"&&",
"len",
"(",
"ips",
")",
">",
"0",
"{",
"return",
"ips",
"[",
"0",
"]",
... | // localhostLookup looks for a loopback IP by resolving localhost. | [
"localhostLookup",
"looks",
"for",
"a",
"loopback",
"IP",
"by",
"resolving",
"localhost",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L114-L119 | train |
perkeep/perkeep | internal/netutil/netutil.go | loopbackIP | func loopbackIP() net.IP {
interfaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, inf := range interfaces {
const flagUpLoopback = net.FlagUp | net.FlagLoopback
if inf.Flags&flagUpLoopback == flagUpLoopback {
addrs, _ := inf.Addrs()
for _, addr := range addrs {
ip, _, err := net.ParseCIDR(addr.String())
if err == nil && ip.IsLoopback() {
return ip
}
}
}
}
return nil
} | go | func loopbackIP() net.IP {
interfaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, inf := range interfaces {
const flagUpLoopback = net.FlagUp | net.FlagLoopback
if inf.Flags&flagUpLoopback == flagUpLoopback {
addrs, _ := inf.Addrs()
for _, addr := range addrs {
ip, _, err := net.ParseCIDR(addr.String())
if err == nil && ip.IsLoopback() {
return ip
}
}
}
}
return nil
} | [
"func",
"loopbackIP",
"(",
")",
"net",
".",
"IP",
"{",
"interfaces",
",",
"err",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"inf",
":=",
"range",
"interfaces",
... | // loopbackIP returns the first loopback IP address sniffing network
// interfaces or nil if none is found. | [
"loopbackIP",
"returns",
"the",
"first",
"loopback",
"IP",
"address",
"sniffing",
"network",
"interfaces",
"or",
"nil",
"if",
"none",
"is",
"found",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L123-L141 | train |
perkeep/perkeep | internal/netutil/netutil.go | RandPort | func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAddr)
if err := listener.Close(); err != nil {
return port, fmt.Errorf("could not close random listener: %v", err)
}
return randAddr.Port, nil
} | go | func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAddr)
if err := listener.Close(); err != nil {
return port, fmt.Errorf("could not close random listener: %v", err)
}
return randAddr.Port, nil
} | [
"func",
"RandPort",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"port",
"int",
"\n",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"tcp\"",
",",
"\"localhost:0\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"port",
... | // RandPort returns a random port to listen on. | [
"RandPort",
"returns",
"a",
"random",
"port",
"to",
"listen",
"on",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L144-L159 | train |
perkeep/perkeep | internal/netutil/netutil.go | IsFQDN | func IsFQDN(domain string) bool {
// TODO(mpl): there's probably a regexp for all this...
if domain == "localhost" {
return false
}
if !strings.Contains(domain, ".") {
return false
}
if strings.Contains(domain, "/") {
return false
}
if net.ParseIP(domain) != nil {
return false
}
return true
} | go | func IsFQDN(domain string) bool {
// TODO(mpl): there's probably a regexp for all this...
if domain == "localhost" {
return false
}
if !strings.Contains(domain, ".") {
return false
}
if strings.Contains(domain, "/") {
return false
}
if net.ParseIP(domain) != nil {
return false
}
return true
} | [
"func",
"IsFQDN",
"(",
"domain",
"string",
")",
"bool",
"{",
"if",
"domain",
"==",
"\"localhost\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"domain",
",",
"\".\"",
")",
"{",
"return",
"false",
"\n",
"}",
"... | // IsFQDN reports whether domain looks like a fully qualified domain name. | [
"IsFQDN",
"reports",
"whether",
"domain",
"looks",
"like",
"a",
"fully",
"qualified",
"domain",
"name",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L168-L183 | train |
perkeep/perkeep | server/perkeepd/ui/goui/geo/geo.go | IsLocMapPredicate | func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
} | go | func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
} | [
"func",
"IsLocMapPredicate",
"(",
"predicate",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"rectangleFromPredicate",
"(",
"predicate",
",",
"LocMapPredicatePrefix",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",... | // IsLocMapPredicate returns whether predicate is a map location predicate. | [
"IsLocMapPredicate",
"returns",
"whether",
"predicate",
"is",
"a",
"map",
"location",
"predicate",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/geo/geo.go#L36-L41 | train |
perkeep/perkeep | server/perkeepd/ui/goui/geo/geo.go | rectangleFromPredicate | func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if len(coords) != 4 {
return nil, errNotARectangle
}
var coord [4]float64
for k, v := range coords {
f, err := strconv.ParseFloat(v, 64)
if err != nil {
return nil, errNotARectangle
}
coord[k] = f
}
return &camtypes.LocationBounds{
North: coord[0],
South: coord[2],
East: coord[3],
West: coord[1],
}, nil
} | go | func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if len(coords) != 4 {
return nil, errNotARectangle
}
var coord [4]float64
for k, v := range coords {
f, err := strconv.ParseFloat(v, 64)
if err != nil {
return nil, errNotARectangle
}
coord[k] = f
}
return &camtypes.LocationBounds{
North: coord[0],
South: coord[2],
East: coord[3],
West: coord[1],
}, nil
} | [
"func",
"rectangleFromPredicate",
"(",
"predicate",
",",
"kind",
"string",
")",
"(",
"*",
"camtypes",
".",
"LocationBounds",
",",
"error",
")",
"{",
"errNotARectangle",
":=",
"fmt",
".",
"Errorf",
"(",
"\"not a valid %v predicate\"",
",",
"kind",
")",
"\n",
"i... | // rectangleFromPredicate, if predicate is a valid location predicate of the given kind
// and returns the corresponding rectangular area. | [
"rectangleFromPredicate",
"if",
"predicate",
"is",
"a",
"valid",
"location",
"predicate",
"of",
"the",
"given",
"kind",
"and",
"returns",
"the",
"corresponding",
"rectangular",
"area",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/geo/geo.go#L45-L69 | train |
perkeep/perkeep | internal/leak/leak.go | NewChecker | func NewChecker() *Checker {
pc := make([]uintptr, 50)
ch := &Checker{pc[:runtime.Callers(0, pc)]}
runtime.SetFinalizer(ch, (*Checker).finalize)
return ch
} | go | func NewChecker() *Checker {
pc := make([]uintptr, 50)
ch := &Checker{pc[:runtime.Callers(0, pc)]}
runtime.SetFinalizer(ch, (*Checker).finalize)
return ch
} | [
"func",
"NewChecker",
"(",
")",
"*",
"Checker",
"{",
"pc",
":=",
"make",
"(",
"[",
"]",
"uintptr",
",",
"50",
")",
"\n",
"ch",
":=",
"&",
"Checker",
"{",
"pc",
"[",
":",
"runtime",
".",
"Callers",
"(",
"0",
",",
"pc",
")",
"]",
"}",
"\n",
"ru... | // NewChecker returns a Checker, remembering the stack trace. | [
"NewChecker",
"returns",
"a",
"Checker",
"remembering",
"the",
"stack",
"trace",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/leak/leak.go#L32-L37 | train |
perkeep/perkeep | pkg/importer/feed/feed.go | autoDiscover | func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make(map[string]string)
for _, a := range t.Attr {
attrs[a.Key] = a.Val
}
if attrs["rel"] == "alternate" && attrs["href"] != "" &&
(attrs["type"] == "application/rss+xml" || attrs["type"] == "application/atom+xml") {
return attrs["href"], nil
}
}
}
}
return "", fmt.Errorf("No feed link found")
} | go | func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make(map[string]string)
for _, a := range t.Attr {
attrs[a.Key] = a.Val
}
if attrs["rel"] == "alternate" && attrs["href"] != "" &&
(attrs["type"] == "application/rss+xml" || attrs["type"] == "application/atom+xml") {
return attrs["href"], nil
}
}
}
}
return "", fmt.Errorf("No feed link found")
} | [
"func",
"autoDiscover",
"(",
"body",
"[",
"]",
"byte",
")",
"(",
"feedURL",
"string",
",",
"err",
"error",
")",
"{",
"r",
":=",
"bytes",
".",
"NewReader",
"(",
"body",
")",
"\n",
"z",
":=",
"html",
".",
"NewTokenizer",
"(",
"r",
")",
"\n",
"for",
... | // autodiscover takes an HTML document and returns the autodiscovered feed
// URL. Returns an error if there is no such URL. | [
"autodiscover",
"takes",
"an",
"HTML",
"document",
"and",
"returns",
"the",
"autodiscovered",
"feed",
"URL",
".",
"Returns",
"an",
"error",
"if",
"there",
"is",
"no",
"such",
"URL",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/feed/feed.go#L191-L214 | train |
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | importStatuses | func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.Printf("mastodon: Beginning statuses import for %s", r.userAddress)
var pg mastodon.Pagination
for {
select {
case <-r.Context().Done():
return r.Context().Err()
default:
}
if pg.MaxID != "" {
log.Printf("mastodon: fetching batch for %s, from %s", r.userAddress, pg.MaxID)
} else {
log.Printf("mastodon: fetching batch for %s", r.userAddress)
}
batch, err := r.cl.GetAccountStatuses(r.Context(), userID, &pg)
if err != nil {
return err
}
if len(batch) == 0 {
log.Printf("mastodon: got empty batch, assuming end of statuses for %s", r.userAddress)
return nil
}
gate := syncutil.NewGate(importAtOnce)
var grp syncutil.Group
allReblogs := true
anyNew := false
var anyNewMu sync.Mutex
for i := range batch {
st := batch[i]
// If an entry is a reblog, we ignore it and move on. However, the
// whole batch being all reblogs does not mean there is nothing new
// on the next page. If everything on this page was a reblog, we
// move on to the next page regardless.
if st.Reblog != nil {
continue
}
allReblogs = false
gate.Start()
grp.Go(func() error {
defer gate.Done()
alreadyHad, err := r.importStatus(statusesNode, st)
if err != nil {
return fmt.Errorf("error importing status %s: %v", st.URI, err)
}
if !alreadyHad {
anyNewMu.Lock()
anyNew = true
anyNewMu.Unlock()
}
return nil
})
}
if err := grp.Err(); err != nil {
return err
}
if !anyNew && !allReblogs {
log.Printf("mastodon: reached the end for incremental import for %s", r.userAddress)
return nil
}
if pg.MaxID == "" {
log.Printf("mastodon: reached the end of statuses for %s", r.userAddress)
return nil
}
}
} | go | func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.Printf("mastodon: Beginning statuses import for %s", r.userAddress)
var pg mastodon.Pagination
for {
select {
case <-r.Context().Done():
return r.Context().Err()
default:
}
if pg.MaxID != "" {
log.Printf("mastodon: fetching batch for %s, from %s", r.userAddress, pg.MaxID)
} else {
log.Printf("mastodon: fetching batch for %s", r.userAddress)
}
batch, err := r.cl.GetAccountStatuses(r.Context(), userID, &pg)
if err != nil {
return err
}
if len(batch) == 0 {
log.Printf("mastodon: got empty batch, assuming end of statuses for %s", r.userAddress)
return nil
}
gate := syncutil.NewGate(importAtOnce)
var grp syncutil.Group
allReblogs := true
anyNew := false
var anyNewMu sync.Mutex
for i := range batch {
st := batch[i]
// If an entry is a reblog, we ignore it and move on. However, the
// whole batch being all reblogs does not mean there is nothing new
// on the next page. If everything on this page was a reblog, we
// move on to the next page regardless.
if st.Reblog != nil {
continue
}
allReblogs = false
gate.Start()
grp.Go(func() error {
defer gate.Done()
alreadyHad, err := r.importStatus(statusesNode, st)
if err != nil {
return fmt.Errorf("error importing status %s: %v", st.URI, err)
}
if !alreadyHad {
anyNewMu.Lock()
anyNew = true
anyNewMu.Unlock()
}
return nil
})
}
if err := grp.Err(); err != nil {
return err
}
if !anyNew && !allReblogs {
log.Printf("mastodon: reached the end for incremental import for %s", r.userAddress)
return nil
}
if pg.MaxID == "" {
log.Printf("mastodon: reached the end of statuses for %s", r.userAddress)
return nil
}
}
} | [
"func",
"(",
"r",
"*",
"run",
")",
"importStatuses",
"(",
"userID",
"mastodon",
".",
"ID",
")",
"error",
"{",
"statusesNode",
",",
"err",
":=",
"r",
".",
"RootNode",
"(",
")",
".",
"ChildPathObject",
"(",
"nodeStatuses",
")",
"\n",
"if",
"err",
"!=",
... | // importStatuses imports statuses for the given user into the store | [
"importStatuses",
"imports",
"statuses",
"for",
"the",
"given",
"user",
"into",
"the",
"store"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L294-L385 | train |
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | importStatus | func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode, err := listNode.ChildPathObject(st.URI)
if err != nil {
return false, err
}
if r.incremental && statusNode.Attr(attrURI) == st.URI {
return true, nil
}
attrs := []string{
nodeattr.Type, "mastodon:status",
attrURI, st.URI,
nodeattr.URL, st.URL,
nodeattr.Content, st.Content,
nodeattr.StartDate, schema.RFC3339FromTime(st.CreatedAt),
}
if st.SpoilerText != "" {
attrs = append(attrs, attrSpoilerText, st.SpoilerText)
}
filenames := make(map[string]int)
for i, att := range st.MediaAttachments {
// All media for a local user will be local
resp, err := ctxutil.Client(r.Context()).Get(att.URL)
if err != nil {
return false, err
}
if resp.StatusCode != http.StatusOK {
return false, fmt.Errorf("failed fetching attachment %s with HTTP status %s", att.URL, resp.Status)
}
fileRef, err := schema.WriteFileFromReader(r.Context(), r.Host.Target(), "", resp.Body)
resp.Body.Close()
if err != nil {
return false, err
}
filename := path.Base(att.URL)
filenames[filename]++
// A status can have several different attachments with the same
// filename. We add numbers to the path to diffirentiate them if that's
// the case
if filenames[filename] > 1 {
ext := path.Ext(filename)
filename = fmt.Sprintf("%s%d%s", strings.TrimSuffix(filename, ext), filenames[filename], ext)
}
attrs = append(attrs, fmt.Sprintf("camliPath:%v", filename), fileRef.String())
// The first image gets to be the preview image for the node
if i == 0 {
attrs = append(attrs, "camliContentImage", fileRef.String())
}
log.Printf("mastodon: adding attachment %s to permanode %s for status %s", fileRef.String(), statusNode.PermanodeRef(), st.URI)
}
changed, err := statusNode.SetAttrs2(attrs...)
if err == nil && changed {
log.Printf("mastodon: Imported status %s to %s", st.URI, statusNode.PermanodeRef())
}
return !changed, err
} | go | func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode, err := listNode.ChildPathObject(st.URI)
if err != nil {
return false, err
}
if r.incremental && statusNode.Attr(attrURI) == st.URI {
return true, nil
}
attrs := []string{
nodeattr.Type, "mastodon:status",
attrURI, st.URI,
nodeattr.URL, st.URL,
nodeattr.Content, st.Content,
nodeattr.StartDate, schema.RFC3339FromTime(st.CreatedAt),
}
if st.SpoilerText != "" {
attrs = append(attrs, attrSpoilerText, st.SpoilerText)
}
filenames := make(map[string]int)
for i, att := range st.MediaAttachments {
// All media for a local user will be local
resp, err := ctxutil.Client(r.Context()).Get(att.URL)
if err != nil {
return false, err
}
if resp.StatusCode != http.StatusOK {
return false, fmt.Errorf("failed fetching attachment %s with HTTP status %s", att.URL, resp.Status)
}
fileRef, err := schema.WriteFileFromReader(r.Context(), r.Host.Target(), "", resp.Body)
resp.Body.Close()
if err != nil {
return false, err
}
filename := path.Base(att.URL)
filenames[filename]++
// A status can have several different attachments with the same
// filename. We add numbers to the path to diffirentiate them if that's
// the case
if filenames[filename] > 1 {
ext := path.Ext(filename)
filename = fmt.Sprintf("%s%d%s", strings.TrimSuffix(filename, ext), filenames[filename], ext)
}
attrs = append(attrs, fmt.Sprintf("camliPath:%v", filename), fileRef.String())
// The first image gets to be the preview image for the node
if i == 0 {
attrs = append(attrs, "camliContentImage", fileRef.String())
}
log.Printf("mastodon: adding attachment %s to permanode %s for status %s", fileRef.String(), statusNode.PermanodeRef(), st.URI)
}
changed, err := statusNode.SetAttrs2(attrs...)
if err == nil && changed {
log.Printf("mastodon: Imported status %s to %s", st.URI, statusNode.PermanodeRef())
}
return !changed, err
} | [
"func",
"(",
"r",
"*",
"run",
")",
"importStatus",
"(",
"listNode",
"*",
"importer",
".",
"Object",
",",
"st",
"*",
"mastodon",
".",
"Status",
")",
"(",
"bool",
",",
"error",
")",
"{",
"select",
"{",
"case",
"<-",
"r",
".",
"Context",
"(",
")",
"... | // importStatus imports a single status, also adding it to the statuses node.
// Returns true if we already had the status in the database. | [
"importStatus",
"imports",
"a",
"single",
"status",
"also",
"adding",
"it",
"to",
"the",
"statuses",
"node",
".",
"Returns",
"true",
"if",
"we",
"already",
"had",
"the",
"status",
"in",
"the",
"database",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L389-L467 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.