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",
"{",
"return",
"s",
"\n",
"}",
"\n",
"if",
"c",
".",
"strs",
"==",
"nil",
"{",
"c",
".",
"strs",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"}",
"\n",
"c",
".",
"strs",
"[",
"s",
"]",
"=",
"s",
"\n",
"return",
"s",
"\n",
"}"
] |
// 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",
".",
"Ref",
"\n",
"}",
"\n",
"return",
"br",
"\n",
"}"
] |
// 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",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// 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",
")",
")",
"\n",
"}"
] |
// 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",
".",
"sorted",
"(",
"newestFirst",
")",
")",
"\n",
"}"
] |
// 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",
"newestFirst",
".",
"Iteration",
"ends",
"prematurely",
"if",
"fn",
"returns",
"false",
"."
] |
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",
"{",
"fn",
"(",
"*",
"bm",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
"{",
"set",
":=",
"c",
".",
"permanodesSetByNodeType",
"[",
"t",
"]",
"\n",
"for",
"br",
":=",
"range",
"set",
"{",
"if",
"bm",
":=",
"c",
".",
"blobs",
"[",
"br",
"]",
";",
"bm",
"!=",
"nil",
"{",
"if",
"!",
"fn",
"(",
"*",
"bm",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// EnumeratePermanodesByNodeTypes enumerates over all permanodes that might
// have one of the provided camliNodeType values, calling fn for each. If fn returns false,
// enumeration ends.
|
[
"EnumeratePermanodesByNodeTypes",
"enumerates",
"over",
"all",
"permanodes",
"that",
"might",
"have",
"one",
"of",
"the",
"provided",
"camliNodeType",
"values",
"calling",
"fn",
"for",
"each",
".",
"If",
"fn",
"returns",
"false",
"enumeration",
"ends",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1116-L1127
|
train
|
perkeep/perkeep
|
pkg/index/corpus.go
|
PermanodeTime
|
func (c *Corpus) PermanodeTime(pn blob.Ref) (t time.Time, ok bool) {
// TODO(bradfitz): keep this time property cached on the permanode / files
// TODO(bradfitz): finish implmenting all these
// Priorities:
// -- Permanode explicit "camliTime" property
// -- EXIF GPS time
// -- Exif camera time - this one is actually already in the FileInfo,
// because we use schema.FileTime (which returns the EXIF time, if available)
// to index the time when receiving a file.
// -- File time
// -- File modtime
// -- camliContent claim set time
if t, ok = c.pnTimeAttr(pn, nodeattr.PaymentDueDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.StartDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateCreated); ok {
return
}
var fi camtypes.FileInfo
ccRef, ccTime, ok := c.pnCamliContent(pn)
if ok {
fi, _ = c.files[ccRef]
}
if fi.Time != nil {
return time.Time(*fi.Time), true
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DatePublished); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateModified); ok {
return
}
if fi.ModTime != nil {
return time.Time(*fi.ModTime), true
}
if ok {
return ccTime, true
}
return time.Time{}, false
}
|
go
|
func (c *Corpus) PermanodeTime(pn blob.Ref) (t time.Time, ok bool) {
// TODO(bradfitz): keep this time property cached on the permanode / files
// TODO(bradfitz): finish implmenting all these
// Priorities:
// -- Permanode explicit "camliTime" property
// -- EXIF GPS time
// -- Exif camera time - this one is actually already in the FileInfo,
// because we use schema.FileTime (which returns the EXIF time, if available)
// to index the time when receiving a file.
// -- File time
// -- File modtime
// -- camliContent claim set time
if t, ok = c.pnTimeAttr(pn, nodeattr.PaymentDueDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.StartDate); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateCreated); ok {
return
}
var fi camtypes.FileInfo
ccRef, ccTime, ok := c.pnCamliContent(pn)
if ok {
fi, _ = c.files[ccRef]
}
if fi.Time != nil {
return time.Time(*fi.Time), true
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DatePublished); ok {
return
}
if t, ok = c.pnTimeAttr(pn, nodeattr.DateModified); ok {
return
}
if fi.ModTime != nil {
return time.Time(*fi.ModTime), true
}
if ok {
return ccTime, true
}
return time.Time{}, false
}
|
[
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeTime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"// TODO(bradfitz): keep this time property cached on the permanode / files",
"// TODO(bradfitz): finish implmenting all these",
"// Priorities:",
"// -- Permanode explicit \"camliTime\" property",
"// -- EXIF GPS time",
"// -- Exif camera time - this one is actually already in the FileInfo,",
"// because we use schema.FileTime (which returns the EXIF time, if available)",
"// to index the time when receiving a file.",
"// -- File time",
"// -- File modtime",
"// -- camliContent claim set time",
"if",
"t",
",",
"ok",
"=",
"c",
".",
"pnTimeAttr",
"(",
"pn",
",",
"nodeattr",
".",
"PaymentDueDate",
")",
";",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"if",
"t",
",",
"ok",
"=",
"c",
".",
"pnTimeAttr",
"(",
"pn",
",",
"nodeattr",
".",
"StartDate",
")",
";",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"if",
"t",
",",
"ok",
"=",
"c",
".",
"pnTimeAttr",
"(",
"pn",
",",
"nodeattr",
".",
"DateCreated",
")",
";",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"var",
"fi",
"camtypes",
".",
"FileInfo",
"\n",
"ccRef",
",",
"ccTime",
",",
"ok",
":=",
"c",
".",
"pnCamliContent",
"(",
"pn",
")",
"\n",
"if",
"ok",
"{",
"fi",
",",
"_",
"=",
"c",
".",
"files",
"[",
"ccRef",
"]",
"\n",
"}",
"\n",
"if",
"fi",
".",
"Time",
"!=",
"nil",
"{",
"return",
"time",
".",
"Time",
"(",
"*",
"fi",
".",
"Time",
")",
",",
"true",
"\n",
"}",
"\n\n",
"if",
"t",
",",
"ok",
"=",
"c",
".",
"pnTimeAttr",
"(",
"pn",
",",
"nodeattr",
".",
"DatePublished",
")",
";",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"if",
"t",
",",
"ok",
"=",
"c",
".",
"pnTimeAttr",
"(",
"pn",
",",
"nodeattr",
".",
"DateModified",
")",
";",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"if",
"fi",
".",
"ModTime",
"!=",
"nil",
"{",
"return",
"time",
".",
"Time",
"(",
"*",
"fi",
".",
"ModTime",
")",
",",
"true",
"\n",
"}",
"\n",
"if",
"ok",
"{",
"return",
"ccTime",
",",
"true",
"\n",
"}",
"\n",
"return",
"time",
".",
"Time",
"{",
"}",
",",
"false",
"\n",
"}"
] |
// 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",
"{",
"return",
"t",
",",
"ok",
"\n",
"}",
"\n",
"return",
"c",
".",
"PermanodeModtime",
"(",
"pn",
")",
"\n",
"}"
] |
// PermanodeAnyTime returns the time that best qualifies the permanode.
// It tries content-specific times first, the permanode modtime otherwise.
|
[
"PermanodeAnyTime",
"returns",
"the",
"time",
"that",
"best",
"qualifies",
"the",
"permanode",
".",
"It",
"tries",
"content",
"-",
"specific",
"times",
"first",
"the",
"permanode",
"modtime",
"otherwise",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1203-L1208
|
train
|
perkeep/perkeep
|
pkg/index/corpus.go
|
PermanodeModtime
|
func (c *Corpus) PermanodeModtime(pn blob.Ref) (t time.Time, ok bool) {
pm, ok := c.permanodes[pn]
if !ok {
return
}
// Note: We intentionally don't try to derive any information
// (except the owner, elsewhere) from the permanode blob
// itself. Even though the permanode blob sometimes has the
// GPG signature time, we intentionally ignore it.
for _, cl := range pm.Claims {
if c.IsDeleted(cl.BlobRef) {
continue
}
if cl.Date.After(t) {
t = cl.Date
}
}
return t, !t.IsZero()
}
|
go
|
func (c *Corpus) PermanodeModtime(pn blob.Ref) (t time.Time, ok bool) {
pm, ok := c.permanodes[pn]
if !ok {
return
}
// Note: We intentionally don't try to derive any information
// (except the owner, elsewhere) from the permanode blob
// itself. Even though the permanode blob sometimes has the
// GPG signature time, we intentionally ignore it.
for _, cl := range pm.Claims {
if c.IsDeleted(cl.BlobRef) {
continue
}
if cl.Date.After(t) {
t = cl.Date
}
}
return t, !t.IsZero()
}
|
[
"func",
"(",
"c",
"*",
"Corpus",
")",
"PermanodeModtime",
"(",
"pn",
"blob",
".",
"Ref",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"pm",
",",
"ok",
":=",
"c",
".",
"permanodes",
"[",
"pn",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n\n",
"// Note: We intentionally don't try to derive any information",
"// (except the owner, elsewhere) from the permanode blob",
"// itself. Even though the permanode blob sometimes has the",
"// GPG signature time, we intentionally ignore it.",
"for",
"_",
",",
"cl",
":=",
"range",
"pm",
".",
"Claims",
"{",
"if",
"c",
".",
"IsDeleted",
"(",
"cl",
".",
"BlobRef",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"cl",
".",
"Date",
".",
"After",
"(",
"t",
")",
"{",
"t",
"=",
"cl",
".",
"Date",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"t",
",",
"!",
"t",
".",
"IsZero",
"(",
")",
"\n",
"}"
] |
// 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",
".",
"A",
"deleted",
"claim",
"is",
"ignored",
"and",
"neither",
"its",
"claim",
"date",
"nor",
"the",
"date",
"of",
"the",
"delete",
"claim",
"affect",
"the",
"modtime",
"of",
"the",
"permanode",
"."
] |
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",
"[",
"permaNode",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"for",
"_",
",",
"cl",
":=",
"range",
"pm",
".",
"Claims",
"{",
"if",
"!",
"at",
".",
"IsZero",
"(",
")",
"&&",
"cl",
".",
"Date",
".",
"After",
"(",
"at",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"fn",
"(",
"cl",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// 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",
"returns",
"false",
"iteration",
"ends",
".",
"Iteration",
"is",
"in",
"an",
"undefined",
"order",
"."
] |
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",
".",
"claimBack",
"[",
"value",
"]",
"{",
"if",
"!",
"at",
".",
"IsZero",
"(",
")",
"&&",
"cl",
".",
"Date",
".",
"After",
"(",
"at",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"fn",
"(",
"cl",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// 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",
"skipped",
".",
"If",
"fn",
"returns",
"false",
"iteration",
"ends",
".",
"Iteration",
"is",
"in",
"an",
"undefined",
"order",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/corpus.go#L1515-L1524
|
train
|
perkeep/perkeep
|
pkg/blobserver/local/generation.go
|
ResetStorageGeneration
|
func (g Generationer) ResetStorageGeneration() error {
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rand.Reader, 20); err != nil {
return err
}
hex := fmt.Sprintf("%x", buf.Bytes())
buf.Reset()
buf.WriteString(hex)
buf.WriteString(`
This file's random string on the first line is an optimization and
paranoia facility for clients.
If the client sees the same random string in multiple upload sessions,
it assumes that the blobserver still has all the same blobs, and also
it's the same server. This mechanism is not fundamental to
Perkeep's operation: the client could also check each blob before
uploading, or enumerate all blobs from the server too. This is purely
an optimization so clients can mix this value into their "is this file
uploaded?" local cache keys.
If you deleted any blobs (or suspect any were corrupted), it's best to
delete this file so clients can safely re-upload them.
`)
return ioutil.WriteFile(g.generationFile(), buf.Bytes(), 0644)
}
|
go
|
func (g Generationer) ResetStorageGeneration() error {
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rand.Reader, 20); err != nil {
return err
}
hex := fmt.Sprintf("%x", buf.Bytes())
buf.Reset()
buf.WriteString(hex)
buf.WriteString(`
This file's random string on the first line is an optimization and
paranoia facility for clients.
If the client sees the same random string in multiple upload sessions,
it assumes that the blobserver still has all the same blobs, and also
it's the same server. This mechanism is not fundamental to
Perkeep's operation: the client could also check each blob before
uploading, or enumerate all blobs from the server too. This is purely
an optimization so clients can mix this value into their "is this file
uploaded?" local cache keys.
If you deleted any blobs (or suspect any were corrupted), it's best to
delete this file so clients can safely re-upload them.
`)
return ioutil.WriteFile(g.generationFile(), buf.Bytes(), 0644)
}
|
[
"func",
"(",
"g",
"Generationer",
")",
"ResetStorageGeneration",
"(",
")",
"error",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"CopyN",
"(",
"&",
"buf",
",",
"rand",
".",
"Reader",
",",
"20",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"hex",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"buf",
".",
"Reset",
"(",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"hex",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"`\n\nThis file's random string on the first line is an optimization and\nparanoia facility for clients.\n\nIf the client sees the same random string in multiple upload sessions,\nit assumes that the blobserver still has all the same blobs, and also\nit's the same server. This mechanism is not fundamental to\nPerkeep's operation: the client could also check each blob before\nuploading, or enumerate all blobs from the server too. This is purely\nan optimization so clients can mix this value into their \"is this file\nuploaded?\" local cache keys.\n\nIf you deleted any blobs (or suspect any were corrupted), it's best to\ndelete this file so clients can safely re-upload them.\n\n`",
")",
"\n\n",
"return",
"ioutil",
".",
"WriteFile",
"(",
"g",
".",
"generationFile",
"(",
")",
",",
"buf",
".",
"Bytes",
"(",
")",
",",
"0644",
")",
"\n",
"}"
] |
// ResetStorageGeneration reinitializes the generation by recreating the
// GENERATION.dat file with a new random string
|
[
"ResetStorageGeneration",
"reinitializes",
"the",
"generation",
"by",
"recreating",
"the",
"GENERATION",
".",
"dat",
"file",
"with",
"a",
"new",
"random",
"string"
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/local/generation.go#L78-L105
|
train
|
perkeep/perkeep
|
internal/gpgagent/gpgagent.go
|
NewConn
|
func NewConn() (*Conn, error) {
sp := strings.SplitN(os.Getenv("GPG_AGENT_INFO"), ":", 3)
if len(sp) == 0 || len(sp[0]) == 0 {
return nil, ErrNoAgent
}
addr := &net.UnixAddr{Net: "unix", Name: sp[0]}
uc, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, err
}
br := bufio.NewReader(uc)
lineb, err := br.ReadSlice('\n')
if err != nil {
return nil, err
}
line := string(lineb)
if !strings.HasPrefix(line, "OK") {
return nil, fmt.Errorf("gpgagent: didn't get OK; got %q", line)
}
return &Conn{uc, br}, nil
}
|
go
|
func NewConn() (*Conn, error) {
sp := strings.SplitN(os.Getenv("GPG_AGENT_INFO"), ":", 3)
if len(sp) == 0 || len(sp[0]) == 0 {
return nil, ErrNoAgent
}
addr := &net.UnixAddr{Net: "unix", Name: sp[0]}
uc, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, err
}
br := bufio.NewReader(uc)
lineb, err := br.ReadSlice('\n')
if err != nil {
return nil, err
}
line := string(lineb)
if !strings.HasPrefix(line, "OK") {
return nil, fmt.Errorf("gpgagent: didn't get OK; got %q", line)
}
return &Conn{uc, br}, nil
}
|
[
"func",
"NewConn",
"(",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"sp",
":=",
"strings",
".",
"SplitN",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
"3",
")",
"\n",
"if",
"len",
"(",
"sp",
")",
"==",
"0",
"||",
"len",
"(",
"sp",
"[",
"0",
"]",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"ErrNoAgent",
"\n",
"}",
"\n",
"addr",
":=",
"&",
"net",
".",
"UnixAddr",
"{",
"Net",
":",
"\"",
"\"",
",",
"Name",
":",
"sp",
"[",
"0",
"]",
"}",
"\n",
"uc",
",",
"err",
":=",
"net",
".",
"DialUnix",
"(",
"\"",
"\"",
",",
"nil",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"br",
":=",
"bufio",
".",
"NewReader",
"(",
"uc",
")",
"\n",
"lineb",
",",
"err",
":=",
"br",
".",
"ReadSlice",
"(",
"'\\n'",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"line",
":=",
"string",
"(",
"lineb",
")",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"line",
",",
"\"",
"\"",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"line",
")",
"\n",
"}",
"\n",
"return",
"&",
"Conn",
"{",
"uc",
",",
"br",
"}",
",",
"nil",
"\n",
"}"
] |
// 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",
"defer",
"sh",
".",
"index",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"sh",
".",
"DescribeLocked",
"(",
"ctx",
",",
"dr",
")",
"\n",
"}"
] |
// Describe returns a response for the given describe request. It acquires RLock
// on the Handler's index.
|
[
"Describe",
"returns",
"a",
"response",
"for",
"the",
"given",
"describe",
"request",
".",
"It",
"acquires",
"RLock",
"on",
"the",
"Handler",
"s",
"index",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L58-L63
|
train
|
perkeep/perkeep
|
pkg/search/describe.go
|
DescribeLocked
|
func (sh *Handler) DescribeLocked(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
if verboseDescribe {
t0 := time.Now()
defer func() {
td := time.Since(t0)
var num int
if dres != nil {
num = len(dres.Meta)
}
log.Printf("Described %d blobs in %v", num, td)
}()
}
sh.initDescribeRequest(dr)
if dr.BlobRef.Valid() {
dr.StartDescribe(ctx, dr.BlobRef, dr.depth())
}
for _, br := range dr.BlobRefs {
dr.StartDescribe(ctx, br, dr.depth())
}
if err := dr.expandRules(ctx); err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
return &DescribeResponse{metaMap}, nil
}
|
go
|
func (sh *Handler) DescribeLocked(ctx context.Context, dr *DescribeRequest) (dres *DescribeResponse, err error) {
if verboseDescribe {
t0 := time.Now()
defer func() {
td := time.Since(t0)
var num int
if dres != nil {
num = len(dres.Meta)
}
log.Printf("Described %d blobs in %v", num, td)
}()
}
sh.initDescribeRequest(dr)
if dr.BlobRef.Valid() {
dr.StartDescribe(ctx, dr.BlobRef, dr.depth())
}
for _, br := range dr.BlobRefs {
dr.StartDescribe(ctx, br, dr.depth())
}
if err := dr.expandRules(ctx); err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
return &DescribeResponse{metaMap}, nil
}
|
[
"func",
"(",
"sh",
"*",
"Handler",
")",
"DescribeLocked",
"(",
"ctx",
"context",
".",
"Context",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"dres",
"*",
"DescribeResponse",
",",
"err",
"error",
")",
"{",
"if",
"verboseDescribe",
"{",
"t0",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"td",
":=",
"time",
".",
"Since",
"(",
"t0",
")",
"\n",
"var",
"num",
"int",
"\n",
"if",
"dres",
"!=",
"nil",
"{",
"num",
"=",
"len",
"(",
"dres",
".",
"Meta",
")",
"\n",
"}",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"num",
",",
"td",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"sh",
".",
"initDescribeRequest",
"(",
"dr",
")",
"\n",
"if",
"dr",
".",
"BlobRef",
".",
"Valid",
"(",
")",
"{",
"dr",
".",
"StartDescribe",
"(",
"ctx",
",",
"dr",
".",
"BlobRef",
",",
"dr",
".",
"depth",
"(",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"br",
":=",
"range",
"dr",
".",
"BlobRefs",
"{",
"dr",
".",
"StartDescribe",
"(",
"ctx",
",",
"br",
",",
"dr",
".",
"depth",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"dr",
".",
"expandRules",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"metaMap",
",",
"err",
":=",
"dr",
".",
"metaMap",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"DescribeResponse",
"{",
"metaMap",
"}",
",",
"nil",
"\n",
"}"
] |
// 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",
")",
"\n",
"for",
"_",
",",
"rule",
":=",
"range",
"dr",
".",
"Rules",
"{",
"rule",
".",
"appendToFlatCache",
"(",
"dr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"dr",
".",
"flatRuleCache",
"\n",
"}"
] |
// Requires dr.mu is held
|
[
"Requires",
"dr",
".",
"mu",
"is",
"held"
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L146-L154
|
train
|
perkeep/perkeep
|
pkg/search/describe.go
|
URLSuffix
|
func (dr *DescribeRequest) URLSuffix() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camli/search/describe?depth=%d&maxdirchildren=%d",
dr.depth(), dr.maxDirChildren())
for _, br := range dr.BlobRefs {
buf.WriteString("&blobref=")
buf.WriteString(br.String())
}
if len(dr.BlobRefs) == 0 && dr.BlobRef.Valid() {
buf.WriteString("&blobref=")
buf.WriteString(dr.BlobRef.String())
}
if !dr.At.IsAnyZero() {
buf.WriteString("&at=")
buf.WriteString(dr.At.String())
}
return buf.String()
}
|
go
|
func (dr *DescribeRequest) URLSuffix() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "camli/search/describe?depth=%d&maxdirchildren=%d",
dr.depth(), dr.maxDirChildren())
for _, br := range dr.BlobRefs {
buf.WriteString("&blobref=")
buf.WriteString(br.String())
}
if len(dr.BlobRefs) == 0 && dr.BlobRef.Valid() {
buf.WriteString("&blobref=")
buf.WriteString(dr.BlobRef.String())
}
if !dr.At.IsAnyZero() {
buf.WriteString("&at=")
buf.WriteString(dr.At.String())
}
return buf.String()
}
|
[
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"URLSuffix",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"",
"\"",
",",
"dr",
".",
"depth",
"(",
")",
",",
"dr",
".",
"maxDirChildren",
"(",
")",
")",
"\n",
"for",
"_",
",",
"br",
":=",
"range",
"dr",
".",
"BlobRefs",
"{",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"br",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"dr",
".",
"BlobRefs",
")",
"==",
"0",
"&&",
"dr",
".",
"BlobRef",
".",
"Valid",
"(",
")",
"{",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"dr",
".",
"BlobRef",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"dr",
".",
"At",
".",
"IsAnyZero",
"(",
")",
"{",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"dr",
".",
"At",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] |
// URLSuffix returns the URL suffix for GET requests.
// This is deprecated.
|
[
"URLSuffix",
"returns",
"the",
"URL",
"suffix",
"for",
"GET",
"requests",
".",
"This",
"is",
"deprecated",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L279-L296
|
train
|
perkeep/perkeep
|
pkg/search/describe.go
|
PermanodeFile
|
func (b *DescribedBlob) PermanodeFile() (path []blob.Ref, fi *camtypes.FileInfo, ok bool) {
if b == nil || b.Permanode == nil {
return
}
if contentRef := b.Permanode.Attr.Get("camliContent"); contentRef != "" {
if cdes := b.Request.DescribedBlobStr(contentRef); cdes != nil && cdes.File != nil {
return []blob.Ref{b.BlobRef, cdes.BlobRef}, cdes.File, true
}
}
return
}
|
go
|
func (b *DescribedBlob) PermanodeFile() (path []blob.Ref, fi *camtypes.FileInfo, ok bool) {
if b == nil || b.Permanode == nil {
return
}
if contentRef := b.Permanode.Attr.Get("camliContent"); contentRef != "" {
if cdes := b.Request.DescribedBlobStr(contentRef); cdes != nil && cdes.File != nil {
return []blob.Ref{b.BlobRef, cdes.BlobRef}, cdes.File, true
}
}
return
}
|
[
"func",
"(",
"b",
"*",
"DescribedBlob",
")",
"PermanodeFile",
"(",
")",
"(",
"path",
"[",
"]",
"blob",
".",
"Ref",
",",
"fi",
"*",
"camtypes",
".",
"FileInfo",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"Permanode",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"contentRef",
":=",
"b",
".",
"Permanode",
".",
"Attr",
".",
"Get",
"(",
"\"",
"\"",
")",
";",
"contentRef",
"!=",
"\"",
"\"",
"{",
"if",
"cdes",
":=",
"b",
".",
"Request",
".",
"DescribedBlobStr",
"(",
"contentRef",
")",
";",
"cdes",
"!=",
"nil",
"&&",
"cdes",
".",
"File",
"!=",
"nil",
"{",
"return",
"[",
"]",
"blob",
".",
"Ref",
"{",
"b",
".",
"BlobRef",
",",
"cdes",
".",
"BlobRef",
"}",
",",
"cdes",
".",
"File",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// 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",
"that",
"is",
"a",
"file",
"blob",
"ok",
"is",
"false",
"."
] |
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",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"dr",
".",
"m",
"[",
"blobstr",
"]",
"\n",
"}"
] |
// 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",
"{",
"return",
"peer",
"\n",
"}",
"\n",
"return",
"&",
"DescribedBlob",
"{",
"Request",
":",
"b",
".",
"Request",
",",
"BlobRef",
":",
"br",
",",
"Stub",
":",
"true",
"}",
"\n",
"}"
] |
// version of PeerBlob when b.Request.mu is already held.
|
[
"version",
"of",
"PeerBlob",
"when",
"b",
".",
"Request",
".",
"mu",
"is",
"already",
"held",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L478-L483
|
train
|
perkeep/perkeep
|
pkg/search/describe.go
|
NewDescribeRequest
|
func (sh *Handler) NewDescribeRequest() *DescribeRequest {
dr := new(DescribeRequest)
sh.initDescribeRequest(dr)
return dr
}
|
go
|
func (sh *Handler) NewDescribeRequest() *DescribeRequest {
dr := new(DescribeRequest)
sh.initDescribeRequest(dr)
return dr
}
|
[
"func",
"(",
"sh",
"*",
"Handler",
")",
"NewDescribeRequest",
"(",
")",
"*",
"DescribeRequest",
"{",
"dr",
":=",
"new",
"(",
"DescribeRequest",
")",
"\n",
"sh",
".",
"initDescribeRequest",
"(",
"dr",
")",
"\n",
"return",
"dr",
"\n",
"}"
] |
// NewDescribeRequest returns a new DescribeRequest holding the state
// of blobs and their summarized descriptions. Use DescribeBlob
// one or more times before calling Result.
|
[
"NewDescribeRequest",
"returns",
"a",
"new",
"DescribeRequest",
"holding",
"the",
"state",
"of",
"blobs",
"and",
"their",
"summarized",
"descriptions",
".",
"Use",
"DescribeBlob",
"one",
"or",
"more",
"times",
"before",
"calling",
"Result",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L507-L511
|
train
|
perkeep/perkeep
|
pkg/search/describe.go
|
StartDescribe
|
func (dr *DescribeRequest) StartDescribe(ctx context.Context, br blob.Ref, depth int) {
if depth <= 0 {
return
}
dr.mu.Lock()
defer dr.mu.Unlock()
if dr.blobDesLock == nil {
dr.blobDesLock = make(map[blob.Ref]*sync.Mutex)
}
desBlobMu, ok := dr.blobDesLock[br]
if !ok {
desBlobMu = new(sync.Mutex)
dr.blobDesLock[br] = desBlobMu
}
if dr.started == nil {
dr.started = make(map[blobrefAndDepth]bool)
}
key := blobrefAndDepth{br, depth}
if dr.started[key] {
return
}
dr.started[key] = true
dr.wg.Add(1)
go func() {
defer dr.wg.Done()
desBlobMu.Lock()
defer desBlobMu.Unlock()
dr.doDescribe(ctx, br, depth)
}()
}
|
go
|
func (dr *DescribeRequest) StartDescribe(ctx context.Context, br blob.Ref, depth int) {
if depth <= 0 {
return
}
dr.mu.Lock()
defer dr.mu.Unlock()
if dr.blobDesLock == nil {
dr.blobDesLock = make(map[blob.Ref]*sync.Mutex)
}
desBlobMu, ok := dr.blobDesLock[br]
if !ok {
desBlobMu = new(sync.Mutex)
dr.blobDesLock[br] = desBlobMu
}
if dr.started == nil {
dr.started = make(map[blobrefAndDepth]bool)
}
key := blobrefAndDepth{br, depth}
if dr.started[key] {
return
}
dr.started[key] = true
dr.wg.Add(1)
go func() {
defer dr.wg.Done()
desBlobMu.Lock()
defer desBlobMu.Unlock()
dr.doDescribe(ctx, br, depth)
}()
}
|
[
"func",
"(",
"dr",
"*",
"DescribeRequest",
")",
"StartDescribe",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"depth",
"int",
")",
"{",
"if",
"depth",
"<=",
"0",
"{",
"return",
"\n",
"}",
"\n",
"dr",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dr",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"dr",
".",
"blobDesLock",
"==",
"nil",
"{",
"dr",
".",
"blobDesLock",
"=",
"make",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"*",
"sync",
".",
"Mutex",
")",
"\n",
"}",
"\n",
"desBlobMu",
",",
"ok",
":=",
"dr",
".",
"blobDesLock",
"[",
"br",
"]",
"\n",
"if",
"!",
"ok",
"{",
"desBlobMu",
"=",
"new",
"(",
"sync",
".",
"Mutex",
")",
"\n",
"dr",
".",
"blobDesLock",
"[",
"br",
"]",
"=",
"desBlobMu",
"\n",
"}",
"\n",
"if",
"dr",
".",
"started",
"==",
"nil",
"{",
"dr",
".",
"started",
"=",
"make",
"(",
"map",
"[",
"blobrefAndDepth",
"]",
"bool",
")",
"\n",
"}",
"\n",
"key",
":=",
"blobrefAndDepth",
"{",
"br",
",",
"depth",
"}",
"\n",
"if",
"dr",
".",
"started",
"[",
"key",
"]",
"{",
"return",
"\n",
"}",
"\n",
"dr",
".",
"started",
"[",
"key",
"]",
"=",
"true",
"\n",
"dr",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"dr",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"desBlobMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"desBlobMu",
".",
"Unlock",
"(",
")",
"\n",
"dr",
".",
"doDescribe",
"(",
"ctx",
",",
"br",
",",
"depth",
")",
"\n",
"}",
"(",
")",
"\n",
"}"
] |
// StartDescribe starts a lookup of br, down to the provided depth.
// It returns immediately. One should call Result to wait for the description to
// be completed.
|
[
"StartDescribe",
"starts",
"a",
"lookup",
"of",
"br",
"down",
"to",
"the",
"provided",
"depth",
".",
"It",
"returns",
"immediately",
".",
"One",
"should",
"call",
"Result",
"to",
"wait",
"for",
"the",
"description",
"to",
"be",
"completed",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L597-L626
|
train
|
perkeep/perkeep
|
pkg/search/describe.go
|
newMatches
|
func (r *DescribeRule) newMatches(br blob.Ref, dr *DescribeRequest) (brs []blob.Ref) {
if r.IfResultRoot {
if !dr.blobInitiallyRequested(br) {
return nil
}
}
if r.parentRule != nil {
if _, ok := dr.resFromRule[r.parentRule][br]; !ok {
return nil
}
}
db, ok := dr.m[br.String()]
if !ok || db.Permanode == nil {
return nil
}
if t := r.IfCamliNodeType; t != "" {
gotType := db.Permanode.Attr.Get("camliNodeType")
if gotType != t {
return nil
}
}
for attr, vv := range db.Permanode.Attr {
matches := false
for _, matchAttr := range r.Attrs {
if attr == matchAttr {
matches = true
break
}
if strings.HasSuffix(matchAttr, "*") && strings.HasPrefix(attr, strings.TrimSuffix(matchAttr, "*")) {
matches = true
break
}
}
if !matches {
continue
}
for _, v := range vv {
if br, ok := blob.Parse(v); ok {
brs = append(brs, br)
}
}
}
return brs
}
|
go
|
func (r *DescribeRule) newMatches(br blob.Ref, dr *DescribeRequest) (brs []blob.Ref) {
if r.IfResultRoot {
if !dr.blobInitiallyRequested(br) {
return nil
}
}
if r.parentRule != nil {
if _, ok := dr.resFromRule[r.parentRule][br]; !ok {
return nil
}
}
db, ok := dr.m[br.String()]
if !ok || db.Permanode == nil {
return nil
}
if t := r.IfCamliNodeType; t != "" {
gotType := db.Permanode.Attr.Get("camliNodeType")
if gotType != t {
return nil
}
}
for attr, vv := range db.Permanode.Attr {
matches := false
for _, matchAttr := range r.Attrs {
if attr == matchAttr {
matches = true
break
}
if strings.HasSuffix(matchAttr, "*") && strings.HasPrefix(attr, strings.TrimSuffix(matchAttr, "*")) {
matches = true
break
}
}
if !matches {
continue
}
for _, v := range vv {
if br, ok := blob.Parse(v); ok {
brs = append(brs, br)
}
}
}
return brs
}
|
[
"func",
"(",
"r",
"*",
"DescribeRule",
")",
"newMatches",
"(",
"br",
"blob",
".",
"Ref",
",",
"dr",
"*",
"DescribeRequest",
")",
"(",
"brs",
"[",
"]",
"blob",
".",
"Ref",
")",
"{",
"if",
"r",
".",
"IfResultRoot",
"{",
"if",
"!",
"dr",
".",
"blobInitiallyRequested",
"(",
"br",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"r",
".",
"parentRule",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"dr",
".",
"resFromRule",
"[",
"r",
".",
"parentRule",
"]",
"[",
"br",
"]",
";",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"db",
",",
"ok",
":=",
"dr",
".",
"m",
"[",
"br",
".",
"String",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"||",
"db",
".",
"Permanode",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"t",
":=",
"r",
".",
"IfCamliNodeType",
";",
"t",
"!=",
"\"",
"\"",
"{",
"gotType",
":=",
"db",
".",
"Permanode",
".",
"Attr",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"gotType",
"!=",
"t",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"attr",
",",
"vv",
":=",
"range",
"db",
".",
"Permanode",
".",
"Attr",
"{",
"matches",
":=",
"false",
"\n",
"for",
"_",
",",
"matchAttr",
":=",
"range",
"r",
".",
"Attrs",
"{",
"if",
"attr",
"==",
"matchAttr",
"{",
"matches",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"matchAttr",
",",
"\"",
"\"",
")",
"&&",
"strings",
".",
"HasPrefix",
"(",
"attr",
",",
"strings",
".",
"TrimSuffix",
"(",
"matchAttr",
",",
"\"",
"\"",
")",
")",
"{",
"matches",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"matches",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"vv",
"{",
"if",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"v",
")",
";",
"ok",
"{",
"brs",
"=",
"append",
"(",
"brs",
",",
"br",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"brs",
"\n",
"}"
] |
// 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",
"[",
"*",
"DescribeRule",
"]",
"map",
"[",
"blob",
".",
"Ref",
"]",
"bool",
")",
"\n",
"}",
"\n",
"m",
",",
"ok",
":=",
"dr",
".",
"resFromRule",
"[",
"rule",
"]",
"\n",
"if",
"!",
"ok",
"{",
"m",
"=",
"make",
"(",
"map",
"[",
"blob",
".",
"Ref",
"]",
"bool",
")",
"\n",
"dr",
".",
"resFromRule",
"[",
"rule",
"]",
"=",
"m",
"\n",
"}",
"\n",
"m",
"[",
"br",
"]",
"=",
"true",
"\n",
"}"
] |
// dr.mu just be locked.
|
[
"dr",
".",
"mu",
"just",
"be",
"locked",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/describe.go#L675-L685
|
train
|
perkeep/perkeep
|
clients/web/embed/closure/updatelibrary.go
|
fileList
|
func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closure", "goog", "deps.js")
f, err := os.Open(closureDepsFile)
if err != nil {
return nil, err
}
defer f.Close()
allClosureDeps, err := closure.DeepParseDeps(f)
if err != nil {
return nil, err
}
uiDeps, err := closure.GenDeps(http.Dir(uiDir))
if err != nil {
return nil, err
}
_, requ, err := closure.ParseDeps(bytes.NewReader(uiDeps))
if err != nil {
return nil, err
}
nameDone := make(map[string]bool)
jsfilesDone := make(map[string]bool)
for _, deps := range requ {
for _, dep := range deps {
if _, ok := nameDone[dep]; ok {
continue
}
jsfiles := allClosureDeps[dep]
for _, filename := range jsfiles {
if _, ok := jsfilesDone[filename]; ok {
continue
}
jsfilesDone[filename] = true
}
nameDone[dep] = true
}
}
jsfiles := []string{
"AUTHORS",
"LICENSE",
"README.md",
filepath.Join("closure", "goog", "base.js"),
filepath.Join("closure", "goog", "bootstrap", "nodejs.js"),
filepath.Join("closure", "goog", "bootstrap", "webworkers.js"),
filepath.Join("closure", "goog", "css", "common.css"),
filepath.Join("closure", "goog", "css", "toolbar.css"),
filepath.Join("closure", "goog", "deps.js"),
}
prefix := filepath.Join("closure", "goog")
for k := range jsfilesDone {
jsfiles = append(jsfiles, filepath.Join(prefix, k))
}
sort.Strings(jsfiles)
return jsfiles, nil
}
|
go
|
func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closure", "goog", "deps.js")
f, err := os.Open(closureDepsFile)
if err != nil {
return nil, err
}
defer f.Close()
allClosureDeps, err := closure.DeepParseDeps(f)
if err != nil {
return nil, err
}
uiDeps, err := closure.GenDeps(http.Dir(uiDir))
if err != nil {
return nil, err
}
_, requ, err := closure.ParseDeps(bytes.NewReader(uiDeps))
if err != nil {
return nil, err
}
nameDone := make(map[string]bool)
jsfilesDone := make(map[string]bool)
for _, deps := range requ {
for _, dep := range deps {
if _, ok := nameDone[dep]; ok {
continue
}
jsfiles := allClosureDeps[dep]
for _, filename := range jsfiles {
if _, ok := jsfilesDone[filename]; ok {
continue
}
jsfilesDone[filename] = true
}
nameDone[dep] = true
}
}
jsfiles := []string{
"AUTHORS",
"LICENSE",
"README.md",
filepath.Join("closure", "goog", "base.js"),
filepath.Join("closure", "goog", "bootstrap", "nodejs.js"),
filepath.Join("closure", "goog", "bootstrap", "webworkers.js"),
filepath.Join("closure", "goog", "css", "common.css"),
filepath.Join("closure", "goog", "css", "toolbar.css"),
filepath.Join("closure", "goog", "deps.js"),
}
prefix := filepath.Join("closure", "goog")
for k := range jsfilesDone {
jsfiles = append(jsfiles, filepath.Join(prefix, k))
}
sort.Strings(jsfiles)
return jsfiles, nil
}
|
[
"func",
"fileList",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"camliRootPath",
",",
"err",
":=",
"osutil",
".",
"GoPackagePath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"uiDir",
":=",
"filepath",
".",
"Join",
"(",
"camliRootPath",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"closureDepsFile",
":=",
"filepath",
".",
"Join",
"(",
"closureGitDir",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"closureDepsFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"allClosureDeps",
",",
"err",
":=",
"closure",
".",
"DeepParseDeps",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"uiDeps",
",",
"err",
":=",
"closure",
".",
"GenDeps",
"(",
"http",
".",
"Dir",
"(",
"uiDir",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"requ",
",",
"err",
":=",
"closure",
".",
"ParseDeps",
"(",
"bytes",
".",
"NewReader",
"(",
"uiDeps",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"nameDone",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"jsfilesDone",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"deps",
":=",
"range",
"requ",
"{",
"for",
"_",
",",
"dep",
":=",
"range",
"deps",
"{",
"if",
"_",
",",
"ok",
":=",
"nameDone",
"[",
"dep",
"]",
";",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"jsfiles",
":=",
"allClosureDeps",
"[",
"dep",
"]",
"\n",
"for",
"_",
",",
"filename",
":=",
"range",
"jsfiles",
"{",
"if",
"_",
",",
"ok",
":=",
"jsfilesDone",
"[",
"filename",
"]",
";",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"jsfilesDone",
"[",
"filename",
"]",
"=",
"true",
"\n",
"}",
"\n",
"nameDone",
"[",
"dep",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"jsfiles",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"}",
"\n",
"prefix",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"for",
"k",
":=",
"range",
"jsfilesDone",
"{",
"jsfiles",
"=",
"append",
"(",
"jsfiles",
",",
"filepath",
".",
"Join",
"(",
"prefix",
",",
"k",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"jsfiles",
")",
"\n",
"return",
"jsfiles",
",",
"nil",
"\n",
"}"
] |
// 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",
"lib",
"required",
"for",
"the",
"UI",
"."
] |
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",
"cmd",
".",
"Stdout",
"=",
"&",
"stdout",
"\n",
"cmd",
".",
"Stderr",
"=",
"&",
"stderr",
"\n",
"err",
":=",
"cmd",
".",
"Run",
"(",
")",
"\n",
"out",
":=",
"stdout",
".",
"Bytes",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"c",
",",
"err",
",",
"string",
"(",
"out",
")",
",",
"stderr",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"out",
"\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",
"(",
"&",
"bson",
".",
"M",
"{",
"mgoKey",
":",
"key",
"}",
")",
"\n",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// 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",
"(",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// 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",
"return",
"false",
"\n",
"}",
"\n",
"ok",
",",
"err",
":=",
"idx",
".",
"HasLegacySHA1",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"ok",
"\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(mpl): change index funcs to take signer keyID. dont care for now, just
// fixing the essential search and describe ones.
errch <- h.index.GetRecentPermanodes(ctx, ch, h.owner.BlobRef(), req.n(), before)
}()
dr := h.NewDescribeRequest()
var recent []*RecentItem
for res := range ch {
dr.StartDescribe(ctx, res.Permanode, 2)
recent = append(recent, &RecentItem{
BlobRef: res.Permanode,
Owner: res.Signer,
ModTime: types.Time3339(res.LastModTime),
})
testHookBug121() // http://perkeep.org/issue/121
}
if err := <-errch; err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &RecentResponse{
Recent: recent,
Meta: metaMap,
}
return res, nil
}
|
go
|
func (h *Handler) GetRecentPermanodes(ctx context.Context, req *RecentRequest) (*RecentResponse, error) {
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan camtypes.RecentPermanode)
errch := make(chan error, 1)
before := time.Now()
if !req.Before.IsZero() {
before = req.Before
}
go func() {
// TODO(mpl): change index funcs to take signer keyID. dont care for now, just
// fixing the essential search and describe ones.
errch <- h.index.GetRecentPermanodes(ctx, ch, h.owner.BlobRef(), req.n(), before)
}()
dr := h.NewDescribeRequest()
var recent []*RecentItem
for res := range ch {
dr.StartDescribe(ctx, res.Permanode, 2)
recent = append(recent, &RecentItem{
BlobRef: res.Permanode,
Owner: res.Signer,
ModTime: types.Time3339(res.LastModTime),
})
testHookBug121() // http://perkeep.org/issue/121
}
if err := <-errch; err != nil {
return nil, err
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &RecentResponse{
Recent: recent,
Meta: metaMap,
}
return res, nil
}
|
[
"func",
"(",
"h",
"*",
"Handler",
")",
"GetRecentPermanodes",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"RecentRequest",
")",
"(",
"*",
"RecentResponse",
",",
"error",
")",
"{",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"index",
".",
"RUnlock",
"(",
")",
"\n\n",
"ch",
":=",
"make",
"(",
"chan",
"camtypes",
".",
"RecentPermanode",
")",
"\n",
"errch",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"before",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"if",
"!",
"req",
".",
"Before",
".",
"IsZero",
"(",
")",
"{",
"before",
"=",
"req",
".",
"Before",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"// TODO(mpl): change index funcs to take signer keyID. dont care for now, just",
"// fixing the essential search and describe ones.",
"errch",
"<-",
"h",
".",
"index",
".",
"GetRecentPermanodes",
"(",
"ctx",
",",
"ch",
",",
"h",
".",
"owner",
".",
"BlobRef",
"(",
")",
",",
"req",
".",
"n",
"(",
")",
",",
"before",
")",
"\n",
"}",
"(",
")",
"\n\n",
"dr",
":=",
"h",
".",
"NewDescribeRequest",
"(",
")",
"\n\n",
"var",
"recent",
"[",
"]",
"*",
"RecentItem",
"\n",
"for",
"res",
":=",
"range",
"ch",
"{",
"dr",
".",
"StartDescribe",
"(",
"ctx",
",",
"res",
".",
"Permanode",
",",
"2",
")",
"\n",
"recent",
"=",
"append",
"(",
"recent",
",",
"&",
"RecentItem",
"{",
"BlobRef",
":",
"res",
".",
"Permanode",
",",
"Owner",
":",
"res",
".",
"Signer",
",",
"ModTime",
":",
"types",
".",
"Time3339",
"(",
"res",
".",
"LastModTime",
")",
",",
"}",
")",
"\n",
"testHookBug121",
"(",
")",
"// http://perkeep.org/issue/121",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"<-",
"errch",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"metaMap",
",",
"err",
":=",
"dr",
".",
"metaMap",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"RecentResponse",
"{",
"Recent",
":",
"recent",
",",
"Meta",
":",
"metaMap",
",",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// GetRecentPermanodes returns recently-modified permanodes.
|
[
"GetRecentPermanodes",
"returns",
"recently",
"-",
"modified",
"permanodes",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L514-L557
|
train
|
perkeep/perkeep
|
pkg/search/handler.go
|
GetPermanodesWithAttr
|
func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
errch <- h.index.SearchPermanodesWithAttr(ctx, ch,
&camtypes.PermanodeByAttrRequest{
Attribute: req.Attr,
Query: req.Value,
Signer: signer,
FuzzyMatch: req.Fuzzy,
MaxResults: req.N,
At: req.At,
})
}()
dr := h.NewDescribeRequest()
var withAttr []*WithAttrItem
for res := range ch {
dr.StartDescribe(ctx, res, 2)
withAttr = append(withAttr, &WithAttrItem{
Permanode: res,
})
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
if err := <-errch; err != nil {
return nil, err
}
res := &WithAttrResponse{
WithAttr: withAttr,
Meta: metaMap,
}
return res, nil
}
|
go
|
func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
errch <- h.index.SearchPermanodesWithAttr(ctx, ch,
&camtypes.PermanodeByAttrRequest{
Attribute: req.Attr,
Query: req.Value,
Signer: signer,
FuzzyMatch: req.Fuzzy,
MaxResults: req.N,
At: req.At,
})
}()
dr := h.NewDescribeRequest()
var withAttr []*WithAttrItem
for res := range ch {
dr.StartDescribe(ctx, res, 2)
withAttr = append(withAttr, &WithAttrItem{
Permanode: res,
})
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
if err := <-errch; err != nil {
return nil, err
}
res := &WithAttrResponse{
WithAttr: withAttr,
Meta: metaMap,
}
return res, nil
}
|
[
"func",
"(",
"h",
"*",
"Handler",
")",
"GetPermanodesWithAttr",
"(",
"req",
"*",
"WithAttrRequest",
")",
"(",
"*",
"WithAttrResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n\n",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"index",
".",
"RUnlock",
"(",
")",
"\n\n",
"ch",
":=",
"make",
"(",
"chan",
"blob",
".",
"Ref",
",",
"buffered",
")",
"\n",
"errch",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"signer",
":=",
"req",
".",
"Signer",
"\n",
"if",
"!",
"signer",
".",
"Valid",
"(",
")",
"{",
"signer",
"=",
"h",
".",
"owner",
".",
"BlobRef",
"(",
")",
"\n",
"}",
"\n",
"errch",
"<-",
"h",
".",
"index",
".",
"SearchPermanodesWithAttr",
"(",
"ctx",
",",
"ch",
",",
"&",
"camtypes",
".",
"PermanodeByAttrRequest",
"{",
"Attribute",
":",
"req",
".",
"Attr",
",",
"Query",
":",
"req",
".",
"Value",
",",
"Signer",
":",
"signer",
",",
"FuzzyMatch",
":",
"req",
".",
"Fuzzy",
",",
"MaxResults",
":",
"req",
".",
"N",
",",
"At",
":",
"req",
".",
"At",
",",
"}",
")",
"\n",
"}",
"(",
")",
"\n\n",
"dr",
":=",
"h",
".",
"NewDescribeRequest",
"(",
")",
"\n\n",
"var",
"withAttr",
"[",
"]",
"*",
"WithAttrItem",
"\n",
"for",
"res",
":=",
"range",
"ch",
"{",
"dr",
".",
"StartDescribe",
"(",
"ctx",
",",
"res",
",",
"2",
")",
"\n",
"withAttr",
"=",
"append",
"(",
"withAttr",
",",
"&",
"WithAttrItem",
"{",
"Permanode",
":",
"res",
",",
"}",
")",
"\n",
"}",
"\n\n",
"metaMap",
",",
"err",
":=",
"dr",
".",
"metaMap",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"<-",
"errch",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"WithAttrResponse",
"{",
"WithAttr",
":",
"withAttr",
",",
"Meta",
":",
"metaMap",
",",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// GetPermanodesWithAttr returns permanodes with attribute req.Attr
// having the req.Value as a value.
// See WithAttrRequest for more details about the query.
|
[
"GetPermanodesWithAttr",
"returns",
"permanodes",
"with",
"attribute",
"req",
".",
"Attr",
"having",
"the",
"req",
".",
"Value",
"as",
"a",
"value",
".",
"See",
"WithAttrRequest",
"for",
"more",
"details",
"about",
"the",
"query",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L574-L622
|
train
|
perkeep/perkeep
|
pkg/search/handler.go
|
GetClaims
|
func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.Permanode, h.owner.KeyID(), req.AttrFilter)
if err != nil {
return nil, fmt.Errorf("Error getting claims of %s: %v", req.Permanode.String(), err)
}
sort.Sort(camtypes.ClaimsByDate(claims))
var jclaims []*ClaimsItem
for _, claim := range claims {
jclaim := &ClaimsItem{
BlobRef: claim.BlobRef,
Signer: claim.Signer,
Permanode: claim.Permanode,
Date: types.Time3339(claim.Date),
Type: claim.Type,
Attr: claim.Attr,
Value: claim.Value,
}
jclaims = append(jclaims, jclaim)
}
res := &ClaimsResponse{
Claims: jclaims,
}
return res, nil
}
|
go
|
func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.Permanode, h.owner.KeyID(), req.AttrFilter)
if err != nil {
return nil, fmt.Errorf("Error getting claims of %s: %v", req.Permanode.String(), err)
}
sort.Sort(camtypes.ClaimsByDate(claims))
var jclaims []*ClaimsItem
for _, claim := range claims {
jclaim := &ClaimsItem{
BlobRef: claim.BlobRef,
Signer: claim.Signer,
Permanode: claim.Permanode,
Date: types.Time3339(claim.Date),
Type: claim.Type,
Attr: claim.Attr,
Value: claim.Value,
}
jclaims = append(jclaims, jclaim)
}
res := &ClaimsResponse{
Claims: jclaims,
}
return res, nil
}
|
[
"func",
"(",
"h",
"*",
"Handler",
")",
"GetClaims",
"(",
"req",
"*",
"ClaimsRequest",
")",
"(",
"*",
"ClaimsResponse",
",",
"error",
")",
"{",
"if",
"!",
"req",
".",
"Permanode",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"index",
".",
"RUnlock",
"(",
")",
"\n\n",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"var",
"claims",
"[",
"]",
"camtypes",
".",
"Claim",
"\n",
"claims",
",",
"err",
":=",
"h",
".",
"index",
".",
"AppendClaims",
"(",
"ctx",
",",
"claims",
",",
"req",
".",
"Permanode",
",",
"h",
".",
"owner",
".",
"KeyID",
"(",
")",
",",
"req",
".",
"AttrFilter",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"req",
".",
"Permanode",
".",
"String",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"camtypes",
".",
"ClaimsByDate",
"(",
"claims",
")",
")",
"\n",
"var",
"jclaims",
"[",
"]",
"*",
"ClaimsItem",
"\n",
"for",
"_",
",",
"claim",
":=",
"range",
"claims",
"{",
"jclaim",
":=",
"&",
"ClaimsItem",
"{",
"BlobRef",
":",
"claim",
".",
"BlobRef",
",",
"Signer",
":",
"claim",
".",
"Signer",
",",
"Permanode",
":",
"claim",
".",
"Permanode",
",",
"Date",
":",
"types",
".",
"Time3339",
"(",
"claim",
".",
"Date",
")",
",",
"Type",
":",
"claim",
".",
"Type",
",",
"Attr",
":",
"claim",
".",
"Attr",
",",
"Value",
":",
"claim",
".",
"Value",
",",
"}",
"\n",
"jclaims",
"=",
"append",
"(",
"jclaims",
",",
"jclaim",
")",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"ClaimsResponse",
"{",
"Claims",
":",
"jclaims",
",",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// GetClaims returns the claims on req.Permanode signed by h.owner.
|
[
"GetClaims",
"returns",
"the",
"claims",
"on",
"req",
".",
"Permanode",
"signed",
"by",
"h",
".",
"owner",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L641-L673
|
train
|
perkeep/perkeep
|
pkg/search/handler.go
|
EdgesTo
|
func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
edge *EdgeItem // or nil
err error
}
resc := make(chan edgeOrError)
verify := func(edge *camtypes.Edge) {
db, err := h.NewDescribeRequest().DescribeSync(ctx, edge.From)
if err != nil {
resc <- edgeOrError{err: err}
return
}
found := false
if db.Permanode != nil {
for attr, vv := range db.Permanode.Attr {
if index.IsBlobReferenceAttribute(attr) {
for _, v := range vv {
if v == toRefStr {
found = true
}
}
}
}
}
var ei *EdgeItem
if found {
ei = &EdgeItem{
From: edge.From,
FromType: "permanode",
}
}
resc <- edgeOrError{edge: ei}
}
verifying := 0
for _, edge := range edges {
if edge.FromType == "permanode" {
verifying++
go verify(edge)
continue
}
ei := &EdgeItem{
From: edge.From,
FromType: edge.FromType,
}
edgeItems = append(edgeItems, ei)
}
for i := 0; i < verifying; i++ {
res := <-resc
if res.err != nil {
return nil, res.err
}
if res.edge != nil {
edgeItems = append(edgeItems, res.edge)
}
}
return &EdgesResponse{
ToRef: toRef,
EdgesTo: edgeItems,
}, nil
}
|
go
|
func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
edge *EdgeItem // or nil
err error
}
resc := make(chan edgeOrError)
verify := func(edge *camtypes.Edge) {
db, err := h.NewDescribeRequest().DescribeSync(ctx, edge.From)
if err != nil {
resc <- edgeOrError{err: err}
return
}
found := false
if db.Permanode != nil {
for attr, vv := range db.Permanode.Attr {
if index.IsBlobReferenceAttribute(attr) {
for _, v := range vv {
if v == toRefStr {
found = true
}
}
}
}
}
var ei *EdgeItem
if found {
ei = &EdgeItem{
From: edge.From,
FromType: "permanode",
}
}
resc <- edgeOrError{edge: ei}
}
verifying := 0
for _, edge := range edges {
if edge.FromType == "permanode" {
verifying++
go verify(edge)
continue
}
ei := &EdgeItem{
From: edge.From,
FromType: edge.FromType,
}
edgeItems = append(edgeItems, ei)
}
for i := 0; i < verifying; i++ {
res := <-resc
if res.err != nil {
return nil, res.err
}
if res.edge != nil {
edgeItems = append(edgeItems, res.edge)
}
}
return &EdgesResponse{
ToRef: toRef,
EdgesTo: edgeItems,
}, nil
}
|
[
"func",
"(",
"h",
"*",
"Handler",
")",
"EdgesTo",
"(",
"req",
"*",
"EdgesRequest",
")",
"(",
"*",
"EdgesResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"index",
".",
"RUnlock",
"(",
")",
"\n\n",
"toRef",
":=",
"req",
".",
"ToRef",
"\n",
"toRefStr",
":=",
"toRef",
".",
"String",
"(",
")",
"\n",
"var",
"edgeItems",
"[",
"]",
"*",
"EdgeItem",
"\n\n",
"edges",
",",
"err",
":=",
"h",
".",
"index",
".",
"EdgesTo",
"(",
"toRef",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"type",
"edgeOrError",
"struct",
"{",
"edge",
"*",
"EdgeItem",
"// or nil",
"\n",
"err",
"error",
"\n",
"}",
"\n",
"resc",
":=",
"make",
"(",
"chan",
"edgeOrError",
")",
"\n",
"verify",
":=",
"func",
"(",
"edge",
"*",
"camtypes",
".",
"Edge",
")",
"{",
"db",
",",
"err",
":=",
"h",
".",
"NewDescribeRequest",
"(",
")",
".",
"DescribeSync",
"(",
"ctx",
",",
"edge",
".",
"From",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"resc",
"<-",
"edgeOrError",
"{",
"err",
":",
"err",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"found",
":=",
"false",
"\n",
"if",
"db",
".",
"Permanode",
"!=",
"nil",
"{",
"for",
"attr",
",",
"vv",
":=",
"range",
"db",
".",
"Permanode",
".",
"Attr",
"{",
"if",
"index",
".",
"IsBlobReferenceAttribute",
"(",
"attr",
")",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"vv",
"{",
"if",
"v",
"==",
"toRefStr",
"{",
"found",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"ei",
"*",
"EdgeItem",
"\n",
"if",
"found",
"{",
"ei",
"=",
"&",
"EdgeItem",
"{",
"From",
":",
"edge",
".",
"From",
",",
"FromType",
":",
"\"",
"\"",
",",
"}",
"\n",
"}",
"\n",
"resc",
"<-",
"edgeOrError",
"{",
"edge",
":",
"ei",
"}",
"\n",
"}",
"\n",
"verifying",
":=",
"0",
"\n",
"for",
"_",
",",
"edge",
":=",
"range",
"edges",
"{",
"if",
"edge",
".",
"FromType",
"==",
"\"",
"\"",
"{",
"verifying",
"++",
"\n",
"go",
"verify",
"(",
"edge",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"ei",
":=",
"&",
"EdgeItem",
"{",
"From",
":",
"edge",
".",
"From",
",",
"FromType",
":",
"edge",
".",
"FromType",
",",
"}",
"\n",
"edgeItems",
"=",
"append",
"(",
"edgeItems",
",",
"ei",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"verifying",
";",
"i",
"++",
"{",
"res",
":=",
"<-",
"resc",
"\n",
"if",
"res",
".",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"res",
".",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"edge",
"!=",
"nil",
"{",
"edgeItems",
"=",
"append",
"(",
"edgeItems",
",",
"res",
".",
"edge",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"EdgesResponse",
"{",
"ToRef",
":",
"toRef",
",",
"EdgesTo",
":",
"edgeItems",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// 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",
"\n",
"er",
".",
"fromHTTP",
"(",
"req",
")",
"\n",
"res",
",",
"err",
":=",
"h",
".",
"EdgesTo",
"(",
"&",
"er",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"httputil",
".",
"ServeJSONError",
"(",
"rw",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"httputil",
".",
"ReturnJSON",
"(",
"rw",
",",
"res",
")",
"\n",
"}"
] |
// Unlike the index interface's EdgesTo method, the "edgesto" Handler
// here additionally filters out since-deleted permanode edges.
|
[
"Unlike",
"the",
"index",
"interface",
"s",
"EdgesTo",
"method",
"the",
"edgesto",
"Handler",
"here",
"additionally",
"filters",
"out",
"since",
"-",
"deleted",
"permanode",
"edges",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L847-L857
|
train
|
perkeep/perkeep
|
pkg/search/handler.go
|
GetSignerPaths
|
func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock()
defer h.index.RUnlock()
paths, err := h.index.PathsOfSignerTarget(ctx, req.Signer, req.Target)
if err != nil {
return nil, fmt.Errorf("Error getting paths of %s: %v", req.Target.String(), err)
}
var jpaths []*SignerPathsItem
for _, path := range paths {
jpaths = append(jpaths, &SignerPathsItem{
ClaimRef: path.Claim,
BaseRef: path.Base,
Suffix: path.Suffix,
})
}
dr := h.NewDescribeRequest()
for _, path := range paths {
dr.StartDescribe(ctx, path.Base, 2)
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &SignerPathsResponse{
Paths: jpaths,
Meta: metaMap,
}
return res, nil
}
|
go
|
func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock()
defer h.index.RUnlock()
paths, err := h.index.PathsOfSignerTarget(ctx, req.Signer, req.Target)
if err != nil {
return nil, fmt.Errorf("Error getting paths of %s: %v", req.Target.String(), err)
}
var jpaths []*SignerPathsItem
for _, path := range paths {
jpaths = append(jpaths, &SignerPathsItem{
ClaimRef: path.Claim,
BaseRef: path.Base,
Suffix: path.Suffix,
})
}
dr := h.NewDescribeRequest()
for _, path := range paths {
dr.StartDescribe(ctx, path.Base, 2)
}
metaMap, err := dr.metaMap()
if err != nil {
return nil, err
}
res := &SignerPathsResponse{
Paths: jpaths,
Meta: metaMap,
}
return res, nil
}
|
[
"func",
"(",
"h",
"*",
"Handler",
")",
"GetSignerPaths",
"(",
"req",
"*",
"SignerPathsRequest",
")",
"(",
"*",
"SignerPathsResponse",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"\n",
"if",
"!",
"req",
".",
"Signer",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"req",
".",
"Target",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"h",
".",
"index",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"index",
".",
"RUnlock",
"(",
")",
"\n\n",
"paths",
",",
"err",
":=",
"h",
".",
"index",
".",
"PathsOfSignerTarget",
"(",
"ctx",
",",
"req",
".",
"Signer",
",",
"req",
".",
"Target",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"req",
".",
"Target",
".",
"String",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"jpaths",
"[",
"]",
"*",
"SignerPathsItem",
"\n",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"jpaths",
"=",
"append",
"(",
"jpaths",
",",
"&",
"SignerPathsItem",
"{",
"ClaimRef",
":",
"path",
".",
"Claim",
",",
"BaseRef",
":",
"path",
".",
"Base",
",",
"Suffix",
":",
"path",
".",
"Suffix",
",",
"}",
")",
"\n",
"}",
"\n\n",
"dr",
":=",
"h",
".",
"NewDescribeRequest",
"(",
")",
"\n",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"dr",
".",
"StartDescribe",
"(",
"ctx",
",",
"path",
".",
"Base",
",",
"2",
")",
"\n",
"}",
"\n",
"metaMap",
",",
"err",
":=",
"dr",
".",
"metaMap",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"SignerPathsResponse",
"{",
"Paths",
":",
"jpaths",
",",
"Meta",
":",
"metaMap",
",",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// GetSignerPaths returns paths with a target of req.Target.
|
[
"GetSignerPaths",
"returns",
"paths",
"with",
"a",
"target",
"of",
"req",
".",
"Target",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L878-L916
|
train
|
perkeep/perkeep
|
pkg/search/handler.go
|
evalSearchInput
|
func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs, nil
} else {
sq, err := parseExpression(context.TODO(), in)
if err != nil {
return nil, err
}
return sq.Constraint.Logical.B, nil
}
}
|
go
|
func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs, nil
} else {
sq, err := parseExpression(context.TODO(), in)
if err != nil {
return nil, err
}
return sq.Constraint.Logical.B, nil
}
}
|
[
"func",
"evalSearchInput",
"(",
"in",
"string",
")",
"(",
"*",
"Constraint",
",",
"error",
")",
"{",
"if",
"len",
"(",
"in",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"in",
",",
"\"",
"\"",
")",
"&&",
"strings",
".",
"HasSuffix",
"(",
"in",
",",
"\"",
"\"",
")",
"{",
"cs",
":=",
"new",
"(",
"Constraint",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"strings",
".",
"NewReader",
"(",
"in",
")",
")",
".",
"Decode",
"(",
"&",
"cs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"cs",
",",
"nil",
"\n",
"}",
"else",
"{",
"sq",
",",
"err",
":=",
"parseExpression",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"sq",
".",
"Constraint",
".",
"Logical",
".",
"B",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// 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",
".",
"It",
"parses",
"the",
"expression",
"and",
"returns",
"the",
"parsed",
"Constraint",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L933-L950
|
train
|
perkeep/perkeep
|
pkg/search/handler.go
|
getNamed
|
func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search found for: %s", name)
}
permaRef := sr.Blobs[0].Blob
substRefS := sr.Describe.Meta.Get(permaRef).Permanode.Attr.Get("camliContent")
br, ok := blob.Parse(substRefS)
if !ok {
return "", fmt.Errorf("Invalid blob ref: %s", substRefS)
}
reader, _, err := sh.fetcher.Fetch(ctx, br)
if err != nil {
return "", err
}
result, err := ioutil.ReadAll(reader)
if err != nil {
return "", err
}
return string(result), nil
}
|
go
|
func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search found for: %s", name)
}
permaRef := sr.Blobs[0].Blob
substRefS := sr.Describe.Meta.Get(permaRef).Permanode.Attr.Get("camliContent")
br, ok := blob.Parse(substRefS)
if !ok {
return "", fmt.Errorf("Invalid blob ref: %s", substRefS)
}
reader, _, err := sh.fetcher.Fetch(ctx, br)
if err != nil {
return "", err
}
result, err := ioutil.ReadAll(reader)
if err != nil {
return "", err
}
return string(result), nil
}
|
[
"func",
"(",
"sh",
"*",
"Handler",
")",
"getNamed",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"sh",
".",
"fetcher",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"sr",
",",
"err",
":=",
"sh",
".",
"Query",
"(",
"ctx",
",",
"NamedSearch",
"(",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"sr",
".",
"Blobs",
")",
"<",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"permaRef",
":=",
"sr",
".",
"Blobs",
"[",
"0",
"]",
".",
"Blob",
"\n",
"substRefS",
":=",
"sr",
".",
"Describe",
".",
"Meta",
".",
"Get",
"(",
"permaRef",
")",
".",
"Permanode",
".",
"Attr",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"substRefS",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"substRefS",
")",
"\n",
"}",
"\n\n",
"reader",
",",
"_",
",",
"err",
":=",
"sh",
".",
"fetcher",
".",
"Fetch",
"(",
"ctx",
",",
"br",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"result",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"result",
")",
",",
"nil",
"\n",
"}"
] |
// getNamed displays the search expression or constraint json for the requested alias.
|
[
"getNamed",
"displays",
"the",
"search",
"expression",
"or",
"constraint",
"json",
"for",
"the",
"requested",
"alias",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/handler.go#L953-L981
|
train
|
perkeep/perkeep
|
app/scanningcabinet/tags.go
|
newSeparatedString
|
func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sort.StringsAreSorted(ss) {
sort.Strings(ss)
}
return ss
}
|
go
|
func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sort.StringsAreSorted(ss) {
sort.Strings(ss)
}
return ss
}
|
[
"func",
"newSeparatedString",
"(",
"commaSeparated",
"string",
")",
"separatedString",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"commaSeparated",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"split",
":=",
"strings",
".",
"Split",
"(",
"commaSeparated",
",",
"\"",
"\"",
")",
"\n",
"var",
"ss",
"[",
"]",
"string",
"\n",
"for",
"i",
",",
"tag",
":=",
"range",
"split",
"{",
"split",
"[",
"i",
"]",
"=",
"strings",
".",
"TrimSpace",
"(",
"tag",
")",
"\n",
"if",
"split",
"[",
"i",
"]",
"!=",
"\"",
"\"",
"{",
"ss",
"=",
"append",
"(",
"ss",
",",
"split",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"(",
"ss",
")",
"{",
"sort",
".",
"Strings",
"(",
"ss",
")",
"\n",
"}",
"\n",
"return",
"ss",
"\n",
"}"
] |
// newSeparatedString returns a newly created SeparatedString value from the string given.
// There is no error if the string does not include a comma.
|
[
"newSeparatedString",
"returns",
"a",
"newly",
"created",
"SeparatedString",
"value",
"from",
"the",
"string",
"given",
".",
"There",
"is",
"no",
"error",
"if",
"the",
"string",
"does",
"not",
"include",
"a",
"comma",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L28-L44
|
train
|
perkeep/perkeep
|
app/scanningcabinet/tags.go
|
Minus
|
func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || css2[k] != s {
keep = append(keep, s)
}
}
return keep
}
|
go
|
func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || css2[k] != s {
keep = append(keep, s)
}
}
return keep
}
|
[
"func",
"(",
"css",
"separatedString",
")",
"Minus",
"(",
"css2",
"separatedString",
")",
"separatedString",
"{",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"(",
"css",
")",
"{",
"sort",
".",
"Strings",
"(",
"css",
")",
"\n",
"}",
"\n",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"(",
"css2",
")",
"{",
"sort",
".",
"Strings",
"(",
"css2",
")",
"\n",
"}",
"\n",
"k",
":=",
"0",
"\n",
"kMax",
":=",
"len",
"(",
"css2",
")",
"\n",
"keep",
":=",
"css",
"[",
":",
"0",
"]",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"css",
"{",
"for",
"k",
"<",
"kMax",
"&&",
"css2",
"[",
"k",
"]",
"<",
"s",
"{",
"k",
"++",
"\n",
"}",
"\n",
"if",
"k",
"==",
"kMax",
"||",
"css2",
"[",
"k",
"]",
"!=",
"s",
"{",
"keep",
"=",
"append",
"(",
"keep",
",",
"s",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"keep",
"\n",
"}"
] |
// 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",
"(",
"css",
")",
"{",
"sort",
".",
"Strings",
"(",
"css",
")",
"\n",
"}",
"\n",
"if",
"!",
"sort",
".",
"StringsAreSorted",
"(",
"css2",
")",
"{",
"sort",
".",
"Strings",
"(",
"css2",
")",
"\n",
"}",
"\n",
"for",
"k",
",",
"s",
":=",
"range",
"css",
"{",
"if",
"s",
"!=",
"css2",
"[",
"k",
"]",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// equal compares css with css2. Both css and css2 are sorted in place before being compared.
|
[
"equal",
"compares",
"css",
"with",
"css2",
".",
"Both",
"css",
"and",
"css2",
"are",
"sorted",
"in",
"place",
"before",
"being",
"compared",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/scanningcabinet/tags.go#L85-L101
|
train
|
perkeep/perkeep
|
pkg/fs/util.go
|
Unmount
|
func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go func() {
if err := exec.Command("umount", point).Run(); err == nil {
errc <- err
}
// retry to unmount with the fallback cmd
errc <- cmd.Run()
}()
select {
case <-time.After(1 * time.Second):
return errors.New("umount timeout")
case err := <-errc:
return err
}
}
|
go
|
func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go func() {
if err := exec.Command("umount", point).Run(); err == nil {
errc <- err
}
// retry to unmount with the fallback cmd
errc <- cmd.Run()
}()
select {
case <-time.After(1 * time.Second):
return errors.New("umount timeout")
case err := <-errc:
return err
}
}
|
[
"func",
"Unmount",
"(",
"point",
"string",
")",
"error",
"{",
"var",
"cmd",
"*",
"exec",
".",
"Cmd",
"\n",
"switch",
"runtime",
".",
"GOOS",
"{",
"case",
"\"",
"\"",
":",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"point",
")",
"\n",
"case",
"\"",
"\"",
":",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"point",
")",
"\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"errc",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"point",
")",
".",
"Run",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"errc",
"<-",
"err",
"\n",
"}",
"\n",
"// retry to unmount with the fallback cmd",
"errc",
"<-",
"cmd",
".",
"Run",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"1",
"*",
"time",
".",
"Second",
")",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"case",
"err",
":=",
"<-",
"errc",
":",
"return",
"err",
"\n",
"}",
"\n",
"}"
] |
// Unmount attempts to unmount the provided FUSE mount point, forcibly
// if necessary.
|
[
"Unmount",
"attempts",
"to",
"unmount",
"the",
"provided",
"FUSE",
"mount",
"point",
"forcibly",
"if",
"necessary",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/fs/util.go#L28-L53
|
train
|
perkeep/perkeep
|
pkg/blobserver/sftp/sftp.go
|
markConnDead
|
func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
}
|
go
|
func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"markConnDead",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"markConnDeadLocked",
"(",
")",
"\n",
"}"
] |
// markConnDead clears the cached SFTP connection after the caller detects
// a connection failure.
|
[
"markConnDead",
"clears",
"the",
"cached",
"SFTP",
"connection",
"after",
"the",
"caller",
"detects",
"a",
"connection",
"failure",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/sftp/sftp.go#L194-L198
|
train
|
perkeep/perkeep
|
make.go
|
fetchJS
|
func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io.Copy(h, f); err != nil {
return err
}
currentSum = fmt.Sprintf("%x", h.Sum(nil))
}
// fetch the hash of the remote
resp, err := http.Get(jsURL + ".sha256")
if err != nil {
return err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
upstreamSum := strings.TrimSuffix(string(data), "\n")
if currentSum != "" &&
currentSum == upstreamSum {
// We already have the latest version
return nil
}
resp, err = http.Get(jsURL)
if err != nil {
return err
}
defer resp.Body.Close()
js := filepath.Join(pkRoot, filepath.FromSlash(jsOnDisk))
f, err := os.Create(js)
if err != nil {
return err
}
h := sha256.New()
mr := io.MultiWriter(f, h)
if _, err := io.Copy(mr, resp.Body); err != nil {
f.Close()
return err
}
if err := f.Close(); err != nil {
return err
}
sum := fmt.Sprintf("%x", h.Sum(nil))
if upstreamSum != sum {
return fmt.Errorf("checksum mismatch for %q: got %q, want %q", jsURL, sum, upstreamSum)
}
return nil
}
|
go
|
func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io.Copy(h, f); err != nil {
return err
}
currentSum = fmt.Sprintf("%x", h.Sum(nil))
}
// fetch the hash of the remote
resp, err := http.Get(jsURL + ".sha256")
if err != nil {
return err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
upstreamSum := strings.TrimSuffix(string(data), "\n")
if currentSum != "" &&
currentSum == upstreamSum {
// We already have the latest version
return nil
}
resp, err = http.Get(jsURL)
if err != nil {
return err
}
defer resp.Body.Close()
js := filepath.Join(pkRoot, filepath.FromSlash(jsOnDisk))
f, err := os.Create(js)
if err != nil {
return err
}
h := sha256.New()
mr := io.MultiWriter(f, h)
if _, err := io.Copy(mr, resp.Body); err != nil {
f.Close()
return err
}
if err := f.Close(); err != nil {
return err
}
sum := fmt.Sprintf("%x", h.Sum(nil))
if upstreamSum != sum {
return fmt.Errorf("checksum mismatch for %q: got %q, want %q", jsURL, sum, upstreamSum)
}
return nil
}
|
[
"func",
"fetchJS",
"(",
"jsURL",
",",
"jsOnDisk",
"string",
")",
"error",
"{",
"var",
"currentSum",
"string",
"\n",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"jsOnDisk",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// If yes, compute its hash",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"jsOnDisk",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"h",
",",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"currentSum",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"}",
"\n\n",
"// fetch the hash of the remote",
"resp",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"jsURL",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"upstreamSum",
":=",
"strings",
".",
"TrimSuffix",
"(",
"string",
"(",
"data",
")",
",",
"\"",
"\\n",
"\"",
")",
"\n\n",
"if",
"currentSum",
"!=",
"\"",
"\"",
"&&",
"currentSum",
"==",
"upstreamSum",
"{",
"// We already have the latest version",
"return",
"nil",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
"=",
"http",
".",
"Get",
"(",
"jsURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"js",
":=",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"filepath",
".",
"FromSlash",
"(",
"jsOnDisk",
")",
")",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"js",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"mr",
":=",
"io",
".",
"MultiWriter",
"(",
"f",
",",
"h",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"mr",
",",
"resp",
".",
"Body",
")",
";",
"err",
"!=",
"nil",
"{",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"sum",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n\n",
"if",
"upstreamSum",
"!=",
"sum",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"jsURL",
",",
"sum",
",",
"upstreamSum",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// fetchJS gets the javascript resource at jsURL and writes it to jsOnDisk.
// Since said resource can be quite large, it first fetches the hashsum contained
// in the file at jsURL+".sha256", and if we already have the file on disk, with a
// matching hashsum, it does not actually fetch jsURL. If it does, it checks that
// the newly written file does match the hashsum.
|
[
"fetchJS",
"gets",
"the",
"javascript",
"resource",
"at",
"jsURL",
"and",
"writes",
"it",
"to",
"jsOnDisk",
".",
"Since",
"said",
"resource",
"can",
"be",
"quite",
"large",
"it",
"first",
"fetches",
"the",
"hashsum",
"contained",
"in",
"the",
"file",
"at",
"jsURL",
"+",
".",
"sha256",
"and",
"if",
"we",
"already",
"have",
"the",
"file",
"on",
"disk",
"with",
"a",
"matching",
"hashsum",
"it",
"does",
"not",
"actually",
"fetch",
"jsURL",
".",
"If",
"it",
"does",
"it",
"checks",
"that",
"the",
"newly",
"written",
"file",
"does",
"match",
"the",
"hashsum",
"."
] |
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",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"v",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] |
// getVersion returns the version of Perkeep found in a VERSION file at the root.
|
[
"getVersion",
"returns",
"the",
"version",
"of",
"Perkeep",
"found",
"in",
"a",
"VERSION",
"file",
"at",
"the",
"root",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L765-L775
|
train
|
perkeep/perkeep
|
make.go
|
getGitVersion
|
func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir = pkRoot
out, err := cmd.Output()
if err != nil {
log.Fatalf("Error running git rev-list in %s: %v", pkRoot, err)
}
v := strings.TrimSpace(string(out))
if m := gitVersionRx.FindStringSubmatch(v); m != nil {
v = m[0]
} else {
panic("Failed to find git version in " + v)
}
cmd = exec.Command("git", "diff", "--exit-code")
cmd.Dir = pkRoot
if err := cmd.Run(); err != nil {
v += "+"
}
return v
}
|
go
|
func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir = pkRoot
out, err := cmd.Output()
if err != nil {
log.Fatalf("Error running git rev-list in %s: %v", pkRoot, err)
}
v := strings.TrimSpace(string(out))
if m := gitVersionRx.FindStringSubmatch(v); m != nil {
v = m[0]
} else {
panic("Failed to find git version in " + v)
}
cmd = exec.Command("git", "diff", "--exit-code")
cmd.Dir = pkRoot
if err := cmd.Run(); err != nil {
v += "+"
}
return v
}
|
[
"func",
"getGitVersion",
"(",
")",
"string",
"{",
"if",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"\"",
"\"",
")",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"pkRoot",
"\n",
"out",
",",
"err",
":=",
"cmd",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"pkRoot",
",",
"err",
")",
"\n",
"}",
"\n",
"v",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"out",
")",
")",
"\n",
"if",
"m",
":=",
"gitVersionRx",
".",
"FindStringSubmatch",
"(",
"v",
")",
";",
"m",
"!=",
"nil",
"{",
"v",
"=",
"m",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"v",
")",
"\n",
"}",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"pkRoot",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"v",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] |
// 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",
"any",
"local",
"uncommitted",
"modifications",
"to",
"the",
"tree",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L782-L808
|
train
|
perkeep/perkeep
|
make.go
|
verifyPerkeepRoot
|
func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory (where make.go is). Current working directory is %s", pkRoot)
}
// we can't rely on perkeep.org/cmd/pk with modules on as we have no assurance
// the current dir is $GOPATH/src/perkeep.org, so we use ./cmd/pk instead.
cmd := exec.Command("go", "list", "-f", "{{.Target}}", "./cmd/pk")
if os.Getenv("GO111MODULE") == "off" || *buildWebUI {
// if we're building the webUI we need to be in "legacy" GOPATH mode, so in
// $GOPATH/src/perkeep.org
if err := validateDirInGOPATH(pkRoot); err != nil {
log.Fatalf("We're running in GO111MODULE=off mode, either because you set it, or because you want to build the Web UI, so we need to be in a GOPATH, but: %v", err)
}
cmd = exec.Command("go", "list", "-f", "{{.Target}}", "perkeep.org/cmd/pk")
}
cmd.Stderr = os.Stderr
out, err := cmd.Output()
if err != nil {
log.Fatalf("Could not run go list to find install dir: %v, %s", err, out)
}
binDir = filepath.Dir(strings.TrimSpace(string(out)))
}
|
go
|
func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory (where make.go is). Current working directory is %s", pkRoot)
}
// we can't rely on perkeep.org/cmd/pk with modules on as we have no assurance
// the current dir is $GOPATH/src/perkeep.org, so we use ./cmd/pk instead.
cmd := exec.Command("go", "list", "-f", "{{.Target}}", "./cmd/pk")
if os.Getenv("GO111MODULE") == "off" || *buildWebUI {
// if we're building the webUI we need to be in "legacy" GOPATH mode, so in
// $GOPATH/src/perkeep.org
if err := validateDirInGOPATH(pkRoot); err != nil {
log.Fatalf("We're running in GO111MODULE=off mode, either because you set it, or because you want to build the Web UI, so we need to be in a GOPATH, but: %v", err)
}
cmd = exec.Command("go", "list", "-f", "{{.Target}}", "perkeep.org/cmd/pk")
}
cmd.Stderr = os.Stderr
out, err := cmd.Output()
if err != nil {
log.Fatalf("Could not run go list to find install dir: %v, %s", err, out)
}
binDir = filepath.Dir(strings.TrimSpace(string(out)))
}
|
[
"func",
"verifyPerkeepRoot",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"pkRoot",
",",
"err",
"=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"testFile",
":=",
"filepath",
".",
"Join",
"(",
"pkRoot",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"testFile",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"pkRoot",
")",
"\n",
"}",
"\n\n",
"// we can't rely on perkeep.org/cmd/pk with modules on as we have no assurance",
"// the current dir is $GOPATH/src/perkeep.org, so we use ./cmd/pk instead.",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"==",
"\"",
"\"",
"||",
"*",
"buildWebUI",
"{",
"// if we're building the webUI we need to be in \"legacy\" GOPATH mode, so in",
"// $GOPATH/src/perkeep.org",
"if",
"err",
":=",
"validateDirInGOPATH",
"(",
"pkRoot",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"cmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"out",
",",
"err",
":=",
"cmd",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
",",
"out",
")",
"\n",
"}",
"\n",
"binDir",
"=",
"filepath",
".",
"Dir",
"(",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"out",
")",
")",
")",
"\n",
"}"
] |
// verifyPerkeepRoot sets pkRoot and crashes if dir isn't the Perkeep root directory.
|
[
"verifyPerkeepRoot",
"sets",
"pkRoot",
"and",
"crashes",
"if",
"dir",
"isn",
"t",
"the",
"Perkeep",
"root",
"directory",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L811-L839
|
train
|
perkeep/perkeep
|
make.go
|
verifyGoVersion
|
func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' command: %v", err)
}
version := string(out)
// Handle non-versioned binaries
// ex: "go version devel +c26fac8 Thu Feb 15 21:41:39 2018 +0000 linux/amd64"
if strings.HasPrefix(version, "go version devel ") {
verifyGopherjsGoroot(" devel")
return
}
m := validVersionRx.FindStringSubmatch(version)
if m == nil {
log.Fatalf("Unexpected output while checking 'go version': %q", version)
}
minorVersion, err := strconv.Atoi(m[1])
if err != nil {
log.Fatalf("Unexpected error while parsing version string %q: %v", m[1], err)
}
if minorVersion < goVersionMinor {
log.Fatalf("Your version of Go (%s) is too old. Perkeep requires Go 1.%d or later.", string(out), goVersionMinor)
}
if *website || *camnetdns {
return
}
if minorVersion != gopherJSGoMinor {
verifyGopherjsGoroot(fmt.Sprintf("1.%d", minorVersion))
}
}
|
go
|
func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' command: %v", err)
}
version := string(out)
// Handle non-versioned binaries
// ex: "go version devel +c26fac8 Thu Feb 15 21:41:39 2018 +0000 linux/amd64"
if strings.HasPrefix(version, "go version devel ") {
verifyGopherjsGoroot(" devel")
return
}
m := validVersionRx.FindStringSubmatch(version)
if m == nil {
log.Fatalf("Unexpected output while checking 'go version': %q", version)
}
minorVersion, err := strconv.Atoi(m[1])
if err != nil {
log.Fatalf("Unexpected error while parsing version string %q: %v", m[1], err)
}
if minorVersion < goVersionMinor {
log.Fatalf("Your version of Go (%s) is too old. Perkeep requires Go 1.%d or later.", string(out), goVersionMinor)
}
if *website || *camnetdns {
return
}
if minorVersion != gopherJSGoMinor {
verifyGopherjsGoroot(fmt.Sprintf("1.%d", minorVersion))
}
}
|
[
"func",
"verifyGoVersion",
"(",
")",
"{",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"goVersionMinor",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"version",
":=",
"string",
"(",
"out",
")",
"\n\n",
"// Handle non-versioned binaries",
"// ex: \"go version devel +c26fac8 Thu Feb 15 21:41:39 2018 +0000 linux/amd64\"",
"if",
"strings",
".",
"HasPrefix",
"(",
"version",
",",
"\"",
"\"",
")",
"{",
"verifyGopherjsGoroot",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"m",
":=",
"validVersionRx",
".",
"FindStringSubmatch",
"(",
"version",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n",
"minorVersion",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"m",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"m",
"[",
"1",
"]",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"minorVersion",
"<",
"goVersionMinor",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"string",
"(",
"out",
")",
",",
"goVersionMinor",
")",
"\n",
"}",
"\n\n",
"if",
"*",
"website",
"||",
"*",
"camnetdns",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"minorVersion",
"!=",
"gopherJSGoMinor",
"{",
"verifyGopherjsGoroot",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"minorVersion",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
"logged",
"and",
"we",
"abort",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/make.go#L888-L927
|
train
|
perkeep/perkeep
|
make.go
|
quote
|
func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.WriteByte(b)
continue
}
fmt.Fprintf(dest, "\\x%02x", b)
}
dest.WriteByte('"')
}
|
go
|
func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.WriteByte(b)
continue
}
fmt.Fprintf(dest, "\\x%02x", b)
}
dest.WriteByte('"')
}
|
[
"func",
"quote",
"(",
"dest",
"*",
"bytes",
".",
"Buffer",
",",
"bs",
"[",
"]",
"byte",
")",
"{",
"dest",
".",
"WriteByte",
"(",
"'\"'",
")",
"\n",
"for",
"_",
",",
"b",
":=",
"range",
"bs",
"{",
"if",
"b",
"==",
"'\\n'",
"{",
"dest",
".",
"WriteString",
"(",
"`\\n`",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"b",
"==",
"'\\\\'",
"{",
"dest",
".",
"WriteString",
"(",
"`\\\\`",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"b",
"==",
"'\"'",
"{",
"dest",
".",
"WriteString",
"(",
"`\\\"`",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"(",
"b",
">=",
"32",
"&&",
"b",
"<=",
"126",
")",
"||",
"b",
"==",
"'\\t'",
"{",
"dest",
".",
"WriteByte",
"(",
"b",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"dest",
",",
"\"",
"\\\\",
"\"",
",",
"b",
")",
"\n",
"}",
"\n",
"dest",
".",
"WriteByte",
"(",
"'\"'",
")",
"\n",
"}"
] |
// 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",
"blob",
".",
"SizedRef",
"{",
"}",
",",
"blobserver",
".",
"ErrReadonly",
"\n",
"}"
] |
// ReceiveBlob would receive the blobs, but now just returns ErrReadonly.
|
[
"ReceiveBlob",
"would",
"receive",
"the",
"blobs",
"but",
"now",
"just",
"returns",
"ErrReadonly",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L56-L58
|
train
|
perkeep/perkeep
|
pkg/blobserver/union/union.go
|
RemoveBlobs
|
func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
}
|
go
|
func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
}
|
[
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"return",
"blobserver",
".",
"ErrReadonly",
"\n",
"}"
] |
// RemoveBlobs would remove the given blobs, but now just returns ErrReadonly.
|
[
"RemoveBlobs",
"would",
"remove",
"the",
"given",
"blobs",
"but",
"now",
"just",
"returns",
"ErrReadonly",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L61-L63
|
train
|
perkeep/perkeep
|
pkg/blobserver/union/union.go
|
Fetch
|
func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go func() {
defer wg.Done()
var res result
res.file, res.size, res.err = bs.Fetch(ctx, b)
results <- res
}()
}
go func() {
wg.Wait()
close(results)
}()
var firstErr error
var firstRes result
for r := range results {
if r.err != nil {
if firstErr == nil {
firstErr = r.err
}
continue
}
if firstRes.file != nil {
if r.file != nil {
r.file.Close() // don't need, we already have a successful Fetch
}
continue
}
firstRes = r
}
if firstRes.file != nil {
return firstRes.file, firstRes.size, nil
}
return nil, 0, firstErr
}
|
go
|
func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go func() {
defer wg.Done()
var res result
res.file, res.size, res.err = bs.Fetch(ctx, b)
results <- res
}()
}
go func() {
wg.Wait()
close(results)
}()
var firstErr error
var firstRes result
for r := range results {
if r.err != nil {
if firstErr == nil {
firstErr = r.err
}
continue
}
if firstRes.file != nil {
if r.file != nil {
r.file.Close() // don't need, we already have a successful Fetch
}
continue
}
firstRes = r
}
if firstRes.file != nil {
return firstRes.file, firstRes.size, nil
}
return nil, 0, firstErr
}
|
[
"func",
"(",
"sto",
"*",
"unionStorage",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"(",
"file",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"type",
"result",
"struct",
"{",
"file",
"io",
".",
"ReadCloser",
"\n",
"size",
"uint32",
"\n",
"err",
"error",
"\n",
"}",
"\n",
"results",
":=",
"make",
"(",
"chan",
"result",
",",
"len",
"(",
"sto",
".",
"subsets",
")",
")",
"\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"for",
"_",
",",
"bs",
":=",
"range",
"sto",
".",
"subsets",
"{",
"bs",
":=",
"bs",
"\n",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n",
"var",
"res",
"result",
"\n",
"res",
".",
"file",
",",
"res",
".",
"size",
",",
"res",
".",
"err",
"=",
"bs",
".",
"Fetch",
"(",
"ctx",
",",
"b",
")",
"\n",
"results",
"<-",
"res",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"wg",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"results",
")",
"\n",
"}",
"(",
")",
"\n",
"var",
"firstErr",
"error",
"\n",
"var",
"firstRes",
"result",
"\n",
"for",
"r",
":=",
"range",
"results",
"{",
"if",
"r",
".",
"err",
"!=",
"nil",
"{",
"if",
"firstErr",
"==",
"nil",
"{",
"firstErr",
"=",
"r",
".",
"err",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"firstRes",
".",
"file",
"!=",
"nil",
"{",
"if",
"r",
".",
"file",
"!=",
"nil",
"{",
"r",
".",
"file",
".",
"Close",
"(",
")",
"// don't need, we already have a successful Fetch",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n\n",
"firstRes",
"=",
"r",
"\n",
"}",
"\n",
"if",
"firstRes",
".",
"file",
"!=",
"nil",
"{",
"return",
"firstRes",
".",
"file",
",",
"firstRes",
".",
"size",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"0",
",",
"firstErr",
"\n",
"}"
] |
// 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",
".",
"MergedEnumerateStorage",
"(",
"ctx",
",",
"dest",
",",
"sto",
".",
"subsets",
",",
"after",
",",
"limit",
")",
"\n",
"}"
] |
// EnumerateBlobs concurrently on the readers, returning one of the errors.
|
[
"EnumerateBlobs",
"concurrently",
"on",
"the",
"readers",
"returning",
"one",
"of",
"the",
"errors",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/union/union.go#L171-L173
|
train
|
perkeep/perkeep
|
server/camnetdns/camnetdns.go
|
Set
|
func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("error checking if record exists for %q from datastore: %v", key, err)
}
// record does not exist, write it.
return cs.put(ctx, key, value)
}
// record already exists
if oldValue.Record != value {
// new record is different, overwrite old one.
return cs.put(ctx, key, value)
}
// record is the same as before
if oldValue.Updated.Add(staleRecord).After(time.Now()) {
// record is still fresh, nothing to do.
return nil
}
// record is older than 30 days, so we rewrite it, for analytics.
return cs.put(ctx, key, value)
}
|
go
|
func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("error checking if record exists for %q from datastore: %v", key, err)
}
// record does not exist, write it.
return cs.put(ctx, key, value)
}
// record already exists
if oldValue.Record != value {
// new record is different, overwrite old one.
return cs.put(ctx, key, value)
}
// record is the same as before
if oldValue.Updated.Add(staleRecord).After(time.Now()) {
// record is still fresh, nothing to do.
return nil
}
// record is older than 30 days, so we rewrite it, for analytics.
return cs.put(ctx, key, value)
}
|
[
"func",
"(",
"cs",
"cachedStore",
")",
"Set",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"// check if record already exists",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"dk",
":=",
"datastore",
".",
"NewKey",
"(",
"ctx",
",",
"\"",
"\"",
",",
"key",
",",
"0",
",",
"nil",
")",
"\n",
"var",
"oldValue",
"dsValue",
"\n",
"if",
"err",
":=",
"cs",
".",
"dsClient",
".",
"Get",
"(",
"ctx",
",",
"dk",
",",
"&",
"oldValue",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"datastore",
".",
"ErrNoSuchEntity",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
",",
"err",
")",
"\n",
"}",
"\n",
"// record does not exist, write it.",
"return",
"cs",
".",
"put",
"(",
"ctx",
",",
"key",
",",
"value",
")",
"\n",
"}",
"\n",
"// record already exists",
"if",
"oldValue",
".",
"Record",
"!=",
"value",
"{",
"// new record is different, overwrite old one.",
"return",
"cs",
".",
"put",
"(",
"ctx",
",",
"key",
",",
"value",
")",
"\n",
"}",
"\n",
"// record is the same as before",
"if",
"oldValue",
".",
"Updated",
".",
"Add",
"(",
"staleRecord",
")",
".",
"After",
"(",
"time",
".",
"Now",
"(",
")",
")",
"{",
"// record is still fresh, nothing to do.",
"return",
"nil",
"\n",
"}",
"\n",
"// record is older than 30 days, so we rewrite it, for analytics.",
"return",
"cs",
".",
"put",
"(",
"ctx",
",",
"key",
",",
"value",
")",
"\n",
"}"
] |
// Set writes the key, value pair to cs. But it does not actually write if the
// value already exists, is up to date, and is more recent than 30 days.
|
[
"Set",
"writes",
"the",
"key",
"value",
"pair",
"to",
"cs",
".",
"But",
"it",
"does",
"not",
"actually",
"write",
"if",
"the",
"value",
"already",
"exists",
"is",
"up",
"to",
"date",
"and",
"is",
"more",
"recent",
"than",
"30",
"days",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/camnetdns/camnetdns.go#L159-L183
|
train
|
perkeep/perkeep
|
pkg/blobserver/s3/s3.go
|
newFromConfigWithTransport
|
func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.NewConfig().WithCredentials(credentials.NewStaticCredentials(
config.RequiredString("aws_access_key"),
config.RequiredString("aws_secret_access_key"),
"",
))
if hostname != "" {
s3Cfg.WithEndpoint(hostname)
}
s3Cfg.WithRegion(region)
if transport != nil {
httpClient := *http.DefaultClient
httpClient.Transport = transport
s3Cfg.WithHTTPClient(&httpClient)
}
awsSession := session.New(s3Cfg)
bucket := config.RequiredString("bucket")
var dirPrefix string
if parts := strings.SplitN(bucket, "/", 2); len(parts) > 1 {
dirPrefix = parts[1]
bucket = parts[0]
}
if dirPrefix != "" && !strings.HasSuffix(dirPrefix, "/") {
dirPrefix += "/"
}
skipStartupCheck := config.OptionalBool("skipStartupCheck", false)
if err := config.Validate(); err != nil {
return nil, err
}
ctx := context.TODO() // TODO: 5 min timeout or something?
if !skipStartupCheck {
info, err := normalizeBucketLocation(ctx, awsSession, hostname, bucket)
if err != nil {
return nil, err
}
awsSession.Config.WithRegion(info.region)
awsSession.Config.WithEndpoint(info.endpoint)
if !info.isAWS {
awsSession.Config.WithS3ForcePathStyle(true)
}
} else {
// safer default if we can't determine more info
awsSession.Config.WithS3ForcePathStyle(true)
}
sto := &s3Storage{
client: s3.New(awsSession),
bucket: bucket,
dirPrefix: dirPrefix,
hostname: hostname,
}
if cacheSize != 0 {
// This has two layers of LRU caching (proxycache and memory).
// We make the outer one 4x the size so that it doesn't evict from the
// underlying one when it's about to perform its own eviction.
return proxycache.New(cacheSize<<2, memory.NewCache(cacheSize), sto), nil
}
return sto, nil
}
|
go
|
func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.NewConfig().WithCredentials(credentials.NewStaticCredentials(
config.RequiredString("aws_access_key"),
config.RequiredString("aws_secret_access_key"),
"",
))
if hostname != "" {
s3Cfg.WithEndpoint(hostname)
}
s3Cfg.WithRegion(region)
if transport != nil {
httpClient := *http.DefaultClient
httpClient.Transport = transport
s3Cfg.WithHTTPClient(&httpClient)
}
awsSession := session.New(s3Cfg)
bucket := config.RequiredString("bucket")
var dirPrefix string
if parts := strings.SplitN(bucket, "/", 2); len(parts) > 1 {
dirPrefix = parts[1]
bucket = parts[0]
}
if dirPrefix != "" && !strings.HasSuffix(dirPrefix, "/") {
dirPrefix += "/"
}
skipStartupCheck := config.OptionalBool("skipStartupCheck", false)
if err := config.Validate(); err != nil {
return nil, err
}
ctx := context.TODO() // TODO: 5 min timeout or something?
if !skipStartupCheck {
info, err := normalizeBucketLocation(ctx, awsSession, hostname, bucket)
if err != nil {
return nil, err
}
awsSession.Config.WithRegion(info.region)
awsSession.Config.WithEndpoint(info.endpoint)
if !info.isAWS {
awsSession.Config.WithS3ForcePathStyle(true)
}
} else {
// safer default if we can't determine more info
awsSession.Config.WithS3ForcePathStyle(true)
}
sto := &s3Storage{
client: s3.New(awsSession),
bucket: bucket,
dirPrefix: dirPrefix,
hostname: hostname,
}
if cacheSize != 0 {
// This has two layers of LRU caching (proxycache and memory).
// We make the outer one 4x the size so that it doesn't evict from the
// underlying one when it's about to perform its own eviction.
return proxycache.New(cacheSize<<2, memory.NewCache(cacheSize), sto), nil
}
return sto, nil
}
|
[
"func",
"newFromConfigWithTransport",
"(",
"_",
"blobserver",
".",
"Loader",
",",
"config",
"jsonconfig",
".",
"Obj",
",",
"transport",
"http",
".",
"RoundTripper",
")",
"(",
"blobserver",
".",
"Storage",
",",
"error",
")",
"{",
"hostname",
":=",
"config",
".",
"OptionalString",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"region",
":=",
"config",
".",
"OptionalString",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"cacheSize",
":=",
"config",
".",
"OptionalInt64",
"(",
"\"",
"\"",
",",
"32",
"<<",
"20",
")",
"\n",
"s3Cfg",
":=",
"aws",
".",
"NewConfig",
"(",
")",
".",
"WithCredentials",
"(",
"credentials",
".",
"NewStaticCredentials",
"(",
"config",
".",
"RequiredString",
"(",
"\"",
"\"",
")",
",",
"config",
".",
"RequiredString",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
")",
")",
"\n",
"if",
"hostname",
"!=",
"\"",
"\"",
"{",
"s3Cfg",
".",
"WithEndpoint",
"(",
"hostname",
")",
"\n",
"}",
"\n",
"s3Cfg",
".",
"WithRegion",
"(",
"region",
")",
"\n",
"if",
"transport",
"!=",
"nil",
"{",
"httpClient",
":=",
"*",
"http",
".",
"DefaultClient",
"\n",
"httpClient",
".",
"Transport",
"=",
"transport",
"\n",
"s3Cfg",
".",
"WithHTTPClient",
"(",
"&",
"httpClient",
")",
"\n",
"}",
"\n",
"awsSession",
":=",
"session",
".",
"New",
"(",
"s3Cfg",
")",
"\n\n",
"bucket",
":=",
"config",
".",
"RequiredString",
"(",
"\"",
"\"",
")",
"\n",
"var",
"dirPrefix",
"string",
"\n",
"if",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"bucket",
",",
"\"",
"\"",
",",
"2",
")",
";",
"len",
"(",
"parts",
")",
">",
"1",
"{",
"dirPrefix",
"=",
"parts",
"[",
"1",
"]",
"\n",
"bucket",
"=",
"parts",
"[",
"0",
"]",
"\n",
"}",
"\n",
"if",
"dirPrefix",
"!=",
"\"",
"\"",
"&&",
"!",
"strings",
".",
"HasSuffix",
"(",
"dirPrefix",
",",
"\"",
"\"",
")",
"{",
"dirPrefix",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"skipStartupCheck",
":=",
"config",
".",
"OptionalBool",
"(",
"\"",
"\"",
",",
"false",
")",
"\n",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"// TODO: 5 min timeout or something?",
"\n",
"if",
"!",
"skipStartupCheck",
"{",
"info",
",",
"err",
":=",
"normalizeBucketLocation",
"(",
"ctx",
",",
"awsSession",
",",
"hostname",
",",
"bucket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"awsSession",
".",
"Config",
".",
"WithRegion",
"(",
"info",
".",
"region",
")",
"\n",
"awsSession",
".",
"Config",
".",
"WithEndpoint",
"(",
"info",
".",
"endpoint",
")",
"\n",
"if",
"!",
"info",
".",
"isAWS",
"{",
"awsSession",
".",
"Config",
".",
"WithS3ForcePathStyle",
"(",
"true",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// safer default if we can't determine more info",
"awsSession",
".",
"Config",
".",
"WithS3ForcePathStyle",
"(",
"true",
")",
"\n",
"}",
"\n\n",
"sto",
":=",
"&",
"s3Storage",
"{",
"client",
":",
"s3",
".",
"New",
"(",
"awsSession",
")",
",",
"bucket",
":",
"bucket",
",",
"dirPrefix",
":",
"dirPrefix",
",",
"hostname",
":",
"hostname",
",",
"}",
"\n\n",
"if",
"cacheSize",
"!=",
"0",
"{",
"// This has two layers of LRU caching (proxycache and memory).",
"// We make the outer one 4x the size so that it doesn't evict from the",
"// underlying one when it's about to perform its own eviction.",
"return",
"proxycache",
".",
"New",
"(",
"cacheSize",
"<<",
"2",
",",
"memory",
".",
"NewCache",
"(",
"cacheSize",
")",
",",
"sto",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"sto",
",",
"nil",
"\n",
"}"
] |
// 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",
"used",
"for",
"unit",
"tests",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/s3/s3.go#L103-L169
|
train
|
perkeep/perkeep
|
pkg/blobserver/s3/s3.go
|
isNotFound
|
func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrCodeNotFound' for comparison)
aerr.Code() == "NotFound"
}
return false
}
|
go
|
func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrCodeNotFound' for comparison)
aerr.Code() == "NotFound"
}
return false
}
|
[
"func",
"isNotFound",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"aerr",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"return",
"aerr",
".",
"Code",
"(",
")",
"==",
"s3",
".",
"ErrCodeNoSuchKey",
"||",
"// Check 'NotFound' as well because it's returned for some requests, even",
"// though the API model doesn't include it (hence why there isn't an",
"// 's3.ErrCodeNotFound' for comparison)",
"aerr",
".",
"Code",
"(",
")",
"==",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// isNotFound checks for s3 errors which indicate the object doesn't exist.
|
[
"isNotFound",
"checks",
"for",
"s3",
"errors",
"which",
"indicate",
"the",
"object",
"doesn",
"t",
"exist",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/s3/s3.go#L176-L188
|
train
|
perkeep/perkeep
|
pkg/server/share.go
|
bytesHaveSchemaLink
|
func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, bp := range b.ByteParts() {
if bp.BlobRef.Valid() {
if bp.BlobRef == target {
return true
}
}
if bp.BytesRef.Valid() {
if bp.BytesRef == target {
return true
}
}
}
case "directory":
if d, ok := b.DirectoryEntries(); ok {
return d == target
}
case "static-set":
for _, m := range b.StaticSetMembers() {
if m == target {
return true
}
}
}
return false
}
|
go
|
func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, bp := range b.ByteParts() {
if bp.BlobRef.Valid() {
if bp.BlobRef == target {
return true
}
}
if bp.BytesRef.Valid() {
if bp.BytesRef == target {
return true
}
}
}
case "directory":
if d, ok := b.DirectoryEntries(); ok {
return d == target
}
case "static-set":
for _, m := range b.StaticSetMembers() {
if m == target {
return true
}
}
}
return false
}
|
[
"func",
"bytesHaveSchemaLink",
"(",
"br",
"blob",
".",
"Ref",
",",
"bb",
"[",
"]",
"byte",
",",
"target",
"blob",
".",
"Ref",
")",
"bool",
"{",
"// Fast path for no:",
"if",
"!",
"bytes",
".",
"Contains",
"(",
"bb",
",",
"[",
"]",
"byte",
"(",
"target",
".",
"String",
"(",
")",
")",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"b",
",",
"err",
":=",
"schema",
".",
"BlobFromReader",
"(",
"br",
",",
"bytes",
".",
"NewReader",
"(",
"bb",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"typ",
":=",
"b",
".",
"Type",
"(",
")",
"\n",
"switch",
"typ",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"for",
"_",
",",
"bp",
":=",
"range",
"b",
".",
"ByteParts",
"(",
")",
"{",
"if",
"bp",
".",
"BlobRef",
".",
"Valid",
"(",
")",
"{",
"if",
"bp",
".",
"BlobRef",
"==",
"target",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"bp",
".",
"BytesRef",
".",
"Valid",
"(",
")",
"{",
"if",
"bp",
".",
"BytesRef",
"==",
"target",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"d",
",",
"ok",
":=",
"b",
".",
"DirectoryEntries",
"(",
")",
";",
"ok",
"{",
"return",
"d",
"==",
"target",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"for",
"_",
",",
"m",
":=",
"range",
"b",
".",
"StaticSetMembers",
"(",
")",
"{",
"if",
"m",
"==",
"target",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// bytesHaveSchemaLink reports whether bb is a valid Perkeep schema
// blob and has target somewhere in a schema field used to represent a
// Merkle-tree-ish file or directory.
|
[
"bytesHaveSchemaLink",
"reports",
"whether",
"bb",
"is",
"a",
"valid",
"Perkeep",
"schema",
"blob",
"and",
"has",
"target",
"somewhere",
"in",
"a",
"schema",
"field",
"used",
"to",
"represent",
"a",
"Merkle",
"-",
"tree",
"-",
"ish",
"file",
"or",
"directory",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/share.go#L316-L352
|
train
|
perkeep/perkeep
|
pkg/blobserver/diskpacked/reindex.go
|
Reindex
|
func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the first error - if the index or disk is corrupt
// and can't close, it's very likely these two errors are related and
// have the same root cause.
if err == nil {
err = closeErr
}
}()
ctx := context.TODO() // TODO(tgulacsi): get the verbosity from context
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
err = s.reindexOne(ctx, index, overwrite, i)
fh.Close()
if err != nil {
return err
}
}
return nil
}
|
go
|
func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the first error - if the index or disk is corrupt
// and can't close, it's very likely these two errors are related and
// have the same root cause.
if err == nil {
err = closeErr
}
}()
ctx := context.TODO() // TODO(tgulacsi): get the verbosity from context
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
err = s.reindexOne(ctx, index, overwrite, i)
fh.Close()
if err != nil {
return err
}
}
return nil
}
|
[
"func",
"Reindex",
"(",
"root",
"string",
",",
"overwrite",
"bool",
",",
"indexConf",
"jsonconfig",
".",
"Obj",
")",
"(",
"err",
"error",
")",
"{",
"// there is newStorage, but that may open a file for writing",
"var",
"s",
"=",
"&",
"storage",
"{",
"root",
":",
"root",
"}",
"\n",
"index",
",",
"err",
":=",
"newIndex",
"(",
"root",
",",
"indexConf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"closeErr",
":=",
"index",
".",
"Close",
"(",
")",
"\n",
"// just returning the first error - if the index or disk is corrupt",
"// and can't close, it's very likely these two errors are related and",
"// have the same root cause.",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"closeErr",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"ctx",
":=",
"context",
".",
"TODO",
"(",
")",
"// TODO(tgulacsi): get the verbosity from context",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
">=",
"0",
";",
"i",
"++",
"{",
"fh",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"s",
".",
"filename",
"(",
"i",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"break",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"reindexOne",
"(",
"ctx",
",",
"index",
",",
"overwrite",
",",
"i",
")",
"\n",
"fh",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Reindex rewrites the index files of the diskpacked .pack files
|
[
"Reindex",
"rewrites",
"the",
"index",
"files",
"of",
"the",
"diskpacked",
".",
"pack",
"files"
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/reindex.go#L42-L75
|
train
|
perkeep/perkeep
|
pkg/blobserver/diskpacked/reindex.go
|
Walk
|
func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
fh.Close()
if err = s.walkPack(verbose, i, walker); err != nil {
return err
}
}
return nil
}
|
go
|
func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
break
}
return err
}
fh.Close()
if err = s.walkPack(verbose, i, walker); err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"storage",
")",
"Walk",
"(",
"ctx",
"context",
".",
"Context",
",",
"walker",
"func",
"(",
"packID",
"int",
",",
"ref",
"blob",
".",
"Ref",
",",
"offset",
"int64",
",",
"size",
"uint32",
")",
"error",
")",
"error",
"{",
"// TODO(tgulacsi): proper verbose flag from context",
"verbose",
":=",
"env",
".",
"IsDebug",
"(",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
">=",
"0",
";",
"i",
"++",
"{",
"fh",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"s",
".",
"filename",
"(",
"i",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"break",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"fh",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"=",
"s",
".",
"walkPack",
"(",
"verbose",
",",
"i",
",",
"walker",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
",",
"plainSize",
",",
"encBR",
")",
"\n",
"return",
"s",
".",
"encryptBlob",
"(",
"nil",
",",
"[",
"]",
"byte",
"(",
"plain",
")",
")",
"\n",
"}"
] |
// makeSingleMetaBlob makes and encrypts a metaBlob with one entry.
|
[
"makeSingleMetaBlob",
"makes",
"and",
"encrypts",
"a",
"metaBlob",
"with",
"one",
"entry",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/meta.go#L148-L151
|
train
|
perkeep/perkeep
|
pkg/blobserver/encrypt/meta.go
|
fetchMeta
|
func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
}
|
go
|
func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
}
|
[
"func",
"(",
"s",
"*",
"storage",
")",
"fetchMeta",
"(",
"ctx",
"context",
".",
"Context",
",",
"b",
"blob",
".",
"Ref",
")",
"(",
"plainSize",
"uint32",
",",
"encBR",
"blob",
".",
"Ref",
",",
"err",
"error",
")",
"{",
"v",
",",
"err",
":=",
"s",
".",
"index",
".",
"Get",
"(",
"b",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"sorted",
".",
"ErrNotFound",
"{",
"err",
"=",
"os",
".",
"ErrNotExist",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"blob",
".",
"Ref",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"unpackIndexEntry",
"(",
"v",
")",
"\n",
"}"
] |
// 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",
"(",
"done",
")",
"{",
"c",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"c",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"addr",
",",
"maxWait",
")",
"\n",
"}"
] |
// 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",
".",
"ListenTCP",
"(",
"\"",
"\"",
",",
"&",
"net",
".",
"TCPAddr",
"{",
"IP",
":",
"ip",
",",
"Port",
":",
"0",
"}",
")",
"\n",
"}"
] |
// 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",
"(",
")",
";",
"ip",
"!=",
"nil",
"{",
"return",
"ip",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// 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",
"}",
"\n",
"return",
"nil",
"\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.ParseCIDR(addr.String())
if err == nil && ip.IsLoopback() {
return ip
}
}
}
}
return nil
}
|
go
|
func loopbackIP() net.IP {
interfaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, inf := range interfaces {
const flagUpLoopback = net.FlagUp | net.FlagLoopback
if inf.Flags&flagUpLoopback == flagUpLoopback {
addrs, _ := inf.Addrs()
for _, addr := range addrs {
ip, _, err := net.ParseCIDR(addr.String())
if err == nil && ip.IsLoopback() {
return ip
}
}
}
}
return nil
}
|
[
"func",
"loopbackIP",
"(",
")",
"net",
".",
"IP",
"{",
"interfaces",
",",
"err",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"inf",
":=",
"range",
"interfaces",
"{",
"const",
"flagUpLoopback",
"=",
"net",
".",
"FlagUp",
"|",
"net",
".",
"FlagLoopback",
"\n",
"if",
"inf",
".",
"Flags",
"&",
"flagUpLoopback",
"==",
"flagUpLoopback",
"{",
"addrs",
",",
"_",
":=",
"inf",
".",
"Addrs",
"(",
")",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"ip",
",",
"_",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"addr",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"ip",
".",
"IsLoopback",
"(",
")",
"{",
"return",
"ip",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// loopbackIP returns the first loopback IP address sniffing network
// interfaces or nil if none is found.
|
[
"loopbackIP",
"returns",
"the",
"first",
"loopback",
"IP",
"address",
"sniffing",
"network",
"interfaces",
"or",
"nil",
"if",
"none",
"is",
"found",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L123-L141
|
train
|
perkeep/perkeep
|
internal/netutil/netutil.go
|
RandPort
|
func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAddr)
if err := listener.Close(); err != nil {
return port, fmt.Errorf("could not close random listener: %v", err)
}
return randAddr.Port, nil
}
|
go
|
func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAddr)
if err := listener.Close(); err != nil {
return port, fmt.Errorf("could not close random listener: %v", err)
}
return randAddr.Port, nil
}
|
[
"func",
"RandPort",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"port",
"int",
"\n",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"port",
",",
"err",
"\n",
"}",
"\n",
"listener",
",",
"err",
":=",
"net",
".",
"ListenTCP",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"port",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"randAddr",
":=",
"listener",
".",
"Addr",
"(",
")",
".",
"(",
"*",
"net",
".",
"TCPAddr",
")",
"\n",
"if",
"err",
":=",
"listener",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"port",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"randAddr",
".",
"Port",
",",
"nil",
"\n",
"}"
] |
// 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",
",",
"\"",
"\"",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"domain",
",",
"\"",
"\"",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"net",
".",
"ParseIP",
"(",
"domain",
")",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// IsFQDN reports whether domain looks like a fully qualified domain name.
|
[
"IsFQDN",
"reports",
"whether",
"domain",
"looks",
"like",
"a",
"fully",
"qualified",
"domain",
"name",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/netutil/netutil.go#L168-L183
|
train
|
perkeep/perkeep
|
server/perkeepd/ui/goui/geo/geo.go
|
IsLocMapPredicate
|
func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
}
|
go
|
func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
}
|
[
"func",
"IsLocMapPredicate",
"(",
"predicate",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"rectangleFromPredicate",
"(",
"predicate",
",",
"LocMapPredicatePrefix",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// IsLocMapPredicate returns whether predicate is a map location predicate.
|
[
"IsLocMapPredicate",
"returns",
"whether",
"predicate",
"is",
"a",
"map",
"location",
"predicate",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/geo/geo.go#L36-L41
|
train
|
perkeep/perkeep
|
server/perkeepd/ui/goui/geo/geo.go
|
rectangleFromPredicate
|
func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if len(coords) != 4 {
return nil, errNotARectangle
}
var coord [4]float64
for k, v := range coords {
f, err := strconv.ParseFloat(v, 64)
if err != nil {
return nil, errNotARectangle
}
coord[k] = f
}
return &camtypes.LocationBounds{
North: coord[0],
South: coord[2],
East: coord[3],
West: coord[1],
}, nil
}
|
go
|
func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if len(coords) != 4 {
return nil, errNotARectangle
}
var coord [4]float64
for k, v := range coords {
f, err := strconv.ParseFloat(v, 64)
if err != nil {
return nil, errNotARectangle
}
coord[k] = f
}
return &camtypes.LocationBounds{
North: coord[0],
South: coord[2],
East: coord[3],
West: coord[1],
}, nil
}
|
[
"func",
"rectangleFromPredicate",
"(",
"predicate",
",",
"kind",
"string",
")",
"(",
"*",
"camtypes",
".",
"LocationBounds",
",",
"error",
")",
"{",
"errNotARectangle",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"kind",
")",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"predicate",
",",
"kind",
"+",
"\"",
"\"",
")",
"{",
"return",
"nil",
",",
"errNotARectangle",
"\n",
"}",
"\n",
"loc",
":=",
"strings",
".",
"TrimPrefix",
"(",
"predicate",
",",
"kind",
"+",
"\"",
"\"",
")",
"\n",
"coords",
":=",
"strings",
".",
"Split",
"(",
"loc",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"coords",
")",
"!=",
"4",
"{",
"return",
"nil",
",",
"errNotARectangle",
"\n",
"}",
"\n",
"var",
"coord",
"[",
"4",
"]",
"float64",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"coords",
"{",
"f",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"v",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errNotARectangle",
"\n",
"}",
"\n",
"coord",
"[",
"k",
"]",
"=",
"f",
"\n",
"}",
"\n",
"return",
"&",
"camtypes",
".",
"LocationBounds",
"{",
"North",
":",
"coord",
"[",
"0",
"]",
",",
"South",
":",
"coord",
"[",
"2",
"]",
",",
"East",
":",
"coord",
"[",
"3",
"]",
",",
"West",
":",
"coord",
"[",
"1",
"]",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// 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",
"runtime",
".",
"SetFinalizer",
"(",
"ch",
",",
"(",
"*",
"Checker",
")",
".",
"finalize",
")",
"\n",
"return",
"ch",
"\n",
"}"
] |
// NewChecker returns a Checker, remembering the stack trace.
|
[
"NewChecker",
"returns",
"a",
"Checker",
"remembering",
"the",
"stack",
"trace",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/leak/leak.go#L32-L37
|
train
|
perkeep/perkeep
|
pkg/importer/feed/feed.go
|
autoDiscover
|
func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make(map[string]string)
for _, a := range t.Attr {
attrs[a.Key] = a.Val
}
if attrs["rel"] == "alternate" && attrs["href"] != "" &&
(attrs["type"] == "application/rss+xml" || attrs["type"] == "application/atom+xml") {
return attrs["href"], nil
}
}
}
}
return "", fmt.Errorf("No feed link found")
}
|
go
|
func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make(map[string]string)
for _, a := range t.Attr {
attrs[a.Key] = a.Val
}
if attrs["rel"] == "alternate" && attrs["href"] != "" &&
(attrs["type"] == "application/rss+xml" || attrs["type"] == "application/atom+xml") {
return attrs["href"], nil
}
}
}
}
return "", fmt.Errorf("No feed link found")
}
|
[
"func",
"autoDiscover",
"(",
"body",
"[",
"]",
"byte",
")",
"(",
"feedURL",
"string",
",",
"err",
"error",
")",
"{",
"r",
":=",
"bytes",
".",
"NewReader",
"(",
"body",
")",
"\n",
"z",
":=",
"html",
".",
"NewTokenizer",
"(",
"r",
")",
"\n",
"for",
"{",
"if",
"z",
".",
"Next",
"(",
")",
"==",
"html",
".",
"ErrorToken",
"{",
"break",
"\n",
"}",
"\n",
"t",
":=",
"z",
".",
"Token",
"(",
")",
"\n",
"switch",
"t",
".",
"DataAtom",
"{",
"case",
"atom",
".",
"Link",
":",
"if",
"t",
".",
"Type",
"==",
"html",
".",
"StartTagToken",
"||",
"t",
".",
"Type",
"==",
"html",
".",
"SelfClosingTagToken",
"{",
"attrs",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"t",
".",
"Attr",
"{",
"attrs",
"[",
"a",
".",
"Key",
"]",
"=",
"a",
".",
"Val",
"\n",
"}",
"\n",
"if",
"attrs",
"[",
"\"",
"\"",
"]",
"==",
"\"",
"\"",
"&&",
"attrs",
"[",
"\"",
"\"",
"]",
"!=",
"\"",
"\"",
"&&",
"(",
"attrs",
"[",
"\"",
"\"",
"]",
"==",
"\"",
"\"",
"||",
"attrs",
"[",
"\"",
"\"",
"]",
"==",
"\"",
"\"",
")",
"{",
"return",
"attrs",
"[",
"\"",
"\"",
"]",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// autodiscover takes an HTML document and returns the autodiscovered feed
// URL. Returns an error if there is no such URL.
|
[
"autodiscover",
"takes",
"an",
"HTML",
"document",
"and",
"returns",
"the",
"autodiscovered",
"feed",
"URL",
".",
"Returns",
"an",
"error",
"if",
"there",
"is",
"no",
"such",
"URL",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/feed/feed.go#L191-L214
|
train
|
perkeep/perkeep
|
pkg/importer/mastodon/mastodon.go
|
importStatuses
|
func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.Printf("mastodon: Beginning statuses import for %s", r.userAddress)
var pg mastodon.Pagination
for {
select {
case <-r.Context().Done():
return r.Context().Err()
default:
}
if pg.MaxID != "" {
log.Printf("mastodon: fetching batch for %s, from %s", r.userAddress, pg.MaxID)
} else {
log.Printf("mastodon: fetching batch for %s", r.userAddress)
}
batch, err := r.cl.GetAccountStatuses(r.Context(), userID, &pg)
if err != nil {
return err
}
if len(batch) == 0 {
log.Printf("mastodon: got empty batch, assuming end of statuses for %s", r.userAddress)
return nil
}
gate := syncutil.NewGate(importAtOnce)
var grp syncutil.Group
allReblogs := true
anyNew := false
var anyNewMu sync.Mutex
for i := range batch {
st := batch[i]
// If an entry is a reblog, we ignore it and move on. However, the
// whole batch being all reblogs does not mean there is nothing new
// on the next page. If everything on this page was a reblog, we
// move on to the next page regardless.
if st.Reblog != nil {
continue
}
allReblogs = false
gate.Start()
grp.Go(func() error {
defer gate.Done()
alreadyHad, err := r.importStatus(statusesNode, st)
if err != nil {
return fmt.Errorf("error importing status %s: %v", st.URI, err)
}
if !alreadyHad {
anyNewMu.Lock()
anyNew = true
anyNewMu.Unlock()
}
return nil
})
}
if err := grp.Err(); err != nil {
return err
}
if !anyNew && !allReblogs {
log.Printf("mastodon: reached the end for incremental import for %s", r.userAddress)
return nil
}
if pg.MaxID == "" {
log.Printf("mastodon: reached the end of statuses for %s", r.userAddress)
return nil
}
}
}
|
go
|
func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.Printf("mastodon: Beginning statuses import for %s", r.userAddress)
var pg mastodon.Pagination
for {
select {
case <-r.Context().Done():
return r.Context().Err()
default:
}
if pg.MaxID != "" {
log.Printf("mastodon: fetching batch for %s, from %s", r.userAddress, pg.MaxID)
} else {
log.Printf("mastodon: fetching batch for %s", r.userAddress)
}
batch, err := r.cl.GetAccountStatuses(r.Context(), userID, &pg)
if err != nil {
return err
}
if len(batch) == 0 {
log.Printf("mastodon: got empty batch, assuming end of statuses for %s", r.userAddress)
return nil
}
gate := syncutil.NewGate(importAtOnce)
var grp syncutil.Group
allReblogs := true
anyNew := false
var anyNewMu sync.Mutex
for i := range batch {
st := batch[i]
// If an entry is a reblog, we ignore it and move on. However, the
// whole batch being all reblogs does not mean there is nothing new
// on the next page. If everything on this page was a reblog, we
// move on to the next page regardless.
if st.Reblog != nil {
continue
}
allReblogs = false
gate.Start()
grp.Go(func() error {
defer gate.Done()
alreadyHad, err := r.importStatus(statusesNode, st)
if err != nil {
return fmt.Errorf("error importing status %s: %v", st.URI, err)
}
if !alreadyHad {
anyNewMu.Lock()
anyNew = true
anyNewMu.Unlock()
}
return nil
})
}
if err := grp.Err(); err != nil {
return err
}
if !anyNew && !allReblogs {
log.Printf("mastodon: reached the end for incremental import for %s", r.userAddress)
return nil
}
if pg.MaxID == "" {
log.Printf("mastodon: reached the end of statuses for %s", r.userAddress)
return nil
}
}
}
|
[
"func",
"(",
"r",
"*",
"run",
")",
"importStatuses",
"(",
"userID",
"mastodon",
".",
"ID",
")",
"error",
"{",
"statusesNode",
",",
"err",
":=",
"r",
".",
"RootNode",
"(",
")",
".",
"ChildPathObject",
"(",
"nodeStatuses",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"nodeTitle",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
")",
"\n",
"if",
"err",
":=",
"statusesNode",
".",
"SetAttr",
"(",
"nodeattr",
".",
"Title",
",",
"nodeTitle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
")",
"\n\n",
"var",
"pg",
"mastodon",
".",
"Pagination",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"r",
".",
"Context",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"r",
".",
"Context",
"(",
")",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"}",
"\n\n",
"if",
"pg",
".",
"MaxID",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
",",
"pg",
".",
"MaxID",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
")",
"\n",
"}",
"\n\n",
"batch",
",",
"err",
":=",
"r",
".",
"cl",
".",
"GetAccountStatuses",
"(",
"r",
".",
"Context",
"(",
")",
",",
"userID",
",",
"&",
"pg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"batch",
")",
"==",
"0",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"gate",
":=",
"syncutil",
".",
"NewGate",
"(",
"importAtOnce",
")",
"\n",
"var",
"grp",
"syncutil",
".",
"Group",
"\n",
"allReblogs",
":=",
"true",
"\n",
"anyNew",
":=",
"false",
"\n",
"var",
"anyNewMu",
"sync",
".",
"Mutex",
"\n\n",
"for",
"i",
":=",
"range",
"batch",
"{",
"st",
":=",
"batch",
"[",
"i",
"]",
"\n\n",
"// If an entry is a reblog, we ignore it and move on. However, the",
"// whole batch being all reblogs does not mean there is nothing new",
"// on the next page. If everything on this page was a reblog, we",
"// move on to the next page regardless.",
"if",
"st",
".",
"Reblog",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"allReblogs",
"=",
"false",
"\n\n",
"gate",
".",
"Start",
"(",
")",
"\n",
"grp",
".",
"Go",
"(",
"func",
"(",
")",
"error",
"{",
"defer",
"gate",
".",
"Done",
"(",
")",
"\n",
"alreadyHad",
",",
"err",
":=",
"r",
".",
"importStatus",
"(",
"statusesNode",
",",
"st",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"st",
".",
"URI",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"alreadyHad",
"{",
"anyNewMu",
".",
"Lock",
"(",
")",
"\n",
"anyNew",
"=",
"true",
"\n",
"anyNewMu",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n\n",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"grp",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"anyNew",
"&&",
"!",
"allReblogs",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"pg",
".",
"MaxID",
"==",
"\"",
"\"",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"r",
".",
"userAddress",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"}",
"\n",
"}"
] |
// importStatuses imports statuses for the given user into the store
|
[
"importStatuses",
"imports",
"statuses",
"for",
"the",
"given",
"user",
"into",
"the",
"store"
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L294-L385
|
train
|
perkeep/perkeep
|
pkg/importer/mastodon/mastodon.go
|
importStatus
|
func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode, err := listNode.ChildPathObject(st.URI)
if err != nil {
return false, err
}
if r.incremental && statusNode.Attr(attrURI) == st.URI {
return true, nil
}
attrs := []string{
nodeattr.Type, "mastodon:status",
attrURI, st.URI,
nodeattr.URL, st.URL,
nodeattr.Content, st.Content,
nodeattr.StartDate, schema.RFC3339FromTime(st.CreatedAt),
}
if st.SpoilerText != "" {
attrs = append(attrs, attrSpoilerText, st.SpoilerText)
}
filenames := make(map[string]int)
for i, att := range st.MediaAttachments {
// All media for a local user will be local
resp, err := ctxutil.Client(r.Context()).Get(att.URL)
if err != nil {
return false, err
}
if resp.StatusCode != http.StatusOK {
return false, fmt.Errorf("failed fetching attachment %s with HTTP status %s", att.URL, resp.Status)
}
fileRef, err := schema.WriteFileFromReader(r.Context(), r.Host.Target(), "", resp.Body)
resp.Body.Close()
if err != nil {
return false, err
}
filename := path.Base(att.URL)
filenames[filename]++
// A status can have several different attachments with the same
// filename. We add numbers to the path to diffirentiate them if that's
// the case
if filenames[filename] > 1 {
ext := path.Ext(filename)
filename = fmt.Sprintf("%s%d%s", strings.TrimSuffix(filename, ext), filenames[filename], ext)
}
attrs = append(attrs, fmt.Sprintf("camliPath:%v", filename), fileRef.String())
// The first image gets to be the preview image for the node
if i == 0 {
attrs = append(attrs, "camliContentImage", fileRef.String())
}
log.Printf("mastodon: adding attachment %s to permanode %s for status %s", fileRef.String(), statusNode.PermanodeRef(), st.URI)
}
changed, err := statusNode.SetAttrs2(attrs...)
if err == nil && changed {
log.Printf("mastodon: Imported status %s to %s", st.URI, statusNode.PermanodeRef())
}
return !changed, err
}
|
go
|
func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode, err := listNode.ChildPathObject(st.URI)
if err != nil {
return false, err
}
if r.incremental && statusNode.Attr(attrURI) == st.URI {
return true, nil
}
attrs := []string{
nodeattr.Type, "mastodon:status",
attrURI, st.URI,
nodeattr.URL, st.URL,
nodeattr.Content, st.Content,
nodeattr.StartDate, schema.RFC3339FromTime(st.CreatedAt),
}
if st.SpoilerText != "" {
attrs = append(attrs, attrSpoilerText, st.SpoilerText)
}
filenames := make(map[string]int)
for i, att := range st.MediaAttachments {
// All media for a local user will be local
resp, err := ctxutil.Client(r.Context()).Get(att.URL)
if err != nil {
return false, err
}
if resp.StatusCode != http.StatusOK {
return false, fmt.Errorf("failed fetching attachment %s with HTTP status %s", att.URL, resp.Status)
}
fileRef, err := schema.WriteFileFromReader(r.Context(), r.Host.Target(), "", resp.Body)
resp.Body.Close()
if err != nil {
return false, err
}
filename := path.Base(att.URL)
filenames[filename]++
// A status can have several different attachments with the same
// filename. We add numbers to the path to diffirentiate them if that's
// the case
if filenames[filename] > 1 {
ext := path.Ext(filename)
filename = fmt.Sprintf("%s%d%s", strings.TrimSuffix(filename, ext), filenames[filename], ext)
}
attrs = append(attrs, fmt.Sprintf("camliPath:%v", filename), fileRef.String())
// The first image gets to be the preview image for the node
if i == 0 {
attrs = append(attrs, "camliContentImage", fileRef.String())
}
log.Printf("mastodon: adding attachment %s to permanode %s for status %s", fileRef.String(), statusNode.PermanodeRef(), st.URI)
}
changed, err := statusNode.SetAttrs2(attrs...)
if err == nil && changed {
log.Printf("mastodon: Imported status %s to %s", st.URI, statusNode.PermanodeRef())
}
return !changed, err
}
|
[
"func",
"(",
"r",
"*",
"run",
")",
"importStatus",
"(",
"listNode",
"*",
"importer",
".",
"Object",
",",
"st",
"*",
"mastodon",
".",
"Status",
")",
"(",
"bool",
",",
"error",
")",
"{",
"select",
"{",
"case",
"<-",
"r",
".",
"Context",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"false",
",",
"r",
".",
"Context",
"(",
")",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"}",
"\n\n",
"// We store child nodes by their URI, since the URI is supposed to be an",
"// unchanging, globally unique identifier for the status",
"statusNode",
",",
"err",
":=",
"listNode",
".",
"ChildPathObject",
"(",
"st",
".",
"URI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"incremental",
"&&",
"statusNode",
".",
"Attr",
"(",
"attrURI",
")",
"==",
"st",
".",
"URI",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"attrs",
":=",
"[",
"]",
"string",
"{",
"nodeattr",
".",
"Type",
",",
"\"",
"\"",
",",
"attrURI",
",",
"st",
".",
"URI",
",",
"nodeattr",
".",
"URL",
",",
"st",
".",
"URL",
",",
"nodeattr",
".",
"Content",
",",
"st",
".",
"Content",
",",
"nodeattr",
".",
"StartDate",
",",
"schema",
".",
"RFC3339FromTime",
"(",
"st",
".",
"CreatedAt",
")",
",",
"}",
"\n\n",
"if",
"st",
".",
"SpoilerText",
"!=",
"\"",
"\"",
"{",
"attrs",
"=",
"append",
"(",
"attrs",
",",
"attrSpoilerText",
",",
"st",
".",
"SpoilerText",
")",
"\n",
"}",
"\n\n",
"filenames",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
"\n\n",
"for",
"i",
",",
"att",
":=",
"range",
"st",
".",
"MediaAttachments",
"{",
"// All media for a local user will be local",
"resp",
",",
"err",
":=",
"ctxutil",
".",
"Client",
"(",
"r",
".",
"Context",
"(",
")",
")",
".",
"Get",
"(",
"att",
".",
"URL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"att",
".",
"URL",
",",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"fileRef",
",",
"err",
":=",
"schema",
".",
"WriteFileFromReader",
"(",
"r",
".",
"Context",
"(",
")",
",",
"r",
".",
"Host",
".",
"Target",
"(",
")",
",",
"\"",
"\"",
",",
"resp",
".",
"Body",
")",
"\n",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"filename",
":=",
"path",
".",
"Base",
"(",
"att",
".",
"URL",
")",
"\n",
"filenames",
"[",
"filename",
"]",
"++",
"\n\n",
"// A status can have several different attachments with the same",
"// filename. We add numbers to the path to diffirentiate them if that's",
"// the case",
"if",
"filenames",
"[",
"filename",
"]",
">",
"1",
"{",
"ext",
":=",
"path",
".",
"Ext",
"(",
"filename",
")",
"\n",
"filename",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"TrimSuffix",
"(",
"filename",
",",
"ext",
")",
",",
"filenames",
"[",
"filename",
"]",
",",
"ext",
")",
"\n",
"}",
"\n\n",
"attrs",
"=",
"append",
"(",
"attrs",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"filename",
")",
",",
"fileRef",
".",
"String",
"(",
")",
")",
"\n\n",
"// The first image gets to be the preview image for the node",
"if",
"i",
"==",
"0",
"{",
"attrs",
"=",
"append",
"(",
"attrs",
",",
"\"",
"\"",
",",
"fileRef",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"fileRef",
".",
"String",
"(",
")",
",",
"statusNode",
".",
"PermanodeRef",
"(",
")",
",",
"st",
".",
"URI",
")",
"\n\n",
"}",
"\n\n",
"changed",
",",
"err",
":=",
"statusNode",
".",
"SetAttrs2",
"(",
"attrs",
"...",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"changed",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"st",
".",
"URI",
",",
"statusNode",
".",
"PermanodeRef",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"!",
"changed",
",",
"err",
"\n\n",
"}"
] |
// 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, authorizationPath)
return &oauth2.Config{
ClientID: ctx.AccountNode.Attr(acctAttrClientID),
ClientSecret: ctx.AccountNode.Attr(acctAttrClientSecret),
RedirectURL: im.RedirectURL(im, ctx),
Endpoint: oauth2.Endpoint{
AuthURL: authURL.String(),
TokenURL: tokenURL.String(),
},
}, nil
}
|
go
|
func (im *imp) auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
baseURL, err := url.Parse(ctx.AccountNode.Attr(acctAttrInstanceURL))
if err != nil {
return nil, err
}
tokenURL := *baseURL
tokenURL.Path = path.Join(tokenURL.Path, tokenPath)
authURL := *baseURL
authURL.Path = path.Join(authURL.Path, authorizationPath)
return &oauth2.Config{
ClientID: ctx.AccountNode.Attr(acctAttrClientID),
ClientSecret: ctx.AccountNode.Attr(acctAttrClientSecret),
RedirectURL: im.RedirectURL(im, ctx),
Endpoint: oauth2.Endpoint{
AuthURL: authURL.String(),
TokenURL: tokenURL.String(),
},
}, nil
}
|
[
"func",
"(",
"im",
"*",
"imp",
")",
"auth",
"(",
"ctx",
"*",
"importer",
".",
"SetupContext",
")",
"(",
"*",
"oauth2",
".",
"Config",
",",
"error",
")",
"{",
"baseURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"ctx",
".",
"AccountNode",
".",
"Attr",
"(",
"acctAttrInstanceURL",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"tokenURL",
":=",
"*",
"baseURL",
"\n",
"tokenURL",
".",
"Path",
"=",
"path",
".",
"Join",
"(",
"tokenURL",
".",
"Path",
",",
"tokenPath",
")",
"\n\n",
"authURL",
":=",
"*",
"baseURL",
"\n",
"authURL",
".",
"Path",
"=",
"path",
".",
"Join",
"(",
"authURL",
".",
"Path",
",",
"authorizationPath",
")",
"\n\n",
"return",
"&",
"oauth2",
".",
"Config",
"{",
"ClientID",
":",
"ctx",
".",
"AccountNode",
".",
"Attr",
"(",
"acctAttrClientID",
")",
",",
"ClientSecret",
":",
"ctx",
".",
"AccountNode",
".",
"Attr",
"(",
"acctAttrClientSecret",
")",
",",
"RedirectURL",
":",
"im",
".",
"RedirectURL",
"(",
"im",
",",
"ctx",
")",
",",
"Endpoint",
":",
"oauth2",
".",
"Endpoint",
"{",
"AuthURL",
":",
"authURL",
".",
"String",
"(",
")",
",",
"TokenURL",
":",
"tokenURL",
".",
"String",
"(",
")",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// auth returns the appropriate oauth2.Config for this account
|
[
"auth",
"returns",
"the",
"appropriate",
"oauth2",
".",
"Config",
"for",
"this",
"account"
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/mastodon/mastodon.go#L470-L491
|
train
|
perkeep/perkeep
|
pkg/importer/mastodon/mastodon.go
|
createMastodonClient
|
func createMastodonClient(ctx context.Context, acct *importer.Object) *mastodon.Client {
// Although the client can take client_id and client_secret, we won't need
// those for token auth
cl := mastodon.NewClient(&mastodon.Config{
Server: acct.Attr(acctAttrInstanceURL),
AccessToken: acct.Attr(importer.AcctAttrAccessToken),
})
cl.Client = *ctxutil.Client(ctx)
return cl
}
|
go
|
func createMastodonClient(ctx context.Context, acct *importer.Object) *mastodon.Client {
// Although the client can take client_id and client_secret, we won't need
// those for token auth
cl := mastodon.NewClient(&mastodon.Config{
Server: acct.Attr(acctAttrInstanceURL),
AccessToken: acct.Attr(importer.AcctAttrAccessToken),
})
cl.Client = *ctxutil.Client(ctx)
return cl
}
|
[
"func",
"createMastodonClient",
"(",
"ctx",
"context",
".",
"Context",
",",
"acct",
"*",
"importer",
".",
"Object",
")",
"*",
"mastodon",
".",
"Client",
"{",
"// Although the client can take client_id and client_secret, we won't need",
"// those for token auth",
"cl",
":=",
"mastodon",
".",
"NewClient",
"(",
"&",
"mastodon",
".",
"Config",
"{",
"Server",
":",
"acct",
".",
"Attr",
"(",
"acctAttrInstanceURL",
")",
",",
"AccessToken",
":",
"acct",
".",
"Attr",
"(",
"importer",
".",
"AcctAttrAccessToken",
")",
",",
"}",
")",
"\n\n",
"cl",
".",
"Client",
"=",
"*",
"ctxutil",
".",
"Client",
"(",
"ctx",
")",
"\n",
"return",
"cl",
"\n",
"}"
] |
// 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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"parsedURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"instanceURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"user",
",",
"parsedURL",
".",
"Host",
")",
",",
"nil",
"\n",
"}"
] |
// 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",
"return",
"sn",
".",
"contents",
",",
"nil",
"\n",
"}"
] |
// Body returns the bytes written to the BlobSniffer.
|
[
"Body",
"returns",
"the",
"bytes",
"written",
"to",
"the",
"BlobSniffer",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/index/sniff.go#L78-L83
|
train
|
perkeep/perkeep
|
pkg/server/image.go
|
cacheScaled
|
func (ih *ImageHandler) cacheScaled(ctx context.Context, thumbBytes []byte, name string) error {
br, err := writeToCache(ctx, ih.Cache, thumbBytes, name)
if err != nil {
return err
}
ih.ThumbMeta.Put(name, br)
return nil
}
|
go
|
func (ih *ImageHandler) cacheScaled(ctx context.Context, thumbBytes []byte, name string) error {
br, err := writeToCache(ctx, ih.Cache, thumbBytes, name)
if err != nil {
return err
}
ih.ThumbMeta.Put(name, br)
return nil
}
|
[
"func",
"(",
"ih",
"*",
"ImageHandler",
")",
"cacheScaled",
"(",
"ctx",
"context",
".",
"Context",
",",
"thumbBytes",
"[",
"]",
"byte",
",",
"name",
"string",
")",
"error",
"{",
"br",
",",
"err",
":=",
"writeToCache",
"(",
"ctx",
",",
"ih",
".",
"Cache",
",",
"thumbBytes",
",",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ih",
".",
"ThumbMeta",
".",
"Put",
"(",
"name",
",",
"br",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// cacheScaled saves in the image handler's cache the scaled image bytes
// in thumbBytes, and puts its blobref in the scaledImage under the key name.
|
[
"cacheScaled",
"saves",
"in",
"the",
"image",
"handler",
"s",
"cache",
"the",
"scaled",
"image",
"bytes",
"in",
"thumbBytes",
"and",
"puts",
"its",
"blobref",
"in",
"the",
"scaledImage",
"under",
"the",
"key",
"name",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/image.go#L117-L124
|
train
|
perkeep/perkeep
|
pkg/server/image.go
|
scaledCached
|
func (ih *ImageHandler) scaledCached(ctx context.Context, buf *bytes.Buffer, file blob.Ref) (format string) {
key := cacheKey(file.String(), ih.MaxWidth, ih.MaxHeight)
br, err := ih.ThumbMeta.Get(key)
if err == errCacheMiss {
return
}
if err != nil {
log.Printf("Warning: thumbnail cachekey(%q)->meta lookup error: %v", key, err)
return
}
fr, err := ih.cached(ctx, br)
if err != nil {
if imageDebug {
log.Printf("Could not get cached image %v: %v\n", br, err)
}
return
}
defer fr.Close()
_, err = io.Copy(buf, fr)
if err != nil {
return
}
mime := magic.MIMEType(buf.Bytes())
if format = strings.TrimPrefix(mime, "image/"); format == mime {
log.Printf("Warning: unescaped MIME type %q of %v file for thumbnail %q", mime, br, key)
return
}
return format
}
|
go
|
func (ih *ImageHandler) scaledCached(ctx context.Context, buf *bytes.Buffer, file blob.Ref) (format string) {
key := cacheKey(file.String(), ih.MaxWidth, ih.MaxHeight)
br, err := ih.ThumbMeta.Get(key)
if err == errCacheMiss {
return
}
if err != nil {
log.Printf("Warning: thumbnail cachekey(%q)->meta lookup error: %v", key, err)
return
}
fr, err := ih.cached(ctx, br)
if err != nil {
if imageDebug {
log.Printf("Could not get cached image %v: %v\n", br, err)
}
return
}
defer fr.Close()
_, err = io.Copy(buf, fr)
if err != nil {
return
}
mime := magic.MIMEType(buf.Bytes())
if format = strings.TrimPrefix(mime, "image/"); format == mime {
log.Printf("Warning: unescaped MIME type %q of %v file for thumbnail %q", mime, br, key)
return
}
return format
}
|
[
"func",
"(",
"ih",
"*",
"ImageHandler",
")",
"scaledCached",
"(",
"ctx",
"context",
".",
"Context",
",",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"file",
"blob",
".",
"Ref",
")",
"(",
"format",
"string",
")",
"{",
"key",
":=",
"cacheKey",
"(",
"file",
".",
"String",
"(",
")",
",",
"ih",
".",
"MaxWidth",
",",
"ih",
".",
"MaxHeight",
")",
"\n",
"br",
",",
"err",
":=",
"ih",
".",
"ThumbMeta",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"==",
"errCacheMiss",
"{",
"return",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"key",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"fr",
",",
"err",
":=",
"ih",
".",
"cached",
"(",
"ctx",
",",
"br",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"imageDebug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"br",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"fr",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"buf",
",",
"fr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"mime",
":=",
"magic",
".",
"MIMEType",
"(",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"if",
"format",
"=",
"strings",
".",
"TrimPrefix",
"(",
"mime",
",",
"\"",
"\"",
")",
";",
"format",
"==",
"mime",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"mime",
",",
"br",
",",
"key",
")",
"\n",
"return",
"\n",
"}",
"\n",
"return",
"format",
"\n",
"}"
] |
// 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",
"is",
"non",
"-",
"empty",
".",
"Almost",
"all",
"errors",
"are",
"not",
"interesting",
".",
"Real",
"errors",
"will",
"be",
"logged",
"."
] |
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",
".",
"Have",
")",
")",
"\n",
"for",
"_",
",",
"size",
":=",
"range",
"sr",
".",
"Have",
"{",
"sizes",
"=",
"append",
"(",
"sizes",
",",
"int",
"(",
"size",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Ints",
"(",
"sizes",
")",
"\n",
"return",
"sizes",
"\n",
"}"
] |
// 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",
"(",
"0",
",",
"0",
",",
"w",
",",
"h",
")",
")",
"\n",
"xdraw",
".",
"ApproxBiLinear",
".",
"Scale",
"(",
"dst",
",",
"dst",
".",
"Bounds",
"(",
")",
",",
"m",
",",
"m",
".",
"Bounds",
"(",
")",
",",
"xdraw",
".",
"Src",
",",
"nil",
")",
"\n",
"return",
"dst",
",",
"true",
"\n",
"}"
] |
// resizeYCbCr returns a scaled copy of the YCbCr image slice r of m.
// The returned image has width w and height h.
|
[
"resizeYCbCr",
"returns",
"a",
"scaled",
"copy",
"of",
"the",
"YCbCr",
"image",
"slice",
"r",
"of",
"m",
".",
"The",
"returned",
"image",
"has",
"width",
"w",
"and",
"height",
"h",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/resize/resize.go#L121-L125
|
train
|
perkeep/perkeep
|
internal/images/resize/resize.go
|
ResampleInplace
|
func ResampleInplace(m image.Image, r image.Rectangle, w, h int) image.Image {
// We don't support scaling up.
if r.Dx() < w || r.Dy() < h {
return m
}
switch m := m.(type) {
case *image.YCbCr:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
cSrc := m.COffset(xSrc, ySrc)
cDst := m.COffset(x, y)
m.Y[m.YOffset(x, y)] = m.Y[m.YOffset(xSrc, ySrc)]
m.Cb[cDst] = m.Cb[cSrc]
m.Cr[cDst] = m.Cr[cSrc]
}
}
case draw.Image:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
r, g, b, a := m.At(xSrc, ySrc).RGBA()
m.Set(x, y, color.RGBA{
R: uint8(r >> 8),
G: uint8(g >> 8),
B: uint8(b >> 8),
A: uint8(a >> 8),
})
}
}
default:
// TODO fallback to generic Resample somehow?
panic("Unhandled image type")
}
r.Max.X = r.Min.X + w
r.Max.Y = r.Min.Y + h
return subImage(m, r)
}
|
go
|
func ResampleInplace(m image.Image, r image.Rectangle, w, h int) image.Image {
// We don't support scaling up.
if r.Dx() < w || r.Dy() < h {
return m
}
switch m := m.(type) {
case *image.YCbCr:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
cSrc := m.COffset(xSrc, ySrc)
cDst := m.COffset(x, y)
m.Y[m.YOffset(x, y)] = m.Y[m.YOffset(xSrc, ySrc)]
m.Cb[cDst] = m.Cb[cSrc]
m.Cr[cDst] = m.Cr[cSrc]
}
}
case draw.Image:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++ {
for x := r.Min.X; x < r.Min.X+w; x++ {
xSrc := int(float64(x) * xStep)
ySrc := int(float64(y) * yStep)
r, g, b, a := m.At(xSrc, ySrc).RGBA()
m.Set(x, y, color.RGBA{
R: uint8(r >> 8),
G: uint8(g >> 8),
B: uint8(b >> 8),
A: uint8(a >> 8),
})
}
}
default:
// TODO fallback to generic Resample somehow?
panic("Unhandled image type")
}
r.Max.X = r.Min.X + w
r.Max.Y = r.Min.Y + h
return subImage(m, r)
}
|
[
"func",
"ResampleInplace",
"(",
"m",
"image",
".",
"Image",
",",
"r",
"image",
".",
"Rectangle",
",",
"w",
",",
"h",
"int",
")",
"image",
".",
"Image",
"{",
"// We don't support scaling up.",
"if",
"r",
".",
"Dx",
"(",
")",
"<",
"w",
"||",
"r",
".",
"Dy",
"(",
")",
"<",
"h",
"{",
"return",
"m",
"\n",
"}",
"\n\n",
"switch",
"m",
":=",
"m",
".",
"(",
"type",
")",
"{",
"case",
"*",
"image",
".",
"YCbCr",
":",
"xStep",
":=",
"float64",
"(",
"r",
".",
"Dx",
"(",
")",
")",
"/",
"float64",
"(",
"w",
")",
"\n",
"yStep",
":=",
"float64",
"(",
"r",
".",
"Dy",
"(",
")",
")",
"/",
"float64",
"(",
"h",
")",
"\n",
"for",
"y",
":=",
"r",
".",
"Min",
".",
"Y",
";",
"y",
"<",
"r",
".",
"Min",
".",
"Y",
"+",
"h",
";",
"y",
"++",
"{",
"for",
"x",
":=",
"r",
".",
"Min",
".",
"X",
";",
"x",
"<",
"r",
".",
"Min",
".",
"X",
"+",
"w",
";",
"x",
"++",
"{",
"xSrc",
":=",
"int",
"(",
"float64",
"(",
"x",
")",
"*",
"xStep",
")",
"\n",
"ySrc",
":=",
"int",
"(",
"float64",
"(",
"y",
")",
"*",
"yStep",
")",
"\n",
"cSrc",
":=",
"m",
".",
"COffset",
"(",
"xSrc",
",",
"ySrc",
")",
"\n",
"cDst",
":=",
"m",
".",
"COffset",
"(",
"x",
",",
"y",
")",
"\n",
"m",
".",
"Y",
"[",
"m",
".",
"YOffset",
"(",
"x",
",",
"y",
")",
"]",
"=",
"m",
".",
"Y",
"[",
"m",
".",
"YOffset",
"(",
"xSrc",
",",
"ySrc",
")",
"]",
"\n",
"m",
".",
"Cb",
"[",
"cDst",
"]",
"=",
"m",
".",
"Cb",
"[",
"cSrc",
"]",
"\n",
"m",
".",
"Cr",
"[",
"cDst",
"]",
"=",
"m",
".",
"Cr",
"[",
"cSrc",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"draw",
".",
"Image",
":",
"xStep",
":=",
"float64",
"(",
"r",
".",
"Dx",
"(",
")",
")",
"/",
"float64",
"(",
"w",
")",
"\n",
"yStep",
":=",
"float64",
"(",
"r",
".",
"Dy",
"(",
")",
")",
"/",
"float64",
"(",
"h",
")",
"\n",
"for",
"y",
":=",
"r",
".",
"Min",
".",
"Y",
";",
"y",
"<",
"r",
".",
"Min",
".",
"Y",
"+",
"h",
";",
"y",
"++",
"{",
"for",
"x",
":=",
"r",
".",
"Min",
".",
"X",
";",
"x",
"<",
"r",
".",
"Min",
".",
"X",
"+",
"w",
";",
"x",
"++",
"{",
"xSrc",
":=",
"int",
"(",
"float64",
"(",
"x",
")",
"*",
"xStep",
")",
"\n",
"ySrc",
":=",
"int",
"(",
"float64",
"(",
"y",
")",
"*",
"yStep",
")",
"\n",
"r",
",",
"g",
",",
"b",
",",
"a",
":=",
"m",
".",
"At",
"(",
"xSrc",
",",
"ySrc",
")",
".",
"RGBA",
"(",
")",
"\n",
"m",
".",
"Set",
"(",
"x",
",",
"y",
",",
"color",
".",
"RGBA",
"{",
"R",
":",
"uint8",
"(",
"r",
">>",
"8",
")",
",",
"G",
":",
"uint8",
"(",
"g",
">>",
"8",
")",
",",
"B",
":",
"uint8",
"(",
"b",
">>",
"8",
")",
",",
"A",
":",
"uint8",
"(",
"a",
">>",
"8",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"// TODO fallback to generic Resample somehow?",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
".",
"Max",
".",
"X",
"=",
"r",
".",
"Min",
".",
"X",
"+",
"w",
"\n",
"r",
".",
"Max",
".",
"Y",
"=",
"r",
".",
"Min",
".",
"Y",
"+",
"h",
"\n",
"return",
"subImage",
"(",
"m",
",",
"r",
")",
"\n",
"}"
] |
// 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",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"session",
".",
"DB",
"(",
"c",
".",
"dbName",
")",
".",
"C",
"(",
"mongo",
".",
"CollectionName",
")",
".",
"RemoveAll",
"(",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// wipeMongo erases all documents from the mongo collection
// if c.dbType is "mongo".
|
[
"wipeMongo",
"erases",
"all",
"documents",
"from",
"the",
"mongo",
"collection",
"if",
"c",
".",
"dbType",
"is",
"mongo",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk/dbinit.go#L290-L303
|
train
|
perkeep/perkeep
|
pkg/importer/oauth.go
|
RedirectURL
|
func (OAuth2) RedirectURL(imp Importer, ctx *SetupContext) string {
// We strip our callback URL of its query component, because the Redirect URI
// we send during authorization has to match exactly the registered redirect
// URI(s). This query component should be stored in the "state" paremeter instead.
// See http://tools.ietf.org/html/rfc6749#section-3.1.2.2
fullCallback := ctx.CallbackURL()
queryPart := imp.CallbackURLParameters(ctx.AccountNode.PermanodeRef())
if len(queryPart) == 0 {
log.Printf("WARNING: callback URL %q has no query component", fullCallback)
}
u, _ := url.Parse(fullCallback)
v := u.Query()
// remove query params in CallbackURLParameters
for k := range queryPart {
v.Del(k)
}
u.RawQuery = v.Encode()
return u.String()
}
|
go
|
func (OAuth2) RedirectURL(imp Importer, ctx *SetupContext) string {
// We strip our callback URL of its query component, because the Redirect URI
// we send during authorization has to match exactly the registered redirect
// URI(s). This query component should be stored in the "state" paremeter instead.
// See http://tools.ietf.org/html/rfc6749#section-3.1.2.2
fullCallback := ctx.CallbackURL()
queryPart := imp.CallbackURLParameters(ctx.AccountNode.PermanodeRef())
if len(queryPart) == 0 {
log.Printf("WARNING: callback URL %q has no query component", fullCallback)
}
u, _ := url.Parse(fullCallback)
v := u.Query()
// remove query params in CallbackURLParameters
for k := range queryPart {
v.Del(k)
}
u.RawQuery = v.Encode()
return u.String()
}
|
[
"func",
"(",
"OAuth2",
")",
"RedirectURL",
"(",
"imp",
"Importer",
",",
"ctx",
"*",
"SetupContext",
")",
"string",
"{",
"// We strip our callback URL of its query component, because the Redirect URI",
"// we send during authorization has to match exactly the registered redirect",
"// URI(s). This query component should be stored in the \"state\" paremeter instead.",
"// See http://tools.ietf.org/html/rfc6749#section-3.1.2.2",
"fullCallback",
":=",
"ctx",
".",
"CallbackURL",
"(",
")",
"\n",
"queryPart",
":=",
"imp",
".",
"CallbackURLParameters",
"(",
"ctx",
".",
"AccountNode",
".",
"PermanodeRef",
"(",
")",
")",
"\n",
"if",
"len",
"(",
"queryPart",
")",
"==",
"0",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"fullCallback",
")",
"\n",
"}",
"\n",
"u",
",",
"_",
":=",
"url",
".",
"Parse",
"(",
"fullCallback",
")",
"\n",
"v",
":=",
"u",
".",
"Query",
"(",
")",
"\n",
"// remove query params in CallbackURLParameters",
"for",
"k",
":=",
"range",
"queryPart",
"{",
"v",
".",
"Del",
"(",
"k",
")",
"\n",
"}",
"\n",
"u",
".",
"RawQuery",
"=",
"v",
".",
"Encode",
"(",
")",
"\n",
"return",
"u",
".",
"String",
"(",
")",
"\n",
"}"
] |
// 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",
"(",
"AcctAttrAccessToken",
")",
"!=",
"\"",
"\"",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] |
// IsAccountReady returns whether the account has been properly configured
// - whether the user ID and access token has been stored in the given account node.
|
[
"IsAccountReady",
"returns",
"whether",
"the",
"account",
"has",
"been",
"properly",
"configured",
"-",
"whether",
"the",
"user",
"ID",
"and",
"access",
"token",
"has",
"been",
"stored",
"in",
"the",
"given",
"account",
"node",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L121-L127
|
train
|
perkeep/perkeep
|
pkg/importer/oauth.go
|
do
|
func (octx OAuthContext) do(method string, url string, form url.Values) (*http.Response, error) {
if octx.Creds == nil {
return nil, errors.New("no OAuth credentials. Not logged in?")
}
if octx.Client == nil {
return nil, errors.New("no OAuth client")
}
var (
res *http.Response
err error
)
if method == http.MethodPost {
res, err = octx.Client.Post(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
} else {
res, err = octx.Client.Get(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
}
if err != nil {
return nil, fmt.Errorf("error fetching %s: %v", url, err)
}
if res.StatusCode != http.StatusOK {
return res, fmt.Errorf("%s request on %s failed with: %s", method, url, res.Status)
}
return res, nil
}
|
go
|
func (octx OAuthContext) do(method string, url string, form url.Values) (*http.Response, error) {
if octx.Creds == nil {
return nil, errors.New("no OAuth credentials. Not logged in?")
}
if octx.Client == nil {
return nil, errors.New("no OAuth client")
}
var (
res *http.Response
err error
)
if method == http.MethodPost {
res, err = octx.Client.Post(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
} else {
res, err = octx.Client.Get(ctxutil.Client(octx.Ctx), octx.Creds, url, form)
}
if err != nil {
return nil, fmt.Errorf("error fetching %s: %v", url, err)
}
if res.StatusCode != http.StatusOK {
return res, fmt.Errorf("%s request on %s failed with: %s", method, url, res.Status)
}
return res, nil
}
|
[
"func",
"(",
"octx",
"OAuthContext",
")",
"do",
"(",
"method",
"string",
",",
"url",
"string",
",",
"form",
"url",
".",
"Values",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"octx",
".",
"Creds",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"octx",
".",
"Client",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"(",
"res",
"*",
"http",
".",
"Response",
"\n",
"err",
"error",
"\n",
")",
"\n",
"if",
"method",
"==",
"http",
".",
"MethodPost",
"{",
"res",
",",
"err",
"=",
"octx",
".",
"Client",
".",
"Post",
"(",
"ctxutil",
".",
"Client",
"(",
"octx",
".",
"Ctx",
")",
",",
"octx",
".",
"Creds",
",",
"url",
",",
"form",
")",
"\n",
"}",
"else",
"{",
"res",
",",
"err",
"=",
"octx",
".",
"Client",
".",
"Get",
"(",
"ctxutil",
".",
"Client",
"(",
"octx",
".",
"Ctx",
")",
",",
"octx",
".",
"Creds",
",",
"url",
",",
"form",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"url",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"res",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"return",
"res",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"method",
",",
"url",
",",
"res",
".",
"Status",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// Do sends through octx the request defined by url and the values in form.
|
[
"Do",
"sends",
"through",
"octx",
"the",
"request",
"defined",
"by",
"url",
"and",
"the",
"values",
"in",
"form",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L159-L182
|
train
|
perkeep/perkeep
|
pkg/importer/oauth.go
|
PopulateJSONFromURL
|
func (octx OAuthContext) PopulateJSONFromURL(result interface{}, method string, apiURL string, keyval ...string) error {
if method != http.MethodGet && method != http.MethodPost {
return fmt.Errorf("only HTTP Get or Post supported: found %v", method)
}
if len(keyval)%2 == 1 {
return errors.New("incorrect number of keyval arguments. must be even")
}
form := url.Values{}
for i := 0; i < len(keyval); i += 2 {
form.Set(keyval[i], keyval[i+1])
}
hres, err := octx.do(method, apiURL, form)
if err != nil {
return err
}
err = httputil.DecodeJSON(hres, result)
if err != nil {
return fmt.Errorf("could not parse response for %s: %v", apiURL, err)
}
return err
}
|
go
|
func (octx OAuthContext) PopulateJSONFromURL(result interface{}, method string, apiURL string, keyval ...string) error {
if method != http.MethodGet && method != http.MethodPost {
return fmt.Errorf("only HTTP Get or Post supported: found %v", method)
}
if len(keyval)%2 == 1 {
return errors.New("incorrect number of keyval arguments. must be even")
}
form := url.Values{}
for i := 0; i < len(keyval); i += 2 {
form.Set(keyval[i], keyval[i+1])
}
hres, err := octx.do(method, apiURL, form)
if err != nil {
return err
}
err = httputil.DecodeJSON(hres, result)
if err != nil {
return fmt.Errorf("could not parse response for %s: %v", apiURL, err)
}
return err
}
|
[
"func",
"(",
"octx",
"OAuthContext",
")",
"PopulateJSONFromURL",
"(",
"result",
"interface",
"{",
"}",
",",
"method",
"string",
",",
"apiURL",
"string",
",",
"keyval",
"...",
"string",
")",
"error",
"{",
"if",
"method",
"!=",
"http",
".",
"MethodGet",
"&&",
"method",
"!=",
"http",
".",
"MethodPost",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"method",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"keyval",
")",
"%",
"2",
"==",
"1",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"form",
":=",
"url",
".",
"Values",
"{",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"keyval",
")",
";",
"i",
"+=",
"2",
"{",
"form",
".",
"Set",
"(",
"keyval",
"[",
"i",
"]",
",",
"keyval",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"\n",
"hres",
",",
"err",
":=",
"octx",
".",
"do",
"(",
"method",
",",
"apiURL",
",",
"form",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"httputil",
".",
"DecodeJSON",
"(",
"hres",
",",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"apiURL",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// PopulateJSONFromURL makes a POST or GET call at apiURL, using keyval as parameters of
// the associated form. The JSON response is decoded into result.
|
[
"PopulateJSONFromURL",
"makes",
"a",
"POST",
"or",
"GET",
"call",
"at",
"apiURL",
"using",
"keyval",
"as",
"parameters",
"of",
"the",
"associated",
"form",
".",
"The",
"JSON",
"response",
"is",
"decoded",
"into",
"result",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/oauth.go#L194-L214
|
train
|
perkeep/perkeep
|
pkg/importer/oauth.go
|
NewOAuthClient
|
func (ctx *SetupContext) NewOAuthClient(uris OAuthURIs) (*oauth.Client, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth.Client{
TemporaryCredentialRequestURI: uris.TemporaryCredentialRequestURI,
ResourceOwnerAuthorizationURI: uris.ResourceOwnerAuthorizationURI,
TokenRequestURI: uris.TokenRequestURI,
Credentials: oauth.Credentials{
Token: clientID,
Secret: secret,
},
}, nil
}
|
go
|
func (ctx *SetupContext) NewOAuthClient(uris OAuthURIs) (*oauth.Client, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth.Client{
TemporaryCredentialRequestURI: uris.TemporaryCredentialRequestURI,
ResourceOwnerAuthorizationURI: uris.ResourceOwnerAuthorizationURI,
TokenRequestURI: uris.TokenRequestURI,
Credentials: oauth.Credentials{
Token: clientID,
Secret: secret,
},
}, nil
}
|
[
"func",
"(",
"ctx",
"*",
"SetupContext",
")",
"NewOAuthClient",
"(",
"uris",
"OAuthURIs",
")",
"(",
"*",
"oauth",
".",
"Client",
",",
"error",
")",
"{",
"clientID",
",",
"secret",
",",
"err",
":=",
"ctx",
".",
"Credentials",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"oauth",
".",
"Client",
"{",
"TemporaryCredentialRequestURI",
":",
"uris",
".",
"TemporaryCredentialRequestURI",
",",
"ResourceOwnerAuthorizationURI",
":",
"uris",
".",
"ResourceOwnerAuthorizationURI",
",",
"TokenRequestURI",
":",
"uris",
".",
"TokenRequestURI",
",",
"Credentials",
":",
"oauth",
".",
"Credentials",
"{",
"Token",
":",
"clientID",
",",
"Secret",
":",
"secret",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// 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",
"]",
";",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"typ",
")",
"\n",
"}",
"\n",
"handlerConstructors",
"[",
"typ",
"]",
"=",
"ctor",
"\n",
"}"
] |
// 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",
":=",
"handlerConstructors",
"[",
"typ",
"]",
"\n",
"mapLock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"typ",
")",
"\n",
"}",
"\n",
"return",
"ctor",
"(",
"loader",
",",
"config",
")",
"\n",
"}"
] |
// 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",
"typ",
"must",
"have",
"been",
"previously",
"registered",
"with",
"RegisterHandlerConstructor",
"."
] |
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",
"{",
"\"",
"\"",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
",",
"}",
",",
"}",
"\n",
"return",
"b",
".",
"build",
"(",
")",
"\n",
"}"
] |
// 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",
"!=",
"\"",
"\"",
"{",
"return",
"strings",
".",
"ToLower",
"(",
"b",
".",
"high",
".",
"Identity",
")",
"\n",
"}",
"\n",
"return",
"osutil",
".",
"Username",
"(",
")",
"// may be empty, if $USER unset",
"\n",
"}"
] |
// 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",
"\"",
"\"",
":",
"return",
"\"",
"\"",
"\n",
"case",
"dbUIThumbcache",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// As of rev 7eda9fd5027fda88166d6c03b6490cffbf2de5fb, we changed how the
// databases names were defined. But we wanted the existing GCE instances to keep
// on working with the old names, so that nothing would break for existing users,
// without any intervention needed. Through the help of the perkeep-config-version
// variable, set by the GCE launcher, we can know whether an instance is such an
// "old" one, and in that case we keep on using the old database names. oldDBNames
// returns these names.
|
[
"As",
"of",
"rev",
"7eda9fd5027fda88166d6c03b6490cffbf2de5fb",
"we",
"changed",
"how",
"the",
"databases",
"names",
"were",
"defined",
".",
"But",
"we",
"wanted",
"the",
"existing",
"GCE",
"instances",
"to",
"keep",
"on",
"working",
"with",
"the",
"old",
"names",
"so",
"that",
"nothing",
"would",
"break",
"for",
"existing",
"users",
"without",
"any",
"intervention",
"needed",
".",
"Through",
"the",
"help",
"of",
"the",
"perkeep",
"-",
"config",
"-",
"version",
"variable",
"set",
"by",
"the",
"GCE",
"launcher",
"we",
"can",
"know",
"whether",
"an",
"instance",
"is",
"such",
"an",
"old",
"one",
"and",
"in",
"that",
"case",
"we",
"keep",
"on",
"using",
"the",
"old",
"database",
"names",
".",
"oldDBNames",
"returns",
"these",
"names",
"."
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L162-L174
|
train
|
perkeep/perkeep
|
pkg/serverinit/genconfig.go
|
searchOwner
|
func (b *lowBuilder) searchOwner() (owner *serverconfig.Owner, err error) {
if b.high.Identity == "" {
return nil, errNoOwner
}
if b.high.IdentitySecretRing == "" {
return nil, errNoOwner
}
return &serverconfig.Owner{
Identity: b.high.Identity,
SecringFile: b.high.IdentitySecretRing,
}, nil
}
|
go
|
func (b *lowBuilder) searchOwner() (owner *serverconfig.Owner, err error) {
if b.high.Identity == "" {
return nil, errNoOwner
}
if b.high.IdentitySecretRing == "" {
return nil, errNoOwner
}
return &serverconfig.Owner{
Identity: b.high.Identity,
SecringFile: b.high.IdentitySecretRing,
}, nil
}
|
[
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"searchOwner",
"(",
")",
"(",
"owner",
"*",
"serverconfig",
".",
"Owner",
",",
"err",
"error",
")",
"{",
"if",
"b",
".",
"high",
".",
"Identity",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errNoOwner",
"\n",
"}",
"\n",
"if",
"b",
".",
"high",
".",
"IdentitySecretRing",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errNoOwner",
"\n",
"}",
"\n",
"return",
"&",
"serverconfig",
".",
"Owner",
"{",
"Identity",
":",
"b",
".",
"high",
".",
"Identity",
",",
"SecringFile",
":",
"b",
".",
"high",
".",
"IdentitySecretRing",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Error is errNoOwner if no identity configured
|
[
"Error",
"is",
"errNoOwner",
"if",
"no",
"identity",
"configured"
] |
e28bbbd1588d64df8ab7a82393afd39d64c061f7
|
https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L179-L190
|
train
|
perkeep/perkeep
|
pkg/serverinit/genconfig.go
|
kvFileType
|
func (b *lowBuilder) kvFileType() string {
switch {
case b.high.SQLite != "":
return "sqlite"
case b.high.KVFile != "":
return "kv"
case b.high.LevelDB != "":
return "leveldb"
default:
return sorted.DefaultKVFileType
}
}
|
go
|
func (b *lowBuilder) kvFileType() string {
switch {
case b.high.SQLite != "":
return "sqlite"
case b.high.KVFile != "":
return "kv"
case b.high.LevelDB != "":
return "leveldb"
default:
return sorted.DefaultKVFileType
}
}
|
[
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"kvFileType",
"(",
")",
"string",
"{",
"switch",
"{",
"case",
"b",
".",
"high",
".",
"SQLite",
"!=",
"\"",
"\"",
":",
"return",
"\"",
"\"",
"\n",
"case",
"b",
".",
"high",
".",
"KVFile",
"!=",
"\"",
"\"",
":",
"return",
"\"",
"\"",
"\n",
"case",
"b",
".",
"high",
".",
"LevelDB",
"!=",
"\"",
"\"",
":",
"return",
"\"",
"\"",
"\n",
"default",
":",
"return",
"sorted",
".",
"DefaultKVFileType",
"\n",
"}",
"\n",
"}"
] |
// 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.