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/serverinit/genconfig.go | sortedDBMS | func (b *lowBuilder) sortedDBMS(named dbname) (map[string]interface{}, error) {
if b.high.MySQL != "" {
return b.dbIndexStorage("mysql", b.high.MySQL, named)
}
if b.high.PostgreSQL != "" {
return b.dbIndexStorage("postgres", b.high.PostgreSQL, named)
}
if b.high.Mongo != "" {
return b.mongoIndexStorage(b.hig... | go | func (b *lowBuilder) sortedDBMS(named dbname) (map[string]interface{}, error) {
if b.high.MySQL != "" {
return b.dbIndexStorage("mysql", b.high.MySQL, named)
}
if b.high.PostgreSQL != "" {
return b.dbIndexStorage("postgres", b.high.PostgreSQL, named)
}
if b.high.Mongo != "" {
return b.mongoIndexStorage(b.hig... | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"sortedDBMS",
"(",
"named",
"dbname",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"b",
".",
"high",
".",
"MySQL",
"!=",
"\"",
"\"",
"{",
"return",
"b",
".",
... | // sortedDBMS returns the configuration for a name database on one of the
// DBMS, if any was found in the configuration. It returns nil otherwise. | [
"sortedDBMS",
"returns",
"the",
"configuration",
"for",
"a",
"name",
"database",
"on",
"one",
"of",
"the",
"DBMS",
"if",
"any",
"was",
"found",
"in",
"the",
"configuration",
".",
"It",
"returns",
"nil",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L467-L478 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | sortedStorageAt | func (b *lowBuilder) sortedStorageAt(sortedType dbname, filePrefix string) (map[string]interface{}, error) {
dbms, err := b.sortedDBMS(sortedType)
if err != nil {
return nil, err
}
if dbms != nil {
return dbms, nil
}
if b.high.MemoryIndex {
return map[string]interface{}{
"type": "memory",
}, nil
}
if... | go | func (b *lowBuilder) sortedStorageAt(sortedType dbname, filePrefix string) (map[string]interface{}, error) {
dbms, err := b.sortedDBMS(sortedType)
if err != nil {
return nil, err
}
if dbms != nil {
return dbms, nil
}
if b.high.MemoryIndex {
return map[string]interface{}{
"type": "memory",
}, nil
}
if... | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"sortedStorageAt",
"(",
"sortedType",
"dbname",
",",
"filePrefix",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"dbms",
",",
"err",
":=",
"b",
".",
"sortedDBMS",... | // filePrefix gives a file path of where to put the database. It can be omitted by
// some sorted implementations, but is required by others.
// The filePrefix should be to a file, not a directory, and should not end in a ".ext" extension.
// An extension like ".kv" or ".sqlite" will be added. | [
"filePrefix",
"gives",
"a",
"file",
"path",
"of",
"where",
"to",
"put",
"the",
"database",
".",
"It",
"can",
"be",
"omitted",
"by",
"some",
"sorted",
"implementations",
"but",
"is",
"required",
"by",
"others",
".",
"The",
"filePrefix",
"should",
"be",
"to"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L484-L526 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | indexFileDir | func (b *lowBuilder) indexFileDir() string {
switch {
case b.high.SQLite != "":
return filepath.Dir(b.high.SQLite)
case b.high.KVFile != "":
return filepath.Dir(b.high.KVFile)
case b.high.LevelDB != "":
return filepath.Dir(b.high.LevelDB)
}
return ""
} | go | func (b *lowBuilder) indexFileDir() string {
switch {
case b.high.SQLite != "":
return filepath.Dir(b.high.SQLite)
case b.high.KVFile != "":
return filepath.Dir(b.high.KVFile)
case b.high.LevelDB != "":
return filepath.Dir(b.high.LevelDB)
}
return ""
} | [
"func",
"(",
"b",
"*",
"lowBuilder",
")",
"indexFileDir",
"(",
")",
"string",
"{",
"switch",
"{",
"case",
"b",
".",
"high",
".",
"SQLite",
"!=",
"\"",
"\"",
":",
"return",
"filepath",
".",
"Dir",
"(",
"b",
".",
"high",
".",
"SQLite",
")",
"\n",
"... | // indexFileDir returns the directory of the sqlite or kv file, or the
// empty string. | [
"indexFileDir",
"returns",
"the",
"directory",
"of",
"the",
"sqlite",
"or",
"kv",
"file",
"or",
"the",
"empty",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L827-L837 | train |
perkeep/perkeep | pkg/serverinit/genconfig.go | WriteDefaultConfigFile | func WriteDefaultConfigFile(filePath string, useSQLite bool) error {
conf := defaultBaseConfig
blobDir, err := osutil.CamliBlobRoot()
if err != nil {
return err
}
varDir, err := osutil.CamliVarDir()
if err != nil {
return err
}
if err := wkfs.MkdirAll(blobDir, 0700); err != nil {
return fmt.Errorf("Could ... | go | func WriteDefaultConfigFile(filePath string, useSQLite bool) error {
conf := defaultBaseConfig
blobDir, err := osutil.CamliBlobRoot()
if err != nil {
return err
}
varDir, err := osutil.CamliVarDir()
if err != nil {
return err
}
if err := wkfs.MkdirAll(blobDir, 0700); err != nil {
return fmt.Errorf("Could ... | [
"func",
"WriteDefaultConfigFile",
"(",
"filePath",
"string",
",",
"useSQLite",
"bool",
")",
"error",
"{",
"conf",
":=",
"defaultBaseConfig",
"\n",
"blobDir",
",",
"err",
":=",
"osutil",
".",
"CamliBlobRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"... | // WriteDefaultConfigFile generates a new default high-level server configuration
// file at filePath. If useSQLite, the default indexer will use SQLite, otherwise
// leveldb. If filePath already exists, it is overwritten. | [
"WriteDefaultConfigFile",
"generates",
"a",
"new",
"default",
"high",
"-",
"level",
"server",
"configuration",
"file",
"at",
"filePath",
".",
"If",
"useSQLite",
"the",
"default",
"indexer",
"will",
"use",
"SQLite",
"otherwise",
"leveldb",
".",
"If",
"filePath",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/serverinit/genconfig.go#L1246-L1285 | train |
perkeep/perkeep | server/perkeepd/autodns.go | listenForCamliNet | func listenForCamliNet(ws *webserver.Server, config *serverinit.Config) (baseURL string, err error) {
camliNetIP := config.CamliNetIP()
if camliNetIP == "" {
return "", errors.New("no camliNetIP")
}
if ip := net.ParseIP(camliNetIP); ip == nil {
return "", fmt.Errorf("camliNetIP value %q is not a valid IP addres... | go | func listenForCamliNet(ws *webserver.Server, config *serverinit.Config) (baseURL string, err error) {
camliNetIP := config.CamliNetIP()
if camliNetIP == "" {
return "", errors.New("no camliNetIP")
}
if ip := net.ParseIP(camliNetIP); ip == nil {
return "", fmt.Errorf("camliNetIP value %q is not a valid IP addres... | [
"func",
"listenForCamliNet",
"(",
"ws",
"*",
"webserver",
".",
"Server",
",",
"config",
"*",
"serverinit",
".",
"Config",
")",
"(",
"baseURL",
"string",
",",
"err",
"error",
")",
"{",
"camliNetIP",
":=",
"config",
".",
"CamliNetIP",
"(",
")",
"\n",
"if",... | // listenForCamliNet prepares the TLS listener for both the GPG challenge, and
// for Let's Encrypt. It then starts listening and returns the baseURL derived from
// the hostname we should obtain from the GPG challenge. | [
"listenForCamliNet",
"prepares",
"the",
"TLS",
"listener",
"for",
"both",
"the",
"GPG",
"challenge",
"and",
"for",
"Let",
"s",
"Encrypt",
".",
"It",
"then",
"starts",
"listening",
"and",
"returns",
"the",
"baseURL",
"derived",
"from",
"the",
"hostname",
"we",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/autodns.go#L52-L105 | train |
perkeep/perkeep | pkg/gc/gc.go | markItem | func (c *Collector) markItem(ctx context.Context, it Item, isRoot bool) error {
if !isRoot {
marked, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if marked {
return nil
}
}
if err := c.Marker.Mark(it); err != nil {
return err
}
// FIXME(tgulacsi): is it a problem that we cannot canc... | go | func (c *Collector) markItem(ctx context.Context, it Item, isRoot bool) error {
if !isRoot {
marked, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if marked {
return nil
}
}
if err := c.Marker.Mark(it); err != nil {
return err
}
// FIXME(tgulacsi): is it a problem that we cannot canc... | [
"func",
"(",
"c",
"*",
"Collector",
")",
"markItem",
"(",
"ctx",
"context",
".",
"Context",
",",
"it",
"Item",
",",
"isRoot",
"bool",
")",
"error",
"{",
"if",
"!",
"isRoot",
"{",
"marked",
",",
"err",
":=",
"c",
".",
"Marker",
".",
"IsMarked",
"(",... | // ctx will be canceled on failure | [
"ctx",
"will",
"be",
"canceled",
"on",
"failure"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/gc/gc.go#L88-L122 | train |
perkeep/perkeep | pkg/gc/gc.go | Collect | func (c *Collector) Collect(ctx context.Context) (err error) {
if c.World == nil {
return errors.New("no World")
}
if c.Marker == nil {
return errors.New("no Marker")
}
if c.Roots == nil {
return errors.New("no Roots")
}
if c.Sweeper == nil {
return errors.New("no Sweeper")
}
if c.ItemEnumerator == nil... | go | func (c *Collector) Collect(ctx context.Context) (err error) {
if c.World == nil {
return errors.New("no World")
}
if c.Marker == nil {
return errors.New("no Marker")
}
if c.Roots == nil {
return errors.New("no Roots")
}
if c.Sweeper == nil {
return errors.New("no Sweeper")
}
if c.ItemEnumerator == nil... | [
"func",
"(",
"c",
"*",
"Collector",
")",
"Collect",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"if",
"c",
".",
"World",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if... | // Collect performs a garbage collection. | [
"Collect",
"performs",
"a",
"garbage",
"collection",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/gc/gc.go#L125-L200 | train |
perkeep/perkeep | pkg/sorted/buffer/buffer.go | New | func New(buffer, backing sorted.KeyValue, maxBufferBytes int64) *KeyValue {
return &KeyValue{
buf: buffer,
back: backing,
maxBuffer: maxBufferBytes,
}
} | go | func New(buffer, backing sorted.KeyValue, maxBufferBytes int64) *KeyValue {
return &KeyValue{
buf: buffer,
back: backing,
maxBuffer: maxBufferBytes,
}
} | [
"func",
"New",
"(",
"buffer",
",",
"backing",
"sorted",
".",
"KeyValue",
",",
"maxBufferBytes",
"int64",
")",
"*",
"KeyValue",
"{",
"return",
"&",
"KeyValue",
"{",
"buf",
":",
"buffer",
",",
"back",
":",
"backing",
",",
"maxBuffer",
":",
"maxBufferBytes",
... | // New returnes a sorted.KeyValue implementation that adds a Flush
// method to flush the buffer to the backing storage. A flush will
// also be performed when maxBufferBytes are reached. If
// maxBufferBytes <= 0, no automatic flushing is performed. | [
"New",
"returnes",
"a",
"sorted",
".",
"KeyValue",
"implementation",
"that",
"adds",
"a",
"Flush",
"method",
"to",
"flush",
"the",
"buffer",
"to",
"the",
"backing",
"storage",
".",
"A",
"flush",
"will",
"also",
"be",
"performed",
"when",
"maxBufferBytes",
"a... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/buffer/buffer.go#L35-L41 | train |
perkeep/perkeep | cmd/pk-put/kvcache.go | maybeRunCompaction | func maybeRunCompaction(dbname string, db *leveldb.DB) error {
val, err := db.GetProperty("leveldb.num-files-at-level0")
if err != nil {
return fmt.Errorf("could not get number of level-0 files of %v's LevelDB: %v", dbname, err)
}
nbFiles, err := strconv.Atoi(val)
if err != nil {
return fmt.Errorf("could not c... | go | func maybeRunCompaction(dbname string, db *leveldb.DB) error {
val, err := db.GetProperty("leveldb.num-files-at-level0")
if err != nil {
return fmt.Errorf("could not get number of level-0 files of %v's LevelDB: %v", dbname, err)
}
nbFiles, err := strconv.Atoi(val)
if err != nil {
return fmt.Errorf("could not c... | [
"func",
"maybeRunCompaction",
"(",
"dbname",
"string",
",",
"db",
"*",
"leveldb",
".",
"DB",
")",
"error",
"{",
"val",
",",
"err",
":=",
"db",
".",
"GetProperty",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Err... | // maybeRunCompaction forces compaction of db, if the number of
// tables in level 0 is >= 4. dbname should be provided for error messages. | [
"maybeRunCompaction",
"forces",
"compaction",
"of",
"db",
"if",
"the",
"number",
"of",
"tables",
"in",
"level",
"0",
"is",
">",
"=",
"4",
".",
"dbname",
"should",
"be",
"provided",
"for",
"error",
"messages",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/kvcache.go#L76-L94 | train |
perkeep/perkeep | cmd/pk-put/kvcache.go | marshalBinary | func (sk *statCacheKey) marshalBinary() ([]byte, error) {
if sk == nil {
return nil, errors.New("Can not marshal from a nil stat cache key")
}
data := make([]byte, 0, len(sk.Filepath)+3)
data = append(data, 1) // version number
data = append(data, sk.Filepath...)
data = append(data, '|')
if sk.Permanode {
da... | go | func (sk *statCacheKey) marshalBinary() ([]byte, error) {
if sk == nil {
return nil, errors.New("Can not marshal from a nil stat cache key")
}
data := make([]byte, 0, len(sk.Filepath)+3)
data = append(data, 1) // version number
data = append(data, sk.Filepath...)
data = append(data, '|')
if sk.Permanode {
da... | [
"func",
"(",
"sk",
"*",
"statCacheKey",
")",
"marshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"sk",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"data",
":="... | // marshalBinary returns a more compact binary
// representation of the contents of sk. | [
"marshalBinary",
"returns",
"a",
"more",
"compact",
"binary",
"representation",
"of",
"the",
"contents",
"of",
"sk",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/kvcache.go#L234-L246 | train |
perkeep/perkeep | cmd/pk-put/kvcache.go | marshalBinary | func (scv *statCacheValue) marshalBinary() ([]byte, error) {
if scv == nil {
return nil, errors.New("Can not marshal from a nil stat cache value")
}
binBr, _ := scv.Result.BlobRef.MarshalBinary()
// Blob size fits on 4 bytes when binary encoded
data := make([]byte, 0, len(scv.Fingerprint)+1+4+1+len(binBr))
buf ... | go | func (scv *statCacheValue) marshalBinary() ([]byte, error) {
if scv == nil {
return nil, errors.New("Can not marshal from a nil stat cache value")
}
binBr, _ := scv.Result.BlobRef.MarshalBinary()
// Blob size fits on 4 bytes when binary encoded
data := make([]byte, 0, len(scv.Fingerprint)+1+4+1+len(binBr))
buf ... | [
"func",
"(",
"scv",
"*",
"statCacheValue",
")",
"marshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"scv",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"binBr",
... | // marshalBinary returns a more compact binary
// representation of the contents of scv. | [
"marshalBinary",
"returns",
"a",
"more",
"compact",
"binary",
"representation",
"of",
"the",
"contents",
"of",
"scv",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/kvcache.go#L257-L286 | train |
perkeep/perkeep | internal/osutil/restart_unix.go | RestartProcess | func RestartProcess(arg ...string) error {
path, err := SelfPath()
if err != nil {
return fmt.Errorf("RestartProcess failed: %v", err)
}
var args []string
if len(arg) > 0 {
args = append(args, os.Args[0])
for _, v := range arg {
args = append(args, v)
}
} else {
args = os.Args
}
return syscall.Ex... | go | func RestartProcess(arg ...string) error {
path, err := SelfPath()
if err != nil {
return fmt.Errorf("RestartProcess failed: %v", err)
}
var args []string
if len(arg) > 0 {
args = append(args, os.Args[0])
for _, v := range arg {
args = append(args, v)
}
} else {
args = os.Args
}
return syscall.Ex... | [
"func",
"RestartProcess",
"(",
"arg",
"...",
"string",
")",
"error",
"{",
"path",
",",
"err",
":=",
"SelfPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"v... | // RestartProcess restarts the process with the given arguments, if any,
// replacing the original process's arguments. It defaults to os.Args otherwise. It
// returns an error if things couldn't be restarted. On success, this function
// never returns because the process becomes the new process. | [
"RestartProcess",
"restarts",
"the",
"process",
"with",
"the",
"given",
"arguments",
"if",
"any",
"replacing",
"the",
"original",
"process",
"s",
"arguments",
".",
"It",
"defaults",
"to",
"os",
".",
"Args",
"otherwise",
".",
"It",
"returns",
"an",
"error",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/restart_unix.go#L63-L80 | train |
perkeep/perkeep | misc/docker/dock.go | buildDockerImage | func buildDockerImage(imageDir, imageName string) {
if dockDir == "" {
panic("dockDir should be set before calling buildDockerImage")
}
cmd := exec.Command("docker", "build", "-t", imageName, ".")
cmd.Dir = filepath.Join(dockDir, imageDir)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err ... | go | func buildDockerImage(imageDir, imageName string) {
if dockDir == "" {
panic("dockDir should be set before calling buildDockerImage")
}
cmd := exec.Command("docker", "build", "-t", imageName, ".")
cmd.Dir = filepath.Join(dockDir, imageDir)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err ... | [
"func",
"buildDockerImage",
"(",
"imageDir",
",",
"imageName",
"string",
")",
"{",
"if",
"dockDir",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
... | // buildDockerImage builds a docker image from the Dockerfile located in
// imageDir, which is a path relative to dockDir. The image will be named after
// imageName. dockDir should have been set behorehand. | [
"buildDockerImage",
"builds",
"a",
"docker",
"image",
"from",
"the",
"Dockerfile",
"located",
"in",
"imageDir",
"which",
"is",
"a",
"path",
"relative",
"to",
"dockDir",
".",
"The",
"image",
"will",
"be",
"named",
"after",
"imageName",
".",
"dockDir",
"should",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/misc/docker/dock.go#L54-L65 | train |
perkeep/perkeep | pkg/blobserver/mergedenum.go | MergedEnumerate | func MergedEnumerate(ctx context.Context, dest chan<- blob.SizedRef, sources []BlobEnumerator, after string, limit int) error {
return mergedEnumerate(ctx, dest, len(sources), func(i int) BlobEnumerator { return sources[i] }, after, limit)
} | go | func MergedEnumerate(ctx context.Context, dest chan<- blob.SizedRef, sources []BlobEnumerator, after string, limit int) error {
return mergedEnumerate(ctx, dest, len(sources), func(i int) BlobEnumerator { return sources[i] }, after, limit)
} | [
"func",
"MergedEnumerate",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"sources",
"[",
"]",
"BlobEnumerator",
",",
"after",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"return",
"mergedEnumerate",
"... | // MergedEnumerate implements the BlobEnumerator interface by
// merge-joining 0 or more sources. | [
"MergedEnumerate",
"implements",
"the",
"BlobEnumerator",
"interface",
"by",
"merge",
"-",
"joining",
"0",
"or",
"more",
"sources",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/mergedenum.go#L29-L31 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | NewOAuthConfig | func NewOAuthConfig(clientID, clientSecret string) *oauth2.Config {
return &oauth2.Config{
Scopes: []string{
logging.WriteScope,
compute.DevstorageFullControlScope,
compute.ComputeScope,
cloudresourcemanager.CloudPlatformScope,
servicemanagement.CloudPlatformScope,
"https://www.googleapis.com/auth/... | go | func NewOAuthConfig(clientID, clientSecret string) *oauth2.Config {
return &oauth2.Config{
Scopes: []string{
logging.WriteScope,
compute.DevstorageFullControlScope,
compute.ComputeScope,
cloudresourcemanager.CloudPlatformScope,
servicemanagement.CloudPlatformScope,
"https://www.googleapis.com/auth/... | [
"func",
"NewOAuthConfig",
"(",
"clientID",
",",
"clientSecret",
"string",
")",
"*",
"oauth2",
".",
"Config",
"{",
"return",
"&",
"oauth2",
".",
"Config",
"{",
"Scopes",
":",
"[",
"]",
"string",
"{",
"logging",
".",
"WriteScope",
",",
"compute",
".",
"Dev... | // NewOAuthConfig returns an OAuth configuration template. | [
"NewOAuthConfig",
"returns",
"an",
"OAuth",
"configuration",
"template",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L83-L98 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | Get | func (d *Deployer) Get() (*compute.Instance, error) {
computeService, err := compute.New(d.Client)
if err != nil {
return nil, err
}
return computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
} | go | func (d *Deployer) Get() (*compute.Instance, error) {
computeService, err := compute.New(d.Client)
if err != nil {
return nil, err
}
return computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
} | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"Get",
"(",
")",
"(",
"*",
"compute",
".",
"Instance",
",",
"error",
")",
"{",
"computeService",
",",
"err",
":=",
"compute",
".",
"New",
"(",
"d",
".",
"Client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Get returns the Instance corresponding to the Project, Zone, and Name defined in the
// Deployer's Conf. | [
"Get",
"returns",
"the",
"Instance",
"corresponding",
"to",
"the",
"Project",
"Zone",
"and",
"Name",
"defined",
"in",
"the",
"Deployer",
"s",
"Conf",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L138-L144 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | projectHasInstance | func (d *Deployer) projectHasInstance() (zone string, err error) {
s, err := compute.New(d.Client)
if err != nil {
return "", err
}
// TODO(mpl): make use of the handler's cached zones.
zl, err := compute.NewZonesService(s).List(d.Conf.Project).Do()
if err != nil {
return "", fmt.Errorf("could not get a list ... | go | func (d *Deployer) projectHasInstance() (zone string, err error) {
s, err := compute.New(d.Client)
if err != nil {
return "", err
}
// TODO(mpl): make use of the handler's cached zones.
zl, err := compute.NewZonesService(s).List(d.Conf.Project).Do()
if err != nil {
return "", fmt.Errorf("could not get a list ... | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"projectHasInstance",
"(",
")",
"(",
"zone",
"string",
",",
"err",
"error",
")",
"{",
"s",
",",
"err",
":=",
"compute",
".",
"New",
"(",
"d",
".",
"Client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return... | // projectHasInstance checks for all the possible zones if there's already an instance for the project.
// It returns the name of the zone at the first instance it finds, if any. | [
"projectHasInstance",
"checks",
"for",
"all",
"the",
"possible",
"zones",
"if",
"there",
"s",
"already",
"an",
"instance",
"for",
"the",
"project",
".",
"It",
"returns",
"the",
"name",
"of",
"the",
"zone",
"at",
"the",
"first",
"instance",
"it",
"finds",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L169-L216 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | getInstanceAttribute | func (d *Deployer) getInstanceAttribute(attr string) (string, error) {
s, err := compute.New(d.Client)
if err != nil {
return "", fmt.Errorf("error getting compute service: %v", err)
}
inst, err := compute.NewInstancesService(s).Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return "", fmt.... | go | func (d *Deployer) getInstanceAttribute(attr string) (string, error) {
s, err := compute.New(d.Client)
if err != nil {
return "", fmt.Errorf("error getting compute service: %v", err)
}
inst, err := compute.NewInstancesService(s).Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return "", fmt.... | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"getInstanceAttribute",
"(",
"attr",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"compute",
".",
"New",
"(",
"d",
".",
"Client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r... | // getInstanceAttribute returns the value for attr in the custom metadata of the
// instance. It returns errAttrNotFound is such a metadata attributed does not
// exist. | [
"getInstanceAttribute",
"returns",
"the",
"value",
"for",
"attr",
"in",
"the",
"custom",
"metadata",
"of",
"the",
"instance",
".",
"It",
"returns",
"errAttrNotFound",
"is",
"such",
"a",
"metadata",
"attributed",
"does",
"not",
"exist",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L455-L470 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | Create | func (d *Deployer) Create(ctx context.Context) (*compute.Instance, error) {
if err := d.enableAPIs(); err != nil {
return nil, projectIDError{
id: d.Conf.Project,
cause: err,
}
}
if err := d.checkProjectID(); err != nil {
return nil, err
}
computeService, _ := compute.New(d.Client)
storageService,... | go | func (d *Deployer) Create(ctx context.Context) (*compute.Instance, error) {
if err := d.enableAPIs(); err != nil {
return nil, projectIDError{
id: d.Conf.Project,
cause: err,
}
}
if err := d.checkProjectID(); err != nil {
return nil, err
}
computeService, _ := compute.New(d.Client)
storageService,... | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"compute",
".",
"Instance",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"enableAPIs",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return... | // Create sets up and starts a Google Compute Engine instance as defined in d.Conf. It
// creates the necessary Google Storage buckets beforehand. | [
"Create",
"sets",
"up",
"and",
"starts",
"a",
"Google",
"Compute",
"Engine",
"instance",
"as",
"defined",
"in",
"d",
".",
"Conf",
".",
"It",
"creates",
"the",
"necessary",
"Google",
"Storage",
"buckets",
"beforehand",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L474-L529 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | setBuckets | func (d *Deployer) setBuckets(ctx context.Context, storageService *storage.Service) error {
projBucket := d.Conf.Project + "-camlistore"
needBucket := map[string]bool{
projBucket: true,
}
buckets, err := storageService.Buckets.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing buckets... | go | func (d *Deployer) setBuckets(ctx context.Context, storageService *storage.Service) error {
projBucket := d.Conf.Project + "-camlistore"
needBucket := map[string]bool{
projBucket: true,
}
buckets, err := storageService.Buckets.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing buckets... | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"setBuckets",
"(",
"ctx",
"context",
".",
"Context",
",",
"storageService",
"*",
"storage",
".",
"Service",
")",
"error",
"{",
"projBucket",
":=",
"d",
".",
"Conf",
".",
"Project",
"+",
"\"",
"\"",
"\n\n",
"needB... | // setBuckets defines the buckets needed by the instance and creates them. | [
"setBuckets",
"defines",
"the",
"buckets",
"needed",
"by",
"the",
"instance",
"and",
"creates",
"them",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L708-L763 | train |
perkeep/perkeep | pkg/deploy/gce/deploy.go | setFirewall | func (d *Deployer) setFirewall(ctx context.Context, computeService *compute.Service) error {
defaultNet, err := computeService.Networks.Get(d.Conf.Project, "default").Do()
if err != nil {
return fmt.Errorf("error getting default network: %v", err)
}
needRules := map[string]compute.Firewall{
"default-allow-http... | go | func (d *Deployer) setFirewall(ctx context.Context, computeService *compute.Service) error {
defaultNet, err := computeService.Networks.Get(d.Conf.Project, "default").Do()
if err != nil {
return fmt.Errorf("error getting default network: %v", err)
}
needRules := map[string]compute.Firewall{
"default-allow-http... | [
"func",
"(",
"d",
"*",
"Deployer",
")",
"setFirewall",
"(",
"ctx",
"context",
".",
"Context",
",",
"computeService",
"*",
"compute",
".",
"Service",
")",
"error",
"{",
"defaultNet",
",",
"err",
":=",
"computeService",
".",
"Networks",
".",
"Get",
"(",
"d... | // setFirewall adds the firewall rules needed for ports 80 & 433 to the default network. | [
"setFirewall",
"adds",
"the",
"firewall",
"rules",
"needed",
"for",
"ports",
"80",
"&",
"433",
"to",
"the",
"default",
"network",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/deploy/gce/deploy.go#L766-L826 | train |
perkeep/perkeep | pkg/webserver/webserver.go | loadX509KeyPair | func loadX509KeyPair(certFile, keyFile string) (cert tls.Certificate, err error) {
certPEMBlock, err := wkfs.ReadFile(certFile)
if err != nil {
return
}
keyPEMBlock, err := wkfs.ReadFile(keyFile)
if err != nil {
return
}
return tls.X509KeyPair(certPEMBlock, keyPEMBlock)
} | go | func loadX509KeyPair(certFile, keyFile string) (cert tls.Certificate, err error) {
certPEMBlock, err := wkfs.ReadFile(certFile)
if err != nil {
return
}
keyPEMBlock, err := wkfs.ReadFile(keyFile)
if err != nil {
return
}
return tls.X509KeyPair(certPEMBlock, keyPEMBlock)
} | [
"func",
"loadX509KeyPair",
"(",
"certFile",
",",
"keyFile",
"string",
")",
"(",
"cert",
"tls",
".",
"Certificate",
",",
"err",
"error",
")",
"{",
"certPEMBlock",
",",
"err",
":=",
"wkfs",
".",
"ReadFile",
"(",
"certFile",
")",
"\n",
"if",
"err",
"!=",
... | // loadX509KeyPair is a copy of tls.LoadX509KeyPair but using wkfs. | [
"loadX509KeyPair",
"is",
"a",
"copy",
"of",
"tls",
".",
"LoadX509KeyPair",
"but",
"using",
"wkfs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/webserver/webserver.go#L277-L287 | train |
perkeep/perkeep | internal/httputil/httputil.go | RequestTargetPort | func RequestTargetPort(req *http.Request) int {
_, portStr, err := net.SplitHostPort(req.Host)
if err == nil && portStr != "" {
port, err := strconv.ParseInt(portStr, 0, 64)
if err == nil {
return int(port)
}
}
if req.TLS != nil {
return 443
}
return 80
} | go | func RequestTargetPort(req *http.Request) int {
_, portStr, err := net.SplitHostPort(req.Host)
if err == nil && portStr != "" {
port, err := strconv.ParseInt(portStr, 0, 64)
if err == nil {
return int(port)
}
}
if req.TLS != nil {
return 443
}
return 80
} | [
"func",
"RequestTargetPort",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"int",
"{",
"_",
",",
"portStr",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"req",
".",
"Host",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"portStr",
"!=",
"\"",
"\... | // RequestTargetPort returns the port targeted by the client
// in req. If not present, it returns 80, or 443 if TLS is used. | [
"RequestTargetPort",
"returns",
"the",
"port",
"targeted",
"by",
"the",
"client",
"in",
"req",
".",
"If",
"not",
"present",
"it",
"returns",
"80",
"or",
"443",
"if",
"TLS",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L153-L165 | train |
perkeep/perkeep | internal/httputil/httputil.go | RecoverJSON | func RecoverJSON(rw http.ResponseWriter, req *http.Request) {
e := recover()
if e == nil {
return
}
ServeJSONError(rw, e)
} | go | func RecoverJSON(rw http.ResponseWriter, req *http.Request) {
e := recover()
if e == nil {
return
}
ServeJSONError(rw, e)
} | [
"func",
"RecoverJSON",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"e",
":=",
"recover",
"(",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"ServeJSONError",
"(",
"rw",
",",
"e",... | // RecoverJSON is like Recover but returns with a JSON response. | [
"RecoverJSON",
"is",
"like",
"Recover",
"but",
"returns",
"with",
"a",
"JSON",
"response",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L182-L188 | train |
perkeep/perkeep | internal/httputil/httputil.go | MustGetBlobRef | func MustGetBlobRef(req *http.Request, param string) blob.Ref {
br, ok := blob.Parse(MustGet(req, param))
if !ok {
panic(InvalidParameterError(param))
}
return br
} | go | func MustGetBlobRef(req *http.Request, param string) blob.Ref {
br, ok := blob.Parse(MustGet(req, param))
if !ok {
panic(InvalidParameterError(param))
}
return br
} | [
"func",
"MustGetBlobRef",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"param",
"string",
")",
"blob",
".",
"Ref",
"{",
"br",
",",
"ok",
":=",
"blob",
".",
"Parse",
"(",
"MustGet",
"(",
"req",
",",
"param",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
... | // MustGetBlobRef returns a non-nil BlobRef from req, as given by param.
// If it doesn't, it panics with a value understood by Recover or RecoverJSON. | [
"MustGetBlobRef",
"returns",
"a",
"non",
"-",
"nil",
"BlobRef",
"from",
"req",
"as",
"given",
"by",
"param",
".",
"If",
"it",
"doesn",
"t",
"it",
"panics",
"with",
"a",
"value",
"understood",
"by",
"Recover",
"or",
"RecoverJSON",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L236-L242 | train |
perkeep/perkeep | internal/httputil/httputil.go | OptionalInt | func OptionalInt(req *http.Request, param string) int {
v := req.FormValue(param)
if v == "" {
return 0
}
i, err := strconv.Atoi(v)
if err != nil {
panic(InvalidParameterError(param))
}
return i
} | go | func OptionalInt(req *http.Request, param string) int {
v := req.FormValue(param)
if v == "" {
return 0
}
i, err := strconv.Atoi(v)
if err != nil {
panic(InvalidParameterError(param))
}
return i
} | [
"func",
"OptionalInt",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"param",
"string",
")",
"int",
"{",
"v",
":=",
"req",
".",
"FormValue",
"(",
"param",
")",
"\n",
"if",
"v",
"==",
"\"",
"\"",
"{",
"return",
"0",
"\n",
"}",
"\n",
"i",
",",
"e... | // OptionalInt returns the integer in req given by param, or 0 if not present.
// If the form value is not an integer, it panics with a a value understood by Recover or RecoverJSON. | [
"OptionalInt",
"returns",
"the",
"integer",
"in",
"req",
"given",
"by",
"param",
"or",
"0",
"if",
"not",
"present",
".",
"If",
"the",
"form",
"value",
"is",
"not",
"an",
"integer",
"it",
"panics",
"with",
"a",
"a",
"value",
"understood",
"by",
"Recover",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/httputil/httputil.go#L246-L256 | train |
perkeep/perkeep | pkg/server/download.go | fileInfoPacked | func fileInfoPacked(ctx context.Context, sh *search.Handler, src blob.Fetcher, r *http.Request, file blob.Ref) (packFileInfo fileInfo, ok bool) {
if sh == nil {
return fileInfo{whyNot: "no search"}, false
}
wf, ok := src.(blobserver.WholeRefFetcher)
if !ok {
return fileInfo{whyNot: "fetcher type"}, false
}
if... | go | func fileInfoPacked(ctx context.Context, sh *search.Handler, src blob.Fetcher, r *http.Request, file blob.Ref) (packFileInfo fileInfo, ok bool) {
if sh == nil {
return fileInfo{whyNot: "no search"}, false
}
wf, ok := src.(blobserver.WholeRefFetcher)
if !ok {
return fileInfo{whyNot: "fetcher type"}, false
}
if... | [
"func",
"fileInfoPacked",
"(",
"ctx",
"context",
".",
"Context",
",",
"sh",
"*",
"search",
".",
"Handler",
",",
"src",
"blob",
".",
"Fetcher",
",",
"r",
"*",
"http",
".",
"Request",
",",
"file",
"blob",
".",
"Ref",
")",
"(",
"packFileInfo",
"fileInfo",... | // Fast path for blobpacked. | [
"Fast",
"path",
"for",
"blobpacked",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L198-L260 | train |
perkeep/perkeep | pkg/server/download.go | isText | func isText(rs io.ReadSeeker) (ok bool, err error) {
defer func() {
if _, seekErr := rs.Seek(0, io.SeekStart); seekErr != nil {
if err == nil {
err = seekErr
}
}
}()
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rs, 1e6); err != nil {
if err != io.EOF {
return false, err
}
}
return utf8.Va... | go | func isText(rs io.ReadSeeker) (ok bool, err error) {
defer func() {
if _, seekErr := rs.Seek(0, io.SeekStart); seekErr != nil {
if err == nil {
err = seekErr
}
}
}()
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rs, 1e6); err != nil {
if err != io.EOF {
return false, err
}
}
return utf8.Va... | [
"func",
"isText",
"(",
"rs",
"io",
".",
"ReadSeeker",
")",
"(",
"ok",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"_",
",",
"seekErr",
":=",
"rs",
".",
"Seek",
"(",
"0",
",",
"io",
".",
"SeekStart",
")",
";",
... | // isText reports whether the first MB read from rs is valid UTF-8 text. | [
"isText",
"reports",
"whether",
"the",
"first",
"MB",
"read",
"from",
"rs",
"is",
"valid",
"UTF",
"-",
"8",
"text",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L375-L390 | train |
perkeep/perkeep | pkg/server/download.go | statFiles | func (dh *DownloadHandler) statFiles(refs []blob.Ref) error {
statter, ok := dh.Fetcher.(blobserver.BlobStatter)
if !ok {
return fmt.Errorf("DownloadHandler.Fetcher %T is not a BlobStatter", dh.Fetcher)
}
statted := make(map[blob.Ref]bool)
err := statter.StatBlobs(context.TODO(), refs, func(sb blob.SizedRef) er... | go | func (dh *DownloadHandler) statFiles(refs []blob.Ref) error {
statter, ok := dh.Fetcher.(blobserver.BlobStatter)
if !ok {
return fmt.Errorf("DownloadHandler.Fetcher %T is not a BlobStatter", dh.Fetcher)
}
statted := make(map[blob.Ref]bool)
err := statter.StatBlobs(context.TODO(), refs, func(sb blob.SizedRef) er... | [
"func",
"(",
"dh",
"*",
"DownloadHandler",
")",
"statFiles",
"(",
"refs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"statter",
",",
"ok",
":=",
"dh",
".",
"Fetcher",
".",
"(",
"blobserver",
".",
"BlobStatter",
")",
"\n",
"if",
"!",
"ok",
"{"... | // statFiles stats the given refs and returns an error if any one of them is not
// found.
// It is the responsibility of the caller to check that dh.Fetcher is a
// blobserver.BlobStatter. | [
"statFiles",
"stats",
"the",
"given",
"refs",
"and",
"returns",
"an",
"error",
"if",
"any",
"one",
"of",
"them",
"is",
"not",
"found",
".",
"It",
"is",
"the",
"responsibility",
"of",
"the",
"caller",
"to",
"check",
"that",
"dh",
".",
"Fetcher",
"is",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L396-L417 | train |
perkeep/perkeep | pkg/server/download.go | serveZip | func (dh *DownloadHandler) serveZip(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if r.Method != "POST" {
http.Error(w, "Invalid download method", http.StatusBadRequest)
return
}
filesValue := r.FormValue("files")
if filesValue == "" {
http.Error(w, "No file blobRefs specified", http.StatusBa... | go | func (dh *DownloadHandler) serveZip(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if r.Method != "POST" {
http.Error(w, "Invalid download method", http.StatusBadRequest)
return
}
filesValue := r.FormValue("files")
if filesValue == "" {
http.Error(w, "No file blobRefs specified", http.StatusBa... | [
"func",
"(",
"dh",
"*",
"DownloadHandler",
")",
"serveZip",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"ctx",
":=",
"r",
".",
"Context",
"(",
")",
"\n",
"if",
"r",
".",
"Method",
"!=",
"\"",
"\"",
"{... | // serveZip creates a zip archive from the files provided as
// ?files=sha1-foo,sha1-bar,... and serves it as the response. | [
"serveZip",
"creates",
"a",
"zip",
"archive",
"from",
"the",
"files",
"provided",
"as",
"?files",
"=",
"sha1",
"-",
"foo",
"sha1",
"-",
"bar",
"...",
"and",
"serves",
"it",
"as",
"the",
"response",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/server/download.go#L477-L552 | train |
perkeep/perkeep | pkg/client/enumerate.go | SimpleEnumerateBlobs | func (c *Client) SimpleEnumerateBlobs(ctx context.Context, ch chan<- blob.SizedRef) error {
return c.EnumerateBlobsOpts(ctx, ch, EnumerateOpts{})
} | go | func (c *Client) SimpleEnumerateBlobs(ctx context.Context, ch chan<- blob.SizedRef) error {
return c.EnumerateBlobsOpts(ctx, ch, EnumerateOpts{})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SimpleEnumerateBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"ch",
"chan",
"<-",
"blob",
".",
"SizedRef",
")",
"error",
"{",
"return",
"c",
".",
"EnumerateBlobsOpts",
"(",
"ctx",
",",
"ch",
",",
"EnumerateOpts... | // SimpleEnumerateBlobs sends all blobs to the provided channel.
// The channel will be closed, regardless of whether an error is returned. | [
"SimpleEnumerateBlobs",
"sends",
"all",
"blobs",
"to",
"the",
"provided",
"channel",
".",
"The",
"channel",
"will",
"be",
"closed",
"regardless",
"of",
"whether",
"an",
"error",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/enumerate.go#L39-L41 | train |
perkeep/perkeep | pkg/client/enumerate.go | EnumerateBlobsOpts | func (c *Client) EnumerateBlobsOpts(ctx context.Context, ch chan<- blob.SizedRef, opts EnumerateOpts) error {
defer close(ch)
if opts.After != "" && opts.MaxWait != 0 {
return errors.New("client error: it's invalid to use enumerate After and MaxWaitSec together")
}
pfx, err := c.prefix()
if err != nil {
return... | go | func (c *Client) EnumerateBlobsOpts(ctx context.Context, ch chan<- blob.SizedRef, opts EnumerateOpts) error {
defer close(ch)
if opts.After != "" && opts.MaxWait != 0 {
return errors.New("client error: it's invalid to use enumerate After and MaxWaitSec together")
}
pfx, err := c.prefix()
if err != nil {
return... | [
"func",
"(",
"c",
"*",
"Client",
")",
"EnumerateBlobsOpts",
"(",
"ctx",
"context",
".",
"Context",
",",
"ch",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"opts",
"EnumerateOpts",
")",
"error",
"{",
"defer",
"close",
"(",
"ch",
")",
"\n",
"if",
"opts",
... | // EnumerateBlobsOpts sends blobs to the provided channel, as directed by opts.
// The channel will be closed, regardless of whether an error is returned. | [
"EnumerateBlobsOpts",
"sends",
"blobs",
"to",
"the",
"provided",
"channel",
"as",
"directed",
"by",
"opts",
".",
"The",
"channel",
"will",
"be",
"closed",
"regardless",
"of",
"whether",
"an",
"error",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/enumerate.go#L62-L141 | train |
perkeep/perkeep | pkg/cmdmain/cmdmain.go | RegisterCommand | func RegisterCommand(mode string, makeCmd func(Flags *flag.FlagSet) CommandRunner) {
RegisterMode(mode, makeCmd)
asNewCommand[mode] = true
} | go | func RegisterCommand(mode string, makeCmd func(Flags *flag.FlagSet) CommandRunner) {
RegisterMode(mode, makeCmd)
asNewCommand[mode] = true
} | [
"func",
"RegisterCommand",
"(",
"mode",
"string",
",",
"makeCmd",
"func",
"(",
"Flags",
"*",
"flag",
".",
"FlagSet",
")",
"CommandRunner",
")",
"{",
"RegisterMode",
"(",
"mode",
",",
"makeCmd",
")",
"\n",
"asNewCommand",
"[",
"mode",
"]",
"=",
"true",
"\... | // RegisterCommand adds a mode to the list of modes for the main command, and
// also specifies that this mode is just another executable that runs as a new
// cmdmain command. The executable to run is determined by the LookPath implementation
// for this mode. | [
"RegisterCommand",
"adds",
"a",
"mode",
"to",
"the",
"list",
"of",
"modes",
"for",
"the",
"main",
"command",
"and",
"also",
"specifies",
"that",
"this",
"mode",
"is",
"just",
"another",
"executable",
"that",
"runs",
"as",
"a",
"new",
"cmdmain",
"command",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/cmdmain/cmdmain.go#L149-L152 | train |
perkeep/perkeep | pkg/cmdmain/cmdmain.go | runAsNewCommand | func runAsNewCommand(cmd CommandRunner, mode string) {
execCmd, ok := cmd.(ExecRunner)
if !ok {
panic(fmt.Sprintf("%v does not implement ExecRunner", mode))
}
cmdPath, err := execCmd.LookPath()
if err != nil {
Errorf("Error: %v\n", err)
Exit(2)
}
allArgs := shiftFlags(mode)
if err := runExec(cmdPath, allA... | go | func runAsNewCommand(cmd CommandRunner, mode string) {
execCmd, ok := cmd.(ExecRunner)
if !ok {
panic(fmt.Sprintf("%v does not implement ExecRunner", mode))
}
cmdPath, err := execCmd.LookPath()
if err != nil {
Errorf("Error: %v\n", err)
Exit(2)
}
allArgs := shiftFlags(mode)
if err := runExec(cmdPath, allA... | [
"func",
"runAsNewCommand",
"(",
"cmd",
"CommandRunner",
",",
"mode",
"string",
")",
"{",
"execCmd",
",",
"ok",
":=",
"cmd",
".",
"(",
"ExecRunner",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"mode",
... | // runAsNewCommand runs the executable specified by cmd's LookPath, which means
// cmd must implement the ExecRunner interface. The executable must be a binary of
// a program that runs Main. | [
"runAsNewCommand",
"runs",
"the",
"executable",
"specified",
"by",
"cmd",
"s",
"LookPath",
"which",
"means",
"cmd",
"must",
"implement",
"the",
"ExecRunner",
"interface",
".",
"The",
"executable",
"must",
"be",
"a",
"binary",
"of",
"a",
"program",
"that",
"run... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/cmdmain/cmdmain.go#L341-L355 | train |
perkeep/perkeep | pkg/cmdmain/cmdmain.go | Printf | func Printf(format string, args ...interface{}) {
if *FlagVerbose {
fmt.Fprintf(Stderr, format, args...)
}
} | go | func Printf(format string, args ...interface{}) {
if *FlagVerbose {
fmt.Fprintf(Stderr, format, args...)
}
} | [
"func",
"Printf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"*",
"FlagVerbose",
"{",
"fmt",
".",
"Fprintf",
"(",
"Stderr",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] | // Printf prints to Stderr if FlagVerbose, and is silent otherwise. | [
"Printf",
"prints",
"to",
"Stderr",
"if",
"FlagVerbose",
"and",
"is",
"silent",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/cmdmain/cmdmain.go#L377-L381 | train |
perkeep/perkeep | server/perkeepd/logging.go | maybeSetupGoogleCloudLogging | func maybeSetupGoogleCloudLogging() io.Closer {
if flagGCEProjectID == "" && flagGCELogName == "" && flagGCEJWTFile == "" {
return types.NopCloser
}
if flagGCEProjectID == "" || flagGCELogName == "" || flagGCEJWTFile == "" {
exitf("All of --gce_project_id, --gce_log_name, and --gce_jwt_file must be specified for... | go | func maybeSetupGoogleCloudLogging() io.Closer {
if flagGCEProjectID == "" && flagGCELogName == "" && flagGCEJWTFile == "" {
return types.NopCloser
}
if flagGCEProjectID == "" || flagGCELogName == "" || flagGCEJWTFile == "" {
exitf("All of --gce_project_id, --gce_log_name, and --gce_jwt_file must be specified for... | [
"func",
"maybeSetupGoogleCloudLogging",
"(",
")",
"io",
".",
"Closer",
"{",
"if",
"flagGCEProjectID",
"==",
"\"",
"\"",
"&&",
"flagGCELogName",
"==",
"\"",
"\"",
"&&",
"flagGCEJWTFile",
"==",
"\"",
"\"",
"{",
"return",
"types",
".",
"NopCloser",
"\n",
"}",
... | // if a non-nil logging Client is returned, it should be closed before the
// program terminates to flush any buffered log entries. | [
"if",
"a",
"non",
"-",
"nil",
"logging",
"Client",
"is",
"returned",
"it",
"should",
"be",
"closed",
"before",
"the",
"program",
"terminates",
"to",
"flush",
"any",
"buffered",
"log",
"entries",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/logging.go#L70-L92 | train |
perkeep/perkeep | server/perkeepd/logging.go | setupLogging | func setupLogging() io.Closer {
if *flagSyslog && runtime.GOOS == "windows" {
exitf("-syslog not available on windows")
}
if fn := setupLoggingSyslog; fn != nil {
if flusher := fn(); flusher != nil {
return flusher
}
}
if env.OnGCE() {
lw, err := gce.LogWriter()
if err != nil {
log.Fatalf("Error se... | go | func setupLogging() io.Closer {
if *flagSyslog && runtime.GOOS == "windows" {
exitf("-syslog not available on windows")
}
if fn := setupLoggingSyslog; fn != nil {
if flusher := fn(); flusher != nil {
return flusher
}
}
if env.OnGCE() {
lw, err := gce.LogWriter()
if err != nil {
log.Fatalf("Error se... | [
"func",
"setupLogging",
"(",
")",
"io",
".",
"Closer",
"{",
"if",
"*",
"flagSyslog",
"&&",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"exitf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"fn",
":=",
"setupLoggingSyslog",
";",
"fn",
"!=",
"nil"... | // setupLogging sets up logging and returns an io.Closer that flushes logs. | [
"setupLogging",
"sets",
"up",
"logging",
"and",
"returns",
"an",
"io",
".",
"Closer",
"that",
"flushes",
"logs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/logging.go#L99-L117 | train |
perkeep/perkeep | pkg/search/websocket.go | writePump | func (c *wsConn) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
c.ws.Close()
}()
for {
select {
case message, ok := <-c.send:
if !ok {
c.write(websocket.CloseMessage, []byte{})
return
}
if err := c.write(websocket.TextMessage, message); err != nil {
retu... | go | func (c *wsConn) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
c.ws.Close()
}()
for {
select {
case message, ok := <-c.send:
if !ok {
c.write(websocket.CloseMessage, []byte{})
return
}
if err := c.write(websocket.TextMessage, message); err != nil {
retu... | [
"func",
"(",
"c",
"*",
"wsConn",
")",
"writePump",
"(",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"pingPeriod",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"c",
".",
"ws",
".",
"Close",
"(",
... | // writePump pumps messages from the hub to the websocket connection. | [
"writePump",
"pumps",
"messages",
"from",
"the",
"hub",
"to",
"the",
"websocket",
"connection",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/search/websocket.go#L279-L301 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Get | func (s *DriveService) Get(ctx context.Context, title string) (*client.File, error) {
// TODO: use field selectors
query := fmt.Sprintf("'%s' in parents and title = '%s'", s.parentID, title)
req := s.apiservice.Files.List().Context(ctx).Q(query)
files, err := req.Do()
if err != nil {
return nil, err
}
if len(f... | go | func (s *DriveService) Get(ctx context.Context, title string) (*client.File, error) {
// TODO: use field selectors
query := fmt.Sprintf("'%s' in parents and title = '%s'", s.parentID, title)
req := s.apiservice.Files.List().Context(ctx).Q(query)
files, err := req.Do()
if err != nil {
return nil, err
}
if len(f... | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Get",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"(",
"*",
"client",
".",
"File",
",",
"error",
")",
"{",
"// TODO: use field selectors",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"... | // Get retrieves a file with its title equal to the provided title and a child of
// the parentID as given to New. If not found, os.ErrNotExist is returned. | [
"Get",
"retrieves",
"a",
"file",
"with",
"its",
"title",
"equal",
"to",
"the",
"provided",
"title",
"and",
"a",
"child",
"of",
"the",
"parentID",
"as",
"given",
"to",
"New",
".",
"If",
"not",
"found",
"os",
".",
"ErrNotExist",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L65-L77 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | List | func (s *DriveService) List(pageToken string, limit int) (files []*client.File, next string, err error) {
req := s.apiservice.Files.List()
req.Q(fmt.Sprintf("'%s' in parents and mimeType != '%s'", s.parentID, MimeTypeDriveFolder))
if pageToken != "" {
req.PageToken(pageToken)
}
if limit > 0 {
req.MaxResults(... | go | func (s *DriveService) List(pageToken string, limit int) (files []*client.File, next string, err error) {
req := s.apiservice.Files.List()
req.Q(fmt.Sprintf("'%s' in parents and mimeType != '%s'", s.parentID, MimeTypeDriveFolder))
if pageToken != "" {
req.PageToken(pageToken)
}
if limit > 0 {
req.MaxResults(... | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"List",
"(",
"pageToken",
"string",
",",
"limit",
"int",
")",
"(",
"files",
"[",
"]",
"*",
"client",
".",
"File",
",",
"next",
"string",
",",
"err",
"error",
")",
"{",
"req",
":=",
"s",
".",
"apiservice",... | // List returns a list of files. When limit is greater than zero a paginated list is returned
// using the next response as a pageToken in subsequent calls. | [
"List",
"returns",
"a",
"list",
"of",
"files",
".",
"When",
"limit",
"is",
"greater",
"than",
"zero",
"a",
"paginated",
"list",
"is",
"returned",
"using",
"the",
"next",
"response",
"as",
"a",
"pageToken",
"in",
"subsequent",
"calls",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L81-L98 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Upsert | func (s *DriveService) Upsert(ctx context.Context, title string, data io.Reader) (file *client.File, err error) {
if file, err = s.Get(ctx, title); err != nil {
if !os.IsNotExist(err) {
return
}
}
if file == nil {
file = &client.File{Title: title}
file.Parents = []*client.ParentReference{
{Id: s.parent... | go | func (s *DriveService) Upsert(ctx context.Context, title string, data io.Reader) (file *client.File, err error) {
if file, err = s.Get(ctx, title); err != nil {
if !os.IsNotExist(err) {
return
}
}
if file == nil {
file = &client.File{Title: title}
file.Parents = []*client.ParentReference{
{Id: s.parent... | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Upsert",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
",",
"data",
"io",
".",
"Reader",
")",
"(",
"file",
"*",
"client",
".",
"File",
",",
"err",
"error",
")",
"{",
"if",
"file",
",",
... | // Upsert inserts a file, or updates if such a file exists. | [
"Upsert",
"inserts",
"a",
"file",
"or",
"updates",
"if",
"such",
"a",
"file",
"exists",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L101-L118 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Fetch | func (s *DriveService) Fetch(ctx context.Context, title string) (body io.ReadCloser, size uint32, err error) {
file, err := s.Get(ctx, title)
if err != nil {
return
}
// TODO: maybe in the case of no download link, remove the file.
// The file should have malformed or converted to a Docs file
// unwantedly.
//... | go | func (s *DriveService) Fetch(ctx context.Context, title string) (body io.ReadCloser, size uint32, err error) {
file, err := s.Get(ctx, title)
if err != nil {
return
}
// TODO: maybe in the case of no download link, remove the file.
// The file should have malformed or converted to a Docs file
// unwantedly.
//... | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"(",
"body",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"file",
",",
"err",
":=",
"s",
".",... | // Fetch retrieves the metadata and contents of a file. | [
"Fetch",
"retrieves",
"the",
"metadata",
"and",
"contents",
"of",
"a",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L123-L152 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Stat | func (s *DriveService) Stat(ctx context.Context, title string) (int64, error) {
file, err := s.Get(ctx, title)
if err != nil || file == nil {
return 0, err
}
return file.FileSize, err
} | go | func (s *DriveService) Stat(ctx context.Context, title string) (int64, error) {
file, err := s.Get(ctx, title)
if err != nil || file == nil {
return 0, err
}
return file.FileSize, err
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Stat",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"ctx",
",",
"title",
")",
"\n",
"if",
... | // Stat retrieves file metadata and returns
// file size. Returns error if file is not found. | [
"Stat",
"retrieves",
"file",
"metadata",
"and",
"returns",
"file",
"size",
".",
"Returns",
"error",
"if",
"file",
"is",
"not",
"found",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L156-L162 | train |
perkeep/perkeep | pkg/blobserver/google/drive/service/service.go | Trash | func (s *DriveService) Trash(ctx context.Context, title string) error {
file, err := s.Get(ctx, title)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
_, err = s.apiservice.Files.Trash(file.Id).Context(ctx).Do()
return err
} | go | func (s *DriveService) Trash(ctx context.Context, title string) error {
file, err := s.Get(ctx, title)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
_, err = s.apiservice.Files.Trash(file.Id).Context(ctx).Do()
return err
} | [
"func",
"(",
"s",
"*",
"DriveService",
")",
"Trash",
"(",
"ctx",
"context",
".",
"Context",
",",
"title",
"string",
")",
"error",
"{",
"file",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"ctx",
",",
"title",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Trash trashes the file with the given title. | [
"Trash",
"trashes",
"the",
"file",
"with",
"the",
"given",
"title",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/google/drive/service/service.go#L165-L175 | train |
perkeep/perkeep | server/perkeepd/ui/goui/mapquery/mapquery.go | Send | func (q *Query) Send() {
if q.pending {
q.Cleanup()
return
}
q.pending = true
go func() {
resp, err := q.send()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
}
q.Callback(string(resp))
}()
} | go | func (q *Query) Send() {
if q.pending {
q.Cleanup()
return
}
q.pending = true
go func() {
resp, err := q.send()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
}
q.Callback(string(resp))
}()
} | [
"func",
"(",
"q",
"*",
"Query",
")",
"Send",
"(",
")",
"{",
"if",
"q",
".",
"pending",
"{",
"q",
".",
"Cleanup",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"q",
".",
"pending",
"=",
"true",
"\n",
"go",
"func",
"(",
")",
"{",
"resp",
",",
"e... | // Send sends the search query, and runs the Query's callback on success. It
// returns immediately if there's already a query in flight. | [
"Send",
"sends",
"the",
"search",
"query",
"and",
"runs",
"the",
"Query",
"s",
"callback",
"on",
"success",
".",
"It",
"returns",
"immediately",
"if",
"there",
"s",
"already",
"a",
"query",
"in",
"flight",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/server/perkeepd/ui/goui/mapquery/mapquery.go#L90-L103 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/punch_linux.go | punchHoleLinux | func punchHoleLinux(file *os.File, offset int64, size int64) error {
err := syscall.Fallocate(int(file.Fd()),
falloc_fl_punch_hole|falloc_fl_keep_size,
offset, size)
if err == syscall.ENOSYS || err == syscall.EOPNOTSUPP {
return errNoPunch
}
return err
} | go | func punchHoleLinux(file *os.File, offset int64, size int64) error {
err := syscall.Fallocate(int(file.Fd()),
falloc_fl_punch_hole|falloc_fl_keep_size,
offset, size)
if err == syscall.ENOSYS || err == syscall.EOPNOTSUPP {
return errNoPunch
}
return err
} | [
"func",
"punchHoleLinux",
"(",
"file",
"*",
"os",
".",
"File",
",",
"offset",
"int64",
",",
"size",
"int64",
")",
"error",
"{",
"err",
":=",
"syscall",
".",
"Fallocate",
"(",
"int",
"(",
"file",
".",
"Fd",
"(",
")",
")",
",",
"falloc_fl_punch_hole",
... | // puncHoleLinux punches a hole into the given file starting at offset,
// measuring "size" bytes | [
"puncHoleLinux",
"punches",
"a",
"hole",
"into",
"the",
"given",
"file",
"starting",
"at",
"offset",
"measuring",
"size",
"bytes"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/punch_linux.go#L38-L46 | train |
perkeep/perkeep | pkg/schema/filereader.go | NewFileReader | func NewFileReader(ctx context.Context, fetcher blob.Fetcher, fileBlobRef blob.Ref) (*FileReader, error) {
// TODO(bradfitz): rename this into bytes reader? but for now it's still
// named FileReader, but can also read a "bytes" schema.
if !fileBlobRef.Valid() {
return nil, errors.New("schema/filer... | go | func NewFileReader(ctx context.Context, fetcher blob.Fetcher, fileBlobRef blob.Ref) (*FileReader, error) {
// TODO(bradfitz): rename this into bytes reader? but for now it's still
// named FileReader, but can also read a "bytes" schema.
if !fileBlobRef.Valid() {
return nil, errors.New("schema/filer... | [
"func",
"NewFileReader",
"(",
"ctx",
"context",
".",
"Context",
",",
"fetcher",
"blob",
".",
"Fetcher",
",",
"fileBlobRef",
"blob",
".",
"Ref",
")",
"(",
"*",
"FileReader",
",",
"error",
")",
"{",
"// TODO(bradfitz): rename this into bytes reader? but for now it's s... | // NewFileReader returns a new FileReader reading the contents of fileBlobRef,
// fetching blobs from fetcher. The fileBlobRef must be of a "bytes" or "file"
// schema blob.
//
// The caller should call Close on the FileReader when done reading. | [
"NewFileReader",
"returns",
"a",
"new",
"FileReader",
"reading",
"the",
"contents",
"of",
"fileBlobRef",
"fetching",
"blobs",
"from",
"fetcher",
".",
"The",
"fileBlobRef",
"must",
"be",
"of",
"a",
"bytes",
"or",
"file",
"schema",
"blob",
".",
"The",
"caller",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L71-L95 | train |
perkeep/perkeep | pkg/schema/filereader.go | NewFileReader | func (ss *superset) NewFileReader(fetcher blob.Fetcher) (*FileReader, error) {
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: Superset not of type \"file\" or \"bytes\"")
}
size := int64(ss.SumPartsSize())
fr := &FileReader{
fetcher: fetcher,
ss: ss,
size: si... | go | func (ss *superset) NewFileReader(fetcher blob.Fetcher) (*FileReader, error) {
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: Superset not of type \"file\" or \"bytes\"")
}
size := int64(ss.SumPartsSize())
fr := &FileReader{
fetcher: fetcher,
ss: ss,
size: si... | [
"func",
"(",
"ss",
"*",
"superset",
")",
"NewFileReader",
"(",
"fetcher",
"blob",
".",
"Fetcher",
")",
"(",
"*",
"FileReader",
",",
"error",
")",
"{",
"if",
"ss",
".",
"Type",
"!=",
"\"",
"\"",
"&&",
"ss",
".",
"Type",
"!=",
"\"",
"\"",
"{",
"ret... | // NewFileReader returns a new FileReader, reading bytes and blobs
// from the provided fetcher.
//
// NewFileReader does no fetch operation on the fetcher itself. The
// fetcher is only used in subsequent read operations.
//
// An error is only returned if the type of the superset is not either
// "file" or "bytes". | [
"NewFileReader",
"returns",
"a",
"new",
"FileReader",
"reading",
"bytes",
"and",
"blobs",
"from",
"the",
"provided",
"fetcher",
".",
"NewFileReader",
"does",
"no",
"fetch",
"operation",
"on",
"the",
"fetcher",
"itself",
".",
"The",
"fetcher",
"is",
"only",
"us... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L109-L122 | train |
perkeep/perkeep | pkg/schema/filereader.go | UnixMtime | func (fr *FileReader) UnixMtime() time.Time {
t, err := time.Parse(time.RFC3339, fr.ss.UnixMtime)
if err != nil {
return time.Time{}
}
return t
} | go | func (fr *FileReader) UnixMtime() time.Time {
t, err := time.Parse(time.RFC3339, fr.ss.UnixMtime)
if err != nil {
return time.Time{}
}
return t
} | [
"func",
"(",
"fr",
"*",
"FileReader",
")",
"UnixMtime",
"(",
")",
"time",
".",
"Time",
"{",
"t",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"fr",
".",
"ss",
".",
"UnixMtime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"... | // UnixMtime returns the file schema's UnixMtime field, or the zero value. | [
"UnixMtime",
"returns",
"the",
"file",
"schema",
"s",
"UnixMtime",
"field",
"or",
"the",
"zero",
"value",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L155-L161 | train |
perkeep/perkeep | pkg/schema/filereader.go | ForeachChunk | func (fr *FileReader) ForeachChunk(ctx context.Context, fn func(schemaPath []blob.Ref, p BytesPart) error) error {
return fr.foreachChunk(ctx, fn, nil)
} | go | func (fr *FileReader) ForeachChunk(ctx context.Context, fn func(schemaPath []blob.Ref, p BytesPart) error) error {
return fr.foreachChunk(ctx, fn, nil)
} | [
"func",
"(",
"fr",
"*",
"FileReader",
")",
"ForeachChunk",
"(",
"ctx",
"context",
".",
"Context",
",",
"fn",
"func",
"(",
"schemaPath",
"[",
"]",
"blob",
".",
"Ref",
",",
"p",
"BytesPart",
")",
"error",
")",
"error",
"{",
"return",
"fr",
".",
"foreac... | // ForeachChunk calls fn for each chunk of fr, in order.
//
// The schemaPath argument will be the path from the "file" or "bytes"
// schema blob down to possibly other "bytes" schema blobs, the final
// one of which references the given BytesPart. The BytesPart will be
// the actual chunk. The fn function will not be ... | [
"ForeachChunk",
"calls",
"fn",
"for",
"each",
"chunk",
"of",
"fr",
"in",
"order",
".",
"The",
"schemaPath",
"argument",
"will",
"be",
"the",
"path",
"from",
"the",
"file",
"or",
"bytes",
"schema",
"blob",
"down",
"to",
"possibly",
"other",
"bytes",
"schema... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/filereader.go#L219-L221 | train |
perkeep/perkeep | internal/media/audio.go | HasID3v1Tag | func HasID3v1Tag(r readerutil.SizeReaderAt) (bool, error) {
if r.Size() < ID3v1TagLength {
return false, nil
}
buf := make([]byte, len(id3v1Magic))
if _, err := r.ReadAt(buf, r.Size()-ID3v1TagLength); err != nil {
return false, fmt.Errorf("Failed to read ID3v1 data: %v", err)
}
if bytes.Equal(buf, id3v1Magic... | go | func HasID3v1Tag(r readerutil.SizeReaderAt) (bool, error) {
if r.Size() < ID3v1TagLength {
return false, nil
}
buf := make([]byte, len(id3v1Magic))
if _, err := r.ReadAt(buf, r.Size()-ID3v1TagLength); err != nil {
return false, fmt.Errorf("Failed to read ID3v1 data: %v", err)
}
if bytes.Equal(buf, id3v1Magic... | [
"func",
"HasID3v1Tag",
"(",
"r",
"readerutil",
".",
"SizeReaderAt",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"r",
".",
"Size",
"(",
")",
"<",
"ID3v1TagLength",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"buf",
":=",
"make",
"(",
... | // HasID3v1Tag returns true if an ID3v1 tag is present at the end of r. | [
"HasID3v1Tag",
"returns",
"true",
"if",
"an",
"ID3v1",
"tag",
"is",
"present",
"at",
"the",
"end",
"of",
"r",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/media/audio.go#L38-L51 | train |
perkeep/perkeep | app/publisher/js/file.go | renderFile | func renderFile() {
var err error
theFic, err = newFileItemContainer(fileThumbnailHeight)
if err != nil {
fmt.Printf("error creating file container: %v\n", err)
return
}
if err := theFic.populate(); err != nil {
fmt.Printf("Error initializing file container: %v", err)
return
}
if err := theFic.render(); ... | go | func renderFile() {
var err error
theFic, err = newFileItemContainer(fileThumbnailHeight)
if err != nil {
fmt.Printf("error creating file container: %v\n", err)
return
}
if err := theFic.populate(); err != nil {
fmt.Printf("Error initializing file container: %v", err)
return
}
if err := theFic.render(); ... | [
"func",
"renderFile",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"theFic",
",",
"err",
"=",
"newFileItemContainer",
"(",
"fileThumbnailHeight",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
... | // renderFile creates a fileItemContainer, populates it, renders it, and
// binds the left and right arrow keys for to it for navigation. | [
"renderFile",
"creates",
"a",
"fileItemContainer",
"populates",
"it",
"renders",
"it",
"and",
"binds",
"the",
"left",
"and",
"right",
"arrow",
"keys",
"for",
"to",
"it",
"for",
"navigation",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/app/publisher/js/file.go#L58-L94 | train |
perkeep/perkeep | internal/closure/gendeps.go | GenDepsWithPath | func GenDepsWithPath(pathPrefix string, root http.FileSystem) ([]byte, error) {
d, err := root.Open("/")
if err != nil {
return nil, fmt.Errorf("Failed to open root of %v: %v", root, err)
}
fi, err := d.Stat()
if err != nil {
return nil, err
}
if !fi.IsDir() {
return nil, fmt.Errorf("root of %v is not a di... | go | func GenDepsWithPath(pathPrefix string, root http.FileSystem) ([]byte, error) {
d, err := root.Open("/")
if err != nil {
return nil, fmt.Errorf("Failed to open root of %v: %v", root, err)
}
fi, err := d.Stat()
if err != nil {
return nil, err
}
if !fi.IsDir() {
return nil, fmt.Errorf("root of %v is not a di... | [
"func",
"GenDepsWithPath",
"(",
"pathPrefix",
"string",
",",
"root",
"http",
".",
"FileSystem",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"d",
",",
"err",
":=",
"root",
".",
"Open",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // GenDepsWithPath is like GenDeps, but you can specify a path where the files are to be found at runtime relative to Closure's base.js. | [
"GenDepsWithPath",
"is",
"like",
"GenDeps",
"but",
"you",
"can",
"specify",
"a",
"path",
"where",
"the",
"files",
"are",
"to",
"be",
"found",
"at",
"runtime",
"relative",
"to",
"Closure",
"s",
"base",
".",
"js",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/closure/gendeps.go#L47-L91 | train |
perkeep/perkeep | internal/closure/gendeps.go | ParseDeps | func ParseDeps(r io.Reader) (providedBy map[string]string, requires map[string][]string, err error) {
providedBy = make(map[string]string)
requires = make(map[string][]string)
scanner := bufio.NewScanner(r)
for scanner.Scan() {
l := scanner.Text()
if strings.HasPrefix(l, "//") {
continue
}
if l == "" {
... | go | func ParseDeps(r io.Reader) (providedBy map[string]string, requires map[string][]string, err error) {
providedBy = make(map[string]string)
requires = make(map[string][]string)
scanner := bufio.NewScanner(r)
for scanner.Scan() {
l := scanner.Text()
if strings.HasPrefix(l, "//") {
continue
}
if l == "" {
... | [
"func",
"ParseDeps",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"providedBy",
"map",
"[",
"string",
"]",
"string",
",",
"requires",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"providedBy",
"=",
"make",
"(",
"map",
"... | // ParseDeps reads closure namespace dependency lines and
// returns a map giving the js file provider for each namespace,
// and a map giving the namespace dependencies for each namespace. | [
"ParseDeps",
"reads",
"closure",
"namespace",
"dependency",
"lines",
"and",
"returns",
"a",
"map",
"giving",
"the",
"js",
"file",
"provider",
"for",
"each",
"namespace",
"and",
"a",
"map",
"giving",
"the",
"namespace",
"dependencies",
"for",
"each",
"namespace",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/closure/gendeps.go#L162-L203 | train |
perkeep/perkeep | internal/closure/gendeps.go | DeepParseDeps | func DeepParseDeps(r io.Reader) (map[string][]string, error) {
providedBy, requires, err := ParseDeps(r)
if err != nil {
return nil, err
}
filesDeps := make(map[string][]string)
var deeperDeps func(namespace string) []string
deeperDeps = func(namespace string) []string {
if jsdeps, ok := filesDeps[namespace];... | go | func DeepParseDeps(r io.Reader) (map[string][]string, error) {
providedBy, requires, err := ParseDeps(r)
if err != nil {
return nil, err
}
filesDeps := make(map[string][]string)
var deeperDeps func(namespace string) []string
deeperDeps = func(namespace string) []string {
if jsdeps, ok := filesDeps[namespace];... | [
"func",
"DeepParseDeps",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"error",
")",
"{",
"providedBy",
",",
"requires",
",",
"err",
":=",
"ParseDeps",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // DeepParseDeps reads closure namespace dependency lines and
// returns a map giving all the required js files for each namespace. | [
"DeepParseDeps",
"reads",
"closure",
"namespace",
"dependency",
"lines",
"and",
"returns",
"a",
"map",
"giving",
"all",
"the",
"required",
"js",
"files",
"for",
"each",
"namespace",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/closure/gendeps.go#L207-L228 | train |
perkeep/perkeep | pkg/types/clientconfig/config.go | Alias | func (conf *Config) Alias(server string) string {
longestMatch := ""
serverAlias := ""
for alias, serverConf := range conf.Servers {
if strings.HasPrefix(server, serverConf.Server) {
if len(serverConf.Server) > len(longestMatch) {
longestMatch = serverConf.Server
serverAlias = alias
}
}
}
return ... | go | func (conf *Config) Alias(server string) string {
longestMatch := ""
serverAlias := ""
for alias, serverConf := range conf.Servers {
if strings.HasPrefix(server, serverConf.Server) {
if len(serverConf.Server) > len(longestMatch) {
longestMatch = serverConf.Server
serverAlias = alias
}
}
}
return ... | [
"func",
"(",
"conf",
"*",
"Config",
")",
"Alias",
"(",
"server",
"string",
")",
"string",
"{",
"longestMatch",
":=",
"\"",
"\"",
"\n",
"serverAlias",
":=",
"\"",
"\"",
"\n",
"for",
"alias",
",",
"serverConf",
":=",
"range",
"conf",
".",
"Servers",
"{",... | // Alias returns the alias of the server from conf that matches server, or the
// empty string if no match. A match means the server from the config is a
// prefix of the input server. The longest match prevails. | [
"Alias",
"returns",
"the",
"alias",
"of",
"the",
"server",
"from",
"conf",
"that",
"matches",
"server",
"or",
"the",
"empty",
"string",
"if",
"no",
"match",
".",
"A",
"match",
"means",
"the",
"server",
"from",
"the",
"config",
"is",
"a",
"prefix",
"of",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/types/clientconfig/config.go#L52-L64 | train |
perkeep/perkeep | pkg/blobserver/replica/replica.go | StatBlobs | func (sto *replicaStorage) StatBlobs(ctx context.Context, blobs []blob.Ref, fn func(blob.SizedRef) error) error {
var (
mu sync.Mutex // serializes calls to fn, guards need
need = make(map[blob.Ref]bool)
failed bool
)
for _, br := range blobs {
need[br] = true
}
group, ctx := errgroup.WithContext(ct... | go | func (sto *replicaStorage) StatBlobs(ctx context.Context, blobs []blob.Ref, fn func(blob.SizedRef) error) error {
var (
mu sync.Mutex // serializes calls to fn, guards need
need = make(map[blob.Ref]bool)
failed bool
)
for _, br := range blobs {
need[br] = true
}
group, ctx := errgroup.WithContext(ct... | [
"func",
"(",
"sto",
"*",
"replicaStorage",
")",
"StatBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
",",
"fn",
"func",
"(",
"blob",
".",
"SizedRef",
")",
"error",
")",
"error",
"{",
"var",
"(",
"mu",
"syn... | // StatBlobs stats all read replicas. | [
"StatBlobs",
"stats",
"all",
"read",
"replicas",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/replica/replica.go#L149-L185 | train |
perkeep/perkeep | pkg/importer/gphotos/gphotos.go | CallbackURLParameters | func (im imp) CallbackURLParameters(acctRef blob.Ref) url.Values {
return url.Values{}
} | go | func (im imp) CallbackURLParameters(acctRef blob.Ref) url.Values {
return url.Values{}
} | [
"func",
"(",
"im",
"imp",
")",
"CallbackURLParameters",
"(",
"acctRef",
"blob",
".",
"Ref",
")",
"url",
".",
"Values",
"{",
"return",
"url",
".",
"Values",
"{",
"}",
"\n",
"}"
] | // CallbackURLParameters returns the needed callback parameters - empty for Google gphotos. | [
"CallbackURLParameters",
"returns",
"the",
"needed",
"callback",
"parameters",
"-",
"empty",
"for",
"Google",
"gphotos",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/gphotos/gphotos.go#L149-L151 | train |
perkeep/perkeep | pkg/importer/gphotos/gphotos.go | decodeToken | func decodeToken(encoded string) *oauth2.Token {
t := new(oauth2.Token)
f := strings.Fields(encoded)
if len(f) > 0 {
t.AccessToken = f[0]
}
if len(f) > 1 {
t.RefreshToken = f[1]
}
if len(f) > 2 && f[2] != "0" {
sec, err := strconv.ParseInt(f[2], 10, 64)
if err == nil {
t.Expiry = time.Unix(sec, 0)
}... | go | func decodeToken(encoded string) *oauth2.Token {
t := new(oauth2.Token)
f := strings.Fields(encoded)
if len(f) > 0 {
t.AccessToken = f[0]
}
if len(f) > 1 {
t.RefreshToken = f[1]
}
if len(f) > 2 && f[2] != "0" {
sec, err := strconv.ParseInt(f[2], 10, 64)
if err == nil {
t.Expiry = time.Unix(sec, 0)
}... | [
"func",
"decodeToken",
"(",
"encoded",
"string",
")",
"*",
"oauth2",
".",
"Token",
"{",
"t",
":=",
"new",
"(",
"oauth2",
".",
"Token",
")",
"\n",
"f",
":=",
"strings",
".",
"Fields",
"(",
"encoded",
")",
"\n",
"if",
"len",
"(",
"f",
")",
">",
"0"... | // decodeToken parses an access token, refresh token, and optional
// expiry unix timestamp separated by spaces into an oauth2.Token.
// It returns as much as it can. | [
"decodeToken",
"parses",
"an",
"access",
"token",
"refresh",
"token",
"and",
"optional",
"expiry",
"unix",
"timestamp",
"separated",
"by",
"spaces",
"into",
"an",
"oauth2",
".",
"Token",
".",
"It",
"returns",
"as",
"much",
"as",
"it",
"can",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/importer/gphotos/gphotos.go#L214-L230 | train |
perkeep/perkeep | pkg/blobserver/encrypt/encrypt.go | encryptBlob | func (s *storage) encryptBlob(ciphertext, plaintext []byte) []byte {
if s.key == [32]byte{} {
// Safety check, we really don't want this to happen.
panic("no passphrase set")
}
var nonce [24]byte
s.randNonce(&nonce)
ciphertext = append(ciphertext, version)
ciphertext = append(ciphertext, nonce[:]...)
return ... | go | func (s *storage) encryptBlob(ciphertext, plaintext []byte) []byte {
if s.key == [32]byte{} {
// Safety check, we really don't want this to happen.
panic("no passphrase set")
}
var nonce [24]byte
s.randNonce(&nonce)
ciphertext = append(ciphertext, version)
ciphertext = append(ciphertext, nonce[:]...)
return ... | [
"func",
"(",
"s",
"*",
"storage",
")",
"encryptBlob",
"(",
"ciphertext",
",",
"plaintext",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"s",
".",
"key",
"==",
"[",
"32",
"]",
"byte",
"{",
"}",
"{",
"// Safety check, we really don't want this to ha... | // encryptBlob encrypts plaintext and appends the result to ciphertext,
// which must not overlap plaintext. | [
"encryptBlob",
"encrypts",
"plaintext",
"and",
"appends",
"the",
"result",
"to",
"ciphertext",
"which",
"must",
"not",
"overlap",
"plaintext",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/encrypt.go#L123-L133 | train |
perkeep/perkeep | pkg/blobserver/encrypt/encrypt.go | decryptBlob | func (s *storage) decryptBlob(plaintext, ciphertext []byte) ([]byte, error) {
if len(ciphertext) < overhead {
return nil, errors.New("blob too short to be encrypted")
}
if ciphertext[0] != version {
return nil, errors.New("unknown encrypted blob version")
}
var nonce [24]byte
copy(nonce[:], ciphertext[1:])
p... | go | func (s *storage) decryptBlob(plaintext, ciphertext []byte) ([]byte, error) {
if len(ciphertext) < overhead {
return nil, errors.New("blob too short to be encrypted")
}
if ciphertext[0] != version {
return nil, errors.New("unknown encrypted blob version")
}
var nonce [24]byte
copy(nonce[:], ciphertext[1:])
p... | [
"func",
"(",
"s",
"*",
"storage",
")",
"decryptBlob",
"(",
"plaintext",
",",
"ciphertext",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"ciphertext",
")",
"<",
"overhead",
"{",
"return",
"nil",
",",
"error... | // decryptBlob decrypts ciphertext and appends the result to plaintext,
// which must not overlap ciphertext. | [
"decryptBlob",
"decrypts",
"ciphertext",
"and",
"appends",
"the",
"result",
"to",
"plaintext",
"which",
"must",
"not",
"overlap",
"ciphertext",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/encrypt/encrypt.go#L137-L151 | train |
perkeep/perkeep | pkg/sorted/sqlite/dbschema.go | InitDB | func InitDB(path string) error {
db, err := sql.Open("sqlite3", path)
if err != nil {
return err
}
defer db.Close()
for _, tableSQL := range SQLCreateTables() {
if _, err := db.Exec(tableSQL); err != nil {
return err
}
}
// Use Write Ahead Logging which improves SQLite concurrency.
// Requires SQLite ... | go | func InitDB(path string) error {
db, err := sql.Open("sqlite3", path)
if err != nil {
return err
}
defer db.Close()
for _, tableSQL := range SQLCreateTables() {
if _, err := db.Exec(tableSQL); err != nil {
return err
}
}
// Use Write Ahead Logging which improves SQLite concurrency.
// Requires SQLite ... | [
"func",
"InitDB",
"(",
"path",
"string",
")",
"error",
"{",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"db",
".",
"Close",
"(",
... | // InitDB creates a new sqlite database based on the file at path. | [
"InitDB",
"creates",
"a",
"new",
"sqlite",
"database",
"based",
"on",
"the",
"file",
"at",
"path",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/sorted/sqlite/dbschema.go#L49-L78 | train |
perkeep/perkeep | dev/devcam/hook.go | hookGofmt | func (c *hookCmd) hookGofmt() error {
if os.Getenv("GIT_GOFMT_HOOK") == "off" {
printf("gofmt disabled by $GIT_GOFMT_HOOK=off\n")
return nil
}
files, err := c.runGofmt()
if err != nil {
printf("gofmt hook reported errors:\n\t%v\n", strings.Replace(strings.TrimSpace(err.Error()), "\n", "\n\t", -1))
return e... | go | func (c *hookCmd) hookGofmt() error {
if os.Getenv("GIT_GOFMT_HOOK") == "off" {
printf("gofmt disabled by $GIT_GOFMT_HOOK=off\n")
return nil
}
files, err := c.runGofmt()
if err != nil {
printf("gofmt hook reported errors:\n\t%v\n", strings.Replace(strings.TrimSpace(err.Error()), "\n", "\n\t", -1))
return e... | [
"func",
"(",
"c",
"*",
"hookCmd",
")",
"hookGofmt",
"(",
")",
"error",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"==",
"\"",
"\"",
"{",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"files",
",",
... | // hookGofmt runs a gofmt check on the local files matching the files in the
// git staging area.
// An error is returned if something went wrong or if some of the files need
// gofmting. In the latter case, the instruction is printed. | [
"hookGofmt",
"runs",
"a",
"gofmt",
"check",
"on",
"the",
"local",
"files",
"matching",
"the",
"files",
"in",
"the",
"git",
"staging",
"area",
".",
"An",
"error",
"is",
"returned",
"if",
"something",
"went",
"wrong",
"or",
"if",
"some",
"of",
"the",
"file... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L228-L245 | train |
perkeep/perkeep | dev/devcam/hook.go | runGofmt | func (c *hookCmd) runGofmt() (files []string, err error) {
repo, err := repoRoot()
if err != nil {
return nil, err
}
if !strings.HasSuffix(repo, string(filepath.Separator)) {
repo += string(filepath.Separator)
}
out, err := cmdOutputDirErr(".", "git", "diff-index", "--name-only", "--diff-filter=ACM", "--cach... | go | func (c *hookCmd) runGofmt() (files []string, err error) {
repo, err := repoRoot()
if err != nil {
return nil, err
}
if !strings.HasSuffix(repo, string(filepath.Separator)) {
repo += string(filepath.Separator)
}
out, err := cmdOutputDirErr(".", "git", "diff-index", "--name-only", "--diff-filter=ACM", "--cach... | [
"func",
"(",
"c",
"*",
"hookCmd",
")",
"runGofmt",
"(",
")",
"(",
"files",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"repo",
",",
"err",
":=",
"repoRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n"... | // runGofmt runs the external gofmt command over the local version of staged files.
// It returns the files that need gofmting. | [
"runGofmt",
"runs",
"the",
"external",
"gofmt",
"command",
"over",
"the",
"local",
"version",
"of",
"staged",
"files",
".",
"It",
"returns",
"the",
"files",
"that",
"need",
"gofmting",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L260-L307 | train |
perkeep/perkeep | dev/devcam/hook.go | nonBlankLines | func nonBlankLines(text string) []string {
var out []string
for _, s := range lines(text) {
if strings.TrimSpace(s) != "" {
out = append(out, s)
}
}
return out
} | go | func nonBlankLines(text string) []string {
var out []string
for _, s := range lines(text) {
if strings.TrimSpace(s) != "" {
out = append(out, s)
}
}
return out
} | [
"func",
"nonBlankLines",
"(",
"text",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"lines",
"(",
"text",
")",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
"!=",
"\"... | // nonBlankLines returns the non-blank lines in text. | [
"nonBlankLines",
"returns",
"the",
"non",
"-",
"blank",
"lines",
"in",
"text",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L322-L330 | train |
perkeep/perkeep | dev/devcam/hook.go | filter | func filter(f func(string) bool, list []string) []string {
var out []string
for _, x := range list {
if f(x) {
out = append(out, x)
}
}
return out
} | go | func filter(f func(string) bool, list []string) []string {
var out []string
for _, x := range list {
if f(x) {
out = append(out, x)
}
}
return out
} | [
"func",
"filter",
"(",
"f",
"func",
"(",
"string",
")",
"bool",
",",
"list",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"x",
":=",
"range",
"list",
"{",
"if",
"f",
"(",
"x",
")",... | // filter returns the elements in list satisfying f. | [
"filter",
"returns",
"the",
"elements",
"in",
"list",
"satisfying",
"f",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/dev/devcam/hook.go#L333-L341 | train |
perkeep/perkeep | internal/osutil/osutil.go | DirExists | func DirExists(dir string) bool {
fi, err := os.Stat(dir)
return err == nil && fi.IsDir()
} | go | func DirExists(dir string) bool {
fi, err := os.Stat(dir)
return err == nil && fi.IsDir()
} | [
"func",
"DirExists",
"(",
"dir",
"string",
")",
"bool",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"return",
"err",
"==",
"nil",
"&&",
"fi",
".",
"IsDir",
"(",
")",
"\n",
"}"
] | // DirExists reports whether dir exists. Errors are ignored and are
// reported as false. | [
"DirExists",
"reports",
"whether",
"dir",
"exists",
".",
"Errors",
"are",
"ignored",
"and",
"are",
"reported",
"as",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/osutil/osutil.go#L33-L36 | train |
perkeep/perkeep | pkg/types/camtypes/errors.go | Err | func Err(key string) error {
v, ok := camErrors[key]
if !ok {
panic(fmt.Sprintf("unknown/unregistered error key %v", key))
}
return v
} | go | func Err(key string) error {
v, ok := camErrors[key]
if !ok {
panic(fmt.Sprintf("unknown/unregistered error key %v", key))
}
return v
} | [
"func",
"Err",
"(",
"key",
"string",
")",
"error",
"{",
"v",
",",
"ok",
":=",
"camErrors",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"key",
")",
")",
"\n",
"}",
"\n",
"return",
"v"... | // Err returns the error registered for key.
// It panics for an unregistered key. | [
"Err",
"returns",
"the",
"error",
"registered",
"for",
"key",
".",
"It",
"panics",
"for",
"an",
"unregistered",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/types/camtypes/errors.go#L68-L74 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | IsDir | func IsDir(dir string) (bool, error) {
_, err := os.Stat(filepath.Join(dir, defaultIndexFile))
if os.IsNotExist(err) {
return false, nil
}
return err == nil, err
} | go | func IsDir(dir string) (bool, error) {
_, err := os.Stat(filepath.Join(dir, defaultIndexFile))
if os.IsNotExist(err) {
return false, nil
}
return err == nil, err
} | [
"func",
"IsDir",
"(",
"dir",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"defaultIndexFile",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err... | // IsDir reports whether dir is a diskpacked directory. | [
"IsDir",
"reports",
"whether",
"dir",
"is",
"a",
"diskpacked",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L115-L121 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | New | func New(dir string) (blobserver.Storage, error) {
var maxSize int64
if ok, _ := IsDir(dir); ok {
// TODO: detect existing max size from size of files, if obvious,
// and set maxSize to that?
}
return newStorage(dir, maxSize, nil)
} | go | func New(dir string) (blobserver.Storage, error) {
var maxSize int64
if ok, _ := IsDir(dir); ok {
// TODO: detect existing max size from size of files, if obvious,
// and set maxSize to that?
}
return newStorage(dir, maxSize, nil)
} | [
"func",
"New",
"(",
"dir",
"string",
")",
"(",
"blobserver",
".",
"Storage",
",",
"error",
")",
"{",
"var",
"maxSize",
"int64",
"\n",
"if",
"ok",
",",
"_",
":=",
"IsDir",
"(",
"dir",
")",
";",
"ok",
"{",
"// TODO: detect existing max size from size of file... | // New returns a diskpacked storage implementation, adding blobs to
// the provided directory. It doesn't delete any existing blob pack
// files. | [
"New",
"returns",
"a",
"diskpacked",
"storage",
"implementation",
"adding",
"blobs",
"to",
"the",
"provided",
"directory",
".",
"It",
"doesn",
"t",
"delete",
"any",
"existing",
"blob",
"pack",
"files",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L126-L133 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | newIndex | func newIndex(root string, indexConf jsonconfig.Obj) (sorted.KeyValue, error) {
if len(indexConf) > 0 {
return sorted.NewKeyValueMaybeWipe(indexConf)
}
return sorted.NewKeyValueMaybeWipe(jsonconfig.Obj{
"type": defaultIndexType,
"file": filepath.Join(root, defaultIndexFile),
})
} | go | func newIndex(root string, indexConf jsonconfig.Obj) (sorted.KeyValue, error) {
if len(indexConf) > 0 {
return sorted.NewKeyValueMaybeWipe(indexConf)
}
return sorted.NewKeyValueMaybeWipe(jsonconfig.Obj{
"type": defaultIndexType,
"file": filepath.Join(root, defaultIndexFile),
})
} | [
"func",
"newIndex",
"(",
"root",
"string",
",",
"indexConf",
"jsonconfig",
".",
"Obj",
")",
"(",
"sorted",
".",
"KeyValue",
",",
"error",
")",
"{",
"if",
"len",
"(",
"indexConf",
")",
">",
"0",
"{",
"return",
"sorted",
".",
"NewKeyValueMaybeWipe",
"(",
... | // newIndex returns a new sorted.KeyValue, using either the given config, or the default. | [
"newIndex",
"returns",
"a",
"new",
"sorted",
".",
"KeyValue",
"using",
"either",
"the",
"given",
"config",
"or",
"the",
"default",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L136-L144 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | openForRead | func (s *storage) openForRead(n int) error {
if n > len(s.fds) {
panic(fmt.Sprintf("openForRead called out of order got %d, expected %d", n, len(s.fds)))
}
fn := s.filename(n)
f, err := os.Open(fn)
if err != nil {
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for read %q", fn)
s.... | go | func (s *storage) openForRead(n int) error {
if n > len(s.fds) {
panic(fmt.Sprintf("openForRead called out of order got %d, expected %d", n, len(s.fds)))
}
fn := s.filename(n)
f, err := os.Open(fn)
if err != nil {
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for read %q", fn)
s.... | [
"func",
"(",
"s",
"*",
"storage",
")",
"openForRead",
"(",
"n",
"int",
")",
"error",
"{",
"if",
"n",
">",
"len",
"(",
"s",
".",
"fds",
")",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"n",
",",
"len",
"(",
"s",
".",
"fds... | // openForRead will open pack file n for read and keep a handle to it in
// s.fds. os.IsNotExist returned if n >= the number of pack files in s.root.
// This function is not thread safe, s.mu should be locked by the caller. | [
"openForRead",
"will",
"open",
"pack",
"file",
"n",
"for",
"read",
"and",
"keep",
"a",
"handle",
"to",
"it",
"in",
"s",
".",
"fds",
".",
"os",
".",
"IsNotExist",
"returned",
"if",
"n",
">",
"=",
"the",
"number",
"of",
"pack",
"files",
"in",
"s",
".... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L212-L226 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | openForWrite | func (s *storage) openForWrite(n int) error {
fn := s.filename(n)
l, err := lock.Lock(fn + ".lock")
if err != nil {
return err
}
f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
l.Close()
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for write %q", fn)
s.... | go | func (s *storage) openForWrite(n int) error {
fn := s.filename(n)
l, err := lock.Lock(fn + ".lock")
if err != nil {
return err
}
f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
l.Close()
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for write %q", fn)
s.... | [
"func",
"(",
"s",
"*",
"storage",
")",
"openForWrite",
"(",
"n",
"int",
")",
"error",
"{",
"fn",
":=",
"s",
".",
"filename",
"(",
"n",
")",
"\n",
"l",
",",
"err",
":=",
"lock",
".",
"Lock",
"(",
"fn",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
... | // openForWrite will create or open pack file n for writes, create a lock
// visible external to the process and seek to the end of the file ready for
// appending new data.
// This function is not thread safe, s.mu should be locked by the caller. | [
"openForWrite",
"will",
"create",
"or",
"open",
"pack",
"file",
"n",
"for",
"writes",
"create",
"a",
"lock",
"visible",
"external",
"to",
"the",
"process",
"and",
"seek",
"to",
"the",
"end",
"of",
"the",
"file",
"ready",
"for",
"appending",
"new",
"data",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L232-L256 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | closePack | func (s *storage) closePack() error {
var err error
if s.writer != nil {
err = s.writer.Close()
openFdsVar.Add(s.root, -1)
s.writer = nil
}
if s.writeLock != nil {
lerr := s.writeLock.Close()
if err == nil {
err = lerr
}
s.writeLock = nil
}
return err
} | go | func (s *storage) closePack() error {
var err error
if s.writer != nil {
err = s.writer.Close()
openFdsVar.Add(s.root, -1)
s.writer = nil
}
if s.writeLock != nil {
lerr := s.writeLock.Close()
if err == nil {
err = lerr
}
s.writeLock = nil
}
return err
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"closePack",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"s",
".",
"writer",
"!=",
"nil",
"{",
"err",
"=",
"s",
".",
"writer",
".",
"Close",
"(",
")",
"\n",
"openFdsVar",
".",
"Add",
"(",
"s... | // closePack opens any pack file currently open for writing. | [
"closePack",
"opens",
"any",
"pack",
"file",
"currently",
"open",
"for",
"writing",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L259-L274 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | nextPack | func (s *storage) nextPack() error {
debug.Println("diskpacked: nextPack")
s.size = 0
if err := s.closePack(); err != nil {
return err
}
n := len(s.fds)
if err := s.openForWrite(n); err != nil {
return err
}
return s.openForRead(n)
} | go | func (s *storage) nextPack() error {
debug.Println("diskpacked: nextPack")
s.size = 0
if err := s.closePack(); err != nil {
return err
}
n := len(s.fds)
if err := s.openForWrite(n); err != nil {
return err
}
return s.openForRead(n)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"nextPack",
"(",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"s",
".",
"size",
"=",
"0",
"\n",
"if",
"err",
":=",
"s",
".",
"closePack",
"(",
")",
";",
"err",
"!=",
"nil",
"{"... | // nextPack will close the current writer and release its lock if open,
// open the next pack file in sequence for writing, grab its lock, set it
// to the currently active writer, and open another copy for read-only use.
// This function is not thread safe, s.mu should be locked by the caller. | [
"nextPack",
"will",
"close",
"the",
"current",
"writer",
"and",
"release",
"its",
"lock",
"if",
"open",
"open",
"the",
"next",
"pack",
"file",
"in",
"sequence",
"for",
"writing",
"grab",
"its",
"lock",
"set",
"it",
"to",
"the",
"currently",
"active",
"writ... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L280-L291 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | openAllPacks | func (s *storage) openAllPacks() error {
debug.Println("diskpacked: openAllPacks")
n := 0
for {
err := s.openForRead(n)
if os.IsNotExist(err) {
break
}
if err != nil {
return err
}
n++
}
if n == 0 {
// If no pack files are found, we create one open for read and write.
return s.nextPack()
}
... | go | func (s *storage) openAllPacks() error {
debug.Println("diskpacked: openAllPacks")
n := 0
for {
err := s.openForRead(n)
if os.IsNotExist(err) {
break
}
if err != nil {
return err
}
n++
}
if n == 0 {
// If no pack files are found, we create one open for read and write.
return s.nextPack()
}
... | [
"func",
"(",
"s",
"*",
"storage",
")",
"openAllPacks",
"(",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"n",
":=",
"0",
"\n",
"for",
"{",
"err",
":=",
"s",
".",
"openForRead",
"(",
"n",
")",
"\n",
"if",
"os",
".",
... | // openAllPacks opens read-only each pack file in s.root, populating s.fds.
// The latest pack file will also have a writable handle opened.
// This function is not thread safe, s.mu should be locked by the caller. | [
"openAllPacks",
"opens",
"read",
"-",
"only",
"each",
"pack",
"file",
"in",
"s",
".",
"root",
"populating",
"s",
".",
"fds",
".",
"The",
"latest",
"pack",
"file",
"will",
"also",
"have",
"a",
"writable",
"handle",
"opened",
".",
"This",
"function",
"is",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L296-L317 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | Close | func (s *storage) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
var closeErr error
s.closed = true
if err := s.index.Close(); err != nil {
log.Println("diskpacked: closing index:", err)
}
for _, f := range s.fds {
err := f.Close()
openFdsVar.Add(s.root, -1)
if err != nil ... | go | func (s *storage) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
var closeErr error
s.closed = true
if err := s.index.Close(); err != nil {
log.Println("diskpacked: closing index:", err)
}
for _, f := range s.fds {
err := f.Close()
openFdsVar.Add(s.root, -1)
if err != nil ... | [
"func",
"(",
"s",
"*",
"storage",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"v... | // Close index and all opened fds, with locking. | [
"Close",
"index",
"and",
"all",
"opened",
"fds",
"with",
"locking",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L320-L342 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | fetch | func (s *storage) fetch(ctx context.Context, br blob.Ref, offset, length int64) (rc io.ReadCloser, size uint32, err error) {
meta, err := s.meta(br)
if err != nil {
return nil, 0, err
}
if meta.file >= len(s.fds) {
return nil, 0, fmt.Errorf("diskpacked: attempt to fetch blob from out of range pack file %d > %d... | go | func (s *storage) fetch(ctx context.Context, br blob.Ref, offset, length int64) (rc io.ReadCloser, size uint32, err error) {
meta, err := s.meta(br)
if err != nil {
return nil, 0, err
}
if meta.file >= len(s.fds) {
return nil, 0, fmt.Errorf("diskpacked: attempt to fetch blob from out of range pack file %d > %d... | [
"func",
"(",
"s",
"*",
"storage",
")",
"fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"offset",
",",
"length",
"int64",
")",
"(",
"rc",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
... | // length of -1 means all | [
"length",
"of",
"-",
"1",
"means",
"all"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L357-L397 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | RemoveBlobs | func (s *storage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
batch := s.index.BeginBatch()
var wg syncutil.Group
for _, br := range blobs {
br := br
removeGate.Start()
batch.Delete(br.String())
wg.Go(func() error {
defer removeGate.Done()
if err := s.delete(br); err != nil && err != os.... | go | func (s *storage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
batch := s.index.BeginBatch()
var wg syncutil.Group
for _, br := range blobs {
br := br
removeGate.Start()
batch.Delete(br.String())
wg.Go(func() error {
defer removeGate.Done()
if err := s.delete(br); err != nil && err != os.... | [
"func",
"(",
"s",
"*",
"storage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"batch",
":=",
"s",
".",
"index",
".",
"BeginBatch",
"(",
")",
"\n",
"var",
"wg",
"syncutil"... | // RemoveBlobs removes the blobs from index and pads data with zero bytes | [
"RemoveBlobs",
"removes",
"the",
"blobs",
"from",
"index",
"and",
"pads",
"data",
"with",
"zero",
"bytes"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L406-L427 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | StreamBlobs | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) error {
defer close(dest)
fileNum, offset, err := parseContToken(contToken)
if err != nil {
return errors.New("diskpacked: invalid continuation token")
}
debug.Printf("Continuing blob streaming from pack %s... | go | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) error {
defer close(dest)
fileNum, offset, err := parseContToken(contToken)
if err != nil {
return errors.New("diskpacked: invalid continuation token")
}
debug.Printf("Continuing blob streaming from pack %s... | [
"func",
"(",
"s",
"*",
"storage",
")",
"StreamBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blobserver",
".",
"BlobAndToken",
",",
"contToken",
"string",
")",
"error",
"{",
"defer",
"close",
"(",
"dest",
")",
"\n\n",
"fileNum... | // StreamBlobs Implements the blobserver.StreamBlobs interface. | [
"StreamBlobs",
"Implements",
"the",
"blobserver",
".",
"StreamBlobs",
"interface",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L529-L635 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | append | func (s *storage) append(br blob.SizedRef, r io.Reader) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return errors.New("diskpacked: write to closed storage")
}
// to be able to undo the append
origOffset := s.size
fn := s.writer.Name()
n, err := fmt.Fprintf(s.writer, "[%v %v]", br.Ref.String(), br.... | go | func (s *storage) append(br blob.SizedRef, r io.Reader) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return errors.New("diskpacked: write to closed storage")
}
// to be able to undo the append
origOffset := s.size
fn := s.writer.Name()
n, err := fmt.Fprintf(s.writer, "[%v %v]", br.Ref.String(), br.... | [
"func",
"(",
"s",
"*",
"storage",
")",
"append",
"(",
"br",
"blob",
".",
"SizedRef",
",",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
... | // append writes the provided blob to the current data file. | [
"append",
"writes",
"the",
"provided",
"blob",
"to",
"the",
"current",
"data",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L661-L722 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | meta | func (s *storage) meta(br blob.Ref) (m blobMeta, err error) {
ms, err := s.index.Get(br.String())
if err != nil {
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
return
}
m, ok := parseBlobMeta(ms)
if !ok {
err = fmt.Errorf("diskpacked: bad blob metadata: %q", ms)
}
return
} | go | func (s *storage) meta(br blob.Ref) (m blobMeta, err error) {
ms, err := s.index.Get(br.String())
if err != nil {
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
return
}
m, ok := parseBlobMeta(ms)
if !ok {
err = fmt.Errorf("diskpacked: bad blob metadata: %q", ms)
}
return
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"meta",
"(",
"br",
"blob",
".",
"Ref",
")",
"(",
"m",
"blobMeta",
",",
"err",
"error",
")",
"{",
"ms",
",",
"err",
":=",
"s",
".",
"index",
".",
"Get",
"(",
"br",
".",
"String",
"(",
")",
")",
"\n",
"i... | // meta fetches the metadata for the specified blob from the index. | [
"meta",
"fetches",
"the",
"metadata",
"for",
"the",
"specified",
"blob",
"from",
"the",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L725-L738 | train |
perkeep/perkeep | cmd/pk-put/files.go | DumpStats | func DumpStats(sr *statspkg.Receiver, destFile string) {
sr.Lock()
defer sr.Unlock()
f, err := os.Create(destFile)
if err != nil {
log.Fatal(err)
}
var sum int64
for _, size := range sr.Have {
fmt.Fprintf(f, "%d\n", size)
}
fmt.Printf("In-memory blob stats: %d blobs, %d bytes\n", len(sr.Have), sum)
err... | go | func DumpStats(sr *statspkg.Receiver, destFile string) {
sr.Lock()
defer sr.Unlock()
f, err := os.Create(destFile)
if err != nil {
log.Fatal(err)
}
var sum int64
for _, size := range sr.Have {
fmt.Fprintf(f, "%d\n", size)
}
fmt.Printf("In-memory blob stats: %d blobs, %d bytes\n", len(sr.Have), sum)
err... | [
"func",
"DumpStats",
"(",
"sr",
"*",
"statspkg",
".",
"Receiver",
",",
"destFile",
"string",
")",
"{",
"sr",
".",
"Lock",
"(",
")",
"\n",
"defer",
"sr",
".",
"Unlock",
"(",
")",
"\n\n",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"destFile",
... | // DumpStats creates the destFile and writes a line per received blob,
// with its blob size. | [
"DumpStats",
"creates",
"the",
"destFile",
"and",
"writes",
"a",
"line",
"per",
"received",
"blob",
"with",
"its",
"blob",
"size",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/files.go#L310-L329 | train |
perkeep/perkeep | cmd/pk-put/files.go | statReceiver | func (up *Uploader) statReceiver(n *node) blobserver.StatReceiver {
statReceiver := up.altStatReceiver
if statReceiver == nil {
// TODO(mpl): simplify the altStatReceiver situation as well,
// see TODO in cmd/pk-put/uploader.go
statReceiver = up.Client
}
if android.IsChild() && n != nil && n.fi.Mode()&os.Mode... | go | func (up *Uploader) statReceiver(n *node) blobserver.StatReceiver {
statReceiver := up.altStatReceiver
if statReceiver == nil {
// TODO(mpl): simplify the altStatReceiver situation as well,
// see TODO in cmd/pk-put/uploader.go
statReceiver = up.Client
}
if android.IsChild() && n != nil && n.fi.Mode()&os.Mode... | [
"func",
"(",
"up",
"*",
"Uploader",
")",
"statReceiver",
"(",
"n",
"*",
"node",
")",
"blobserver",
".",
"StatReceiver",
"{",
"statReceiver",
":=",
"up",
".",
"altStatReceiver",
"\n",
"if",
"statReceiver",
"==",
"nil",
"{",
"// TODO(mpl): simplify the altStatRece... | // statReceiver returns the StatReceiver used for checking for and uploading blobs.
//
// The optional provided node is only used for conditionally printing out status info to stdout. | [
"statReceiver",
"returns",
"the",
"StatReceiver",
"used",
"for",
"checking",
"for",
"and",
"uploading",
"blobs",
".",
"The",
"optional",
"provided",
"node",
"is",
"only",
"used",
"for",
"conditionally",
"printing",
"out",
"status",
"info",
"to",
"stdout",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/files.go#L435-L446 | train |
perkeep/perkeep | cmd/pk-put/files.go | NewTreeUpload | func (up *Uploader) NewTreeUpload(dir string) *TreeUpload {
tu := up.NewRootlessTreeUpload()
tu.rootless = false
tu.base = dir
return tu
} | go | func (up *Uploader) NewTreeUpload(dir string) *TreeUpload {
tu := up.NewRootlessTreeUpload()
tu.rootless = false
tu.base = dir
return tu
} | [
"func",
"(",
"up",
"*",
"Uploader",
")",
"NewTreeUpload",
"(",
"dir",
"string",
")",
"*",
"TreeUpload",
"{",
"tu",
":=",
"up",
".",
"NewRootlessTreeUpload",
"(",
")",
"\n",
"tu",
".",
"rootless",
"=",
"false",
"\n",
"tu",
".",
"base",
"=",
"dir",
"\n... | // NewTreeUpload returns a TreeUpload. It doesn't begin uploading any files until a
// call to Start | [
"NewTreeUpload",
"returns",
"a",
"TreeUpload",
".",
"It",
"doesn",
"t",
"begin",
"uploading",
"any",
"files",
"until",
"a",
"call",
"to",
"Start"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/files.go#L801-L806 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | ReceiveBlob | func (sto *overlayStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
sb, err = sto.upper.ReceiveBlob(ctx, br, src)
if err == nil && sto.deleted != nil {
err = sto.deleted.Delete(br.String())
}
return sb, err
} | go | func (sto *overlayStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
sb, err = sto.upper.ReceiveBlob(ctx, br, src)
if err == nil && sto.deleted != nil {
err = sto.deleted.Delete(br.String())
}
return sb, err
} | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"ReceiveBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"src",
"io",
".",
"Reader",
")",
"(",
"sb",
"blob",
".",
"SizedRef",
",",
"err",
"error",
")",
"{",
"sb",
",",... | // ReceiveBlob stores received blobs on the upper layer. | [
"ReceiveBlob",
"stores",
"received",
"blobs",
"on",
"the",
"upper",
"layer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L120-L126 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | RemoveBlobs | func (sto *overlayStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if sto.deleted == nil {
return blobserver.ErrNotImplemented
}
err := sto.upper.RemoveBlobs(ctx, blobs)
if err != nil {
return err
}
m := sto.deleted.BeginBatch()
for _, br := range blobs {
m.Set(br.String(), "1")
}
re... | go | func (sto *overlayStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if sto.deleted == nil {
return blobserver.ErrNotImplemented
}
err := sto.upper.RemoveBlobs(ctx, blobs)
if err != nil {
return err
}
m := sto.deleted.BeginBatch()
for _, br := range blobs {
m.Set(br.String(), "1")
}
re... | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"if",
"sto",
".",
"deleted",
"==",
"nil",
"{",
"return",
"blobserver",
".",
"ErrNotImpl... | // RemoveBlobs marks the given blobs as deleted, and removes them if they are in the upper layer. | [
"RemoveBlobs",
"marks",
"the",
"given",
"blobs",
"as",
"deleted",
"and",
"removes",
"them",
"if",
"they",
"are",
"in",
"the",
"upper",
"layer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L129-L144 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | Fetch | func (sto *overlayStorage) Fetch(ctx context.Context, br blob.Ref) (file io.ReadCloser, size uint32, err error) {
if sto.isDeleted(br) {
return nil, 0, os.ErrNotExist
}
file, size, err = sto.upper.Fetch(ctx, br)
if err != os.ErrNotExist {
return file, size, err
}
return sto.lower.Fetch(ctx, br)
} | go | func (sto *overlayStorage) Fetch(ctx context.Context, br blob.Ref) (file io.ReadCloser, size uint32, err error) {
if sto.isDeleted(br) {
return nil, 0, os.ErrNotExist
}
file, size, err = sto.upper.Fetch(ctx, br)
if err != os.ErrNotExist {
return file, size, err
}
return sto.lower.Fetch(ctx, br)
} | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
")",
"(",
"file",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"if",
"sto",
".",
"isDel... | // Fetch the blob by trying first the upper and then lower.
// The lower storage is checked only if the blob was not deleleted in sto itself. | [
"Fetch",
"the",
"blob",
"by",
"trying",
"first",
"the",
"upper",
"and",
"then",
"lower",
".",
"The",
"lower",
"storage",
"is",
"checked",
"only",
"if",
"the",
"blob",
"was",
"not",
"deleleted",
"in",
"sto",
"itself",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L165-L176 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | EnumerateBlobs | func (sto *overlayStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
defer close(dest)
enums := []blobserver.BlobEnumerator{sto.lower, sto.upper}
// Ensure that we send limit blobs if possible.
sent := 0
for sent < limit {
ch := make(chan blob.SizedRef)
e... | go | func (sto *overlayStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
defer close(dest)
enums := []blobserver.BlobEnumerator{sto.lower, sto.upper}
// Ensure that we send limit blobs if possible.
sent := 0
for sent < limit {
ch := make(chan blob.SizedRef)
e... | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"EnumerateBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"after",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"defer",
"close",
"(",
"dest",
... | // EnumerateBlobs enumerates blobs of the lower and upper layers. | [
"EnumerateBlobs",
"enumerates",
"blobs",
"of",
"the",
"lower",
"and",
"upper",
"layers",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L209-L251 | train |
perkeep/perkeep | internal/geocode/geocode.go | GetAPIKeyPath | func GetAPIKeyPath() (string, error) {
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", fmt.Errorf("could not get config dir: %v", err)
}
return filepath.Join(dir, apiKeyName), nil
} | go | func GetAPIKeyPath() (string, error) {
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", fmt.Errorf("could not get config dir: %v", err)
}
return filepath.Join(dir, apiKeyName), nil
} | [
"func",
"GetAPIKeyPath",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"dir",
",",
"err",
":=",
"osutil",
".",
"PerkeepConfigDir",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
... | // GetAPIKeyPath returns the file path to the Google geocoding API key. | [
"GetAPIKeyPath",
"returns",
"the",
"file",
"path",
"to",
"the",
"Google",
"geocoding",
"API",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/geocode/geocode.go#L77-L83 | train |
perkeep/perkeep | internal/geocode/geocode.go | GetAPIKey | func GetAPIKey() (string, error) {
mu.RLock()
key := apiKey
mu.RUnlock()
if apiKey != "" {
return key, nil
}
mu.Lock()
defer mu.Unlock()
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", err
}
slurp, err := wkfs.ReadFile(filepath.Join(dir, apiKeyName))
if os.IsNotExist(err) {
return ""... | go | func GetAPIKey() (string, error) {
mu.RLock()
key := apiKey
mu.RUnlock()
if apiKey != "" {
return key, nil
}
mu.Lock()
defer mu.Unlock()
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", err
}
slurp, err := wkfs.ReadFile(filepath.Join(dir, apiKeyName))
if os.IsNotExist(err) {
return ""... | [
"func",
"GetAPIKey",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"mu",
".",
"RLock",
"(",
")",
"\n",
"key",
":=",
"apiKey",
"\n",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"apiKey",
"!=",
"\"",
"\"",
"{",
"return",
"key",
",",
"nil",
"\n... | // GetAPIKey returns the Google geocoding API key stored in the Perkeep
// configuration directory as google-geocode.key. | [
"GetAPIKey",
"returns",
"the",
"Google",
"geocoding",
"API",
"key",
"stored",
"in",
"the",
"Perkeep",
"configuration",
"directory",
"as",
"google",
"-",
"geocode",
".",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/geocode/geocode.go#L87-L114 | train |
perkeep/perkeep | internal/geocode/geocode.go | Lookup | func Lookup(ctx context.Context, address string) ([]Rect, error) {
if AltLookupFn != nil {
return AltLookupFn(ctx, address)
}
mu.RLock()
rects, ok := cache[address]
mu.RUnlock()
if ok {
return rects, nil
}
key, err := GetAPIKey()
if err != nil {
return nil, err
}
rectsi, err := sf.Do(address, func()... | go | func Lookup(ctx context.Context, address string) ([]Rect, error) {
if AltLookupFn != nil {
return AltLookupFn(ctx, address)
}
mu.RLock()
rects, ok := cache[address]
mu.RUnlock()
if ok {
return rects, nil
}
key, err := GetAPIKey()
if err != nil {
return nil, err
}
rectsi, err := sf.Do(address, func()... | [
"func",
"Lookup",
"(",
"ctx",
"context",
".",
"Context",
",",
"address",
"string",
")",
"(",
"[",
"]",
"Rect",
",",
"error",
")",
"{",
"if",
"AltLookupFn",
"!=",
"nil",
"{",
"return",
"AltLookupFn",
"(",
"ctx",
",",
"address",
")",
"\n",
"}",
"\n\n",... | // Lookup returns rectangles for the given address. Currently the only
// implementation is the Google geocoding service. | [
"Lookup",
"returns",
"rectangles",
"for",
"the",
"given",
"address",
".",
"Currently",
"the",
"only",
"implementation",
"is",
"the",
"Google",
"geocoding",
"service",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/geocode/geocode.go#L120-L163 | train |
perkeep/perkeep | website/pk-web/pkweb.go | htmlFmt | func htmlFmt(w io.Writer, format string, x ...interface{}) string {
writeAny(w, true, x[0])
return ""
} | go | func htmlFmt(w io.Writer, format string, x ...interface{}) string {
writeAny(w, true, x[0])
return ""
} | [
"func",
"htmlFmt",
"(",
"w",
"io",
".",
"Writer",
",",
"format",
"string",
",",
"x",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"writeAny",
"(",
"w",
",",
"true",
",",
"x",
"[",
"0",
"]",
")",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Template formatter for "html" format. | [
"Template",
"formatter",
"for",
"html",
"format",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L133-L136 | train |
perkeep/perkeep | website/pk-web/pkweb.go | htmlEscFmt | func htmlEscFmt(w io.Writer, format string, x ...interface{}) string {
var buf bytes.Buffer
writeAny(&buf, false, x[0])
template.HTMLEscape(w, buf.Bytes())
return ""
} | go | func htmlEscFmt(w io.Writer, format string, x ...interface{}) string {
var buf bytes.Buffer
writeAny(&buf, false, x[0])
template.HTMLEscape(w, buf.Bytes())
return ""
} | [
"func",
"htmlEscFmt",
"(",
"w",
"io",
".",
"Writer",
",",
"format",
"string",
",",
"x",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"writeAny",
"(",
"&",
"buf",
",",
"false",
",",
"x",
"[",
"0",
"... | // Template formatter for "htmlesc" format. | [
"Template",
"formatter",
"for",
"htmlesc",
"format",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L139-L144 | train |
perkeep/perkeep | website/pk-web/pkweb.go | writeAny | func writeAny(w io.Writer, html bool, x interface{}) {
switch v := x.(type) {
case []byte:
writeText(w, v, html)
case string:
writeText(w, []byte(v), html)
default:
if html {
var buf bytes.Buffer
fmt.Fprint(&buf, x)
writeText(w, buf.Bytes(), true)
} else {
fmt.Fprint(w, x)
}
}
} | go | func writeAny(w io.Writer, html bool, x interface{}) {
switch v := x.(type) {
case []byte:
writeText(w, v, html)
case string:
writeText(w, []byte(v), html)
default:
if html {
var buf bytes.Buffer
fmt.Fprint(&buf, x)
writeText(w, buf.Bytes(), true)
} else {
fmt.Fprint(w, x)
}
}
} | [
"func",
"writeAny",
"(",
"w",
"io",
".",
"Writer",
",",
"html",
"bool",
",",
"x",
"interface",
"{",
"}",
")",
"{",
"switch",
"v",
":=",
"x",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"byte",
":",
"writeText",
"(",
"w",
",",
"v",
",",
"htm... | // Write anything to w; optionally html-escaped. | [
"Write",
"anything",
"to",
"w",
";",
"optionally",
"html",
"-",
"escaped",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L147-L162 | train |
perkeep/perkeep | website/pk-web/pkweb.go | writeText | func writeText(w io.Writer, text []byte, html bool) {
if html {
template.HTMLEscape(w, text)
return
}
w.Write(text)
} | go | func writeText(w io.Writer, text []byte, html bool) {
if html {
template.HTMLEscape(w, text)
return
}
w.Write(text)
} | [
"func",
"writeText",
"(",
"w",
"io",
".",
"Writer",
",",
"text",
"[",
"]",
"byte",
",",
"html",
"bool",
")",
"{",
"if",
"html",
"{",
"template",
".",
"HTMLEscape",
"(",
"w",
",",
"text",
")",
"\n",
"return",
"\n",
"}",
"\n",
"w",
".",
"Write",
... | // Write text to w; optionally html-escaped. | [
"Write",
"text",
"to",
"w",
";",
"optionally",
"html",
"-",
"escaped",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L165-L171 | train |
perkeep/perkeep | website/pk-web/pkweb.go | redirectPath | func redirectPath(u *url.URL) string {
// Redirect old gitweb URLs to gerrit. Example:
// /code/?p=camlistore.git;a=commit;h=b0d2a8f0e5f27bbfc025a96ec3c7896b42d198ed
if strings.HasPrefix(u.Path, "/code/") {
m := gitwebCommit.FindStringSubmatch(u.RawQuery)
if len(m) == 2 {
return gerritURLPrefix + m[1]
}
}
... | go | func redirectPath(u *url.URL) string {
// Redirect old gitweb URLs to gerrit. Example:
// /code/?p=camlistore.git;a=commit;h=b0d2a8f0e5f27bbfc025a96ec3c7896b42d198ed
if strings.HasPrefix(u.Path, "/code/") {
m := gitwebCommit.FindStringSubmatch(u.RawQuery)
if len(m) == 2 {
return gerritURLPrefix + m[1]
}
}
... | [
"func",
"redirectPath",
"(",
"u",
"*",
"url",
".",
"URL",
")",
"string",
"{",
"// Redirect old gitweb URLs to gerrit. Example:",
"// /code/?p=camlistore.git;a=commit;h=b0d2a8f0e5f27bbfc025a96ec3c7896b42d198ed",
"if",
"strings",
".",
"HasPrefix",
"(",
"u",
".",
"Path",
",",
... | // empty return value means don't redirect. | [
"empty",
"return",
"value",
"means",
"don",
"t",
"redirect",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L269-L307 | train |
perkeep/perkeep | website/pk-web/pkweb.go | serveFile | func serveFile(w http.ResponseWriter, r *http.Request, absPath string) {
if !strings.HasSuffix(absPath, ".html") && !strings.HasSuffix(absPath, ".md") {
http.ServeFile(w, r, absPath)
return
}
data, err := ioutil.ReadFile(absPath)
if err != nil {
serveError(w, r, absPath, err)
return
}
// AutoHeadingIDs ... | go | func serveFile(w http.ResponseWriter, r *http.Request, absPath string) {
if !strings.HasSuffix(absPath, ".html") && !strings.HasSuffix(absPath, ".md") {
http.ServeFile(w, r, absPath)
return
}
data, err := ioutil.ReadFile(absPath)
if err != nil {
serveError(w, r, absPath, err)
return
}
// AutoHeadingIDs ... | [
"func",
"serveFile",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"absPath",
"string",
")",
"{",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"absPath",
",",
"\"",
"\"",
")",
"&&",
"!",
"strings",
".",
"HasSuff... | // serveFile serves a file from disk, converting any markdown to HTML. | [
"serveFile",
"serves",
"a",
"file",
"from",
"disk",
"converting",
"any",
"markdown",
"to",
"HTML",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L436-L460 | train |
perkeep/perkeep | website/pk-web/pkweb.go | runAsChild | func runAsChild(res string) {
cmdName, err := exec.LookPath(res)
if err != nil {
log.Fatalf("Could not find %v in $PATH: %v", res, err)
}
cmd := exec.Command(cmdName)
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
log.Printf("Running %v", res)
if err := cmd.Start(); err != nil {
log.Fatalf("Program %v failed... | go | func runAsChild(res string) {
cmdName, err := exec.LookPath(res)
if err != nil {
log.Fatalf("Could not find %v in $PATH: %v", res, err)
}
cmd := exec.Command(cmdName)
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
log.Printf("Running %v", res)
if err := cmd.Start(); err != nil {
log.Fatalf("Program %v failed... | [
"func",
"runAsChild",
"(",
"res",
"string",
")",
"{",
"cmdName",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"res",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"res",
",",
"err",
")",
"\n",
"}",
"\n... | // runAsChild runs res as a child process and
// does not wait for it to finish. | [
"runAsChild",
"runs",
"res",
"as",
"a",
"child",
"process",
"and",
"does",
"not",
"wait",
"for",
"it",
"to",
"finish",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L490-L507 | train |
perkeep/perkeep | website/pk-web/pkweb.go | runDemoBlobServerContainer | func runDemoBlobServerContainer(name string) error {
removeContainer(name)
cmd := exec.Command("docker", "run",
"--rm",
"--name="+name,
"-e", "CAMLI_ROOT="+prodSrcDir+"/website/blobserver-example/root",
"-e", "CAMLI_PASSWORD="+randHex(20),
"-v", pkSrcDir()+":"+prodSrcDir,
"--net=host",
"--workdir="+prod... | go | func runDemoBlobServerContainer(name string) error {
removeContainer(name)
cmd := exec.Command("docker", "run",
"--rm",
"--name="+name,
"-e", "CAMLI_ROOT="+prodSrcDir+"/website/blobserver-example/root",
"-e", "CAMLI_PASSWORD="+randHex(20),
"-v", pkSrcDir()+":"+prodSrcDir,
"--net=host",
"--workdir="+prod... | [
"func",
"runDemoBlobServerContainer",
"(",
"name",
"string",
")",
"error",
"{",
"removeContainer",
"(",
"name",
")",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"name",
",",
"\""... | // runDemoBlobServerContainer runs the demo blobserver as name in a docker
// container. It is not run in daemon mode, so it never returns if successful. | [
"runDemoBlobServerContainer",
"runs",
"the",
"demo",
"blobserver",
"as",
"name",
"in",
"a",
"docker",
"container",
".",
"It",
"is",
"not",
"run",
"in",
"daemon",
"mode",
"so",
"it",
"never",
"returns",
"if",
"successful",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L704-L725 | 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.