id int32 0 167k | 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 listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
31,800 | 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 |
31,801 | 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 |
31,802 | 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 |
31,803 | 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 |
31,804 | 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 |
31,805 | 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 |
31,806 | 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 |
31,807 | 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 |
31,808 | 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 |
31,809 | 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 |
31,810 | 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 |
31,811 | 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 |
31,812 | 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 |
31,813 | 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 |
31,814 | 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 |
31,815 | 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 |
31,816 | 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 |
31,817 | 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 |
31,818 | 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 |
31,819 | 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 |
31,820 | 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 |
31,821 | 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 |
31,822 | 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 |
31,823 | 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 |
31,824 | 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 |
31,825 | 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 |
31,826 | 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 |
31,827 | 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 |
31,828 | 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 |
31,829 | 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 |
31,830 | 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 |
31,831 | 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 |
31,832 | 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 |
31,833 | 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 |
31,834 | 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 |
31,835 | 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 |
31,836 | 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 |
31,837 | 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 |
31,838 | 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 |
31,839 | 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 |
31,840 | 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 |
31,841 | 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 |
31,842 | 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 |
31,843 | 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 |
31,844 | 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 |
31,845 | 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 |
31,846 | 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 |
31,847 | 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 |
31,848 | 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 |
31,849 | 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 |
31,850 | 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 |
31,851 | 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 |
31,852 | 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 |
31,853 | 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 |
31,854 | 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 |
31,855 | 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 |
31,856 | 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 |
31,857 | 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 |
31,858 | 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 |
31,859 | 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 |
31,860 | 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 |
31,861 | 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 |
31,862 | 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 |
31,863 | 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 |
31,864 | 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 |
31,865 | 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 |
31,866 | 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 |
31,867 | 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 |
31,868 | 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 |
31,869 | 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 |
31,870 | 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 |
31,871 | 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 |
31,872 | 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 |
31,873 | 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 |
31,874 | 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 |
31,875 | 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 |
31,876 | perkeep/perkeep | website/pk-web/pkweb.go | httpClient | func httpClient(projID string) *http.Client {
if *gceJWTFile == "" {
log.Fatal("Cannot initialize an authorized http Client without --gce_jwt_file")
}
jsonSlurp, err := ioutil.ReadFile(*gceJWTFile)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
jwtConf, err := google.JWTConfigFrom... | go | func httpClient(projID string) *http.Client {
if *gceJWTFile == "" {
log.Fatal("Cannot initialize an authorized http Client without --gce_jwt_file")
}
jsonSlurp, err := ioutil.ReadFile(*gceJWTFile)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
jwtConf, err := google.JWTConfigFrom... | [
"func",
"httpClient",
"(",
"projID",
"string",
")",
"*",
"http",
".",
"Client",
"{",
"if",
"*",
"gceJWTFile",
"==",
"\"",
"\"",
"{",
"log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"jsonSlurp",
",",
"err",
":=",
"ioutil",
".",
"ReadFile... | // httpClient returns an http Client suitable for Google Cloud Storage or Google Cloud
// Logging calls with the projID project ID. | [
"httpClient",
"returns",
"an",
"http",
"Client",
"suitable",
"for",
"Google",
"Cloud",
"Storage",
"or",
"Google",
"Cloud",
"Logging",
"calls",
"with",
"the",
"projID",
"project",
"ID",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L791-L804 |
31,877 | perkeep/perkeep | website/pk-web/pkweb.go | issueRedirect | func issueRedirect(urlPath string) (string, bool) {
m := issueNum.FindStringSubmatch(urlPath)
if m == nil {
return "", false
}
issueNumber := strings.TrimPrefix(m[1], "/")
suffix := ""
if issueNumber != "" {
suffix = "/" + issueNumber
}
return "https://github.com/perkeep/perkeep/issues" + suffix, true
} | go | func issueRedirect(urlPath string) (string, bool) {
m := issueNum.FindStringSubmatch(urlPath)
if m == nil {
return "", false
}
issueNumber := strings.TrimPrefix(m[1], "/")
suffix := ""
if issueNumber != "" {
suffix = "/" + issueNumber
}
return "https://github.com/perkeep/perkeep/issues" + suffix, true
} | [
"func",
"issueRedirect",
"(",
"urlPath",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"m",
":=",
"issueNum",
".",
"FindStringSubmatch",
"(",
"urlPath",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}",
"\n... | // issueRedirect returns whether the request should be redirected to the
// issues tracker, and the url for that redirection if yes, the empty
// string otherwise. | [
"issueRedirect",
"returns",
"whether",
"the",
"request",
"should",
"be",
"redirected",
"to",
"the",
"issues",
"tracker",
"and",
"the",
"url",
"for",
"that",
"redirection",
"if",
"yes",
"the",
"empty",
"string",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L1103-L1114 |
31,878 | perkeep/perkeep | internal/video/thumbnail/handler.go | serveRef | func serveRef(rw http.ResponseWriter, req *http.Request, ref blob.Ref, fetcher blob.Fetcher) {
if !httputil.IsGet(req) {
http.Error(rw, "Invalid download method.", 400)
return
}
if !httputil.IsLocalhost(req) {
http.Error(rw, "Forbidden.", 403)
return
}
parts := strings.Split(req.URL.Path, "/")
if len(p... | go | func serveRef(rw http.ResponseWriter, req *http.Request, ref blob.Ref, fetcher blob.Fetcher) {
if !httputil.IsGet(req) {
http.Error(rw, "Invalid download method.", 400)
return
}
if !httputil.IsLocalhost(req) {
http.Error(rw, "Forbidden.", 403)
return
}
parts := strings.Split(req.URL.Path, "/")
if len(p... | [
"func",
"serveRef",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"ref",
"blob",
".",
"Ref",
",",
"fetcher",
"blob",
".",
"Fetcher",
")",
"{",
"if",
"!",
"httputil",
".",
"IsGet",
"(",
"req",
")",
"{",
"htt... | // serveRef gets the file at ref from fetcher and serves its contents.
// It is used by Service as a one time handler to serve to the thumbnail child process on localhost. | [
"serveRef",
"gets",
"the",
"file",
"at",
"ref",
"from",
"fetcher",
"and",
"serves",
"its",
"contents",
".",
"It",
"is",
"used",
"by",
"Service",
"as",
"a",
"one",
"time",
"handler",
"to",
"serve",
"to",
"the",
"thumbnail",
"child",
"process",
"on",
"loca... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/video/thumbnail/handler.go#L32-L73 |
31,879 | perkeep/perkeep | pkg/jsonsign/keys.go | ParseArmoredPublicKey | func ParseArmoredPublicKey(r io.Reader) (shortKeyId, armoredKey string, err error) {
var buf bytes.Buffer
pk, err := openArmoredPublicKeyFile(ioutil.NopCloser(io.TeeReader(r, &buf)))
if err != nil {
return
}
return publicKeyID(pk), buf.String(), nil
} | go | func ParseArmoredPublicKey(r io.Reader) (shortKeyId, armoredKey string, err error) {
var buf bytes.Buffer
pk, err := openArmoredPublicKeyFile(ioutil.NopCloser(io.TeeReader(r, &buf)))
if err != nil {
return
}
return publicKeyID(pk), buf.String(), nil
} | [
"func",
"ParseArmoredPublicKey",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"shortKeyId",
",",
"armoredKey",
"string",
",",
"err",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"pk",
",",
"err",
":=",
"openArmoredPublicKeyFile",
"(",
"ioutil... | // ParseArmoredPublicKey tries to parse an armored public key from r,
// taking care to bound the amount it reads.
// The returned shortKeyId is 8 capital hex digits.
// The returned armoredKey is a copy of the contents read. | [
"ParseArmoredPublicKey",
"tries",
"to",
"parse",
"an",
"armored",
"public",
"key",
"from",
"r",
"taking",
"care",
"to",
"bound",
"the",
"amount",
"it",
"reads",
".",
"The",
"returned",
"shortKeyId",
"is",
"8",
"capital",
"hex",
"digits",
".",
"The",
"returne... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L43-L50 |
31,880 | perkeep/perkeep | pkg/jsonsign/keys.go | NewEntity | func NewEntity() (*openpgp.Entity, error) {
name := "" // intentionally empty
comment := "camlistore"
email := "" // intentionally empty
return openpgp.NewEntity(name, comment, email, nil)
} | go | func NewEntity() (*openpgp.Entity, error) {
name := "" // intentionally empty
comment := "camlistore"
email := "" // intentionally empty
return openpgp.NewEntity(name, comment, email, nil)
} | [
"func",
"NewEntity",
"(",
")",
"(",
"*",
"openpgp",
".",
"Entity",
",",
"error",
")",
"{",
"name",
":=",
"\"",
"\"",
"// intentionally empty",
"\n",
"comment",
":=",
"\"",
"\"",
"\n",
"email",
":=",
"\"",
"\"",
"// intentionally empty",
"\n",
"return",
"... | // NewEntity returns a new OpenPGP entity. | [
"NewEntity",
"returns",
"a",
"new",
"OpenPGP",
"entity",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L161-L166 |
31,881 | perkeep/perkeep | pkg/jsonsign/keys.go | KeyIdFromRing | func KeyIdFromRing(secRing string) (keyID string, err error) {
f, err := wkfs.Open(secRing)
if err != nil {
return "", fmt.Errorf("Could not open secret ring file %v: %v", secRing, err)
}
defer f.Close()
el, err := openpgp.ReadKeyRing(f)
if err != nil {
return "", fmt.Errorf("Could not read secret ring file %... | go | func KeyIdFromRing(secRing string) (keyID string, err error) {
f, err := wkfs.Open(secRing)
if err != nil {
return "", fmt.Errorf("Could not open secret ring file %v: %v", secRing, err)
}
defer f.Close()
el, err := openpgp.ReadKeyRing(f)
if err != nil {
return "", fmt.Errorf("Could not read secret ring file %... | [
"func",
"KeyIdFromRing",
"(",
"secRing",
"string",
")",
"(",
"keyID",
"string",
",",
"err",
"error",
")",
"{",
"f",
",",
"err",
":=",
"wkfs",
".",
"Open",
"(",
"secRing",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
... | // KeyIdFromRing returns the public keyID contained in the secret
// ring file secRing. It expects only one keyID in this secret ring
// and returns an error otherwise. | [
"KeyIdFromRing",
"returns",
"the",
"public",
"keyID",
"contained",
"in",
"the",
"secret",
"ring",
"file",
"secRing",
".",
"It",
"expects",
"only",
"one",
"keyID",
"in",
"this",
"secret",
"ring",
"and",
"returns",
"an",
"error",
"otherwise",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L180-L195 |
31,882 | perkeep/perkeep | pkg/jsonsign/keys.go | GenerateNewSecRing | func GenerateNewSecRing(secRing string) (keyID string, err error) {
ent, err := NewEntity()
if err != nil {
return "", fmt.Errorf("generating new identity: %v", err)
}
if err := os.MkdirAll(filepath.Dir(secRing), 0700); err != nil {
return "", err
}
f, err := wkfs.OpenFile(secRing, os.O_WRONLY|os.O_CREATE|os.... | go | func GenerateNewSecRing(secRing string) (keyID string, err error) {
ent, err := NewEntity()
if err != nil {
return "", fmt.Errorf("generating new identity: %v", err)
}
if err := os.MkdirAll(filepath.Dir(secRing), 0700); err != nil {
return "", err
}
f, err := wkfs.OpenFile(secRing, os.O_WRONLY|os.O_CREATE|os.... | [
"func",
"GenerateNewSecRing",
"(",
"secRing",
"string",
")",
"(",
"keyID",
"string",
",",
"err",
"error",
")",
"{",
"ent",
",",
"err",
":=",
"NewEntity",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
... | // GenerateNewSecRing creates a new secret ring file secRing, with
// a new GPG identity. It returns the public keyID of that identity.
// It returns an error if the file already exists. | [
"GenerateNewSecRing",
"creates",
"a",
"new",
"secret",
"ring",
"file",
"secRing",
"with",
"a",
"new",
"GPG",
"identity",
".",
"It",
"returns",
"the",
"public",
"keyID",
"of",
"that",
"identity",
".",
"It",
"returns",
"an",
"error",
"if",
"the",
"file",
"al... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/jsonsign/keys.go#L200-L221 |
31,883 | perkeep/perkeep | pkg/client/client.go | New | func New(opts ...ClientOption) (*Client, error) {
c := &Client{
haveCache: noHaveCache{},
Logger: log.New(os.Stderr, "", log.Ldate|log.Ltime),
authMode: auth.None{},
}
for _, v := range opts {
v.modifyClient(c)
}
if c.sto != nil && len(opts) > 1 {
return nil, errors.New("use of OptionUseStorageClient... | go | func New(opts ...ClientOption) (*Client, error) {
c := &Client{
haveCache: noHaveCache{},
Logger: log.New(os.Stderr, "", log.Ldate|log.Ltime),
authMode: auth.None{},
}
for _, v := range opts {
v.modifyClient(c)
}
if c.sto != nil && len(opts) > 1 {
return nil, errors.New("use of OptionUseStorageClient... | [
"func",
"New",
"(",
"opts",
"...",
"ClientOption",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"c",
":=",
"&",
"Client",
"{",
"haveCache",
":",
"noHaveCache",
"{",
"}",
",",
"Logger",
":",
"log",
".",
"New",
"(",
"os",
".",
"Stderr",
",",
"\... | // New returns a new Perkeep Client.
//
// By default, with no options, it uses the client as configured in
// the environment or default configuration files. | [
"New",
"returns",
"a",
"new",
"Perkeep",
"Client",
".",
"By",
"default",
"with",
"no",
"options",
"it",
"uses",
"the",
"client",
"as",
"configured",
"in",
"the",
"environment",
"or",
"default",
"configuration",
"files",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L173-L219 |
31,884 | perkeep/perkeep | pkg/client/client.go | NewOrFail | func NewOrFail(opts ...ClientOption) *Client {
c, err := New(opts...)
if err != nil {
log.Fatalf("error creating client: %v", err)
}
return c
} | go | func NewOrFail(opts ...ClientOption) *Client {
c, err := New(opts...)
if err != nil {
log.Fatalf("error creating client: %v", err)
}
return c
} | [
"func",
"NewOrFail",
"(",
"opts",
"...",
"ClientOption",
")",
"*",
"Client",
"{",
"c",
",",
"err",
":=",
"New",
"(",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n... | // NewOrFail is like New, but calls log.Fatal instead of returning an error. | [
"NewOrFail",
"is",
"like",
"New",
"but",
"calls",
"log",
".",
"Fatal",
"instead",
"of",
"returning",
"an",
"error",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L231-L237 |
31,885 | perkeep/perkeep | pkg/client/client.go | NewPathClient | func (c *Client) NewPathClient(path string) (*Client, error) {
u, err := url.Parse(c.server)
if err != nil {
return nil, fmt.Errorf("bogus server %q for NewPathClient receiver: %v", c.server, err)
}
u.Path = path
pc, err := New(OptionServer(u.String()))
if err != nil {
return nil, err
}
pc.authMode = c.auth... | go | func (c *Client) NewPathClient(path string) (*Client, error) {
u, err := url.Parse(c.server)
if err != nil {
return nil, fmt.Errorf("bogus server %q for NewPathClient receiver: %v", c.server, err)
}
u.Path = path
pc, err := New(OptionServer(u.String()))
if err != nil {
return nil, err
}
pc.authMode = c.auth... | [
"func",
"(",
"c",
"*",
"Client",
")",
"NewPathClient",
"(",
"path",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"c",
".",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"retur... | // NewPathClient returns a new client accessing a subpath of c. | [
"NewPathClient",
"returns",
"a",
"new",
"client",
"accessing",
"a",
"subpath",
"of",
"c",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L240-L253 |
31,886 | perkeep/perkeep | pkg/client/client.go | transportForConfig | func (c *Client) transportForConfig(tc *TransportConfig) http.RoundTripper {
if inGopherJS {
// Calls to net.Dial* functions - which would happen if the client's transport
// is not nil - are prohibited with GopherJS. So we force nil here, so that the
// call to transportForConfig in newClient is of no consequen... | go | func (c *Client) transportForConfig(tc *TransportConfig) http.RoundTripper {
if inGopherJS {
// Calls to net.Dial* functions - which would happen if the client's transport
// is not nil - are prohibited with GopherJS. So we force nil here, so that the
// call to transportForConfig in newClient is of no consequen... | [
"func",
"(",
"c",
"*",
"Client",
")",
"transportForConfig",
"(",
"tc",
"*",
"TransportConfig",
")",
"http",
".",
"RoundTripper",
"{",
"if",
"inGopherJS",
"{",
"// Calls to net.Dial* functions - which would happen if the client's transport",
"// is not nil - are prohibited wit... | // transportForConfig returns a transport for the client, setting the correct
// Proxy, Dial, and TLSClientConfig if needed. It does not mutate c.
// It is the caller's responsibility to then use that transport to set
// the client's httpClient with SetHTTPClient. | [
"transportForConfig",
"returns",
"a",
"transport",
"for",
"the",
"client",
"setting",
"the",
"correct",
"Proxy",
"Dial",
"and",
"TLSClientConfig",
"if",
"needed",
".",
"It",
"does",
"not",
"mutate",
"c",
".",
"It",
"is",
"the",
"caller",
"s",
"responsibility",... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L283-L323 |
31,887 | perkeep/perkeep | pkg/client/client.go | HTTPStats | func (c *Client) HTTPStats() *httputil.StatsTransport {
st, _ := c.httpClient.Transport.(*httputil.StatsTransport)
return st
} | go | func (c *Client) HTTPStats() *httputil.StatsTransport {
st, _ := c.httpClient.Transport.(*httputil.StatsTransport)
return st
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HTTPStats",
"(",
")",
"*",
"httputil",
".",
"StatsTransport",
"{",
"st",
",",
"_",
":=",
"c",
".",
"httpClient",
".",
"Transport",
".",
"(",
"*",
"httputil",
".",
"StatsTransport",
")",
"\n",
"return",
"st",
"\n... | // HTTPStats returns the client's underlying httputil.StatsTransport, if in use.
// If another transport is being used, nil is returned. | [
"HTTPStats",
"returns",
"the",
"client",
"s",
"underlying",
"httputil",
".",
"StatsTransport",
"if",
"in",
"use",
".",
"If",
"another",
"transport",
"is",
"being",
"used",
"nil",
"is",
"returned",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L327-L330 |
31,888 | perkeep/perkeep | pkg/client/client.go | NewFromShareRoot | func NewFromShareRoot(ctx context.Context, shareBlobURL string, opts ...ClientOption) (c *Client, target blob.Ref, err error) {
var root string
m := shareURLRx.FindStringSubmatch(shareBlobURL)
if m == nil {
return nil, blob.Ref{}, fmt.Errorf("Unknown share URL base")
}
c, err = New(append(opts[:len(opts):cap(opt... | go | func NewFromShareRoot(ctx context.Context, shareBlobURL string, opts ...ClientOption) (c *Client, target blob.Ref, err error) {
var root string
m := shareURLRx.FindStringSubmatch(shareBlobURL)
if m == nil {
return nil, blob.Ref{}, fmt.Errorf("Unknown share URL base")
}
c, err = New(append(opts[:len(opts):cap(opt... | [
"func",
"NewFromShareRoot",
"(",
"ctx",
"context",
".",
"Context",
",",
"shareBlobURL",
"string",
",",
"opts",
"...",
"ClientOption",
")",
"(",
"c",
"*",
"Client",
",",
"target",
"blob",
".",
"Ref",
",",
"err",
"error",
")",
"{",
"var",
"root",
"string",... | // NewFromShareRoot uses shareBlobURL to set up and return a client that
// will be used to fetch shared blobs. | [
"NewFromShareRoot",
"uses",
"shareBlobURL",
"to",
"set",
"up",
"and",
"return",
"a",
"client",
"that",
"will",
"be",
"used",
"to",
"fetch",
"shared",
"blobs",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L449-L491 |
31,889 | perkeep/perkeep | pkg/client/client.go | SetHTTPClient | func (c *Client) SetHTTPClient(client *http.Client) {
if client == nil {
client = http.DefaultClient
}
c.httpClient = client
} | go | func (c *Client) SetHTTPClient(client *http.Client) {
if client == nil {
client = http.DefaultClient
}
c.httpClient = client
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"{",
"if",
"client",
"==",
"nil",
"{",
"client",
"=",
"http",
".",
"DefaultClient",
"\n",
"}",
"\n",
"c",
".",
"httpClient",
"=",
"client",
"\n",
... | // SetHTTPClient sets the Perkeep client's HTTP client.
// If nil, the default HTTP client is used. | [
"SetHTTPClient",
"sets",
"the",
"Perkeep",
"client",
"s",
"HTTP",
"client",
".",
"If",
"nil",
"the",
"default",
"HTTP",
"client",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L495-L500 |
31,890 | perkeep/perkeep | pkg/client/client.go | BlobRoot | func (c *Client) BlobRoot() (string, error) {
prefix, err := c.prefix()
if err != nil {
return "", err
}
return prefix + "/", nil
} | go | func (c *Client) BlobRoot() (string, error) {
prefix, err := c.prefix()
if err != nil {
return "", err
}
return prefix + "/", nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"BlobRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"prefix",
",",
"err",
":=",
"c",
".",
"prefix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n... | // BlobRoot returns the server's blobroot URL prefix.
// If the client was constructed with an explicit path,
// that path is used. Otherwise the server's
// default advertised blobRoot is used. | [
"BlobRoot",
"returns",
"the",
"server",
"s",
"blobroot",
"URL",
"prefix",
".",
"If",
"the",
"client",
"was",
"constructed",
"with",
"an",
"explicit",
"path",
"that",
"path",
"is",
"used",
".",
"Otherwise",
"the",
"server",
"s",
"default",
"advertised",
"blob... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L560-L566 |
31,891 | perkeep/perkeep | pkg/client/client.go | ServerPublicKeyBlobRef | func (c *Client) ServerPublicKeyBlobRef() (blob.Ref, error) {
if err := c.condDiscovery(); err != nil {
return blob.Ref{}, err
}
if !c.serverPublicKeyBlobRef.Valid() {
return blob.Ref{}, ErrNoSigning
}
return c.serverPublicKeyBlobRef, nil
} | go | func (c *Client) ServerPublicKeyBlobRef() (blob.Ref, error) {
if err := c.condDiscovery(); err != nil {
return blob.Ref{}, err
}
if !c.serverPublicKeyBlobRef.Valid() {
return blob.Ref{}, ErrNoSigning
}
return c.serverPublicKeyBlobRef, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ServerPublicKeyBlobRef",
"(",
")",
"(",
"blob",
".",
"Ref",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"blob",
".",
"Ref",
"{",
"}... | // ServerPublicKeyBlobRef returns the server's public key blobRef
// If the server isn't running a sign handler, the error will be ErrNoSigning. | [
"ServerPublicKeyBlobRef",
"returns",
"the",
"server",
"s",
"public",
"key",
"blobRef",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"sign",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSigning",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L583-L592 |
31,892 | perkeep/perkeep | pkg/client/client.go | SearchRoot | func (c *Client) SearchRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.searchRoot == "" {
return "", ErrNoSearchRoot
}
return c.searchRoot, nil
} | go | func (c *Client) SearchRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.searchRoot == "" {
return "", ErrNoSearchRoot
}
return c.searchRoot, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SearchRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
... | // SearchRoot returns the server's search handler.
// If the server isn't running an index and search handler, the error
// will be ErrNoSearchRoot. | [
"SearchRoot",
"returns",
"the",
"server",
"s",
"search",
"handler",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"an",
"index",
"and",
"search",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSearchRoot",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L597-L605 |
31,893 | perkeep/perkeep | pkg/client/client.go | HelpRoot | func (c *Client) HelpRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.helpRoot == "" {
return "", ErrNoHelpRoot
}
return c.helpRoot, nil
} | go | func (c *Client) HelpRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.helpRoot == "" {
return "", ErrNoHelpRoot
}
return c.helpRoot, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HelpRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
... | // HelpRoot returns the server's help handler.
// If the server isn't running a help handler, the error will be
// ErrNoHelpRoot. | [
"HelpRoot",
"returns",
"the",
"server",
"s",
"help",
"handler",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"help",
"handler",
"the",
"error",
"will",
"be",
"ErrNoHelpRoot",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L610-L618 |
31,894 | perkeep/perkeep | pkg/client/client.go | ShareRoot | func (c *Client) ShareRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.shareRoot == "" {
return "", ErrNoShareRoot
}
return c.shareRoot, nil
} | go | func (c *Client) ShareRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.shareRoot == "" {
return "", ErrNoShareRoot
}
return c.shareRoot, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ShareRoot",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
... | // ShareRoot returns the server's share handler prefix URL.
// If the server isn't running a share handler, the error will be
// ErrNoShareRoot. | [
"ShareRoot",
"returns",
"the",
"server",
"s",
"share",
"handler",
"prefix",
"URL",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"share",
"handler",
"the",
"error",
"will",
"be",
"ErrNoShareRoot",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L623-L631 |
31,895 | perkeep/perkeep | pkg/client/client.go | SignHandler | func (c *Client) SignHandler() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.signHandler == "" {
return "", ErrNoSigning
}
return c.signHandler, nil
} | go | func (c *Client) SignHandler() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.signHandler == "" {
return "", ErrNoSigning
}
return c.signHandler, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SignHandler",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",... | // SignHandler returns the server's sign handler.
// If the server isn't running a sign handler, the error will be
// ErrNoSigning. | [
"SignHandler",
"returns",
"the",
"server",
"s",
"sign",
"handler",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"a",
"sign",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSigning",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L636-L644 |
31,896 | perkeep/perkeep | pkg/client/client.go | StorageGeneration | func (c *Client) StorageGeneration() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.storageGen == "" {
return "", ErrNoStorageGeneration
}
return c.storageGen, nil
} | go | func (c *Client) StorageGeneration() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.storageGen == "" {
return "", ErrNoStorageGeneration
}
return c.storageGen, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"StorageGeneration",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
... | // StorageGeneration returns the server's unique ID for its storage
// generation, reset whenever storage is reset, moved, or partially
// lost.
//
// This is a value that can be used in client cache keys to add
// certainty that they're talking to the same instance as previously.
//
// If the server doesn't return suc... | [
"StorageGeneration",
"returns",
"the",
"server",
"s",
"unique",
"ID",
"for",
"its",
"storage",
"generation",
"reset",
"whenever",
"storage",
"is",
"reset",
"moved",
"or",
"partially",
"lost",
".",
"This",
"is",
"a",
"value",
"that",
"can",
"be",
"used",
"in"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L655-L663 |
31,897 | perkeep/perkeep | pkg/client/client.go | HasLegacySHA1 | func (c *Client) HasLegacySHA1() (bool, error) {
if err := c.condDiscovery(); err != nil {
return false, err
}
return c.hasLegacySHA1, nil
} | go | func (c *Client) HasLegacySHA1() (bool, error) {
if err := c.condDiscovery(); err != nil {
return false, err
}
return c.hasLegacySHA1, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HasLegacySHA1",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
... | // HasLegacySHA1 reports whether the server has SHA-1 blobs indexed. | [
"HasLegacySHA1",
"reports",
"whether",
"the",
"server",
"has",
"SHA",
"-",
"1",
"blobs",
"indexed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L666-L671 |
31,898 | perkeep/perkeep | pkg/client/client.go | SyncHandlers | func (c *Client) SyncHandlers() ([]*SyncInfo, error) {
if err := c.condDiscovery(); err != nil {
return nil, err
}
if c.syncHandlers == nil {
return nil, ErrNoSync
}
return c.syncHandlers, nil
} | go | func (c *Client) SyncHandlers() ([]*SyncInfo, error) {
if err := c.condDiscovery(); err != nil {
return nil, err
}
if c.syncHandlers == nil {
return nil, ErrNoSync
}
return c.syncHandlers, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SyncHandlers",
"(",
")",
"(",
"[",
"]",
"*",
"SyncInfo",
",",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}"... | // SyncHandlers returns the server's sync handlers "from" and
// "to" prefix URLs.
// If the server isn't running any sync handler, the error
// will be ErrNoSync. | [
"SyncHandlers",
"returns",
"the",
"server",
"s",
"sync",
"handlers",
"from",
"and",
"to",
"prefix",
"URLs",
".",
"If",
"the",
"server",
"isn",
"t",
"running",
"any",
"sync",
"handler",
"the",
"error",
"will",
"be",
"ErrNoSync",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L685-L693 |
31,899 | perkeep/perkeep | pkg/client/client.go | GetRecentPermanodes | func (c *Client) GetRecentPermanodes(ctx context.Context, req *search.RecentRequest) (*search.RecentResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
... | go | func (c *Client) GetRecentPermanodes(ctx context.Context, req *search.RecentRequest) (*search.RecentResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
... | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetRecentPermanodes",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"search",
".",
"RecentRequest",
")",
"(",
"*",
"search",
".",
"RecentResponse",
",",
"error",
")",
"{",
"sr",
",",
"err",
":=",
"c",
... | // GetRecentPermanodes implements search.GetRecentPermanoder against a remote server over HTTP. | [
"GetRecentPermanodes",
"implements",
"search",
".",
"GetRecentPermanoder",
"against",
"a",
"remote",
"server",
"over",
"HTTP",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L698-L717 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.