repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | auth | func (im *imp) auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
baseURL, err := url.Parse(ctx.AccountNode.Attr(acctAttrInstanceURL))
if err != nil {
return nil, err
}
tokenURL := *baseURL
tokenURL.Path = path.Join(tokenURL.Path, tokenPath)
authURL := *baseURL
authURL.Path = path.Join(authURL.Path, authorizationPath)
return &oauth2.Config{
ClientID: ctx.AccountNode.Attr(acctAttrClientID),
ClientSecret: ctx.AccountNode.Attr(acctAttrClientSecret),
RedirectURL: im.RedirectURL(im, ctx),
Endpoint: oauth2.Endpoint{
AuthURL: authURL.String(),
TokenURL: tokenURL.String(),
},
}, nil
} | go | func (im *imp) auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
baseURL, err := url.Parse(ctx.AccountNode.Attr(acctAttrInstanceURL))
if err != nil {
return nil, err
}
tokenURL := *baseURL
tokenURL.Path = path.Join(tokenURL.Path, tokenPath)
authURL := *baseURL
authURL.Path = path.Join(authURL.Path, authorizationPath)
return &oauth2.Config{
ClientID: ctx.AccountNode.Attr(acctAttrClientID),
ClientSecret: ctx.AccountNode.Attr(acctAttrClientSecret),
RedirectURL: im.RedirectURL(im, ctx),
Endpoint: oauth2.Endpoint{
AuthURL: authURL.String(),
TokenURL: tokenURL.String(),
},
}, nil
} | [
"func",
"(",
"im",
"*",
"imp",
")",
"auth",
"(",
"ctx",
"*",
"importer",
".",
"SetupContext",
")",
"(",
"*",
"oauth2",
".",
"Config",
",",
"error",
")",
"{",
"baseURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"ctx",
".",
"AccountNode",
".",
"... | // auth returns the appropriate oauth2.Config for this account | [
"auth",
"returns",
"the",
"appropriate",
"oauth2",
".",
"Config",
"for",
"this",
"account"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L470-L491 | train |
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | createMastodonClient | func createMastodonClient(ctx context.Context, acct *importer.Object) *mastodon.Client {
// Although the client can take client_id and client_secret, we won't need
// those for token auth
cl := mastodon.NewClient(&mastodon.Config{
Server: acct.Attr(acctAttrInstanceURL),
AccessToken: acct.Attr(importer.AcctAttrAccessToken),
})
cl.Client = *ctxutil.Client(ctx)
return cl
} | go | func createMastodonClient(ctx context.Context, acct *importer.Object) *mastodon.Client {
// Although the client can take client_id and client_secret, we won't need
// those for token auth
cl := mastodon.NewClient(&mastodon.Config{
Server: acct.Attr(acctAttrInstanceURL),
AccessToken: acct.Attr(importer.AcctAttrAccessToken),
})
cl.Client = *ctxutil.Client(ctx)
return cl
} | [
"func",
"createMastodonClient",
"(",
"ctx",
"context",
".",
"Context",
",",
"acct",
"*",
"importer",
".",
"Object",
")",
"*",
"mastodon",
".",
"Client",
"{",
"cl",
":=",
"mastodon",
".",
"NewClient",
"(",
"&",
"mastodon",
".",
"Config",
"{",
"Server",
":... | // createMastodonClient returns a new Client configured for the provided
// account. It does not check if the account has the needed fields filled. | [
"createMastodonClient",
"returns",
"a",
"new",
"Client",
"configured",
"for",
"the",
"provided",
"account",
".",
"It",
"does",
"not",
"check",
"if",
"the",
"account",
"has",
"the",
"needed",
"fields",
"filled",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L495-L506 | train |
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | getExpandedAddress | func getExpandedAddress(user, instanceURL string) (string, error) {
if user == "" || instanceURL == "" {
return "", errors.New("some required account data is missing")
}
parsedURL, err := url.Parse(instanceURL)
if err != nil {
return "", err
}
return fmt.Sprintf("@%s@%s", user, parsedURL.Host), nil
} | go | func getExpandedAddress(user, instanceURL string) (string, error) {
if user == "" || instanceURL == "" {
return "", errors.New("some required account data is missing")
}
parsedURL, err := url.Parse(instanceURL)
if err != nil {
return "", err
}
return fmt.Sprintf("@%s@%s", user, parsedURL.Host), nil
} | [
"func",
"getExpandedAddress",
"(",
"user",
",",
"instanceURL",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"user",
"==",
"\"\"",
"||",
"instanceURL",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"some required acco... | // getExpandedAddress returns the address for the account in the @user@example.com form | [
"getExpandedAddress",
"returns",
"the",
"address",
"for",
"the",
"account",
"in",
"the"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L509-L521 | train |
perkeep/perkeep | pkg/index/sniff.go | Body | func (sn *BlobSniffer) Body() ([]byte, error) {
if sn.IsTruncated() {
return nil, errors.New("index.Body: was truncated")
}
return sn.contents, nil
} | go | func (sn *BlobSniffer) Body() ([]byte, error) {
if sn.IsTruncated() {
return nil, errors.New("index.Body: was truncated")
}
return sn.contents, nil
} | [
"func",
"(",
"sn",
"*",
"BlobSniffer",
")",
"Body",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"sn",
".",
"IsTruncated",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"index.Body: was truncated\"",
")",
"\n",
... | // Body returns the bytes written to the BlobSniffer. | [
"Body",
"returns",
"the",
"bytes",
"written",
"to",
"the",
"BlobSniffer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/sniff.go#L78-L83 | train |
perkeep/perkeep | pkg/server/image.go | cacheScaled | func (ih *ImageHandler) cacheScaled(ctx context.Context, thumbBytes []byte, name string) error {
br, err := writeToCache(ctx, ih.Cache, thumbBytes, name)
if err != nil {
return err
}
ih.ThumbMeta.Put(name, br)
return nil
} | go | func (ih *ImageHandler) cacheScaled(ctx context.Context, thumbBytes []byte, name string) error {
br, err := writeToCache(ctx, ih.Cache, thumbBytes, name)
if err != nil {
return err
}
ih.ThumbMeta.Put(name, br)
return nil
} | [
"func",
"(",
"ih",
"*",
"ImageHandler",
")",
"cacheScaled",
"(",
"ctx",
"context",
".",
"Context",
",",
"thumbBytes",
"[",
"]",
"byte",
",",
"name",
"string",
")",
"error",
"{",
"br",
",",
"err",
":=",
"writeToCache",
"(",
"ctx",
",",
"ih",
".",
"Cac... | // cacheScaled saves in the image handler's cache the scaled image bytes
// in thumbBytes, and puts its blobref in the scaledImage under the key name. | [
"cacheScaled",
"saves",
"in",
"the",
"image",
"handler",
"s",
"cache",
"the",
"scaled",
"image",
"bytes",
"in",
"thumbBytes",
"and",
"puts",
"its",
"blobref",
"in",
"the",
"scaledImage",
"under",
"the",
"key",
"name",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/image.go#L117-L124 | train |
perkeep/perkeep | pkg/server/image.go | scaledCached | func (ih *ImageHandler) scaledCached(ctx context.Context, buf *bytes.Buffer, file blob.Ref) (format string) {
key := cacheKey(file.String(), ih.MaxWidth, ih.MaxHeight)
br, err := ih.ThumbMeta.Get(key)
if err == errCacheMiss {
return
}
if err != nil {
log.Printf("Warning: thumbnail cachekey(%q)->meta lookup error: %v", key, err)
return
}
fr, err := ih.cached(ctx, br)
if err != nil {
if imageDebug {
log.Printf("Could not get cached image %v: %v\n", br, err)
}
return
}
defer fr.Close()
_, err = io.Copy(buf, fr)
if err != nil {
return
}
mime := magic.MIMEType(buf.Bytes())
if format = strings.TrimPrefix(mime, "image/"); format == mime {
log.Printf("Warning: unescaped MIME type %q of %v file for thumbnail %q", mime, br, key)
return
}
return format
} | go | func (ih *ImageHandler) scaledCached(ctx context.Context, buf *bytes.Buffer, file blob.Ref) (format string) {
key := cacheKey(file.String(), ih.MaxWidth, ih.MaxHeight)
br, err := ih.ThumbMeta.Get(key)
if err == errCacheMiss {
return
}
if err != nil {
log.Printf("Warning: thumbnail cachekey(%q)->meta lookup error: %v", key, err)
return
}
fr, err := ih.cached(ctx, br)
if err != nil {
if imageDebug {
log.Printf("Could not get cached image %v: %v\n", br, err)
}
return
}
defer fr.Close()
_, err = io.Copy(buf, fr)
if err != nil {
return
}
mime := magic.MIMEType(buf.Bytes())
if format = strings.TrimPrefix(mime, "image/"); format == mime {
log.Printf("Warning: unescaped MIME type %q of %v file for thumbnail %q", mime, br, key)
return
}
return format
} | [
"func",
"(",
"ih",
"*",
"ImageHandler",
")",
"scaledCached",
"(",
"ctx",
"context",
".",
"Context",
",",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"file",
"blob",
".",
"Ref",
")",
"(",
"format",
"string",
")",
"{",
"key",
":=",
"cacheKey",
"(",
"file"... | // ScaledCached reads the scaled version of the image in file,
// if it is in cache and writes it to buf.
//
// On successful read and population of buf, the returned format is non-empty.
// Almost all errors are not interesting. Real errors will be logged. | [
"ScaledCached",
"reads",
"the",
"scaled",
"version",
"of",
"the",
"image",
"in",
"file",
"if",
"it",
"is",
"in",
"cache",
"and",
"writes",
"it",
"to",
"buf",
".",
"On",
"successful",
"read",
"and",
"population",
"of",
"buf",
"the",
"returned",
"format",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/image.go#L181-L209 | train |
perkeep/perkeep | pkg/blobserver/stats/statreceiver.go | Sizes | func (sr *Receiver) Sizes() []int {
sr.Lock()
defer sr.Unlock()
sizes := make([]int, 0, len(sr.Have))
for _, size := range sr.Have {
sizes = append(sizes, int(size))
}
sort.Ints(sizes)
return sizes
} | go | func (sr *Receiver) Sizes() []int {
sr.Lock()
defer sr.Unlock()
sizes := make([]int, 0, len(sr.Have))
for _, size := range sr.Have {
sizes = append(sizes, int(size))
}
sort.Ints(sizes)
return sizes
} | [
"func",
"(",
"sr",
"*",
"Receiver",
")",
"Sizes",
"(",
")",
"[",
"]",
"int",
"{",
"sr",
".",
"Lock",
"(",
")",
"\n",
"defer",
"sr",
".",
"Unlock",
"(",
")",
"\n",
"sizes",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"0",
",",
"len",
"(",
"sr",... | // Sizes returns the sorted blob sizes. | [
"Sizes",
"returns",
"the",
"sorted",
"blob",
"sizes",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/stats/statreceiver.go#L49-L58 | train |
perkeep/perkeep | internal/images/resize/resize.go | resizeYCbCr | func resizeYCbCr(m *image.YCbCr, r image.Rectangle, w, h int) (image.Image, bool) {
dst := image.NewRGBA(image.Rect(0, 0, w, h))
xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), m, m.Bounds(), xdraw.Src, nil)
return dst, true
} | go | func resizeYCbCr(m *image.YCbCr, r image.Rectangle, w, h int) (image.Image, bool) {
dst := image.NewRGBA(image.Rect(0, 0, w, h))
xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), m, m.Bounds(), xdraw.Src, nil)
return dst, true
} | [
"func",
"resizeYCbCr",
"(",
"m",
"*",
"image",
".",
"YCbCr",
",",
"r",
"image",
".",
"Rectangle",
",",
"w",
",",
"h",
"int",
")",
"(",
"image",
".",
"Image",
",",
"bool",
")",
"{",
"dst",
":=",
"image",
".",
"NewRGBA",
"(",
"image",
".",
"Rect",
... | // resizeYCbCr returns a scaled copy of the YCbCr image slice r of m.
// The returned image has width w and height h. | [
"resizeYCbCr",
"returns",
"a",
"scaled",
"copy",
"of",
"the",
"YCbCr",
"image",
"slice",
"r",
"of",
"m",
".",
"The",
"returned",
"image",
"has",
"width",
"w",
"and",
"height",
"h",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/resize/resize.go#L121-L125 | train |
perkeep/perkeep | internal/images/resize/resize.go | ResampleInplace | func ResampleInplace(m image.Image, r image.Rectangle, w, h int) image.Image {
// We don't support scaling up.
if r.Dx() < w || r.Dy() < h {
return m
}
switch m := m.(type) {
case *image.YCbCr:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
cSrc := m.COffset(xSrc, ySrc)
cDst := m.COffset(x, y)
m.Y[m.YOffset(x, y)] = m.Y[m.YOffset(xSrc, ySrc)]
m.Cb[cDst] = m.Cb[cSrc]
m.Cr[cDst] = m.Cr[cSrc]
}
}
case draw.Image:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
r, g, b, a := m.At(xSrc, ySrc).RGBA()
m.Set(x, y, color.RGBA{
R: uint8(r >> 8),
G: uint8(g >> 8),
B: uint8(b >> 8),
A: uint8(a >> 8),
})
}
}
default:
// TODO fallback to generic Resample somehow?
panic("Unhandled image type")
}
r.Max.X = r.Min.X + w
r.Max.Y = r.Min.Y + h
return subImage(m, r)
} | go | func ResampleInplace(m image.Image, r image.Rectangle, w, h int) image.Image {
// We don't support scaling up.
if r.Dx() < w || r.Dy() < h {
return m
}
switch m := m.(type) {
case *image.YCbCr:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
cSrc := m.COffset(xSrc, ySrc)
cDst := m.COffset(x, y)
m.Y[m.YOffset(x, y)] = m.Y[m.YOffset(xSrc, ySrc)]
m.Cb[cDst] = m.Cb[cSrc]
m.Cr[cDst] = m.Cr[cSrc]
}
}
case draw.Image:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
r, g, b, a := m.At(xSrc, ySrc).RGBA()
m.Set(x, y, color.RGBA{
R: uint8(r >> 8),
G: uint8(g >> 8),
B: uint8(b >> 8),
A: uint8(a >> 8),
})
}
}
default:
// TODO fallback to generic Resample somehow?
panic("Unhandled image type")
}
r.Max.X = r.Min.X + w
r.Max.Y = r.Min.Y + h
return subImage(m, r)
} | [
"func",
"ResampleInplace",
"(",
"m",
"image",
".",
"Image",
",",
"r",
"image",
".",
"Rectangle",
",",
"w",
",",
"h",
"int",
")",
"image",
".",
"Image",
"{",
"if",
"r",
".",
"Dx",
"(",
")",
"<",
"w",
"||",
"r",
".",
"Dy",
"(",
")",
"<",
"h",
... | // ResampleInplace will resample m inplace, overwritting existing pixel data,
// and return a subimage of m sized to w and h. | [
"ResampleInplace",
"will",
"resample",
"m",
"inplace",
"overwritting",
"existing",
"pixel",
"data",
"and",
"return",
"a",
"subimage",
"of",
"m",
"sized",
"to",
"w",
"and",
"h",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/resize/resize.go#L239-L283 | train |
perkeep/perkeep | cmd/pk/dbinit.go | wipeMongo | func (c *dbinitCmd) wipeMongo() error {
if c.dbType != "mongo" {
return nil
}
session, err := c.mongoSession()
if err != nil {
return err
}
defer session.Close()
if _, err := session.DB(c.dbName).C(mongo.CollectionName).RemoveAll(nil); err != nil {
return err
}
return nil
} | go | func (c *dbinitCmd) wipeMongo() error {
if c.dbType != "mongo" {
return nil
}
session, err := c.mongoSession()
if err != nil {
return err
}
defer session.Close()
if _, err := session.DB(c.dbName).C(mongo.CollectionName).RemoveAll(nil); err != nil {
return err
}
return nil
} | [
"func",
"(",
"c",
"*",
"dbinitCmd",
")",
"wipeMongo",
"(",
")",
"error",
"{",
"if",
"c",
".",
"dbType",
"!=",
"\"mongo\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"c",
".",
"mongoSession",
"(",
")",
"\n",
"if",
"err",
... | // wipeMongo erases all documents from the mongo collection
// if c.dbType is "mongo". | [
"wipeMongo",
"erases",
"all",
"documents",
"from",
"the",
"mongo",
"collection",
"if",
"c",
".",
"dbType",
"is",
"mongo",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk/dbinit.go#L290-L303 | train |
perkeep/perkeep | pkg/importer/oauth.go | RedirectURL | func (OAuth2) RedirectURL(imp Importer, ctx *SetupContext) string {
// We strip our callback URL of its query component, because the Redirect URI
// we send during authorization has to match exactly the registered redirect
// URI(s). This query component should be stored in the "state" paremeter instead.
// See http://tools.ietf.org/html/rfc6749#section-3.1.2.2
fullCallback := ctx.CallbackURL()
queryPart := imp.CallbackURLParameters(ctx.AccountNode.PermanodeRef())
if len(queryPart) == 0 {
log.Printf("WARNING: callback URL %q has no query component", fullCallback)
}
u, _ := url.Parse(fullCallback)
v := u.Query()
// remove query params in CallbackURLParameters
for k := range queryPart {
v.Del(k)
}
u.RawQuery = v.Encode()
return u.String()
} | go | func (OAuth2) RedirectURL(imp Importer, ctx *SetupContext) string {
// We strip our callback URL of its query component, because the Redirect URI
// we send during authorization has to match exactly the registered redirect
// URI(s). This query component should be stored in the "state" paremeter instead.
// See http://tools.ietf.org/html/rfc6749#section-3.1.2.2
fullCallback := ctx.CallbackURL()
queryPart := imp.CallbackURLParameters(ctx.AccountNode.PermanodeRef())
if len(queryPart) == 0 {
log.Printf("WARNING: callback URL %q has no query component", fullCallback)
}
u, _ := url.Parse(fullCallback)
v := u.Query()
// remove query params in CallbackURLParameters
for k := range queryPart {
v.Del(k)
}
u.RawQuery = v.Encode()
return u.String()
} | [
"func",
"(",
"OAuth2",
")",
"RedirectURL",
"(",
"imp",
"Importer",
",",
"ctx",
"*",
"SetupContext",
")",
"string",
"{",
"fullCallback",
":=",
"ctx",
".",
"CallbackURL",
"(",
")",
"\n",
"queryPart",
":=",
"imp",
".",
"CallbackURLParameters",
"(",
"ctx",
"."... | // RedirectURL returns the redirect URI that imp should set in an oauth.Config
// for the authorization phase of OAuth2 authentication. | [
"RedirectURL",
"returns",
"the",
"redirect",
"URI",
"that",
"imp",
"should",
"set",
"in",
"an",
"oauth",
".",
"Config",
"for",
"the",
"authorization",
"phase",
"of",
"OAuth2",
"authentication",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L87-L105 | train |
perkeep/perkeep | pkg/importer/oauth.go | IsAccountReady | func (OAuth2) IsAccountReady(acctNode *Object) (ok bool, err error) {
if acctNode.Attr(AcctAttrUserID) != "" &&
acctNode.Attr(AcctAttrAccessToken) != "" {
return true, nil
}
return false, nil
} | go | func (OAuth2) IsAccountReady(acctNode *Object) (ok bool, err error) {
if acctNode.Attr(AcctAttrUserID) != "" &&
acctNode.Attr(AcctAttrAccessToken) != "" {
return true, nil
}
return false, nil
} | [
"func",
"(",
"OAuth2",
")",
"IsAccountReady",
"(",
"acctNode",
"*",
"Object",
")",
"(",
"ok",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"acctNode",
".",
"Attr",
"(",
"AcctAttrUserID",
")",
"!=",
"\"\"",
"&&",
"acctNode",
".",
"Attr",
"(",
"AcctAttrA... | // IsAccountReady returns whether the account has been properly configured
// - whether the user ID and access token has been stored in the given account node. | [
"IsAccountReady",
"returns",
"whether",
"the",
"account",
"has",
"been",
"properly",
"configured",
"-",
"whether",
"the",
"user",
"ID",
"and",
"access",
"token",
"has",
"been",
"stored",
"in",
"the",
"given",
"account",
"node",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L121-L127 | train |
perkeep/perkeep | pkg/importer/oauth.go | do | func (octx OAuthContext) do(method string, url string, form url.Values) (*http.Response, error) {
if octx.Creds == nil {
return nil, errors.New("no OAuth credentials. Not logged in?")
}
if octx.Client == nil {
return nil, errors.New("no OAuth client")
}
var (
res *http.Response
err error
)
if method == http.MethodPost {
res, err = octx.Client.Post(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
} else {
res, err = octx.Client.Get(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
}
if err != nil {
return nil, fmt.Errorf("error fetching %s: %v", url, err)
}
if res.StatusCode != http.StatusOK {
return res, fmt.Errorf("%s request on %s failed with: %s", method, url, res.Status)
}
return res, nil
} | go | func (octx OAuthContext) do(method string, url string, form url.Values) (*http.Response, error) {
if octx.Creds == nil {
return nil, errors.New("no OAuth credentials. Not logged in?")
}
if octx.Client == nil {
return nil, errors.New("no OAuth client")
}
var (
res *http.Response
err error
)
if method == http.MethodPost {
res, err = octx.Client.Post(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
} else {
res, err = octx.Client.Get(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
}
if err != nil {
return nil, fmt.Errorf("error fetching %s: %v", url, err)
}
if res.StatusCode != http.StatusOK {
return res, fmt.Errorf("%s request on %s failed with: %s", method, url, res.Status)
}
return res, nil
} | [
"func",
"(",
"octx",
"OAuthContext",
")",
"do",
"(",
"method",
"string",
",",
"url",
"string",
",",
"form",
"url",
".",
"Values",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"octx",
".",
"Creds",
"==",
"nil",
"{",
"return"... | // Do sends through octx the request defined by url and the values in form. | [
"Do",
"sends",
"through",
"octx",
"the",
"request",
"defined",
"by",
"url",
"and",
"the",
"values",
"in",
"form",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L159-L182 | train |
perkeep/perkeep | pkg/importer/oauth.go | PopulateJSONFromURL | func (octx OAuthContext) PopulateJSONFromURL(result interface{}, method string, apiURL string, keyval ...string) error {
if method != http.MethodGet && method != http.MethodPost {
return fmt.Errorf("only HTTP Get or Post supported: found %v", method)
}
if len(keyval)%2 == 1 {
return errors.New("incorrect number of keyval arguments. must be even")
}
form := url.Values{}
for i := 0; i < len(keyval); i += 2 {
form.Set(keyval[i], keyval[i+1])
}
hres, err := octx.do(method, apiURL, form)
if err != nil {
return err
}
err = httputil.DecodeJSON(hres, result)
if err != nil {
return fmt.Errorf("could not parse response for %s: %v", apiURL, err)
}
return err
} | go | func (octx OAuthContext) PopulateJSONFromURL(result interface{}, method string, apiURL string, keyval ...string) error {
if method != http.MethodGet && method != http.MethodPost {
return fmt.Errorf("only HTTP Get or Post supported: found %v", method)
}
if len(keyval)%2 == 1 {
return errors.New("incorrect number of keyval arguments. must be even")
}
form := url.Values{}
for i := 0; i < len(keyval); i += 2 {
form.Set(keyval[i], keyval[i+1])
}
hres, err := octx.do(method, apiURL, form)
if err != nil {
return err
}
err = httputil.DecodeJSON(hres, result)
if err != nil {
return fmt.Errorf("could not parse response for %s: %v", apiURL, err)
}
return err
} | [
"func",
"(",
"octx",
"OAuthContext",
")",
"PopulateJSONFromURL",
"(",
"result",
"interface",
"{",
"}",
",",
"method",
"string",
",",
"apiURL",
"string",
",",
"keyval",
"...",
"string",
")",
"error",
"{",
"if",
"method",
"!=",
"http",
".",
"MethodGet",
"&&"... | // PopulateJSONFromURL makes a POST or GET call at apiURL, using keyval as parameters of
// the associated form. The JSON response is decoded into result. | [
"PopulateJSONFromURL",
"makes",
"a",
"POST",
"or",
"GET",
"call",
"at",
"apiURL",
"using",
"keyval",
"as",
"parameters",
"of",
"the",
"associated",
"form",
".",
"The",
"JSON",
"response",
"is",
"decoded",
"into",
"result",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L194-L214 | train |
perkeep/perkeep | pkg/importer/oauth.go | NewOAuthClient | func (ctx *SetupContext) NewOAuthClient(uris OAuthURIs) (*oauth.Client, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth.Client{
TemporaryCredentialRequestURI: uris.TemporaryCredentialRequestURI,
ResourceOwnerAuthorizationURI: uris.ResourceOwnerAuthorizationURI,
TokenRequestURI: uris.TokenRequestURI,
Credentials: oauth.Credentials{
Token: clientID,
Secret: secret,
},
}, nil
} | go | func (ctx *SetupContext) NewOAuthClient(uris OAuthURIs) (*oauth.Client, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth.Client{
TemporaryCredentialRequestURI: uris.TemporaryCredentialRequestURI,
ResourceOwnerAuthorizationURI: uris.ResourceOwnerAuthorizationURI,
TokenRequestURI: uris.TokenRequestURI,
Credentials: oauth.Credentials{
Token: clientID,
Secret: secret,
},
}, nil
} | [
"func",
"(",
"ctx",
"*",
"SetupContext",
")",
"NewOAuthClient",
"(",
"uris",
"OAuthURIs",
")",
"(",
"*",
"oauth",
".",
"Client",
",",
"error",
")",
"{",
"clientID",
",",
"secret",
",",
"err",
":=",
"ctx",
".",
"Credentials",
"(",
")",
"\n",
"if",
"er... | // NewOAuthClient returns an oauth Client configured with uris and the
// credentials obtained from ctx. | [
"NewOAuthClient",
"returns",
"an",
"oauth",
"Client",
"configured",
"with",
"uris",
"and",
"the",
"credentials",
"obtained",
"from",
"ctx",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L225-L239 | train |
perkeep/perkeep | pkg/blobserver/registry.go | RegisterHandlerConstructor | func RegisterHandlerConstructor(typ string, ctor HandlerConstructor) {
mapLock.Lock()
defer mapLock.Unlock()
if _, ok := handlerConstructors[typ]; ok {
panic("blobserver: HandlerConstrutor already registered for type: " + typ)
}
handlerConstructors[typ] = ctor
} | go | func RegisterHandlerConstructor(typ string, ctor HandlerConstructor) {
mapLock.Lock()
defer mapLock.Unlock()
if _, ok := handlerConstructors[typ]; ok {
panic("blobserver: HandlerConstrutor already registered for type: " + typ)
}
handlerConstructors[typ] = ctor
} | [
"func",
"RegisterHandlerConstructor",
"(",
"typ",
"string",
",",
"ctor",
"HandlerConstructor",
")",
"{",
"mapLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mapLock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"handlerConstructors",
"[",
"typ... | // RegisterHandlerConstructor registers an http Handler constructor function
// for a given handler type.
//
// It is an error to register the same handler type twice. | [
"RegisterHandlerConstructor",
"registers",
"an",
"http",
"Handler",
"constructor",
"function",
"for",
"a",
"given",
"handler",
"type",
".",
"It",
"is",
"an",
"error",
"to",
"register",
"the",
"same",
"handler",
"type",
"twice",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/registry.go#L118-L125 | train |
perkeep/perkeep | pkg/blobserver/registry.go | CreateHandler | func CreateHandler(typ string, loader Loader, config jsonconfig.Obj) (http.Handler, error) {
mapLock.Lock()
ctor, ok := handlerConstructors[typ]
mapLock.Unlock()
if !ok {
return nil, fmt.Errorf("blobserver: Handler type %q not known or loaded", typ)
}
return ctor(loader, config)
} | go | func CreateHandler(typ string, loader Loader, config jsonconfig.Obj) (http.Handler, error) {
mapLock.Lock()
ctor, ok := handlerConstructors[typ]
mapLock.Unlock()
if !ok {
return nil, fmt.Errorf("blobserver: Handler type %q not known or loaded", typ)
}
return ctor(loader, config)
} | [
"func",
"CreateHandler",
"(",
"typ",
"string",
",",
"loader",
"Loader",
",",
"config",
"jsonconfig",
".",
"Obj",
")",
"(",
"http",
".",
"Handler",
",",
"error",
")",
"{",
"mapLock",
".",
"Lock",
"(",
")",
"\n",
"ctor",
",",
"ok",
":=",
"handlerConstruc... | // CreateHandler instantiates an http Handler of type 'typ' from the
// provided JSON configuration, and finding peer handlers and
// configuration from the environment in 'loader'.
//
// The handler 'typ' must have been previously registered with
// RegisterHandlerConstructor. | [
"CreateHandler",
"instantiates",
"an",
"http",
"Handler",
"of",
"type",
"typ",
"from",
"the",
"provided",
"JSON",
"configuration",
"and",
"finding",
"peer",
"handlers",
"and",
"configuration",
"from",
"the",
"environment",
"in",
"loader",
".",
"The",
"handler",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/registry.go#L133-L141 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | genLowLevelConfig | func genLowLevelConfig(conf *serverconfig.Config) (lowLevelConf *Config, err error) {
b := &lowBuilder{
high: conf,
low: jsonconfig.Obj{
"prefixes": make(map[string]interface{}),
},
}
return b.build()
} | go | func genLowLevelConfig(conf *serverconfig.Config) (lowLevelConf *Config, err error) {
b := &lowBuilder{
high: conf,
low: jsonconfig.Obj{
"prefixes": make(map[string]interface{}),
},
}
return b.build()
} | [
"func",
"genLowLevelConfig",
"(",
"conf",
"*",
"serverconfig",
".",
"Config",
")",
"(",
"lowLevelConf",
"*",
"Config",
",",
"err",
"error",
")",
"{",
"b",
":=",
"&",
"lowBuilder",
"{",
"high",
":",
"conf",
",",
"low",
":",
"jsonconfig",
".",
"Obj",
"{"... | // genLowLevelConfig returns a low-level config from a high-level config. | [
"genLowLevelConfig",
"returns",
"a",
"low",
"-",
"level",
"config",
"from",
"a",
"high",
"-",
"level",
"config",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L52-L60 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | dbUnique | func (b *lowBuilder) dbUnique() string {
if b.high.DBUnique != "" {
return b.high.DBUnique
}
if b.high.Identity != "" {
return strings.ToLower(b.high.Identity)
}
return osutil.Username() // may be empty, if $USER unset
} | go | func (b *lowBuilder) dbUnique() string {
if b.high.DBUnique != "" {
return b.high.DBUnique
}
if b.high.Identity != "" {
return strings.ToLower(b.high.Identity)
}
return osutil.Username() // may be empty, if $USER unset
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"dbUnique",
"(",
")",
"string",
"{",
"if",
"b",
".",
"high",
".",
"DBUnique",
"!=",
"\"\"",
"{",
"return",
"b",
".",
"high",
".",
"DBUnique",
"\n",
"}",
"\n",
"if",
"b",
".",
"high",
".",
"Identity",
"!="... | // dbUnique returns the uniqueness string that is used in databases names to
// differentiate them from databases used by other Perkeep instances on the same
// DBMS. | [
"dbUnique",
"returns",
"the",
"uniqueness",
"string",
"that",
"is",
"used",
"in",
"databases",
"names",
"to",
"differentiate",
"them",
"from",
"databases",
"used",
"by",
"other",
"Perkeep",
"instances",
"on",
"the",
"same",
"DBMS",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L105-L113 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | oldDBNames | func (b *lowBuilder) oldDBNames(of dbname) string {
switch of {
case dbIndex:
return "camlistore_index"
case dbBlobpackedIndex:
return "blobpacked_index"
case "queue-sync-to-index":
return "sync_index_queue"
case dbUIThumbcache:
return "ui_thumbmeta_cache"
}
return ""
} | go | func (b *lowBuilder) oldDBNames(of dbname) string {
switch of {
case dbIndex:
return "camlistore_index"
case dbBlobpackedIndex:
return "blobpacked_index"
case "queue-sync-to-index":
return "sync_index_queue"
case dbUIThumbcache:
return "ui_thumbmeta_cache"
}
return ""
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"oldDBNames",
"(",
"of",
"dbname",
")",
"string",
"{",
"switch",
"of",
"{",
"case",
"dbIndex",
":",
"return",
"\"camlistore_index\"",
"\n",
"case",
"dbBlobpackedIndex",
":",
"return",
"\"blobpacked_index\"",
"\n",
"cas... | // As of rev 7eda9fd5027fda88166d6c03b6490cffbf2de5fb, we changed how the
// databases names were defined. But we wanted the existing GCE instances to keep
// on working with the old names, so that nothing would break for existing users,
// without any intervention needed. Through the help of the perkeep-config-version
// variable, set by the GCE launcher, we can know whether an instance is such an
// "old" one, and in that case we keep on using the old database names. oldDBNames
// returns these names. | [
"As",
"of",
"rev",
"7eda9fd5027fda88166d6c03b6490cffbf2de5fb",
"we",
"changed",
"how",
"the",
"databases",
"names",
"were",
"defined",
".",
"But",
"we",
"wanted",
"the",
"existing",
"GCE",
"instances",
"to",
"keep",
"on",
"working",
"with",
"the",
"old",
"names"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L162-L174 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | searchOwner | func (b *lowBuilder) searchOwner() (owner *serverconfig.Owner, err error) {
if b.high.Identity == "" {
return nil, errNoOwner
}
if b.high.IdentitySecretRing == "" {
return nil, errNoOwner
}
return &serverconfig.Owner{
Identity: b.high.Identity,
SecringFile: b.high.IdentitySecretRing,
}, nil
} | go | func (b *lowBuilder) searchOwner() (owner *serverconfig.Owner, err error) {
if b.high.Identity == "" {
return nil, errNoOwner
}
if b.high.IdentitySecretRing == "" {
return nil, errNoOwner
}
return &serverconfig.Owner{
Identity: b.high.Identity,
SecringFile: b.high.IdentitySecretRing,
}, nil
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"searchOwner",
"(",
")",
"(",
"owner",
"*",
"serverconfig",
".",
"Owner",
",",
"err",
"error",
")",
"{",
"if",
"b",
".",
"high",
".",
"Identity",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errNoOwner",
"\n",
... | // Error is errNoOwner if no identity configured | [
"Error",
"is",
"errNoOwner",
"if",
"no",
"identity",
"configured"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L179-L190 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | kvFileType | func (b *lowBuilder) kvFileType() string {
switch {
case b.high.SQLite != "":
return "sqlite"
case b.high.KVFile != "":
return "kv"
case b.high.LevelDB != "":
return "leveldb"
default:
return sorted.DefaultKVFileType
}
} | go | func (b *lowBuilder) kvFileType() string {
switch {
case b.high.SQLite != "":
return "sqlite"
case b.high.KVFile != "":
return "kv"
case b.high.LevelDB != "":
return "leveldb"
default:
return sorted.DefaultKVFileType
}
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"kvFileType",
"(",
")",
"string",
"{",
"switch",
"{",
"case",
"b",
".",
"high",
".",
"SQLite",
"!=",
"\"\"",
":",
"return",
"\"sqlite\"",
"\n",
"case",
"b",
".",
"high",
".",
"KVFile",
"!=",
"\"\"",
":",
"r... | // kvFileType returns the file based sorted type defined for index storage, if
// any. It defaults to "leveldb" otherwise. | [
"kvFileType",
"returns",
"the",
"file",
"based",
"sorted",
"type",
"defined",
"for",
"index",
"storage",
"if",
"any",
".",
"It",
"defaults",
"to",
"leveldb",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L355-L366 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | sortedDBMS | func (b *lowBuilder) sortedDBMS(named dbname) (map[string]interface{}, error) {
if b.high.MySQL != "" {
return b.dbIndexStorage("mysql", b.high.MySQL, named)
}
if b.high.PostgreSQL != "" {
return b.dbIndexStorage("postgres", b.high.PostgreSQL, named)
}
if b.high.Mongo != "" {
return b.mongoIndexStorage(b.high.Mongo, named)
}
return nil, nil
} | go | func (b *lowBuilder) sortedDBMS(named dbname) (map[string]interface{}, error) {
if b.high.MySQL != "" {
return b.dbIndexStorage("mysql", b.high.MySQL, named)
}
if b.high.PostgreSQL != "" {
return b.dbIndexStorage("postgres", b.high.PostgreSQL, named)
}
if b.high.Mongo != "" {
return b.mongoIndexStorage(b.high.Mongo, named)
}
return nil, nil
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"sortedDBMS",
"(",
"named",
"dbname",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"b",
".",
"high",
".",
"MySQL",
"!=",
"\"\"",
"{",
"return",
"b",
".",
"dbIn... | // sortedDBMS returns the configuration for a name database on one of the
// DBMS, if any was found in the configuration. It returns nil otherwise. | [
"sortedDBMS",
"returns",
"the",
"configuration",
"for",
"a",
"name",
"database",
"on",
"one",
"of",
"the",
"DBMS",
"if",
"any",
"was",
"found",
"in",
"the",
"configuration",
".",
"It",
"returns",
"nil",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L467-L478 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | sortedStorageAt | func (b *lowBuilder) sortedStorageAt(sortedType dbname, filePrefix string) (map[string]interface{}, error) {
dbms, err := b.sortedDBMS(sortedType)
if err != nil {
return nil, err
}
if dbms != nil {
return dbms, nil
}
if b.high.MemoryIndex {
return map[string]interface{}{
"type": "memory",
}, nil
}
if sortedType != "index" && filePrefix == "" {
return nil, fmt.Errorf("internal error: use of sortedStorageAt with a non-index type (%v) and no file location for non-database sorted implementation", sortedType)
}
// dbFile returns path directly if sortedType == "index", else it returns filePrefix+"."+ext.
dbFile := func(path, ext string) string {
if sortedType == "index" {
return path
}
return filePrefix + "." + ext
}
if b.high.SQLite != "" {
return map[string]interface{}{
"type": "sqlite",
"file": dbFile(b.high.SQLite, "sqlite"),
}, nil
}
if b.high.KVFile != "" {
return map[string]interface{}{
"type": "kv",
"file": dbFile(b.high.KVFile, "kv"),
}, nil
}
if b.high.LevelDB != "" {
return map[string]interface{}{
"type": "leveldb",
"file": dbFile(b.high.LevelDB, "leveldb"),
}, nil
}
panic("internal error: sortedStorageAt didn't find a sorted implementation")
} | go | func (b *lowBuilder) sortedStorageAt(sortedType dbname, filePrefix string) (map[string]interface{}, error) {
dbms, err := b.sortedDBMS(sortedType)
if err != nil {
return nil, err
}
if dbms != nil {
return dbms, nil
}
if b.high.MemoryIndex {
return map[string]interface{}{
"type": "memory",
}, nil
}
if sortedType != "index" && filePrefix == "" {
return nil, fmt.Errorf("internal error: use of sortedStorageAt with a non-index type (%v) and no file location for non-database sorted implementation", sortedType)
}
// dbFile returns path directly if sortedType == "index", else it returns filePrefix+"."+ext.
dbFile := func(path, ext string) string {
if sortedType == "index" {
return path
}
return filePrefix + "." + ext
}
if b.high.SQLite != "" {
return map[string]interface{}{
"type": "sqlite",
"file": dbFile(b.high.SQLite, "sqlite"),
}, nil
}
if b.high.KVFile != "" {
return map[string]interface{}{
"type": "kv",
"file": dbFile(b.high.KVFile, "kv"),
}, nil
}
if b.high.LevelDB != "" {
return map[string]interface{}{
"type": "leveldb",
"file": dbFile(b.high.LevelDB, "leveldb"),
}, nil
}
panic("internal error: sortedStorageAt didn't find a sorted implementation")
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"sortedStorageAt",
"(",
"sortedType",
"dbname",
",",
"filePrefix",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"dbms",
",",
"err",
":=",
"b",
".",
"sortedDBMS",... | // filePrefix gives a file path of where to put the database. It can be omitted by
// some sorted implementations, but is required by others.
// The filePrefix should be to a file, not a directory, and should not end in a ".ext" extension.
// An extension like ".kv" or ".sqlite" will be added. | [
"filePrefix",
"gives",
"a",
"file",
"path",
"of",
"where",
"to",
"put",
"the",
"database",
".",
"It",
"can",
"be",
"omitted",
"by",
"some",
"sorted",
"implementations",
"but",
"is",
"required",
"by",
"others",
".",
"The",
"filePrefix",
"should",
"be",
"to"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L484-L526 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | indexFileDir | func (b *lowBuilder) indexFileDir() string {
switch {
case b.high.SQLite != "":
return filepath.Dir(b.high.SQLite)
case b.high.KVFile != "":
return filepath.Dir(b.high.KVFile)
case b.high.LevelDB != "":
return filepath.Dir(b.high.LevelDB)
}
return ""
} | go | func (b *lowBuilder) indexFileDir() string {
switch {
case b.high.SQLite != "":
return filepath.Dir(b.high.SQLite)
case b.high.KVFile != "":
return filepath.Dir(b.high.KVFile)
case b.high.LevelDB != "":
return filepath.Dir(b.high.LevelDB)
}
return ""
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"indexFileDir",
"(",
")",
"string",
"{",
"switch",
"{",
"case",
"b",
".",
"high",
".",
"SQLite",
"!=",
"\"\"",
":",
"return",
"filepath",
".",
"Dir",
"(",
"b",
".",
"high",
".",
"SQLite",
")",
"\n",
"case",... | // indexFileDir returns the directory of the sqlite or kv file, or the
// empty string. | [
"indexFileDir",
"returns",
"the",
"directory",
"of",
"the",
"sqlite",
"or",
"kv",
"file",
"or",
"the",
"empty",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L827-L837 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | WriteDefaultConfigFile | func WriteDefaultConfigFile(filePath string, useSQLite bool) error {
conf := defaultBaseConfig
blobDir, err := osutil.CamliBlobRoot()
if err != nil {
return err
}
varDir, err := osutil.CamliVarDir()
if err != nil {
return err
}
if err := wkfs.MkdirAll(blobDir, 0700); err != nil {
return fmt.Errorf("Could not create default blobs directory: %v", err)
}
conf.BlobPath = blobDir
conf.PackRelated = true
if useSQLite {
conf.SQLite = filepath.Join(varDir, "index.sqlite")
} else {
conf.LevelDB = filepath.Join(varDir, "index.leveldb")
}
keyID, secretRing, err := getOrMakeKeyring()
if err != nil {
return err
}
conf.Identity = keyID
conf.IdentitySecretRing = secretRing
confData, err := json.MarshalIndent(conf, "", " ")
if err != nil {
return fmt.Errorf("Could not json encode config file : %v", err)
}
if err := wkfs.WriteFile(filePath, confData, 0600); err != nil {
return fmt.Errorf("Could not create or write default server config: %v", err)
}
return nil
} | go | func WriteDefaultConfigFile(filePath string, useSQLite bool) error {
conf := defaultBaseConfig
blobDir, err := osutil.CamliBlobRoot()
if err != nil {
return err
}
varDir, err := osutil.CamliVarDir()
if err != nil {
return err
}
if err := wkfs.MkdirAll(blobDir, 0700); err != nil {
return fmt.Errorf("Could not create default blobs directory: %v", err)
}
conf.BlobPath = blobDir
conf.PackRelated = true
if useSQLite {
conf.SQLite = filepath.Join(varDir, "index.sqlite")
} else {
conf.LevelDB = filepath.Join(varDir, "index.leveldb")
}
keyID, secretRing, err := getOrMakeKeyring()
if err != nil {
return err
}
conf.Identity = keyID
conf.IdentitySecretRing = secretRing
confData, err := json.MarshalIndent(conf, "", " ")
if err != nil {
return fmt.Errorf("Could not json encode config file : %v", err)
}
if err := wkfs.WriteFile(filePath, confData, 0600); err != nil {
return fmt.Errorf("Could not create or write default server config: %v", err)
}
return nil
} | [
"func",
"WriteDefaultConfigFile",
"(",
"filePath",
"string",
",",
"useSQLite",
"bool",
")",
"error",
"{",
"conf",
":=",
"defaultBaseConfig",
"\n",
"blobDir",
",",
"err",
":=",
"osutil",
".",
"CamliBlobRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"... | // WriteDefaultConfigFile generates a new default high-level server configuration
// file at filePath. If useSQLite, the default indexer will use SQLite, otherwise
// leveldb. If filePath already exists, it is overwritten. | [
"WriteDefaultConfigFile",
"generates",
"a",
"new",
"default",
"high",
"-",
"level",
"server",
"configuration",
"file",
"at",
"filePath",
".",
"If",
"useSQLite",
"the",
"default",
"indexer",
"will",
"use",
"SQLite",
"otherwise",
"leveldb",
".",
"If",
"filePath",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L1246-L1285 | train |
perkeep/perkeep | server/perkeepd/autodns.go | listenForCamliNet | func listenForCamliNet(ws *webserver.Server, config *serverinit.Config) (baseURL string, err error) {
camliNetIP := config.CamliNetIP()
if camliNetIP == "" {
return "", errors.New("no camliNetIP")
}
if ip := net.ParseIP(camliNetIP); ip == nil {
return "", fmt.Errorf("camliNetIP value %q is not a valid IP address", camliNetIP)
} else if ip.To4() == nil {
// TODO: support IPv6 when GCE supports IPv6: https://code.google.com/p/google-compute-engine/issues/detail?id=8
return "", errors.New("CamliNetIP should be an IPv4, as IPv6 is not yet supported on GCE")
}
challengeHostname := camliNetIP + gpgchallenge.SNISuffix
selfCert, selfKey, err := httputil.GenSelfTLS(challengeHostname)
if err != nil {
return "", fmt.Errorf("could not generate self-signed certificate: %v", err)
}
gpgchallengeCert, err := tls.X509KeyPair(selfCert, selfKey)
if err != nil {
return "", fmt.Errorf("could not load TLS certificate: %v", err)
}
_, keyId, err := config.KeyRingAndId()
if err != nil {
return "", fmt.Errorf("could not get keyId for camliNet hostname: %v", err)
}
// catch future length changes
if len(keyId) != 16 {
panic("length of GPG keyId is not 16 anymore")
}
shortKeyId := keyId[8:]
camliNetHostName = strings.ToLower(shortKeyId + "." + camliNetDomain)
m := autocert.Manager{
Prompt: autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist(camliNetHostName),
Cache: autocert.DirCache(osutil.DefaultLetsEncryptCache()),
}
go func() {
err := http.ListenAndServe(":http", m.HTTPHandler(nil))
log.Fatalf("Could not start server for http-01 challenge: %v", err)
}()
getCertificate := func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
if hello.ServerName == challengeHostname {
return &gpgchallengeCert, nil
}
return m.GetCertificate(hello)
}
log.Printf("TLS enabled, with Let's Encrypt for %v", camliNetHostName)
ws.SetTLS(webserver.TLSSetup{CertManager: getCertificate})
err = ws.Listen(fmt.Sprintf(":%d", gpgchallenge.ClientChallengedPort))
if err != nil {
return "", fmt.Errorf("Listen: %v", err)
}
return fmt.Sprintf("https://%s", camliNetHostName), nil
} | go | func listenForCamliNet(ws *webserver.Server, config *serverinit.Config) (baseURL string, err error) {
camliNetIP := config.CamliNetIP()
if camliNetIP == "" {
return "", errors.New("no camliNetIP")
}
if ip := net.ParseIP(camliNetIP); ip == nil {
return "", fmt.Errorf("camliNetIP value %q is not a valid IP address", camliNetIP)
} else if ip.To4() == nil {
// TODO: support IPv6 when GCE supports IPv6: https://code.google.com/p/google-compute-engine/issues/detail?id=8
return "", errors.New("CamliNetIP should be an IPv4, as IPv6 is not yet supported on GCE")
}
challengeHostname := camliNetIP + gpgchallenge.SNISuffix
selfCert, selfKey, err := httputil.GenSelfTLS(challengeHostname)
if err != nil {
return "", fmt.Errorf("could not generate self-signed certificate: %v", err)
}
gpgchallengeCert, err := tls.X509KeyPair(selfCert, selfKey)
if err != nil {
return "", fmt.Errorf("could not load TLS certificate: %v", err)
}
_, keyId, err := config.KeyRingAndId()
if err != nil {
return "", fmt.Errorf("could not get keyId for camliNet hostname: %v", err)
}
// catch future length changes
if len(keyId) != 16 {
panic("length of GPG keyId is not 16 anymore")
}
shortKeyId := keyId[8:]
camliNetHostName = strings.ToLower(shortKeyId + "." + camliNetDomain)
m := autocert.Manager{
Prompt: autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist(camliNetHostName),
Cache: autocert.DirCache(osutil.DefaultLetsEncryptCache()),
}
go func() {
err := http.ListenAndServe(":http", m.HTTPHandler(nil))
log.Fatalf("Could not start server for http-01 challenge: %v", err)
}()
getCertificate := func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
if hello.ServerName == challengeHostname {
return &gpgchallengeCert, nil
}
return m.GetCertificate(hello)
}
log.Printf("TLS enabled, with Let's Encrypt for %v", camliNetHostName)
ws.SetTLS(webserver.TLSSetup{CertManager: getCertificate})
err = ws.Listen(fmt.Sprintf(":%d", gpgchallenge.ClientChallengedPort))
if err != nil {
return "", fmt.Errorf("Listen: %v", err)
}
return fmt.Sprintf("https://%s", camliNetHostName), nil
} | [
"func",
"listenForCamliNet",
"(",
"ws",
"*",
"webserver",
".",
"Server",
",",
"config",
"*",
"serverinit",
".",
"Config",
")",
"(",
"baseURL",
"string",
",",
"err",
"error",
")",
"{",
"camliNetIP",
":=",
"config",
".",
"CamliNetIP",
"(",
")",
"\n",
"if",... | // listenForCamliNet prepares the TLS listener for both the GPG challenge, and
// for Let's Encrypt. It then starts listening and returns the baseURL derived from
// the hostname we should obtain from the GPG challenge. | [
"listenForCamliNet",
"prepares",
"the",
"TLS",
"listener",
"for",
"both",
"the",
"GPG",
"challenge",
"and",
"for",
"Let",
"s",
"Encrypt",
".",
"It",
"then",
"starts",
"listening",
"and",
"returns",
"the",
"baseURL",
"derived",
"from",
"the",
"hostname",
"we",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/autodns.go#L52-L105 | train |
perkeep/perkeep | pkg/gc/gc.go | markItem | func (c *Collector) markItem(ctx context.Context, it Item, isRoot bool) error {
if !isRoot {
marked, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if marked {
return nil
}
}
if err := c.Marker.Mark(it); err != nil {
return err
}
// FIXME(tgulacsi): is it a problem that we cannot cancel the parent?
ctx, cancel := context.WithCancel(ctx)
ch := make(chan Item, buffered)
var grp syncutil.Group
grp.Go(func() error {
return c.ItemEnumerator.EnumerateItem(ctx, it, ch)
})
grp.Go(func() error {
for it := range ch {
if err := c.markItem(ctx, it, false); err != nil {
return err
}
}
return nil
})
if err := grp.Err(); err != nil {
cancel()
return err
}
return nil
} | go | func (c *Collector) markItem(ctx context.Context, it Item, isRoot bool) error {
if !isRoot {
marked, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if marked {
return nil
}
}
if err := c.Marker.Mark(it); err != nil {
return err
}
// FIXME(tgulacsi): is it a problem that we cannot cancel the parent?
ctx, cancel := context.WithCancel(ctx)
ch := make(chan Item, buffered)
var grp syncutil.Group
grp.Go(func() error {
return c.ItemEnumerator.EnumerateItem(ctx, it, ch)
})
grp.Go(func() error {
for it := range ch {
if err := c.markItem(ctx, it, false); err != nil {
return err
}
}
return nil
})
if err := grp.Err(); err != nil {
cancel()
return err
}
return nil
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"markItem",
"(",
"ctx",
"context",
".",
"Context",
",",
"it",
"Item",
",",
"isRoot",
"bool",
")",
"error",
"{",
"if",
"!",
"isRoot",
"{",
"marked",
",",
"err",
":=",
"c",
".",
"Marker",
".",
"IsMarked",
"(",... | // ctx will be canceled on failure | [
"ctx",
"will",
"be",
"canceled",
"on",
"failure"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/gc/gc.go#L88-L122 | train |
perkeep/perkeep | pkg/gc/gc.go | Collect | func (c *Collector) Collect(ctx context.Context) (err error) {
if c.World == nil {
return errors.New("no World")
}
if c.Marker == nil {
return errors.New("no Marker")
}
if c.Roots == nil {
return errors.New("no Roots")
}
if c.Sweeper == nil {
return errors.New("no Sweeper")
}
if c.ItemEnumerator == nil {
return errors.New("no ItemEnumerator")
}
if c.Deleter == nil {
return errors.New("no Deleter")
}
if err := c.World.Stop(); err != nil {
return err
}
defer func() {
startErr := c.World.Start()
if err == nil {
err = startErr
}
}()
// Mark.
roots := make(chan Item, buffered)
markCtx, cancelMark := context.WithCancel(ctx)
var marker syncutil.Group
marker.Go(func() error {
defer cancelMark()
for it := range roots {
if err := c.markItem(markCtx, it, true); err != nil {
return err
}
}
return nil
})
marker.Go(func() error {
return c.Roots.Enumerate(markCtx, roots)
})
if err := marker.Err(); err != nil {
return fmt.Errorf("Mark failure: %v", err)
}
// Sweep.
all := make(chan Item, buffered)
sweepCtx, _ := context.WithCancel(ctx)
var sweeper syncutil.Group
sweeper.Go(func() error {
return c.Sweeper.Enumerate(sweepCtx, all)
})
sweeper.Go(func() error {
defer sweepCtx.Done()
for it := range all {
ok, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if !ok {
if err := c.Deleter.Delete(it); err != nil {
return err
}
}
}
return nil
})
if err := sweeper.Err(); err != nil {
return fmt.Errorf("Sweep failure: %v", err)
}
return nil
} | go | func (c *Collector) Collect(ctx context.Context) (err error) {
if c.World == nil {
return errors.New("no World")
}
if c.Marker == nil {
return errors.New("no Marker")
}
if c.Roots == nil {
return errors.New("no Roots")
}
if c.Sweeper == nil {
return errors.New("no Sweeper")
}
if c.ItemEnumerator == nil {
return errors.New("no ItemEnumerator")
}
if c.Deleter == nil {
return errors.New("no Deleter")
}
if err := c.World.Stop(); err != nil {
return err
}
defer func() {
startErr := c.World.Start()
if err == nil {
err = startErr
}
}()
// Mark.
roots := make(chan Item, buffered)
markCtx, cancelMark := context.WithCancel(ctx)
var marker syncutil.Group
marker.Go(func() error {
defer cancelMark()
for it := range roots {
if err := c.markItem(markCtx, it, true); err != nil {
return err
}
}
return nil
})
marker.Go(func() error {
return c.Roots.Enumerate(markCtx, roots)
})
if err := marker.Err(); err != nil {
return fmt.Errorf("Mark failure: %v", err)
}
// Sweep.
all := make(chan Item, buffered)
sweepCtx, _ := context.WithCancel(ctx)
var sweeper syncutil.Group
sweeper.Go(func() error {
return c.Sweeper.Enumerate(sweepCtx, all)
})
sweeper.Go(func() error {
defer sweepCtx.Done()
for it := range all {
ok, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if !ok {
if err := c.Deleter.Delete(it); err != nil {
return err
}
}
}
return nil
})
if err := sweeper.Err(); err != nil {
return fmt.Errorf("Sweep failure: %v", err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"Collect",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"if",
"c",
".",
"World",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"no World\"",
")",
"\n",
"}",
"\n",
"... | // Collect performs a garbage collection. | [
"Collect",
"performs",
"a",
"garbage",
"collection",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/gc/gc.go#L125-L200 | train |
perkeep/perkeep | pkg/sorted/buffer/buffer.go | New | func New(buffer, backing sorted.KeyValue, maxBufferBytes int64) *KeyValue {
return &KeyValue{
buf: buffer,
back: backing,
maxBuffer: maxBufferBytes,
}
} | go | func New(buffer, backing sorted.KeyValue, maxBufferBytes int64) *KeyValue {
return &KeyValue{
buf: buffer,
back: backing,
maxBuffer: maxBufferBytes,
}
} | [
"func",
"New",
"(",
"buffer",
",",
"backing",
"sorted",
".",
"KeyValue",
",",
"maxBufferBytes",
"int64",
")",
"*",
"KeyValue",
"{",
"return",
"&",
"KeyValue",
"{",
"buf",
":",
"buffer",
",",
"back",
":",
"backing",
",",
"maxBuffer",
":",
"maxBufferBytes",
... | // New returnes a sorted.KeyValue implementation that adds a Flush
// method to flush the buffer to the backing storage. A flush will
// also be performed when maxBufferBytes are reached. If
// maxBufferBytes <= 0, no automatic flushing is performed. | [
"New",
"returnes",
"a",
"sorted",
".",
"KeyValue",
"implementation",
"that",
"adds",
"a",
"Flush",
"method",
"to",
"flush",
"the",
"buffer",
"to",
"the",
"backing",
"storage",
".",
"A",
"flush",
"will",
"also",
"be",
"performed",
"when",
"maxBufferBytes",
"a... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/buffer/buffer.go#L35-L41 | train |
perkeep/perkeep | cmd/pk-put/kvcache.go | maybeRunCompaction | func maybeRunCompaction(dbname string, db *leveldb.DB) error {
val, err := db.GetProperty("leveldb.num-files-at-level0")
if err != nil {
return fmt.Errorf("could not get number of level-0 files of %v's LevelDB: %v", dbname, err)
}
nbFiles, err := strconv.Atoi(val)
if err != nil {
return fmt.Errorf("could not convert number of level-0 files to int: %v", err)
}
// Only force compaction if we're at the default trigger (4), see
// github.com/syndtr/goleveldb/leveldb/opt.DefaultCompactionL0Trigger
if nbFiles < 4 {
return nil
}
if err := db.CompactRange(util.Range{nil, nil}); err != nil {
return fmt.Errorf("could not run compaction on %v's LevelDB: %v", dbname, err)
}
return nil
} | go | func maybeRunCompaction(dbname string, db *leveldb.DB) error {
val, err := db.GetProperty("leveldb.num-files-at-level0")
if err != nil {
return fmt.Errorf("could not get number of level-0 files of %v's LevelDB: %v", dbname, err)
}
nbFiles, err := strconv.Atoi(val)
if err != nil {
return fmt.Errorf("could not convert number of level-0 files to int: %v", err)
}
// Only force compaction if we're at the default trigger (4), see
// github.com/syndtr/goleveldb/leveldb/opt.DefaultCompactionL0Trigger
if nbFiles < 4 {
return nil
}
if err := db.CompactRange(util.Range{nil, nil}); err != nil {
return fmt.Errorf("could not run compaction on %v's LevelDB: %v", dbname, err)
}
return nil
} | [
"func",
"maybeRunCompaction",
"(",
"dbname",
"string",
",",
"db",
"*",
"leveldb",
".",
"DB",
")",
"error",
"{",
"val",
",",
"err",
":=",
"db",
".",
"GetProperty",
"(",
"\"leveldb.num-files-at-level0\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // maybeRunCompaction forces compaction of db, if the number of
// tables in level 0 is >= 4. dbname should be provided for error messages. | [
"maybeRunCompaction",
"forces",
"compaction",
"of",
"db",
"if",
"the",
"number",
"of",
"tables",
"in",
"level",
"0",
"is",
">",
"=",
"4",
".",
"dbname",
"should",
"be",
"provided",
"for",
"error",
"messages",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/kvcache.go#L76-L94 | train |
perkeep/perkeep | cmd/pk-put/kvcache.go | marshalBinary | func (sk *statCacheKey) marshalBinary() ([]byte, error) {
if sk == nil {
return nil, errors.New("Can not marshal from a nil stat cache key")
}
data := make([]byte, 0, len(sk.Filepath)+3)
data = append(data, 1) // version number
data = append(data, sk.Filepath...)
data = append(data, '|')
if sk.Permanode {
data = append(data, 1)
}
return data, nil
} | go | func (sk *statCacheKey) marshalBinary() ([]byte, error) {
if sk == nil {
return nil, errors.New("Can not marshal from a nil stat cache key")
}
data := make([]byte, 0, len(sk.Filepath)+3)
data = append(data, 1) // version number
data = append(data, sk.Filepath...)
data = append(data, '|')
if sk.Permanode {
data = append(data, 1)
}
return data, nil
} | [
"func",
"(",
"sk",
"*",
"statCacheKey",
")",
"marshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"sk",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Can not marshal from a nil stat cache key\"",
")",
"\... | // marshalBinary returns a more compact binary
// representation of the contents of sk. | [
"marshalBinary",
"returns",
"a",
"more",
"compact",
"binary",
"representation",
"of",
"the",
"contents",
"of",
"sk",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/kvcache.go#L234-L246 | train |
perkeep/perkeep | cmd/pk-put/kvcache.go | marshalBinary | func (scv *statCacheValue) marshalBinary() ([]byte, error) {
if scv == nil {
return nil, errors.New("Can not marshal from a nil stat cache value")
}
binBr, _ := scv.Result.BlobRef.MarshalBinary()
// Blob size fits on 4 bytes when binary encoded
data := make([]byte, 0, len(scv.Fingerprint)+1+4+1+len(binBr))
buf := bytes.NewBuffer(data)
_, err := buf.WriteString(string(scv.Fingerprint))
if err != nil {
return nil, fmt.Errorf("Could not write fingerprint %v: %v", scv.Fingerprint, err)
}
err = buf.WriteByte('|')
if err != nil {
return nil, fmt.Errorf("Could not write '|': %v", err)
}
err = binary.Write(buf, binary.BigEndian, int32(scv.Result.Size))
if err != nil {
return nil, fmt.Errorf("Could not write blob size %d: %v", scv.Result.Size, err)
}
err = buf.WriteByte('|')
if err != nil {
return nil, fmt.Errorf("Could not write '|': %v", err)
}
_, err = buf.Write(binBr)
if err != nil {
return nil, fmt.Errorf("Could not write binary blobref %q: %v", binBr, err)
}
return buf.Bytes(), nil
} | go | func (scv *statCacheValue) marshalBinary() ([]byte, error) {
if scv == nil {
return nil, errors.New("Can not marshal from a nil stat cache value")
}
binBr, _ := scv.Result.BlobRef.MarshalBinary()
// Blob size fits on 4 bytes when binary encoded
data := make([]byte, 0, len(scv.Fingerprint)+1+4+1+len(binBr))
buf := bytes.NewBuffer(data)
_, err := buf.WriteString(string(scv.Fingerprint))
if err != nil {
return nil, fmt.Errorf("Could not write fingerprint %v: %v", scv.Fingerprint, err)
}
err = buf.WriteByte('|')
if err != nil {
return nil, fmt.Errorf("Could not write '|': %v", err)
}
err = binary.Write(buf, binary.BigEndian, int32(scv.Result.Size))
if err != nil {
return nil, fmt.Errorf("Could not write blob size %d: %v", scv.Result.Size, err)
}
err = buf.WriteByte('|')
if err != nil {
return nil, fmt.Errorf("Could not write '|': %v", err)
}
_, err = buf.Write(binBr)
if err != nil {
return nil, fmt.Errorf("Could not write binary blobref %q: %v", binBr, err)
}
return buf.Bytes(), nil
} | [
"func",
"(",
"scv",
"*",
"statCacheValue",
")",
"marshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"scv",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Can not marshal from a nil stat cache value\"",
")"... | // marshalBinary returns a more compact binary
// representation of the contents of scv. | [
"marshalBinary",
"returns",
"a",
"more",
"compact",
"binary",
"representation",
"of",
"the",
"contents",
"of",
"scv",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/kvcache.go#L257-L286 | train |
perkeep/perkeep | internal/osutil/restart_unix.go | RestartProcess | func RestartProcess(arg ...string) error {
path, err := SelfPath()
if err != nil {
return fmt.Errorf("RestartProcess failed: %v", err)
}
var args []string
if len(arg) > 0 {
args = append(args, os.Args[0])
for _, v := range arg {
args = append(args, v)
}
} else {
args = os.Args
}
return syscall.Exec(path, args, os.Environ())
} | go | func RestartProcess(arg ...string) error {
path, err := SelfPath()
if err != nil {
return fmt.Errorf("RestartProcess failed: %v", err)
}
var args []string
if len(arg) > 0 {
args = append(args, os.Args[0])
for _, v := range arg {
args = append(args, v)
}
} else {
args = os.Args
}
return syscall.Exec(path, args, os.Environ())
} | [
"func",
"RestartProcess",
"(",
"arg",
"...",
"string",
")",
"error",
"{",
"path",
",",
"err",
":=",
"SelfPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"RestartProcess failed: %v\"",
",",
"err",
")",
"\n",
... | // RestartProcess restarts the process with the given arguments, if any,
// replacing the original process's arguments. It defaults to os.Args otherwise. It
// returns an error if things couldn't be restarted. On success, this function
// never returns because the process becomes the new process. | [
"RestartProcess",
"restarts",
"the",
"process",
"with",
"the",
"given",
"arguments",
"if",
"any",
"replacing",
"the",
"original",
"process",
"s",
"arguments",
".",
"It",
"defaults",
"to",
"os",
".",
"Args",
"otherwise",
".",
"It",
"returns",
"an",
"error",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/restart_unix.go#L63-L80 | train |
perkeep/perkeep | misc/docker/dock.go | buildDockerImage | func buildDockerImage(imageDir, imageName string) {
if dockDir == "" {
panic("dockDir should be set before calling buildDockerImage")
}
cmd := exec.Command("docker", "build", "-t", imageName, ".")
cmd.Dir = filepath.Join(dockDir, imageDir)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatalf("Error building docker image %v: %v", imageName, err)
}
} | go | func buildDockerImage(imageDir, imageName string) {
if dockDir == "" {
panic("dockDir should be set before calling buildDockerImage")
}
cmd := exec.Command("docker", "build", "-t", imageName, ".")
cmd.Dir = filepath.Join(dockDir, imageDir)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatalf("Error building docker image %v: %v", imageName, err)
}
} | [
"func",
"buildDockerImage",
"(",
"imageDir",
",",
"imageName",
"string",
")",
"{",
"if",
"dockDir",
"==",
"\"\"",
"{",
"panic",
"(",
"\"dockDir should be set before calling buildDockerImage\"",
")",
"\n",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"d... | // buildDockerImage builds a docker image from the Dockerfile located in
// imageDir, which is a path relative to dockDir. The image will be named after
// imageName. dockDir should have been set behorehand. | [
"buildDockerImage",
"builds",
"a",
"docker",
"image",
"from",
"the",
"Dockerfile",
"located",
"in",
"imageDir",
"which",
"is",
"a",
"path",
"relative",
"to",
"dockDir",
".",
"The",
"image",
"will",
"be",
"named",
"after",
"imageName",
".",
"dockDir",
"should",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/misc/docker/dock.go#L54-L65 | train |
perkeep/perkeep | pkg/blobserver/mergedenum.go | MergedEnumerate | func MergedEnumerate(ctx context.Context, dest chan<- blob.SizedRef, sources []BlobEnumerator, after string, limit int) error {
return mergedEnumerate(ctx, dest, len(sources), func(i int) BlobEnumerator { return sources[i] }, after, limit)
} | go | func MergedEnumerate(ctx context.Context, dest chan<- blob.SizedRef, sources []BlobEnumerator, after string, limit int) error {
return mergedEnumerate(ctx, dest, len(sources), func(i int) BlobEnumerator { return sources[i] }, after, limit)
} | [
"func",
"MergedEnumerate",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"sources",
"[",
"]",
"BlobEnumerator",
",",
"after",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"return",
"mergedEnumerate",
"... | // MergedEnumerate implements the BlobEnumerator interface by
// merge-joining 0 or more sources. | [
"MergedEnumerate",
"implements",
"the",
"BlobEnumerator",
"interface",
"by",
"merge",
"-",
"joining",
"0",
"or",
"more",
"sources",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/mergedenum.go#L29-L31 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | NewOAuthConfig | func NewOAuthConfig(clientID, clientSecret string) *oauth2.Config {
return &oauth2.Config{
Scopes: []string{
logging.WriteScope,
compute.DevstorageFullControlScope,
compute.ComputeScope,
cloudresourcemanager.CloudPlatformScope,
servicemanagement.CloudPlatformScope,
"https://www.googleapis.com/auth/sqlservice",
"https://www.googleapis.com/auth/sqlservice.admin",
},
Endpoint: google.Endpoint,
ClientID: clientID,
ClientSecret: clientSecret,
}
} | go | func NewOAuthConfig(clientID, clientSecret string) *oauth2.Config {
return &oauth2.Config{
Scopes: []string{
logging.WriteScope,
compute.DevstorageFullControlScope,
compute.ComputeScope,
cloudresourcemanager.CloudPlatformScope,
servicemanagement.CloudPlatformScope,
"https://www.googleapis.com/auth/sqlservice",
"https://www.googleapis.com/auth/sqlservice.admin",
},
Endpoint: google.Endpoint,
ClientID: clientID,
ClientSecret: clientSecret,
}
} | [
"func",
"NewOAuthConfig",
"(",
"clientID",
",",
"clientSecret",
"string",
")",
"*",
"oauth2",
".",
"Config",
"{",
"return",
"&",
"oauth2",
".",
"Config",
"{",
"Scopes",
":",
"[",
"]",
"string",
"{",
"logging",
".",
"WriteScope",
",",
"compute",
".",
"Dev... | // NewOAuthConfig returns an OAuth configuration template. | [
"NewOAuthConfig",
"returns",
"an",
"OAuth",
"configuration",
"template",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L83-L98 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | Get | func (d *Deployer) Get() (*compute.Instance, error) {
computeService, err := compute.New(d.Client)
if err != nil {
return nil, err
}
return computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
} | go | func (d *Deployer) Get() (*compute.Instance, error) {
computeService, err := compute.New(d.Client)
if err != nil {
return nil, err
}
return computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"Get",
"(",
")",
"(",
"*",
"compute",
".",
"Instance",
",",
"error",
")",
"{",
"computeService",
",",
"err",
":=",
"compute",
".",
"New",
"(",
"d",
".",
"Client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Get returns the Instance corresponding to the Project, Zone, and Name defined in the
// Deployer's Conf. | [
"Get",
"returns",
"the",
"Instance",
"corresponding",
"to",
"the",
"Project",
"Zone",
"and",
"Name",
"defined",
"in",
"the",
"Deployer",
"s",
"Conf",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L138-L144 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | projectHasInstance | func (d *Deployer) projectHasInstance() (zone string, err error) {
s, err := compute.New(d.Client)
if err != nil {
return "", err
}
// TODO(mpl): make use of the handler's cached zones.
zl, err := compute.NewZonesService(s).List(d.Conf.Project).Do()
if err != nil {
return "", fmt.Errorf("could not get a list of zones: %v", err)
}
computeService, _ := compute.New(d.Client)
var zoneOnce sync.Once
var grp syncutil.Group
errc := make(chan error, 1)
zonec := make(chan string, 1)
timeout := time.NewTimer(30 * time.Second)
defer timeout.Stop()
for _, z := range zl.Items {
z := z
grp.Go(func() error {
list, err := computeService.Instances.List(d.Conf.Project, z.Name).Do()
if err != nil {
return fmt.Errorf("could not list existing instances: %v", err)
}
if len(list.Items) > 0 {
zoneOnce.Do(func() {
zonec <- z.Name
})
}
return nil
})
}
go func() {
errc <- grp.Err()
}()
// We block until either an instance was found in a zone, or all the instance
// listing is done. Or we timed-out.
select {
case err = <-errc:
return "", err
case zone = <-zonec:
// We voluntarily ignore any listing error if we found at least one instance
// because that's what we primarily want to report about.
return zone, nil
case <-timeout.C:
return "", errors.New("timed out")
}
} | go | func (d *Deployer) projectHasInstance() (zone string, err error) {
s, err := compute.New(d.Client)
if err != nil {
return "", err
}
// TODO(mpl): make use of the handler's cached zones.
zl, err := compute.NewZonesService(s).List(d.Conf.Project).Do()
if err != nil {
return "", fmt.Errorf("could not get a list of zones: %v", err)
}
computeService, _ := compute.New(d.Client)
var zoneOnce sync.Once
var grp syncutil.Group
errc := make(chan error, 1)
zonec := make(chan string, 1)
timeout := time.NewTimer(30 * time.Second)
defer timeout.Stop()
for _, z := range zl.Items {
z := z
grp.Go(func() error {
list, err := computeService.Instances.List(d.Conf.Project, z.Name).Do()
if err != nil {
return fmt.Errorf("could not list existing instances: %v", err)
}
if len(list.Items) > 0 {
zoneOnce.Do(func() {
zonec <- z.Name
})
}
return nil
})
}
go func() {
errc <- grp.Err()
}()
// We block until either an instance was found in a zone, or all the instance
// listing is done. Or we timed-out.
select {
case err = <-errc:
return "", err
case zone = <-zonec:
// We voluntarily ignore any listing error if we found at least one instance
// because that's what we primarily want to report about.
return zone, nil
case <-timeout.C:
return "", errors.New("timed out")
}
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"projectHasInstance",
"(",
")",
"(",
"zone",
"string",
",",
"err",
"error",
")",
"{",
"s",
",",
"err",
":=",
"compute",
".",
"New",
"(",
"d",
".",
"Client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return... | // projectHasInstance checks for all the possible zones if there's already an instance for the project.
// It returns the name of the zone at the first instance it finds, if any. | [
"projectHasInstance",
"checks",
"for",
"all",
"the",
"possible",
"zones",
"if",
"there",
"s",
"already",
"an",
"instance",
"for",
"the",
"project",
".",
"It",
"returns",
"the",
"name",
"of",
"the",
"zone",
"at",
"the",
"first",
"instance",
"it",
"finds",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L169-L216 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | getInstanceAttribute | func (d *Deployer) getInstanceAttribute(attr string) (string, error) {
s, err := compute.New(d.Client)
if err != nil {
return "", fmt.Errorf("error getting compute service: %v", err)
}
inst, err := compute.NewInstancesService(s).Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return "", fmt.Errorf("error getting instance: %v", err)
}
for _, v := range inst.Metadata.Items {
if v.Key == attr {
return *(v.Value), nil
}
}
return "", errAttrNotFound
} | go | func (d *Deployer) getInstanceAttribute(attr string) (string, error) {
s, err := compute.New(d.Client)
if err != nil {
return "", fmt.Errorf("error getting compute service: %v", err)
}
inst, err := compute.NewInstancesService(s).Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return "", fmt.Errorf("error getting instance: %v", err)
}
for _, v := range inst.Metadata.Items {
if v.Key == attr {
return *(v.Value), nil
}
}
return "", errAttrNotFound
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"getInstanceAttribute",
"(",
"attr",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"compute",
".",
"New",
"(",
"d",
".",
"Client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r... | // getInstanceAttribute returns the value for attr in the custom metadata of the
// instance. It returns errAttrNotFound is such a metadata attributed does not
// exist. | [
"getInstanceAttribute",
"returns",
"the",
"value",
"for",
"attr",
"in",
"the",
"custom",
"metadata",
"of",
"the",
"instance",
".",
"It",
"returns",
"errAttrNotFound",
"is",
"such",
"a",
"metadata",
"attributed",
"does",
"not",
"exist",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L455-L470 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | Create | func (d *Deployer) Create(ctx context.Context) (*compute.Instance, error) {
if err := d.enableAPIs(); err != nil {
return nil, projectIDError{
id: d.Conf.Project,
cause: err,
}
}
if err := d.checkProjectID(); err != nil {
return nil, err
}
computeService, _ := compute.New(d.Client)
storageService, _ := storage.New(d.Client)
fwc := make(chan error, 1)
go func() {
fwc <- d.setFirewall(ctx, computeService)
}()
config := cloudConfig(d.Conf)
const maxCloudConfig = 32 << 10 // per compute API docs
if len(config) > maxCloudConfig {
return nil, fmt.Errorf("cloud config length of %d bytes is over %d byte limit", len(config), maxCloudConfig)
}
if zone, err := d.projectHasInstance(); zone != "" {
return nil, instanceExistsError{
project: d.Conf.Project,
zone: zone,
}
} else if err != nil {
return nil, fmt.Errorf("could not scan project for existing instances: %v", err)
}
if err := d.setBuckets(ctx, storageService); err != nil {
return nil, fmt.Errorf("could not create buckets: %v", err)
}
if err := d.createInstance(ctx, computeService); err != nil {
return nil, fmt.Errorf("could not create compute instance: %v", err)
}
inst, err := computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return nil, fmt.Errorf("error getting instance after creation: %v", err)
}
if Verbose {
ij, _ := json.MarshalIndent(inst, "", " ")
d.Printf("Instance: %s", ij)
}
if err = <-fwc; err != nil {
return nil, fmt.Errorf("could not create firewall rules: %v", err)
}
return inst, nil
} | go | func (d *Deployer) Create(ctx context.Context) (*compute.Instance, error) {
if err := d.enableAPIs(); err != nil {
return nil, projectIDError{
id: d.Conf.Project,
cause: err,
}
}
if err := d.checkProjectID(); err != nil {
return nil, err
}
computeService, _ := compute.New(d.Client)
storageService, _ := storage.New(d.Client)
fwc := make(chan error, 1)
go func() {
fwc <- d.setFirewall(ctx, computeService)
}()
config := cloudConfig(d.Conf)
const maxCloudConfig = 32 << 10 // per compute API docs
if len(config) > maxCloudConfig {
return nil, fmt.Errorf("cloud config length of %d bytes is over %d byte limit", len(config), maxCloudConfig)
}
if zone, err := d.projectHasInstance(); zone != "" {
return nil, instanceExistsError{
project: d.Conf.Project,
zone: zone,
}
} else if err != nil {
return nil, fmt.Errorf("could not scan project for existing instances: %v", err)
}
if err := d.setBuckets(ctx, storageService); err != nil {
return nil, fmt.Errorf("could not create buckets: %v", err)
}
if err := d.createInstance(ctx, computeService); err != nil {
return nil, fmt.Errorf("could not create compute instance: %v", err)
}
inst, err := computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return nil, fmt.Errorf("error getting instance after creation: %v", err)
}
if Verbose {
ij, _ := json.MarshalIndent(inst, "", " ")
d.Printf("Instance: %s", ij)
}
if err = <-fwc; err != nil {
return nil, fmt.Errorf("could not create firewall rules: %v", err)
}
return inst, nil
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"compute",
".",
"Instance",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"enableAPIs",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return... | // Create sets up and starts a Google Compute Engine instance as defined in d.Conf. It
// creates the necessary Google Storage buckets beforehand. | [
"Create",
"sets",
"up",
"and",
"starts",
"a",
"Google",
"Compute",
"Engine",
"instance",
"as",
"defined",
"in",
"d",
".",
"Conf",
".",
"It",
"creates",
"the",
"necessary",
"Google",
"Storage",
"buckets",
"beforehand",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L474-L529 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | setBuckets | func (d *Deployer) setBuckets(ctx context.Context, storageService *storage.Service) error {
projBucket := d.Conf.Project + "-camlistore"
needBucket := map[string]bool{
projBucket: true,
}
buckets, err := storageService.Buckets.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing buckets: %v", err)
}
for _, it := range buckets.Items {
delete(needBucket, it.Name)
}
if len(needBucket) > 0 {
if Verbose {
d.Printf("Need to create buckets: %v", needBucket)
}
var waitBucket sync.WaitGroup
var bucketErr error
for name := range needBucket {
select {
case <-ctx.Done():
return ctx.Err()
default:
}
name := name
waitBucket.Add(1)
go func() {
defer waitBucket.Done()
if Verbose {
d.Printf("Creating bucket %s", name)
}
b, err := storageService.Buckets.Insert(d.Conf.Project, &storage.Bucket{
Id: name,
Name: name,
}).Do()
if err != nil && bucketErr == nil {
bucketErr = fmt.Errorf("error creating bucket %s: %v", name, err)
return
}
if Verbose {
d.Printf("Created bucket %s: %+v", name, b)
}
}()
}
waitBucket.Wait()
if bucketErr != nil {
return bucketErr
}
}
d.Conf.configDir = path.Join(projBucket, configDir)
d.Conf.blobDir = path.Join(projBucket, "blobs")
return nil
} | go | func (d *Deployer) setBuckets(ctx context.Context, storageService *storage.Service) error {
projBucket := d.Conf.Project + "-camlistore"
needBucket := map[string]bool{
projBucket: true,
}
buckets, err := storageService.Buckets.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing buckets: %v", err)
}
for _, it := range buckets.Items {
delete(needBucket, it.Name)
}
if len(needBucket) > 0 {
if Verbose {
d.Printf("Need to create buckets: %v", needBucket)
}
var waitBucket sync.WaitGroup
var bucketErr error
for name := range needBucket {
select {
case <-ctx.Done():
return ctx.Err()
default:
}
name := name
waitBucket.Add(1)
go func() {
defer waitBucket.Done()
if Verbose {
d.Printf("Creating bucket %s", name)
}
b, err := storageService.Buckets.Insert(d.Conf.Project, &storage.Bucket{
Id: name,
Name: name,
}).Do()
if err != nil && bucketErr == nil {
bucketErr = fmt.Errorf("error creating bucket %s: %v", name, err)
return
}
if Verbose {
d.Printf("Created bucket %s: %+v", name, b)
}
}()
}
waitBucket.Wait()
if bucketErr != nil {
return bucketErr
}
}
d.Conf.configDir = path.Join(projBucket, configDir)
d.Conf.blobDir = path.Join(projBucket, "blobs")
return nil
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"setBuckets",
"(",
"ctx",
"context",
".",
"Context",
",",
"storageService",
"*",
"storage",
".",
"Service",
")",
"error",
"{",
"projBucket",
":=",
"d",
".",
"Conf",
".",
"Project",
"+",
"\"-camlistore\"",
"\n",
"ne... | // setBuckets defines the buckets needed by the instance and creates them. | [
"setBuckets",
"defines",
"the",
"buckets",
"needed",
"by",
"the",
"instance",
"and",
"creates",
"them",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L708-L763 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | setFirewall | func (d *Deployer) setFirewall(ctx context.Context, computeService *compute.Service) error {
defaultNet, err := computeService.Networks.Get(d.Conf.Project, "default").Do()
if err != nil {
return fmt.Errorf("error getting default network: %v", err)
}
needRules := map[string]compute.Firewall{
"default-allow-http": {
Name: "default-allow-http",
SourceRanges: []string{"0.0.0.0/0"},
SourceTags: []string{"http-server"},
Allowed: []*compute.FirewallAllowed{{IPProtocol: "tcp", Ports: []string{"80"}}},
Network: defaultNet.SelfLink,
},
"default-allow-https": {
Name: "default-allow-https",
SourceRanges: []string{"0.0.0.0/0"},
SourceTags: []string{"https-server"},
Allowed: []*compute.FirewallAllowed{{IPProtocol: "tcp", Ports: []string{"443"}}},
Network: defaultNet.SelfLink,
},
}
rules, err := computeService.Firewalls.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing rules: %v", err)
}
for _, it := range rules.Items {
delete(needRules, it.Name)
}
if len(needRules) == 0 {
return nil
}
if Verbose {
d.Printf("Need to create rules: %v", needRules)
}
var wg syncutil.Group
for name, rule := range needRules {
select {
case <-ctx.Done():
return ctx.Err()
default:
}
name, rule := name, rule
wg.Go(func() error {
if Verbose {
d.Printf("Creating rule %s", name)
}
r, err := computeService.Firewalls.Insert(d.Conf.Project, &rule).Do()
if err != nil {
return fmt.Errorf("error creating rule %s: %v", name, err)
}
if Verbose {
d.Printf("Created rule %s: %+v", name, r)
}
return nil
})
}
return wg.Err()
} | go | func (d *Deployer) setFirewall(ctx context.Context, computeService *compute.Service) error {
defaultNet, err := computeService.Networks.Get(d.Conf.Project, "default").Do()
if err != nil {
return fmt.Errorf("error getting default network: %v", err)
}
needRules := map[string]compute.Firewall{
"default-allow-http": {
Name: "default-allow-http",
SourceRanges: []string{"0.0.0.0/0"},
SourceTags: []string{"http-server"},
Allowed: []*compute.FirewallAllowed{{IPProtocol: "tcp", Ports: []string{"80"}}},
Network: defaultNet.SelfLink,
},
"default-allow-https": {
Name: "default-allow-https",
SourceRanges: []string{"0.0.0.0/0"},
SourceTags: []string{"https-server"},
Allowed: []*compute.FirewallAllowed{{IPProtocol: "tcp", Ports: []string{"443"}}},
Network: defaultNet.SelfLink,
},
}
rules, err := computeService.Firewalls.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing rules: %v", err)
}
for _, it := range rules.Items {
delete(needRules, it.Name)
}
if len(needRules) == 0 {
return nil
}
if Verbose {
d.Printf("Need to create rules: %v", needRules)
}
var wg syncutil.Group
for name, rule := range needRules {
select {
case <-ctx.Done():
return ctx.Err()
default:
}
name, rule := name, rule
wg.Go(func() error {
if Verbose {
d.Printf("Creating rule %s", name)
}
r, err := computeService.Firewalls.Insert(d.Conf.Project, &rule).Do()
if err != nil {
return fmt.Errorf("error creating rule %s: %v", name, err)
}
if Verbose {
d.Printf("Created rule %s: %+v", name, r)
}
return nil
})
}
return wg.Err()
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"setFirewall",
"(",
"ctx",
"context",
".",
"Context",
",",
"computeService",
"*",
"compute",
".",
"Service",
")",
"error",
"{",
"defaultNet",
",",
"err",
":=",
"computeService",
".",
"Networks",
".",
"Get",
"(",
"d... | // setFirewall adds the firewall rules needed for ports 80 & 433 to the default network. | [
"setFirewall",
"adds",
"the",
"firewall",
"rules",
"needed",
"for",
"ports",
"80",
"&",
"433",
"to",
"the",
"default",
"network",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L766-L826 | train |
perkeep/perkeep | pkg/webserver/webserver.go | loadX509KeyPair | func loadX509KeyPair(certFile, keyFile string) (cert tls.Certificate, err error) {
certPEMBlock, err := wkfs.ReadFile(certFile)
if err != nil {
return
}
keyPEMBlock, err := wkfs.ReadFile(keyFile)
if err != nil {
return
}
return tls.X509KeyPair(certPEMBlock, keyPEMBlock)
} | go | func loadX509KeyPair(certFile, keyFile string) (cert tls.Certificate, err error) {
certPEMBlock, err := wkfs.ReadFile(certFile)
if err != nil {
return
}
keyPEMBlock, err := wkfs.ReadFile(keyFile)
if err != nil {
return
}
return tls.X509KeyPair(certPEMBlock, keyPEMBlock)
} | [
"func",
"loadX509KeyPair",
"(",
"certFile",
",",
"keyFile",
"string",
")",
"(",
"cert",
"tls",
".",
"Certificate",
",",
"err",
"error",
")",
"{",
"certPEMBlock",
",",
"err",
":=",
"wkfs",
".",
"ReadFile",
"(",
"certFile",
")",
"\n",
"if",
"err",
"!=",
... | // loadX509KeyPair is a copy of tls.LoadX509KeyPair but using wkfs. | [
"loadX509KeyPair",
"is",
"a",
"copy",
"of",
"tls",
".",
"LoadX509KeyPair",
"but",
"using",
"wkfs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/webserver/webserver.go#L277-L287 | train |
perkeep/perkeep | internal/httputil/httputil.go | RequestTargetPort | func RequestTargetPort(req *http.Request) int {
_, portStr, err := net.SplitHostPort(req.Host)
if err == nil && portStr != "" {
port, err := strconv.ParseInt(portStr, 0, 64)
if err == nil {
return int(port)
}
}
if req.TLS != nil {
return 443
}
return 80
} | go | func RequestTargetPort(req *http.Request) int {
_, portStr, err := net.SplitHostPort(req.Host)
if err == nil && portStr != "" {
port, err := strconv.ParseInt(portStr, 0, 64)
if err == nil {
return int(port)
}
}
if req.TLS != nil {
return 443
}
return 80
} | [
"func",
"RequestTargetPort",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"int",
"{",
"_",
",",
"portStr",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"req",
".",
"Host",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"portStr",
"!=",
"\"\"",
... | // RequestTargetPort returns the port targeted by the client
// in req. If not present, it returns 80, or 443 if TLS is used. | [
"RequestTargetPort",
"returns",
"the",
"port",
"targeted",
"by",
"the",
"client",
"in",
"req",
".",
"If",
"not",
"present",
"it",
"returns",
"80",
"or",
"443",
"if",
"TLS",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L153-L165 | train |
perkeep/perkeep | internal/httputil/httputil.go | RecoverJSON | func RecoverJSON(rw http.ResponseWriter, req *http.Request) {
e := recover()
if e == nil {
return
}
ServeJSONError(rw, e)
} | go | func RecoverJSON(rw http.ResponseWriter, req *http.Request) {
e := recover()
if e == nil {
return
}
ServeJSONError(rw, e)
} | [
"func",
"RecoverJSON",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"e",
":=",
"recover",
"(",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"ServeJSONError",
"(",
"rw",
",",
"e",... | // RecoverJSON is like Recover but returns with a JSON response. | [
"RecoverJSON",
"is",
"like",
"Recover",
"but",
"returns",
"with",
"a",
"JSON",
"response",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L182-L188 | train |
perkeep/perkeep | internal/httputil/httputil.go | MustGetBlobRef | func MustGetBlobRef(req *http.Request, param string) blob.Ref {
br, ok := blob.Parse(MustGet(req, param))
if !ok {
panic(InvalidParameterError(param))
}
return br
} | go | func MustGetBlobRef(req *http.Request, param string) blob.Ref {
br, ok := blob.Parse(MustGet(req, param))
if !ok {
panic(InvalidParameterError(param))
}
return br
} | [
"func",
"MustGetBlobRef",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"param",
"string",
")",
"blob",
".",
"Ref",
"{",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"MustGet",
"(",
"req",
",",
"param",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
... | // MustGetBlobRef returns a non-nil BlobRef from req, as given by param.
// If it doesn't, it panics with a value understood by Recover or RecoverJSON. | [
"MustGetBlobRef",
"returns",
"a",
"non",
"-",
"nil",
"BlobRef",
"from",
"req",
"as",
"given",
"by",
"param",
".",
"If",
"it",
"doesn",
"t",
"it",
"panics",
"with",
"a",
"value",
"understood",
"by",
"Recover",
"or",
"RecoverJSON",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L236-L242 | train |
perkeep/perkeep | internal/httputil/httputil.go | OptionalInt | func OptionalInt(req *http.Request, param string) int {
v := req.FormValue(param)
if v == "" {
return 0
}
i, err := strconv.Atoi(v)
if err != nil {
panic(InvalidParameterError(param))
}
return i
} | go | func OptionalInt(req *http.Request, param string) int {
v := req.FormValue(param)
if v == "" {
return 0
}
i, err := strconv.Atoi(v)
if err != nil {
panic(InvalidParameterError(param))
}
return i
} | [
"func",
"OptionalInt",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"param",
"string",
")",
"int",
"{",
"v",
":=",
"req",
".",
"FormValue",
"(",
"param",
")",
"\n",
"if",
"v",
"==",
"\"\"",
"{",
"return",
"0",
"\n",
"}",
"\n",
"i",
",",
"err",
... | // OptionalInt returns the integer in req given by param, or 0 if not present.
// If the form value is not an integer, it panics with a a value understood by Recover or RecoverJSON. | [
"OptionalInt",
"returns",
"the",
"integer",
"in",
"req",
"given",
"by",
"param",
"or",
"0",
"if",
"not",
"present",
".",
"If",
"the",
"form",
"value",
"is",
"not",
"an",
"integer",
"it",
"panics",
"with",
"a",
"a",
"value",
"understood",
"by",
"Recover",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L246-L256 | train |
perkeep/perkeep | pkg/server/download.go | fileInfoPacked | func fileInfoPacked(ctx context.Context, sh *search.Handler, src blob.Fetcher, r *http.Request, file blob.Ref) (packFileInfo fileInfo, ok bool) {
if sh == nil {
return fileInfo{whyNot: "no search"}, false
}
wf, ok := src.(blobserver.WholeRefFetcher)
if !ok {
return fileInfo{whyNot: "fetcher type"}, false
}
if r != nil && r.Header.Get("Range") != "" {
// TODO: not handled yet. Maybe not even important,
// considering rarity.
return fileInfo{whyNot: "range header"}, false
}
des, err := sh.Describe(ctx, &search.DescribeRequest{BlobRef: file})
if err != nil {
log.Printf("ui: fileInfoPacked: skipping fast path due to error from search: %v", err)
return fileInfo{whyNot: "search error"}, false
}
db, ok := des.Meta[file.String()]
if !ok || db.File == nil {
return fileInfo{whyNot: "search index doesn't know file"}, false
}
fi := db.File
if !fi.WholeRef.Valid() {
return fileInfo{whyNot: "no wholeref from search index"}, false
}
offset := int64(0)
rc, wholeSize, err := wf.OpenWholeRef(fi.WholeRef, offset)
if err == os.ErrNotExist {
return fileInfo{whyNot: "WholeRefFetcher returned ErrNotexist"}, false
}
if wholeSize != fi.Size {
log.Printf("ui: fileInfoPacked: OpenWholeRef size %d != index size %d; ignoring fast path", wholeSize, fi.Size)
return fileInfo{whyNot: "WholeRefFetcher and index don't agree"}, false
}
if err != nil {
log.Printf("ui: fileInfoPacked: skipping fast path due to error from WholeRefFetcher (%T): %v", src, err)
return fileInfo{whyNot: "WholeRefFetcher error"}, false
}
modtime := fi.ModTime
if modtime.IsAnyZero() {
modtime = fi.Time
}
// TODO(mpl): it'd be nicer to get the FileMode from the describe response,
// instead of having to fetch the file schema again, but we don't index the
// FileMode for now, so it's not just a matter of adding the FileMode to
// camtypes.FileInfo
fr, err := schema.NewFileReader(ctx, src, file)
fr.Close()
if err != nil {
return fileInfo{whyNot: fmt.Sprintf("cannot open a file reader: %v", err)}, false
}
return fileInfo{
mime: fi.MIMEType,
name: fi.FileName,
size: fi.Size,
modtime: modtime.Time(),
mode: fr.FileMode(),
rs: readerutil.NewFakeSeeker(rc, fi.Size-offset),
close: rc.Close,
}, true
} | go | func fileInfoPacked(ctx context.Context, sh *search.Handler, src blob.Fetcher, r *http.Request, file blob.Ref) (packFileInfo fileInfo, ok bool) {
if sh == nil {
return fileInfo{whyNot: "no search"}, false
}
wf, ok := src.(blobserver.WholeRefFetcher)
if !ok {
return fileInfo{whyNot: "fetcher type"}, false
}
if r != nil && r.Header.Get("Range") != "" {
// TODO: not handled yet. Maybe not even important,
// considering rarity.
return fileInfo{whyNot: "range header"}, false
}
des, err := sh.Describe(ctx, &search.DescribeRequest{BlobRef: file})
if err != nil {
log.Printf("ui: fileInfoPacked: skipping fast path due to error from search: %v", err)
return fileInfo{whyNot: "search error"}, false
}
db, ok := des.Meta[file.String()]
if !ok || db.File == nil {
return fileInfo{whyNot: "search index doesn't know file"}, false
}
fi := db.File
if !fi.WholeRef.Valid() {
return fileInfo{whyNot: "no wholeref from search index"}, false
}
offset := int64(0)
rc, wholeSize, err := wf.OpenWholeRef(fi.WholeRef, offset)
if err == os.ErrNotExist {
return fileInfo{whyNot: "WholeRefFetcher returned ErrNotexist"}, false
}
if wholeSize != fi.Size {
log.Printf("ui: fileInfoPacked: OpenWholeRef size %d != index size %d; ignoring fast path", wholeSize, fi.Size)
return fileInfo{whyNot: "WholeRefFetcher and index don't agree"}, false
}
if err != nil {
log.Printf("ui: fileInfoPacked: skipping fast path due to error from WholeRefFetcher (%T): %v", src, err)
return fileInfo{whyNot: "WholeRefFetcher error"}, false
}
modtime := fi.ModTime
if modtime.IsAnyZero() {
modtime = fi.Time
}
// TODO(mpl): it'd be nicer to get the FileMode from the describe response,
// instead of having to fetch the file schema again, but we don't index the
// FileMode for now, so it's not just a matter of adding the FileMode to
// camtypes.FileInfo
fr, err := schema.NewFileReader(ctx, src, file)
fr.Close()
if err != nil {
return fileInfo{whyNot: fmt.Sprintf("cannot open a file reader: %v", err)}, false
}
return fileInfo{
mime: fi.MIMEType,
name: fi.FileName,
size: fi.Size,
modtime: modtime.Time(),
mode: fr.FileMode(),
rs: readerutil.NewFakeSeeker(rc, fi.Size-offset),
close: rc.Close,
}, true
} | [
"func",
"fileInfoPacked",
"(",
"ctx",
"context",
".",
"Context",
",",
"sh",
"*",
"search",
".",
"Handler",
",",
"src",
"blob",
".",
"Fetcher",
",",
"r",
"*",
"http",
".",
"Request",
",",
"file",
"blob",
".",
"Ref",
")",
"(",
"packFileInfo",
"fileInfo",... | // Fast path for blobpacked. | [
"Fast",
"path",
"for",
"blobpacked",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L198-L260 | train |
perkeep/perkeep | pkg/server/download.go | isText | func isText(rs io.ReadSeeker) (ok bool, err error) {
defer func() {
if _, seekErr := rs.Seek(0, io.SeekStart); seekErr != nil {
if err == nil {
err = seekErr
}
}
}()
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rs, 1e6); err != nil {
if err != io.EOF {
return false, err
}
}
return utf8.Valid(buf.Bytes()), nil
} | go | func isText(rs io.ReadSeeker) (ok bool, err error) {
defer func() {
if _, seekErr := rs.Seek(0, io.SeekStart); seekErr != nil {
if err == nil {
err = seekErr
}
}
}()
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rs, 1e6); err != nil {
if err != io.EOF {
return false, err
}
}
return utf8.Valid(buf.Bytes()), nil
} | [
"func",
"isText",
"(",
"rs",
"io",
".",
"ReadSeeker",
")",
"(",
"ok",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"_",
",",
"seekErr",
":=",
"rs",
".",
"Seek",
"(",
"0",
",",
"io",
".",
"SeekStart",
")",
";",
... | // isText reports whether the first MB read from rs is valid UTF-8 text. | [
"isText",
"reports",
"whether",
"the",
"first",
"MB",
"read",
"from",
"rs",
"is",
"valid",
"UTF",
"-",
"8",
"text",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L375-L390 | train |
perkeep/perkeep | pkg/server/download.go | statFiles | func (dh *DownloadHandler) statFiles(refs []blob.Ref) error {
statter, ok := dh.Fetcher.(blobserver.BlobStatter)
if !ok {
return fmt.Errorf("DownloadHandler.Fetcher %T is not a BlobStatter", dh.Fetcher)
}
statted := make(map[blob.Ref]bool)
err := statter.StatBlobs(context.TODO(), refs, func(sb blob.SizedRef) error {
statted[sb.Ref] = true
return nil
})
if err != nil {
log.Printf("Error statting blob files for download archive: %v", err)
return fmt.Errorf("error looking for files")
}
for _, v := range refs {
if _, ok := statted[v]; !ok {
return fmt.Errorf("%q was not found", v)
}
}
return nil
} | go | func (dh *DownloadHandler) statFiles(refs []blob.Ref) error {
statter, ok := dh.Fetcher.(blobserver.BlobStatter)
if !ok {
return fmt.Errorf("DownloadHandler.Fetcher %T is not a BlobStatter", dh.Fetcher)
}
statted := make(map[blob.Ref]bool)
err := statter.StatBlobs(context.TODO(), refs, func(sb blob.SizedRef) error {
statted[sb.Ref] = true
return nil
})
if err != nil {
log.Printf("Error statting blob files for download archive: %v", err)
return fmt.Errorf("error looking for files")
}
for _, v := range refs {
if _, ok := statted[v]; !ok {
return fmt.Errorf("%q was not found", v)
}
}
return nil
} | [
"func",
"(",
"dh",
"*",
"DownloadHandler",
")",
"statFiles",
"(",
"refs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"statter",
",",
"ok",
":=",
"dh",
".",
"Fetcher",
".",
"(",
"blobserver",
".",
"BlobStatter",
")",
"\n",
"if",
"!",
"ok",
"{"... | // statFiles stats the given refs and returns an error if any one of them is not
// found.
// It is the responsibility of the caller to check that dh.Fetcher is a
// blobserver.BlobStatter. | [
"statFiles",
"stats",
"the",
"given",
"refs",
"and",
"returns",
"an",
"error",
"if",
"any",
"one",
"of",
"them",
"is",
"not",
"found",
".",
"It",
"is",
"the",
"responsibility",
"of",
"the",
"caller",
"to",
"check",
"that",
"dh",
".",
"Fetcher",
"is",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L396-L417 | train |
perkeep/perkeep | pkg/server/download.go | serveZip | func (dh *DownloadHandler) serveZip(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if r.Method != "POST" {
http.Error(w, "Invalid download method", http.StatusBadRequest)
return
}
filesValue := r.FormValue("files")
if filesValue == "" {
http.Error(w, "No file blobRefs specified", http.StatusBadRequest)
return
}
files := strings.Split(filesValue, ",")
var refs []blob.Ref
for _, file := range files {
br, ok := blob.Parse(file)
if !ok {
http.Error(w, fmt.Sprintf("%q is not a valid blobRef", file), http.StatusBadRequest)
return
}
refs = append(refs, br)
}
// We check as many things as we can before writing the zip, because
// once we start sending a response we can't http.Error anymore.
var allRefs map[blob.Ref]string
_, ok := (dh.Fetcher).(*cacher.CachingFetcher)
if ok {
// If we have a caching fetcher, allRefs and dh.pathByRef are populated with all
// the input refs plus their children, so we don't have to redo later the recursing
// work that we're alreading doing in checkFiles.
dh.pathByRef = make(map[blob.Ref]string, len(refs))
err := dh.checkFiles(ctx, "", refs)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
allRefs = dh.pathByRef
} else {
_, ok := dh.Fetcher.(blobserver.BlobStatter)
if ok {
if err := dh.statFiles(refs); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
// If we don't have a cacher we don't know yet of all the possible
// children refs, so allRefs is just the input refs, and the
// children will be discovered on the fly, while building the zip archive.
// This is the case even if we have a statter, because statFiles does not
// recurse into directories.
allRefs = make(map[blob.Ref]string, len(refs))
for _, v := range refs {
allRefs[v] = ""
}
}
h := w.Header()
h.Set("Content-Type", "application/zip")
zipName := "camli-download-" + time.Now().Format(downloadTimeLayout) + ".zip"
h.Set("Content-Disposition", "attachment; filename="+zipName)
zw := zip.NewWriter(w)
dh.r = r
for br := range allRefs {
if err := dh.zipFile(ctx, "", br, zw); err != nil {
log.Printf("error zipping %v: %v", br, err)
// http.Error is of no use since we've already started sending a response
panic(http.ErrAbortHandler)
}
}
if err := zw.Close(); err != nil {
log.Printf("error closing zip stream: %v", err)
panic(http.ErrAbortHandler)
}
} | go | func (dh *DownloadHandler) serveZip(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if r.Method != "POST" {
http.Error(w, "Invalid download method", http.StatusBadRequest)
return
}
filesValue := r.FormValue("files")
if filesValue == "" {
http.Error(w, "No file blobRefs specified", http.StatusBadRequest)
return
}
files := strings.Split(filesValue, ",")
var refs []blob.Ref
for _, file := range files {
br, ok := blob.Parse(file)
if !ok {
http.Error(w, fmt.Sprintf("%q is not a valid blobRef", file), http.StatusBadRequest)
return
}
refs = append(refs, br)
}
// We check as many things as we can before writing the zip, because
// once we start sending a response we can't http.Error anymore.
var allRefs map[blob.Ref]string
_, ok := (dh.Fetcher).(*cacher.CachingFetcher)
if ok {
// If we have a caching fetcher, allRefs and dh.pathByRef are populated with all
// the input refs plus their children, so we don't have to redo later the recursing
// work that we're alreading doing in checkFiles.
dh.pathByRef = make(map[blob.Ref]string, len(refs))
err := dh.checkFiles(ctx, "", refs)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
allRefs = dh.pathByRef
} else {
_, ok := dh.Fetcher.(blobserver.BlobStatter)
if ok {
if err := dh.statFiles(refs); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
// If we don't have a cacher we don't know yet of all the possible
// children refs, so allRefs is just the input refs, and the
// children will be discovered on the fly, while building the zip archive.
// This is the case even if we have a statter, because statFiles does not
// recurse into directories.
allRefs = make(map[blob.Ref]string, len(refs))
for _, v := range refs {
allRefs[v] = ""
}
}
h := w.Header()
h.Set("Content-Type", "application/zip")
zipName := "camli-download-" + time.Now().Format(downloadTimeLayout) + ".zip"
h.Set("Content-Disposition", "attachment; filename="+zipName)
zw := zip.NewWriter(w)
dh.r = r
for br := range allRefs {
if err := dh.zipFile(ctx, "", br, zw); err != nil {
log.Printf("error zipping %v: %v", br, err)
// http.Error is of no use since we've already started sending a response
panic(http.ErrAbortHandler)
}
}
if err := zw.Close(); err != nil {
log.Printf("error closing zip stream: %v", err)
panic(http.ErrAbortHandler)
}
} | [
"func",
"(",
"dh",
"*",
"DownloadHandler",
")",
"serveZip",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"ctx",
":=",
"r",
".",
"Context",
"(",
")",
"\n",
"if",
"r",
".",
"Method",
"!=",
"\"POST\"",
"{",... | // serveZip creates a zip archive from the files provided as
// ?files=sha1-foo,sha1-bar,... and serves it as the response. | [
"serveZip",
"creates",
"a",
"zip",
"archive",
"from",
"the",
"files",
"provided",
"as",
"?files",
"=",
"sha1",
"-",
"foo",
"sha1",
"-",
"bar",
"...",
"and",
"serves",
"it",
"as",
"the",
"response",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L477-L552 | train |
perkeep/perkeep | pkg/client/enumerate.go | SimpleEnumerateBlobs | func (c *Client) SimpleEnumerateBlobs(ctx context.Context, ch chan<- blob.SizedRef) error {
return c.EnumerateBlobsOpts(ctx, ch, EnumerateOpts{})
} | go | func (c *Client) SimpleEnumerateBlobs(ctx context.Context, ch chan<- blob.SizedRef) error {
return c.EnumerateBlobsOpts(ctx, ch, EnumerateOpts{})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SimpleEnumerateBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"ch",
"chan",
"<-",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"return",
"c",
".",
"EnumerateBlobsOpts",
"(",
"ctx",
",",
"ch",
",",
"EnumerateOpts... | // SimpleEnumerateBlobs sends all blobs to the provided channel.
// The channel will be closed, regardless of whether an error is returned. | [
"SimpleEnumerateBlobs",
"sends",
"all",
"blobs",
"to",
"the",
"provided",
"channel",
".",
"The",
"channel",
"will",
"be",
"closed",
"regardless",
"of",
"whether",
"an",
"error",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/enumerate.go#L39-L41 | train |
perkeep/perkeep | pkg/client/enumerate.go | EnumerateBlobsOpts | func (c *Client) EnumerateBlobsOpts(ctx context.Context, ch chan<- blob.SizedRef, opts EnumerateOpts) error {
defer close(ch)
if opts.After != "" && opts.MaxWait != 0 {
return errors.New("client error: it's invalid to use enumerate After and MaxWaitSec together")
}
pfx, err := c.prefix()
if err != nil {
return err
}
error := func(msg string, e error) error {
err := fmt.Errorf("client enumerate error: %s: %v", msg, e)
c.printf("%v", err)
return err
}
nSent := 0
keepGoing := true
after := opts.After
for keepGoing {
waitSec := 0
if after == "" {
if opts.MaxWait > 0 {
waitSec = int(opts.MaxWait.Seconds())
if waitSec == 0 {
waitSec = 1
}
}
}
url_ := fmt.Sprintf("%s/camli/enumerate-blobs?after=%s&limit=%d&maxwaitsec=%d",
pfx, url.QueryEscape(after), enumerateBatchSize, waitSec)
req := c.newRequest(ctx, "GET", url_)
resp, err := c.httpClient.Do(req)
if err != nil {
return error("http request", err)
}
json, err := c.responseJSONMap("enumerate-blobs", resp)
if err != nil {
return error("stat json parse error", err)
}
blobs, ok := getJSONMapArray(json, "blobs")
if !ok {
return error("response JSON didn't contain 'blobs' array", nil)
}
for _, v := range blobs {
itemJSON, ok := v.(map[string]interface{})
if !ok {
return error("item in 'blobs' was malformed", nil)
}
blobrefStr, ok := getJSONMapString(itemJSON, "blobRef")
if !ok {
return error("item in 'blobs' was missing string 'blobRef'", nil)
}
size, ok := getJSONMapUint32(itemJSON, "size")
if !ok {
return error("item in 'blobs' was missing numeric 'size'", nil)
}
br, ok := blob.Parse(blobrefStr)
if !ok {
return error("item in 'blobs' had invalid blobref.", nil)
}
select {
case ch <- blob.SizedRef{Ref: br, Size: uint32(size)}:
case <-ctx.Done():
return ctx.Err()
}
nSent++
if opts.Limit == nSent {
// nSent can't be zero at this point, so opts.Limit being 0
// is okay.
return nil
}
}
after, keepGoing = getJSONMapString(json, "continueAfter")
}
return nil
} | go | func (c *Client) EnumerateBlobsOpts(ctx context.Context, ch chan<- blob.SizedRef, opts EnumerateOpts) error {
defer close(ch)
if opts.After != "" && opts.MaxWait != 0 {
return errors.New("client error: it's invalid to use enumerate After and MaxWaitSec together")
}
pfx, err := c.prefix()
if err != nil {
return err
}
error := func(msg string, e error) error {
err := fmt.Errorf("client enumerate error: %s: %v", msg, e)
c.printf("%v", err)
return err
}
nSent := 0
keepGoing := true
after := opts.After
for keepGoing {
waitSec := 0
if after == "" {
if opts.MaxWait > 0 {
waitSec = int(opts.MaxWait.Seconds())
if waitSec == 0 {
waitSec = 1
}
}
}
url_ := fmt.Sprintf("%s/camli/enumerate-blobs?after=%s&limit=%d&maxwaitsec=%d",
pfx, url.QueryEscape(after), enumerateBatchSize, waitSec)
req := c.newRequest(ctx, "GET", url_)
resp, err := c.httpClient.Do(req)
if err != nil {
return error("http request", err)
}
json, err := c.responseJSONMap("enumerate-blobs", resp)
if err != nil {
return error("stat json parse error", err)
}
blobs, ok := getJSONMapArray(json, "blobs")
if !ok {
return error("response JSON didn't contain 'blobs' array", nil)
}
for _, v := range blobs {
itemJSON, ok := v.(map[string]interface{})
if !ok {
return error("item in 'blobs' was malformed", nil)
}
blobrefStr, ok := getJSONMapString(itemJSON, "blobRef")
if !ok {
return error("item in 'blobs' was missing string 'blobRef'", nil)
}
size, ok := getJSONMapUint32(itemJSON, "size")
if !ok {
return error("item in 'blobs' was missing numeric 'size'", nil)
}
br, ok := blob.Parse(blobrefStr)
if !ok {
return error("item in 'blobs' had invalid blobref.", nil)
}
select {
case ch <- blob.SizedRef{Ref: br, Size: uint32(size)}:
case <-ctx.Done():
return ctx.Err()
}
nSent++
if opts.Limit == nSent {
// nSent can't be zero at this point, so opts.Limit being 0
// is okay.
return nil
}
}
after, keepGoing = getJSONMapString(json, "continueAfter")
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"EnumerateBlobsOpts",
"(",
"ctx",
"context",
".",
"Context",
",",
"ch",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"opts",
"EnumerateOpts",
")",
"error",
"{",
"defer",
"close",
"(",
"ch",
")",
"\n",
"if",
"opts",
... | // EnumerateBlobsOpts sends blobs to the provided channel, as directed by opts.
// The channel will be closed, regardless of whether an error is returned. | [
"EnumerateBlobsOpts",
"sends",
"blobs",
"to",
"the",
"provided",
"channel",
"as",
"directed",
"by",
"opts",
".",
"The",
"channel",
"will",
"be",
"closed",
"regardless",
"of",
"whether",
"an",
"error",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/enumerate.go#L62-L141 | train |
perkeep/perkeep | pkg/cmdmain/cmdmain.go | RegisterCommand | func RegisterCommand(mode string, makeCmd func(Flags *flag.FlagSet) CommandRunner) {
RegisterMode(mode, makeCmd)
asNewCommand[mode] = true
} | go | func RegisterCommand(mode string, makeCmd func(Flags *flag.FlagSet) CommandRunner) {
RegisterMode(mode, makeCmd)
asNewCommand[mode] = true
} | [
"func",
"RegisterCommand",
"(",
"mode",
"string",
",",
"makeCmd",
"func",
"(",
"Flags",
"*",
"flag",
".",
"FlagSet",
")",
"CommandRunner",
")",
"{",
"RegisterMode",
"(",
"mode",
",",
"makeCmd",
")",
"\n",
"asNewCommand",
"[",
"mode",
"]",
"=",
"true",
"\... | // RegisterCommand adds a mode to the list of modes for the main command, and
// also specifies that this mode is just another executable that runs as a new
// cmdmain command. The executable to run is determined by the LookPath implementation
// for this mode. | [
"RegisterCommand",
"adds",
"a",
"mode",
"to",
"the",
"list",
"of",
"modes",
"for",
"the",
"main",
"command",
"and",
"also",
"specifies",
"that",
"this",
"mode",
"is",
"just",
"another",
"executable",
"that",
"runs",
"as",
"a",
"new",
"cmdmain",
"command",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/cmdmain/cmdmain.go#L149-L152 | train |
perkeep/perkeep | pkg/cmdmain/cmdmain.go | runAsNewCommand | func runAsNewCommand(cmd CommandRunner, mode string) {
execCmd, ok := cmd.(ExecRunner)
if !ok {
panic(fmt.Sprintf("%v does not implement ExecRunner", mode))
}
cmdPath, err := execCmd.LookPath()
if err != nil {
Errorf("Error: %v\n", err)
Exit(2)
}
allArgs := shiftFlags(mode)
if err := runExec(cmdPath, allArgs, newCopyEnv()); err != nil {
panic(fmt.Sprintf("running %v should have ended with an os.Exit, and not leave us with that error: %v", cmdPath, err))
}
} | go | func runAsNewCommand(cmd CommandRunner, mode string) {
execCmd, ok := cmd.(ExecRunner)
if !ok {
panic(fmt.Sprintf("%v does not implement ExecRunner", mode))
}
cmdPath, err := execCmd.LookPath()
if err != nil {
Errorf("Error: %v\n", err)
Exit(2)
}
allArgs := shiftFlags(mode)
if err := runExec(cmdPath, allArgs, newCopyEnv()); err != nil {
panic(fmt.Sprintf("running %v should have ended with an os.Exit, and not leave us with that error: %v", cmdPath, err))
}
} | [
"func",
"runAsNewCommand",
"(",
"cmd",
"CommandRunner",
",",
"mode",
"string",
")",
"{",
"execCmd",
",",
"ok",
":=",
"cmd",
".",
"(",
"ExecRunner",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%v does not implement ExecRunn... | // runAsNewCommand runs the executable specified by cmd's LookPath, which means
// cmd must implement the ExecRunner interface. The executable must be a binary of
// a program that runs Main. | [
"runAsNewCommand",
"runs",
"the",
"executable",
"specified",
"by",
"cmd",
"s",
"LookPath",
"which",
"means",
"cmd",
"must",
"implement",
"the",
"ExecRunner",
"interface",
".",
"The",
"executable",
"must",
"be",
"a",
"binary",
"of",
"a",
"program",
"that",
"run... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/cmdmain/cmdmain.go#L341-L355 | train |
perkeep/perkeep | pkg/cmdmain/cmdmain.go | Printf | func Printf(format string, args ...interface{}) {
if *FlagVerbose {
fmt.Fprintf(Stderr, format, args...)
}
} | go | func Printf(format string, args ...interface{}) {
if *FlagVerbose {
fmt.Fprintf(Stderr, format, args...)
}
} | [
"func",
"Printf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"*",
"FlagVerbose",
"{",
"fmt",
".",
"Fprintf",
"(",
"Stderr",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] | // Printf prints to Stderr if FlagVerbose, and is silent otherwise. | [
"Printf",
"prints",
"to",
"Stderr",
"if",
"FlagVerbose",
"and",
"is",
"silent",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/cmdmain/cmdmain.go#L377-L381 | train |
perkeep/perkeep | server/perkeepd/logging.go | maybeSetupGoogleCloudLogging | func maybeSetupGoogleCloudLogging() io.Closer {
if flagGCEProjectID == "" && flagGCELogName == "" && flagGCEJWTFile == "" {
return types.NopCloser
}
if flagGCEProjectID == "" || flagGCELogName == "" || flagGCEJWTFile == "" {
exitf("All of --gce_project_id, --gce_log_name, and --gce_jwt_file must be specified for logging on Google Cloud Logging.")
}
ctx := context.Background()
logc, err := logging.NewClient(ctx,
flagGCEProjectID, option.WithServiceAccountFile(flagGCEJWTFile))
if err != nil {
exitf("Error creating GCL client: %v", err)
}
if err := logc.Ping(ctx); err != nil {
exitf("Google logging client not ready (ping failed): %v", err)
}
logw := gclWriter{
severity: logging.Debug,
logger: logc.Logger(flagGCELogName),
}
log.SetOutput(io.MultiWriter(os.Stderr, logw))
return logc
} | go | func maybeSetupGoogleCloudLogging() io.Closer {
if flagGCEProjectID == "" && flagGCELogName == "" && flagGCEJWTFile == "" {
return types.NopCloser
}
if flagGCEProjectID == "" || flagGCELogName == "" || flagGCEJWTFile == "" {
exitf("All of --gce_project_id, --gce_log_name, and --gce_jwt_file must be specified for logging on Google Cloud Logging.")
}
ctx := context.Background()
logc, err := logging.NewClient(ctx,
flagGCEProjectID, option.WithServiceAccountFile(flagGCEJWTFile))
if err != nil {
exitf("Error creating GCL client: %v", err)
}
if err := logc.Ping(ctx); err != nil {
exitf("Google logging client not ready (ping failed): %v", err)
}
logw := gclWriter{
severity: logging.Debug,
logger: logc.Logger(flagGCELogName),
}
log.SetOutput(io.MultiWriter(os.Stderr, logw))
return logc
} | [
"func",
"maybeSetupGoogleCloudLogging",
"(",
")",
"io",
".",
"Closer",
"{",
"if",
"flagGCEProjectID",
"==",
"\"\"",
"&&",
"flagGCELogName",
"==",
"\"\"",
"&&",
"flagGCEJWTFile",
"==",
"\"\"",
"{",
"return",
"types",
".",
"NopCloser",
"\n",
"}",
"\n",
"if",
"... | // if a non-nil logging Client is returned, it should be closed before the
// program terminates to flush any buffered log entries. | [
"if",
"a",
"non",
"-",
"nil",
"logging",
"Client",
"is",
"returned",
"it",
"should",
"be",
"closed",
"before",
"the",
"program",
"terminates",
"to",
"flush",
"any",
"buffered",
"log",
"entries",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/logging.go#L70-L92 | train |
perkeep/perkeep | server/perkeepd/logging.go | setupLogging | func setupLogging() io.Closer {
if *flagSyslog && runtime.GOOS == "windows" {
exitf("-syslog not available on windows")
}
if fn := setupLoggingSyslog; fn != nil {
if flusher := fn(); flusher != nil {
return flusher
}
}
if env.OnGCE() {
lw, err := gce.LogWriter()
if err != nil {
log.Fatalf("Error setting up logging: %v", err)
}
log.SetOutput(lw)
return lw
}
return maybeSetupGoogleCloudLogging()
} | go | func setupLogging() io.Closer {
if *flagSyslog && runtime.GOOS == "windows" {
exitf("-syslog not available on windows")
}
if fn := setupLoggingSyslog; fn != nil {
if flusher := fn(); flusher != nil {
return flusher
}
}
if env.OnGCE() {
lw, err := gce.LogWriter()
if err != nil {
log.Fatalf("Error setting up logging: %v", err)
}
log.SetOutput(lw)
return lw
}
return maybeSetupGoogleCloudLogging()
} | [
"func",
"setupLogging",
"(",
")",
"io",
".",
"Closer",
"{",
"if",
"*",
"flagSyslog",
"&&",
"runtime",
".",
"GOOS",
"==",
"\"windows\"",
"{",
"exitf",
"(",
"\"-syslog not available on windows\"",
")",
"\n",
"}",
"\n",
"if",
"fn",
":=",
"setupLoggingSyslog",
"... | // setupLogging sets up logging and returns an io.Closer that flushes logs. | [
"setupLogging",
"sets",
"up",
"logging",
"and",
"returns",
"an",
"io",
".",
"Closer",
"that",
"flushes",
"logs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/logging.go#L99-L117 | train |
perkeep/perkeep | pkg/search/websocket.go | writePump | func (c *wsConn) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
c.ws.Close()
}()
for {
select {
case message, ok := <-c.send:
if !ok {
c.write(websocket.CloseMessage, []byte{})
return
}
if err := c.write(websocket.TextMessage, message); err != nil {
return
}
case <-ticker.C:
if err := c.write(websocket.PingMessage, []byte{}); err != nil {
return
}
}
}
} | go | func (c *wsConn) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
c.ws.Close()
}()
for {
select {
case message, ok := <-c.send:
if !ok {
c.write(websocket.CloseMessage, []byte{})
return
}
if err := c.write(websocket.TextMessage, message); err != nil {
return
}
case <-ticker.C:
if err := c.write(websocket.PingMessage, []byte{}); err != nil {
return
}
}
}
} | [
"func",
"(",
"c",
"*",
"wsConn",
")",
"writePump",
"(",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"pingPeriod",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"c",
".",
"ws",
".",
"Close",
"(",
... | // writePump pumps messages from the hub to the websocket connection. | [
"writePump",
"pumps",
"messages",
"from",
"the",
"hub",
"to",
"the",
"websocket",
"connection",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/websocket.go#L279-L301 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Get | func (s *DriveService) Get(ctx context.Context, title string) (*client.File, error) {
// TODO: use field selectors
query := fmt.Sprintf("'%s' in parents and title = '%s'", s.parentID, title)
req := s.apiservice.Files.List().Context(ctx).Q(query)
files, err := req.Do()
if err != nil {
return nil, err
}
if len(files.Items) < 1 {
return nil, os.ErrNotExist
}
return files.Items[0], nil
} | go | func (s *DriveService) Get(ctx context.Context, title string) (*client.File, error) {
// TODO: use field selectors
query := fmt.Sprintf("'%s' in parents and title = '%s'", s.parentID, title)
req := s.apiservice.Files.List().Context(ctx).Q(query)
files, err := req.Do()
if err != nil {
return nil, err
}
if len(files.Items) < 1 {
return nil, os.ErrNotExist
}
return files.Items[0], nil
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Get",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"(",
"*",
"client",
".",
"File",
",",
"error",
")",
"{",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"'%s' in parents and title = '%s'... | // Get retrieves a file with its title equal to the provided title and a child of
// the parentID as given to New. If not found, os.ErrNotExist is returned. | [
"Get",
"retrieves",
"a",
"file",
"with",
"its",
"title",
"equal",
"to",
"the",
"provided",
"title",
"and",
"a",
"child",
"of",
"the",
"parentID",
"as",
"given",
"to",
"New",
".",
"If",
"not",
"found",
"os",
".",
"ErrNotExist",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L65-L77 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | List | func (s *DriveService) List(pageToken string, limit int) (files []*client.File, next string, err error) {
req := s.apiservice.Files.List()
req.Q(fmt.Sprintf("'%s' in parents and mimeType != '%s'", s.parentID, MimeTypeDriveFolder))
if pageToken != "" {
req.PageToken(pageToken)
}
if limit > 0 {
req.MaxResults(int64(limit))
}
result, err := req.Do()
if err != nil {
return
}
return result.Items, result.NextPageToken, err
} | go | func (s *DriveService) List(pageToken string, limit int) (files []*client.File, next string, err error) {
req := s.apiservice.Files.List()
req.Q(fmt.Sprintf("'%s' in parents and mimeType != '%s'", s.parentID, MimeTypeDriveFolder))
if pageToken != "" {
req.PageToken(pageToken)
}
if limit > 0 {
req.MaxResults(int64(limit))
}
result, err := req.Do()
if err != nil {
return
}
return result.Items, result.NextPageToken, err
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"List",
"(",
"pageToken",
"string",
",",
"limit",
"int",
")",
"(",
"files",
"[",
"]",
"*",
"client",
".",
"File",
",",
"next",
"string",
",",
"err",
"error",
")",
"{",
"req",
":=",
"s",
".",
"apiservice",... | // List returns a list of files. When limit is greater than zero a paginated list is returned
// using the next response as a pageToken in subsequent calls. | [
"List",
"returns",
"a",
"list",
"of",
"files",
".",
"When",
"limit",
"is",
"greater",
"than",
"zero",
"a",
"paginated",
"list",
"is",
"returned",
"using",
"the",
"next",
"response",
"as",
"a",
"pageToken",
"in",
"subsequent",
"calls",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L81-L98 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Upsert | func (s *DriveService) Upsert(ctx context.Context, title string, data io.Reader) (file *client.File, err error) {
if file, err = s.Get(ctx, title); err != nil {
if !os.IsNotExist(err) {
return
}
}
if file == nil {
file = &client.File{Title: title}
file.Parents = []*client.ParentReference{
{Id: s.parentID},
}
file.MimeType = MimeTypeCamliBlob
return s.apiservice.Files.Insert(file).Media(data).Context(ctx).Do()
}
// TODO: handle large blobs
return s.apiservice.Files.Update(file.Id, file).Media(data).Context(ctx).Do()
} | go | func (s *DriveService) Upsert(ctx context.Context, title string, data io.Reader) (file *client.File, err error) {
if file, err = s.Get(ctx, title); err != nil {
if !os.IsNotExist(err) {
return
}
}
if file == nil {
file = &client.File{Title: title}
file.Parents = []*client.ParentReference{
{Id: s.parentID},
}
file.MimeType = MimeTypeCamliBlob
return s.apiservice.Files.Insert(file).Media(data).Context(ctx).Do()
}
// TODO: handle large blobs
return s.apiservice.Files.Update(file.Id, file).Media(data).Context(ctx).Do()
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Upsert",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
",",
"data",
"io",
".",
"Reader",
")",
"(",
"file",
"*",
"client",
".",
"File",
",",
"err",
"error",
")",
"{",
"if",
"file",
",",
... | // Upsert inserts a file, or updates if such a file exists. | [
"Upsert",
"inserts",
"a",
"file",
"or",
"updates",
"if",
"such",
"a",
"file",
"exists",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L101-L118 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Fetch | func (s *DriveService) Fetch(ctx context.Context, title string) (body io.ReadCloser, size uint32, err error) {
file, err := s.Get(ctx, title)
if err != nil {
return
}
// TODO: maybe in the case of no download link, remove the file.
// The file should have malformed or converted to a Docs file
// unwantedly.
// TODO(mpl): I do not think the above comment is accurate. It
// looks like at least one case we do not get a DownloadUrl is when
// the UI would make you pick a conversion format first (spreadsheet,
// doc, etc). -> we should see if the API offers the possibility to do
// that conversion. and we could pass the type(s) we want (pdf, xls, doc...)
// as arguments (in an options struct) to Fetch.
if file.DownloadUrl == "" {
err = errNoDownload
return
}
req, _ := http.NewRequest("GET", file.DownloadUrl, nil)
req.WithContext(ctx)
var resp *http.Response
if resp, err = s.client.Transport.RoundTrip(req); err != nil {
return
}
if file.FileSize > math.MaxUint32 || file.FileSize < 0 {
err = errors.New("file too big")
}
return resp.Body, uint32(file.FileSize), err
} | go | func (s *DriveService) Fetch(ctx context.Context, title string) (body io.ReadCloser, size uint32, err error) {
file, err := s.Get(ctx, title)
if err != nil {
return
}
// TODO: maybe in the case of no download link, remove the file.
// The file should have malformed or converted to a Docs file
// unwantedly.
// TODO(mpl): I do not think the above comment is accurate. It
// looks like at least one case we do not get a DownloadUrl is when
// the UI would make you pick a conversion format first (spreadsheet,
// doc, etc). -> we should see if the API offers the possibility to do
// that conversion. and we could pass the type(s) we want (pdf, xls, doc...)
// as arguments (in an options struct) to Fetch.
if file.DownloadUrl == "" {
err = errNoDownload
return
}
req, _ := http.NewRequest("GET", file.DownloadUrl, nil)
req.WithContext(ctx)
var resp *http.Response
if resp, err = s.client.Transport.RoundTrip(req); err != nil {
return
}
if file.FileSize > math.MaxUint32 || file.FileSize < 0 {
err = errors.New("file too big")
}
return resp.Body, uint32(file.FileSize), err
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"(",
"body",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"file",
",",
"err",
":=",
"s",
".",... | // Fetch retrieves the metadata and contents of a file. | [
"Fetch",
"retrieves",
"the",
"metadata",
"and",
"contents",
"of",
"a",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L123-L152 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Stat | func (s *DriveService) Stat(ctx context.Context, title string) (int64, error) {
file, err := s.Get(ctx, title)
if err != nil || file == nil {
return 0, err
}
return file.FileSize, err
} | go | func (s *DriveService) Stat(ctx context.Context, title string) (int64, error) {
file, err := s.Get(ctx, title)
if err != nil || file == nil {
return 0, err
}
return file.FileSize, err
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Stat",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"ctx",
",",
"title",
")",
"\n",
"if",
... | // Stat retrieves file metadata and returns
// file size. Returns error if file is not found. | [
"Stat",
"retrieves",
"file",
"metadata",
"and",
"returns",
"file",
"size",
".",
"Returns",
"error",
"if",
"file",
"is",
"not",
"found",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L156-L162 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Trash | func (s *DriveService) Trash(ctx context.Context, title string) error {
file, err := s.Get(ctx, title)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
_, err = s.apiservice.Files.Trash(file.Id).Context(ctx).Do()
return err
} | go | func (s *DriveService) Trash(ctx context.Context, title string) error {
file, err := s.Get(ctx, title)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
_, err = s.apiservice.Files.Trash(file.Id).Context(ctx).Do()
return err
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Trash",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"error",
"{",
"file",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"ctx",
",",
"title",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Trash trashes the file with the given title. | [
"Trash",
"trashes",
"the",
"file",
"with",
"the",
"given",
"title",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L165-L175 | train |
perkeep/perkeep | server/perkeepd/ui/goui/mapquery/mapquery.go | Send | func (q *Query) Send() {
if q.pending {
q.Cleanup()
return
}
q.pending = true
go func() {
resp, err := q.send()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
}
q.Callback(string(resp))
}()
} | go | func (q *Query) Send() {
if q.pending {
q.Cleanup()
return
}
q.pending = true
go func() {
resp, err := q.send()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
}
q.Callback(string(resp))
}()
} | [
"func",
"(",
"q",
"*",
"Query",
")",
"Send",
"(",
")",
"{",
"if",
"q",
".",
"pending",
"{",
"q",
".",
"Cleanup",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"q",
".",
"pending",
"=",
"true",
"\n",
"go",
"func",
"(",
")",
"{",
"resp",
",",
"e... | // Send sends the search query, and runs the Query's callback on success. It
// returns immediately if there's already a query in flight. | [
"Send",
"sends",
"the",
"search",
"query",
"and",
"runs",
"the",
"Query",
"s",
"callback",
"on",
"success",
".",
"It",
"returns",
"immediately",
"if",
"there",
"s",
"already",
"a",
"query",
"in",
"flight",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/mapquery/mapquery.go#L90-L103 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/punch_linux.go | punchHoleLinux | func punchHoleLinux(file *os.File, offset int64, size int64) error {
err := syscall.Fallocate(int(file.Fd()),
falloc_fl_punch_hole|falloc_fl_keep_size,
offset, size)
if err == syscall.ENOSYS || err == syscall.EOPNOTSUPP {
return errNoPunch
}
return err
} | go | func punchHoleLinux(file *os.File, offset int64, size int64) error {
err := syscall.Fallocate(int(file.Fd()),
falloc_fl_punch_hole|falloc_fl_keep_size,
offset, size)
if err == syscall.ENOSYS || err == syscall.EOPNOTSUPP {
return errNoPunch
}
return err
} | [
"func",
"punchHoleLinux",
"(",
"file",
"*",
"os",
".",
"File",
",",
"offset",
"int64",
",",
"size",
"int64",
")",
"error",
"{",
"err",
":=",
"syscall",
".",
"Fallocate",
"(",
"int",
"(",
"file",
".",
"Fd",
"(",
")",
")",
",",
"falloc_fl_punch_hole",
... | // puncHoleLinux punches a hole into the given file starting at offset,
// measuring "size" bytes | [
"puncHoleLinux",
"punches",
"a",
"hole",
"into",
"the",
"given",
"file",
"starting",
"at",
"offset",
"measuring",
"size",
"bytes"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/punch_linux.go#L38-L46 | train |
perkeep/perkeep | pkg/schema/filereader.go | NewFileReader | func NewFileReader(ctx context.Context, fetcher blob.Fetcher, fileBlobRef blob.Ref) (*FileReader, error) {
// TODO(bradfitz): rename this into bytes reader? but for now it's still
// named FileReader, but can also read a "bytes" schema.
if !fileBlobRef.Valid() {
return nil, errors.New("schema/filereader: NewFileReader blobref invalid")
}
rc, _, err := fetcher.Fetch(ctx, fileBlobRef)
if err != nil {
return nil, fmt.Errorf("schema/filereader: fetching file schema blob: %v", err)
}
defer rc.Close()
ss, err := parseSuperset(rc)
if err != nil {
return nil, fmt.Errorf("schema/filereader: decoding file schema blob: %v", err)
}
ss.BlobRef = fileBlobRef
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: expected \"file\" or \"bytes\" schema blob, got %q", ss.Type)
}
fr, err := ss.NewFileReader(fetcher)
if err != nil {
return nil, fmt.Errorf("schema/filereader: creating FileReader for %s: %v", fileBlobRef, err)
}
return fr, nil
} | go | func NewFileReader(ctx context.Context, fetcher blob.Fetcher, fileBlobRef blob.Ref) (*FileReader, error) {
// TODO(bradfitz): rename this into bytes reader? but for now it's still
// named FileReader, but can also read a "bytes" schema.
if !fileBlobRef.Valid() {
return nil, errors.New("schema/filereader: NewFileReader blobref invalid")
}
rc, _, err := fetcher.Fetch(ctx, fileBlobRef)
if err != nil {
return nil, fmt.Errorf("schema/filereader: fetching file schema blob: %v", err)
}
defer rc.Close()
ss, err := parseSuperset(rc)
if err != nil {
return nil, fmt.Errorf("schema/filereader: decoding file schema blob: %v", err)
}
ss.BlobRef = fileBlobRef
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: expected \"file\" or \"bytes\" schema blob, got %q", ss.Type)
}
fr, err := ss.NewFileReader(fetcher)
if err != nil {
return nil, fmt.Errorf("schema/filereader: creating FileReader for %s: %v", fileBlobRef, err)
}
return fr, nil
} | [
"func",
"NewFileReader",
"(",
"ctx",
"context",
".",
"Context",
",",
"fetcher",
"blob",
".",
"Fetcher",
",",
"fileBlobRef",
"blob",
".",
"Ref",
")",
"(",
"*",
"FileReader",
",",
"error",
")",
"{",
"if",
"!",
"fileBlobRef",
".",
"Valid",
"(",
")",
"{",
... | // NewFileReader returns a new FileReader reading the contents of fileBlobRef,
// fetching blobs from fetcher. The fileBlobRef must be of a "bytes" or "file"
// schema blob.
//
// The caller should call Close on the FileReader when done reading. | [
"NewFileReader",
"returns",
"a",
"new",
"FileReader",
"reading",
"the",
"contents",
"of",
"fileBlobRef",
"fetching",
"blobs",
"from",
"fetcher",
".",
"The",
"fileBlobRef",
"must",
"be",
"of",
"a",
"bytes",
"or",
"file",
"schema",
"blob",
".",
"The",
"caller",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L71-L95 | train |
perkeep/perkeep | pkg/schema/filereader.go | NewFileReader | func (ss *superset) NewFileReader(fetcher blob.Fetcher) (*FileReader, error) {
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: Superset not of type \"file\" or \"bytes\"")
}
size := int64(ss.SumPartsSize())
fr := &FileReader{
fetcher: fetcher,
ss: ss,
size: size,
ssm: make(map[blob.Ref]*superset),
}
fr.SectionReader = io.NewSectionReader(fr, 0, size)
return fr, nil
} | go | func (ss *superset) NewFileReader(fetcher blob.Fetcher) (*FileReader, error) {
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: Superset not of type \"file\" or \"bytes\"")
}
size := int64(ss.SumPartsSize())
fr := &FileReader{
fetcher: fetcher,
ss: ss,
size: size,
ssm: make(map[blob.Ref]*superset),
}
fr.SectionReader = io.NewSectionReader(fr, 0, size)
return fr, nil
} | [
"func",
"(",
"ss",
"*",
"superset",
")",
"NewFileReader",
"(",
"fetcher",
"blob",
".",
"Fetcher",
")",
"(",
"*",
"FileReader",
",",
"error",
")",
"{",
"if",
"ss",
".",
"Type",
"!=",
"\"file\"",
"&&",
"ss",
".",
"Type",
"!=",
"\"bytes\"",
"{",
"return... | // NewFileReader returns a new FileReader, reading bytes and blobs
// from the provided fetcher.
//
// NewFileReader does no fetch operation on the fetcher itself. The
// fetcher is only used in subsequent read operations.
//
// An error is only returned if the type of the superset is not either
// "file" or "bytes". | [
"NewFileReader",
"returns",
"a",
"new",
"FileReader",
"reading",
"bytes",
"and",
"blobs",
"from",
"the",
"provided",
"fetcher",
".",
"NewFileReader",
"does",
"no",
"fetch",
"operation",
"on",
"the",
"fetcher",
"itself",
".",
"The",
"fetcher",
"is",
"only",
"us... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L109-L122 | train |
perkeep/perkeep | pkg/schema/filereader.go | UnixMtime | func (fr *FileReader) UnixMtime() time.Time {
t, err := time.Parse(time.RFC3339, fr.ss.UnixMtime)
if err != nil {
return time.Time{}
}
return t
} | go | func (fr *FileReader) UnixMtime() time.Time {
t, err := time.Parse(time.RFC3339, fr.ss.UnixMtime)
if err != nil {
return time.Time{}
}
return t
} | [
"func",
"(",
"fr",
"*",
"FileReader",
")",
"UnixMtime",
"(",
")",
"time",
".",
"Time",
"{",
"t",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"fr",
".",
"ss",
".",
"UnixMtime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"... | // UnixMtime returns the file schema's UnixMtime field, or the zero value. | [
"UnixMtime",
"returns",
"the",
"file",
"schema",
"s",
"UnixMtime",
"field",
"or",
"the",
"zero",
"value",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L155-L161 | train |
perkeep/perkeep | pkg/schema/filereader.go | ForeachChunk | func (fr *FileReader) ForeachChunk(ctx context.Context, fn func(schemaPath []blob.Ref, p BytesPart) error) error {
return fr.foreachChunk(ctx, fn, nil)
} | go | func (fr *FileReader) ForeachChunk(ctx context.Context, fn func(schemaPath []blob.Ref, p BytesPart) error) error {
return fr.foreachChunk(ctx, fn, nil)
} | [
"func",
"(",
"fr",
"*",
"FileReader",
")",
"ForeachChunk",
"(",
"ctx",
"context",
".",
"Context",
",",
"fn",
"func",
"(",
"schemaPath",
"[",
"]",
"blob",
".",
"Ref",
",",
"p",
"BytesPart",
")",
"error",
")",
"error",
"{",
"return",
"fr",
".",
"foreac... | // ForeachChunk calls fn for each chunk of fr, in order.
//
// The schemaPath argument will be the path from the "file" or "bytes"
// schema blob down to possibly other "bytes" schema blobs, the final
// one of which references the given BytesPart. The BytesPart will be
// the actual chunk. The fn function will not be called with
// BytesParts referencing a "BytesRef"; those are followed recursively
// instead. The fn function must not retain or mutate schemaPath.
//
// If fn returns an error, iteration stops and that error is returned
// from ForeachChunk. Other errors may be returned from ForeachChunk
// if schema blob fetches fail. | [
"ForeachChunk",
"calls",
"fn",
"for",
"each",
"chunk",
"of",
"fr",
"in",
"order",
".",
"The",
"schemaPath",
"argument",
"will",
"be",
"the",
"path",
"from",
"the",
"file",
"or",
"bytes",
"schema",
"blob",
"down",
"to",
"possibly",
"other",
"bytes",
"schema... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L219-L221 | train |
perkeep/perkeep | internal/media/audio.go | HasID3v1Tag | func HasID3v1Tag(r readerutil.SizeReaderAt) (bool, error) {
if r.Size() < ID3v1TagLength {
return false, nil
}
buf := make([]byte, len(id3v1Magic))
if _, err := r.ReadAt(buf, r.Size()-ID3v1TagLength); err != nil {
return false, fmt.Errorf("Failed to read ID3v1 data: %v", err)
}
if bytes.Equal(buf, id3v1Magic) {
return true, nil
}
return false, nil
} | go | func HasID3v1Tag(r readerutil.SizeReaderAt) (bool, error) {
if r.Size() < ID3v1TagLength {
return false, nil
}
buf := make([]byte, len(id3v1Magic))
if _, err := r.ReadAt(buf, r.Size()-ID3v1TagLength); err != nil {
return false, fmt.Errorf("Failed to read ID3v1 data: %v", err)
}
if bytes.Equal(buf, id3v1Magic) {
return true, nil
}
return false, nil
} | [
"func",
"HasID3v1Tag",
"(",
"r",
"readerutil",
".",
"SizeReaderAt",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"r",
".",
"Size",
"(",
")",
"<",
"ID3v1TagLength",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"buf",
":=",
"make",
"(",
"[... | // HasID3v1Tag returns true if an ID3v1 tag is present at the end of r. | [
"HasID3v1Tag",
"returns",
"true",
"if",
"an",
"ID3v1",
"tag",
"is",
"present",
"at",
"the",
"end",
"of",
"r",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/media/audio.go#L38-L51 | train |
perkeep/perkeep | app/publisher/js/file.go | renderFile | func renderFile() {
var err error
theFic, err = newFileItemContainer(fileThumbnailHeight)
if err != nil {
fmt.Printf("error creating file container: %v\n", err)
return
}
if err := theFic.populate(); err != nil {
fmt.Printf("Error initializing file container: %v", err)
return
}
if err := theFic.render(); err != nil {
fmt.Printf("Error rendering file container: %v", err)
return
}
jQuery(js.Global).Call(jquery.KEYUP, func(e jquery.Event) {
if e.Which == 37 {
theFic.doPrev()
go func() {
if err := theFic.render(); err != nil {
fmt.Printf("Error rendering file container: %v", err)
}
}()
return
}
if e.Which == 39 {
theFic.doNext()
go func() {
if err := theFic.render(); err != nil {
fmt.Printf("Error rendering file container: %v", err)
}
}()
return
}
})
} | go | func renderFile() {
var err error
theFic, err = newFileItemContainer(fileThumbnailHeight)
if err != nil {
fmt.Printf("error creating file container: %v\n", err)
return
}
if err := theFic.populate(); err != nil {
fmt.Printf("Error initializing file container: %v", err)
return
}
if err := theFic.render(); err != nil {
fmt.Printf("Error rendering file container: %v", err)
return
}
jQuery(js.Global).Call(jquery.KEYUP, func(e jquery.Event) {
if e.Which == 37 {
theFic.doPrev()
go func() {
if err := theFic.render(); err != nil {
fmt.Printf("Error rendering file container: %v", err)
}
}()
return
}
if e.Which == 39 {
theFic.doNext()
go func() {
if err := theFic.render(); err != nil {
fmt.Printf("Error rendering file container: %v", err)
}
}()
return
}
})
} | [
"func",
"renderFile",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"theFic",
",",
"err",
"=",
"newFileItemContainer",
"(",
"fileThumbnailHeight",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"error creating file container: %v\\n\"",
",... | // renderFile creates a fileItemContainer, populates it, renders it, and
// binds the left and right arrow keys for to it for navigation. | [
"renderFile",
"creates",
"a",
"fileItemContainer",
"populates",
"it",
"renders",
"it",
"and",
"binds",
"the",
"left",
"and",
"right",
"arrow",
"keys",
"for",
"to",
"it",
"for",
"navigation",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/publisher/js/file.go#L58-L94 | train |
perkeep/perkeep | internal/closure/gendeps.go | GenDepsWithPath | func GenDepsWithPath(pathPrefix string, root http.FileSystem) ([]byte, error) {
d, err := root.Open("/")
if err != nil {
return nil, fmt.Errorf("Failed to open root of %v: %v", root, err)
}
fi, err := d.Stat()
if err != nil {
return nil, err
}
if !fi.IsDir() {
return nil, fmt.Errorf("root of %v is not a dir", root)
}
ent, err := d.Readdir(-1)
if err != nil {
return nil, fmt.Errorf("Could not read dir entries of root: %v", err)
}
var buf bytes.Buffer
for _, info := range ent {
name := info.Name()
if !strings.HasSuffix(name, ".js") {
continue
}
if strings.HasPrefix(name, ".#") {
// Emacs noise.
continue
}
if strings.HasPrefix(name, "goui.js") {
// because it is too large for bufio.Scanner
continue
}
f, err := root.Open(name)
if err != nil {
return nil, fmt.Errorf("Could not open %v: %v", name, err)
}
prov, req, err := parseProvidesRequires(info, name, f)
f.Close()
if err != nil {
return nil, fmt.Errorf("Could not parse deps for %v: %v", name, err)
}
if len(prov) > 0 {
fmt.Fprintf(&buf, "goog.addDependency(%q, %v, %v);\n", pathPrefix+name, jsList(prov), jsList(req))
}
}
return buf.Bytes(), nil
} | go | func GenDepsWithPath(pathPrefix string, root http.FileSystem) ([]byte, error) {
d, err := root.Open("/")
if err != nil {
return nil, fmt.Errorf("Failed to open root of %v: %v", root, err)
}
fi, err := d.Stat()
if err != nil {
return nil, err
}
if !fi.IsDir() {
return nil, fmt.Errorf("root of %v is not a dir", root)
}
ent, err := d.Readdir(-1)
if err != nil {
return nil, fmt.Errorf("Could not read dir entries of root: %v", err)
}
var buf bytes.Buffer
for _, info := range ent {
name := info.Name()
if !strings.HasSuffix(name, ".js") {
continue
}
if strings.HasPrefix(name, ".#") {
// Emacs noise.
continue
}
if strings.HasPrefix(name, "goui.js") {
// because it is too large for bufio.Scanner
continue
}
f, err := root.Open(name)
if err != nil {
return nil, fmt.Errorf("Could not open %v: %v", name, err)
}
prov, req, err := parseProvidesRequires(info, name, f)
f.Close()
if err != nil {
return nil, fmt.Errorf("Could not parse deps for %v: %v", name, err)
}
if len(prov) > 0 {
fmt.Fprintf(&buf, "goog.addDependency(%q, %v, %v);\n", pathPrefix+name, jsList(prov), jsList(req))
}
}
return buf.Bytes(), nil
} | [
"func",
"GenDepsWithPath",
"(",
"pathPrefix",
"string",
",",
"root",
"http",
".",
"FileSystem",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"d",
",",
"err",
":=",
"root",
".",
"Open",
"(",
"\"/\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // GenDepsWithPath is like GenDeps, but you can specify a path where the files are to be found at runtime relative to Closure's base.js. | [
"GenDepsWithPath",
"is",
"like",
"GenDeps",
"but",
"you",
"can",
"specify",
"a",
"path",
"where",
"the",
"files",
"are",
"to",
"be",
"found",
"at",
"runtime",
"relative",
"to",
"Closure",
"s",
"base",
".",
"js",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/closure/gendeps.go#L47-L91 | train |
perkeep/perkeep | internal/closure/gendeps.go | ParseDeps | func ParseDeps(r io.Reader) (providedBy map[string]string, requires map[string][]string, err error) {
providedBy = make(map[string]string)
requires = make(map[string][]string)
scanner := bufio.NewScanner(r)
for scanner.Scan() {
l := scanner.Text()
if strings.HasPrefix(l, "//") {
continue
}
if l == "" {
continue
}
m := depsRx.FindStringSubmatch(l)
if m == nil {
return nil, nil, fmt.Errorf("Invalid line in deps: %q", l)
}
jsfile := m[1]
provides := strings.Split(m[2], ", ")
var required []string
if m[5] != "" {
required = strings.Split(
strings.Replace(strings.Replace(m[5], "'", "", -1), `"`, "", -1), ", ")
}
for _, v := range provides {
namespace := strings.Trim(v, `'"`)
if otherjs, ok := providedBy[namespace]; ok {
return nil, nil, fmt.Errorf("Name %v is provided by both %v and %v", namespace, jsfile, otherjs)
}
providedBy[namespace] = jsfile
if _, ok := requires[namespace]; ok {
return nil, nil, fmt.Errorf("Name %v has two sets of dependencies", namespace)
}
if required != nil {
requires[namespace] = required
}
}
}
if err := scanner.Err(); err != nil {
return nil, nil, err
}
return providedBy, requires, nil
} | go | func ParseDeps(r io.Reader) (providedBy map[string]string, requires map[string][]string, err error) {
providedBy = make(map[string]string)
requires = make(map[string][]string)
scanner := bufio.NewScanner(r)
for scanner.Scan() {
l := scanner.Text()
if strings.HasPrefix(l, "//") {
continue
}
if l == "" {
continue
}
m := depsRx.FindStringSubmatch(l)
if m == nil {
return nil, nil, fmt.Errorf("Invalid line in deps: %q", l)
}
jsfile := m[1]
provides := strings.Split(m[2], ", ")
var required []string
if m[5] != "" {
required = strings.Split(
strings.Replace(strings.Replace(m[5], "'", "", -1), `"`, "", -1), ", ")
}
for _, v := range provides {
namespace := strings.Trim(v, `'"`)
if otherjs, ok := providedBy[namespace]; ok {
return nil, nil, fmt.Errorf("Name %v is provided by both %v and %v", namespace, jsfile, otherjs)
}
providedBy[namespace] = jsfile
if _, ok := requires[namespace]; ok {
return nil, nil, fmt.Errorf("Name %v has two sets of dependencies", namespace)
}
if required != nil {
requires[namespace] = required
}
}
}
if err := scanner.Err(); err != nil {
return nil, nil, err
}
return providedBy, requires, nil
} | [
"func",
"ParseDeps",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"providedBy",
"map",
"[",
"string",
"]",
"string",
",",
"requires",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"providedBy",
"=",
"make",
"(",
"map",
"... | // ParseDeps reads closure namespace dependency lines and
// returns a map giving the js file provider for each namespace,
// and a map giving the namespace dependencies for each namespace. | [
"ParseDeps",
"reads",
"closure",
"namespace",
"dependency",
"lines",
"and",
"returns",
"a",
"map",
"giving",
"the",
"js",
"file",
"provider",
"for",
"each",
"namespace",
"and",
"a",
"map",
"giving",
"the",
"namespace",
"dependencies",
"for",
"each",
"namespace",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/closure/gendeps.go#L162-L203 | train |
perkeep/perkeep | internal/closure/gendeps.go | DeepParseDeps | func DeepParseDeps(r io.Reader) (map[string][]string, error) {
providedBy, requires, err := ParseDeps(r)
if err != nil {
return nil, err
}
filesDeps := make(map[string][]string)
var deeperDeps func(namespace string) []string
deeperDeps = func(namespace string) []string {
if jsdeps, ok := filesDeps[namespace]; ok {
return jsdeps
}
jsfiles := []string{providedBy[namespace]}
for _, dep := range requires[namespace] {
jsfiles = append(jsfiles, deeperDeps(dep)...)
}
return jsfiles
}
for namespace := range providedBy {
filesDeps[namespace] = deeperDeps(namespace)
}
return filesDeps, nil
} | go | func DeepParseDeps(r io.Reader) (map[string][]string, error) {
providedBy, requires, err := ParseDeps(r)
if err != nil {
return nil, err
}
filesDeps := make(map[string][]string)
var deeperDeps func(namespace string) []string
deeperDeps = func(namespace string) []string {
if jsdeps, ok := filesDeps[namespace]; ok {
return jsdeps
}
jsfiles := []string{providedBy[namespace]}
for _, dep := range requires[namespace] {
jsfiles = append(jsfiles, deeperDeps(dep)...)
}
return jsfiles
}
for namespace := range providedBy {
filesDeps[namespace] = deeperDeps(namespace)
}
return filesDeps, nil
} | [
"func",
"DeepParseDeps",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"error",
")",
"{",
"providedBy",
",",
"requires",
",",
"err",
":=",
"ParseDeps",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // DeepParseDeps reads closure namespace dependency lines and
// returns a map giving all the required js files for each namespace. | [
"DeepParseDeps",
"reads",
"closure",
"namespace",
"dependency",
"lines",
"and",
"returns",
"a",
"map",
"giving",
"all",
"the",
"required",
"js",
"files",
"for",
"each",
"namespace",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/closure/gendeps.go#L207-L228 | train |
perkeep/perkeep | pkg/types/clientconfig/config.go | Alias | func (conf *Config) Alias(server string) string {
longestMatch := ""
serverAlias := ""
for alias, serverConf := range conf.Servers {
if strings.HasPrefix(server, serverConf.Server) {
if len(serverConf.Server) > len(longestMatch) {
longestMatch = serverConf.Server
serverAlias = alias
}
}
}
return serverAlias
} | go | func (conf *Config) Alias(server string) string {
longestMatch := ""
serverAlias := ""
for alias, serverConf := range conf.Servers {
if strings.HasPrefix(server, serverConf.Server) {
if len(serverConf.Server) > len(longestMatch) {
longestMatch = serverConf.Server
serverAlias = alias
}
}
}
return serverAlias
} | [
"func",
"(",
"conf",
"*",
"Config",
")",
"Alias",
"(",
"server",
"string",
")",
"string",
"{",
"longestMatch",
":=",
"\"\"",
"\n",
"serverAlias",
":=",
"\"\"",
"\n",
"for",
"alias",
",",
"serverConf",
":=",
"range",
"conf",
".",
"Servers",
"{",
"if",
"... | // Alias returns the alias of the server from conf that matches server, or the
// empty string if no match. A match means the server from the config is a
// prefix of the input server. The longest match prevails. | [
"Alias",
"returns",
"the",
"alias",
"of",
"the",
"server",
"from",
"conf",
"that",
"matches",
"server",
"or",
"the",
"empty",
"string",
"if",
"no",
"match",
".",
"A",
"match",
"means",
"the",
"server",
"from",
"the",
"config",
"is",
"a",
"prefix",
"of",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/types/clientconfig/config.go#L52-L64 | train |
perkeep/perkeep | pkg/blobserver/replica/replica.go | StatBlobs | func (sto *replicaStorage) StatBlobs(ctx context.Context, blobs []blob.Ref, fn func(blob.SizedRef) error) error {
var (
mu sync.Mutex // serializes calls to fn, guards need
need = make(map[blob.Ref]bool)
failed bool
)
for _, br := range blobs {
need[br] = true
}
group, ctx := errgroup.WithContext(ctx)
for _, replica := range sto.readReplicas {
replica := replica
group.Go(func() error {
return replica.StatBlobs(ctx, blobs, func(sb blob.SizedRef) error {
mu.Lock()
defer mu.Unlock()
if failed {
return nil
}
if !need[sb.Ref] {
// dup, lost race from other replica
return nil
}
delete(need, sb.Ref)
if err := fn(sb); err != nil {
failed = true
return err
}
return nil
})
})
}
return group.Wait()
} | go | func (sto *replicaStorage) StatBlobs(ctx context.Context, blobs []blob.Ref, fn func(blob.SizedRef) error) error {
var (
mu sync.Mutex // serializes calls to fn, guards need
need = make(map[blob.Ref]bool)
failed bool
)
for _, br := range blobs {
need[br] = true
}
group, ctx := errgroup.WithContext(ctx)
for _, replica := range sto.readReplicas {
replica := replica
group.Go(func() error {
return replica.StatBlobs(ctx, blobs, func(sb blob.SizedRef) error {
mu.Lock()
defer mu.Unlock()
if failed {
return nil
}
if !need[sb.Ref] {
// dup, lost race from other replica
return nil
}
delete(need, sb.Ref)
if err := fn(sb); err != nil {
failed = true
return err
}
return nil
})
})
}
return group.Wait()
} | [
"func",
"(",
"sto",
"*",
"replicaStorage",
")",
"StatBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
",",
"fn",
"func",
"(",
"blob",
".",
"SizedRef",
")",
"error",
")",
"error",
"{",
"var",
"(",
"mu",
"syn... | // StatBlobs stats all read replicas. | [
"StatBlobs",
"stats",
"all",
"read",
"replicas",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/replica/replica.go#L149-L185 | train |
perkeep/perkeep | pkg/importer/gphotos/gphotos.go | CallbackURLParameters | func (im imp) CallbackURLParameters(acctRef blob.Ref) url.Values {
return url.Values{}
} | go | func (im imp) CallbackURLParameters(acctRef blob.Ref) url.Values {
return url.Values{}
} | [
"func",
"(",
"im",
"imp",
")",
"CallbackURLParameters",
"(",
"acctRef",
"blob",
".",
"Ref",
")",
"url",
".",
"Values",
"{",
"return",
"url",
".",
"Values",
"{",
"}",
"\n",
"}"
] | // CallbackURLParameters returns the needed callback parameters - empty for Google gphotos. | [
"CallbackURLParameters",
"returns",
"the",
"needed",
"callback",
"parameters",
"-",
"empty",
"for",
"Google",
"gphotos",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/gphotos/gphotos.go#L149-L151 | train |
perkeep/perkeep | pkg/importer/gphotos/gphotos.go | decodeToken | func decodeToken(encoded string) *oauth2.Token {
t := new(oauth2.Token)
f := strings.Fields(encoded)
if len(f) > 0 {
t.AccessToken = f[0]
}
if len(f) > 1 {
t.RefreshToken = f[1]
}
if len(f) > 2 && f[2] != "0" {
sec, err := strconv.ParseInt(f[2], 10, 64)
if err == nil {
t.Expiry = time.Unix(sec, 0)
}
}
return t
} | go | func decodeToken(encoded string) *oauth2.Token {
t := new(oauth2.Token)
f := strings.Fields(encoded)
if len(f) > 0 {
t.AccessToken = f[0]
}
if len(f) > 1 {
t.RefreshToken = f[1]
}
if len(f) > 2 && f[2] != "0" {
sec, err := strconv.ParseInt(f[2], 10, 64)
if err == nil {
t.Expiry = time.Unix(sec, 0)
}
}
return t
} | [
"func",
"decodeToken",
"(",
"encoded",
"string",
")",
"*",
"oauth2",
".",
"Token",
"{",
"t",
":=",
"new",
"(",
"oauth2",
".",
"Token",
")",
"\n",
"f",
":=",
"strings",
".",
"Fields",
"(",
"encoded",
")",
"\n",
"if",
"len",
"(",
"f",
")",
">",
"0"... | // decodeToken parses an access token, refresh token, and optional
// expiry unix timestamp separated by spaces into an oauth2.Token.
// It returns as much as it can. | [
"decodeToken",
"parses",
"an",
"access",
"token",
"refresh",
"token",
"and",
"optional",
"expiry",
"unix",
"timestamp",
"separated",
"by",
"spaces",
"into",
"an",
"oauth2",
".",
"Token",
".",
"It",
"returns",
"as",
"much",
"as",
"it",
"can",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/gphotos/gphotos.go#L214-L230 | train |
perkeep/perkeep | pkg/blobserver/encrypt/encrypt.go | encryptBlob | func (s *storage) encryptBlob(ciphertext, plaintext []byte) []byte {
if s.key == [32]byte{} {
// Safety check, we really don't want this to happen.
panic("no passphrase set")
}
var nonce [24]byte
s.randNonce(&nonce)
ciphertext = append(ciphertext, version)
ciphertext = append(ciphertext, nonce[:]...)
return secretbox.Seal(ciphertext, plaintext, &nonce, &s.key)
} | go | func (s *storage) encryptBlob(ciphertext, plaintext []byte) []byte {
if s.key == [32]byte{} {
// Safety check, we really don't want this to happen.
panic("no passphrase set")
}
var nonce [24]byte
s.randNonce(&nonce)
ciphertext = append(ciphertext, version)
ciphertext = append(ciphertext, nonce[:]...)
return secretbox.Seal(ciphertext, plaintext, &nonce, &s.key)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"encryptBlob",
"(",
"ciphertext",
",",
"plaintext",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"s",
".",
"key",
"==",
"[",
"32",
"]",
"byte",
"{",
"}",
"{",
"panic",
"(",
"\"no passphrase set\"",
")",... | // encryptBlob encrypts plaintext and appends the result to ciphertext,
// which must not overlap plaintext. | [
"encryptBlob",
"encrypts",
"plaintext",
"and",
"appends",
"the",
"result",
"to",
"ciphertext",
"which",
"must",
"not",
"overlap",
"plaintext",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/encrypt.go#L123-L133 | train |
perkeep/perkeep | pkg/blobserver/encrypt/encrypt.go | decryptBlob | func (s *storage) decryptBlob(plaintext, ciphertext []byte) ([]byte, error) {
if len(ciphertext) < overhead {
return nil, errors.New("blob too short to be encrypted")
}
if ciphertext[0] != version {
return nil, errors.New("unknown encrypted blob version")
}
var nonce [24]byte
copy(nonce[:], ciphertext[1:])
plaintext, success := secretbox.Open(plaintext, ciphertext[25:], &nonce, &s.key)
if !success {
return nil, errors.New("encrypted blob failed authentication")
}
return plaintext, nil
} | go | func (s *storage) decryptBlob(plaintext, ciphertext []byte) ([]byte, error) {
if len(ciphertext) < overhead {
return nil, errors.New("blob too short to be encrypted")
}
if ciphertext[0] != version {
return nil, errors.New("unknown encrypted blob version")
}
var nonce [24]byte
copy(nonce[:], ciphertext[1:])
plaintext, success := secretbox.Open(plaintext, ciphertext[25:], &nonce, &s.key)
if !success {
return nil, errors.New("encrypted blob failed authentication")
}
return plaintext, nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"decryptBlob",
"(",
"plaintext",
",",
"ciphertext",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"ciphertext",
")",
"<",
"overhead",
"{",
"return",
"nil",
",",
"error... | // decryptBlob decrypts ciphertext and appends the result to plaintext,
// which must not overlap ciphertext. | [
"decryptBlob",
"decrypts",
"ciphertext",
"and",
"appends",
"the",
"result",
"to",
"plaintext",
"which",
"must",
"not",
"overlap",
"ciphertext",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/encrypt.go#L137-L151 | train |
perkeep/perkeep | pkg/sorted/sqlite/dbschema.go | InitDB | func InitDB(path string) error {
db, err := sql.Open("sqlite3", path)
if err != nil {
return err
}
defer db.Close()
for _, tableSQL := range SQLCreateTables() {
if _, err := db.Exec(tableSQL); err != nil {
return err
}
}
// Use Write Ahead Logging which improves SQLite concurrency.
// Requires SQLite >= 3.7.0
if _, err := db.Exec("PRAGMA journal_mode = WAL"); err != nil {
return err
}
// Check if the WAL mode was set correctly
var journalMode string
if err = db.QueryRow("PRAGMA journal_mode").Scan(&journalMode); err != nil {
log.Fatalf("Unable to determine sqlite3 journal_mode: %v", err)
}
if journalMode != "wal" {
log.Fatal("SQLite Write Ahead Logging (introducted in v3.7.0) is required. See http://perkeep.org/issue/114")
}
_, err = db.Exec(fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, SchemaVersion()))
return err
} | go | func InitDB(path string) error {
db, err := sql.Open("sqlite3", path)
if err != nil {
return err
}
defer db.Close()
for _, tableSQL := range SQLCreateTables() {
if _, err := db.Exec(tableSQL); err != nil {
return err
}
}
// Use Write Ahead Logging which improves SQLite concurrency.
// Requires SQLite >= 3.7.0
if _, err := db.Exec("PRAGMA journal_mode = WAL"); err != nil {
return err
}
// Check if the WAL mode was set correctly
var journalMode string
if err = db.QueryRow("PRAGMA journal_mode").Scan(&journalMode); err != nil {
log.Fatalf("Unable to determine sqlite3 journal_mode: %v", err)
}
if journalMode != "wal" {
log.Fatal("SQLite Write Ahead Logging (introducted in v3.7.0) is required. See http://perkeep.org/issue/114")
}
_, err = db.Exec(fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, SchemaVersion()))
return err
} | [
"func",
"InitDB",
"(",
"path",
"string",
")",
"error",
"{",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"\"sqlite3\"",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"db",
".",
"Close",
"(",... | // InitDB creates a new sqlite database based on the file at path. | [
"InitDB",
"creates",
"a",
"new",
"sqlite",
"database",
"based",
"on",
"the",
"file",
"at",
"path",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/sqlite/dbschema.go#L49-L78 | train |
perkeep/perkeep | dev/devcam/hook.go | hookGofmt | func (c *hookCmd) hookGofmt() error {
if os.Getenv("GIT_GOFMT_HOOK") == "off" {
printf("gofmt disabled by $GIT_GOFMT_HOOK=off\n")
return nil
}
files, err := c.runGofmt()
if err != nil {
printf("gofmt hook reported errors:\n\t%v\n", strings.Replace(strings.TrimSpace(err.Error()), "\n", "\n\t", -1))
return errors.New("gofmt errors")
}
if len(files) == 0 {
return nil
}
printf("You need to format with gofmt:\n\tgofmt -w %s\n",
strings.Join(files, " "))
return errors.New("gofmt required")
} | go | func (c *hookCmd) hookGofmt() error {
if os.Getenv("GIT_GOFMT_HOOK") == "off" {
printf("gofmt disabled by $GIT_GOFMT_HOOK=off\n")
return nil
}
files, err := c.runGofmt()
if err != nil {
printf("gofmt hook reported errors:\n\t%v\n", strings.Replace(strings.TrimSpace(err.Error()), "\n", "\n\t", -1))
return errors.New("gofmt errors")
}
if len(files) == 0 {
return nil
}
printf("You need to format with gofmt:\n\tgofmt -w %s\n",
strings.Join(files, " "))
return errors.New("gofmt required")
} | [
"func",
"(",
"c",
"*",
"hookCmd",
")",
"hookGofmt",
"(",
")",
"error",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"GIT_GOFMT_HOOK\"",
")",
"==",
"\"off\"",
"{",
"printf",
"(",
"\"gofmt disabled by $GIT_GOFMT_HOOK=off\\n\"",
")",
"\n",
"\\n",
"\n",
"}",
"\n",
"... | // hookGofmt runs a gofmt check on the local files matching the files in the
// git staging area.
// An error is returned if something went wrong or if some of the files need
// gofmting. In the latter case, the instruction is printed. | [
"hookGofmt",
"runs",
"a",
"gofmt",
"check",
"on",
"the",
"local",
"files",
"matching",
"the",
"files",
"in",
"the",
"git",
"staging",
"area",
".",
"An",
"error",
"is",
"returned",
"if",
"something",
"went",
"wrong",
"or",
"if",
"some",
"of",
"the",
"file... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L228-L245 | train |
perkeep/perkeep | dev/devcam/hook.go | runGofmt | func (c *hookCmd) runGofmt() (files []string, err error) {
repo, err := repoRoot()
if err != nil {
return nil, err
}
if !strings.HasSuffix(repo, string(filepath.Separator)) {
repo += string(filepath.Separator)
}
out, err := cmdOutputDirErr(".", "git", "diff-index", "--name-only", "--diff-filter=ACM", "--cached", "HEAD", "--", ":(glob)**/*.go", ":!/vendor/")
if err != nil {
return nil, err
}
indexFiles := addRoot(repo, nonBlankLines(out))
if len(indexFiles) == 0 {
return
}
args := []string{"-l"}
// TODO(mpl): it would be nice to TrimPrefix the pwd from each file to get a shorter output.
// However, since git sets the pwd to GIT_DIR before running the pre-commit hook, we lost
// the actual pwd from when we ran `git commit`, so no dice so far.
for _, file := range indexFiles {
args = append(args, file)
}
if c.verbose {
fmt.Fprintln(cmdmain.Stderr, commandString("gofmt", args))
}
cmd := exec.Command("gofmt", args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
if err != nil {
// Error but no stderr: usually can't find gofmt.
if stderr.Len() == 0 {
return nil, fmt.Errorf("invoking gofmt: %v", err)
}
return nil, fmt.Errorf("%s: %v", stderr.String(), err)
}
// Build file list.
files = lines(stdout.String())
sort.Strings(files)
return files, nil
} | go | func (c *hookCmd) runGofmt() (files []string, err error) {
repo, err := repoRoot()
if err != nil {
return nil, err
}
if !strings.HasSuffix(repo, string(filepath.Separator)) {
repo += string(filepath.Separator)
}
out, err := cmdOutputDirErr(".", "git", "diff-index", "--name-only", "--diff-filter=ACM", "--cached", "HEAD", "--", ":(glob)**/*.go", ":!/vendor/")
if err != nil {
return nil, err
}
indexFiles := addRoot(repo, nonBlankLines(out))
if len(indexFiles) == 0 {
return
}
args := []string{"-l"}
// TODO(mpl): it would be nice to TrimPrefix the pwd from each file to get a shorter output.
// However, since git sets the pwd to GIT_DIR before running the pre-commit hook, we lost
// the actual pwd from when we ran `git commit`, so no dice so far.
for _, file := range indexFiles {
args = append(args, file)
}
if c.verbose {
fmt.Fprintln(cmdmain.Stderr, commandString("gofmt", args))
}
cmd := exec.Command("gofmt", args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
if err != nil {
// Error but no stderr: usually can't find gofmt.
if stderr.Len() == 0 {
return nil, fmt.Errorf("invoking gofmt: %v", err)
}
return nil, fmt.Errorf("%s: %v", stderr.String(), err)
}
// Build file list.
files = lines(stdout.String())
sort.Strings(files)
return files, nil
} | [
"func",
"(",
"c",
"*",
"hookCmd",
")",
"runGofmt",
"(",
")",
"(",
"files",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"repo",
",",
"err",
":=",
"repoRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n"... | // runGofmt runs the external gofmt command over the local version of staged files.
// It returns the files that need gofmting. | [
"runGofmt",
"runs",
"the",
"external",
"gofmt",
"command",
"over",
"the",
"local",
"version",
"of",
"staged",
"files",
".",
"It",
"returns",
"the",
"files",
"that",
"need",
"gofmting",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L260-L307 | train |
perkeep/perkeep | dev/devcam/hook.go | nonBlankLines | func nonBlankLines(text string) []string {
var out []string
for _, s := range lines(text) {
if strings.TrimSpace(s) != "" {
out = append(out, s)
}
}
return out
} | go | func nonBlankLines(text string) []string {
var out []string
for _, s := range lines(text) {
if strings.TrimSpace(s) != "" {
out = append(out, s)
}
}
return out
} | [
"func",
"nonBlankLines",
"(",
"text",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"lines",
"(",
"text",
")",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
"!=",
"\"... | // nonBlankLines returns the non-blank lines in text. | [
"nonBlankLines",
"returns",
"the",
"non",
"-",
"blank",
"lines",
"in",
"text",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L322-L330 | train |
perkeep/perkeep | dev/devcam/hook.go | filter | func filter(f func(string) bool, list []string) []string {
var out []string
for _, x := range list {
if f(x) {
out = append(out, x)
}
}
return out
} | go | func filter(f func(string) bool, list []string) []string {
var out []string
for _, x := range list {
if f(x) {
out = append(out, x)
}
}
return out
} | [
"func",
"filter",
"(",
"f",
"func",
"(",
"string",
")",
"bool",
",",
"list",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"x",
":=",
"range",
"list",
"{",
"if",
"f",
"(",
"x",
")",... | // filter returns the elements in list satisfying f. | [
"filter",
"returns",
"the",
"elements",
"in",
"list",
"satisfying",
"f",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L333-L341 | train |
perkeep/perkeep | internal/osutil/osutil.go | DirExists | func DirExists(dir string) bool {
fi, err := os.Stat(dir)
return err == nil && fi.IsDir()
} | go | func DirExists(dir string) bool {
fi, err := os.Stat(dir)
return err == nil && fi.IsDir()
} | [
"func",
"DirExists",
"(",
"dir",
"string",
")",
"bool",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"return",
"err",
"==",
"nil",
"&&",
"fi",
".",
"IsDir",
"(",
")",
"\n",
"}"
] | // DirExists reports whether dir exists. Errors are ignored and are
// reported as false. | [
"DirExists",
"reports",
"whether",
"dir",
"exists",
".",
"Errors",
"are",
"ignored",
"and",
"are",
"reported",
"as",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/osutil.go#L33-L36 | train |
perkeep/perkeep | pkg/types/camtypes/errors.go | Err | func Err(key string) error {
v, ok := camErrors[key]
if !ok {
panic(fmt.Sprintf("unknown/unregistered error key %v", key))
}
return v
} | go | func Err(key string) error {
v, ok := camErrors[key]
if !ok {
panic(fmt.Sprintf("unknown/unregistered error key %v", key))
}
return v
} | [
"func",
"Err",
"(",
"key",
"string",
")",
"error",
"{",
"v",
",",
"ok",
":=",
"camErrors",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"unknown/unregistered error key %v\"",
",",
"key",
")",
")",
"\n",
"}"... | // Err returns the error registered for key.
// It panics for an unregistered key. | [
"Err",
"returns",
"the",
"error",
"registered",
"for",
"key",
".",
"It",
"panics",
"for",
"an",
"unregistered",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/types/camtypes/errors.go#L68-L74 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | IsDir | func IsDir(dir string) (bool, error) {
_, err := os.Stat(filepath.Join(dir, defaultIndexFile))
if os.IsNotExist(err) {
return false, nil
}
return err == nil, err
} | go | func IsDir(dir string) (bool, error) {
_, err := os.Stat(filepath.Join(dir, defaultIndexFile))
if os.IsNotExist(err) {
return false, nil
}
return err == nil, err
} | [
"func",
"IsDir",
"(",
"dir",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"defaultIndexFile",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err... | // IsDir reports whether dir is a diskpacked directory. | [
"IsDir",
"reports",
"whether",
"dir",
"is",
"a",
"diskpacked",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L115-L121 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | New | func New(dir string) (blobserver.Storage, error) {
var maxSize int64
if ok, _ := IsDir(dir); ok {
// TODO: detect existing max size from size of files, if obvious,
// and set maxSize to that?
}
return newStorage(dir, maxSize, nil)
} | go | func New(dir string) (blobserver.Storage, error) {
var maxSize int64
if ok, _ := IsDir(dir); ok {
// TODO: detect existing max size from size of files, if obvious,
// and set maxSize to that?
}
return newStorage(dir, maxSize, nil)
} | [
"func",
"New",
"(",
"dir",
"string",
")",
"(",
"blobserver",
".",
"Storage",
",",
"error",
")",
"{",
"var",
"maxSize",
"int64",
"\n",
"if",
"ok",
",",
"_",
":=",
"IsDir",
"(",
"dir",
")",
";",
"ok",
"{",
"}",
"\n",
"return",
"newStorage",
"(",
"d... | // New returns a diskpacked storage implementation, adding blobs to
// the provided directory. It doesn't delete any existing blob pack
// files. | [
"New",
"returns",
"a",
"diskpacked",
"storage",
"implementation",
"adding",
"blobs",
"to",
"the",
"provided",
"directory",
".",
"It",
"doesn",
"t",
"delete",
"any",
"existing",
"blob",
"pack",
"files",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L126-L133 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | newIndex | func newIndex(root string, indexConf jsonconfig.Obj) (sorted.KeyValue, error) {
if len(indexConf) > 0 {
return sorted.NewKeyValueMaybeWipe(indexConf)
}
return sorted.NewKeyValueMaybeWipe(jsonconfig.Obj{
"type": defaultIndexType,
"file": filepath.Join(root, defaultIndexFile),
})
} | go | func newIndex(root string, indexConf jsonconfig.Obj) (sorted.KeyValue, error) {
if len(indexConf) > 0 {
return sorted.NewKeyValueMaybeWipe(indexConf)
}
return sorted.NewKeyValueMaybeWipe(jsonconfig.Obj{
"type": defaultIndexType,
"file": filepath.Join(root, defaultIndexFile),
})
} | [
"func",
"newIndex",
"(",
"root",
"string",
",",
"indexConf",
"jsonconfig",
".",
"Obj",
")",
"(",
"sorted",
".",
"KeyValue",
",",
"error",
")",
"{",
"if",
"len",
"(",
"indexConf",
")",
">",
"0",
"{",
"return",
"sorted",
".",
"NewKeyValueMaybeWipe",
"(",
... | // newIndex returns a new sorted.KeyValue, using either the given config, or the default. | [
"newIndex",
"returns",
"a",
"new",
"sorted",
".",
"KeyValue",
"using",
"either",
"the",
"given",
"config",
"or",
"the",
"default",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L136-L144 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | openForRead | func (s *storage) openForRead(n int) error {
if n > len(s.fds) {
panic(fmt.Sprintf("openForRead called out of order got %d, expected %d", n, len(s.fds)))
}
fn := s.filename(n)
f, err := os.Open(fn)
if err != nil {
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for read %q", fn)
s.fds = append(s.fds, f)
return nil
} | go | func (s *storage) openForRead(n int) error {
if n > len(s.fds) {
panic(fmt.Sprintf("openForRead called out of order got %d, expected %d", n, len(s.fds)))
}
fn := s.filename(n)
f, err := os.Open(fn)
if err != nil {
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for read %q", fn)
s.fds = append(s.fds, f)
return nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"openForRead",
"(",
"n",
"int",
")",
"error",
"{",
"if",
"n",
">",
"len",
"(",
"s",
".",
"fds",
")",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"openForRead called out of order got %d, expected %d\"",
",",
"n"... | // openForRead will open pack file n for read and keep a handle to it in
// s.fds. os.IsNotExist returned if n >= the number of pack files in s.root.
// This function is not thread safe, s.mu should be locked by the caller. | [
"openForRead",
"will",
"open",
"pack",
"file",
"n",
"for",
"read",
"and",
"keep",
"a",
"handle",
"to",
"it",
"in",
"s",
".",
"fds",
".",
"os",
".",
"IsNotExist",
"returned",
"if",
"n",
">",
"=",
"the",
"number",
"of",
"pack",
"files",
"in",
"s",
".... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L212-L226 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | openForWrite | func (s *storage) openForWrite(n int) error {
fn := s.filename(n)
l, err := lock.Lock(fn + ".lock")
if err != nil {
return err
}
f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
l.Close()
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for write %q", fn)
s.size, err = f.Seek(0, os.SEEK_END)
if err != nil {
f.Close()
l.Close()
return err
}
s.writer = f
s.writeLock = l
return nil
} | go | func (s *storage) openForWrite(n int) error {
fn := s.filename(n)
l, err := lock.Lock(fn + ".lock")
if err != nil {
return err
}
f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
l.Close()
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for write %q", fn)
s.size, err = f.Seek(0, os.SEEK_END)
if err != nil {
f.Close()
l.Close()
return err
}
s.writer = f
s.writeLock = l
return nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"openForWrite",
"(",
"n",
"int",
")",
"error",
"{",
"fn",
":=",
"s",
".",
"filename",
"(",
"n",
")",
"\n",
"l",
",",
"err",
":=",
"lock",
".",
"Lock",
"(",
"fn",
"+",
"\".lock\"",
")",
"\n",
"if",
"err",
... | // openForWrite will create or open pack file n for writes, create a lock
// visible external to the process and seek to the end of the file ready for
// appending new data.
// This function is not thread safe, s.mu should be locked by the caller. | [
"openForWrite",
"will",
"create",
"or",
"open",
"pack",
"file",
"n",
"for",
"writes",
"create",
"a",
"lock",
"visible",
"external",
"to",
"the",
"process",
"and",
"seek",
"to",
"the",
"end",
"of",
"the",
"file",
"ready",
"for",
"appending",
"new",
"data",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L232-L256 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | closePack | func (s *storage) closePack() error {
var err error
if s.writer != nil {
err = s.writer.Close()
openFdsVar.Add(s.root, -1)
s.writer = nil
}
if s.writeLock != nil {
lerr := s.writeLock.Close()
if err == nil {
err = lerr
}
s.writeLock = nil
}
return err
} | go | func (s *storage) closePack() error {
var err error
if s.writer != nil {
err = s.writer.Close()
openFdsVar.Add(s.root, -1)
s.writer = nil
}
if s.writeLock != nil {
lerr := s.writeLock.Close()
if err == nil {
err = lerr
}
s.writeLock = nil
}
return err
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"closePack",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"s",
".",
"writer",
"!=",
"nil",
"{",
"err",
"=",
"s",
".",
"writer",
".",
"Close",
"(",
")",
"\n",
"openFdsVar",
".",
"Add",
"(",
"s... | // closePack opens any pack file currently open for writing. | [
"closePack",
"opens",
"any",
"pack",
"file",
"currently",
"open",
"for",
"writing",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L259-L274 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | nextPack | func (s *storage) nextPack() error {
debug.Println("diskpacked: nextPack")
s.size = 0
if err := s.closePack(); err != nil {
return err
}
n := len(s.fds)
if err := s.openForWrite(n); err != nil {
return err
}
return s.openForRead(n)
} | go | func (s *storage) nextPack() error {
debug.Println("diskpacked: nextPack")
s.size = 0
if err := s.closePack(); err != nil {
return err
}
n := len(s.fds)
if err := s.openForWrite(n); err != nil {
return err
}
return s.openForRead(n)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"nextPack",
"(",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"diskpacked: nextPack\"",
")",
"\n",
"s",
".",
"size",
"=",
"0",
"\n",
"if",
"err",
":=",
"s",
".",
"closePack",
"(",
")",
";",
"err",
"!=",
... | // nextPack will close the current writer and release its lock if open,
// open the next pack file in sequence for writing, grab its lock, set it
// to the currently active writer, and open another copy for read-only use.
// This function is not thread safe, s.mu should be locked by the caller. | [
"nextPack",
"will",
"close",
"the",
"current",
"writer",
"and",
"release",
"its",
"lock",
"if",
"open",
"open",
"the",
"next",
"pack",
"file",
"in",
"sequence",
"for",
"writing",
"grab",
"its",
"lock",
"set",
"it",
"to",
"the",
"currently",
"active",
"writ... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L280-L291 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | openAllPacks | func (s *storage) openAllPacks() error {
debug.Println("diskpacked: openAllPacks")
n := 0
for {
err := s.openForRead(n)
if os.IsNotExist(err) {
break
}
if err != nil {
return err
}
n++
}
if n == 0 {
// If no pack files are found, we create one open for read and write.
return s.nextPack()
}
// If 1 or more pack files are found, open the last one read and write.
return s.openForWrite(n - 1)
} | go | func (s *storage) openAllPacks() error {
debug.Println("diskpacked: openAllPacks")
n := 0
for {
err := s.openForRead(n)
if os.IsNotExist(err) {
break
}
if err != nil {
return err
}
n++
}
if n == 0 {
// If no pack files are found, we create one open for read and write.
return s.nextPack()
}
// If 1 or more pack files are found, open the last one read and write.
return s.openForWrite(n - 1)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"openAllPacks",
"(",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"diskpacked: openAllPacks\"",
")",
"\n",
"n",
":=",
"0",
"\n",
"for",
"{",
"err",
":=",
"s",
".",
"openForRead",
"(",
"n",
")",
"\n",
"if",... | // openAllPacks opens read-only each pack file in s.root, populating s.fds.
// The latest pack file will also have a writable handle opened.
// This function is not thread safe, s.mu should be locked by the caller. | [
"openAllPacks",
"opens",
"read",
"-",
"only",
"each",
"pack",
"file",
"in",
"s",
".",
"root",
"populating",
"s",
".",
"fds",
".",
"The",
"latest",
"pack",
"file",
"will",
"also",
"have",
"a",
"writable",
"handle",
"opened",
".",
"This",
"function",
"is",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L296-L317 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | Close | func (s *storage) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
var closeErr error
s.closed = true
if err := s.index.Close(); err != nil {
log.Println("diskpacked: closing index:", err)
}
for _, f := range s.fds {
err := f.Close()
openFdsVar.Add(s.root, -1)
if err != nil {
closeErr = err
}
}
if err := s.closePack(); err != nil && closeErr == nil {
closeErr = err
}
return closeErr
} | go | func (s *storage) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
var closeErr error
s.closed = true
if err := s.index.Close(); err != nil {
log.Println("diskpacked: closing index:", err)
}
for _, f := range s.fds {
err := f.Close()
openFdsVar.Add(s.root, -1)
if err != nil {
closeErr = err
}
}
if err := s.closePack(); err != nil && closeErr == nil {
closeErr = err
}
return closeErr
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"v... | // Close index and all opened fds, with locking. | [
"Close",
"index",
"and",
"all",
"opened",
"fds",
"with",
"locking",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L320-L342 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | fetch | func (s *storage) fetch(ctx context.Context, br blob.Ref, offset, length int64) (rc io.ReadCloser, size uint32, err error) {
meta, err := s.meta(br)
if err != nil {
return nil, 0, err
}
if meta.file >= len(s.fds) {
return nil, 0, fmt.Errorf("diskpacked: attempt to fetch blob from out of range pack file %d > %d", meta.file, len(s.fds))
}
rac := s.fds[meta.file]
var rs io.ReadSeeker
if length == -1 {
// normal Fetch mode
rs = io.NewSectionReader(rac, meta.offset, int64(meta.size))
} else {
if offset > int64(meta.size) {
return nil, 0, blob.ErrOutOfRangeOffsetSubFetch
} else if offset+length > int64(meta.size) {
length = int64(meta.size) - offset
}
rs = io.NewSectionReader(rac, meta.offset+offset, length)
}
fn := rac.Name()
// Ensure entry is in map.
readVar.Add(fn, 0)
if v, ok := readVar.Get(fn).(*expvar.Int); ok {
rs = readerutil.NewStatsReadSeeker(v, rs)
}
readTotVar.Add(s.root, 0)
if v, ok := readTotVar.Get(s.root).(*expvar.Int); ok {
rs = readerutil.NewStatsReadSeeker(v, rs)
}
rsc := struct {
io.ReadSeeker
io.Closer
}{
rs,
types.NopCloser,
}
return rsc, meta.size, nil
} | go | func (s *storage) fetch(ctx context.Context, br blob.Ref, offset, length int64) (rc io.ReadCloser, size uint32, err error) {
meta, err := s.meta(br)
if err != nil {
return nil, 0, err
}
if meta.file >= len(s.fds) {
return nil, 0, fmt.Errorf("diskpacked: attempt to fetch blob from out of range pack file %d > %d", meta.file, len(s.fds))
}
rac := s.fds[meta.file]
var rs io.ReadSeeker
if length == -1 {
// normal Fetch mode
rs = io.NewSectionReader(rac, meta.offset, int64(meta.size))
} else {
if offset > int64(meta.size) {
return nil, 0, blob.ErrOutOfRangeOffsetSubFetch
} else if offset+length > int64(meta.size) {
length = int64(meta.size) - offset
}
rs = io.NewSectionReader(rac, meta.offset+offset, length)
}
fn := rac.Name()
// Ensure entry is in map.
readVar.Add(fn, 0)
if v, ok := readVar.Get(fn).(*expvar.Int); ok {
rs = readerutil.NewStatsReadSeeker(v, rs)
}
readTotVar.Add(s.root, 0)
if v, ok := readTotVar.Get(s.root).(*expvar.Int); ok {
rs = readerutil.NewStatsReadSeeker(v, rs)
}
rsc := struct {
io.ReadSeeker
io.Closer
}{
rs,
types.NopCloser,
}
return rsc, meta.size, nil
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"offset",
",",
"length",
"int64",
")",
"(",
"rc",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
... | // length of -1 means all | [
"length",
"of",
"-",
"1",
"means",
"all"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L357-L397 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.