repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
perkeep/perkeep | pkg/index/corpus.go | str | func (c *Corpus) str(s string) string {
if s == "" {
return ""
}
if s, ok := c.strs[s]; ok {
return s
}
if c.strs == nil {
c.strs = make(map[string]string)
}
c.strs[s] = s
return s
} | go | func (c *Corpus) str(s string) string {
if s == "" {
return ""
}
if s, ok := c.strs[s]; ok {
return s
}
if c.strs == nil {
c.strs = make(map[string]string)
}
c.strs[s] = s
return s
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"str",
"(",
"s",
"string",
")",
"string",
"{",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"s",
",",
"ok",
":=",
"c",
".",
"strs",
"[",
"s",
"]",
";",
"ok",
"{",
"re... | // str returns s, interned. | [
"str",
"returns",
"s",
"interned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L933-L945 | train |
perkeep/perkeep | pkg/index/corpus.go | br | func (c *Corpus) br(br blob.Ref) blob.Ref {
if bm, ok := c.blobs[br]; ok {
c.brInterns++
return bm.Ref
}
return br
} | go | func (c *Corpus) br(br blob.Ref) blob.Ref {
if bm, ok := c.blobs[br]; ok {
c.brInterns++
return bm.Ref
}
return br
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"br",
"(",
"br",
"blob",
".",
"Ref",
")",
"blob",
".",
"Ref",
"{",
"if",
"bm",
",",
"ok",
":=",
"c",
".",
"blobs",
"[",
"br",
"]",
";",
"ok",
"{",
"c",
".",
"brInterns",
"++",
"\n",
"return",
"bm",
".",... | // br returns br, interned. | [
"br",
"returns",
"br",
"interned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L948-L954 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumerateBlobMeta | func (c *Corpus) EnumerateBlobMeta(fn func(camtypes.BlobMeta) bool) {
for _, bm := range c.blobs {
if !fn(*bm) {
return
}
}
} | go | func (c *Corpus) EnumerateBlobMeta(fn func(camtypes.BlobMeta) bool) {
for _, bm := range c.blobs {
if !fn(*bm) {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumerateBlobMeta",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
")",
"{",
"for",
"_",
",",
"bm",
":=",
"range",
"c",
".",
"blobs",
"{",
"if",
"!",
"fn",
"(",
"*",
"bm",
")",
"{",
"ret... | // EnumerateBlobMeta calls fn for all known meta blobs in an undefined
// order.
// If fn returns false, iteration ends. | [
"EnumerateBlobMeta",
"calls",
"fn",
"for",
"all",
"known",
"meta",
"blobs",
"in",
"an",
"undefined",
"order",
".",
"If",
"fn",
"returns",
"false",
"iteration",
"ends",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L985-L991 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumeratePermanodesLastModified | func (c *Corpus) EnumeratePermanodesLastModified(fn func(camtypes.BlobMeta) bool) {
c.enumeratePermanodes(fn, c.permanodesByModtime.sorted(true))
} | go | func (c *Corpus) EnumeratePermanodesLastModified(fn func(camtypes.BlobMeta) bool) {
c.enumeratePermanodes(fn, c.permanodesByModtime.sorted(true))
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumeratePermanodesLastModified",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
")",
"{",
"c",
".",
"enumeratePermanodes",
"(",
"fn",
",",
"c",
".",
"permanodesByModtime",
".",
"sorted",
"(",
"true... | // EnumeratePermanodesLastModified calls fn for all permanodes, sorted by most recently modified first.
// Iteration ends prematurely if fn returns false. | [
"EnumeratePermanodesLastModified",
"calls",
"fn",
"for",
"all",
"permanodes",
"sorted",
"by",
"most",
"recently",
"modified",
"first",
".",
"Iteration",
"ends",
"prematurely",
"if",
"fn",
"returns",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1094-L1096 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumeratePermanodesCreated | func (c *Corpus) EnumeratePermanodesCreated(fn func(camtypes.BlobMeta) bool, newestFirst bool) {
c.enumeratePermanodes(fn, c.permanodesByTime.sorted(newestFirst))
} | go | func (c *Corpus) EnumeratePermanodesCreated(fn func(camtypes.BlobMeta) bool, newestFirst bool) {
c.enumeratePermanodes(fn, c.permanodesByTime.sorted(newestFirst))
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumeratePermanodesCreated",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
",",
"newestFirst",
"bool",
")",
"{",
"c",
".",
"enumeratePermanodes",
"(",
"fn",
",",
"c",
".",
"permanodesByTime",
".",
... | // EnumeratePermanodesCreated calls fn for all permanodes.
// They are sorted using the contents creation date if any, the permanode modtime
// otherwise, and in the order specified by newestFirst.
// Iteration ends prematurely if fn returns false. | [
"EnumeratePermanodesCreated",
"calls",
"fn",
"for",
"all",
"permanodes",
".",
"They",
"are",
"sorted",
"using",
"the",
"contents",
"creation",
"date",
"if",
"any",
"the",
"permanode",
"modtime",
"otherwise",
"and",
"in",
"the",
"order",
"specified",
"by",
"newes... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1102-L1104 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumerateSingleBlob | func (c *Corpus) EnumerateSingleBlob(fn func(camtypes.BlobMeta) bool, br blob.Ref) {
if bm := c.blobs[br]; bm != nil {
fn(*bm)
}
} | go | func (c *Corpus) EnumerateSingleBlob(fn func(camtypes.BlobMeta) bool, br blob.Ref) {
if bm := c.blobs[br]; bm != nil {
fn(*bm)
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumerateSingleBlob",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
",",
"br",
"blob",
".",
"Ref",
")",
"{",
"if",
"bm",
":=",
"c",
".",
"blobs",
"[",
"br",
"]",
";",
"bm",
"!=",
"nil",
... | // EnumerateSingleBlob calls fn with br's BlobMeta if br exists in the corpus. | [
"EnumerateSingleBlob",
"calls",
"fn",
"with",
"br",
"s",
"BlobMeta",
"if",
"br",
"exists",
"in",
"the",
"corpus",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1107-L1111 | train |
perkeep/perkeep | pkg/index/corpus.go | EnumeratePermanodesByNodeTypes | func (c *Corpus) EnumeratePermanodesByNodeTypes(fn func(camtypes.BlobMeta) bool, camliNodeTypes []string) {
for _, t := range camliNodeTypes {
set := c.permanodesSetByNodeType[t]
for br := range set {
if bm := c.blobs[br]; bm != nil {
if !fn(*bm) {
return
}
}
}
}
} | go | func (c *Corpus) EnumeratePermanodesByNodeTypes(fn func(camtypes.BlobMeta) bool, camliNodeTypes []string) {
for _, t := range camliNodeTypes {
set := c.permanodesSetByNodeType[t]
for br := range set {
if bm := c.blobs[br]; bm != nil {
if !fn(*bm) {
return
}
}
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"EnumeratePermanodesByNodeTypes",
"(",
"fn",
"func",
"(",
"camtypes",
".",
"BlobMeta",
")",
"bool",
",",
"camliNodeTypes",
"[",
"]",
"string",
")",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"camliNodeTypes",
"{",
"se... | // EnumeratePermanodesByNodeTypes enumerates over all permanodes that might
// have one of the provided camliNodeType values, calling fn for each. If fn returns false,
// enumeration ends. | [
"EnumeratePermanodesByNodeTypes",
"enumerates",
"over",
"all",
"permanodes",
"that",
"might",
"have",
"one",
"of",
"the",
"provided",
"camliNodeType",
"values",
"calling",
"fn",
"for",
"each",
".",
"If",
"fn",
"returns",
"false",
"enumeration",
"ends",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1116-L1127 | train |
perkeep/perkeep | pkg/index/corpus.go | PermanodeTime | func (c *Corpus) PermanodeTime(pn blob.Ref) (t time.Time, ok bool) {
// TODO(bradfitz): keep this time property cached on the permanode / files
// TODO(bradfitz): finish implmenting all these
// Priorities:
// -- Permanode explicit "camliTime" property
// -- EXIF GPS time
// -- Exif camera time - this one is act... | go | func (c *Corpus) PermanodeTime(pn blob.Ref) (t time.Time, ok bool) {
// TODO(bradfitz): keep this time property cached on the permanode / files
// TODO(bradfitz): finish implmenting all these
// Priorities:
// -- Permanode explicit "camliTime" property
// -- EXIF GPS time
// -- Exif camera time - this one is act... | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeTime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"// TODO(bradfitz): keep this time property cached on the permanode / files",
"// TODO(bradfitz): finish implmenting ... | // PermanodeTime returns the time of the content in permanode. | [
"PermanodeTime",
"returns",
"the",
"time",
"of",
"the",
"content",
"in",
"permanode",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1154-L1199 | train |
perkeep/perkeep | pkg/index/corpus.go | PermanodeAnyTime | func (c *Corpus) PermanodeAnyTime(pn blob.Ref) (t time.Time, ok bool) {
if t, ok := c.PermanodeTime(pn); ok {
return t, ok
}
return c.PermanodeModtime(pn)
} | go | func (c *Corpus) PermanodeAnyTime(pn blob.Ref) (t time.Time, ok bool) {
if t, ok := c.PermanodeTime(pn); ok {
return t, ok
}
return c.PermanodeModtime(pn)
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeAnyTime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"if",
"t",
",",
"ok",
":=",
"c",
".",
"PermanodeTime",
"(",
"pn",
")",
";",
"ok",
"{",
"... | // PermanodeAnyTime returns the time that best qualifies the permanode.
// It tries content-specific times first, the permanode modtime otherwise. | [
"PermanodeAnyTime",
"returns",
"the",
"time",
"that",
"best",
"qualifies",
"the",
"permanode",
".",
"It",
"tries",
"content",
"-",
"specific",
"times",
"first",
"the",
"permanode",
"modtime",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1203-L1208 | train |
perkeep/perkeep | pkg/index/corpus.go | PermanodeModtime | func (c *Corpus) PermanodeModtime(pn blob.Ref) (t time.Time, ok bool) {
pm, ok := c.permanodes[pn]
if !ok {
return
}
// Note: We intentionally don't try to derive any information
// (except the owner, elsewhere) from the permanode blob
// itself. Even though the permanode blob sometimes has the
// GPG signatu... | go | func (c *Corpus) PermanodeModtime(pn blob.Ref) (t time.Time, ok bool) {
pm, ok := c.permanodes[pn]
if !ok {
return
}
// Note: We intentionally don't try to derive any information
// (except the owner, elsewhere) from the permanode blob
// itself. Even though the permanode blob sometimes has the
// GPG signatu... | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeModtime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"pm",
",",
"ok",
":=",
"c",
".",
"permanodes",
"[",
"pn",
"]",
"\n",
"if",
"!",
"ok",
"{... | // PermanodeModtime returns the latest modification time of the given
// permanode.
//
// The ok value is true only if the permanode is known and has any
// non-deleted claims. A deleted claim is ignored and neither its
// claim date nor the date of the delete claim affect the modtime of
// the permanode. | [
"PermanodeModtime",
"returns",
"the",
"latest",
"modification",
"time",
"of",
"the",
"given",
"permanode",
".",
"The",
"ok",
"value",
"is",
"true",
"only",
"if",
"the",
"permanode",
"is",
"known",
"and",
"has",
"any",
"non",
"-",
"deleted",
"claims",
".",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1241-L1260 | train |
perkeep/perkeep | pkg/index/corpus.go | ForeachClaim | func (c *Corpus) ForeachClaim(permaNode blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
pm, ok := c.permanodes[permaNode]
if !ok {
return
}
for _, cl := range pm.Claims {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | go | func (c *Corpus) ForeachClaim(permaNode blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
pm, ok := c.permanodes[permaNode]
if !ok {
return
}
for _, cl := range pm.Claims {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"ForeachClaim",
"(",
"permaNode",
"blob",
".",
"Ref",
",",
"at",
"time",
".",
"Time",
",",
"fn",
"func",
"(",
"*",
"camtypes",
".",
"Claim",
")",
"bool",
")",
"{",
"pm",
",",
"ok",
":=",
"c",
".",
"permanodes... | // ForeachClaim calls fn for each claim of permaNode.
// If at is zero, all claims are yielded.
// If at is non-zero, claims after that point are skipped.
// If fn returns false, iteration ends.
// Iteration is in an undefined order. | [
"ForeachClaim",
"calls",
"fn",
"for",
"each",
"claim",
"of",
"permaNode",
".",
"If",
"at",
"is",
"zero",
"all",
"claims",
"are",
"yielded",
".",
"If",
"at",
"is",
"non",
"-",
"zero",
"claims",
"after",
"that",
"point",
"are",
"skipped",
".",
"If",
"fn"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1495-L1508 | train |
perkeep/perkeep | pkg/index/corpus.go | ForeachClaimBack | func (c *Corpus) ForeachClaimBack(value blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
for _, cl := range c.claimBack[value] {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | go | func (c *Corpus) ForeachClaimBack(value blob.Ref, at time.Time, fn func(*camtypes.Claim) bool) {
for _, cl := range c.claimBack[value] {
if !at.IsZero() && cl.Date.After(at) {
continue
}
if !fn(cl) {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Corpus",
")",
"ForeachClaimBack",
"(",
"value",
"blob",
".",
"Ref",
",",
"at",
"time",
".",
"Time",
",",
"fn",
"func",
"(",
"*",
"camtypes",
".",
"Claim",
")",
"bool",
")",
"{",
"for",
"_",
",",
"cl",
":=",
"range",
"c",
... | // ForeachClaimBack calls fn for each claim with a value referencing br.
// If at is zero, all claims are yielded.
// If at is non-zero, claims after that point are skipped.
// If fn returns false, iteration ends.
// Iteration is in an undefined order. | [
"ForeachClaimBack",
"calls",
"fn",
"for",
"each",
"claim",
"with",
"a",
"value",
"referencing",
"br",
".",
"If",
"at",
"is",
"zero",
"all",
"claims",
"are",
"yielded",
".",
"If",
"at",
"is",
"non",
"-",
"zero",
"claims",
"after",
"that",
"point",
"are",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1515-L1524 | train |
perkeep/perkeep | pkg/blobserver/local/generation.go | ResetStorageGeneration | func (g Generationer) ResetStorageGeneration() error {
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rand.Reader, 20); err != nil {
return err
}
hex := fmt.Sprintf("%x", buf.Bytes())
buf.Reset()
buf.WriteString(hex)
buf.WriteString(`
This file's random string on the first line is an optimization and
parano... | go | func (g Generationer) ResetStorageGeneration() error {
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rand.Reader, 20); err != nil {
return err
}
hex := fmt.Sprintf("%x", buf.Bytes())
buf.Reset()
buf.WriteString(hex)
buf.WriteString(`
This file's random string on the first line is an optimization and
parano... | [
"func",
"(",
"g",
"Generationer",
")",
"ResetStorageGeneration",
"(",
")",
"error",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"CopyN",
"(",
"&",
"buf",
",",
"rand",
".",
"Reader",
",",
"20",
")",
";",
... | // ResetStorageGeneration reinitializes the generation by recreating the
// GENERATION.dat file with a new random string | [
"ResetStorageGeneration",
"reinitializes",
"the",
"generation",
"by",
"recreating",
"the",
"GENERATION",
".",
"dat",
"file",
"with",
"a",
"new",
"random",
"string"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/local/generation.go#L78-L105 | train |
perkeep/perkeep | internal/gpgagent/gpgagent.go | NewConn | func NewConn() (*Conn, error) {
sp := strings.SplitN(os.Getenv("GPG_AGENT_INFO"), ":", 3)
if len(sp) == 0 || len(sp[0]) == 0 {
return nil, ErrNoAgent
}
addr := &net.UnixAddr{Net: "unix", Name: sp[0]}
uc, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, err
}
br := bufio.NewReader(uc)
line... | go | func NewConn() (*Conn, error) {
sp := strings.SplitN(os.Getenv("GPG_AGENT_INFO"), ":", 3)
if len(sp) == 0 || len(sp[0]) == 0 {
return nil, ErrNoAgent
}
addr := &net.UnixAddr{Net: "unix", Name: sp[0]}
uc, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, err
}
br := bufio.NewReader(uc)
line... | [
"func",
"NewConn",
"(",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"sp",
":=",
"strings",
".",
"SplitN",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
"3",
")",
"\n",
"if",
"len",
"(",
"sp",
")",
"==",
"0",
"||",... | // NewConn connects to the GPG Agent as described in the
// GPG_AGENT_INFO environment variable. | [
"NewConn",
"connects",
"to",
"the",
"GPG",
"Agent",
"as",
"described",
"in",
"the",
"GPG_AGENT_INFO",
"environment",
"variable",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/gpgagent/gpgagent.go#L49-L69 | train |
perkeep/perkeep | pkg/search/describe.go | Describe | func (sh *Handler) Describe(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
sh.index.RLock()
defer sh.index.RUnlock()
return sh.DescribeLocked(ctx, dr)
} | go | func (sh *Handler) Describe(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
sh.index.RLock()
defer sh.index.RUnlock()
return sh.DescribeLocked(ctx, dr)
} | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"Describe",
"(",
"ctx",
"context",
".",
"Context",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"dres",
"*",
"DescribeResponse",
",",
"err",
"error",
")",
"{",
"sh",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
... | // Describe returns a response for the given describe request. It acquires RLock
// on the Handler's index. | [
"Describe",
"returns",
"a",
"response",
"for",
"the",
"given",
"describe",
"request",
".",
"It",
"acquires",
"RLock",
"on",
"the",
"Handler",
"s",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L58-L63 | train |
perkeep/perkeep | pkg/search/describe.go | DescribeLocked | func (sh *Handler) DescribeLocked(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
if verboseDescribe {
t0 := time.Now()
defer func() {
td := time.Since(t0)
var num int
if dres != nil {
num = len(dres.Meta)
}
log.Printf("Described %d blobs in %v", num, td)
}()
}... | go | func (sh *Handler) DescribeLocked(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
if verboseDescribe {
t0 := time.Now()
defer func() {
td := time.Since(t0)
var num int
if dres != nil {
num = len(dres.Meta)
}
log.Printf("Described %d blobs in %v", num, td)
}()
}... | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"DescribeLocked",
"(",
"ctx",
"context",
".",
"Context",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"dres",
"*",
"DescribeResponse",
",",
"err",
"error",
")",
"{",
"if",
"verboseDescribe",
"{",
"t0",
":=",
"time"... | // DescribeLocked returns a response for the given describe request. It is the
// caller's responsibility to lock the search handler's index. | [
"DescribeLocked",
"returns",
"a",
"response",
"for",
"the",
"given",
"describe",
"request",
".",
"It",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"lock",
"the",
"search",
"handler",
"s",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L67-L94 | train |
perkeep/perkeep | pkg/search/describe.go | flatRules | func (dr *DescribeRequest) flatRules() []*DescribeRule {
if dr.flatRuleCache == nil {
dr.flatRuleCache = make([]*DescribeRule, 0)
for _, rule := range dr.Rules {
rule.appendToFlatCache(dr)
}
}
return dr.flatRuleCache
} | go | func (dr *DescribeRequest) flatRules() []*DescribeRule {
if dr.flatRuleCache == nil {
dr.flatRuleCache = make([]*DescribeRule, 0)
for _, rule := range dr.Rules {
rule.appendToFlatCache(dr)
}
}
return dr.flatRuleCache
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"flatRules",
"(",
")",
"[",
"]",
"*",
"DescribeRule",
"{",
"if",
"dr",
".",
"flatRuleCache",
"==",
"nil",
"{",
"dr",
".",
"flatRuleCache",
"=",
"make",
"(",
"[",
"]",
"*",
"DescribeRule",
",",
"0",
")",... | // Requires dr.mu is held | [
"Requires",
"dr",
".",
"mu",
"is",
"held"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L146-L154 | train |
perkeep/perkeep | pkg/search/describe.go | URLSuffix | func (dr *DescribeRequest) URLSuffix() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camli/search/describe?depth=%d&maxdirchildren=%d",
dr.depth(), dr.maxDirChildren())
for _, br := range dr.BlobRefs {
buf.WriteString("&blobref=")
buf.WriteString(br.String())
}
if len(dr.BlobRefs) == 0 && dr.BlobRef.Valid... | go | func (dr *DescribeRequest) URLSuffix() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camli/search/describe?depth=%d&maxdirchildren=%d",
dr.depth(), dr.maxDirChildren())
for _, br := range dr.BlobRefs {
buf.WriteString("&blobref=")
buf.WriteString(br.String())
}
if len(dr.BlobRefs) == 0 && dr.BlobRef.Valid... | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"URLSuffix",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"",
"\"",
",",
"dr",
".",
"depth",
"(",
")",
",",
"dr",
".",
"maxDirC... | // URLSuffix returns the URL suffix for GET requests.
// This is deprecated. | [
"URLSuffix",
"returns",
"the",
"URL",
"suffix",
"for",
"GET",
"requests",
".",
"This",
"is",
"deprecated",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L279-L296 | train |
perkeep/perkeep | pkg/search/describe.go | PermanodeFile | func (b *DescribedBlob) PermanodeFile() (path []blob.Ref, fi *camtypes.FileInfo, ok bool) {
if b == nil || b.Permanode == nil {
return
}
if contentRef := b.Permanode.Attr.Get("camliContent"); contentRef != "" {
if cdes := b.Request.DescribedBlobStr(contentRef); cdes != nil && cdes.File != nil {
return []blob.... | go | func (b *DescribedBlob) PermanodeFile() (path []blob.Ref, fi *camtypes.FileInfo, ok bool) {
if b == nil || b.Permanode == nil {
return
}
if contentRef := b.Permanode.Attr.Get("camliContent"); contentRef != "" {
if cdes := b.Request.DescribedBlobStr(contentRef); cdes != nil && cdes.File != nil {
return []blob.... | [
"func",
"(",
"b",
"*",
"DescribedBlob",
")",
"PermanodeFile",
"(",
")",
"(",
"path",
"[",
"]",
"blob",
".",
"Ref",
",",
"fi",
"*",
"camtypes",
".",
"FileInfo",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"Permanode",
"=="... | // PermanodeFile returns in path the blobref of the described permanode
// and the blobref of its File camliContent.
// If b isn't a permanode, or doesn't have a camliContent that
// is a file blob, ok is false. | [
"PermanodeFile",
"returns",
"in",
"path",
"the",
"blobref",
"of",
"the",
"described",
"permanode",
"and",
"the",
"blobref",
"of",
"its",
"File",
"camliContent",
".",
"If",
"b",
"isn",
"t",
"a",
"permanode",
"or",
"doesn",
"t",
"have",
"a",
"camliContent",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L339-L349 | train |
perkeep/perkeep | pkg/search/describe.go | DescribedBlobStr | func (dr *DescribeRequest) DescribedBlobStr(blobstr string) *DescribedBlob {
if dr == nil {
return nil
}
dr.mu.Lock()
defer dr.mu.Unlock()
return dr.m[blobstr]
} | go | func (dr *DescribeRequest) DescribedBlobStr(blobstr string) *DescribedBlob {
if dr == nil {
return nil
}
dr.mu.Lock()
defer dr.mu.Unlock()
return dr.m[blobstr]
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"DescribedBlobStr",
"(",
"blobstr",
"string",
")",
"*",
"DescribedBlob",
"{",
"if",
"dr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"dr",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dr",... | // DescribedBlobStr when given a blobref string returns a Description
// or nil. dr may be nil itself. | [
"DescribedBlobStr",
"when",
"given",
"a",
"blobref",
"string",
"returns",
"a",
"Description",
"or",
"nil",
".",
"dr",
"may",
"be",
"nil",
"itself",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L452-L459 | train |
perkeep/perkeep | pkg/search/describe.go | peerBlob | func (b *DescribedBlob) peerBlob(br blob.Ref) *DescribedBlob {
if peer, ok := b.Request.m[br.String()]; ok {
return peer
}
return &DescribedBlob{Request: b.Request, BlobRef: br, Stub: true}
} | go | func (b *DescribedBlob) peerBlob(br blob.Ref) *DescribedBlob {
if peer, ok := b.Request.m[br.String()]; ok {
return peer
}
return &DescribedBlob{Request: b.Request, BlobRef: br, Stub: true}
} | [
"func",
"(",
"b",
"*",
"DescribedBlob",
")",
"peerBlob",
"(",
"br",
"blob",
".",
"Ref",
")",
"*",
"DescribedBlob",
"{",
"if",
"peer",
",",
"ok",
":=",
"b",
".",
"Request",
".",
"m",
"[",
"br",
".",
"String",
"(",
")",
"]",
";",
"ok",
"{",
"retu... | // version of PeerBlob when b.Request.mu is already held. | [
"version",
"of",
"PeerBlob",
"when",
"b",
".",
"Request",
".",
"mu",
"is",
"already",
"held",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L478-L483 | train |
perkeep/perkeep | pkg/search/describe.go | NewDescribeRequest | func (sh *Handler) NewDescribeRequest() *DescribeRequest {
dr := new(DescribeRequest)
sh.initDescribeRequest(dr)
return dr
} | go | func (sh *Handler) NewDescribeRequest() *DescribeRequest {
dr := new(DescribeRequest)
sh.initDescribeRequest(dr)
return dr
} | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"NewDescribeRequest",
"(",
")",
"*",
"DescribeRequest",
"{",
"dr",
":=",
"new",
"(",
"DescribeRequest",
")",
"\n",
"sh",
".",
"initDescribeRequest",
"(",
"dr",
")",
"\n",
"return",
"dr",
"\n",
"}"
] | // NewDescribeRequest returns a new DescribeRequest holding the state
// of blobs and their summarized descriptions. Use DescribeBlob
// one or more times before calling Result. | [
"NewDescribeRequest",
"returns",
"a",
"new",
"DescribeRequest",
"holding",
"the",
"state",
"of",
"blobs",
"and",
"their",
"summarized",
"descriptions",
".",
"Use",
"DescribeBlob",
"one",
"or",
"more",
"times",
"before",
"calling",
"Result",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L507-L511 | train |
perkeep/perkeep | pkg/search/describe.go | StartDescribe | func (dr *DescribeRequest) StartDescribe(ctx context.Context, br blob.Ref, depth int) {
if depth <= 0 {
return
}
dr.mu.Lock()
defer dr.mu.Unlock()
if dr.blobDesLock == nil {
dr.blobDesLock = make(map[blob.Ref]*sync.Mutex)
}
desBlobMu, ok := dr.blobDesLock[br]
if !ok {
desBlobMu = new(sync.Mutex)
dr.blob... | go | func (dr *DescribeRequest) StartDescribe(ctx context.Context, br blob.Ref, depth int) {
if depth <= 0 {
return
}
dr.mu.Lock()
defer dr.mu.Unlock()
if dr.blobDesLock == nil {
dr.blobDesLock = make(map[blob.Ref]*sync.Mutex)
}
desBlobMu, ok := dr.blobDesLock[br]
if !ok {
desBlobMu = new(sync.Mutex)
dr.blob... | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"StartDescribe",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"depth",
"int",
")",
"{",
"if",
"depth",
"<=",
"0",
"{",
"return",
"\n",
"}",
"\n",
"dr",
".",
"mu",
".",
... | // StartDescribe starts a lookup of br, down to the provided depth.
// It returns immediately. One should call Result to wait for the description to
// be completed. | [
"StartDescribe",
"starts",
"a",
"lookup",
"of",
"br",
"down",
"to",
"the",
"provided",
"depth",
".",
"It",
"returns",
"immediately",
".",
"One",
"should",
"call",
"Result",
"to",
"wait",
"for",
"the",
"description",
"to",
"be",
"completed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L597-L626 | train |
perkeep/perkeep | pkg/search/describe.go | newMatches | func (r *DescribeRule) newMatches(br blob.Ref, dr *DescribeRequest) (brs []blob.Ref) {
if r.IfResultRoot {
if !dr.blobInitiallyRequested(br) {
return nil
}
}
if r.parentRule != nil {
if _, ok := dr.resFromRule[r.parentRule][br]; !ok {
return nil
}
}
db, ok := dr.m[br.String()]
if !ok || db.Permanode... | go | func (r *DescribeRule) newMatches(br blob.Ref, dr *DescribeRequest) (brs []blob.Ref) {
if r.IfResultRoot {
if !dr.blobInitiallyRequested(br) {
return nil
}
}
if r.parentRule != nil {
if _, ok := dr.resFromRule[r.parentRule][br]; !ok {
return nil
}
}
db, ok := dr.m[br.String()]
if !ok || db.Permanode... | [
"func",
"(",
"r",
"*",
"DescribeRule",
")",
"newMatches",
"(",
"br",
"blob",
".",
"Ref",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"brs",
"[",
"]",
"blob",
".",
"Ref",
")",
"{",
"if",
"r",
".",
"IfResultRoot",
"{",
"if",
"!",
"dr",
".",
"blobI... | // requires dr.mu be held. | [
"requires",
"dr",
".",
"mu",
"be",
"held",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L629-L672 | train |
perkeep/perkeep | pkg/search/describe.go | noteResultFromRule | func (dr *DescribeRequest) noteResultFromRule(rule *DescribeRule, br blob.Ref) {
if dr.resFromRule == nil {
dr.resFromRule = make(map[*DescribeRule]map[blob.Ref]bool)
}
m, ok := dr.resFromRule[rule]
if !ok {
m = make(map[blob.Ref]bool)
dr.resFromRule[rule] = m
}
m[br] = true
} | go | func (dr *DescribeRequest) noteResultFromRule(rule *DescribeRule, br blob.Ref) {
if dr.resFromRule == nil {
dr.resFromRule = make(map[*DescribeRule]map[blob.Ref]bool)
}
m, ok := dr.resFromRule[rule]
if !ok {
m = make(map[blob.Ref]bool)
dr.resFromRule[rule] = m
}
m[br] = true
} | [
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"noteResultFromRule",
"(",
"rule",
"*",
"DescribeRule",
",",
"br",
"blob",
".",
"Ref",
")",
"{",
"if",
"dr",
".",
"resFromRule",
"==",
"nil",
"{",
"dr",
".",
"resFromRule",
"=",
"make",
"(",
"map",
"[",
... | // dr.mu just be locked. | [
"dr",
".",
"mu",
"just",
"be",
"locked",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L675-L685 | train |
perkeep/perkeep | clients/web/embed/closure/updatelibrary.go | fileList | func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closur... | go | func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closur... | [
"func",
"fileList",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"camliRootPath",
",",
"err",
":=",
"osutil",
".",
"GoPackagePath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"\"",
"\"",
")"... | // fileList parses deps.js from the closure repo, as well as the similar
// dependencies generated for the UI js files, and compiles the list of
// js files from the closure lib required for the UI. | [
"fileList",
"parses",
"deps",
".",
"js",
"from",
"the",
"closure",
"repo",
"as",
"well",
"as",
"the",
"similar",
"dependencies",
"generated",
"for",
"the",
"UI",
"js",
"files",
"and",
"compiles",
"the",
"list",
"of",
"js",
"files",
"from",
"the",
"closure"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/clients/web/embed/closure/updatelibrary.go#L65-L126 | train |
perkeep/perkeep | clients/web/embed/closure/updatelibrary.go | run | func (c *command) run() []byte {
cmd := exec.Command(c.program, c.args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
out := stdout.Bytes()
if err != nil {
log.Fatalf("Could not run %v: %v: %v: %v", c, err, string(out), stderr.String())
}
return out
} | go | func (c *command) run() []byte {
cmd := exec.Command(c.program, c.args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
out := stdout.Bytes()
if err != nil {
log.Fatalf("Could not run %v: %v: %v: %v", c, err, string(out), stderr.String())
}
return out
} | [
"func",
"(",
"c",
"*",
"command",
")",
"run",
"(",
")",
"[",
"]",
"byte",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"c",
".",
"program",
",",
"c",
".",
"args",
"...",
")",
"\n",
"var",
"stdout",
",",
"stderr",
"bytes",
".",
"Buffer",
"\n",... | // run runs the command and returns the output if it succeeds.
// On error, the process dies. | [
"run",
"runs",
"the",
"command",
"and",
"returns",
"the",
"output",
"if",
"it",
"succeeds",
".",
"On",
"error",
"the",
"process",
"dies",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/clients/web/embed/closure/updatelibrary.go#L143-L154 | train |
perkeep/perkeep | pkg/sorted/mongo/mongokv.go | Delete | func (kv *keyValue) Delete(key string) error {
kv.mu.Lock()
defer kv.mu.Unlock()
err := kv.db.Remove(&bson.M{mgoKey: key})
if err == mgo.ErrNotFound {
return nil
}
return err
} | go | func (kv *keyValue) Delete(key string) error {
kv.mu.Lock()
defer kv.mu.Unlock()
err := kv.db.Remove(&bson.M{mgoKey: key})
if err == mgo.ErrNotFound {
return nil
}
return err
} | [
"func",
"(",
"kv",
"*",
"keyValue",
")",
"Delete",
"(",
"key",
"string",
")",
"error",
"{",
"kv",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kv",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"kv",
".",
"db",
".",
"Remove",
"(... | // Delete removes the document with the matching key. | [
"Delete",
"removes",
"the",
"document",
"with",
"the",
"matching",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/mongo/mongokv.go#L159-L167 | train |
perkeep/perkeep | pkg/sorted/mongo/mongokv.go | Wipe | func (kv *keyValue) Wipe() error {
kv.mu.Lock()
defer kv.mu.Unlock()
_, err := kv.db.RemoveAll(nil)
return err
} | go | func (kv *keyValue) Wipe() error {
kv.mu.Lock()
defer kv.mu.Unlock()
_, err := kv.db.RemoveAll(nil)
return err
} | [
"func",
"(",
"kv",
"*",
"keyValue",
")",
"Wipe",
"(",
")",
"error",
"{",
"kv",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kv",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"kv",
".",
"db",
".",
"RemoveAll",
"(",
"... | // Wipe removes all documents from the collection. | [
"Wipe",
"removes",
"all",
"documents",
"from",
"the",
"collection",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/mongo/mongokv.go#L170-L175 | train |
perkeep/perkeep | pkg/sorted/mongo/mongokv.go | Ping | func Ping(host string, timeout time.Duration) bool {
return (&instance{server: host}).ping(timeout)
} | go | func Ping(host string, timeout time.Duration) bool {
return (&instance{server: host}).ping(timeout)
} | [
"func",
"Ping",
"(",
"host",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"bool",
"{",
"return",
"(",
"&",
"instance",
"{",
"server",
":",
"host",
"}",
")",
".",
"ping",
"(",
"timeout",
")",
"\n",
"}"
] | // Ping tests if MongoDB on host can be dialed. | [
"Ping",
"tests",
"if",
"MongoDB",
"on",
"host",
"can",
"be",
"dialed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/mongo/mongokv.go#L217-L219 | train |
perkeep/perkeep | pkg/search/handler.go | SendStatusUpdate | func (h *Handler) SendStatusUpdate(status json.RawMessage) {
h.wsHub.statusUpdate <- status
} | go | func (h *Handler) SendStatusUpdate(status json.RawMessage) {
h.wsHub.statusUpdate <- status
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"SendStatusUpdate",
"(",
"status",
"json",
".",
"RawMessage",
")",
"{",
"h",
".",
"wsHub",
".",
"statusUpdate",
"<-",
"status",
"\n",
"}"
] | // SendStatusUpdate sends a JSON status map to any connected WebSocket clients. | [
"SendStatusUpdate",
"sends",
"a",
"JSON",
"status",
"map",
"to",
"any",
"connected",
"WebSocket",
"clients",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L137-L139 | train |
perkeep/perkeep | pkg/search/handler.go | HasLegacySHA1 | func (h *Handler) HasLegacySHA1() bool {
idx, ok := h.index.(*index.Index)
if !ok {
log.Printf("Cannot guess for legacy SHA1 because we don't have an *index.Index")
return false
}
ok, err := idx.HasLegacySHA1()
if err != nil {
log.Printf("Cannot guess for legacy SHA1: %v", err)
return false
}
return ok
} | go | func (h *Handler) HasLegacySHA1() bool {
idx, ok := h.index.(*index.Index)
if !ok {
log.Printf("Cannot guess for legacy SHA1 because we don't have an *index.Index")
return false
}
ok, err := idx.HasLegacySHA1()
if err != nil {
log.Printf("Cannot guess for legacy SHA1: %v", err)
return false
}
return ok
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"HasLegacySHA1",
"(",
")",
"bool",
"{",
"idx",
",",
"ok",
":=",
"h",
".",
"index",
".",
"(",
"*",
"index",
".",
"Index",
")",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",... | // HasLegacySHA1 reports whether the server has legacy SHA-1 blobs indexed. | [
"HasLegacySHA1",
"reports",
"whether",
"the",
"server",
"has",
"legacy",
"SHA",
"-",
"1",
"blobs",
"indexed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L220-L232 | train |
perkeep/perkeep | pkg/search/handler.go | GetRecentPermanodes | func (h *Handler) GetRecentPermanodes(ctx context.Context, req *RecentRequest) (*RecentResponse, error) {
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan camtypes.RecentPermanode)
errch := make(chan error, 1)
before := time.Now()
if !req.Before.IsZero() {
before = req.Before
}
go func() {
// TODO(m... | go | func (h *Handler) GetRecentPermanodes(ctx context.Context, req *RecentRequest) (*RecentResponse, error) {
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan camtypes.RecentPermanode)
errch := make(chan error, 1)
before := time.Now()
if !req.Before.IsZero() {
before = req.Before
}
go func() {
// TODO(m... | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetRecentPermanodes",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"RecentRequest",
")",
"(",
"*",
"RecentResponse",
",",
"error",
")",
"{",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
... | // GetRecentPermanodes returns recently-modified permanodes. | [
"GetRecentPermanodes",
"returns",
"recently",
"-",
"modified",
"permanodes",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L514-L557 | train |
perkeep/perkeep | pkg/search/handler.go | GetPermanodesWithAttr | func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
... | go | func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
... | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetPermanodesWithAttr",
"(",
"req",
"*",
"WithAttrRequest",
")",
"(",
"*",
"WithAttrResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n\n",
"h",
".",
"index",
".",
"RLock",
"(",
... | // GetPermanodesWithAttr returns permanodes with attribute req.Attr
// having the req.Value as a value.
// See WithAttrRequest for more details about the query. | [
"GetPermanodesWithAttr",
"returns",
"permanodes",
"with",
"attribute",
"req",
".",
"Attr",
"having",
"the",
"req",
".",
"Value",
"as",
"a",
"value",
".",
"See",
"WithAttrRequest",
"for",
"more",
"details",
"about",
"the",
"query",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L574-L622 | train |
perkeep/perkeep | pkg/search/handler.go | GetClaims | func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.... | go | func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.... | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetClaims",
"(",
"req",
"*",
"ClaimsRequest",
")",
"(",
"*",
"ClaimsResponse",
",",
"error",
")",
"{",
"if",
"!",
"req",
".",
"Permanode",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"Ne... | // GetClaims returns the claims on req.Permanode signed by h.owner. | [
"GetClaims",
"returns",
"the",
"claims",
"on",
"req",
".",
"Permanode",
"signed",
"by",
"h",
".",
"owner",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L641-L673 | train |
perkeep/perkeep | pkg/search/handler.go | EdgesTo | func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
e... | go | func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
e... | [
"func",
"(",
"h",
"*",
"Handler",
")",
"EdgesTo",
"(",
"req",
"*",
"EdgesRequest",
")",
"(",
"*",
"EdgesResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defe... | // EdgesTo returns edges that reference req.RefTo.
// It filters out since-deleted permanode edges. | [
"EdgesTo",
"returns",
"edges",
"that",
"reference",
"req",
".",
"RefTo",
".",
"It",
"filters",
"out",
"since",
"-",
"deleted",
"permanode",
"edges",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L770-L843 | train |
perkeep/perkeep | pkg/search/handler.go | serveEdgesTo | func (h *Handler) serveEdgesTo(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var er EdgesRequest
er.fromHTTP(req)
res, err := h.EdgesTo(&er)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
} | go | func (h *Handler) serveEdgesTo(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var er EdgesRequest
er.fromHTTP(req)
res, err := h.EdgesTo(&er)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveEdgesTo",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"defer",
"httputil",
".",
"RecoverJSON",
"(",
"rw",
",",
"req",
")",
"\n",
"var",
"er",
"EdgesRequest",
... | // Unlike the index interface's EdgesTo method, the "edgesto" Handler
// here additionally filters out since-deleted permanode edges. | [
"Unlike",
"the",
"index",
"interface",
"s",
"EdgesTo",
"method",
"the",
"edgesto",
"Handler",
"here",
"additionally",
"filters",
"out",
"since",
"-",
"deleted",
"permanode",
"edges",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L847-L857 | train |
perkeep/perkeep | pkg/search/handler.go | GetSignerPaths | func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock(... | go | func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock(... | [
"func",
"(",
"h",
"*",
"Handler",
")",
"GetSignerPaths",
"(",
"req",
"*",
"SignerPathsRequest",
")",
"(",
"*",
"SignerPathsResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"if",
"!",
"req",
".",
"Signer",
".",
"... | // GetSignerPaths returns paths with a target of req.Target. | [
"GetSignerPaths",
"returns",
"paths",
"with",
"a",
"target",
"of",
"req",
".",
"Target",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L878-L916 | train |
perkeep/perkeep | pkg/search/handler.go | evalSearchInput | func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs... | go | func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs... | [
"func",
"evalSearchInput",
"(",
"in",
"string",
")",
"(",
"*",
"Constraint",
",",
"error",
")",
"{",
"if",
"len",
"(",
"in",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"strings",
... | // EvalSearchInput checks if its input is JSON. If so it returns a Constraint constructed from that JSON. Otherwise
// it assumes the input to be a search expression. It parses the expression and returns the parsed Constraint. | [
"EvalSearchInput",
"checks",
"if",
"its",
"input",
"is",
"JSON",
".",
"If",
"so",
"it",
"returns",
"a",
"Constraint",
"constructed",
"from",
"that",
"JSON",
".",
"Otherwise",
"it",
"assumes",
"the",
"input",
"to",
"be",
"a",
"search",
"expression",
".",
"I... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L933-L950 | train |
perkeep/perkeep | pkg/search/handler.go | getNamed | func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search f... | go | func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search f... | [
"func",
"(",
"sh",
"*",
"Handler",
")",
"getNamed",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"sh",
".",
"fetcher",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Er... | // getNamed displays the search expression or constraint json for the requested alias. | [
"getNamed",
"displays",
"the",
"search",
"expression",
"or",
"constraint",
"json",
"for",
"the",
"requested",
"alias",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L953-L981 | train |
perkeep/perkeep | app/scanningcabinet/tags.go | newSeparatedString | func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sor... | go | func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sor... | [
"func",
"newSeparatedString",
"(",
"commaSeparated",
"string",
")",
"separatedString",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"commaSeparated",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"split",
":=",
"strings",
".",
"Split",
"(",
... | // newSeparatedString returns a newly created SeparatedString value from the string given.
// There is no error if the string does not include a comma. | [
"newSeparatedString",
"returns",
"a",
"newly",
"created",
"SeparatedString",
"value",
"from",
"the",
"string",
"given",
".",
"There",
"is",
"no",
"error",
"if",
"the",
"string",
"does",
"not",
"include",
"a",
"comma",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L28-L44 | train |
perkeep/perkeep | app/scanningcabinet/tags.go | Minus | func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || c... | go | func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || c... | [
"func",
"(",
"css",
"separatedString",
")",
"Minus",
"(",
"css2",
"separatedString",
")",
"separatedString",
"{",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"(",
"css",
")",
"{",
"sort",
".",
"Strings",
"(",
"css",
")",
"\n",
"}",
"\n",
"if",
"!",
"so... | // Minus returns a newly created SeparatedString containing all the elements from css that did
// not appear in css2 | [
"Minus",
"returns",
"a",
"newly",
"created",
"SeparatedString",
"containing",
"all",
"the",
"elements",
"from",
"css",
"that",
"did",
"not",
"appear",
"in",
"css2"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L63-L82 | train |
perkeep/perkeep | app/scanningcabinet/tags.go | equal | func (css separatedString) equal(css2 separatedString) bool {
if len(css) != len(css2) {
return false
}
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
for k, s := range css {
if s != css2[k] {
return false
}
}
return true
} | go | func (css separatedString) equal(css2 separatedString) bool {
if len(css) != len(css2) {
return false
}
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
for k, s := range css {
if s != css2[k] {
return false
}
}
return true
} | [
"func",
"(",
"css",
"separatedString",
")",
"equal",
"(",
"css2",
"separatedString",
")",
"bool",
"{",
"if",
"len",
"(",
"css",
")",
"!=",
"len",
"(",
"css2",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"... | // equal compares css with css2. Both css and css2 are sorted in place before being compared. | [
"equal",
"compares",
"css",
"with",
"css2",
".",
"Both",
"css",
"and",
"css2",
"are",
"sorted",
"in",
"place",
"before",
"being",
"compared",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L85-L101 | train |
perkeep/perkeep | pkg/fs/util.go | Unmount | func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go fu... | go | func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go fu... | [
"func",
"Unmount",
"(",
"point",
"string",
")",
"error",
"{",
"var",
"cmd",
"*",
"exec",
".",
"Cmd",
"\n",
"switch",
"runtime",
".",
"GOOS",
"{",
"case",
"\"",
"\"",
":",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
... | // Unmount attempts to unmount the provided FUSE mount point, forcibly
// if necessary. | [
"Unmount",
"attempts",
"to",
"unmount",
"the",
"provided",
"FUSE",
"mount",
"point",
"forcibly",
"if",
"necessary",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/fs/util.go#L28-L53 | train |
perkeep/perkeep | pkg/blobserver/sftp/sftp.go | markConnDead | func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
} | go | func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
} | [
"func",
"(",
"s",
"*",
"Storage",
")",
"markConnDead",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"markConnDeadLocked",
"(",
")",
"\n",
"}"
] | // markConnDead clears the cached SFTP connection after the caller detects
// a connection failure. | [
"markConnDead",
"clears",
"the",
"cached",
"SFTP",
"connection",
"after",
"the",
"caller",
"detects",
"a",
"connection",
"failure",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/sftp/sftp.go#L194-L198 | train |
perkeep/perkeep | make.go | fetchJS | func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io... | go | func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io... | [
"func",
"fetchJS",
"(",
"jsURL",
",",
"jsOnDisk",
"string",
")",
"error",
"{",
"var",
"currentSum",
"string",
"\n",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"jsOnDisk",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"os",
".",
"IsNotExi... | // fetchJS gets the javascript resource at jsURL and writes it to jsOnDisk.
// Since said resource can be quite large, it first fetches the hashsum contained
// in the file at jsURL+".sha256", and if we already have the file on disk, with a
// matching hashsum, it does not actually fetch jsURL. If it does, it checks th... | [
"fetchJS",
"gets",
"the",
"javascript",
"resource",
"at",
"jsURL",
"and",
"writes",
"it",
"to",
"jsOnDisk",
".",
"Since",
"said",
"resource",
"can",
"be",
"quite",
"large",
"it",
"first",
"fetches",
"the",
"hashsum",
"contained",
"in",
"the",
"file",
"at",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L525-L589 | train |
perkeep/perkeep | make.go | fullSrcPath | func fullSrcPath(fromSrc string) string {
return filepath.Join(pkRoot, filepath.FromSlash(fromSrc))
} | go | func fullSrcPath(fromSrc string) string {
return filepath.Join(pkRoot, filepath.FromSlash(fromSrc))
} | [
"func",
"fullSrcPath",
"(",
"fromSrc",
"string",
")",
"string",
"{",
"return",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"filepath",
".",
"FromSlash",
"(",
"fromSrc",
")",
")",
"\n",
"}"
] | // fullSrcPath returns the full path concatenation
// of pkRoot with fromSrc. | [
"fullSrcPath",
"returns",
"the",
"full",
"path",
"concatenation",
"of",
"pkRoot",
"with",
"fromSrc",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L687-L689 | train |
perkeep/perkeep | make.go | getVersion | func getVersion() string {
slurp, err := ioutil.ReadFile(filepath.Join(pkRoot, "VERSION"))
v := strings.TrimSpace(string(slurp))
if err != nil && !os.IsNotExist(err) {
log.Fatal(err)
}
if v == "" {
return "unknown"
}
return v
} | go | func getVersion() string {
slurp, err := ioutil.ReadFile(filepath.Join(pkRoot, "VERSION"))
v := strings.TrimSpace(string(slurp))
if err != nil && !os.IsNotExist(err) {
log.Fatal(err)
}
if v == "" {
return "unknown"
}
return v
} | [
"func",
"getVersion",
"(",
")",
"string",
"{",
"slurp",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"\"",
"\"",
")",
")",
"\n",
"v",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"slurp",
... | // getVersion returns the version of Perkeep found in a VERSION file at the root. | [
"getVersion",
"returns",
"the",
"version",
"of",
"Perkeep",
"found",
"in",
"a",
"VERSION",
"file",
"at",
"the",
"root",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L765-L775 | train |
perkeep/perkeep | make.go | getGitVersion | func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir =... | go | func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir =... | [
"func",
"getGitVersion",
"(",
")",
"string",
"{",
"if",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
... | // getGitVersion returns the git version of the git repo at pkRoot as a
// string of the form "yyyy-mm-dd-xxxxxxx", with an optional trailing
// '+' if there are any local uncommitted modifications to the tree. | [
"getGitVersion",
"returns",
"the",
"git",
"version",
"of",
"the",
"git",
"repo",
"at",
"pkRoot",
"as",
"a",
"string",
"of",
"the",
"form",
"yyyy",
"-",
"mm",
"-",
"dd",
"-",
"xxxxxxx",
"with",
"an",
"optional",
"trailing",
"+",
"if",
"there",
"are",
"a... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L782-L808 | train |
perkeep/perkeep | make.go | verifyPerkeepRoot | func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory... | go | func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory... | [
"func",
"verifyPerkeepRoot",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"pkRoot",
",",
"err",
"=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"tes... | // verifyPerkeepRoot sets pkRoot and crashes if dir isn't the Perkeep root directory. | [
"verifyPerkeepRoot",
"sets",
"pkRoot",
"and",
"crashes",
"if",
"dir",
"isn",
"t",
"the",
"Perkeep",
"root",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L811-L839 | train |
perkeep/perkeep | make.go | verifyGoVersion | func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' co... | go | func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' co... | [
"func",
"verifyGoVersion",
"(",
")",
"{",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"goVersionMinor",
")",
"\n",
"}",
"\n",
"out",
",",
... | // verifyGoVersion runs "go version" and parses the output. If the version is
// acceptable a check for gopherjs versions are also done. If problems
// are found a message is logged and we abort. | [
"verifyGoVersion",
"runs",
"go",
"version",
"and",
"parses",
"the",
"output",
".",
"If",
"the",
"version",
"is",
"acceptable",
"a",
"check",
"for",
"gopherjs",
"versions",
"are",
"also",
"done",
".",
"If",
"problems",
"are",
"found",
"a",
"message",
"is",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L888-L927 | train |
perkeep/perkeep | make.go | quote | func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.Write... | go | func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.Write... | [
"func",
"quote",
"(",
"dest",
"*",
"bytes",
".",
"Buffer",
",",
"bs",
"[",
"]",
"byte",
")",
"{",
"dest",
".",
"WriteByte",
"(",
"'\"'",
")",
"\n",
"for",
"_",
",",
"b",
":=",
"range",
"bs",
"{",
"if",
"b",
"==",
"'\\n'",
"{",
"dest",
".",
"W... | // quote escapes and quotes the bytes from bs and writes
// them to dest. | [
"quote",
"escapes",
"and",
"quotes",
"the",
"bytes",
"from",
"bs",
"and",
"writes",
"them",
"to",
"dest",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L1155-L1177 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | ReceiveBlob | func (sto *unionStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
return blob.SizedRef{}, blobserver.ErrReadonly
} | go | func (sto *unionStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
return blob.SizedRef{}, blobserver.ErrReadonly
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"ReceiveBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"src",
"io",
".",
"Reader",
")",
"(",
"sb",
"blob",
".",
"SizedRef",
",",
"err",
"error",
")",
"{",
"return",
"b... | // ReceiveBlob would receive the blobs, but now just returns ErrReadonly. | [
"ReceiveBlob",
"would",
"receive",
"the",
"blobs",
"but",
"now",
"just",
"returns",
"ErrReadonly",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L56-L58 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | RemoveBlobs | func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
} | go | func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"return",
"blobserver",
".",
"ErrReadonly",
"\n",
"}"
] | // RemoveBlobs would remove the given blobs, but now just returns ErrReadonly. | [
"RemoveBlobs",
"would",
"remove",
"the",
"given",
"blobs",
"but",
"now",
"just",
"returns",
"ErrReadonly",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L61-L63 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | Fetch | func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go fun... | go | func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go fun... | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"(",
"file",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"type",
"result",
"struct",
... | // Fetch the blob by trying all configured read Storage concurrently,
// returning the first successful response, or the first error if there's no match. | [
"Fetch",
"the",
"blob",
"by",
"trying",
"all",
"configured",
"read",
"Storage",
"concurrently",
"returning",
"the",
"first",
"successful",
"response",
"or",
"the",
"first",
"error",
"if",
"there",
"s",
"no",
"match",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L67-L111 | train |
perkeep/perkeep | pkg/blobserver/union/union.go | EnumerateBlobs | func (sto *unionStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
return blobserver.MergedEnumerateStorage(ctx, dest, sto.subsets, after, limit)
} | go | func (sto *unionStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
return blobserver.MergedEnumerateStorage(ctx, dest, sto.subsets, after, limit)
} | [
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"EnumerateBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"after",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"return",
"blobserver",
".",
"Merge... | // EnumerateBlobs concurrently on the readers, returning one of the errors. | [
"EnumerateBlobs",
"concurrently",
"on",
"the",
"readers",
"returning",
"one",
"of",
"the",
"errors",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L171-L173 | train |
perkeep/perkeep | server/camnetdns/camnetdns.go | Set | func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("err... | go | func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("err... | [
"func",
"(",
"cs",
"cachedStore",
")",
"Set",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"// check if record already exists",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"dk",
":=",
"datastore",
".",
"NewKey",
"(",
"ctx",
",",
... | // Set writes the key, value pair to cs. But it does not actually write if the
// value already exists, is up to date, and is more recent than 30 days. | [
"Set",
"writes",
"the",
"key",
"value",
"pair",
"to",
"cs",
".",
"But",
"it",
"does",
"not",
"actually",
"write",
"if",
"the",
"value",
"already",
"exists",
"is",
"up",
"to",
"date",
"and",
"is",
"more",
"recent",
"than",
"30",
"days",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/camnetdns/camnetdns.go#L159-L183 | train |
perkeep/perkeep | pkg/blobserver/s3/s3.go | newFromConfigWithTransport | func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.New... | go | func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.New... | [
"func",
"newFromConfigWithTransport",
"(",
"_",
"blobserver",
".",
"Loader",
",",
"config",
"jsonconfig",
".",
"Obj",
",",
"transport",
"http",
".",
"RoundTripper",
")",
"(",
"blobserver",
".",
"Storage",
",",
"error",
")",
"{",
"hostname",
":=",
"config",
"... | // newFromConfigWithTransport constructs a s3 blobserver using the given
// transport for all s3 requests. The transport may be set to 'nil' to use a
// default transport.
// This is used for unit tests. | [
"newFromConfigWithTransport",
"constructs",
"a",
"s3",
"blobserver",
"using",
"the",
"given",
"transport",
"for",
"all",
"s3",
"requests",
".",
"The",
"transport",
"may",
"be",
"set",
"to",
"nil",
"to",
"use",
"a",
"default",
"transport",
".",
"This",
"is",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/s3/s3.go#L103-L169 | train |
perkeep/perkeep | pkg/blobserver/s3/s3.go | isNotFound | func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrC... | go | func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrC... | [
"func",
"isNotFound",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"aerr",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"return",
"aerr",
".",
... | // isNotFound checks for s3 errors which indicate the object doesn't exist. | [
"isNotFound",
"checks",
"for",
"s3",
"errors",
"which",
"indicate",
"the",
"object",
"doesn",
"t",
"exist",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/s3/s3.go#L176-L188 | train |
perkeep/perkeep | pkg/server/share.go | bytesHaveSchemaLink | func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, ... | go | func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, ... | [
"func",
"bytesHaveSchemaLink",
"(",
"br",
"blob",
".",
"Ref",
",",
"bb",
"[",
"]",
"byte",
",",
"target",
"blob",
".",
"Ref",
")",
"bool",
"{",
"// Fast path for no:",
"if",
"!",
"bytes",
".",
"Contains",
"(",
"bb",
",",
"[",
"]",
"byte",
"(",
"targe... | // bytesHaveSchemaLink reports whether bb is a valid Perkeep schema
// blob and has target somewhere in a schema field used to represent a
// Merkle-tree-ish file or directory. | [
"bytesHaveSchemaLink",
"reports",
"whether",
"bb",
"is",
"a",
"valid",
"Perkeep",
"schema",
"blob",
"and",
"has",
"target",
"somewhere",
"in",
"a",
"schema",
"field",
"used",
"to",
"represent",
"a",
"Merkle",
"-",
"tree",
"-",
"ish",
"file",
"or",
"directory... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/share.go#L316-L352 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/reindex.go | Reindex | func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the firs... | go | func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the firs... | [
"func",
"Reindex",
"(",
"root",
"string",
",",
"overwrite",
"bool",
",",
"indexConf",
"jsonconfig",
".",
"Obj",
")",
"(",
"err",
"error",
")",
"{",
"// there is newStorage, but that may open a file for writing",
"var",
"s",
"=",
"&",
"storage",
"{",
"root",
":",... | // Reindex rewrites the index files of the diskpacked .pack files | [
"Reindex",
"rewrites",
"the",
"index",
"files",
"of",
"the",
"diskpacked",
".",
"pack",
"files"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/reindex.go#L42-L75 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/reindex.go | Walk | func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
br... | go | func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
br... | [
"func",
"(",
"s",
"*",
"storage",
")",
"Walk",
"(",
"ctx",
"context",
".",
"Context",
",",
"walker",
"func",
"(",
"packID",
"int",
",",
"ref",
"blob",
".",
"Ref",
",",
"offset",
"int64",
",",
"size",
"uint32",
")",
"error",
")",
"error",
"{",
"// T... | // Walk walks the storage and calls the walker callback with each blobref
// stops if walker returns non-nil error, and returns that | [
"Walk",
"walks",
"the",
"storage",
"and",
"calls",
"the",
"walker",
"callback",
"with",
"each",
"blobref",
"stops",
"if",
"walker",
"returns",
"non",
"-",
"nil",
"error",
"and",
"returns",
"that"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/reindex.go#L143-L163 | train |
perkeep/perkeep | pkg/blobserver/encrypt/meta.go | makeSingleMetaBlob | func (s *storage) makeSingleMetaBlob(plainBR, encBR blob.Ref, plainSize uint32) []byte {
plain := fmt.Sprintf("#camlistore/encmeta=2\n%s/%d/%s\n", plainBR, plainSize, encBR)
return s.encryptBlob(nil, []byte(plain))
} | go | func (s *storage) makeSingleMetaBlob(plainBR, encBR blob.Ref, plainSize uint32) []byte {
plain := fmt.Sprintf("#camlistore/encmeta=2\n%s/%d/%s\n", plainBR, plainSize, encBR)
return s.encryptBlob(nil, []byte(plain))
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"makeSingleMetaBlob",
"(",
"plainBR",
",",
"encBR",
"blob",
".",
"Ref",
",",
"plainSize",
"uint32",
")",
"[",
"]",
"byte",
"{",
"plain",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"plainBR"... | // makeSingleMetaBlob makes and encrypts a metaBlob with one entry. | [
"makeSingleMetaBlob",
"makes",
"and",
"encrypts",
"a",
"metaBlob",
"with",
"one",
"entry",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/meta.go#L148-L151 | train |
perkeep/perkeep | pkg/blobserver/encrypt/meta.go | fetchMeta | func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
} | go | func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"fetchMeta",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"(",
"plainSize",
"uint32",
",",
"encBR",
"blob",
".",
"Ref",
",",
"err",
"error",
")",
"{",
"v",
",",
"err",
":=",
"s",... | // fetchMeta returns os.ErrNotExist if the plaintext blob is not in the index. | [
"fetchMeta",
"returns",
"os",
".",
"ErrNotExist",
"if",
"the",
"plaintext",
"blob",
"is",
"not",
"in",
"the",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/meta.go#L177-L186 | train |
perkeep/perkeep | server/perkeepd/ui/goui/aboutdialog/gen_AboutMenuItem_reactGen.go | Props | func (a AboutMenuItemDef) Props() AboutMenuItemProps {
uprops := a.ComponentDef.Props()
return uprops.(AboutMenuItemProps)
} | go | func (a AboutMenuItemDef) Props() AboutMenuItemProps {
uprops := a.ComponentDef.Props()
return uprops.(AboutMenuItemProps)
} | [
"func",
"(",
"a",
"AboutMenuItemDef",
")",
"Props",
"(",
")",
"AboutMenuItemProps",
"{",
"uprops",
":=",
"a",
".",
"ComponentDef",
".",
"Props",
"(",
")",
"\n",
"return",
"uprops",
".",
"(",
"AboutMenuItemProps",
")",
"\n",
"}"
] | // Props is an auto-generated proxy to the current props of AboutMenuItem | [
"Props",
"is",
"an",
"auto",
"-",
"generated",
"proxy",
"to",
"the",
"current",
"props",
"of",
"AboutMenuItem"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/aboutdialog/gen_AboutMenuItem_reactGen.go#L30-L33 | train |
perkeep/perkeep | internal/netutil/netutil.go | AwaitReachable | func AwaitReachable(addr string, maxWait time.Duration) error {
done := time.Now().Add(maxWait)
for time.Now().Before(done) {
c, err := net.Dial("tcp", addr)
if err == nil {
c.Close()
return nil
}
time.Sleep(100 * time.Millisecond)
}
return fmt.Errorf("%v unreachable for %v", addr, maxWait)
} | go | func AwaitReachable(addr string, maxWait time.Duration) error {
done := time.Now().Add(maxWait)
for time.Now().Before(done) {
c, err := net.Dial("tcp", addr)
if err == nil {
c.Close()
return nil
}
time.Sleep(100 * time.Millisecond)
}
return fmt.Errorf("%v unreachable for %v", addr, maxWait)
} | [
"func",
"AwaitReachable",
"(",
"addr",
"string",
",",
"maxWait",
"time",
".",
"Duration",
")",
"error",
"{",
"done",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"maxWait",
")",
"\n",
"for",
"time",
".",
"Now",
"(",
")",
".",
"Before",
"(",... | // AwaitReachable tries to make a TCP connection to addr regularly.
// It returns an error if it's unable to make a connection before maxWait. | [
"AwaitReachable",
"tries",
"to",
"make",
"a",
"TCP",
"connection",
"to",
"addr",
"regularly",
".",
"It",
"returns",
"an",
"error",
"if",
"it",
"s",
"unable",
"to",
"make",
"a",
"connection",
"before",
"maxWait",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L30-L41 | train |
perkeep/perkeep | internal/netutil/netutil.go | ListenOnLocalRandomPort | func ListenOnLocalRandomPort() (net.Listener, error) {
ip, err := Localhost()
if err != nil {
return nil, err
}
return net.ListenTCP("tcp", &net.TCPAddr{IP: ip, Port: 0})
} | go | func ListenOnLocalRandomPort() (net.Listener, error) {
ip, err := Localhost()
if err != nil {
return nil, err
}
return net.ListenTCP("tcp", &net.TCPAddr{IP: ip, Port: 0})
} | [
"func",
"ListenOnLocalRandomPort",
"(",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"ip",
",",
"err",
":=",
"Localhost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"net",
"."... | // ListenOnLocalRandomPort returns a TCP listener on a random
// localhost port. | [
"ListenOnLocalRandomPort",
"returns",
"a",
"TCP",
"listener",
"on",
"a",
"random",
"localhost",
"port",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L92-L98 | train |
perkeep/perkeep | internal/netutil/netutil.go | Localhost | func Localhost() (net.IP, error) {
if ip := localhostLookup(); ip != nil {
return ip, nil
}
if ip := loopbackIP(); ip != nil {
return ip, nil
}
return nil, errors.New("no loopback ip found")
} | go | func Localhost() (net.IP, error) {
if ip := localhostLookup(); ip != nil {
return ip, nil
}
if ip := loopbackIP(); ip != nil {
return ip, nil
}
return nil, errors.New("no loopback ip found")
} | [
"func",
"Localhost",
"(",
")",
"(",
"net",
".",
"IP",
",",
"error",
")",
"{",
"if",
"ip",
":=",
"localhostLookup",
"(",
")",
";",
"ip",
"!=",
"nil",
"{",
"return",
"ip",
",",
"nil",
"\n",
"}",
"\n",
"if",
"ip",
":=",
"loopbackIP",
"(",
")",
";"... | // Localhost returns the first address found when
// doing a lookup of "localhost". If not successful,
// it looks for an ip on the loopback interfaces. | [
"Localhost",
"returns",
"the",
"first",
"address",
"found",
"when",
"doing",
"a",
"lookup",
"of",
"localhost",
".",
"If",
"not",
"successful",
"it",
"looks",
"for",
"an",
"ip",
"on",
"the",
"loopback",
"interfaces",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L103-L111 | train |
perkeep/perkeep | internal/netutil/netutil.go | localhostLookup | func localhostLookup() net.IP {
if ips, err := net.LookupIP("localhost"); err == nil && len(ips) > 0 {
return ips[0]
}
return nil
} | go | func localhostLookup() net.IP {
if ips, err := net.LookupIP("localhost"); err == nil && len(ips) > 0 {
return ips[0]
}
return nil
} | [
"func",
"localhostLookup",
"(",
")",
"net",
".",
"IP",
"{",
"if",
"ips",
",",
"err",
":=",
"net",
".",
"LookupIP",
"(",
"\"",
"\"",
")",
";",
"err",
"==",
"nil",
"&&",
"len",
"(",
"ips",
")",
">",
"0",
"{",
"return",
"ips",
"[",
"0",
"]",
"\n... | // localhostLookup looks for a loopback IP by resolving localhost. | [
"localhostLookup",
"looks",
"for",
"a",
"loopback",
"IP",
"by",
"resolving",
"localhost",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L114-L119 | train |
perkeep/perkeep | internal/netutil/netutil.go | loopbackIP | func loopbackIP() net.IP {
interfaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, inf := range interfaces {
const flagUpLoopback = net.FlagUp | net.FlagLoopback
if inf.Flags&flagUpLoopback == flagUpLoopback {
addrs, _ := inf.Addrs()
for _, addr := range addrs {
ip, _, err := net.Par... | go | func loopbackIP() net.IP {
interfaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, inf := range interfaces {
const flagUpLoopback = net.FlagUp | net.FlagLoopback
if inf.Flags&flagUpLoopback == flagUpLoopback {
addrs, _ := inf.Addrs()
for _, addr := range addrs {
ip, _, err := net.Par... | [
"func",
"loopbackIP",
"(",
")",
"net",
".",
"IP",
"{",
"interfaces",
",",
"err",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"inf",
":=",
"range",
"interfaces",
... | // loopbackIP returns the first loopback IP address sniffing network
// interfaces or nil if none is found. | [
"loopbackIP",
"returns",
"the",
"first",
"loopback",
"IP",
"address",
"sniffing",
"network",
"interfaces",
"or",
"nil",
"if",
"none",
"is",
"found",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L123-L141 | train |
perkeep/perkeep | internal/netutil/netutil.go | RandPort | func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAdd... | go | func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAdd... | [
"func",
"RandPort",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"port",
"int",
"\n",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"port",
... | // RandPort returns a random port to listen on. | [
"RandPort",
"returns",
"a",
"random",
"port",
"to",
"listen",
"on",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L144-L159 | train |
perkeep/perkeep | internal/netutil/netutil.go | IsFQDN | func IsFQDN(domain string) bool {
// TODO(mpl): there's probably a regexp for all this...
if domain == "localhost" {
return false
}
if !strings.Contains(domain, ".") {
return false
}
if strings.Contains(domain, "/") {
return false
}
if net.ParseIP(domain) != nil {
return false
}
return true
} | go | func IsFQDN(domain string) bool {
// TODO(mpl): there's probably a regexp for all this...
if domain == "localhost" {
return false
}
if !strings.Contains(domain, ".") {
return false
}
if strings.Contains(domain, "/") {
return false
}
if net.ParseIP(domain) != nil {
return false
}
return true
} | [
"func",
"IsFQDN",
"(",
"domain",
"string",
")",
"bool",
"{",
"// TODO(mpl): there's probably a regexp for all this...",
"if",
"domain",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"domain",
",",
"\"",
... | // IsFQDN reports whether domain looks like a fully qualified domain name. | [
"IsFQDN",
"reports",
"whether",
"domain",
"looks",
"like",
"a",
"fully",
"qualified",
"domain",
"name",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L168-L183 | train |
perkeep/perkeep | server/perkeepd/ui/goui/geo/geo.go | IsLocMapPredicate | func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
} | go | func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
} | [
"func",
"IsLocMapPredicate",
"(",
"predicate",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"rectangleFromPredicate",
"(",
"predicate",
",",
"LocMapPredicatePrefix",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",... | // IsLocMapPredicate returns whether predicate is a map location predicate. | [
"IsLocMapPredicate",
"returns",
"whether",
"predicate",
"is",
"a",
"map",
"location",
"predicate",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/geo/geo.go#L36-L41 | train |
perkeep/perkeep | server/perkeepd/ui/goui/geo/geo.go | rectangleFromPredicate | func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if... | go | func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if... | [
"func",
"rectangleFromPredicate",
"(",
"predicate",
",",
"kind",
"string",
")",
"(",
"*",
"camtypes",
".",
"LocationBounds",
",",
"error",
")",
"{",
"errNotARectangle",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"kind",
")",
"\n",
"if",
"!",
"stri... | // rectangleFromPredicate, if predicate is a valid location predicate of the given kind
// and returns the corresponding rectangular area. | [
"rectangleFromPredicate",
"if",
"predicate",
"is",
"a",
"valid",
"location",
"predicate",
"of",
"the",
"given",
"kind",
"and",
"returns",
"the",
"corresponding",
"rectangular",
"area",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/geo/geo.go#L45-L69 | train |
perkeep/perkeep | internal/leak/leak.go | NewChecker | func NewChecker() *Checker {
pc := make([]uintptr, 50)
ch := &Checker{pc[:runtime.Callers(0, pc)]}
runtime.SetFinalizer(ch, (*Checker).finalize)
return ch
} | go | func NewChecker() *Checker {
pc := make([]uintptr, 50)
ch := &Checker{pc[:runtime.Callers(0, pc)]}
runtime.SetFinalizer(ch, (*Checker).finalize)
return ch
} | [
"func",
"NewChecker",
"(",
")",
"*",
"Checker",
"{",
"pc",
":=",
"make",
"(",
"[",
"]",
"uintptr",
",",
"50",
")",
"\n",
"ch",
":=",
"&",
"Checker",
"{",
"pc",
"[",
":",
"runtime",
".",
"Callers",
"(",
"0",
",",
"pc",
")",
"]",
"}",
"\n",
"ru... | // NewChecker returns a Checker, remembering the stack trace. | [
"NewChecker",
"returns",
"a",
"Checker",
"remembering",
"the",
"stack",
"trace",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/leak/leak.go#L32-L37 | train |
perkeep/perkeep | pkg/importer/feed/feed.go | autoDiscover | func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make... | go | func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make... | [
"func",
"autoDiscover",
"(",
"body",
"[",
"]",
"byte",
")",
"(",
"feedURL",
"string",
",",
"err",
"error",
")",
"{",
"r",
":=",
"bytes",
".",
"NewReader",
"(",
"body",
")",
"\n",
"z",
":=",
"html",
".",
"NewTokenizer",
"(",
"r",
")",
"\n",
"for",
... | // autodiscover takes an HTML document and returns the autodiscovered feed
// URL. Returns an error if there is no such URL. | [
"autodiscover",
"takes",
"an",
"HTML",
"document",
"and",
"returns",
"the",
"autodiscovered",
"feed",
"URL",
".",
"Returns",
"an",
"error",
"if",
"there",
"is",
"no",
"such",
"URL",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/feed/feed.go#L191-L214 | train |
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | importStatuses | func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.... | go | func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.... | [
"func",
"(",
"r",
"*",
"run",
")",
"importStatuses",
"(",
"userID",
"mastodon",
".",
"ID",
")",
"error",
"{",
"statusesNode",
",",
"err",
":=",
"r",
".",
"RootNode",
"(",
")",
".",
"ChildPathObject",
"(",
"nodeStatuses",
")",
"\n",
"if",
"err",
"!=",
... | // importStatuses imports statuses for the given user into the store | [
"importStatuses",
"imports",
"statuses",
"for",
"the",
"given",
"user",
"into",
"the",
"store"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L294-L385 | train |
perkeep/perkeep | pkg/importer/mastodon/mastodon.go | importStatus | func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode... | go | func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode... | [
"func",
"(",
"r",
"*",
"run",
")",
"importStatus",
"(",
"listNode",
"*",
"importer",
".",
"Object",
",",
"st",
"*",
"mastodon",
".",
"Status",
")",
"(",
"bool",
",",
"error",
")",
"{",
"select",
"{",
"case",
"<-",
"r",
".",
"Context",
"(",
")",
"... | // importStatus imports a single status, also adding it to the statuses node.
// Returns true if we already had the status in the database. | [
"importStatus",
"imports",
"a",
"single",
"status",
"also",
"adding",
"it",
"to",
"the",
"statuses",
"node",
".",
"Returns",
"true",
"if",
"we",
"already",
"had",
"the",
"status",
"in",
"the",
"database",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L389-L467 | train |
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, ... | 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, ... | [
"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.Acct... | 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.Acct... | [
"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",
":=... | // 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",
"(",
"\"... | // 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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"re... | // 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 err... | 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 err... | [
"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++... | 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++... | [
"func",
"ResampleInplace",
"(",
"m",
"image",
".",
"Image",
",",
"r",
"image",
".",
"Rectangle",
",",
"w",
",",
"h",
"int",
")",
"image",
".",
"Image",
"{",
"// We don't support scaling up.",
"if",
"r",
".",
"Dx",
"(",
")",
"<",
"w",
"||",
"r",
".",
... | // 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",
"!=",
"\"",
"\"",
"{",
"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 htt... | 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 htt... | [
"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",
"... | // 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",
"(",
"Acc... | // 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 == h... | 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 == h... | [
"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 ... | 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 ... | [
"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.ResourceOwnerAuthorizationU... | 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.ResourceOwnerAuthorizationU... | [
"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",
"\"",
"\"",
"\n",
"case",
"dbBlobpackedIndex",
":",
"return",
"\"",
"\"",
"\n",
"case",
"\"",
"\"",
... | // 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... | [
"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",
"... | // 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",
"\"",
"\"",
"\n",
"case",
"b",
".",
"high",
".",
"KVFile",
"!=",
"\"",
"\"",... | // 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 |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.