repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
perkeep/perkeep | website/pk-web/pkweb.go | httpClient | func httpClient(projID string) *http.Client {
if *gceJWTFile == "" {
log.Fatal("Cannot initialize an authorized http Client without --gce_jwt_file")
}
jsonSlurp, err := ioutil.ReadFile(*gceJWTFile)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
jwtConf, err := google.JWTConfigFromJSON(jsonSlurp, logging.WriteScope)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
return jwtConf.Client(context.Background())
} | go | func httpClient(projID string) *http.Client {
if *gceJWTFile == "" {
log.Fatal("Cannot initialize an authorized http Client without --gce_jwt_file")
}
jsonSlurp, err := ioutil.ReadFile(*gceJWTFile)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
jwtConf, err := google.JWTConfigFromJSON(jsonSlurp, logging.WriteScope)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
return jwtConf.Client(context.Background())
} | [
"func",
"httpClient",
"(",
"projID",
"string",
")",
"*",
"http",
".",
"Client",
"{",
"if",
"*",
"gceJWTFile",
"==",
"\"",
"\"",
"{",
"log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"jsonSlurp",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"*",
"gceJWTFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"jwtConf",
",",
"err",
":=",
"google",
".",
"JWTConfigFromJSON",
"(",
"jsonSlurp",
",",
"logging",
".",
"WriteScope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"jwtConf",
".",
"Client",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}"
] | // httpClient returns an http Client suitable for Google Cloud Storage or Google Cloud
// Logging calls with the projID project ID. | [
"httpClient",
"returns",
"an",
"http",
"Client",
"suitable",
"for",
"Google",
"Cloud",
"Storage",
"or",
"Google",
"Cloud",
"Logging",
"calls",
"with",
"the",
"projID",
"project",
"ID",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L791-L804 | train |
perkeep/perkeep | website/pk-web/pkweb.go | issueRedirect | func issueRedirect(urlPath string) (string, bool) {
m := issueNum.FindStringSubmatch(urlPath)
if m == nil {
return "", false
}
issueNumber := strings.TrimPrefix(m[1], "/")
suffix := ""
if issueNumber != "" {
suffix = "/" + issueNumber
}
return "https://github.com/perkeep/perkeep/issues" + suffix, true
} | go | func issueRedirect(urlPath string) (string, bool) {
m := issueNum.FindStringSubmatch(urlPath)
if m == nil {
return "", false
}
issueNumber := strings.TrimPrefix(m[1], "/")
suffix := ""
if issueNumber != "" {
suffix = "/" + issueNumber
}
return "https://github.com/perkeep/perkeep/issues" + suffix, true
} | [
"func",
"issueRedirect",
"(",
"urlPath",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"m",
":=",
"issueNum",
".",
"FindStringSubmatch",
"(",
"urlPath",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}",
"\n",
"issueNumber",
":=",
"strings",
".",
"TrimPrefix",
"(",
"m",
"[",
"1",
"]",
",",
"\"",
"\"",
")",
"\n",
"suffix",
":=",
"\"",
"\"",
"\n",
"if",
"issueNumber",
"!=",
"\"",
"\"",
"{",
"suffix",
"=",
"\"",
"\"",
"+",
"issueNumber",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"+",
"suffix",
",",
"true",
"\n",
"}"
] | // issueRedirect returns whether the request should be redirected to the
// issues tracker, and the url for that redirection if yes, the empty
// string otherwise. | [
"issueRedirect",
"returns",
"whether",
"the",
"request",
"should",
"be",
"redirected",
"to",
"the",
"issues",
"tracker",
"and",
"the",
"url",
"for",
"that",
"redirection",
"if",
"yes",
"the",
"empty",
"string",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L1103-L1114 | train |
perkeep/perkeep | internal/video/thumbnail/handler.go | serveRef | func serveRef(rw http.ResponseWriter, req *http.Request, ref blob.Ref, fetcher blob.Fetcher) {
if !httputil.IsGet(req) {
http.Error(rw, "Invalid download method.", 400)
return
}
if !httputil.IsLocalhost(req) {
http.Error(rw, "Forbidden.", 403)
return
}
parts := strings.Split(req.URL.Path, "/")
if len(parts) < 2 {
http.Error(rw, "Malformed GET URL.", 400)
return
}
blobRef, ok := blob.Parse(parts[1])
if !ok {
http.Error(rw, "Malformed GET URL.", 400)
return
}
// only serves its ref
if blobRef != ref {
log.Printf("videothumbnail: access to %v forbidden; wrong blobref for handler", blobRef)
http.Error(rw, "Forbidden.", 403)
return
}
rw.Header().Set("Content-Type", "application/octet-stream")
fr, err := schema.NewFileReader(req.Context(), fetcher, ref)
if err != nil {
httputil.ServeError(rw, req, err)
return
}
defer fr.Close()
http.ServeContent(rw, req, "", time.Now(), fr)
} | go | func serveRef(rw http.ResponseWriter, req *http.Request, ref blob.Ref, fetcher blob.Fetcher) {
if !httputil.IsGet(req) {
http.Error(rw, "Invalid download method.", 400)
return
}
if !httputil.IsLocalhost(req) {
http.Error(rw, "Forbidden.", 403)
return
}
parts := strings.Split(req.URL.Path, "/")
if len(parts) < 2 {
http.Error(rw, "Malformed GET URL.", 400)
return
}
blobRef, ok := blob.Parse(parts[1])
if !ok {
http.Error(rw, "Malformed GET URL.", 400)
return
}
// only serves its ref
if blobRef != ref {
log.Printf("videothumbnail: access to %v forbidden; wrong blobref for handler", blobRef)
http.Error(rw, "Forbidden.", 403)
return
}
rw.Header().Set("Content-Type", "application/octet-stream")
fr, err := schema.NewFileReader(req.Context(), fetcher, ref)
if err != nil {
httputil.ServeError(rw, req, err)
return
}
defer fr.Close()
http.ServeContent(rw, req, "", time.Now(), fr)
} | [
"func",
"serveRef",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"ref",
"blob",
".",
"Ref",
",",
"fetcher",
"blob",
".",
"Fetcher",
")",
"{",
"if",
"!",
"httputil",
".",
"IsGet",
"(",
"req",
")",
"{",
"http",
".",
"Error",
"(",
"rw",
",",
"\"",
"\"",
",",
"400",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"!",
"httputil",
".",
"IsLocalhost",
"(",
"req",
")",
"{",
"http",
".",
"Error",
"(",
"rw",
",",
"\"",
"\"",
",",
"403",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"req",
".",
"URL",
".",
"Path",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"<",
"2",
"{",
"http",
".",
"Error",
"(",
"rw",
",",
"\"",
"\"",
",",
"400",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"blobRef",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"if",
"!",
"ok",
"{",
"http",
".",
"Error",
"(",
"rw",
",",
"\"",
"\"",
",",
"400",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// only serves its ref",
"if",
"blobRef",
"!=",
"ref",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"blobRef",
")",
"\n",
"http",
".",
"Error",
"(",
"rw",
",",
"\"",
"\"",
",",
"403",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"rw",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"fr",
",",
"err",
":=",
"schema",
".",
"NewFileReader",
"(",
"req",
".",
"Context",
"(",
")",
",",
"fetcher",
",",
"ref",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"httputil",
".",
"ServeError",
"(",
"rw",
",",
"req",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"fr",
".",
"Close",
"(",
")",
"\n\n",
"http",
".",
"ServeContent",
"(",
"rw",
",",
"req",
",",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
",",
"fr",
")",
"\n",
"}"
] | // serveRef gets the file at ref from fetcher and serves its contents.
// It is used by Service as a one time handler to serve to the thumbnail child process on localhost. | [
"serveRef",
"gets",
"the",
"file",
"at",
"ref",
"from",
"fetcher",
"and",
"serves",
"its",
"contents",
".",
"It",
"is",
"used",
"by",
"Service",
"as",
"a",
"one",
"time",
"handler",
"to",
"serve",
"to",
"the",
"thumbnail",
"child",
"process",
"on",
"localhost",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/video/thumbnail/handler.go#L32-L73 | train |
perkeep/perkeep | pkg/jsonsign/keys.go | ParseArmoredPublicKey | func ParseArmoredPublicKey(r io.Reader) (shortKeyId, armoredKey string, err error) {
var buf bytes.Buffer
pk, err := openArmoredPublicKeyFile(ioutil.NopCloser(io.TeeReader(r, &buf)))
if err != nil {
return
}
return publicKeyID(pk), buf.String(), nil
} | go | func ParseArmoredPublicKey(r io.Reader) (shortKeyId, armoredKey string, err error) {
var buf bytes.Buffer
pk, err := openArmoredPublicKeyFile(ioutil.NopCloser(io.TeeReader(r, &buf)))
if err != nil {
return
}
return publicKeyID(pk), buf.String(), nil
} | [
"func",
"ParseArmoredPublicKey",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"shortKeyId",
",",
"armoredKey",
"string",
",",
"err",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"pk",
",",
"err",
":=",
"openArmoredPublicKeyFile",
"(",
"ioutil",
".",
"NopCloser",
"(",
"io",
".",
"TeeReader",
"(",
"r",
",",
"&",
"buf",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"return",
"publicKeyID",
"(",
"pk",
")",
",",
"buf",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] | // ParseArmoredPublicKey tries to parse an armored public key from r,
// taking care to bound the amount it reads.
// The returned shortKeyId is 8 capital hex digits.
// The returned armoredKey is a copy of the contents read. | [
"ParseArmoredPublicKey",
"tries",
"to",
"parse",
"an",
"armored",
"public",
"key",
"from",
"r",
"taking",
"care",
"to",
"bound",
"the",
"amount",
"it",
"reads",
".",
"The",
"returned",
"shortKeyId",
"is",
"8",
"capital",
"hex",
"digits",
".",
"The",
"returned",
"armoredKey",
"is",
"a",
"copy",
"of",
"the",
"contents",
"read",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L43-L50 | train |
perkeep/perkeep | pkg/jsonsign/keys.go | NewEntity | func NewEntity() (*openpgp.Entity, error) {
name := "" // intentionally empty
comment := "camlistore"
email := "" // intentionally empty
return openpgp.NewEntity(name, comment, email, nil)
} | go | func NewEntity() (*openpgp.Entity, error) {
name := "" // intentionally empty
comment := "camlistore"
email := "" // intentionally empty
return openpgp.NewEntity(name, comment, email, nil)
} | [
"func",
"NewEntity",
"(",
")",
"(",
"*",
"openpgp",
".",
"Entity",
",",
"error",
")",
"{",
"name",
":=",
"\"",
"\"",
"// intentionally empty",
"\n",
"comment",
":=",
"\"",
"\"",
"\n",
"email",
":=",
"\"",
"\"",
"// intentionally empty",
"\n",
"return",
"openpgp",
".",
"NewEntity",
"(",
"name",
",",
"comment",
",",
"email",
",",
"nil",
")",
"\n",
"}"
] | // NewEntity returns a new OpenPGP entity. | [
"NewEntity",
"returns",
"a",
"new",
"OpenPGP",
"entity",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L161-L166 | train |
perkeep/perkeep | pkg/jsonsign/keys.go | KeyIdFromRing | func KeyIdFromRing(secRing string) (keyID string, err error) {
f, err := wkfs.Open(secRing)
if err != nil {
return "", fmt.Errorf("Could not open secret ring file %v: %v", secRing, err)
}
defer f.Close()
el, err := openpgp.ReadKeyRing(f)
if err != nil {
return "", fmt.Errorf("Could not read secret ring file %s: %v", secRing, err)
}
if len(el) != 1 {
return "", fmt.Errorf("Secret ring file %v contained %d identities; expected 1", secRing, len(el))
}
ent := el[0]
return ent.PrimaryKey.KeyIdString(), nil
} | go | func KeyIdFromRing(secRing string) (keyID string, err error) {
f, err := wkfs.Open(secRing)
if err != nil {
return "", fmt.Errorf("Could not open secret ring file %v: %v", secRing, err)
}
defer f.Close()
el, err := openpgp.ReadKeyRing(f)
if err != nil {
return "", fmt.Errorf("Could not read secret ring file %s: %v", secRing, err)
}
if len(el) != 1 {
return "", fmt.Errorf("Secret ring file %v contained %d identities; expected 1", secRing, len(el))
}
ent := el[0]
return ent.PrimaryKey.KeyIdString(), nil
} | [
"func",
"KeyIdFromRing",
"(",
"secRing",
"string",
")",
"(",
"keyID",
"string",
",",
"err",
"error",
")",
"{",
"f",
",",
"err",
":=",
"wkfs",
".",
"Open",
"(",
"secRing",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"secRing",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"el",
",",
"err",
":=",
"openpgp",
".",
"ReadKeyRing",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"secRing",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"el",
")",
"!=",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"secRing",
",",
"len",
"(",
"el",
")",
")",
"\n",
"}",
"\n",
"ent",
":=",
"el",
"[",
"0",
"]",
"\n",
"return",
"ent",
".",
"PrimaryKey",
".",
"KeyIdString",
"(",
")",
",",
"nil",
"\n",
"}"
] | // KeyIdFromRing returns the public keyID contained in the secret
// ring file secRing. It expects only one keyID in this secret ring
// and returns an error otherwise. | [
"KeyIdFromRing",
"returns",
"the",
"public",
"keyID",
"contained",
"in",
"the",
"secret",
"ring",
"file",
"secRing",
".",
"It",
"expects",
"only",
"one",
"keyID",
"in",
"this",
"secret",
"ring",
"and",
"returns",
"an",
"error",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L180-L195 | train |
perkeep/perkeep | pkg/jsonsign/keys.go | GenerateNewSecRing | func GenerateNewSecRing(secRing string) (keyID string, err error) {
ent, err := NewEntity()
if err != nil {
return "", fmt.Errorf("generating new identity: %v", err)
}
if err := os.MkdirAll(filepath.Dir(secRing), 0700); err != nil {
return "", err
}
f, err := wkfs.OpenFile(secRing, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
if err != nil {
return "", err
}
err = WriteKeyRing(f, openpgp.EntityList([]*openpgp.Entity{ent}))
if err != nil {
f.Close()
return "", fmt.Errorf("Could not write new key ring to %s: %v", secRing, err)
}
if err := f.Close(); err != nil {
return "", fmt.Errorf("Could not close %v: %v", secRing, err)
}
return ent.PrimaryKey.KeyIdString(), nil
} | go | func GenerateNewSecRing(secRing string) (keyID string, err error) {
ent, err := NewEntity()
if err != nil {
return "", fmt.Errorf("generating new identity: %v", err)
}
if err := os.MkdirAll(filepath.Dir(secRing), 0700); err != nil {
return "", err
}
f, err := wkfs.OpenFile(secRing, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
if err != nil {
return "", err
}
err = WriteKeyRing(f, openpgp.EntityList([]*openpgp.Entity{ent}))
if err != nil {
f.Close()
return "", fmt.Errorf("Could not write new key ring to %s: %v", secRing, err)
}
if err := f.Close(); err != nil {
return "", fmt.Errorf("Could not close %v: %v", secRing, err)
}
return ent.PrimaryKey.KeyIdString(), nil
} | [
"func",
"GenerateNewSecRing",
"(",
"secRing",
"string",
")",
"(",
"keyID",
"string",
",",
"err",
"error",
")",
"{",
"ent",
",",
"err",
":=",
"NewEntity",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"secRing",
")",
",",
"0700",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"f",
",",
"err",
":=",
"wkfs",
".",
"OpenFile",
"(",
"secRing",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_EXCL",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"WriteKeyRing",
"(",
"f",
",",
"openpgp",
".",
"EntityList",
"(",
"[",
"]",
"*",
"openpgp",
".",
"Entity",
"{",
"ent",
"}",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"secRing",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"secRing",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"ent",
".",
"PrimaryKey",
".",
"KeyIdString",
"(",
")",
",",
"nil",
"\n",
"}"
] | // GenerateNewSecRing creates a new secret ring file secRing, with
// a new GPG identity. It returns the public keyID of that identity.
// It returns an error if the file already exists. | [
"GenerateNewSecRing",
"creates",
"a",
"new",
"secret",
"ring",
"file",
"secRing",
"with",
"a",
"new",
"GPG",
"identity",
".",
"It",
"returns",
"the",
"public",
"keyID",
"of",
"that",
"identity",
".",
"It",
"returns",
"an",
"error",
"if",
"the",
"file",
"already",
"exists",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L200-L221 | train |
perkeep/perkeep | pkg/client/client.go | New | func New(opts ...ClientOption) (*Client, error) {
c := &Client{
haveCache: noHaveCache{},
Logger: log.New(os.Stderr, "", log.Ldate|log.Ltime),
authMode: auth.None{},
}
for _, v := range opts {
v.modifyClient(c)
}
if c.sto != nil && len(opts) > 1 {
return nil, errors.New("use of OptionUseStorageClient precludes use of any other options")
}
if inGopherJS {
c.noExtConfig = true
c.sameOrigin = true
}
if c.noExtConfig {
c.setDefaultHTTPClient()
return c, nil
}
if c.server != "" {
if !isURLOrHostPort(c.server) {
configOnce.Do(parseConfig)
serverConf, ok := config.Servers[c.server]
if !ok {
log.Fatalf("%q looks like a server alias, but no such alias found in config at %v", c.server, osutil.UserClientConfigPath())
}
c.server = serverConf.Server
}
c.setDefaultHTTPClient()
return c, nil
}
var err error
c.server, err = getServer()
if err != nil {
return nil, err
}
err = c.SetupAuth()
if err != nil {
return nil, err
}
c.setDefaultHTTPClient()
return c, nil
} | go | func New(opts ...ClientOption) (*Client, error) {
c := &Client{
haveCache: noHaveCache{},
Logger: log.New(os.Stderr, "", log.Ldate|log.Ltime),
authMode: auth.None{},
}
for _, v := range opts {
v.modifyClient(c)
}
if c.sto != nil && len(opts) > 1 {
return nil, errors.New("use of OptionUseStorageClient precludes use of any other options")
}
if inGopherJS {
c.noExtConfig = true
c.sameOrigin = true
}
if c.noExtConfig {
c.setDefaultHTTPClient()
return c, nil
}
if c.server != "" {
if !isURLOrHostPort(c.server) {
configOnce.Do(parseConfig)
serverConf, ok := config.Servers[c.server]
if !ok {
log.Fatalf("%q looks like a server alias, but no such alias found in config at %v", c.server, osutil.UserClientConfigPath())
}
c.server = serverConf.Server
}
c.setDefaultHTTPClient()
return c, nil
}
var err error
c.server, err = getServer()
if err != nil {
return nil, err
}
err = c.SetupAuth()
if err != nil {
return nil, err
}
c.setDefaultHTTPClient()
return c, nil
} | [
"func",
"New",
"(",
"opts",
"...",
"ClientOption",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"c",
":=",
"&",
"Client",
"{",
"haveCache",
":",
"noHaveCache",
"{",
"}",
",",
"Logger",
":",
"log",
".",
"New",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"log",
".",
"Ldate",
"|",
"log",
".",
"Ltime",
")",
",",
"authMode",
":",
"auth",
".",
"None",
"{",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"opts",
"{",
"v",
".",
"modifyClient",
"(",
"c",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"sto",
"!=",
"nil",
"&&",
"len",
"(",
"opts",
")",
">",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"inGopherJS",
"{",
"c",
".",
"noExtConfig",
"=",
"true",
"\n",
"c",
".",
"sameOrigin",
"=",
"true",
"\n",
"}",
"\n",
"if",
"c",
".",
"noExtConfig",
"{",
"c",
".",
"setDefaultHTTPClient",
"(",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"server",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isURLOrHostPort",
"(",
"c",
".",
"server",
")",
"{",
"configOnce",
".",
"Do",
"(",
"parseConfig",
")",
"\n",
"serverConf",
",",
"ok",
":=",
"config",
".",
"Servers",
"[",
"c",
".",
"server",
"]",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"c",
".",
"server",
",",
"osutil",
".",
"UserClientConfigPath",
"(",
")",
")",
"\n",
"}",
"\n",
"c",
".",
"server",
"=",
"serverConf",
".",
"Server",
"\n",
"}",
"\n",
"c",
".",
"setDefaultHTTPClient",
"(",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"c",
".",
"server",
",",
"err",
"=",
"getServer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"c",
".",
"SetupAuth",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"c",
".",
"setDefaultHTTPClient",
"(",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // New returns a new Perkeep Client.
//
// By default, with no options, it uses the client as configured in
// the environment or default configuration files. | [
"New",
"returns",
"a",
"new",
"Perkeep",
"Client",
".",
"By",
"default",
"with",
"no",
"options",
"it",
"uses",
"the",
"client",
"as",
"configured",
"in",
"the",
"environment",
"or",
"default",
"configuration",
"files",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L173-L219 | train |
perkeep/perkeep | pkg/client/client.go | NewOrFail | func NewOrFail(opts ...ClientOption) *Client {
c, err := New(opts...)
if err != nil {
log.Fatalf("error creating client: %v", err)
}
return c
} | go | func NewOrFail(opts ...ClientOption) *Client {
c, err := New(opts...)
if err != nil {
log.Fatalf("error creating client: %v", err)
}
return c
} | [
"func",
"NewOrFail",
"(",
"opts",
"...",
"ClientOption",
")",
"*",
"Client",
"{",
"c",
",",
"err",
":=",
"New",
"(",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
"\n",
"}"
] | // NewOrFail is like New, but calls log.Fatal instead of returning an error. | [
"NewOrFail",
"is",
"like",
"New",
"but",
"calls",
"log",
".",
"Fatal",
"instead",
"of",
"returning",
"an",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L231-L237 | train |
perkeep/perkeep | pkg/client/client.go | NewPathClient | func (c *Client) NewPathClient(path string) (*Client, error) {
u, err := url.Parse(c.server)
if err != nil {
return nil, fmt.Errorf("bogus server %q for NewPathClient receiver: %v", c.server, err)
}
u.Path = path
pc, err := New(OptionServer(u.String()))
if err != nil {
return nil, err
}
pc.authMode = c.authMode
pc.discoOnce.Do(noop)
return pc, nil
} | go | func (c *Client) NewPathClient(path string) (*Client, error) {
u, err := url.Parse(c.server)
if err != nil {
return nil, fmt.Errorf("bogus server %q for NewPathClient receiver: %v", c.server, err)
}
u.Path = path
pc, err := New(OptionServer(u.String()))
if err != nil {
return nil, err
}
pc.authMode = c.authMode
pc.discoOnce.Do(noop)
return pc, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"NewPathClient",
"(",
"path",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"c",
".",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
".",
"server",
",",
"err",
")",
"\n",
"}",
"\n",
"u",
".",
"Path",
"=",
"path",
"\n",
"pc",
",",
"err",
":=",
"New",
"(",
"OptionServer",
"(",
"u",
".",
"String",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"pc",
".",
"authMode",
"=",
"c",
".",
"authMode",
"\n",
"pc",
".",
"discoOnce",
".",
"Do",
"(",
"noop",
")",
"\n",
"return",
"pc",
",",
"nil",
"\n",
"}"
] | // NewPathClient returns a new client accessing a subpath of c. | [
"NewPathClient",
"returns",
"a",
"new",
"client",
"accessing",
"a",
"subpath",
"of",
"c",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L240-L253 | train |
perkeep/perkeep | pkg/client/client.go | transportForConfig | func (c *Client) transportForConfig(tc *TransportConfig) http.RoundTripper {
if inGopherJS {
// Calls to net.Dial* functions - which would happen if the client's transport
// is not nil - are prohibited with GopherJS. So we force nil here, so that the
// call to transportForConfig in newClient is of no consequence when on the
// browser.
return nil
}
if c == nil {
return nil
}
var transport http.RoundTripper
proxy := http.ProxyFromEnvironment
if tc != nil && tc.Proxy != nil {
proxy = tc.Proxy
}
if c.useHTTP2(tc) {
transport = &http2.Transport{
DialTLS: c.http2DialTLSFunc(),
}
} else {
transport = &http.Transport{
DialTLS: c.DialTLSFunc(),
Dial: c.DialFunc(),
Proxy: proxy,
MaxIdleConnsPerHost: maxParallelHTTP_h1,
}
}
httpStats := &httputil.StatsTransport{
Transport: transport,
}
if tc != nil {
httpStats.VerboseLog = tc.Verbose
}
transport = httpStats
if android.IsChild() {
transport = &android.StatsTransport{transport}
}
return transport
} | go | func (c *Client) transportForConfig(tc *TransportConfig) http.RoundTripper {
if inGopherJS {
// Calls to net.Dial* functions - which would happen if the client's transport
// is not nil - are prohibited with GopherJS. So we force nil here, so that the
// call to transportForConfig in newClient is of no consequence when on the
// browser.
return nil
}
if c == nil {
return nil
}
var transport http.RoundTripper
proxy := http.ProxyFromEnvironment
if tc != nil && tc.Proxy != nil {
proxy = tc.Proxy
}
if c.useHTTP2(tc) {
transport = &http2.Transport{
DialTLS: c.http2DialTLSFunc(),
}
} else {
transport = &http.Transport{
DialTLS: c.DialTLSFunc(),
Dial: c.DialFunc(),
Proxy: proxy,
MaxIdleConnsPerHost: maxParallelHTTP_h1,
}
}
httpStats := &httputil.StatsTransport{
Transport: transport,
}
if tc != nil {
httpStats.VerboseLog = tc.Verbose
}
transport = httpStats
if android.IsChild() {
transport = &android.StatsTransport{transport}
}
return transport
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"transportForConfig",
"(",
"tc",
"*",
"TransportConfig",
")",
"http",
".",
"RoundTripper",
"{",
"if",
"inGopherJS",
"{",
"// Calls to net.Dial* functions - which would happen if the client's transport",
"// is not nil - are prohibited with GopherJS. So we force nil here, so that the",
"// call to transportForConfig in newClient is of no consequence when on the",
"// browser.",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"c",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"transport",
"http",
".",
"RoundTripper",
"\n",
"proxy",
":=",
"http",
".",
"ProxyFromEnvironment",
"\n",
"if",
"tc",
"!=",
"nil",
"&&",
"tc",
".",
"Proxy",
"!=",
"nil",
"{",
"proxy",
"=",
"tc",
".",
"Proxy",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"useHTTP2",
"(",
"tc",
")",
"{",
"transport",
"=",
"&",
"http2",
".",
"Transport",
"{",
"DialTLS",
":",
"c",
".",
"http2DialTLSFunc",
"(",
")",
",",
"}",
"\n",
"}",
"else",
"{",
"transport",
"=",
"&",
"http",
".",
"Transport",
"{",
"DialTLS",
":",
"c",
".",
"DialTLSFunc",
"(",
")",
",",
"Dial",
":",
"c",
".",
"DialFunc",
"(",
")",
",",
"Proxy",
":",
"proxy",
",",
"MaxIdleConnsPerHost",
":",
"maxParallelHTTP_h1",
",",
"}",
"\n",
"}",
"\n",
"httpStats",
":=",
"&",
"httputil",
".",
"StatsTransport",
"{",
"Transport",
":",
"transport",
",",
"}",
"\n",
"if",
"tc",
"!=",
"nil",
"{",
"httpStats",
".",
"VerboseLog",
"=",
"tc",
".",
"Verbose",
"\n",
"}",
"\n",
"transport",
"=",
"httpStats",
"\n",
"if",
"android",
".",
"IsChild",
"(",
")",
"{",
"transport",
"=",
"&",
"android",
".",
"StatsTransport",
"{",
"transport",
"}",
"\n",
"}",
"\n",
"return",
"transport",
"\n",
"}"
] | // transportForConfig returns a transport for the client, setting the correct
// Proxy, Dial, and TLSClientConfig if needed. It does not mutate c.
// It is the caller's responsibility to then use that transport to set
// the client's httpClient with SetHTTPClient. | [
"transportForConfig",
"returns",
"a",
"transport",
"for",
"the",
"client",
"setting",
"the",
"correct",
"Proxy",
"Dial",
"and",
"TLSClientConfig",
"if",
"needed",
".",
"It",
"does",
"not",
"mutate",
"c",
".",
"It",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"then",
"use",
"that",
"transport",
"to",
"set",
"the",
"client",
"s",
"httpClient",
"with",
"SetHTTPClient",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L283-L323 | train |
perkeep/perkeep | pkg/client/client.go | HTTPStats | func (c *Client) HTTPStats() *httputil.StatsTransport {
st, _ := c.httpClient.Transport.(*httputil.StatsTransport)
return st
} | go | func (c *Client) HTTPStats() *httputil.StatsTransport {
st, _ := c.httpClient.Transport.(*httputil.StatsTransport)
return st
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HTTPStats",
"(",
")",
"*",
"httputil",
".",
"StatsTransport",
"{",
"st",
",",
"_",
":=",
"c",
".",
"httpClient",
".",
"Transport",
".",
"(",
"*",
"httputil",
".",
"StatsTransport",
")",
"\n",
"return",
"st",
"\n",
"}"
] | // HTTPStats returns the client's underlying httputil.StatsTransport, if in use.
// If another transport is being used, nil is returned. | [
"HTTPStats",
"returns",
"the",
"client",
"s",
"underlying",
"httputil",
".",
"StatsTransport",
"if",
"in",
"use",
".",
"If",
"another",
"transport",
"is",
"being",
"used",
"nil",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L327-L330 | train |
perkeep/perkeep | pkg/client/client.go | NewFromShareRoot | func NewFromShareRoot(ctx context.Context, shareBlobURL string, opts ...ClientOption) (c *Client, target blob.Ref, err error) {
var root string
m := shareURLRx.FindStringSubmatch(shareBlobURL)
if m == nil {
return nil, blob.Ref{}, fmt.Errorf("Unknown share URL base")
}
c, err = New(append(opts[:len(opts):cap(opts)], OptionServer(m[1]))...)
if err != nil {
return nil, blob.Ref{}, err
}
c.discoOnce.Do(noop)
c.prefixOnce.Do(noop)
c.prefixv = m[1]
c.isSharePrefix = true
c.authMode = auth.None{}
c.via = make(map[blob.Ref]blob.Ref)
root = m[2]
req := c.newRequest(ctx, "GET", shareBlobURL, nil)
res, err := c.expect2XX(req)
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error fetching %s: %v", shareBlobURL, err)
}
defer res.Body.Close()
var buf bytes.Buffer
rootbr, ok := blob.Parse(root)
if !ok {
return nil, blob.Ref{}, fmt.Errorf("invalid root blob ref for sharing: %q", root)
}
b, err := schema.BlobFromReader(rootbr, io.TeeReader(res.Body, &buf))
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error parsing JSON from %s: %v , with response: %q", shareBlobURL, err, buf.Bytes())
}
if b.ShareAuthType() != schema.ShareHaveRef {
return nil, blob.Ref{}, fmt.Errorf("unknown share authType of %q", b.ShareAuthType())
}
target = b.ShareTarget()
if !target.Valid() {
return nil, blob.Ref{}, fmt.Errorf("no target")
}
c.via[target] = rootbr
return c, target, nil
} | go | func NewFromShareRoot(ctx context.Context, shareBlobURL string, opts ...ClientOption) (c *Client, target blob.Ref, err error) {
var root string
m := shareURLRx.FindStringSubmatch(shareBlobURL)
if m == nil {
return nil, blob.Ref{}, fmt.Errorf("Unknown share URL base")
}
c, err = New(append(opts[:len(opts):cap(opts)], OptionServer(m[1]))...)
if err != nil {
return nil, blob.Ref{}, err
}
c.discoOnce.Do(noop)
c.prefixOnce.Do(noop)
c.prefixv = m[1]
c.isSharePrefix = true
c.authMode = auth.None{}
c.via = make(map[blob.Ref]blob.Ref)
root = m[2]
req := c.newRequest(ctx, "GET", shareBlobURL, nil)
res, err := c.expect2XX(req)
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error fetching %s: %v", shareBlobURL, err)
}
defer res.Body.Close()
var buf bytes.Buffer
rootbr, ok := blob.Parse(root)
if !ok {
return nil, blob.Ref{}, fmt.Errorf("invalid root blob ref for sharing: %q", root)
}
b, err := schema.BlobFromReader(rootbr, io.TeeReader(res.Body, &buf))
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error parsing JSON from %s: %v , with response: %q", shareBlobURL, err, buf.Bytes())
}
if b.ShareAuthType() != schema.ShareHaveRef {
return nil, blob.Ref{}, fmt.Errorf("unknown share authType of %q", b.ShareAuthType())
}
target = b.ShareTarget()
if !target.Valid() {
return nil, blob.Ref{}, fmt.Errorf("no target")
}
c.via[target] = rootbr
return c, target, nil
} | [
"func",
"NewFromShareRoot",
"(",
"ctx",
"context",
".",
"Context",
",",
"shareBlobURL",
"string",
",",
"opts",
"...",
"ClientOption",
")",
"(",
"c",
"*",
"Client",
",",
"target",
"blob",
".",
"Ref",
",",
"err",
"error",
")",
"{",
"var",
"root",
"string",
"\n",
"m",
":=",
"shareURLRx",
".",
"FindStringSubmatch",
"(",
"shareBlobURL",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
",",
"err",
"=",
"New",
"(",
"append",
"(",
"opts",
"[",
":",
"len",
"(",
"opts",
")",
":",
"cap",
"(",
"opts",
")",
"]",
",",
"OptionServer",
"(",
"m",
"[",
"1",
"]",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"c",
".",
"discoOnce",
".",
"Do",
"(",
"noop",
")",
"\n",
"c",
".",
"prefixOnce",
".",
"Do",
"(",
"noop",
")",
"\n",
"c",
".",
"prefixv",
"=",
"m",
"[",
"1",
"]",
"\n",
"c",
".",
"isSharePrefix",
"=",
"true",
"\n",
"c",
".",
"authMode",
"=",
"auth",
".",
"None",
"{",
"}",
"\n",
"c",
".",
"via",
"=",
"make",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"blob",
".",
"Ref",
")",
"\n",
"root",
"=",
"m",
"[",
"2",
"]",
"\n\n",
"req",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"",
"\"",
",",
"shareBlobURL",
",",
"nil",
")",
"\n",
"res",
",",
"err",
":=",
"c",
".",
"expect2XX",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"shareBlobURL",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"rootbr",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"root",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"root",
")",
"\n",
"}",
"\n",
"b",
",",
"err",
":=",
"schema",
".",
"BlobFromReader",
"(",
"rootbr",
",",
"io",
".",
"TeeReader",
"(",
"res",
".",
"Body",
",",
"&",
"buf",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"shareBlobURL",
",",
"err",
",",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"b",
".",
"ShareAuthType",
"(",
")",
"!=",
"schema",
".",
"ShareHaveRef",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"b",
".",
"ShareAuthType",
"(",
")",
")",
"\n",
"}",
"\n",
"target",
"=",
"b",
".",
"ShareTarget",
"(",
")",
"\n",
"if",
"!",
"target",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
".",
"via",
"[",
"target",
"]",
"=",
"rootbr",
"\n",
"return",
"c",
",",
"target",
",",
"nil",
"\n",
"}"
] | // NewFromShareRoot uses shareBlobURL to set up and return a client that
// will be used to fetch shared blobs. | [
"NewFromShareRoot",
"uses",
"shareBlobURL",
"to",
"set",
"up",
"and",
"return",
"a",
"client",
"that",
"will",
"be",
"used",
"to",
"fetch",
"shared",
"blobs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L449-L491 | train |
perkeep/perkeep | pkg/client/client.go | SetHTTPClient | func (c *Client) SetHTTPClient(client *http.Client) {
if client == nil {
client = http.DefaultClient
}
c.httpClient = client
} | go | func (c *Client) SetHTTPClient(client *http.Client) {
if client == nil {
client = http.DefaultClient
}
c.httpClient = client
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"{",
"if",
"client",
"==",
"nil",
"{",
"client",
"=",
"http",
".",
"DefaultClient",
"\n",
"}",
"\n",
"c",
".",
"httpClient",
"=",
"client",
"\n",
"}"
] | // SetHTTPClient sets the Perkeep client's HTTP client.
// If nil, the default HTTP client is used. | [
"SetHTTPClient",
"sets",
"the",
"Perkeep",
"client",
"s",
"HTTP",
"client",
".",
"If",
"nil",
"the",
"default",
"HTTP",
"client",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L495-L500 | train |
perkeep/perkeep | pkg/client/client.go | BlobRoot | func (c *Client) BlobRoot() (string, error) {
prefix, err := c.prefix()
if err != nil {
return "", err
}
return prefix + "/", nil
} | go | func (c *Client) BlobRoot() (string, error) {
prefix, err := c.prefix()
if err != nil {
return "", err
}
return prefix + "/", nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"BlobRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"prefix",
",",
"err",
":=",
"c",
".",
"prefix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"prefix",
"+",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] | // BlobRoot returns the server's blobroot URL prefix.
// If the client was constructed with an explicit path,
// that path is used. Otherwise the server's
// default advertised blobRoot is used. | [
"BlobRoot",
"returns",
"the",
"server",
"s",
"blobroot",
"URL",
"prefix",
".",
"If",
"the",
"client",
"was",
"constructed",
"with",
"an",
"explicit",
"path",
"that",
"path",
"is",
"used",
".",
"Otherwise",
"the",
"server",
"s",
"default",
"advertised",
"blobRoot",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L560-L566 | train |
perkeep/perkeep | pkg/client/client.go | ServerPublicKeyBlobRef | func (c *Client) ServerPublicKeyBlobRef() (blob.Ref, error) {
if err := c.condDiscovery(); err != nil {
return blob.Ref{}, err
}
if !c.serverPublicKeyBlobRef.Valid() {
return blob.Ref{}, ErrNoSigning
}
return c.serverPublicKeyBlobRef, nil
} | go | func (c *Client) ServerPublicKeyBlobRef() (blob.Ref, error) {
if err := c.condDiscovery(); err != nil {
return blob.Ref{}, err
}
if !c.serverPublicKeyBlobRef.Valid() {
return blob.Ref{}, ErrNoSigning
}
return c.serverPublicKeyBlobRef, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ServerPublicKeyBlobRef",
"(",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"blob",
".",
"Ref",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"c",
".",
"serverPublicKeyBlobRef",
".",
"Valid",
"(",
")",
"{",
"return",
"blob",
".",
"Ref",
"{",
"}",
",",
"ErrNoSigning",
"\n",
"}",
"\n",
"return",
"c",
".",
"serverPublicKeyBlobRef",
",",
"nil",
"\n",
"}"
] | // ServerPublicKeyBlobRef returns the server's public key blobRef
// If the server isn't running a sign handler, the error will be ErrNoSigning. | [
"ServerPublicKeyBlobRef",
"returns",
"the",
"server",
"s",
"public",
"key",
"blobRef",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"sign",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSigning",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L583-L592 | train |
perkeep/perkeep | pkg/client/client.go | SearchRoot | func (c *Client) SearchRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.searchRoot == "" {
return "", ErrNoSearchRoot
}
return c.searchRoot, nil
} | go | func (c *Client) SearchRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.searchRoot == "" {
return "", ErrNoSearchRoot
}
return c.searchRoot, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SearchRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"c",
".",
"searchRoot",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrNoSearchRoot",
"\n",
"}",
"\n",
"return",
"c",
".",
"searchRoot",
",",
"nil",
"\n",
"}"
] | // SearchRoot returns the server's search handler.
// If the server isn't running an index and search handler, the error
// will be ErrNoSearchRoot. | [
"SearchRoot",
"returns",
"the",
"server",
"s",
"search",
"handler",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"an",
"index",
"and",
"search",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSearchRoot",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L597-L605 | train |
perkeep/perkeep | pkg/client/client.go | HelpRoot | func (c *Client) HelpRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.helpRoot == "" {
return "", ErrNoHelpRoot
}
return c.helpRoot, nil
} | go | func (c *Client) HelpRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.helpRoot == "" {
return "", ErrNoHelpRoot
}
return c.helpRoot, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HelpRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"c",
".",
"helpRoot",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrNoHelpRoot",
"\n",
"}",
"\n",
"return",
"c",
".",
"helpRoot",
",",
"nil",
"\n",
"}"
] | // HelpRoot returns the server's help handler.
// If the server isn't running a help handler, the error will be
// ErrNoHelpRoot. | [
"HelpRoot",
"returns",
"the",
"server",
"s",
"help",
"handler",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"help",
"handler",
"the",
"error",
"will",
"be",
"ErrNoHelpRoot",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L610-L618 | train |
perkeep/perkeep | pkg/client/client.go | ShareRoot | func (c *Client) ShareRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.shareRoot == "" {
return "", ErrNoShareRoot
}
return c.shareRoot, nil
} | go | func (c *Client) ShareRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.shareRoot == "" {
return "", ErrNoShareRoot
}
return c.shareRoot, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ShareRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"c",
".",
"shareRoot",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrNoShareRoot",
"\n",
"}",
"\n",
"return",
"c",
".",
"shareRoot",
",",
"nil",
"\n",
"}"
] | // ShareRoot returns the server's share handler prefix URL.
// If the server isn't running a share handler, the error will be
// ErrNoShareRoot. | [
"ShareRoot",
"returns",
"the",
"server",
"s",
"share",
"handler",
"prefix",
"URL",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"share",
"handler",
"the",
"error",
"will",
"be",
"ErrNoShareRoot",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L623-L631 | train |
perkeep/perkeep | pkg/client/client.go | SignHandler | func (c *Client) SignHandler() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.signHandler == "" {
return "", ErrNoSigning
}
return c.signHandler, nil
} | go | func (c *Client) SignHandler() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.signHandler == "" {
return "", ErrNoSigning
}
return c.signHandler, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SignHandler",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"c",
".",
"signHandler",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrNoSigning",
"\n",
"}",
"\n",
"return",
"c",
".",
"signHandler",
",",
"nil",
"\n",
"}"
] | // SignHandler returns the server's sign handler.
// If the server isn't running a sign handler, the error will be
// ErrNoSigning. | [
"SignHandler",
"returns",
"the",
"server",
"s",
"sign",
"handler",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"sign",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSigning",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L636-L644 | train |
perkeep/perkeep | pkg/client/client.go | StorageGeneration | func (c *Client) StorageGeneration() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.storageGen == "" {
return "", ErrNoStorageGeneration
}
return c.storageGen, nil
} | go | func (c *Client) StorageGeneration() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.storageGen == "" {
return "", ErrNoStorageGeneration
}
return c.storageGen, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"StorageGeneration",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"c",
".",
"storageGen",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrNoStorageGeneration",
"\n",
"}",
"\n",
"return",
"c",
".",
"storageGen",
",",
"nil",
"\n",
"}"
] | // StorageGeneration returns the server's unique ID for its storage
// generation, reset whenever storage is reset, moved, or partially
// lost.
//
// This is a value that can be used in client cache keys to add
// certainty that they're talking to the same instance as previously.
//
// If the server doesn't return such a value, the error will be
// ErrNoStorageGeneration. | [
"StorageGeneration",
"returns",
"the",
"server",
"s",
"unique",
"ID",
"for",
"its",
"storage",
"generation",
"reset",
"whenever",
"storage",
"is",
"reset",
"moved",
"or",
"partially",
"lost",
".",
"This",
"is",
"a",
"value",
"that",
"can",
"be",
"used",
"in",
"client",
"cache",
"keys",
"to",
"add",
"certainty",
"that",
"they",
"re",
"talking",
"to",
"the",
"same",
"instance",
"as",
"previously",
".",
"If",
"the",
"server",
"doesn",
"t",
"return",
"such",
"a",
"value",
"the",
"error",
"will",
"be",
"ErrNoStorageGeneration",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L655-L663 | train |
perkeep/perkeep | pkg/client/client.go | HasLegacySHA1 | func (c *Client) HasLegacySHA1() (bool, error) {
if err := c.condDiscovery(); err != nil {
return false, err
}
return c.hasLegacySHA1, nil
} | go | func (c *Client) HasLegacySHA1() (bool, error) {
if err := c.condDiscovery(); err != nil {
return false, err
}
return c.hasLegacySHA1, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HasLegacySHA1",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
".",
"hasLegacySHA1",
",",
"nil",
"\n",
"}"
] | // HasLegacySHA1 reports whether the server has SHA-1 blobs indexed. | [
"HasLegacySHA1",
"reports",
"whether",
"the",
"server",
"has",
"SHA",
"-",
"1",
"blobs",
"indexed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L666-L671 | train |
perkeep/perkeep | pkg/client/client.go | SyncHandlers | func (c *Client) SyncHandlers() ([]*SyncInfo, error) {
if err := c.condDiscovery(); err != nil {
return nil, err
}
if c.syncHandlers == nil {
return nil, ErrNoSync
}
return c.syncHandlers, nil
} | go | func (c *Client) SyncHandlers() ([]*SyncInfo, error) {
if err := c.condDiscovery(); err != nil {
return nil, err
}
if c.syncHandlers == nil {
return nil, ErrNoSync
}
return c.syncHandlers, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SyncHandlers",
"(",
")",
"(",
"[",
"]",
"*",
"SyncInfo",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"c",
".",
"syncHandlers",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrNoSync",
"\n",
"}",
"\n",
"return",
"c",
".",
"syncHandlers",
",",
"nil",
"\n",
"}"
] | // SyncHandlers returns the server's sync handlers "from" and
// "to" prefix URLs.
// If the server isn't running any sync handler, the error
// will be ErrNoSync. | [
"SyncHandlers",
"returns",
"the",
"server",
"s",
"sync",
"handlers",
"from",
"and",
"to",
"prefix",
"URLs",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"any",
"sync",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSync",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L685-L693 | train |
perkeep/perkeep | pkg/client/client.go | GetRecentPermanodes | func (c *Client) GetRecentPermanodes(ctx context.Context, req *search.RecentRequest) (*search.RecentResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
}
res := new(search.RecentResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | go | func (c *Client) GetRecentPermanodes(ctx context.Context, req *search.RecentRequest) (*search.RecentResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
}
res := new(search.RecentResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetRecentPermanodes",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"search",
".",
"RecentRequest",
")",
"(",
"*",
"search",
".",
"RecentResponse",
",",
"error",
")",
"{",
"sr",
",",
"err",
":=",
"c",
".",
"SearchRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"url",
":=",
"sr",
"+",
"req",
".",
"URLSuffix",
"(",
")",
"\n",
"hreq",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"",
"\"",
",",
"url",
")",
"\n",
"hres",
",",
"err",
":=",
"c",
".",
"expect2XX",
"(",
"hreq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"new",
"(",
"search",
".",
"RecentResponse",
")",
"\n",
"if",
"err",
":=",
"httputil",
".",
"DecodeJSON",
"(",
"hres",
",",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"res",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // GetRecentPermanodes implements search.GetRecentPermanoder against a remote server over HTTP. | [
"GetRecentPermanodes",
"implements",
"search",
".",
"GetRecentPermanoder",
"against",
"a",
"remote",
"server",
"over",
"HTTP",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L698-L717 | train |
perkeep/perkeep | pkg/client/client.go | GetPermanodesWithAttr | func (c *Client) GetPermanodesWithAttr(ctx context.Context, req *search.WithAttrRequest) (*search.WithAttrResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
}
res := new(search.WithAttrResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | go | func (c *Client) GetPermanodesWithAttr(ctx context.Context, req *search.WithAttrRequest) (*search.WithAttrResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
}
res := new(search.WithAttrResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetPermanodesWithAttr",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"search",
".",
"WithAttrRequest",
")",
"(",
"*",
"search",
".",
"WithAttrResponse",
",",
"error",
")",
"{",
"sr",
",",
"err",
":=",
"c",
".",
"SearchRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"url",
":=",
"sr",
"+",
"req",
".",
"URLSuffix",
"(",
")",
"\n",
"hreq",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"",
"\"",
",",
"url",
")",
"\n",
"hres",
",",
"err",
":=",
"c",
".",
"expect2XX",
"(",
"hreq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"new",
"(",
"search",
".",
"WithAttrResponse",
")",
"\n",
"if",
"err",
":=",
"httputil",
".",
"DecodeJSON",
"(",
"hres",
",",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"res",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // GetPermanodesWithAttr searches for permanodes that match the given search request.
// The Fuzzy option in the request must not be set, and the Attribute option
// must be set.
// Only indexed attributes may be queried. | [
"GetPermanodesWithAttr",
"searches",
"for",
"permanodes",
"that",
"match",
"the",
"given",
"search",
"request",
".",
"The",
"Fuzzy",
"option",
"in",
"the",
"request",
"must",
"not",
"be",
"set",
"and",
"the",
"Attribute",
"option",
"must",
"be",
"set",
".",
"Only",
"indexed",
"attributes",
"may",
"be",
"queried",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L723-L742 | train |
perkeep/perkeep | pkg/client/client.go | QueryRaw | func (c *Client) QueryRaw(ctx context.Context, req *search.SearchQuery) ([]byte, error) {
hres, err := c.query(ctx, req)
if err != nil {
return nil, err
}
defer hres.Body.Close()
return ioutil.ReadAll(hres.Body)
} | go | func (c *Client) QueryRaw(ctx context.Context, req *search.SearchQuery) ([]byte, error) {
hres, err := c.query(ctx, req)
if err != nil {
return nil, err
}
defer hres.Body.Close()
return ioutil.ReadAll(hres.Body)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"QueryRaw",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"search",
".",
"SearchQuery",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"hres",
",",
"err",
":=",
"c",
".",
"query",
"(",
"ctx",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"hres",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"ioutil",
".",
"ReadAll",
"(",
"hres",
".",
"Body",
")",
"\n",
"}"
] | // QueryRaw sends req and returns the body of the response, which should be the
// unparsed JSON of a search.SearchResult. | [
"QueryRaw",
"sends",
"req",
"and",
"returns",
"the",
"body",
"of",
"the",
"response",
"which",
"should",
"be",
"the",
"unparsed",
"JSON",
"of",
"a",
"search",
".",
"SearchResult",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L812-L819 | train |
perkeep/perkeep | pkg/client/client.go | versionMismatch | func (c *Client) versionMismatch(ctx context.Context) (bool, error) {
const shortRFC3339 = "2006-01-02"
version := buildinfo.GitInfo
if version == "" {
return false, errors.New("unknown client version")
}
version = version[:10] // keep only the date part
clientDate, err := time.Parse(shortRFC3339, version)
if err != nil {
return false, fmt.Errorf("could not parse date from version %q: %v", version, err)
}
apiChangeDate, _ := time.Parse(shortRFC3339, "2018-01-13")
if !clientDate.After(apiChangeDate) {
// client is old enough, all good.
return false, nil
}
url := c.discoRoot() + "/status/status.json"
req := c.newRequest(ctx, "GET", url)
res, err := c.doReqGated(req)
if err != nil {
return false, err
}
if res.StatusCode != 200 {
body, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1<<20))
res.Body.Close()
return false, fmt.Errorf("got status code %d from URL %s; body %s", res.StatusCode, url, body)
}
var status struct {
Version string `json:"version"`
}
if err := httputil.DecodeJSON(res, &status); err != nil {
return false, fmt.Errorf("error parsing JSON from URL %s: %v", url, err)
}
serverVersion := status.Version[:10]
serverDate, err := time.Parse(shortRFC3339, serverVersion)
if err != nil {
return false, fmt.Errorf("could not parse date from server version %q: %v", status.Version, err)
}
if serverDate.After(apiChangeDate) {
// server is recent enough, all good.
return false, nil
}
return true, nil
} | go | func (c *Client) versionMismatch(ctx context.Context) (bool, error) {
const shortRFC3339 = "2006-01-02"
version := buildinfo.GitInfo
if version == "" {
return false, errors.New("unknown client version")
}
version = version[:10] // keep only the date part
clientDate, err := time.Parse(shortRFC3339, version)
if err != nil {
return false, fmt.Errorf("could not parse date from version %q: %v", version, err)
}
apiChangeDate, _ := time.Parse(shortRFC3339, "2018-01-13")
if !clientDate.After(apiChangeDate) {
// client is old enough, all good.
return false, nil
}
url := c.discoRoot() + "/status/status.json"
req := c.newRequest(ctx, "GET", url)
res, err := c.doReqGated(req)
if err != nil {
return false, err
}
if res.StatusCode != 200 {
body, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1<<20))
res.Body.Close()
return false, fmt.Errorf("got status code %d from URL %s; body %s", res.StatusCode, url, body)
}
var status struct {
Version string `json:"version"`
}
if err := httputil.DecodeJSON(res, &status); err != nil {
return false, fmt.Errorf("error parsing JSON from URL %s: %v", url, err)
}
serverVersion := status.Version[:10]
serverDate, err := time.Parse(shortRFC3339, serverVersion)
if err != nil {
return false, fmt.Errorf("could not parse date from server version %q: %v", status.Version, err)
}
if serverDate.After(apiChangeDate) {
// server is recent enough, all good.
return false, nil
}
return true, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"versionMismatch",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"bool",
",",
"error",
")",
"{",
"const",
"shortRFC3339",
"=",
"\"",
"\"",
"\n",
"version",
":=",
"buildinfo",
".",
"GitInfo",
"\n",
"if",
"version",
"==",
"\"",
"\"",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"version",
"=",
"version",
"[",
":",
"10",
"]",
"// keep only the date part",
"\n",
"clientDate",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"shortRFC3339",
",",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"version",
",",
"err",
")",
"\n",
"}",
"\n",
"apiChangeDate",
",",
"_",
":=",
"time",
".",
"Parse",
"(",
"shortRFC3339",
",",
"\"",
"\"",
")",
"\n",
"if",
"!",
"clientDate",
".",
"After",
"(",
"apiChangeDate",
")",
"{",
"// client is old enough, all good.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"url",
":=",
"c",
".",
"discoRoot",
"(",
")",
"+",
"\"",
"\"",
"\n",
"req",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"",
"\"",
",",
"url",
")",
"\n",
"res",
",",
"err",
":=",
"c",
".",
"doReqGated",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"StatusCode",
"!=",
"200",
"{",
"body",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"io",
".",
"LimitReader",
"(",
"res",
".",
"Body",
",",
"1",
"<<",
"20",
")",
")",
"\n",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"StatusCode",
",",
"url",
",",
"body",
")",
"\n",
"}",
"\n",
"var",
"status",
"struct",
"{",
"Version",
"string",
"`json:\"version\"`",
"\n",
"}",
"\n",
"if",
"err",
":=",
"httputil",
".",
"DecodeJSON",
"(",
"res",
",",
"&",
"status",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"url",
",",
"err",
")",
"\n",
"}",
"\n",
"serverVersion",
":=",
"status",
".",
"Version",
"[",
":",
"10",
"]",
"\n",
"serverDate",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"shortRFC3339",
",",
"serverVersion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"status",
".",
"Version",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"serverDate",
".",
"After",
"(",
"apiChangeDate",
")",
"{",
"// server is recent enough, all good.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // versionMismatch returns true if the server was built before 2018-01-13 and
// the client was built at or after 2018-01-13. | [
"versionMismatch",
"returns",
"true",
"if",
"the",
"server",
"was",
"built",
"before",
"2018",
"-",
"01",
"-",
"13",
"and",
"the",
"client",
"was",
"built",
"at",
"or",
"after",
"2018",
"-",
"01",
"-",
"13",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L884-L927 | train |
perkeep/perkeep | pkg/client/client.go | FileHasContents | func (c *Client) FileHasContents(ctx context.Context, f, wholeRef blob.Ref) bool {
if err := c.condDiscovery(); err != nil {
return false
}
if c.downloadHelper == "" {
return false
}
req := c.newRequest(ctx, "HEAD", c.downloadHelper+f.String()+"/?verifycontents="+wholeRef.String())
res, err := c.expect2XX(req)
if err != nil {
log.Printf("download helper HEAD error: %v", err)
return false
}
defer res.Body.Close()
return res.Header.Get("X-Camli-Contents") == wholeRef.String()
} | go | func (c *Client) FileHasContents(ctx context.Context, f, wholeRef blob.Ref) bool {
if err := c.condDiscovery(); err != nil {
return false
}
if c.downloadHelper == "" {
return false
}
req := c.newRequest(ctx, "HEAD", c.downloadHelper+f.String()+"/?verifycontents="+wholeRef.String())
res, err := c.expect2XX(req)
if err != nil {
log.Printf("download helper HEAD error: %v", err)
return false
}
defer res.Body.Close()
return res.Header.Get("X-Camli-Contents") == wholeRef.String()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"FileHasContents",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
",",
"wholeRef",
"blob",
".",
"Ref",
")",
"bool",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"downloadHelper",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"req",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"",
"\"",
",",
"c",
".",
"downloadHelper",
"+",
"f",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"wholeRef",
".",
"String",
"(",
")",
")",
"\n",
"res",
",",
"err",
":=",
"c",
".",
"expect2XX",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"res",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"==",
"wholeRef",
".",
"String",
"(",
")",
"\n",
"}"
] | // FileHasContents returns true iff f refers to a "file" or "bytes" schema blob,
// the server is configured with a "download helper", and the server responds
// that all chunks of 'f' are available and match the digest of wholeRef. | [
"FileHasContents",
"returns",
"true",
"iff",
"f",
"refers",
"to",
"a",
"file",
"or",
"bytes",
"schema",
"blob",
"the",
"server",
"is",
"configured",
"with",
"a",
"download",
"helper",
"and",
"the",
"server",
"responds",
"that",
"all",
"chunks",
"of",
"f",
"are",
"available",
"and",
"match",
"the",
"digest",
"of",
"wholeRef",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L932-L947 | train |
perkeep/perkeep | pkg/client/client.go | initPrefix | func (c *Client) initPrefix() error {
c.isSharePrefix = false
root := c.discoRoot()
u, err := url.Parse(root)
if err != nil {
return err
}
if len(u.Path) > 1 {
c.prefixv = strings.TrimRight(root, "/")
return nil
}
return c.condDiscovery()
} | go | func (c *Client) initPrefix() error {
c.isSharePrefix = false
root := c.discoRoot()
u, err := url.Parse(root)
if err != nil {
return err
}
if len(u.Path) > 1 {
c.prefixv = strings.TrimRight(root, "/")
return nil
}
return c.condDiscovery()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"initPrefix",
"(",
")",
"error",
"{",
"c",
".",
"isSharePrefix",
"=",
"false",
"\n",
"root",
":=",
"c",
".",
"discoRoot",
"(",
")",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"root",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"u",
".",
"Path",
")",
">",
"1",
"{",
"c",
".",
"prefixv",
"=",
"strings",
".",
"TrimRight",
"(",
"root",
",",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"c",
".",
"condDiscovery",
"(",
")",
"\n",
"}"
] | // initPrefix uses the user provided server URL to define the URL
// prefix to the blobserver root. If the server URL has a path
// component then it is directly used, otherwise the blobRoot
// from the discovery is used as the path. | [
"initPrefix",
"uses",
"the",
"user",
"provided",
"server",
"URL",
"to",
"define",
"the",
"URL",
"prefix",
"to",
"the",
"blobserver",
"root",
".",
"If",
"the",
"server",
"URL",
"has",
"a",
"path",
"component",
"then",
"it",
"is",
"directly",
"used",
"otherwise",
"the",
"blobRoot",
"from",
"the",
"discovery",
"is",
"used",
"as",
"the",
"path",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L994-L1006 | train |
perkeep/perkeep | pkg/client/client.go | DiscoveryDoc | func (c *Client) DiscoveryDoc(ctx context.Context) (io.Reader, error) {
res, err := c.discoveryResp(ctx)
if err != nil {
return nil, err
}
defer res.Body.Close()
const maxSize = 1 << 20
all, err := ioutil.ReadAll(io.LimitReader(res.Body, maxSize+1))
if err != nil {
return nil, err
}
if len(all) > maxSize {
return nil, errors.New("discovery document oddly large")
}
if len(all) > 0 && all[len(all)-1] != '\n' {
all = append(all, '\n')
}
return bytes.NewReader(all), err
} | go | func (c *Client) DiscoveryDoc(ctx context.Context) (io.Reader, error) {
res, err := c.discoveryResp(ctx)
if err != nil {
return nil, err
}
defer res.Body.Close()
const maxSize = 1 << 20
all, err := ioutil.ReadAll(io.LimitReader(res.Body, maxSize+1))
if err != nil {
return nil, err
}
if len(all) > maxSize {
return nil, errors.New("discovery document oddly large")
}
if len(all) > 0 && all[len(all)-1] != '\n' {
all = append(all, '\n')
}
return bytes.NewReader(all), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DiscoveryDoc",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"discoveryResp",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"const",
"maxSize",
"=",
"1",
"<<",
"20",
"\n",
"all",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"io",
".",
"LimitReader",
"(",
"res",
".",
"Body",
",",
"maxSize",
"+",
"1",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"all",
")",
">",
"maxSize",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"all",
")",
">",
"0",
"&&",
"all",
"[",
"len",
"(",
"all",
")",
"-",
"1",
"]",
"!=",
"'\\n'",
"{",
"all",
"=",
"append",
"(",
"all",
",",
"'\\n'",
")",
"\n",
"}",
"\n",
"return",
"bytes",
".",
"NewReader",
"(",
"all",
")",
",",
"err",
"\n",
"}"
] | // DiscoveryDoc returns the server's JSON discovery document.
// This method exists purely for the "camtool discovery" command.
// Clients shouldn't have to parse this themselves. | [
"DiscoveryDoc",
"returns",
"the",
"server",
"s",
"JSON",
"discovery",
"document",
".",
"This",
"method",
"exists",
"purely",
"for",
"the",
"camtool",
"discovery",
"command",
".",
"Clients",
"shouldn",
"t",
"have",
"to",
"parse",
"this",
"themselves",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1018-L1036 | train |
perkeep/perkeep | pkg/client/client.go | GetJSON | func (c *Client) GetJSON(ctx context.Context, url string, data interface{}) error {
if !strings.HasPrefix(url, c.discoRoot()) {
return fmt.Errorf("wrong URL (%q) for this server", url)
}
hreq := c.newRequest(ctx, "GET", url)
resp, err := c.expect2XX(hreq)
if err != nil {
return err
}
return httputil.DecodeJSON(resp, data)
} | go | func (c *Client) GetJSON(ctx context.Context, url string, data interface{}) error {
if !strings.HasPrefix(url, c.discoRoot()) {
return fmt.Errorf("wrong URL (%q) for this server", url)
}
hreq := c.newRequest(ctx, "GET", url)
resp, err := c.expect2XX(hreq)
if err != nil {
return err
}
return httputil.DecodeJSON(resp, data)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetJSON",
"(",
"ctx",
"context",
".",
"Context",
",",
"url",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"url",
",",
"c",
".",
"discoRoot",
"(",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"url",
")",
"\n",
"}",
"\n",
"hreq",
":=",
"c",
".",
"newRequest",
"(",
"ctx",
",",
"\"",
"\"",
",",
"url",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"expect2XX",
"(",
"hreq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"httputil",
".",
"DecodeJSON",
"(",
"resp",
",",
"data",
")",
"\n",
"}"
] | // GetJSON sends a GET request to url, and unmarshals the returned
// JSON response into data. The URL's host must match the client's
// configured server. | [
"GetJSON",
"sends",
"a",
"GET",
"request",
"to",
"url",
"and",
"unmarshals",
"the",
"returned",
"JSON",
"response",
"into",
"data",
".",
"The",
"URL",
"s",
"host",
"must",
"match",
"the",
"client",
"s",
"configured",
"server",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1160-L1170 | train |
perkeep/perkeep | pkg/client/client.go | Sign | func (c *Client) Sign(ctx context.Context, server string, r io.Reader) (signed []byte, err error) {
signHandler, err := c.SignHandler()
if err != nil {
return nil, err
}
signServer := strings.TrimSuffix(server, "/") + signHandler
resp, err := c.post(ctx, signServer, "application/x-www-form-urlencoded", r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
} | go | func (c *Client) Sign(ctx context.Context, server string, r io.Reader) (signed []byte, err error) {
signHandler, err := c.SignHandler()
if err != nil {
return nil, err
}
signServer := strings.TrimSuffix(server, "/") + signHandler
resp, err := c.post(ctx, signServer, "application/x-www-form-urlencoded", r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Sign",
"(",
"ctx",
"context",
".",
"Context",
",",
"server",
"string",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"signed",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"signHandler",
",",
"err",
":=",
"c",
".",
"SignHandler",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"signServer",
":=",
"strings",
".",
"TrimSuffix",
"(",
"server",
",",
"\"",
"\"",
")",
"+",
"signHandler",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"post",
"(",
"ctx",
",",
"signServer",
",",
"\"",
"\"",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"}"
] | // Sign sends a request to the sign handler on server to sign the contents of r,
// and return them signed. It uses the same implementation details, such as gated
// requests, as Post. | [
"Sign",
"sends",
"a",
"request",
"to",
"the",
"sign",
"handler",
"on",
"server",
"to",
"sign",
"the",
"contents",
"of",
"r",
"and",
"return",
"them",
"signed",
".",
"It",
"uses",
"the",
"same",
"implementation",
"details",
"such",
"as",
"gated",
"requests",
"as",
"Post",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1186-L1198 | train |
perkeep/perkeep | pkg/client/client.go | newRequest | func (c *Client) newRequest(ctx context.Context, method, url string, body ...io.Reader) *http.Request {
var bodyR io.Reader
if len(body) > 0 {
bodyR = body[0]
}
if len(body) > 1 {
panic("too many body arguments")
}
req, err := http.NewRequest(method, url, bodyR)
if err != nil {
panic(err.Error())
}
// not done by http.NewRequest in Go 1.0:
if br, ok := bodyR.(*bytes.Reader); ok {
req.ContentLength = int64(br.Len())
}
c.authMode.AddAuthHeader(req)
return req.WithContext(ctx)
} | go | func (c *Client) newRequest(ctx context.Context, method, url string, body ...io.Reader) *http.Request {
var bodyR io.Reader
if len(body) > 0 {
bodyR = body[0]
}
if len(body) > 1 {
panic("too many body arguments")
}
req, err := http.NewRequest(method, url, bodyR)
if err != nil {
panic(err.Error())
}
// not done by http.NewRequest in Go 1.0:
if br, ok := bodyR.(*bytes.Reader); ok {
req.ContentLength = int64(br.Len())
}
c.authMode.AddAuthHeader(req)
return req.WithContext(ctx)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"newRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"method",
",",
"url",
"string",
",",
"body",
"...",
"io",
".",
"Reader",
")",
"*",
"http",
".",
"Request",
"{",
"var",
"bodyR",
"io",
".",
"Reader",
"\n",
"if",
"len",
"(",
"body",
")",
">",
"0",
"{",
"bodyR",
"=",
"body",
"[",
"0",
"]",
"\n",
"}",
"\n",
"if",
"len",
"(",
"body",
")",
">",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"method",
",",
"url",
",",
"bodyR",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"// not done by http.NewRequest in Go 1.0:",
"if",
"br",
",",
"ok",
":=",
"bodyR",
".",
"(",
"*",
"bytes",
".",
"Reader",
")",
";",
"ok",
"{",
"req",
".",
"ContentLength",
"=",
"int64",
"(",
"br",
".",
"Len",
"(",
")",
")",
"\n",
"}",
"\n",
"c",
".",
"authMode",
".",
"AddAuthHeader",
"(",
"req",
")",
"\n",
"return",
"req",
".",
"WithContext",
"(",
"ctx",
")",
"\n",
"}"
] | // newRequest creates a request with the authentication header, and with the
// appropriate scheme and port in the case of self-signed TLS. | [
"newRequest",
"creates",
"a",
"request",
"with",
"the",
"authentication",
"header",
"and",
"with",
"the",
"appropriate",
"scheme",
"and",
"port",
"in",
"the",
"case",
"of",
"self",
"-",
"signed",
"TLS",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1215-L1233 | train |
perkeep/perkeep | pkg/client/client.go | expect2XX | func (c *Client) expect2XX(req *http.Request) (*http.Response, error) {
res, err := c.doReqGated(req)
if err == nil && (res.StatusCode < 200 || res.StatusCode > 299) {
buf := new(bytes.Buffer)
io.CopyN(buf, res.Body, 1<<20)
res.Body.Close()
return res, fmt.Errorf("client: got status code %d from URL %s; body %s", res.StatusCode, req.URL.String(), buf.String())
}
return res, err
} | go | func (c *Client) expect2XX(req *http.Request) (*http.Response, error) {
res, err := c.doReqGated(req)
if err == nil && (res.StatusCode < 200 || res.StatusCode > 299) {
buf := new(bytes.Buffer)
io.CopyN(buf, res.Body, 1<<20)
res.Body.Close()
return res, fmt.Errorf("client: got status code %d from URL %s; body %s", res.StatusCode, req.URL.String(), buf.String())
}
return res, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"expect2XX",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"doReqGated",
"(",
"req",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"(",
"res",
".",
"StatusCode",
"<",
"200",
"||",
"res",
".",
"StatusCode",
">",
"299",
")",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"io",
".",
"CopyN",
"(",
"buf",
",",
"res",
".",
"Body",
",",
"1",
"<<",
"20",
")",
"\n",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"res",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"StatusCode",
",",
"req",
".",
"URL",
".",
"String",
"(",
")",
",",
"buf",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // expect2XX will doReqGated and promote HTTP response codes outside of
// the 200-299 range to a non-nil error containing the response body. | [
"expect2XX",
"will",
"doReqGated",
"and",
"promote",
"HTTP",
"response",
"codes",
"outside",
"of",
"the",
"200",
"-",
"299",
"range",
"to",
"a",
"non",
"-",
"nil",
"error",
"containing",
"the",
"response",
"body",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1237-L1246 | train |
perkeep/perkeep | pkg/client/client.go | DialFunc | func (c *Client) DialFunc() func(network, addr string) (net.Conn, error) {
if c.useTLS() {
return nil
}
if android.IsChild() {
return func(network, addr string) (net.Conn, error) {
return android.Dial(network, addr)
}
}
return nil
} | go | func (c *Client) DialFunc() func(network, addr string) (net.Conn, error) {
if c.useTLS() {
return nil
}
if android.IsChild() {
return func(network, addr string) (net.Conn, error) {
return android.Dial(network, addr)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DialFunc",
"(",
")",
"func",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"if",
"c",
".",
"useTLS",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"android",
".",
"IsChild",
"(",
")",
"{",
"return",
"func",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"android",
".",
"Dial",
"(",
"network",
",",
"addr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DialFunc returns the adequate dial function when we're on android. | [
"DialFunc",
"returns",
"the",
"adequate",
"dial",
"function",
"when",
"we",
"re",
"on",
"android",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1255-L1265 | train |
perkeep/perkeep | pkg/client/client.go | Signer | func (c *Client) Signer() (*schema.Signer, error) {
c.signerOnce.Do(c.signerInit)
return c.signer, c.signerErr
} | go | func (c *Client) Signer() (*schema.Signer, error) {
c.signerOnce.Do(c.signerInit)
return c.signer, c.signerErr
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Signer",
"(",
")",
"(",
"*",
"schema",
".",
"Signer",
",",
"error",
")",
"{",
"c",
".",
"signerOnce",
".",
"Do",
"(",
"c",
".",
"signerInit",
")",
"\n",
"return",
"c",
".",
"signer",
",",
"c",
".",
"signerErr",
"\n",
"}"
] | // Signer returns the client's Signer, if any. The Signer signs JSON
// mutation claims. | [
"Signer",
"returns",
"the",
"client",
"s",
"Signer",
"if",
"any",
".",
"The",
"Signer",
"signs",
"JSON",
"mutation",
"claims",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1395-L1398 | train |
perkeep/perkeep | pkg/client/client.go | signBlob | func (c *Client) signBlob(ctx context.Context, bb schema.Buildable, sigTime time.Time) (string, error) {
signer, err := c.Signer()
if err != nil {
return "", err
}
return bb.Builder().SignAt(ctx, signer, sigTime)
} | go | func (c *Client) signBlob(ctx context.Context, bb schema.Buildable, sigTime time.Time) (string, error) {
signer, err := c.Signer()
if err != nil {
return "", err
}
return bb.Builder().SignAt(ctx, signer, sigTime)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"signBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"bb",
"schema",
".",
"Buildable",
",",
"sigTime",
"time",
".",
"Time",
")",
"(",
"string",
",",
"error",
")",
"{",
"signer",
",",
"err",
":=",
"c",
".",
"Signer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"bb",
".",
"Builder",
"(",
")",
".",
"SignAt",
"(",
"ctx",
",",
"signer",
",",
"sigTime",
")",
"\n",
"}"
] | // sigTime optionally specifies the signature time.
// If zero, the current time is used. | [
"sigTime",
"optionally",
"specifies",
"the",
"signature",
"time",
".",
"If",
"zero",
"the",
"current",
"time",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1414-L1420 | train |
perkeep/perkeep | pkg/client/client.go | checkMatchingKeys | func (c *Client) checkMatchingKeys() {
serverKey, err := c.ServerKeyID()
// The server provides the full (16 digit) key fingerprint but schema.Signer only stores
// the short (8 digit) key ID.
if err == nil && len(serverKey) >= 8 {
shortServerKey := serverKey[len(serverKey)-8:]
if shortServerKey != c.signer.KeyID() {
log.Printf("Warning: client (%s) and server (%s) keys differ.", c.signer.KeyID(), shortServerKey)
}
}
} | go | func (c *Client) checkMatchingKeys() {
serverKey, err := c.ServerKeyID()
// The server provides the full (16 digit) key fingerprint but schema.Signer only stores
// the short (8 digit) key ID.
if err == nil && len(serverKey) >= 8 {
shortServerKey := serverKey[len(serverKey)-8:]
if shortServerKey != c.signer.KeyID() {
log.Printf("Warning: client (%s) and server (%s) keys differ.", c.signer.KeyID(), shortServerKey)
}
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"checkMatchingKeys",
"(",
")",
"{",
"serverKey",
",",
"err",
":=",
"c",
".",
"ServerKeyID",
"(",
")",
"\n",
"// The server provides the full (16 digit) key fingerprint but schema.Signer only stores",
"// the short (8 digit) key ID.",
"if",
"err",
"==",
"nil",
"&&",
"len",
"(",
"serverKey",
")",
">=",
"8",
"{",
"shortServerKey",
":=",
"serverKey",
"[",
"len",
"(",
"serverKey",
")",
"-",
"8",
":",
"]",
"\n",
"if",
"shortServerKey",
"!=",
"c",
".",
"signer",
".",
"KeyID",
"(",
")",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"c",
".",
"signer",
".",
"KeyID",
"(",
")",
",",
"shortServerKey",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // checkMatchingKeys compares the client's and the server's keys and logs if they differ. | [
"checkMatchingKeys",
"compares",
"the",
"client",
"s",
"and",
"the",
"server",
"s",
"keys",
"and",
"logs",
"if",
"they",
"differ",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1439-L1449 | train |
perkeep/perkeep | internal/images/fastjpeg/fastjpeg.go | Factor | func Factor(w, h, sw, sh int) int {
switch {
case w>>3 >= sw && h>>3 >= sh:
return 8
case w>>2 >= sw && h>>2 >= sh:
return 4
case w>>1 >= sw && h>>1 >= sh:
return 2
}
return 1
} | go | func Factor(w, h, sw, sh int) int {
switch {
case w>>3 >= sw && h>>3 >= sh:
return 8
case w>>2 >= sw && h>>2 >= sh:
return 4
case w>>1 >= sw && h>>1 >= sh:
return 2
}
return 1
} | [
"func",
"Factor",
"(",
"w",
",",
"h",
",",
"sw",
",",
"sh",
"int",
")",
"int",
"{",
"switch",
"{",
"case",
"w",
">>",
"3",
">=",
"sw",
"&&",
"h",
">>",
"3",
">=",
"sh",
":",
"return",
"8",
"\n",
"case",
"w",
">>",
"2",
">=",
"sw",
"&&",
"h",
">>",
"2",
">=",
"sh",
":",
"return",
"4",
"\n",
"case",
"w",
">>",
"1",
">=",
"sw",
"&&",
"h",
">>",
"1",
">=",
"sh",
":",
"return",
"2",
"\n",
"}",
"\n",
"return",
"1",
"\n",
"}"
] | // Factor returns the sample factor DecodeSample should use to generate a
// sampled image greater than or equal to sw x sh pixels given a source image
// of w x h pixels. | [
"Factor",
"returns",
"the",
"sample",
"factor",
"DecodeSample",
"should",
"use",
"to",
"generate",
"a",
"sampled",
"image",
"greater",
"than",
"or",
"equal",
"to",
"sw",
"x",
"sh",
"pixels",
"given",
"a",
"source",
"image",
"of",
"w",
"x",
"h",
"pixels",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/fastjpeg/fastjpeg.go#L158-L168 | train |
perkeep/perkeep | internal/images/fastjpeg/fastjpeg.go | DecodeDownsample | func DecodeDownsample(r io.Reader, factor int) (image.Image, error) {
if !Available() {
return nil, ErrDjpegNotFound
}
switch factor {
case 1, 2, 4, 8:
default:
return nil, fmt.Errorf("fastjpeg: unsupported sample factor %d", factor)
}
buf := new(bytes.Buffer)
tr := io.TeeReader(r, buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, err
}
if format != "jpeg" {
return nil, fmt.Errorf("fastjpeg: Unsupported format %q", format)
}
var bpp int
switch ic.ColorModel {
case color.YCbCrModel:
bpp = 4 // JPEG will decode to RGB, and we'll expand inplace to RGBA.
case color.GrayModel:
bpp = 1
default:
return nil, fmt.Errorf("fastjpeg: Unsupported thumnbnail color model %T", ic.ColorModel)
}
args := []string{djpegBin, "-scale", fmt.Sprintf("1/%d", factor)}
cmd := exec.Command(args[0], args[1:]...)
cmd.Stdin = readerutil.NewStatsReader(djpegBytesWrittenVar, io.MultiReader(buf, r))
// Allocate space for the RGBA / Gray pixel data plus some extra for PNM
// header info. Explicitly allocate all the memory upfront to prevent
// many smaller allocations.
pixSize := ic.Width*ic.Height*bpp/factor/factor + 128
w := bytes.NewBuffer(make([]byte, 0, pixSize))
cmd.Stdout = w
stderrW := new(bytes.Buffer)
cmd.Stderr = stderrW
if err := cmd.Run(); err != nil {
djpegFailureVar.Add(1)
return nil, DjpegFailedError{Err: fmt.Errorf("%v: %s", err, stderrW)}
}
djpegSuccessVar.Add(1)
djpegBytesReadVar.Add(int64(w.Len()))
m, err := readPNM(w)
if err != nil {
return m, DjpegFailedError{Err: err}
}
return m, nil
} | go | func DecodeDownsample(r io.Reader, factor int) (image.Image, error) {
if !Available() {
return nil, ErrDjpegNotFound
}
switch factor {
case 1, 2, 4, 8:
default:
return nil, fmt.Errorf("fastjpeg: unsupported sample factor %d", factor)
}
buf := new(bytes.Buffer)
tr := io.TeeReader(r, buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, err
}
if format != "jpeg" {
return nil, fmt.Errorf("fastjpeg: Unsupported format %q", format)
}
var bpp int
switch ic.ColorModel {
case color.YCbCrModel:
bpp = 4 // JPEG will decode to RGB, and we'll expand inplace to RGBA.
case color.GrayModel:
bpp = 1
default:
return nil, fmt.Errorf("fastjpeg: Unsupported thumnbnail color model %T", ic.ColorModel)
}
args := []string{djpegBin, "-scale", fmt.Sprintf("1/%d", factor)}
cmd := exec.Command(args[0], args[1:]...)
cmd.Stdin = readerutil.NewStatsReader(djpegBytesWrittenVar, io.MultiReader(buf, r))
// Allocate space for the RGBA / Gray pixel data plus some extra for PNM
// header info. Explicitly allocate all the memory upfront to prevent
// many smaller allocations.
pixSize := ic.Width*ic.Height*bpp/factor/factor + 128
w := bytes.NewBuffer(make([]byte, 0, pixSize))
cmd.Stdout = w
stderrW := new(bytes.Buffer)
cmd.Stderr = stderrW
if err := cmd.Run(); err != nil {
djpegFailureVar.Add(1)
return nil, DjpegFailedError{Err: fmt.Errorf("%v: %s", err, stderrW)}
}
djpegSuccessVar.Add(1)
djpegBytesReadVar.Add(int64(w.Len()))
m, err := readPNM(w)
if err != nil {
return m, DjpegFailedError{Err: err}
}
return m, nil
} | [
"func",
"DecodeDownsample",
"(",
"r",
"io",
".",
"Reader",
",",
"factor",
"int",
")",
"(",
"image",
".",
"Image",
",",
"error",
")",
"{",
"if",
"!",
"Available",
"(",
")",
"{",
"return",
"nil",
",",
"ErrDjpegNotFound",
"\n",
"}",
"\n",
"switch",
"factor",
"{",
"case",
"1",
",",
"2",
",",
"4",
",",
"8",
":",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"factor",
")",
"\n",
"}",
"\n\n",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"tr",
":=",
"io",
".",
"TeeReader",
"(",
"r",
",",
"buf",
")",
"\n",
"ic",
",",
"format",
",",
"err",
":=",
"image",
".",
"DecodeConfig",
"(",
"tr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"format",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"format",
")",
"\n",
"}",
"\n",
"var",
"bpp",
"int",
"\n",
"switch",
"ic",
".",
"ColorModel",
"{",
"case",
"color",
".",
"YCbCrModel",
":",
"bpp",
"=",
"4",
"// JPEG will decode to RGB, and we'll expand inplace to RGBA.",
"\n",
"case",
"color",
".",
"GrayModel",
":",
"bpp",
"=",
"1",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ic",
".",
"ColorModel",
")",
"\n",
"}",
"\n",
"args",
":=",
"[",
"]",
"string",
"{",
"djpegBin",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"factor",
")",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"args",
"[",
"0",
"]",
",",
"args",
"[",
"1",
":",
"]",
"...",
")",
"\n",
"cmd",
".",
"Stdin",
"=",
"readerutil",
".",
"NewStatsReader",
"(",
"djpegBytesWrittenVar",
",",
"io",
".",
"MultiReader",
"(",
"buf",
",",
"r",
")",
")",
"\n\n",
"// Allocate space for the RGBA / Gray pixel data plus some extra for PNM",
"// header info. Explicitly allocate all the memory upfront to prevent",
"// many smaller allocations.",
"pixSize",
":=",
"ic",
".",
"Width",
"*",
"ic",
".",
"Height",
"*",
"bpp",
"/",
"factor",
"/",
"factor",
"+",
"128",
"\n",
"w",
":=",
"bytes",
".",
"NewBuffer",
"(",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"pixSize",
")",
")",
"\n",
"cmd",
".",
"Stdout",
"=",
"w",
"\n\n",
"stderrW",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"cmd",
".",
"Stderr",
"=",
"stderrW",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"djpegFailureVar",
".",
"Add",
"(",
"1",
")",
"\n",
"return",
"nil",
",",
"DjpegFailedError",
"{",
"Err",
":",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
",",
"stderrW",
")",
"}",
"\n",
"}",
"\n",
"djpegSuccessVar",
".",
"Add",
"(",
"1",
")",
"\n",
"djpegBytesReadVar",
".",
"Add",
"(",
"int64",
"(",
"w",
".",
"Len",
"(",
")",
")",
")",
"\n",
"m",
",",
"err",
":=",
"readPNM",
"(",
"w",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"m",
",",
"DjpegFailedError",
"{",
"Err",
":",
"err",
"}",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] | // DecodeDownsample decodes JPEG data in r, down-sampling it by factor.
// If djpeg is not found, err is ErrDjpegNotFound and r is not read from.
// If the execution of djpeg, or decoding the resulting PNM fails, error will
// be of type DjpegFailedError. | [
"DecodeDownsample",
"decodes",
"JPEG",
"data",
"in",
"r",
"down",
"-",
"sampling",
"it",
"by",
"factor",
".",
"If",
"djpeg",
"is",
"not",
"found",
"err",
"is",
"ErrDjpegNotFound",
"and",
"r",
"is",
"not",
"read",
"from",
".",
"If",
"the",
"execution",
"of",
"djpeg",
"or",
"decoding",
"the",
"resulting",
"PNM",
"fails",
"error",
"will",
"be",
"of",
"type",
"DjpegFailedError",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/fastjpeg/fastjpeg.go#L174-L226 | train |
perkeep/perkeep | pkg/schema/blob.go | ClaimDate | func (b *Blob) ClaimDate() (time.Time, error) {
var ct time.Time
claimDate := b.ss.ClaimDate
if claimDate.IsAnyZero() {
return ct, MissingFieldError("claimDate")
}
return claimDate.Time(), nil
} | go | func (b *Blob) ClaimDate() (time.Time, error) {
var ct time.Time
claimDate := b.ss.ClaimDate
if claimDate.IsAnyZero() {
return ct, MissingFieldError("claimDate")
}
return claimDate.Time(), nil
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"ClaimDate",
"(",
")",
"(",
"time",
".",
"Time",
",",
"error",
")",
"{",
"var",
"ct",
"time",
".",
"Time",
"\n",
"claimDate",
":=",
"b",
".",
"ss",
".",
"ClaimDate",
"\n",
"if",
"claimDate",
".",
"IsAnyZero",
"(",
")",
"{",
"return",
"ct",
",",
"MissingFieldError",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"claimDate",
".",
"Time",
"(",
")",
",",
"nil",
"\n",
"}"
] | // ClaimDate returns the "claimDate" field.
// If there is no claimDate, the error will be a MissingFieldError. | [
"ClaimDate",
"returns",
"the",
"claimDate",
"field",
".",
"If",
"there",
"is",
"no",
"claimDate",
"the",
"error",
"will",
"be",
"a",
"MissingFieldError",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L92-L99 | train |
perkeep/perkeep | pkg/schema/blob.go | ByteParts | func (b *Blob) ByteParts() []BytesPart {
// TODO: move this method off Blob, and make the caller go
// through a (*Blob).ByteBackedBlob() comma-ok accessor first.
s := make([]BytesPart, len(b.ss.Parts))
for i, part := range b.ss.Parts {
s[i] = *part
}
return s
} | go | func (b *Blob) ByteParts() []BytesPart {
// TODO: move this method off Blob, and make the caller go
// through a (*Blob).ByteBackedBlob() comma-ok accessor first.
s := make([]BytesPart, len(b.ss.Parts))
for i, part := range b.ss.Parts {
s[i] = *part
}
return s
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"ByteParts",
"(",
")",
"[",
"]",
"BytesPart",
"{",
"// TODO: move this method off Blob, and make the caller go",
"// through a (*Blob).ByteBackedBlob() comma-ok accessor first.",
"s",
":=",
"make",
"(",
"[",
"]",
"BytesPart",
",",
"len",
"(",
"b",
".",
"ss",
".",
"Parts",
")",
")",
"\n",
"for",
"i",
",",
"part",
":=",
"range",
"b",
".",
"ss",
".",
"Parts",
"{",
"s",
"[",
"i",
"]",
"=",
"*",
"part",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // ByteParts returns the "parts" field. The caller owns the returned
// slice. | [
"ByteParts",
"returns",
"the",
"parts",
"field",
".",
"The",
"caller",
"owns",
"the",
"returned",
"slice",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L103-L111 | train |
perkeep/perkeep | pkg/schema/blob.go | AsClaim | func (b *Blob) AsClaim() (c Claim, ok bool) {
if b.ss.Signer.Valid() && b.ss.Sig != "" && b.ss.ClaimType != "" && !b.ss.ClaimDate.IsAnyZero() {
return Claim{b}, true
}
return
} | go | func (b *Blob) AsClaim() (c Claim, ok bool) {
if b.ss.Signer.Valid() && b.ss.Sig != "" && b.ss.ClaimType != "" && !b.ss.ClaimDate.IsAnyZero() {
return Claim{b}, true
}
return
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"AsClaim",
"(",
")",
"(",
"c",
"Claim",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
".",
"ss",
".",
"Signer",
".",
"Valid",
"(",
")",
"&&",
"b",
".",
"ss",
".",
"Sig",
"!=",
"\"",
"\"",
"&&",
"b",
".",
"ss",
".",
"ClaimType",
"!=",
"\"",
"\"",
"&&",
"!",
"b",
".",
"ss",
".",
"ClaimDate",
".",
"IsAnyZero",
"(",
")",
"{",
"return",
"Claim",
"{",
"b",
"}",
",",
"true",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // AsClaim returns a Claim if the receiver Blob has all the required fields. | [
"AsClaim",
"returns",
"a",
"Claim",
"if",
"the",
"receiver",
"Blob",
"has",
"all",
"the",
"required",
"fields",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L125-L130 | train |
perkeep/perkeep | pkg/schema/blob.go | AsShare | func (b *Blob) AsShare() (s Share, ok bool) {
c, isClaim := b.AsClaim()
if !isClaim {
return
}
if ClaimType(b.ss.ClaimType) == ShareClaim && b.ss.AuthType == ShareHaveRef && (b.ss.Target.Valid() || b.ss.Search != nil) {
return Share{c}, true
}
return s, false
} | go | func (b *Blob) AsShare() (s Share, ok bool) {
c, isClaim := b.AsClaim()
if !isClaim {
return
}
if ClaimType(b.ss.ClaimType) == ShareClaim && b.ss.AuthType == ShareHaveRef && (b.ss.Target.Valid() || b.ss.Search != nil) {
return Share{c}, true
}
return s, false
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"AsShare",
"(",
")",
"(",
"s",
"Share",
",",
"ok",
"bool",
")",
"{",
"c",
",",
"isClaim",
":=",
"b",
".",
"AsClaim",
"(",
")",
"\n",
"if",
"!",
"isClaim",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"ClaimType",
"(",
"b",
".",
"ss",
".",
"ClaimType",
")",
"==",
"ShareClaim",
"&&",
"b",
".",
"ss",
".",
"AuthType",
"==",
"ShareHaveRef",
"&&",
"(",
"b",
".",
"ss",
".",
"Target",
".",
"Valid",
"(",
")",
"||",
"b",
".",
"ss",
".",
"Search",
"!=",
"nil",
")",
"{",
"return",
"Share",
"{",
"c",
"}",
",",
"true",
"\n",
"}",
"\n",
"return",
"s",
",",
"false",
"\n",
"}"
] | // AsShare returns a Share if the receiver Blob has all the required fields. | [
"AsShare",
"returns",
"a",
"Share",
"if",
"the",
"receiver",
"Blob",
"has",
"all",
"the",
"required",
"fields",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L133-L143 | train |
perkeep/perkeep | pkg/schema/blob.go | DirectoryEntries | func (b *Blob) DirectoryEntries() (br blob.Ref, ok bool) {
if b.Type() != "directory" {
return
}
return b.ss.Entries, true
} | go | func (b *Blob) DirectoryEntries() (br blob.Ref, ok bool) {
if b.Type() != "directory" {
return
}
return b.ss.Entries, true
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"DirectoryEntries",
"(",
")",
"(",
"br",
"blob",
".",
"Ref",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
".",
"Type",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n",
"return",
"b",
".",
"ss",
".",
"Entries",
",",
"true",
"\n",
"}"
] | // DirectoryEntries the "entries" field if valid and b's type is "directory". | [
"DirectoryEntries",
"the",
"entries",
"field",
"if",
"valid",
"and",
"b",
"s",
"type",
"is",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L146-L151 | train |
perkeep/perkeep | pkg/schema/blob.go | StaticSetMembers | func (b *Blob) StaticSetMembers() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.Members))
for _, ref := range b.ss.Members {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | go | func (b *Blob) StaticSetMembers() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.Members))
for _, ref := range b.ss.Members {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"StaticSetMembers",
"(",
")",
"[",
"]",
"blob",
".",
"Ref",
"{",
"if",
"b",
".",
"Type",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"s",
":=",
"make",
"(",
"[",
"]",
"blob",
".",
"Ref",
",",
"0",
",",
"len",
"(",
"b",
".",
"ss",
".",
"Members",
")",
")",
"\n",
"for",
"_",
",",
"ref",
":=",
"range",
"b",
".",
"ss",
".",
"Members",
"{",
"if",
"ref",
".",
"Valid",
"(",
")",
"{",
"s",
"=",
"append",
"(",
"s",
",",
"ref",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // StaticSetMembers returns the refs in the "members" field if b is a valid
// "static-set" schema. Note that if it is a large static-set, the members are
// actually spread as subsets in "mergeSets". See StaticSetMergeSets. | [
"StaticSetMembers",
"returns",
"the",
"refs",
"in",
"the",
"members",
"field",
"if",
"b",
"is",
"a",
"valid",
"static",
"-",
"set",
"schema",
".",
"Note",
"that",
"if",
"it",
"is",
"a",
"large",
"static",
"-",
"set",
"the",
"members",
"are",
"actually",
"spread",
"as",
"subsets",
"in",
"mergeSets",
".",
"See",
"StaticSetMergeSets",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L156-L168 | train |
perkeep/perkeep | pkg/schema/blob.go | StaticSetMergeSets | func (b *Blob) StaticSetMergeSets() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.MergeSets))
for _, ref := range b.ss.MergeSets {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | go | func (b *Blob) StaticSetMergeSets() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.MergeSets))
for _, ref := range b.ss.MergeSets {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"StaticSetMergeSets",
"(",
")",
"[",
"]",
"blob",
".",
"Ref",
"{",
"if",
"b",
".",
"Type",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"s",
":=",
"make",
"(",
"[",
"]",
"blob",
".",
"Ref",
",",
"0",
",",
"len",
"(",
"b",
".",
"ss",
".",
"MergeSets",
")",
")",
"\n",
"for",
"_",
",",
"ref",
":=",
"range",
"b",
".",
"ss",
".",
"MergeSets",
"{",
"if",
"ref",
".",
"Valid",
"(",
")",
"{",
"s",
"=",
"append",
"(",
"s",
",",
"ref",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // StaticSetMergeSets returns the refs of the static-sets in "mergeSets". These
// are the subsets of all the static-set members in the case of a large directory. | [
"StaticSetMergeSets",
"returns",
"the",
"refs",
"of",
"the",
"static",
"-",
"sets",
"in",
"mergeSets",
".",
"These",
"are",
"the",
"subsets",
"of",
"all",
"the",
"static",
"-",
"set",
"members",
"in",
"the",
"case",
"of",
"a",
"large",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L172-L184 | train |
perkeep/perkeep | pkg/schema/blob.go | IsExpired | func (s Share) IsExpired() bool {
t := time.Time(s.b.ss.Expires)
return !t.IsZero() && clockNow().After(t)
} | go | func (s Share) IsExpired() bool {
t := time.Time(s.b.ss.Expires)
return !t.IsZero() && clockNow().After(t)
} | [
"func",
"(",
"s",
"Share",
")",
"IsExpired",
"(",
")",
"bool",
"{",
"t",
":=",
"time",
".",
"Time",
"(",
"s",
".",
"b",
".",
"ss",
".",
"Expires",
")",
"\n",
"return",
"!",
"t",
".",
"IsZero",
"(",
")",
"&&",
"clockNow",
"(",
")",
".",
"After",
"(",
"t",
")",
"\n",
"}"
] | // IsExpired reports whether this share has expired. | [
"IsExpired",
"reports",
"whether",
"this",
"share",
"has",
"expired",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L266-L269 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticFile | func (b *Blob) AsStaticFile() (sf StaticFile, ok bool) {
// TODO (marete) Add support for device files to
// Perkeep and change the implementation of StaticFile to
// reflect that.
t := b.ss.Type
if t == "file" || t == "symlink" || t == "fifo" || t == "socket" {
return StaticFile{b}, true
}
return
} | go | func (b *Blob) AsStaticFile() (sf StaticFile, ok bool) {
// TODO (marete) Add support for device files to
// Perkeep and change the implementation of StaticFile to
// reflect that.
t := b.ss.Type
if t == "file" || t == "symlink" || t == "fifo" || t == "socket" {
return StaticFile{b}, true
}
return
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"AsStaticFile",
"(",
")",
"(",
"sf",
"StaticFile",
",",
"ok",
"bool",
")",
"{",
"// TODO (marete) Add support for device files to",
"// Perkeep and change the implementation of StaticFile to",
"// reflect that.",
"t",
":=",
"b",
".",
"ss",
".",
"Type",
"\n",
"if",
"t",
"==",
"\"",
"\"",
"||",
"t",
"==",
"\"",
"\"",
"||",
"t",
"==",
"\"",
"\"",
"||",
"t",
"==",
"\"",
"\"",
"{",
"return",
"StaticFile",
"{",
"b",
"}",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // AsStaticFile returns the Blob as a StaticFile if it represents
// one. Otherwise, it returns false in the boolean parameter and the
// zero value of StaticFile. | [
"AsStaticFile",
"returns",
"the",
"Blob",
"as",
"a",
"StaticFile",
"if",
"it",
"represents",
"one",
".",
"Otherwise",
"it",
"returns",
"false",
"in",
"the",
"boolean",
"parameter",
"and",
"the",
"zero",
"value",
"of",
"StaticFile",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L285-L295 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticSymlink | func (sf StaticFile) AsStaticSymlink() (s StaticSymlink, ok bool) {
if sf.b.ss.Type == "symlink" {
return StaticSymlink{sf}, true
}
return
} | go | func (sf StaticFile) AsStaticSymlink() (s StaticSymlink, ok bool) {
if sf.b.ss.Type == "symlink" {
return StaticSymlink{sf}, true
}
return
} | [
"func",
"(",
"sf",
"StaticFile",
")",
"AsStaticSymlink",
"(",
")",
"(",
"s",
"StaticSymlink",
",",
"ok",
"bool",
")",
"{",
"if",
"sf",
".",
"b",
".",
"ss",
".",
"Type",
"==",
"\"",
"\"",
"{",
"return",
"StaticSymlink",
"{",
"sf",
"}",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // AsStaticSymlink returns the StaticFile as a StaticSymlink if the
// StaticFile represents a symlink. Othwerwise, it returns the zero
// value of StaticSymlink and false. | [
"AsStaticSymlink",
"returns",
"the",
"StaticFile",
"as",
"a",
"StaticSymlink",
"if",
"the",
"StaticFile",
"represents",
"a",
"symlink",
".",
"Othwerwise",
"it",
"returns",
"the",
"zero",
"value",
"of",
"StaticSymlink",
"and",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L324-L330 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticFIFO | func (sf StaticFile) AsStaticFIFO() (fifo StaticFIFO, ok bool) {
if sf.b.ss.Type == "fifo" {
return StaticFIFO{sf}, true
}
return
} | go | func (sf StaticFile) AsStaticFIFO() (fifo StaticFIFO, ok bool) {
if sf.b.ss.Type == "fifo" {
return StaticFIFO{sf}, true
}
return
} | [
"func",
"(",
"sf",
"StaticFile",
")",
"AsStaticFIFO",
"(",
")",
"(",
"fifo",
"StaticFIFO",
",",
"ok",
"bool",
")",
"{",
"if",
"sf",
".",
"b",
".",
"ss",
".",
"Type",
"==",
"\"",
"\"",
"{",
"return",
"StaticFIFO",
"{",
"sf",
"}",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // AsStaticFIFO returns the StatifFile as a StaticFIFO if the
// StaticFile represents a fifo. Otherwise, it returns the zero value
// of StaticFIFO and false. | [
"AsStaticFIFO",
"returns",
"the",
"StatifFile",
"as",
"a",
"StaticFIFO",
"if",
"the",
"StaticFile",
"represents",
"a",
"fifo",
".",
"Otherwise",
"it",
"returns",
"the",
"zero",
"value",
"of",
"StaticFIFO",
"and",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L335-L341 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticSocket | func (sf StaticFile) AsStaticSocket() (ss StaticSocket, ok bool) {
if sf.b.ss.Type == "socket" {
return StaticSocket{sf}, true
}
return
} | go | func (sf StaticFile) AsStaticSocket() (ss StaticSocket, ok bool) {
if sf.b.ss.Type == "socket" {
return StaticSocket{sf}, true
}
return
} | [
"func",
"(",
"sf",
"StaticFile",
")",
"AsStaticSocket",
"(",
")",
"(",
"ss",
"StaticSocket",
",",
"ok",
"bool",
")",
"{",
"if",
"sf",
".",
"b",
".",
"ss",
".",
"Type",
"==",
"\"",
"\"",
"{",
"return",
"StaticSocket",
"{",
"sf",
"}",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // AsStaticSocket returns the StaticFile as a StaticSocket if the
// StaticFile represents a socket. Otherwise, it returns the zero
// value of StaticSocket and false. | [
"AsStaticSocket",
"returns",
"the",
"StaticFile",
"as",
"a",
"StaticSocket",
"if",
"the",
"StaticFile",
"represents",
"a",
"socket",
".",
"Otherwise",
"it",
"returns",
"the",
"zero",
"value",
"of",
"StaticSocket",
"and",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L346-L352 | train |
perkeep/perkeep | pkg/schema/blob.go | SetShareTarget | func (bb *Builder) SetShareTarget(t blob.Ref) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareTarget on non-share")
}
bb.m["target"] = t.String()
return bb
} | go | func (bb *Builder) SetShareTarget(t blob.Ref) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareTarget on non-share")
}
bb.m["target"] = t.String()
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetShareTarget",
"(",
"t",
"blob",
".",
"Ref",
")",
"*",
"Builder",
"{",
"if",
"bb",
".",
"Type",
"(",
")",
"!=",
"\"",
"\"",
"||",
"bb",
".",
"ClaimType",
"(",
")",
"!=",
"ShareClaim",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"t",
".",
"String",
"(",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetShareTarget sets the target of share claim.
// It panics if bb isn't a "share" claim type. | [
"SetShareTarget",
"sets",
"the",
"target",
"of",
"share",
"claim",
".",
"It",
"panics",
"if",
"bb",
"isn",
"t",
"a",
"share",
"claim",
"type",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L371-L377 | train |
perkeep/perkeep | pkg/schema/blob.go | SetShareExpiration | func (bb *Builder) SetShareExpiration(t time.Time) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareExpiration on non-share")
}
if t.IsZero() {
delete(bb.m, "expires")
} else {
bb.m["expires"] = RFC3339FromTime(t)
}
return bb
} | go | func (bb *Builder) SetShareExpiration(t time.Time) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareExpiration on non-share")
}
if t.IsZero() {
delete(bb.m, "expires")
} else {
bb.m["expires"] = RFC3339FromTime(t)
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetShareExpiration",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Builder",
"{",
"if",
"bb",
".",
"Type",
"(",
")",
"!=",
"\"",
"\"",
"||",
"bb",
".",
"ClaimType",
"(",
")",
"!=",
"ShareClaim",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"IsZero",
"(",
")",
"{",
"delete",
"(",
"bb",
".",
"m",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"RFC3339FromTime",
"(",
"t",
")",
"\n",
"}",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetShareExpiration sets the expiration time on share claim.
// It panics if bb isn't a "share" claim type.
// If t is zero, the expiration is removed. | [
"SetShareExpiration",
"sets",
"the",
"expiration",
"time",
"on",
"share",
"claim",
".",
"It",
"panics",
"if",
"bb",
"isn",
"t",
"a",
"share",
"claim",
"type",
".",
"If",
"t",
"is",
"zero",
"the",
"expiration",
"is",
"removed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L393-L403 | train |
perkeep/perkeep | pkg/schema/blob.go | SetRawStringField | func (bb *Builder) SetRawStringField(key, value string) *Builder {
bb.m[key] = value
return bb
} | go | func (bb *Builder) SetRawStringField(key, value string) *Builder {
bb.m[key] = value
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetRawStringField",
"(",
"key",
",",
"value",
"string",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetRawStringField sets a raw string field in the underlying map. | [
"SetRawStringField",
"sets",
"a",
"raw",
"string",
"field",
"in",
"the",
"underlying",
"map",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L418-L421 | train |
perkeep/perkeep | pkg/schema/blob.go | Blob | func (bb *Builder) Blob() *Blob {
json, err := mapJSON(bb.m)
if err != nil {
panic(err)
}
ss, err := parseSuperset(strings.NewReader(json))
if err != nil {
panic(err)
}
h := blob.NewHash()
h.Write([]byte(json))
return &Blob{
str: json,
ss: ss,
br: blob.RefFromHash(h),
}
} | go | func (bb *Builder) Blob() *Blob {
json, err := mapJSON(bb.m)
if err != nil {
panic(err)
}
ss, err := parseSuperset(strings.NewReader(json))
if err != nil {
panic(err)
}
h := blob.NewHash()
h.Write([]byte(json))
return &Blob{
str: json,
ss: ss,
br: blob.RefFromHash(h),
}
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"Blob",
"(",
")",
"*",
"Blob",
"{",
"json",
",",
"err",
":=",
"mapJSON",
"(",
"bb",
".",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"ss",
",",
"err",
":=",
"parseSuperset",
"(",
"strings",
".",
"NewReader",
"(",
"json",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"h",
":=",
"blob",
".",
"NewHash",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"json",
")",
")",
"\n",
"return",
"&",
"Blob",
"{",
"str",
":",
"json",
",",
"ss",
":",
"ss",
",",
"br",
":",
"blob",
".",
"RefFromHash",
"(",
"h",
")",
",",
"}",
"\n",
"}"
] | // Blob builds the Blob. The builder continues to be usable after a call to Build. | [
"Blob",
"builds",
"the",
"Blob",
".",
"The",
"builder",
"continues",
"to",
"be",
"usable",
"after",
"a",
"call",
"to",
"Build",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L424-L440 | train |
perkeep/perkeep | pkg/schema/blob.go | SetSigner | func (bb *Builder) SetSigner(signer blob.Ref) *Builder {
bb.m["camliSigner"] = signer.String()
return bb
} | go | func (bb *Builder) SetSigner(signer blob.Ref) *Builder {
bb.m["camliSigner"] = signer.String()
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetSigner",
"(",
"signer",
"blob",
".",
"Ref",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"signer",
".",
"String",
"(",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetSigner sets the camliSigner field.
// Calling SetSigner is unnecessary if using Sign. | [
"SetSigner",
"sets",
"the",
"camliSigner",
"field",
".",
"Calling",
"SetSigner",
"is",
"unnecessary",
"if",
"using",
"Sign",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L454-L457 | train |
perkeep/perkeep | pkg/schema/blob.go | Sign | func (bb *Builder) Sign(ctx context.Context, signer *Signer) (string, error) {
return bb.SignAt(ctx, signer, time.Time{})
} | go | func (bb *Builder) Sign(ctx context.Context, signer *Signer) (string, error) {
return bb.SignAt(ctx, signer, time.Time{})
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"Sign",
"(",
"ctx",
"context",
".",
"Context",
",",
"signer",
"*",
"Signer",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"bb",
".",
"SignAt",
"(",
"ctx",
",",
"signer",
",",
"time",
".",
"Time",
"{",
"}",
")",
"\n",
"}"
] | // Sign sets the blob builder's camliSigner field with SetSigner
// and returns the signed JSON using the provided signer. | [
"Sign",
"sets",
"the",
"blob",
"builder",
"s",
"camliSigner",
"field",
"with",
"SetSigner",
"and",
"returns",
"the",
"signed",
"JSON",
"using",
"the",
"provided",
"signer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L461-L463 | train |
perkeep/perkeep | pkg/schema/blob.go | SignAt | func (bb *Builder) SignAt(ctx context.Context, signer *Signer, sigTime time.Time) (string, error) {
switch bb.Type() {
case "permanode", "claim":
default:
return "", fmt.Errorf("can't sign camliType %q", bb.Type())
}
if sigTime.IsZero() {
sigTime = time.Now()
}
bb.SetClaimDate(sigTime)
return signer.SignJSON(ctx, bb.SetSigner(signer.pubref).Blob().JSON(), sigTime)
} | go | func (bb *Builder) SignAt(ctx context.Context, signer *Signer, sigTime time.Time) (string, error) {
switch bb.Type() {
case "permanode", "claim":
default:
return "", fmt.Errorf("can't sign camliType %q", bb.Type())
}
if sigTime.IsZero() {
sigTime = time.Now()
}
bb.SetClaimDate(sigTime)
return signer.SignJSON(ctx, bb.SetSigner(signer.pubref).Blob().JSON(), sigTime)
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SignAt",
"(",
"ctx",
"context",
".",
"Context",
",",
"signer",
"*",
"Signer",
",",
"sigTime",
"time",
".",
"Time",
")",
"(",
"string",
",",
"error",
")",
"{",
"switch",
"bb",
".",
"Type",
"(",
")",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"default",
":",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"bb",
".",
"Type",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"sigTime",
".",
"IsZero",
"(",
")",
"{",
"sigTime",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"bb",
".",
"SetClaimDate",
"(",
"sigTime",
")",
"\n",
"return",
"signer",
".",
"SignJSON",
"(",
"ctx",
",",
"bb",
".",
"SetSigner",
"(",
"signer",
".",
"pubref",
")",
".",
"Blob",
"(",
")",
".",
"JSON",
"(",
")",
",",
"sigTime",
")",
"\n",
"}"
] | // SignAt sets the blob builder's camliSigner field with SetSigner
// and returns the signed JSON using the provided signer.
// The provided sigTime is the time of the signature, used mostly
// for planned permanodes. If the zero value, the current time is used. | [
"SignAt",
"sets",
"the",
"blob",
"builder",
"s",
"camliSigner",
"field",
"with",
"SetSigner",
"and",
"returns",
"the",
"signed",
"JSON",
"using",
"the",
"provided",
"signer",
".",
"The",
"provided",
"sigTime",
"is",
"the",
"time",
"of",
"the",
"signature",
"used",
"mostly",
"for",
"planned",
"permanodes",
".",
"If",
"the",
"zero",
"value",
"the",
"current",
"time",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L469-L480 | train |
perkeep/perkeep | pkg/schema/blob.go | SetType | func (bb *Builder) SetType(t string) *Builder {
bb.m["camliType"] = t
return bb
} | go | func (bb *Builder) SetType(t string) *Builder {
bb.m["camliType"] = t
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetType",
"(",
"t",
"string",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"t",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetType sets the camliType field. | [
"SetType",
"sets",
"the",
"camliType",
"field",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L483-L486 | train |
perkeep/perkeep | pkg/schema/blob.go | Type | func (bb *Builder) Type() string {
if s, ok := bb.m["camliType"].(string); ok {
return s
}
return ""
} | go | func (bb *Builder) Type() string {
if s, ok := bb.m["camliType"].(string); ok {
return s
}
return ""
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"Type",
"(",
")",
"string",
"{",
"if",
"s",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Type returns the camliType value. | [
"Type",
"returns",
"the",
"camliType",
"value",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L489-L494 | train |
perkeep/perkeep | pkg/schema/blob.go | ClaimType | func (bb *Builder) ClaimType() ClaimType {
if s, ok := bb.m["claimType"].(string); ok {
return ClaimType(s)
}
return ""
} | go | func (bb *Builder) ClaimType() ClaimType {
if s, ok := bb.m["claimType"].(string); ok {
return ClaimType(s)
}
return ""
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"ClaimType",
"(",
")",
"ClaimType",
"{",
"if",
"s",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"ClaimType",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ClaimType returns the claimType value, or the empty string. | [
"ClaimType",
"returns",
"the",
"claimType",
"value",
"or",
"the",
"empty",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L497-L502 | train |
perkeep/perkeep | pkg/schema/blob.go | SetFileName | func (bb *Builder) SetFileName(name string) *Builder {
baseName := filepath.Base(name)
if utf8.ValidString(baseName) {
bb.m["fileName"] = baseName
} else {
bb.m["fileNameBytes"] = mixedArrayFromString(baseName)
}
return bb
} | go | func (bb *Builder) SetFileName(name string) *Builder {
baseName := filepath.Base(name)
if utf8.ValidString(baseName) {
bb.m["fileName"] = baseName
} else {
bb.m["fileNameBytes"] = mixedArrayFromString(baseName)
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetFileName",
"(",
"name",
"string",
")",
"*",
"Builder",
"{",
"baseName",
":=",
"filepath",
".",
"Base",
"(",
"name",
")",
"\n",
"if",
"utf8",
".",
"ValidString",
"(",
"baseName",
")",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"baseName",
"\n",
"}",
"else",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"mixedArrayFromString",
"(",
"baseName",
")",
"\n",
"}",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetFileName sets the fileName or fileNameBytes field.
// The filename is truncated to just the base. | [
"SetFileName",
"sets",
"the",
"fileName",
"or",
"fileNameBytes",
"field",
".",
"The",
"filename",
"is",
"truncated",
"to",
"just",
"the",
"base",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L506-L514 | train |
perkeep/perkeep | pkg/schema/blob.go | SetSymlinkTarget | func (bb *Builder) SetSymlinkTarget(target string) *Builder {
bb.SetType("symlink")
if utf8.ValidString(target) {
bb.m["symlinkTarget"] = target
} else {
bb.m["symlinkTargetBytes"] = mixedArrayFromString(target)
}
return bb
} | go | func (bb *Builder) SetSymlinkTarget(target string) *Builder {
bb.SetType("symlink")
if utf8.ValidString(target) {
bb.m["symlinkTarget"] = target
} else {
bb.m["symlinkTargetBytes"] = mixedArrayFromString(target)
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetSymlinkTarget",
"(",
"target",
"string",
")",
"*",
"Builder",
"{",
"bb",
".",
"SetType",
"(",
"\"",
"\"",
")",
"\n",
"if",
"utf8",
".",
"ValidString",
"(",
"target",
")",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"target",
"\n",
"}",
"else",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"mixedArrayFromString",
"(",
"target",
")",
"\n",
"}",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetSymlinkTarget sets bb to be of type "symlink" and sets the symlink's target. | [
"SetSymlinkTarget",
"sets",
"bb",
"to",
"be",
"of",
"type",
"symlink",
"and",
"sets",
"the",
"symlink",
"s",
"target",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L517-L525 | train |
perkeep/perkeep | pkg/schema/blob.go | SetClaimDate | func (bb *Builder) SetClaimDate(t time.Time) *Builder {
if !bb.IsClaimType() {
// This is a little gross, using panic here, but I
// don't want all callers to check errors. This is
// really a programming error, not a runtime error
// that would arise from e.g. random user data.
panic("SetClaimDate called on non-claim *Builder; camliType=" + bb.Type())
}
bb.m["claimDate"] = RFC3339FromTime(t)
return bb
} | go | func (bb *Builder) SetClaimDate(t time.Time) *Builder {
if !bb.IsClaimType() {
// This is a little gross, using panic here, but I
// don't want all callers to check errors. This is
// really a programming error, not a runtime error
// that would arise from e.g. random user data.
panic("SetClaimDate called on non-claim *Builder; camliType=" + bb.Type())
}
bb.m["claimDate"] = RFC3339FromTime(t)
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetClaimDate",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Builder",
"{",
"if",
"!",
"bb",
".",
"IsClaimType",
"(",
")",
"{",
"// This is a little gross, using panic here, but I",
"// don't want all callers to check errors. This is",
"// really a programming error, not a runtime error",
"// that would arise from e.g. random user data.",
"panic",
"(",
"\"",
"\"",
"+",
"bb",
".",
"Type",
"(",
")",
")",
"\n",
"}",
"\n",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"RFC3339FromTime",
"(",
"t",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetClaimDate sets the "claimDate" on a claim.
// It is a fatal error to call SetClaimDate if the Map isn't of Type "claim". | [
"SetClaimDate",
"sets",
"the",
"claimDate",
"on",
"a",
"claim",
".",
"It",
"is",
"a",
"fatal",
"error",
"to",
"call",
"SetClaimDate",
"if",
"the",
"Map",
"isn",
"t",
"of",
"Type",
"claim",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L539-L549 | train |
perkeep/perkeep | pkg/schema/blob.go | SetModTime | func (bb *Builder) SetModTime(t time.Time) *Builder {
bb.m["unixMtime"] = RFC3339FromTime(t)
return bb
} | go | func (bb *Builder) SetModTime(t time.Time) *Builder {
bb.m["unixMtime"] = RFC3339FromTime(t)
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetModTime",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"RFC3339FromTime",
"(",
"t",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetModTime sets the "unixMtime" field. | [
"SetModTime",
"sets",
"the",
"unixMtime",
"field",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L552-L555 | train |
perkeep/perkeep | pkg/schema/blob.go | CapCreationTime | func (bb *Builder) CapCreationTime() *Builder {
ctime, ok := bb.m["unixCtime"].(string)
if !ok {
return bb
}
mtime, ok := bb.m["unixMtime"].(string)
if ok && ctime > mtime {
bb.m["unixCtime"] = mtime
}
return bb
} | go | func (bb *Builder) CapCreationTime() *Builder {
ctime, ok := bb.m["unixCtime"].(string)
if !ok {
return bb
}
mtime, ok := bb.m["unixMtime"].(string)
if ok && ctime > mtime {
bb.m["unixCtime"] = mtime
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"CapCreationTime",
"(",
")",
"*",
"Builder",
"{",
"ctime",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"bb",
"\n",
"}",
"\n",
"mtime",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"ok",
"&&",
"ctime",
">",
"mtime",
"{",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"mtime",
"\n",
"}",
"\n",
"return",
"bb",
"\n",
"}"
] | // CapCreationTime caps the "unixCtime" field to be less or equal than "unixMtime" | [
"CapCreationTime",
"caps",
"the",
"unixCtime",
"field",
"to",
"be",
"less",
"or",
"equal",
"than",
"unixMtime"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L558-L568 | train |
perkeep/perkeep | pkg/schema/blob.go | ModTime | func (bb *Builder) ModTime() (t time.Time, ok bool) {
s, ok := bb.m["unixMtime"].(string)
if !ok {
return
}
t, err := time.Parse(time.RFC3339, s)
if err != nil {
return
}
return t, true
} | go | func (bb *Builder) ModTime() (t time.Time, ok bool) {
s, ok := bb.m["unixMtime"].(string)
if !ok {
return
}
t, err := time.Parse(time.RFC3339, s)
if err != nil {
return
}
return t, true
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"ModTime",
"(",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"s",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"t",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"return",
"t",
",",
"true",
"\n",
"}"
] | // ModTime returns the "unixMtime" modtime field, if set. | [
"ModTime",
"returns",
"the",
"unixMtime",
"modtime",
"field",
"if",
"set",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L571-L581 | train |
perkeep/perkeep | pkg/schema/blob.go | PartsSize | func (bb *Builder) PartsSize() int64 {
n := int64(0)
if parts, ok := bb.m["parts"].([]BytesPart); ok {
for _, part := range parts {
n += int64(part.Size)
}
}
return n
} | go | func (bb *Builder) PartsSize() int64 {
n := int64(0)
if parts, ok := bb.m["parts"].([]BytesPart); ok {
for _, part := range parts {
n += int64(part.Size)
}
}
return n
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"PartsSize",
"(",
")",
"int64",
"{",
"n",
":=",
"int64",
"(",
"0",
")",
"\n",
"if",
"parts",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"[",
"]",
"BytesPart",
")",
";",
"ok",
"{",
"for",
"_",
",",
"part",
":=",
"range",
"parts",
"{",
"n",
"+=",
"int64",
"(",
"part",
".",
"Size",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}"
] | // PartsSize returns the number of bytes represented by the "parts" field. | [
"PartsSize",
"returns",
"the",
"number",
"of",
"bytes",
"represented",
"by",
"the",
"parts",
"field",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L592-L600 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/stream.go | StreamBlobs | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
return blobserver.NewMultiBlobStreamer(
smallBlobStreamer{s},
largeBlobStreamer{s},
).StreamBlobs(ctx, dest, contToken)
} | go | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
return blobserver.NewMultiBlobStreamer(
smallBlobStreamer{s},
largeBlobStreamer{s},
).StreamBlobs(ctx, dest, contToken)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"StreamBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blobserver",
".",
"BlobAndToken",
",",
"contToken",
"string",
")",
"(",
"err",
"error",
")",
"{",
"return",
"blobserver",
".",
"NewMultiBlobStreamer",
"(",
"smallBlobStreamer",
"{",
"s",
"}",
",",
"largeBlobStreamer",
"{",
"s",
"}",
",",
")",
".",
"StreamBlobs",
"(",
"ctx",
",",
"dest",
",",
"contToken",
")",
"\n",
"}"
] | // StreamBlobs impl. | [
"StreamBlobs",
"impl",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/stream.go#L33-L38 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/stream.go | StreamBlobs | func (st smallBlobStreamer) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
small := st.sto.small
if bs, ok := small.(blobserver.BlobStreamer); ok {
return bs.StreamBlobs(ctx, dest, contToken)
}
defer close(dest)
donec := ctx.Done()
return blobserver.EnumerateAllFrom(ctx, small, contToken, func(sb blob.SizedRef) error {
select {
case dest <- blobserver.BlobAndToken{
Blob: blob.NewBlob(sb.Ref, sb.Size, func(ctx context.Context) ([]byte, error) {
return slurpSizedRef(ctx, small, sb)
}),
Token: sb.Ref.StringMinusOne(), // streamer is >=, enumerate is >
}:
return nil
case <-donec:
return ctx.Err()
}
})
} | go | func (st smallBlobStreamer) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
small := st.sto.small
if bs, ok := small.(blobserver.BlobStreamer); ok {
return bs.StreamBlobs(ctx, dest, contToken)
}
defer close(dest)
donec := ctx.Done()
return blobserver.EnumerateAllFrom(ctx, small, contToken, func(sb blob.SizedRef) error {
select {
case dest <- blobserver.BlobAndToken{
Blob: blob.NewBlob(sb.Ref, sb.Size, func(ctx context.Context) ([]byte, error) {
return slurpSizedRef(ctx, small, sb)
}),
Token: sb.Ref.StringMinusOne(), // streamer is >=, enumerate is >
}:
return nil
case <-donec:
return ctx.Err()
}
})
} | [
"func",
"(",
"st",
"smallBlobStreamer",
")",
"StreamBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blobserver",
".",
"BlobAndToken",
",",
"contToken",
"string",
")",
"(",
"err",
"error",
")",
"{",
"small",
":=",
"st",
".",
"sto",
".",
"small",
"\n",
"if",
"bs",
",",
"ok",
":=",
"small",
".",
"(",
"blobserver",
".",
"BlobStreamer",
")",
";",
"ok",
"{",
"return",
"bs",
".",
"StreamBlobs",
"(",
"ctx",
",",
"dest",
",",
"contToken",
")",
"\n",
"}",
"\n",
"defer",
"close",
"(",
"dest",
")",
"\n",
"donec",
":=",
"ctx",
".",
"Done",
"(",
")",
"\n",
"return",
"blobserver",
".",
"EnumerateAllFrom",
"(",
"ctx",
",",
"small",
",",
"contToken",
",",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"select",
"{",
"case",
"dest",
"<-",
"blobserver",
".",
"BlobAndToken",
"{",
"Blob",
":",
"blob",
".",
"NewBlob",
"(",
"sb",
".",
"Ref",
",",
"sb",
".",
"Size",
",",
"func",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"slurpSizedRef",
"(",
"ctx",
",",
"small",
",",
"sb",
")",
"\n",
"}",
")",
",",
"Token",
":",
"sb",
".",
"Ref",
".",
"StringMinusOne",
"(",
")",
",",
"// streamer is >=, enumerate is >",
"}",
":",
"return",
"nil",
"\n",
"case",
"<-",
"donec",
":",
"return",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // stream the loose blobs | [
"stream",
"the",
"loose",
"blobs"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/stream.go#L44-L64 | train |
perkeep/perkeep | internal/images/images.go | ScaledDimensions | func ScaledDimensions(w, h, mw, mh int) (newWidth int, newHeight int) {
if w == 0 || h == 0 || mw == 0 || mh == 0 {
imageDebug("ScaledDimensions was given as 0; returning 1x1 as dimensions.")
return 1, 1
}
newWidth, newHeight = mw, mh
if float32(h)/float32(mh) > float32(w)/float32(mw) {
newWidth = w * mh / h
} else {
newHeight = h * mw / w
}
return
} | go | func ScaledDimensions(w, h, mw, mh int) (newWidth int, newHeight int) {
if w == 0 || h == 0 || mw == 0 || mh == 0 {
imageDebug("ScaledDimensions was given as 0; returning 1x1 as dimensions.")
return 1, 1
}
newWidth, newHeight = mw, mh
if float32(h)/float32(mh) > float32(w)/float32(mw) {
newWidth = w * mh / h
} else {
newHeight = h * mw / w
}
return
} | [
"func",
"ScaledDimensions",
"(",
"w",
",",
"h",
",",
"mw",
",",
"mh",
"int",
")",
"(",
"newWidth",
"int",
",",
"newHeight",
"int",
")",
"{",
"if",
"w",
"==",
"0",
"||",
"h",
"==",
"0",
"||",
"mw",
"==",
"0",
"||",
"mh",
"==",
"0",
"{",
"imageDebug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"1",
",",
"1",
"\n",
"}",
"\n",
"newWidth",
",",
"newHeight",
"=",
"mw",
",",
"mh",
"\n",
"if",
"float32",
"(",
"h",
")",
"/",
"float32",
"(",
"mh",
")",
">",
"float32",
"(",
"w",
")",
"/",
"float32",
"(",
"mw",
")",
"{",
"newWidth",
"=",
"w",
"*",
"mh",
"/",
"h",
"\n",
"}",
"else",
"{",
"newHeight",
"=",
"h",
"*",
"mw",
"/",
"w",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // ScaledDimensions returns the newWidth and newHeight obtained
// when an image of dimensions w x h has to be rescaled under
// mw x mh, while conserving the proportions.
// It returns 1,1 if any of the parameter is 0. | [
"ScaledDimensions",
"returns",
"the",
"newWidth",
"and",
"newHeight",
"obtained",
"when",
"an",
"image",
"of",
"dimensions",
"w",
"x",
"h",
"has",
"to",
"be",
"rescaled",
"under",
"mw",
"x",
"mh",
"while",
"conserving",
"the",
"proportions",
".",
"It",
"returns",
"1",
"1",
"if",
"any",
"of",
"the",
"parameter",
"is",
"0",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L248-L260 | train |
perkeep/perkeep | internal/images/images.go | rescaleDimensions | func (opts *DecodeOpts) rescaleDimensions(b image.Rectangle, swapDimensions bool) (width, height int, needRescale bool) {
w, h := b.Dx(), b.Dy()
mw, mh := opts.MaxWidth, opts.MaxHeight
mwf, mhf := opts.ScaleWidth, opts.ScaleHeight
if mw == 0 && mh == 0 && mwf == 0 && mhf == 0 {
return w, h, false
}
// Floating point compares probably only allow this to work if the values
// were specified as the literal 1 or 1.0, computed values will likely be
// off. If Scale{Width,Height} end up being 1.0-epsilon we'll rescale
// when it probably wouldn't even be noticeable but that's okay.
if opts.ScaleWidth == 1.0 && opts.ScaleHeight == 1.0 {
return w, h, false
}
if swapDimensions {
w, h = h, w
}
// ScaleWidth and ScaleHeight overrule MaxWidth and MaxHeight
if mwf > 0.0 && mwf <= 1 {
mw = int(mwf * float32(w))
}
if mhf > 0.0 && mhf <= 1 {
mh = int(mhf * float32(h))
}
neww, newh := ScaledDimensions(w, h, mw, mh)
if neww > w || newh > h {
// Don't scale up.
return w, h, false
}
needRescale = neww != w || newh != h
if swapDimensions {
return newh, neww, needRescale
}
return neww, newh, needRescale
} | go | func (opts *DecodeOpts) rescaleDimensions(b image.Rectangle, swapDimensions bool) (width, height int, needRescale bool) {
w, h := b.Dx(), b.Dy()
mw, mh := opts.MaxWidth, opts.MaxHeight
mwf, mhf := opts.ScaleWidth, opts.ScaleHeight
if mw == 0 && mh == 0 && mwf == 0 && mhf == 0 {
return w, h, false
}
// Floating point compares probably only allow this to work if the values
// were specified as the literal 1 or 1.0, computed values will likely be
// off. If Scale{Width,Height} end up being 1.0-epsilon we'll rescale
// when it probably wouldn't even be noticeable but that's okay.
if opts.ScaleWidth == 1.0 && opts.ScaleHeight == 1.0 {
return w, h, false
}
if swapDimensions {
w, h = h, w
}
// ScaleWidth and ScaleHeight overrule MaxWidth and MaxHeight
if mwf > 0.0 && mwf <= 1 {
mw = int(mwf * float32(w))
}
if mhf > 0.0 && mhf <= 1 {
mh = int(mhf * float32(h))
}
neww, newh := ScaledDimensions(w, h, mw, mh)
if neww > w || newh > h {
// Don't scale up.
return w, h, false
}
needRescale = neww != w || newh != h
if swapDimensions {
return newh, neww, needRescale
}
return neww, newh, needRescale
} | [
"func",
"(",
"opts",
"*",
"DecodeOpts",
")",
"rescaleDimensions",
"(",
"b",
"image",
".",
"Rectangle",
",",
"swapDimensions",
"bool",
")",
"(",
"width",
",",
"height",
"int",
",",
"needRescale",
"bool",
")",
"{",
"w",
",",
"h",
":=",
"b",
".",
"Dx",
"(",
")",
",",
"b",
".",
"Dy",
"(",
")",
"\n",
"mw",
",",
"mh",
":=",
"opts",
".",
"MaxWidth",
",",
"opts",
".",
"MaxHeight",
"\n",
"mwf",
",",
"mhf",
":=",
"opts",
".",
"ScaleWidth",
",",
"opts",
".",
"ScaleHeight",
"\n",
"if",
"mw",
"==",
"0",
"&&",
"mh",
"==",
"0",
"&&",
"mwf",
"==",
"0",
"&&",
"mhf",
"==",
"0",
"{",
"return",
"w",
",",
"h",
",",
"false",
"\n",
"}",
"\n\n",
"// Floating point compares probably only allow this to work if the values",
"// were specified as the literal 1 or 1.0, computed values will likely be",
"// off. If Scale{Width,Height} end up being 1.0-epsilon we'll rescale",
"// when it probably wouldn't even be noticeable but that's okay.",
"if",
"opts",
".",
"ScaleWidth",
"==",
"1.0",
"&&",
"opts",
".",
"ScaleHeight",
"==",
"1.0",
"{",
"return",
"w",
",",
"h",
",",
"false",
"\n",
"}",
"\n\n",
"if",
"swapDimensions",
"{",
"w",
",",
"h",
"=",
"h",
",",
"w",
"\n",
"}",
"\n\n",
"// ScaleWidth and ScaleHeight overrule MaxWidth and MaxHeight",
"if",
"mwf",
">",
"0.0",
"&&",
"mwf",
"<=",
"1",
"{",
"mw",
"=",
"int",
"(",
"mwf",
"*",
"float32",
"(",
"w",
")",
")",
"\n",
"}",
"\n",
"if",
"mhf",
">",
"0.0",
"&&",
"mhf",
"<=",
"1",
"{",
"mh",
"=",
"int",
"(",
"mhf",
"*",
"float32",
"(",
"h",
")",
")",
"\n",
"}",
"\n\n",
"neww",
",",
"newh",
":=",
"ScaledDimensions",
"(",
"w",
",",
"h",
",",
"mw",
",",
"mh",
")",
"\n",
"if",
"neww",
">",
"w",
"||",
"newh",
">",
"h",
"{",
"// Don't scale up.",
"return",
"w",
",",
"h",
",",
"false",
"\n",
"}",
"\n\n",
"needRescale",
"=",
"neww",
"!=",
"w",
"||",
"newh",
"!=",
"h",
"\n",
"if",
"swapDimensions",
"{",
"return",
"newh",
",",
"neww",
",",
"needRescale",
"\n",
"}",
"\n",
"return",
"neww",
",",
"newh",
",",
"needRescale",
"\n",
"}"
] | // rescaleDimensions computes the width & height in the pre-rotated
// orientation needed to meet the post-rotation constraints of opts.
// The image bound by b represents the pre-rotated dimensions of the image.
// needRescale is true if the image requires a resize. | [
"rescaleDimensions",
"computes",
"the",
"width",
"&",
"height",
"in",
"the",
"pre",
"-",
"rotated",
"orientation",
"needed",
"to",
"meet",
"the",
"post",
"-",
"rotation",
"constraints",
"of",
"opts",
".",
"The",
"image",
"bound",
"by",
"b",
"represents",
"the",
"pre",
"-",
"rotated",
"dimensions",
"of",
"the",
"image",
".",
"needRescale",
"is",
"true",
"if",
"the",
"image",
"requires",
"a",
"resize",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L266-L305 | train |
perkeep/perkeep | internal/images/images.go | rescale | func rescale(im image.Image, sw, sh int) image.Image {
b := im.Bounds()
w, h := b.Dx(), b.Dy()
if sw == w && sh == h {
return im
}
// If it's gigantic, it's more efficient to downsample first
// and then resize; resizing will smooth out the roughness.
// (trusting the moustachio guys on that one).
if w > sw*2 && h > sh*2 {
im = resize.ResampleInplace(im, b, sw*2, sh*2)
return resize.HalveInplace(im)
}
return resize.Resize(im, b, sw, sh)
} | go | func rescale(im image.Image, sw, sh int) image.Image {
b := im.Bounds()
w, h := b.Dx(), b.Dy()
if sw == w && sh == h {
return im
}
// If it's gigantic, it's more efficient to downsample first
// and then resize; resizing will smooth out the roughness.
// (trusting the moustachio guys on that one).
if w > sw*2 && h > sh*2 {
im = resize.ResampleInplace(im, b, sw*2, sh*2)
return resize.HalveInplace(im)
}
return resize.Resize(im, b, sw, sh)
} | [
"func",
"rescale",
"(",
"im",
"image",
".",
"Image",
",",
"sw",
",",
"sh",
"int",
")",
"image",
".",
"Image",
"{",
"b",
":=",
"im",
".",
"Bounds",
"(",
")",
"\n",
"w",
",",
"h",
":=",
"b",
".",
"Dx",
"(",
")",
",",
"b",
".",
"Dy",
"(",
")",
"\n",
"if",
"sw",
"==",
"w",
"&&",
"sh",
"==",
"h",
"{",
"return",
"im",
"\n",
"}",
"\n\n",
"// If it's gigantic, it's more efficient to downsample first",
"// and then resize; resizing will smooth out the roughness.",
"// (trusting the moustachio guys on that one).",
"if",
"w",
">",
"sw",
"*",
"2",
"&&",
"h",
">",
"sh",
"*",
"2",
"{",
"im",
"=",
"resize",
".",
"ResampleInplace",
"(",
"im",
",",
"b",
",",
"sw",
"*",
"2",
",",
"sh",
"*",
"2",
")",
"\n",
"return",
"resize",
".",
"HalveInplace",
"(",
"im",
")",
"\n",
"}",
"\n",
"return",
"resize",
".",
"Resize",
"(",
"im",
",",
"b",
",",
"sw",
",",
"sh",
")",
"\n",
"}"
] | // rescale resizes im in-place to the dimensions sw x sh, overwriting the
// existing pixel data. It is up to the caller to ensure sw & sh maintain the
// aspect ratio of im. | [
"rescale",
"resizes",
"im",
"in",
"-",
"place",
"to",
"the",
"dimensions",
"sw",
"x",
"sh",
"overwriting",
"the",
"existing",
"pixel",
"data",
".",
"It",
"is",
"up",
"to",
"the",
"caller",
"to",
"ensure",
"sw",
"&",
"sh",
"maintain",
"the",
"aspect",
"ratio",
"of",
"im",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L310-L325 | train |
perkeep/perkeep | internal/images/images.go | forcedOrientation | func (opts *DecodeOpts) forcedOrientation() (angle int, flipMode FlipDirection, err error) {
var (
ok bool
)
if opts.forcedRotate() {
if angle, ok = opts.Rotate.(int); !ok {
return 0, 0, fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
}
}
if opts.forcedFlip() {
if flipMode, ok = opts.Flip.(FlipDirection); !ok {
return 0, 0, fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
}
}
return angle, flipMode, nil
} | go | func (opts *DecodeOpts) forcedOrientation() (angle int, flipMode FlipDirection, err error) {
var (
ok bool
)
if opts.forcedRotate() {
if angle, ok = opts.Rotate.(int); !ok {
return 0, 0, fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
}
}
if opts.forcedFlip() {
if flipMode, ok = opts.Flip.(FlipDirection); !ok {
return 0, 0, fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
}
}
return angle, flipMode, nil
} | [
"func",
"(",
"opts",
"*",
"DecodeOpts",
")",
"forcedOrientation",
"(",
")",
"(",
"angle",
"int",
",",
"flipMode",
"FlipDirection",
",",
"err",
"error",
")",
"{",
"var",
"(",
"ok",
"bool",
"\n",
")",
"\n",
"if",
"opts",
".",
"forcedRotate",
"(",
")",
"{",
"if",
"angle",
",",
"ok",
"=",
"opts",
".",
"Rotate",
".",
"(",
"int",
")",
";",
"!",
"ok",
"{",
"return",
"0",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"opts",
".",
"Rotate",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"opts",
".",
"forcedFlip",
"(",
")",
"{",
"if",
"flipMode",
",",
"ok",
"=",
"opts",
".",
"Flip",
".",
"(",
"FlipDirection",
")",
";",
"!",
"ok",
"{",
"return",
"0",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"opts",
".",
"Flip",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"angle",
",",
"flipMode",
",",
"nil",
"\n",
"}"
] | // forcedOrientation returns the rotation and flip values stored in opts. The
// values are asserted to their proper type, and err is non-nil if an invalid
// value is found. This function ignores the orientation stored in EXIF.
// If auto-correction of the image's orientation is desired, it is the
// caller's responsibility to check via useEXIF first. | [
"forcedOrientation",
"returns",
"the",
"rotation",
"and",
"flip",
"values",
"stored",
"in",
"opts",
".",
"The",
"values",
"are",
"asserted",
"to",
"their",
"proper",
"type",
"and",
"err",
"is",
"non",
"-",
"nil",
"if",
"an",
"invalid",
"value",
"is",
"found",
".",
"This",
"function",
"ignores",
"the",
"orientation",
"stored",
"in",
"EXIF",
".",
"If",
"auto",
"-",
"correction",
"of",
"the",
"image",
"s",
"orientation",
"is",
"desired",
"it",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"check",
"via",
"useEXIF",
"first",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L348-L363 | train |
perkeep/perkeep | internal/images/images.go | DecodeConfig | func DecodeConfig(r io.Reader) (Config, error) {
var buf bytes.Buffer
tr := io.TeeReader(io.LimitReader(r, 8<<20), &buf)
conf, format, err := image.DecodeConfig(tr)
if err != nil {
if debug {
log.Printf("internal/images: DecodeConfig failed after reading %d bytes: %v", buf.Len(), err)
}
return Config{}, err
}
c := Config{
Format: format,
Width: conf.Width,
Height: conf.Height,
}
mr := io.LimitReader(io.MultiReader(&buf, r), 8<<20)
if format == "heic" {
hf := heif.Open(readerutil.NewBufferingReaderAt(mr))
exifBytes, err := hf.EXIF()
if err != nil {
return c, err
}
c.HEICEXIF = exifBytes
mr = bytes.NewReader(exifBytes)
}
ex, err := exif.Decode(mr)
// trigger a retry when there isn't enough data for reading exif data from a tiff file
if exif.IsShortReadTagValueError(err) {
return c, io.ErrUnexpectedEOF
}
if err != nil {
imageDebug(fmt.Sprintf("No valid EXIF, error: %v.", err))
return c, nil
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF.`)
return c, nil
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF Error: %v", err))
return c, nil
}
switch orient {
// those are the orientations that require
// a rotation of ±90
case leftSideTop, rightSideTop, rightSideBottom, leftSideBottom:
c.Width, c.Height = c.Height, c.Width
}
return c, nil
} | go | func DecodeConfig(r io.Reader) (Config, error) {
var buf bytes.Buffer
tr := io.TeeReader(io.LimitReader(r, 8<<20), &buf)
conf, format, err := image.DecodeConfig(tr)
if err != nil {
if debug {
log.Printf("internal/images: DecodeConfig failed after reading %d bytes: %v", buf.Len(), err)
}
return Config{}, err
}
c := Config{
Format: format,
Width: conf.Width,
Height: conf.Height,
}
mr := io.LimitReader(io.MultiReader(&buf, r), 8<<20)
if format == "heic" {
hf := heif.Open(readerutil.NewBufferingReaderAt(mr))
exifBytes, err := hf.EXIF()
if err != nil {
return c, err
}
c.HEICEXIF = exifBytes
mr = bytes.NewReader(exifBytes)
}
ex, err := exif.Decode(mr)
// trigger a retry when there isn't enough data for reading exif data from a tiff file
if exif.IsShortReadTagValueError(err) {
return c, io.ErrUnexpectedEOF
}
if err != nil {
imageDebug(fmt.Sprintf("No valid EXIF, error: %v.", err))
return c, nil
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF.`)
return c, nil
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF Error: %v", err))
return c, nil
}
switch orient {
// those are the orientations that require
// a rotation of ±90
case leftSideTop, rightSideTop, rightSideBottom, leftSideBottom:
c.Width, c.Height = c.Height, c.Width
}
return c, nil
} | [
"func",
"DecodeConfig",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"Config",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"tr",
":=",
"io",
".",
"TeeReader",
"(",
"io",
".",
"LimitReader",
"(",
"r",
",",
"8",
"<<",
"20",
")",
",",
"&",
"buf",
")",
"\n\n",
"conf",
",",
"format",
",",
"err",
":=",
"image",
".",
"DecodeConfig",
"(",
"tr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"debug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"buf",
".",
"Len",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"Config",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"c",
":=",
"Config",
"{",
"Format",
":",
"format",
",",
"Width",
":",
"conf",
".",
"Width",
",",
"Height",
":",
"conf",
".",
"Height",
",",
"}",
"\n",
"mr",
":=",
"io",
".",
"LimitReader",
"(",
"io",
".",
"MultiReader",
"(",
"&",
"buf",
",",
"r",
")",
",",
"8",
"<<",
"20",
")",
"\n",
"if",
"format",
"==",
"\"",
"\"",
"{",
"hf",
":=",
"heif",
".",
"Open",
"(",
"readerutil",
".",
"NewBufferingReaderAt",
"(",
"mr",
")",
")",
"\n",
"exifBytes",
",",
"err",
":=",
"hf",
".",
"EXIF",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"c",
".",
"HEICEXIF",
"=",
"exifBytes",
"\n",
"mr",
"=",
"bytes",
".",
"NewReader",
"(",
"exifBytes",
")",
"\n",
"}",
"\n\n",
"ex",
",",
"err",
":=",
"exif",
".",
"Decode",
"(",
"mr",
")",
"\n",
"// trigger a retry when there isn't enough data for reading exif data from a tiff file",
"if",
"exif",
".",
"IsShortReadTagValueError",
"(",
"err",
")",
"{",
"return",
"c",
",",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"imageDebug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}",
"\n",
"tag",
",",
"err",
":=",
"ex",
".",
"Get",
"(",
"exif",
".",
"Orientation",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"imageDebug",
"(",
"`No \"Orientation\" tag in EXIF.`",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}",
"\n",
"orient",
",",
"err",
":=",
"tag",
".",
"Int",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"imageDebug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}",
"\n",
"switch",
"orient",
"{",
"// those are the orientations that require",
"// a rotation of ±90",
"case",
"leftSideTop",
",",
"rightSideTop",
",",
"rightSideBottom",
",",
"leftSideBottom",
":",
"c",
".",
"Width",
",",
"c",
".",
"Height",
"=",
"c",
".",
"Height",
",",
"c",
".",
"Width",
"\n",
"}",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // DecodeConfig returns the image Config similarly to
// the standard library's image.DecodeConfig with the
// addition that it also checks for an EXIF orientation,
// and sets the Width and Height as they would visibly
// be after correcting for that orientation. | [
"DecodeConfig",
"returns",
"the",
"image",
"Config",
"similarly",
"to",
"the",
"standard",
"library",
"s",
"image",
".",
"DecodeConfig",
"with",
"the",
"addition",
"that",
"it",
"also",
"checks",
"for",
"an",
"EXIF",
"orientation",
"and",
"sets",
"the",
"Width",
"and",
"Height",
"as",
"they",
"would",
"visibly",
"be",
"after",
"correcting",
"for",
"that",
"orientation",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L395-L448 | train |
perkeep/perkeep | internal/images/images.go | decode | func decode(r io.Reader, opts *DecodeOpts, swapDimensions bool) (im image.Image, format string, err error, needRescale bool) {
if opts == nil {
// Fall-back to normal decode.
im, format, err = image.Decode(r)
return im, format, err, false
}
var buf bytes.Buffer
tr := io.TeeReader(r, &buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, "", err, false
}
mr := io.MultiReader(&buf, r)
b := image.Rect(0, 0, ic.Width, ic.Height)
sw, sh, needRescale := opts.rescaleDimensions(b, swapDimensions)
if !needRescale {
im, format, err = image.Decode(mr)
return im, format, err, false
}
imageDebug(fmt.Sprintf("Resizing from %dx%d -> %dx%d", ic.Width, ic.Height, sw, sh))
if format == "cr2" {
// Replace mr with an io.Reader to the JPEG thumbnail embedded in a
// CR2 image.
if mr, err = cr2.NewReader(mr); err != nil {
return nil, "", err, false
}
format = "jpeg"
}
if format == "jpeg" && fastjpeg.Available() {
factor := fastjpeg.Factor(ic.Width, ic.Height, sw, sh)
if factor > 1 {
var buf bytes.Buffer
tr := io.TeeReader(mr, &buf)
im, err = fastjpeg.DecodeDownsample(tr, factor)
switch err.(type) {
case fastjpeg.DjpegFailedError:
log.Printf("Retrying with jpeg.Decode, because djpeg failed with: %v", err)
im, err = jpeg.Decode(io.MultiReader(&buf, mr))
case nil:
// fallthrough to rescale() below.
default:
return nil, format, err, false
}
return rescale(im, sw, sh), format, err, true
}
}
// Fall-back to normal decode.
im, format, err = image.Decode(mr)
if err != nil {
return nil, "", err, false
}
return rescale(im, sw, sh), format, err, needRescale
} | go | func decode(r io.Reader, opts *DecodeOpts, swapDimensions bool) (im image.Image, format string, err error, needRescale bool) {
if opts == nil {
// Fall-back to normal decode.
im, format, err = image.Decode(r)
return im, format, err, false
}
var buf bytes.Buffer
tr := io.TeeReader(r, &buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, "", err, false
}
mr := io.MultiReader(&buf, r)
b := image.Rect(0, 0, ic.Width, ic.Height)
sw, sh, needRescale := opts.rescaleDimensions(b, swapDimensions)
if !needRescale {
im, format, err = image.Decode(mr)
return im, format, err, false
}
imageDebug(fmt.Sprintf("Resizing from %dx%d -> %dx%d", ic.Width, ic.Height, sw, sh))
if format == "cr2" {
// Replace mr with an io.Reader to the JPEG thumbnail embedded in a
// CR2 image.
if mr, err = cr2.NewReader(mr); err != nil {
return nil, "", err, false
}
format = "jpeg"
}
if format == "jpeg" && fastjpeg.Available() {
factor := fastjpeg.Factor(ic.Width, ic.Height, sw, sh)
if factor > 1 {
var buf bytes.Buffer
tr := io.TeeReader(mr, &buf)
im, err = fastjpeg.DecodeDownsample(tr, factor)
switch err.(type) {
case fastjpeg.DjpegFailedError:
log.Printf("Retrying with jpeg.Decode, because djpeg failed with: %v", err)
im, err = jpeg.Decode(io.MultiReader(&buf, mr))
case nil:
// fallthrough to rescale() below.
default:
return nil, format, err, false
}
return rescale(im, sw, sh), format, err, true
}
}
// Fall-back to normal decode.
im, format, err = image.Decode(mr)
if err != nil {
return nil, "", err, false
}
return rescale(im, sw, sh), format, err, needRescale
} | [
"func",
"decode",
"(",
"r",
"io",
".",
"Reader",
",",
"opts",
"*",
"DecodeOpts",
",",
"swapDimensions",
"bool",
")",
"(",
"im",
"image",
".",
"Image",
",",
"format",
"string",
",",
"err",
"error",
",",
"needRescale",
"bool",
")",
"{",
"if",
"opts",
"==",
"nil",
"{",
"// Fall-back to normal decode.",
"im",
",",
"format",
",",
"err",
"=",
"image",
".",
"Decode",
"(",
"r",
")",
"\n",
"return",
"im",
",",
"format",
",",
"err",
",",
"false",
"\n",
"}",
"\n\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"tr",
":=",
"io",
".",
"TeeReader",
"(",
"r",
",",
"&",
"buf",
")",
"\n",
"ic",
",",
"format",
",",
"err",
":=",
"image",
".",
"DecodeConfig",
"(",
"tr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
",",
"false",
"\n",
"}",
"\n\n",
"mr",
":=",
"io",
".",
"MultiReader",
"(",
"&",
"buf",
",",
"r",
")",
"\n",
"b",
":=",
"image",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"ic",
".",
"Width",
",",
"ic",
".",
"Height",
")",
"\n",
"sw",
",",
"sh",
",",
"needRescale",
":=",
"opts",
".",
"rescaleDimensions",
"(",
"b",
",",
"swapDimensions",
")",
"\n",
"if",
"!",
"needRescale",
"{",
"im",
",",
"format",
",",
"err",
"=",
"image",
".",
"Decode",
"(",
"mr",
")",
"\n",
"return",
"im",
",",
"format",
",",
"err",
",",
"false",
"\n",
"}",
"\n\n",
"imageDebug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ic",
".",
"Width",
",",
"ic",
".",
"Height",
",",
"sw",
",",
"sh",
")",
")",
"\n",
"if",
"format",
"==",
"\"",
"\"",
"{",
"// Replace mr with an io.Reader to the JPEG thumbnail embedded in a",
"// CR2 image.",
"if",
"mr",
",",
"err",
"=",
"cr2",
".",
"NewReader",
"(",
"mr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
",",
"false",
"\n",
"}",
"\n",
"format",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"format",
"==",
"\"",
"\"",
"&&",
"fastjpeg",
".",
"Available",
"(",
")",
"{",
"factor",
":=",
"fastjpeg",
".",
"Factor",
"(",
"ic",
".",
"Width",
",",
"ic",
".",
"Height",
",",
"sw",
",",
"sh",
")",
"\n",
"if",
"factor",
">",
"1",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"tr",
":=",
"io",
".",
"TeeReader",
"(",
"mr",
",",
"&",
"buf",
")",
"\n",
"im",
",",
"err",
"=",
"fastjpeg",
".",
"DecodeDownsample",
"(",
"tr",
",",
"factor",
")",
"\n",
"switch",
"err",
".",
"(",
"type",
")",
"{",
"case",
"fastjpeg",
".",
"DjpegFailedError",
":",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"im",
",",
"err",
"=",
"jpeg",
".",
"Decode",
"(",
"io",
".",
"MultiReader",
"(",
"&",
"buf",
",",
"mr",
")",
")",
"\n",
"case",
"nil",
":",
"// fallthrough to rescale() below.",
"default",
":",
"return",
"nil",
",",
"format",
",",
"err",
",",
"false",
"\n",
"}",
"\n",
"return",
"rescale",
"(",
"im",
",",
"sw",
",",
"sh",
")",
",",
"format",
",",
"err",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Fall-back to normal decode.",
"im",
",",
"format",
",",
"err",
"=",
"image",
".",
"Decode",
"(",
"mr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
",",
"false",
"\n",
"}",
"\n",
"return",
"rescale",
"(",
"im",
",",
"sw",
",",
"sh",
")",
",",
"format",
",",
"err",
",",
"needRescale",
"\n",
"}"
] | // decoder reads an image from r and modifies the image as defined by opts.
// swapDimensions indicates the decoded image will be rotated after being
// returned, and when interpreting opts, the post-rotation dimensions should
// be considered.
// The decoded image is returned in im. The registered name of the decoder
// used is returned in format. If the image was not successfully decoded, err
// will be non-nil. If the decoded image was made smaller, needRescale will
// be true. | [
"decoder",
"reads",
"an",
"image",
"from",
"r",
"and",
"modifies",
"the",
"image",
"as",
"defined",
"by",
"opts",
".",
"swapDimensions",
"indicates",
"the",
"decoded",
"image",
"will",
"be",
"rotated",
"after",
"being",
"returned",
"and",
"when",
"interpreting",
"opts",
"the",
"post",
"-",
"rotation",
"dimensions",
"should",
"be",
"considered",
".",
"The",
"decoded",
"image",
"is",
"returned",
"in",
"im",
".",
"The",
"registered",
"name",
"of",
"the",
"decoder",
"used",
"is",
"returned",
"in",
"format",
".",
"If",
"the",
"image",
"was",
"not",
"successfully",
"decoded",
"err",
"will",
"be",
"non",
"-",
"nil",
".",
"If",
"the",
"decoded",
"image",
"was",
"made",
"smaller",
"needRescale",
"will",
"be",
"true",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L458-L515 | train |
perkeep/perkeep | internal/images/images.go | exifOrientation | func exifOrientation(r io.Reader) (int, FlipDirection) {
var (
angle int
flipMode FlipDirection
)
ex, err := exif.Decode(r)
if err != nil {
imageDebug("No valid EXIF; will not rotate or flip.")
return 0, 0
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF; will not rotate or flip.`)
return 0, 0
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF error: %v", err))
return 0, 0
}
switch orient {
case topLeftSide:
// do nothing
case topRightSide:
flipMode = 2
case bottomRightSide:
angle = 180
case bottomLeftSide:
angle = 180
flipMode = 2
case leftSideTop:
angle = -90
flipMode = 2
case rightSideTop:
angle = -90
case rightSideBottom:
angle = 90
flipMode = 2
case leftSideBottom:
angle = 90
}
return angle, flipMode
} | go | func exifOrientation(r io.Reader) (int, FlipDirection) {
var (
angle int
flipMode FlipDirection
)
ex, err := exif.Decode(r)
if err != nil {
imageDebug("No valid EXIF; will not rotate or flip.")
return 0, 0
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF; will not rotate or flip.`)
return 0, 0
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF error: %v", err))
return 0, 0
}
switch orient {
case topLeftSide:
// do nothing
case topRightSide:
flipMode = 2
case bottomRightSide:
angle = 180
case bottomLeftSide:
angle = 180
flipMode = 2
case leftSideTop:
angle = -90
flipMode = 2
case rightSideTop:
angle = -90
case rightSideBottom:
angle = 90
flipMode = 2
case leftSideBottom:
angle = 90
}
return angle, flipMode
} | [
"func",
"exifOrientation",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"FlipDirection",
")",
"{",
"var",
"(",
"angle",
"int",
"\n",
"flipMode",
"FlipDirection",
"\n",
")",
"\n",
"ex",
",",
"err",
":=",
"exif",
".",
"Decode",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"imageDebug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"0",
",",
"0",
"\n",
"}",
"\n",
"tag",
",",
"err",
":=",
"ex",
".",
"Get",
"(",
"exif",
".",
"Orientation",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"imageDebug",
"(",
"`No \"Orientation\" tag in EXIF; will not rotate or flip.`",
")",
"\n",
"return",
"0",
",",
"0",
"\n",
"}",
"\n",
"orient",
",",
"err",
":=",
"tag",
".",
"Int",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"imageDebug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"0",
",",
"0",
"\n",
"}",
"\n",
"switch",
"orient",
"{",
"case",
"topLeftSide",
":",
"// do nothing",
"case",
"topRightSide",
":",
"flipMode",
"=",
"2",
"\n",
"case",
"bottomRightSide",
":",
"angle",
"=",
"180",
"\n",
"case",
"bottomLeftSide",
":",
"angle",
"=",
"180",
"\n",
"flipMode",
"=",
"2",
"\n",
"case",
"leftSideTop",
":",
"angle",
"=",
"-",
"90",
"\n",
"flipMode",
"=",
"2",
"\n",
"case",
"rightSideTop",
":",
"angle",
"=",
"-",
"90",
"\n",
"case",
"rightSideBottom",
":",
"angle",
"=",
"90",
"\n",
"flipMode",
"=",
"2",
"\n",
"case",
"leftSideBottom",
":",
"angle",
"=",
"90",
"\n",
"}",
"\n",
"return",
"angle",
",",
"flipMode",
"\n",
"}"
] | // exifOrientation parses the EXIF data in r and returns the stored
// orientation as the angle and flip necessary to transform the image. | [
"exifOrientation",
"parses",
"the",
"EXIF",
"data",
"in",
"r",
"and",
"returns",
"the",
"stored",
"orientation",
"as",
"the",
"angle",
"and",
"flip",
"necessary",
"to",
"transform",
"the",
"image",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L519-L561 | train |
perkeep/perkeep | internal/images/images.go | Decode | func Decode(r io.Reader, opts *DecodeOpts) (image.Image, Config, error) {
var (
angle int
buf bytes.Buffer
c Config
flipMode FlipDirection
)
tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
if opts.useEXIF() {
angle, flipMode = exifOrientation(tr)
} else {
var err error
angle, flipMode, err = opts.forcedOrientation()
if err != nil {
return nil, c, err
}
}
// Orientation changing rotations should have their dimensions swapped
// when scaling.
var swapDimensions bool
switch angle {
case 90, -90:
swapDimensions = true
}
mr := io.MultiReader(&buf, r)
im, format, err, rescaled := decode(mr, opts, swapDimensions)
if err != nil {
return nil, c, err
}
c.Modified = rescaled
if angle != 0 {
im = rotate(im, angle)
c.Modified = true
}
if flipMode != 0 {
im = flip(im, flipMode)
c.Modified = true
}
c.Format = format
c.setBounds(im)
return im, c, nil
} | go | func Decode(r io.Reader, opts *DecodeOpts) (image.Image, Config, error) {
var (
angle int
buf bytes.Buffer
c Config
flipMode FlipDirection
)
tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
if opts.useEXIF() {
angle, flipMode = exifOrientation(tr)
} else {
var err error
angle, flipMode, err = opts.forcedOrientation()
if err != nil {
return nil, c, err
}
}
// Orientation changing rotations should have their dimensions swapped
// when scaling.
var swapDimensions bool
switch angle {
case 90, -90:
swapDimensions = true
}
mr := io.MultiReader(&buf, r)
im, format, err, rescaled := decode(mr, opts, swapDimensions)
if err != nil {
return nil, c, err
}
c.Modified = rescaled
if angle != 0 {
im = rotate(im, angle)
c.Modified = true
}
if flipMode != 0 {
im = flip(im, flipMode)
c.Modified = true
}
c.Format = format
c.setBounds(im)
return im, c, nil
} | [
"func",
"Decode",
"(",
"r",
"io",
".",
"Reader",
",",
"opts",
"*",
"DecodeOpts",
")",
"(",
"image",
".",
"Image",
",",
"Config",
",",
"error",
")",
"{",
"var",
"(",
"angle",
"int",
"\n",
"buf",
"bytes",
".",
"Buffer",
"\n",
"c",
"Config",
"\n",
"flipMode",
"FlipDirection",
"\n",
")",
"\n\n",
"tr",
":=",
"io",
".",
"TeeReader",
"(",
"io",
".",
"LimitReader",
"(",
"r",
",",
"2",
"<<",
"20",
")",
",",
"&",
"buf",
")",
"\n",
"if",
"opts",
".",
"useEXIF",
"(",
")",
"{",
"angle",
",",
"flipMode",
"=",
"exifOrientation",
"(",
"tr",
")",
"\n",
"}",
"else",
"{",
"var",
"err",
"error",
"\n",
"angle",
",",
"flipMode",
",",
"err",
"=",
"opts",
".",
"forcedOrientation",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Orientation changing rotations should have their dimensions swapped",
"// when scaling.",
"var",
"swapDimensions",
"bool",
"\n",
"switch",
"angle",
"{",
"case",
"90",
",",
"-",
"90",
":",
"swapDimensions",
"=",
"true",
"\n",
"}",
"\n\n",
"mr",
":=",
"io",
".",
"MultiReader",
"(",
"&",
"buf",
",",
"r",
")",
"\n",
"im",
",",
"format",
",",
"err",
",",
"rescaled",
":=",
"decode",
"(",
"mr",
",",
"opts",
",",
"swapDimensions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
",",
"err",
"\n",
"}",
"\n",
"c",
".",
"Modified",
"=",
"rescaled",
"\n\n",
"if",
"angle",
"!=",
"0",
"{",
"im",
"=",
"rotate",
"(",
"im",
",",
"angle",
")",
"\n",
"c",
".",
"Modified",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"flipMode",
"!=",
"0",
"{",
"im",
"=",
"flip",
"(",
"im",
",",
"flipMode",
")",
"\n",
"c",
".",
"Modified",
"=",
"true",
"\n",
"}",
"\n\n",
"c",
".",
"Format",
"=",
"format",
"\n",
"c",
".",
"setBounds",
"(",
"im",
")",
"\n",
"return",
"im",
",",
"c",
",",
"nil",
"\n",
"}"
] | // Decode decodes an image from r using the provided decoding options.
// The Config returned is similar to the one from the image package,
// with the addition of the Modified field which indicates if the
// image was actually flipped, rotated, or scaled.
// If opts is nil, the defaults are used. | [
"Decode",
"decodes",
"an",
"image",
"from",
"r",
"using",
"the",
"provided",
"decoding",
"options",
".",
"The",
"Config",
"returned",
"is",
"similar",
"to",
"the",
"one",
"from",
"the",
"image",
"package",
"with",
"the",
"addition",
"of",
"the",
"Modified",
"field",
"which",
"indicates",
"if",
"the",
"image",
"was",
"actually",
"flipped",
"rotated",
"or",
"scaled",
".",
"If",
"opts",
"is",
"nil",
"the",
"defaults",
"are",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L568-L615 | train |
perkeep/perkeep | internal/images/images.go | localImageMagick | func localImageMagick() string {
bin, err := exec.LookPath("magick")
if err != nil {
return ""
}
magickHasHEIC.Lock()
defer magickHasHEIC.Unlock()
if magickHasHEIC.checked {
if magickHasHEIC.heic {
return bin
}
return ""
}
magickHasHEIC.checked = true
out, err := exec.Command(bin, "-version").CombinedOutput()
if err != nil {
log.Printf("internal/images: error checking local machine's imagemagick version: %v, %s", err, out)
return ""
}
if strings.Contains(string(out), " heic") {
magickHasHEIC.heic = true
return bin
}
return ""
} | go | func localImageMagick() string {
bin, err := exec.LookPath("magick")
if err != nil {
return ""
}
magickHasHEIC.Lock()
defer magickHasHEIC.Unlock()
if magickHasHEIC.checked {
if magickHasHEIC.heic {
return bin
}
return ""
}
magickHasHEIC.checked = true
out, err := exec.Command(bin, "-version").CombinedOutput()
if err != nil {
log.Printf("internal/images: error checking local machine's imagemagick version: %v, %s", err, out)
return ""
}
if strings.Contains(string(out), " heic") {
magickHasHEIC.heic = true
return bin
}
return ""
} | [
"func",
"localImageMagick",
"(",
")",
"string",
"{",
"bin",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"magickHasHEIC",
".",
"Lock",
"(",
")",
"\n",
"defer",
"magickHasHEIC",
".",
"Unlock",
"(",
")",
"\n",
"if",
"magickHasHEIC",
".",
"checked",
"{",
"if",
"magickHasHEIC",
".",
"heic",
"{",
"return",
"bin",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"magickHasHEIC",
".",
"checked",
"=",
"true",
"\n",
"out",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"bin",
",",
"\"",
"\"",
")",
".",
"CombinedOutput",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
",",
"out",
")",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"string",
"(",
"out",
")",
",",
"\"",
"\"",
")",
"{",
"magickHasHEIC",
".",
"heic",
"=",
"true",
"\n",
"return",
"bin",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // localImageMagick returns the path to the local ImageMagick "magick" binary,
// if it's new enough. Otherwise it returns the empty string. | [
"localImageMagick",
"returns",
"the",
"path",
"to",
"the",
"local",
"ImageMagick",
"magick",
"binary",
"if",
"it",
"s",
"new",
"enough",
".",
"Otherwise",
"it",
"returns",
"the",
"empty",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L633-L657 | train |
perkeep/perkeep | internal/images/images.go | HEIFToJPEG | func HEIFToJPEG(fr io.Reader, maxSize *Dimensions) ([]byte, error) {
convertGate.Start()
defer convertGate.Done()
useDocker := false
bin := localImageMagick()
if bin == "" {
if err := setUpThumbnailContainer(); err != nil {
return nil, NoHEICTOJPEGError{fmt.Errorf("recent ImageMagick magick binary not found in PATH, and could not fallback on docker image because %v. Install a modern ImageMagick or install docker.", err)}
}
bin = "docker"
useDocker = true
}
outDir, err := ioutil.TempDir("", "perkeep-heif")
if err != nil {
return nil, err
}
defer os.RemoveAll(outDir)
inFile := filepath.Join(outDir, "input.heic")
outFile := filepath.Join(outDir, "output.jpg")
// first create the input file in tmp as heiftojpeg cannot take a piped stdin
f, err := os.Create(inFile)
if err != nil {
return nil, err
}
if _, err := io.Copy(f, fr); err != nil {
f.Close()
return nil, err
}
if err := f.Close(); err != nil {
return nil, err
}
// now actually run ImageMagick
var args []string
outFileArg := outFile
if useDocker {
args = append(args, "run",
"--rm",
"-v", outDir+":/out/",
thumbnailImage,
"/usr/local/bin/magick",
)
inFile = "/out/input.heic"
outFileArg = "/out/output.jpg"
}
args = append(args, "convert")
if maxSize != nil {
args = append(args, "-thumbnail", fmt.Sprintf("%dx%d", maxSize.MaxWidth, maxSize.MaxHeight))
}
args = append(args, inFile, "-colorspace", "RGB", "-auto-orient", outFileArg)
cmd := exec.Command(bin, args...)
t0 := time.Now()
if debug {
log.Printf("internal/images: running imagemagick heic conversion: %q %q", bin, args)
}
var buf bytes.Buffer
cmd.Stderr = &buf
if err = cmd.Run(); err != nil {
if debug {
log.Printf("internal/images: error running imagemagick heic conversion: %s", buf.Bytes())
}
return nil, fmt.Errorf("error running imagemagick: %v, %s", err, buf.Bytes())
}
if debug {
log.Printf("internal/images: ran imagemagick heic conversion in %v", time.Since(t0))
}
return ioutil.ReadFile(outFile)
} | go | func HEIFToJPEG(fr io.Reader, maxSize *Dimensions) ([]byte, error) {
convertGate.Start()
defer convertGate.Done()
useDocker := false
bin := localImageMagick()
if bin == "" {
if err := setUpThumbnailContainer(); err != nil {
return nil, NoHEICTOJPEGError{fmt.Errorf("recent ImageMagick magick binary not found in PATH, and could not fallback on docker image because %v. Install a modern ImageMagick or install docker.", err)}
}
bin = "docker"
useDocker = true
}
outDir, err := ioutil.TempDir("", "perkeep-heif")
if err != nil {
return nil, err
}
defer os.RemoveAll(outDir)
inFile := filepath.Join(outDir, "input.heic")
outFile := filepath.Join(outDir, "output.jpg")
// first create the input file in tmp as heiftojpeg cannot take a piped stdin
f, err := os.Create(inFile)
if err != nil {
return nil, err
}
if _, err := io.Copy(f, fr); err != nil {
f.Close()
return nil, err
}
if err := f.Close(); err != nil {
return nil, err
}
// now actually run ImageMagick
var args []string
outFileArg := outFile
if useDocker {
args = append(args, "run",
"--rm",
"-v", outDir+":/out/",
thumbnailImage,
"/usr/local/bin/magick",
)
inFile = "/out/input.heic"
outFileArg = "/out/output.jpg"
}
args = append(args, "convert")
if maxSize != nil {
args = append(args, "-thumbnail", fmt.Sprintf("%dx%d", maxSize.MaxWidth, maxSize.MaxHeight))
}
args = append(args, inFile, "-colorspace", "RGB", "-auto-orient", outFileArg)
cmd := exec.Command(bin, args...)
t0 := time.Now()
if debug {
log.Printf("internal/images: running imagemagick heic conversion: %q %q", bin, args)
}
var buf bytes.Buffer
cmd.Stderr = &buf
if err = cmd.Run(); err != nil {
if debug {
log.Printf("internal/images: error running imagemagick heic conversion: %s", buf.Bytes())
}
return nil, fmt.Errorf("error running imagemagick: %v, %s", err, buf.Bytes())
}
if debug {
log.Printf("internal/images: ran imagemagick heic conversion in %v", time.Since(t0))
}
return ioutil.ReadFile(outFile)
} | [
"func",
"HEIFToJPEG",
"(",
"fr",
"io",
".",
"Reader",
",",
"maxSize",
"*",
"Dimensions",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"convertGate",
".",
"Start",
"(",
")",
"\n",
"defer",
"convertGate",
".",
"Done",
"(",
")",
"\n",
"useDocker",
":=",
"false",
"\n",
"bin",
":=",
"localImageMagick",
"(",
")",
"\n",
"if",
"bin",
"==",
"\"",
"\"",
"{",
"if",
"err",
":=",
"setUpThumbnailContainer",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"NoHEICTOJPEGError",
"{",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"}",
"\n",
"}",
"\n",
"bin",
"=",
"\"",
"\"",
"\n",
"useDocker",
"=",
"true",
"\n",
"}",
"\n\n",
"outDir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"os",
".",
"RemoveAll",
"(",
"outDir",
")",
"\n",
"inFile",
":=",
"filepath",
".",
"Join",
"(",
"outDir",
",",
"\"",
"\"",
")",
"\n",
"outFile",
":=",
"filepath",
".",
"Join",
"(",
"outDir",
",",
"\"",
"\"",
")",
"\n\n",
"// first create the input file in tmp as heiftojpeg cannot take a piped stdin",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"inFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"f",
",",
"fr",
")",
";",
"err",
"!=",
"nil",
"{",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// now actually run ImageMagick",
"var",
"args",
"[",
"]",
"string",
"\n",
"outFileArg",
":=",
"outFile",
"\n",
"if",
"useDocker",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"outDir",
"+",
"\"",
"\"",
",",
"thumbnailImage",
",",
"\"",
"\"",
",",
")",
"\n",
"inFile",
"=",
"\"",
"\"",
"\n",
"outFileArg",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"if",
"maxSize",
"!=",
"nil",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"maxSize",
".",
"MaxWidth",
",",
"maxSize",
".",
"MaxHeight",
")",
")",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"inFile",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"outFileArg",
")",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"bin",
",",
"args",
"...",
")",
"\n",
"t0",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"if",
"debug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"bin",
",",
"args",
")",
"\n",
"}",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"cmd",
".",
"Stderr",
"=",
"&",
"buf",
"\n",
"if",
"err",
"=",
"cmd",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"debug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
",",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"debug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"time",
".",
"Since",
"(",
"t0",
")",
")",
"\n",
"}",
"\n",
"return",
"ioutil",
".",
"ReadFile",
"(",
"outFile",
")",
"\n",
"}"
] | // HEIFToJPEG converts the HEIF file in fr to JPEG. It optionally resizes it
// to the given maxSize argument, if any. It returns the contents of the JPEG file. | [
"HEIFToJPEG",
"converts",
"the",
"HEIF",
"file",
"in",
"fr",
"to",
"JPEG",
".",
"It",
"optionally",
"resizes",
"it",
"to",
"the",
"given",
"maxSize",
"argument",
"if",
"any",
".",
"It",
"returns",
"the",
"contents",
"of",
"the",
"JPEG",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L665-L735 | train |
perkeep/perkeep | pkg/server/sync.go | enumerateQueuedBlobs | func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseUint(it.Value(), 10, 32)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q => %q", it.Key(), it.Value())
continue
}
select {
case dst <- blob.SizedRef{Ref: br, Size: uint32(size)}:
case <-intr:
return it.Close()
}
}
return it.Close()
} | go | func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseUint(it.Value(), 10, 32)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q => %q", it.Key(), it.Value())
continue
}
select {
case dst <- blob.SizedRef{Ref: br, Size: uint32(size)}:
case <-intr:
return it.Close()
}
}
return it.Close()
} | [
"func",
"(",
"sh",
"*",
"SyncHandler",
")",
"enumerateQueuedBlobs",
"(",
"dst",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"intr",
"<-",
"chan",
"struct",
"{",
"}",
")",
"error",
"{",
"defer",
"close",
"(",
"dst",
")",
"\n",
"it",
":=",
"sh",
".",
"queue",
".",
"Find",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"for",
"it",
".",
"Next",
"(",
")",
"{",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"it",
".",
"Key",
"(",
")",
")",
"\n",
"size",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"it",
".",
"Value",
"(",
")",
",",
"10",
",",
"32",
")",
"\n",
"if",
"!",
"ok",
"||",
"err",
"!=",
"nil",
"{",
"sh",
".",
"logf",
"(",
"\"",
"\"",
",",
"it",
".",
"Key",
"(",
")",
",",
"it",
".",
"Value",
"(",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"select",
"{",
"case",
"dst",
"<-",
"blob",
".",
"SizedRef",
"{",
"Ref",
":",
"br",
",",
"Size",
":",
"uint32",
"(",
"size",
")",
"}",
":",
"case",
"<-",
"intr",
":",
"return",
"it",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"it",
".",
"Close",
"(",
")",
"\n",
"}"
] | // enumerateQueuedBlobs yields blobs from the on-disk sorted.KeyValue store.
// This differs from enumeratePendingBlobs, which sends from the in-memory pending list. | [
"enumerateQueuedBlobs",
"yields",
"blobs",
"from",
"the",
"on",
"-",
"disk",
"sorted",
".",
"KeyValue",
"store",
".",
"This",
"differs",
"from",
"enumeratePendingBlobs",
"which",
"sends",
"from",
"the",
"in",
"-",
"memory",
"pending",
"list",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/sync.go#L544-L561 | train |
perkeep/perkeep | pkg/server/sync.go | startValidatePrefix | func (sh *SyncHandler) startValidatePrefix(ctx context.Context, pfx string, doDest bool) (<-chan blob.SizedRef, <-chan error) {
var e blobserver.BlobEnumerator
if doDest {
e = sh.to
} else {
e = sh.from
}
c := make(chan blob.SizedRef, 64)
errc := make(chan error, 1)
go func() {
defer close(c)
var last string // last blobref seen; to double check storage's enumeration works correctly.
err := blobserver.EnumerateAllFrom(ctx, e, pfx, func(sb blob.SizedRef) error {
// Just double-check that the storage target is returning sorted results correctly.
brStr := sb.Ref.String()
if brStr < pfx {
log.Fatalf("Storage target %T enumerate not behaving: %q < requested prefix %q", e, brStr, pfx)
}
if last != "" && last >= brStr {
log.Fatalf("Storage target %T enumerate not behaving: previous %q >= current %q", e, last, brStr)
}
last = brStr
// TODO: could add a more efficient method on blob.Ref to do this,
// that doesn't involve call String().
if !strings.HasPrefix(brStr, pfx) {
return errNotPrefix
}
select {
case c <- sb:
sh.mu.Lock()
if doDest {
sh.vdestCount++
sh.vdestBytes += int64(sb.Size)
} else {
sh.vsrcCount++
sh.vsrcBytes += int64(sb.Size)
}
sh.mu.Unlock()
return nil
case <-ctx.Done():
return ctx.Err()
}
})
if err == errNotPrefix {
err = nil
}
if err != nil {
// Send a zero value to shut down ListMissingDestinationBlobs.
c <- blob.SizedRef{}
}
errc <- err
}()
return c, errc
} | go | func (sh *SyncHandler) startValidatePrefix(ctx context.Context, pfx string, doDest bool) (<-chan blob.SizedRef, <-chan error) {
var e blobserver.BlobEnumerator
if doDest {
e = sh.to
} else {
e = sh.from
}
c := make(chan blob.SizedRef, 64)
errc := make(chan error, 1)
go func() {
defer close(c)
var last string // last blobref seen; to double check storage's enumeration works correctly.
err := blobserver.EnumerateAllFrom(ctx, e, pfx, func(sb blob.SizedRef) error {
// Just double-check that the storage target is returning sorted results correctly.
brStr := sb.Ref.String()
if brStr < pfx {
log.Fatalf("Storage target %T enumerate not behaving: %q < requested prefix %q", e, brStr, pfx)
}
if last != "" && last >= brStr {
log.Fatalf("Storage target %T enumerate not behaving: previous %q >= current %q", e, last, brStr)
}
last = brStr
// TODO: could add a more efficient method on blob.Ref to do this,
// that doesn't involve call String().
if !strings.HasPrefix(brStr, pfx) {
return errNotPrefix
}
select {
case c <- sb:
sh.mu.Lock()
if doDest {
sh.vdestCount++
sh.vdestBytes += int64(sb.Size)
} else {
sh.vsrcCount++
sh.vsrcBytes += int64(sb.Size)
}
sh.mu.Unlock()
return nil
case <-ctx.Done():
return ctx.Err()
}
})
if err == errNotPrefix {
err = nil
}
if err != nil {
// Send a zero value to shut down ListMissingDestinationBlobs.
c <- blob.SizedRef{}
}
errc <- err
}()
return c, errc
} | [
"func",
"(",
"sh",
"*",
"SyncHandler",
")",
"startValidatePrefix",
"(",
"ctx",
"context",
".",
"Context",
",",
"pfx",
"string",
",",
"doDest",
"bool",
")",
"(",
"<-",
"chan",
"blob",
".",
"SizedRef",
",",
"<-",
"chan",
"error",
")",
"{",
"var",
"e",
"blobserver",
".",
"BlobEnumerator",
"\n",
"if",
"doDest",
"{",
"e",
"=",
"sh",
".",
"to",
"\n",
"}",
"else",
"{",
"e",
"=",
"sh",
".",
"from",
"\n",
"}",
"\n",
"c",
":=",
"make",
"(",
"chan",
"blob",
".",
"SizedRef",
",",
"64",
")",
"\n",
"errc",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"c",
")",
"\n",
"var",
"last",
"string",
"// last blobref seen; to double check storage's enumeration works correctly.",
"\n",
"err",
":=",
"blobserver",
".",
"EnumerateAllFrom",
"(",
"ctx",
",",
"e",
",",
"pfx",
",",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"// Just double-check that the storage target is returning sorted results correctly.",
"brStr",
":=",
"sb",
".",
"Ref",
".",
"String",
"(",
")",
"\n",
"if",
"brStr",
"<",
"pfx",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"e",
",",
"brStr",
",",
"pfx",
")",
"\n",
"}",
"\n",
"if",
"last",
"!=",
"\"",
"\"",
"&&",
"last",
">=",
"brStr",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"e",
",",
"last",
",",
"brStr",
")",
"\n",
"}",
"\n",
"last",
"=",
"brStr",
"\n\n",
"// TODO: could add a more efficient method on blob.Ref to do this,",
"// that doesn't involve call String().",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"brStr",
",",
"pfx",
")",
"{",
"return",
"errNotPrefix",
"\n",
"}",
"\n",
"select",
"{",
"case",
"c",
"<-",
"sb",
":",
"sh",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"doDest",
"{",
"sh",
".",
"vdestCount",
"++",
"\n",
"sh",
".",
"vdestBytes",
"+=",
"int64",
"(",
"sb",
".",
"Size",
")",
"\n",
"}",
"else",
"{",
"sh",
".",
"vsrcCount",
"++",
"\n",
"sh",
".",
"vsrcBytes",
"+=",
"int64",
"(",
"sb",
".",
"Size",
")",
"\n",
"}",
"\n",
"sh",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"==",
"errNotPrefix",
"{",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Send a zero value to shut down ListMissingDestinationBlobs.",
"c",
"<-",
"blob",
".",
"SizedRef",
"{",
"}",
"\n",
"}",
"\n",
"errc",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"return",
"c",
",",
"errc",
"\n",
"}"
] | // doDest is false for source and true for dest. | [
"doDest",
"is",
"false",
"for",
"source",
"and",
"true",
"for",
"dest",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/sync.go#L837-L891 | train |
perkeep/perkeep | pkg/server/sync.go | hourlyCompare | func (sh *SyncHandler) hourlyCompare(hourlyBytes uint64) {
ctx := context.TODO()
ticker := time.NewTicker(time.Hour).C
for {
content := make([]byte, 16)
if _, err := rand.Read(content); err != nil {
panic(err)
}
after := blob.RefFromBytes(content).String()
var roundBytes uint64
var roundBlobs int
err := blobserver.EnumerateAllFrom(ctx, sh.from, after, func(sr blob.SizedRef) error {
sh.mu.Lock()
if _, ok := sh.needCopy[sr.Ref]; ok {
sh.mu.Unlock()
return nil // skip blobs in the copy queue
}
sh.mu.Unlock()
if roundBytes+uint64(sr.Size) > hourlyBytes {
return errStopEnumerating
}
blob, size, err := sh.to.(blob.Fetcher).Fetch(ctx, sr.Ref)
if err != nil {
return fmt.Errorf("error fetching %s: %v", sr.Ref, err)
}
if size != sr.Size {
return fmt.Errorf("%s: expected size %d, got %d", sr.Ref, sr.Size, size)
}
h := sr.Ref.Hash()
if _, err := io.Copy(h, blob); err != nil {
return fmt.Errorf("error while reading %s: %v", sr.Ref, err)
}
if !sr.HashMatches(h) {
return fmt.Errorf("expected %s, got %x", sr.Ref, h.Sum(nil))
}
sh.mu.Lock()
sh.comparedBlobs++
sh.comparedBytes += uint64(size)
sh.compLastBlob = sr.Ref.String()
sh.mu.Unlock()
roundBlobs++
roundBytes += uint64(size)
return nil
})
sh.mu.Lock()
if err != nil && err != errStopEnumerating {
sh.compareErrors = append(sh.compareErrors, fmt.Sprintf("%s %v", time.Now(), err))
sh.logf("!! hourly compare error !!: %v", err)
}
sh.comparedRounds++
sh.mu.Unlock()
sh.logf("compared %d blobs (%d bytes)", roundBlobs, roundBytes)
<-ticker
}
} | go | func (sh *SyncHandler) hourlyCompare(hourlyBytes uint64) {
ctx := context.TODO()
ticker := time.NewTicker(time.Hour).C
for {
content := make([]byte, 16)
if _, err := rand.Read(content); err != nil {
panic(err)
}
after := blob.RefFromBytes(content).String()
var roundBytes uint64
var roundBlobs int
err := blobserver.EnumerateAllFrom(ctx, sh.from, after, func(sr blob.SizedRef) error {
sh.mu.Lock()
if _, ok := sh.needCopy[sr.Ref]; ok {
sh.mu.Unlock()
return nil // skip blobs in the copy queue
}
sh.mu.Unlock()
if roundBytes+uint64(sr.Size) > hourlyBytes {
return errStopEnumerating
}
blob, size, err := sh.to.(blob.Fetcher).Fetch(ctx, sr.Ref)
if err != nil {
return fmt.Errorf("error fetching %s: %v", sr.Ref, err)
}
if size != sr.Size {
return fmt.Errorf("%s: expected size %d, got %d", sr.Ref, sr.Size, size)
}
h := sr.Ref.Hash()
if _, err := io.Copy(h, blob); err != nil {
return fmt.Errorf("error while reading %s: %v", sr.Ref, err)
}
if !sr.HashMatches(h) {
return fmt.Errorf("expected %s, got %x", sr.Ref, h.Sum(nil))
}
sh.mu.Lock()
sh.comparedBlobs++
sh.comparedBytes += uint64(size)
sh.compLastBlob = sr.Ref.String()
sh.mu.Unlock()
roundBlobs++
roundBytes += uint64(size)
return nil
})
sh.mu.Lock()
if err != nil && err != errStopEnumerating {
sh.compareErrors = append(sh.compareErrors, fmt.Sprintf("%s %v", time.Now(), err))
sh.logf("!! hourly compare error !!: %v", err)
}
sh.comparedRounds++
sh.mu.Unlock()
sh.logf("compared %d blobs (%d bytes)", roundBlobs, roundBytes)
<-ticker
}
} | [
"func",
"(",
"sh",
"*",
"SyncHandler",
")",
"hourlyCompare",
"(",
"hourlyBytes",
"uint64",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"time",
".",
"Hour",
")",
".",
"C",
"\n",
"for",
"{",
"content",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"16",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"content",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"after",
":=",
"blob",
".",
"RefFromBytes",
"(",
"content",
")",
".",
"String",
"(",
")",
"\n",
"var",
"roundBytes",
"uint64",
"\n",
"var",
"roundBlobs",
"int",
"\n",
"err",
":=",
"blobserver",
".",
"EnumerateAllFrom",
"(",
"ctx",
",",
"sh",
".",
"from",
",",
"after",
",",
"func",
"(",
"sr",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"sh",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"sh",
".",
"needCopy",
"[",
"sr",
".",
"Ref",
"]",
";",
"ok",
"{",
"sh",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"// skip blobs in the copy queue",
"\n",
"}",
"\n",
"sh",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"roundBytes",
"+",
"uint64",
"(",
"sr",
".",
"Size",
")",
">",
"hourlyBytes",
"{",
"return",
"errStopEnumerating",
"\n",
"}",
"\n",
"blob",
",",
"size",
",",
"err",
":=",
"sh",
".",
"to",
".",
"(",
"blob",
".",
"Fetcher",
")",
".",
"Fetch",
"(",
"ctx",
",",
"sr",
".",
"Ref",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sr",
".",
"Ref",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"size",
"!=",
"sr",
".",
"Size",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sr",
".",
"Ref",
",",
"sr",
".",
"Size",
",",
"size",
")",
"\n",
"}",
"\n",
"h",
":=",
"sr",
".",
"Ref",
".",
"Hash",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"h",
",",
"blob",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sr",
".",
"Ref",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"sr",
".",
"HashMatches",
"(",
"h",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sr",
".",
"Ref",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"}",
"\n\n",
"sh",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"sh",
".",
"comparedBlobs",
"++",
"\n",
"sh",
".",
"comparedBytes",
"+=",
"uint64",
"(",
"size",
")",
"\n",
"sh",
".",
"compLastBlob",
"=",
"sr",
".",
"Ref",
".",
"String",
"(",
")",
"\n",
"sh",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"roundBlobs",
"++",
"\n",
"roundBytes",
"+=",
"uint64",
"(",
"size",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"sh",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"errStopEnumerating",
"{",
"sh",
".",
"compareErrors",
"=",
"append",
"(",
"sh",
".",
"compareErrors",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
",",
"err",
")",
")",
"\n",
"sh",
".",
"logf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"sh",
".",
"comparedRounds",
"++",
"\n",
"sh",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"sh",
".",
"logf",
"(",
"\"",
"\"",
",",
"roundBlobs",
",",
"roundBytes",
")",
"\n",
"<-",
"ticker",
"\n",
"}",
"\n",
"}"
] | // Every hour, hourlyCompare picks blob names from a random point in the source,
// downloads up to hourlyBytes from the destination, and verifies them. | [
"Every",
"hour",
"hourlyCompare",
"picks",
"blob",
"names",
"from",
"a",
"random",
"point",
"in",
"the",
"source",
"downloads",
"up",
"to",
"hourlyBytes",
"from",
"the",
"destination",
"and",
"verifies",
"them",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/sync.go#L1078-L1134 | train |
perkeep/perkeep | pkg/importer/swarm/swarm.go | urlFileRef | func (r *run) urlFileRef(urlstr, filename string) string {
im := r.im
im.mu.Lock()
if br, ok := im.imageFileRef[urlstr]; ok {
im.mu.Unlock()
return br.String()
}
im.mu.Unlock()
if urlstr == "" {
return ""
}
res, err := ctxutil.Client(r.Context()).Get(urlstr)
if err != nil {
log.Printf("swarm: couldn't fetch image %q: %v", urlstr, err)
return ""
}
defer res.Body.Close()
fileRef, err := schema.WriteFileFromReader(r.Context(), r.Host.Target(), filename, res.Body)
if err != nil {
r.errorf("couldn't write file: %v", err)
return ""
}
im.mu.Lock()
defer im.mu.Unlock()
im.imageFileRef[urlstr] = fileRef
return fileRef.String()
} | go | func (r *run) urlFileRef(urlstr, filename string) string {
im := r.im
im.mu.Lock()
if br, ok := im.imageFileRef[urlstr]; ok {
im.mu.Unlock()
return br.String()
}
im.mu.Unlock()
if urlstr == "" {
return ""
}
res, err := ctxutil.Client(r.Context()).Get(urlstr)
if err != nil {
log.Printf("swarm: couldn't fetch image %q: %v", urlstr, err)
return ""
}
defer res.Body.Close()
fileRef, err := schema.WriteFileFromReader(r.Context(), r.Host.Target(), filename, res.Body)
if err != nil {
r.errorf("couldn't write file: %v", err)
return ""
}
im.mu.Lock()
defer im.mu.Unlock()
im.imageFileRef[urlstr] = fileRef
return fileRef.String()
} | [
"func",
"(",
"r",
"*",
"run",
")",
"urlFileRef",
"(",
"urlstr",
",",
"filename",
"string",
")",
"string",
"{",
"im",
":=",
"r",
".",
"im",
"\n",
"im",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"br",
",",
"ok",
":=",
"im",
".",
"imageFileRef",
"[",
"urlstr",
"]",
";",
"ok",
"{",
"im",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"br",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"im",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"urlstr",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"res",
",",
"err",
":=",
"ctxutil",
".",
"Client",
"(",
"r",
".",
"Context",
"(",
")",
")",
".",
"Get",
"(",
"urlstr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"urlstr",
",",
"err",
")",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"fileRef",
",",
"err",
":=",
"schema",
".",
"WriteFileFromReader",
"(",
"r",
".",
"Context",
"(",
")",
",",
"r",
".",
"Host",
".",
"Target",
"(",
")",
",",
"filename",
",",
"res",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r",
".",
"errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"im",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"im",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"im",
".",
"imageFileRef",
"[",
"urlstr",
"]",
"=",
"fileRef",
"\n",
"return",
"fileRef",
".",
"String",
"(",
")",
"\n",
"}"
] | // urlFileRef slurps urlstr from the net, writes to a file and returns its
// fileref or "" on error or if urlstr was empty. | [
"urlFileRef",
"slurps",
"urlstr",
"from",
"the",
"net",
"writes",
"to",
"a",
"file",
"and",
"returns",
"its",
"fileref",
"or",
"on",
"error",
"or",
"if",
"urlstr",
"was",
"empty",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/swarm/swarm.go#L183-L212 | train |
perkeep/perkeep | pkg/importer/swarm/swarm.go | auth | func auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth2.Config{
ClientID: clientID,
ClientSecret: secret,
Endpoint: oauth2.Endpoint{
AuthURL: authURL,
TokenURL: tokenURL,
},
RedirectURL: ctx.CallbackURL(),
// No scope needed for foursquare as far as I can tell
}, nil
} | go | func auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth2.Config{
ClientID: clientID,
ClientSecret: secret,
Endpoint: oauth2.Endpoint{
AuthURL: authURL,
TokenURL: tokenURL,
},
RedirectURL: ctx.CallbackURL(),
// No scope needed for foursquare as far as I can tell
}, nil
} | [
"func",
"auth",
"(",
"ctx",
"*",
"importer",
".",
"SetupContext",
")",
"(",
"*",
"oauth2",
".",
"Config",
",",
"error",
")",
"{",
"clientID",
",",
"secret",
",",
"err",
":=",
"ctx",
".",
"Credentials",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"oauth2",
".",
"Config",
"{",
"ClientID",
":",
"clientID",
",",
"ClientSecret",
":",
"secret",
",",
"Endpoint",
":",
"oauth2",
".",
"Endpoint",
"{",
"AuthURL",
":",
"authURL",
",",
"TokenURL",
":",
"tokenURL",
",",
"}",
",",
"RedirectURL",
":",
"ctx",
".",
"CallbackURL",
"(",
")",
",",
"// No scope needed for foursquare as far as I can tell",
"}",
",",
"nil",
"\n",
"}"
] | // auth returns a new oauth2 Config | [
"auth",
"returns",
"a",
"new",
"oauth2",
"Config"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/swarm/swarm.go#L537-L552 | train |
perkeep/perkeep | pkg/schema/schema.go | mixedArrayFromString | func mixedArrayFromString(s string) (parts []interface{}) {
for len(s) > 0 {
if n := utf8StrLen(s); n > 0 {
parts = append(parts, s[:n])
s = s[n:]
} else {
parts = append(parts, s[0])
s = s[1:]
}
}
return parts
} | go | func mixedArrayFromString(s string) (parts []interface{}) {
for len(s) > 0 {
if n := utf8StrLen(s); n > 0 {
parts = append(parts, s[:n])
s = s[n:]
} else {
parts = append(parts, s[0])
s = s[1:]
}
}
return parts
} | [
"func",
"mixedArrayFromString",
"(",
"s",
"string",
")",
"(",
"parts",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"for",
"len",
"(",
"s",
")",
">",
"0",
"{",
"if",
"n",
":=",
"utf8StrLen",
"(",
"s",
")",
";",
"n",
">",
"0",
"{",
"parts",
"=",
"append",
"(",
"parts",
",",
"s",
"[",
":",
"n",
"]",
")",
"\n",
"s",
"=",
"s",
"[",
"n",
":",
"]",
"\n",
"}",
"else",
"{",
"parts",
"=",
"append",
"(",
"parts",
",",
"s",
"[",
"0",
"]",
")",
"\n",
"s",
"=",
"s",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"parts",
"\n",
"}"
] | // mixedArrayFromString is the inverse of stringFromMixedArray. It
// splits a string to a series of either UTF-8 strings and non-UTF-8
// bytes. | [
"mixedArrayFromString",
"is",
"the",
"inverse",
"of",
"stringFromMixedArray",
".",
"It",
"splits",
"a",
"string",
"to",
"a",
"series",
"of",
"either",
"UTF",
"-",
"8",
"strings",
"and",
"non",
"-",
"UTF",
"-",
"8",
"bytes",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L400-L411 | train |
perkeep/perkeep | pkg/schema/schema.go | utf8StrLen | func utf8StrLen(s string) int {
for i, r := range s {
for r == utf8.RuneError {
// The RuneError value can be an error
// sentinel value (if it's size 1) or the same
// value encoded properly. Decode it to see if
// it's the 1 byte sentinel value.
_, size := utf8.DecodeRuneInString(s[i:])
if size == 1 {
return i
}
}
}
return len(s)
} | go | func utf8StrLen(s string) int {
for i, r := range s {
for r == utf8.RuneError {
// The RuneError value can be an error
// sentinel value (if it's size 1) or the same
// value encoded properly. Decode it to see if
// it's the 1 byte sentinel value.
_, size := utf8.DecodeRuneInString(s[i:])
if size == 1 {
return i
}
}
}
return len(s)
} | [
"func",
"utf8StrLen",
"(",
"s",
"string",
")",
"int",
"{",
"for",
"i",
",",
"r",
":=",
"range",
"s",
"{",
"for",
"r",
"==",
"utf8",
".",
"RuneError",
"{",
"// The RuneError value can be an error",
"// sentinel value (if it's size 1) or the same",
"// value encoded properly. Decode it to see if",
"// it's the 1 byte sentinel value.",
"_",
",",
"size",
":=",
"utf8",
".",
"DecodeRuneInString",
"(",
"s",
"[",
"i",
":",
"]",
")",
"\n",
"if",
"size",
"==",
"1",
"{",
"return",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"len",
"(",
"s",
")",
"\n",
"}"
] | // utf8StrLen returns how many prefix bytes of s are valid UTF-8. | [
"utf8StrLen",
"returns",
"how",
"many",
"prefix",
"bytes",
"of",
"s",
"are",
"valid",
"UTF",
"-",
"8",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L414-L428 | train |
perkeep/perkeep | pkg/schema/schema.go | FileNameString | func (ss *superset) FileNameString() string {
v := ss.FileName
if v == "" {
v = stringFromMixedArray(ss.FileNameBytes)
}
if v != "" {
if strings.Contains(v, "/") {
// Bogus schema blob; ignore.
return ""
}
if strings.Contains(v, "\\") {
// Bogus schema blob; ignore.
return ""
}
}
return v
} | go | func (ss *superset) FileNameString() string {
v := ss.FileName
if v == "" {
v = stringFromMixedArray(ss.FileNameBytes)
}
if v != "" {
if strings.Contains(v, "/") {
// Bogus schema blob; ignore.
return ""
}
if strings.Contains(v, "\\") {
// Bogus schema blob; ignore.
return ""
}
}
return v
} | [
"func",
"(",
"ss",
"*",
"superset",
")",
"FileNameString",
"(",
")",
"string",
"{",
"v",
":=",
"ss",
".",
"FileName",
"\n",
"if",
"v",
"==",
"\"",
"\"",
"{",
"v",
"=",
"stringFromMixedArray",
"(",
"ss",
".",
"FileNameBytes",
")",
"\n",
"}",
"\n",
"if",
"v",
"!=",
"\"",
"\"",
"{",
"if",
"strings",
".",
"Contains",
"(",
"v",
",",
"\"",
"\"",
")",
"{",
"// Bogus schema blob; ignore.",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"v",
",",
"\"",
"\\\\",
"\"",
")",
"{",
"// Bogus schema blob; ignore.",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] | // FileNameString returns the schema blob's base filename.
//
// If the fileName field of the blob accidentally or maliciously
// contains a slash, this function returns an empty string instead. | [
"FileNameString",
"returns",
"the",
"schema",
"blob",
"s",
"base",
"filename",
".",
"If",
"the",
"fileName",
"field",
"of",
"the",
"blob",
"accidentally",
"or",
"maliciously",
"contains",
"a",
"slash",
"this",
"function",
"returns",
"an",
"empty",
"string",
"instead",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L448-L464 | train |
perkeep/perkeep | pkg/schema/schema.go | NewUnsignedPermanode | func NewUnsignedPermanode() *Builder {
bb := base(1, "permanode")
chars := make([]byte, 20)
_, err := io.ReadFull(rand.Reader, chars)
if err != nil {
panic("error reading random bytes: " + err.Error())
}
bb.m["random"] = base64.StdEncoding.EncodeToString(chars)
return bb
} | go | func NewUnsignedPermanode() *Builder {
bb := base(1, "permanode")
chars := make([]byte, 20)
_, err := io.ReadFull(rand.Reader, chars)
if err != nil {
panic("error reading random bytes: " + err.Error())
}
bb.m["random"] = base64.StdEncoding.EncodeToString(chars)
return bb
} | [
"func",
"NewUnsignedPermanode",
"(",
")",
"*",
"Builder",
"{",
"bb",
":=",
"base",
"(",
"1",
",",
"\"",
"\"",
")",
"\n",
"chars",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"20",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"rand",
".",
"Reader",
",",
"chars",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"bb",
".",
"m",
"[",
"\"",
"\"",
"]",
"=",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"chars",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // NewUnsignedPermanode returns a new random permanode, not yet signed. | [
"NewUnsignedPermanode",
"returns",
"a",
"new",
"random",
"permanode",
"not",
"yet",
"signed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L660-L669 | train |
perkeep/perkeep | pkg/schema/schema.go | NewHashPlannedPermanode | func NewHashPlannedPermanode(h hash.Hash) *Builder {
return NewPlannedPermanode(blob.RefFromHash(h).String())
} | go | func NewHashPlannedPermanode(h hash.Hash) *Builder {
return NewPlannedPermanode(blob.RefFromHash(h).String())
} | [
"func",
"NewHashPlannedPermanode",
"(",
"h",
"hash",
".",
"Hash",
")",
"*",
"Builder",
"{",
"return",
"NewPlannedPermanode",
"(",
"blob",
".",
"RefFromHash",
"(",
"h",
")",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // NewHashPlannedPermanode returns a planned permanode with the sum
// of the hash, prefixed with "sha1-", as the key. | [
"NewHashPlannedPermanode",
"returns",
"a",
"planned",
"permanode",
"with",
"the",
"sum",
"of",
"the",
"hash",
"prefixed",
"with",
"sha1",
"-",
"as",
"the",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L684-L686 | train |
perkeep/perkeep | pkg/schema/schema.go | PopulateParts | func (bb *Builder) PopulateParts(size int64, parts []BytesPart) error {
return populateParts(bb.m, size, parts)
} | go | func (bb *Builder) PopulateParts(size int64, parts []BytesPart) error {
return populateParts(bb.m, size, parts)
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"PopulateParts",
"(",
"size",
"int64",
",",
"parts",
"[",
"]",
"BytesPart",
")",
"error",
"{",
"return",
"populateParts",
"(",
"bb",
".",
"m",
",",
"size",
",",
"parts",
")",
"\n",
"}"
] | // PopulateParts sets the "parts" field of the blob with the provided
// parts. The sum of the sizes of parts must match the provided size
// or an error is returned. Also, each BytesPart may only contain either
// a BytesPart or a BlobRef, but not both. | [
"PopulateParts",
"sets",
"the",
"parts",
"field",
"of",
"the",
"blob",
"with",
"the",
"provided",
"parts",
".",
"The",
"sum",
"of",
"the",
"sizes",
"of",
"parts",
"must",
"match",
"the",
"provided",
"size",
"or",
"an",
"error",
"is",
"returned",
".",
"Also",
"each",
"BytesPart",
"may",
"only",
"contain",
"either",
"a",
"BytesPart",
"or",
"a",
"BlobRef",
"but",
"not",
"both",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L754-L756 | train |
perkeep/perkeep | pkg/schema/schema.go | NewDelAttributeClaim | func NewDelAttributeClaim(permaNode blob.Ref, attr, value string) *Builder {
return newClaim(&claimParam{
permanode: permaNode,
claimType: DelAttributeClaim,
attribute: attr,
value: value,
})
} | go | func NewDelAttributeClaim(permaNode blob.Ref, attr, value string) *Builder {
return newClaim(&claimParam{
permanode: permaNode,
claimType: DelAttributeClaim,
attribute: attr,
value: value,
})
} | [
"func",
"NewDelAttributeClaim",
"(",
"permaNode",
"blob",
".",
"Ref",
",",
"attr",
",",
"value",
"string",
")",
"*",
"Builder",
"{",
"return",
"newClaim",
"(",
"&",
"claimParam",
"{",
"permanode",
":",
"permaNode",
",",
"claimType",
":",
"DelAttributeClaim",
",",
"attribute",
":",
"attr",
",",
"value",
":",
"value",
",",
"}",
")",
"\n",
"}"
] | // NewDelAttributeClaim creates a new claim to remove value from the
// values set for the attribute attr of permaNode. If value is empty then
// all the values for attribute are cleared. | [
"NewDelAttributeClaim",
"creates",
"a",
"new",
"claim",
"to",
"remove",
"value",
"from",
"the",
"values",
"set",
"for",
"the",
"attribute",
"attr",
"of",
"permaNode",
".",
"If",
"value",
"is",
"empty",
"then",
"all",
"the",
"values",
"for",
"attribute",
"are",
"cleared",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L887-L894 | train |
perkeep/perkeep | pkg/schema/schema.go | NewDeleteClaim | func NewDeleteClaim(target blob.Ref) *Builder {
return newClaim(&claimParam{
target: target,
claimType: DeleteClaim,
})
} | go | func NewDeleteClaim(target blob.Ref) *Builder {
return newClaim(&claimParam{
target: target,
claimType: DeleteClaim,
})
} | [
"func",
"NewDeleteClaim",
"(",
"target",
"blob",
".",
"Ref",
")",
"*",
"Builder",
"{",
"return",
"newClaim",
"(",
"&",
"claimParam",
"{",
"target",
":",
"target",
",",
"claimType",
":",
"DeleteClaim",
",",
"}",
")",
"\n",
"}"
] | // NewDeleteClaim creates a new claim to delete a target claim or permanode. | [
"NewDeleteClaim",
"creates",
"a",
"new",
"claim",
"to",
"delete",
"a",
"target",
"claim",
"or",
"permanode",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L897-L902 | train |
perkeep/perkeep | pkg/schema/schema.go | IsZoneKnown | func IsZoneKnown(t time.Time) bool {
if t.Location() == UnknownLocation {
return false
}
if _, off := t.Zone(); off == -60 {
return false
}
return true
} | go | func IsZoneKnown(t time.Time) bool {
if t.Location() == UnknownLocation {
return false
}
if _, off := t.Zone(); off == -60 {
return false
}
return true
} | [
"func",
"IsZoneKnown",
"(",
"t",
"time",
".",
"Time",
")",
"bool",
"{",
"if",
"t",
".",
"Location",
"(",
")",
"==",
"UnknownLocation",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"_",
",",
"off",
":=",
"t",
".",
"Zone",
"(",
")",
";",
"off",
"==",
"-",
"60",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // IsZoneKnown reports whether t is in a known timezone.
// Perkeep uses the magic timezone offset of 1 minute west of UTC
// to mean that the timezone wasn't known. | [
"IsZoneKnown",
"reports",
"whether",
"t",
"is",
"in",
"a",
"known",
"timezone",
".",
"Perkeep",
"uses",
"the",
"magic",
"timezone",
"offset",
"of",
"1",
"minute",
"west",
"of",
"UTC",
"to",
"mean",
"that",
"the",
"timezone",
"wasn",
"t",
"known",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/schema.go#L918-L926 | train |
perkeep/perkeep | pkg/server/help.go | SetServerConfig | func (hh *HelpHandler) SetServerConfig(config jsonconfig.Obj) {
if hh.serverConfig == nil {
hh.serverConfig = config
}
} | go | func (hh *HelpHandler) SetServerConfig(config jsonconfig.Obj) {
if hh.serverConfig == nil {
hh.serverConfig = config
}
} | [
"func",
"(",
"hh",
"*",
"HelpHandler",
")",
"SetServerConfig",
"(",
"config",
"jsonconfig",
".",
"Obj",
")",
"{",
"if",
"hh",
".",
"serverConfig",
"==",
"nil",
"{",
"hh",
".",
"serverConfig",
"=",
"config",
"\n",
"}",
"\n",
"}"
] | // SetServerConfig enables the handler to receive the server config
// before InitHandler, which generates a client config from the server config, is called. | [
"SetServerConfig",
"enables",
"the",
"handler",
"to",
"receive",
"the",
"server",
"config",
"before",
"InitHandler",
"which",
"generates",
"a",
"client",
"config",
"from",
"the",
"server",
"config",
"is",
"called",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/help.go#L73-L77 | train |
perkeep/perkeep | pkg/client/get.go | UpdateShareChain | func (c *Client) UpdateShareChain(b blob.Ref, r io.Reader) error {
c.viaMu.Lock()
defer c.viaMu.Unlock()
if c.via == nil {
// Not in sharing mode, so return immediately.
return ErrNotSharing
}
// Slurp 1 MB to find references to other blobrefs for the via path.
var buf bytes.Buffer
const maxSlurp = 1 << 20
if _, err := io.Copy(&buf, io.LimitReader(r, maxSlurp)); err != nil {
return err
}
// If it looks like a JSON schema blob (starts with '{')
if schema.LikelySchemaBlob(buf.Bytes()) {
for _, blobstr := range blobsRx.FindAllString(buf.String(), -1) {
br, ok := blob.Parse(blobstr)
if !ok {
c.printf("Invalid blob ref %q noticed in schema of %v", blobstr, b)
continue
}
c.via[br] = b
}
}
return nil
} | go | func (c *Client) UpdateShareChain(b blob.Ref, r io.Reader) error {
c.viaMu.Lock()
defer c.viaMu.Unlock()
if c.via == nil {
// Not in sharing mode, so return immediately.
return ErrNotSharing
}
// Slurp 1 MB to find references to other blobrefs for the via path.
var buf bytes.Buffer
const maxSlurp = 1 << 20
if _, err := io.Copy(&buf, io.LimitReader(r, maxSlurp)); err != nil {
return err
}
// If it looks like a JSON schema blob (starts with '{')
if schema.LikelySchemaBlob(buf.Bytes()) {
for _, blobstr := range blobsRx.FindAllString(buf.String(), -1) {
br, ok := blob.Parse(blobstr)
if !ok {
c.printf("Invalid blob ref %q noticed in schema of %v", blobstr, b)
continue
}
c.via[br] = b
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateShareChain",
"(",
"b",
"blob",
".",
"Ref",
",",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"c",
".",
"viaMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"viaMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"c",
".",
"via",
"==",
"nil",
"{",
"// Not in sharing mode, so return immediately.",
"return",
"ErrNotSharing",
"\n",
"}",
"\n",
"// Slurp 1 MB to find references to other blobrefs for the via path.",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"const",
"maxSlurp",
"=",
"1",
"<<",
"20",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"&",
"buf",
",",
"io",
".",
"LimitReader",
"(",
"r",
",",
"maxSlurp",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// If it looks like a JSON schema blob (starts with '{')",
"if",
"schema",
".",
"LikelySchemaBlob",
"(",
"buf",
".",
"Bytes",
"(",
")",
")",
"{",
"for",
"_",
",",
"blobstr",
":=",
"range",
"blobsRx",
".",
"FindAllString",
"(",
"buf",
".",
"String",
"(",
")",
",",
"-",
"1",
")",
"{",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"blobstr",
")",
"\n",
"if",
"!",
"ok",
"{",
"c",
".",
"printf",
"(",
"\"",
"\"",
",",
"blobstr",
",",
"b",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"c",
".",
"via",
"[",
"br",
"]",
"=",
"b",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpdateShareChain reads the schema of b from r, and instructs the client that
// all blob refs found in this schema should use b as a preceding chain link, in
// all subsequent shared blobs fetches. If the client was not created with
// NewFromShareRoot, ErrNotSharing is returned. | [
"UpdateShareChain",
"reads",
"the",
"schema",
"of",
"b",
"from",
"r",
"and",
"instructs",
"the",
"client",
"that",
"all",
"blob",
"refs",
"found",
"in",
"this",
"schema",
"should",
"use",
"b",
"as",
"a",
"preceding",
"chain",
"link",
"in",
"all",
"subsequent",
"shared",
"blobs",
"fetches",
".",
"If",
"the",
"client",
"was",
"not",
"created",
"with",
"NewFromShareRoot",
"ErrNotSharing",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/get.go#L165-L190 | train |
perkeep/perkeep | pkg/blobserver/archiver/archiver.go | RunOnce | func (a *Archiver) RunOnce(ctx context.Context) error {
if a.Source == nil {
return errors.New("archiver: nil Source")
}
if a.Store == nil {
return errors.New("archiver: nil Store func")
}
pz := &potentialZip{a: a}
err := blobserver.EnumerateAll(ctx, a.Source, func(sb blob.SizedRef) error {
if err := pz.addBlob(ctx, sb); err != nil {
return err
}
if pz.bigEnough() {
return errStopEnumerate
}
return nil
})
if err == errStopEnumerate {
err = nil
}
if err != nil {
return err
}
if err := pz.condClose(); err != nil {
return err
}
if !pz.bigEnough() {
return ErrSourceTooSmall
}
if err := a.Store(pz.buf.Bytes(), pz.blobs); err != nil {
return err
}
if a.DeleteSourceAfterStore {
blobs := make([]blob.Ref, 0, len(pz.blobs))
for _, sb := range pz.blobs {
blobs = append(blobs, sb.Ref)
}
if err := a.Source.RemoveBlobs(ctx, blobs); err != nil {
return err
}
}
return nil
} | go | func (a *Archiver) RunOnce(ctx context.Context) error {
if a.Source == nil {
return errors.New("archiver: nil Source")
}
if a.Store == nil {
return errors.New("archiver: nil Store func")
}
pz := &potentialZip{a: a}
err := blobserver.EnumerateAll(ctx, a.Source, func(sb blob.SizedRef) error {
if err := pz.addBlob(ctx, sb); err != nil {
return err
}
if pz.bigEnough() {
return errStopEnumerate
}
return nil
})
if err == errStopEnumerate {
err = nil
}
if err != nil {
return err
}
if err := pz.condClose(); err != nil {
return err
}
if !pz.bigEnough() {
return ErrSourceTooSmall
}
if err := a.Store(pz.buf.Bytes(), pz.blobs); err != nil {
return err
}
if a.DeleteSourceAfterStore {
blobs := make([]blob.Ref, 0, len(pz.blobs))
for _, sb := range pz.blobs {
blobs = append(blobs, sb.Ref)
}
if err := a.Source.RemoveBlobs(ctx, blobs); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"Archiver",
")",
"RunOnce",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"a",
".",
"Source",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"a",
".",
"Store",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"pz",
":=",
"&",
"potentialZip",
"{",
"a",
":",
"a",
"}",
"\n",
"err",
":=",
"blobserver",
".",
"EnumerateAll",
"(",
"ctx",
",",
"a",
".",
"Source",
",",
"func",
"(",
"sb",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"if",
"err",
":=",
"pz",
".",
"addBlob",
"(",
"ctx",
",",
"sb",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"pz",
".",
"bigEnough",
"(",
")",
"{",
"return",
"errStopEnumerate",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"if",
"err",
"==",
"errStopEnumerate",
"{",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"pz",
".",
"condClose",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"pz",
".",
"bigEnough",
"(",
")",
"{",
"return",
"ErrSourceTooSmall",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"Store",
"(",
"pz",
".",
"buf",
".",
"Bytes",
"(",
")",
",",
"pz",
".",
"blobs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"a",
".",
"DeleteSourceAfterStore",
"{",
"blobs",
":=",
"make",
"(",
"[",
"]",
"blob",
".",
"Ref",
",",
"0",
",",
"len",
"(",
"pz",
".",
"blobs",
")",
")",
"\n",
"for",
"_",
",",
"sb",
":=",
"range",
"pz",
".",
"blobs",
"{",
"blobs",
"=",
"append",
"(",
"blobs",
",",
"sb",
".",
"Ref",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"Source",
".",
"RemoveBlobs",
"(",
"ctx",
",",
"blobs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RunOnce scans a.Source and conditionally creates a new zip.
// It returns ErrSourceTooSmall if there aren't enough blobs on Source. | [
"RunOnce",
"scans",
"a",
".",
"Source",
"and",
"conditionally",
"creates",
"a",
"new",
"zip",
".",
"It",
"returns",
"ErrSourceTooSmall",
"if",
"there",
"aren",
"t",
"enough",
"blobs",
"on",
"Source",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/archiver/archiver.go#L80-L122 | train |
perkeep/perkeep | pkg/blobserver/enumerate.go | EnumerateAll | func EnumerateAll(ctx context.Context, src BlobEnumerator, fn func(blob.SizedRef) error) error {
return EnumerateAllFrom(ctx, src, "", fn)
} | go | func EnumerateAll(ctx context.Context, src BlobEnumerator, fn func(blob.SizedRef) error) error {
return EnumerateAllFrom(ctx, src, "", fn)
} | [
"func",
"EnumerateAll",
"(",
"ctx",
"context",
".",
"Context",
",",
"src",
"BlobEnumerator",
",",
"fn",
"func",
"(",
"blob",
".",
"SizedRef",
")",
"error",
")",
"error",
"{",
"return",
"EnumerateAllFrom",
"(",
"ctx",
",",
"src",
",",
"\"",
"\"",
",",
"fn",
")",
"\n",
"}"
] | // EnumerateAll runs fn for each blob in src.
// If fn returns an error, iteration stops and fn isn't called again.
// EnumerateAll will not return concurrently with fn. | [
"EnumerateAll",
"runs",
"fn",
"for",
"each",
"blob",
"in",
"src",
".",
"If",
"fn",
"returns",
"an",
"error",
"iteration",
"stops",
"and",
"fn",
"isn",
"t",
"called",
"again",
".",
"EnumerateAll",
"will",
"not",
"return",
"concurrently",
"with",
"fn",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/enumerate.go#L29-L31 | train |
perkeep/perkeep | pkg/blobserver/enumerate.go | EnumerateAllFrom | func EnumerateAllFrom(ctx context.Context, src BlobEnumerator, after string, fn func(blob.SizedRef) error) error {
const batchSize = 1000
var mu sync.Mutex // protects returning with an error while fn is still running
errc := make(chan error, 1)
for {
ch := make(chan blob.SizedRef, 16)
n := 0
go func() {
var err error
for sb := range ch {
if err != nil {
continue
}
mu.Lock()
err = fn(sb)
mu.Unlock()
after = sb.Ref.String()
n++
}
errc <- err
}()
err := src.EnumerateBlobs(ctx, ch, after, batchSize)
if err != nil {
mu.Lock() // make sure fn callback finished; no need to unlock
return err
}
if err := <-errc; err != nil {
return err
}
if n == 0 {
return nil
}
}
} | go | func EnumerateAllFrom(ctx context.Context, src BlobEnumerator, after string, fn func(blob.SizedRef) error) error {
const batchSize = 1000
var mu sync.Mutex // protects returning with an error while fn is still running
errc := make(chan error, 1)
for {
ch := make(chan blob.SizedRef, 16)
n := 0
go func() {
var err error
for sb := range ch {
if err != nil {
continue
}
mu.Lock()
err = fn(sb)
mu.Unlock()
after = sb.Ref.String()
n++
}
errc <- err
}()
err := src.EnumerateBlobs(ctx, ch, after, batchSize)
if err != nil {
mu.Lock() // make sure fn callback finished; no need to unlock
return err
}
if err := <-errc; err != nil {
return err
}
if n == 0 {
return nil
}
}
} | [
"func",
"EnumerateAllFrom",
"(",
"ctx",
"context",
".",
"Context",
",",
"src",
"BlobEnumerator",
",",
"after",
"string",
",",
"fn",
"func",
"(",
"blob",
".",
"SizedRef",
")",
"error",
")",
"error",
"{",
"const",
"batchSize",
"=",
"1000",
"\n",
"var",
"mu",
"sync",
".",
"Mutex",
"// protects returning with an error while fn is still running",
"\n",
"errc",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"for",
"{",
"ch",
":=",
"make",
"(",
"chan",
"blob",
".",
"SizedRef",
",",
"16",
")",
"\n",
"n",
":=",
"0",
"\n",
"go",
"func",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"for",
"sb",
":=",
"range",
"ch",
"{",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"mu",
".",
"Lock",
"(",
")",
"\n",
"err",
"=",
"fn",
"(",
"sb",
")",
"\n",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"after",
"=",
"sb",
".",
"Ref",
".",
"String",
"(",
")",
"\n",
"n",
"++",
"\n",
"}",
"\n",
"errc",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"err",
":=",
"src",
".",
"EnumerateBlobs",
"(",
"ctx",
",",
"ch",
",",
"after",
",",
"batchSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"mu",
".",
"Lock",
"(",
")",
"// make sure fn callback finished; no need to unlock",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"<-",
"errc",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"n",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // EnumerateAllFrom is like EnumerateAll, but takes an after parameter. | [
"EnumerateAllFrom",
"is",
"like",
"EnumerateAll",
"but",
"takes",
"an",
"after",
"parameter",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/enumerate.go#L34-L67 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.