repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
perkeep/perkeep | pkg/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.ErrNotExist {
return err
}
return nil
})
}
err1 := wg.Err()
err2 := s.index.CommitBatch(batch)
if err1 != nil {
return err1
}
return err2
} | 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.ErrNotExist {
return err
}
return nil
})
}
err1 := wg.Err()
err2 := s.index.CommitBatch(batch)
if err1 != nil {
return err1
}
return err2
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"batch",
":=",
"s",
".",
"index",
".",
"BeginBatch",
"(",
")",
"\n",
"var",
"wg",
"syncutil"... | // RemoveBlobs removes the blobs from index and pads data with zero bytes | [
"RemoveBlobs",
"removes",
"the",
"blobs",
"from",
"index",
"and",
"pads",
"data",
"with",
"zero",
"bytes"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L406-L427 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | StreamBlobs | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) error {
defer close(dest)
fileNum, offset, err := parseContToken(contToken)
if err != nil {
return errors.New("diskpacked: invalid continuation token")
}
debug.Printf("Continuing blob streaming from pack %s, offset %d",
s.filename(fileNum), offset)
fd, err := os.Open(s.filename(fileNum))
if err != nil {
return err
}
// fd will change over time; Close whichever is current when we exit.
defer func() {
if fd != nil { // may be nil on os.Open error below
fd.Close()
}
}()
// ContToken always refers to the exact next place we will read from.
// Note that seeking past the end is legal on Unix and for io.Seeker,
// but that will just result in a mostly harmless EOF.
//
// TODO: probably be stricter here and don't allow seek past
// the end, since we know the size of closed files and the
// size of the file diskpacked currently still writing.
_, err = fd.Seek(offset, os.SEEK_SET)
if err != nil {
return err
}
const ioBufSize = 256 * 1024
// We'll use bufio to avoid read system call overhead.
r := bufio.NewReaderSize(fd, ioBufSize)
for {
// Are we at the EOF of this pack?
if _, err := r.Peek(1); err != nil {
if err != io.EOF {
return err
}
// EOF case; continue to the next pack, if any.
fileNum++
offset = 0
fd.Close() // Close the previous pack
fd, err = os.Open(s.filename(fileNum))
if os.IsNotExist(err) {
// We reached the end.
return nil
} else if err != nil {
return err
}
r.Reset(fd)
continue
}
thisOffset := offset // of current blob's header
consumed, digest, size, err := readHeader(r)
if err != nil {
return err
}
offset += int64(consumed)
if deletedBlobRef.Match(digest) {
// Skip over deletion padding
if _, err := io.CopyN(ioutil.Discard, r, int64(size)); err != nil {
return err
}
offset += int64(size)
continue
}
ref, ok := blob.ParseBytes(digest)
if !ok {
return fmt.Errorf("diskpacked: Invalid blobref %q", digest)
}
// Finally, read and send the blob.
// TODO: remove this allocation per blob. We can make one instead
// outside of the loop, guarded by a mutex, and re-use it, only to
// lock the mutex and clone it if somebody actually calls ReadFull
// on the *blob.Blob. Otherwise callers just scanning all the blobs
// to see if they have everything incur lots of garbage if they
// don't open any blobs.
data := make([]byte, size)
if _, err := io.ReadFull(r, data); err != nil {
return err
}
offset += int64(size)
blob := blob.NewBlob(ref, size, func(context.Context) ([]byte, error) {
return data, nil
})
select {
case dest <- blobserver.BlobAndToken{
Blob: blob,
Token: fmt.Sprintf("%d %d", fileNum, thisOffset),
}:
// Nothing.
case <-ctx.Done():
return ctx.Err()
}
}
} | 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, offset %d",
s.filename(fileNum), offset)
fd, err := os.Open(s.filename(fileNum))
if err != nil {
return err
}
// fd will change over time; Close whichever is current when we exit.
defer func() {
if fd != nil { // may be nil on os.Open error below
fd.Close()
}
}()
// ContToken always refers to the exact next place we will read from.
// Note that seeking past the end is legal on Unix and for io.Seeker,
// but that will just result in a mostly harmless EOF.
//
// TODO: probably be stricter here and don't allow seek past
// the end, since we know the size of closed files and the
// size of the file diskpacked currently still writing.
_, err = fd.Seek(offset, os.SEEK_SET)
if err != nil {
return err
}
const ioBufSize = 256 * 1024
// We'll use bufio to avoid read system call overhead.
r := bufio.NewReaderSize(fd, ioBufSize)
for {
// Are we at the EOF of this pack?
if _, err := r.Peek(1); err != nil {
if err != io.EOF {
return err
}
// EOF case; continue to the next pack, if any.
fileNum++
offset = 0
fd.Close() // Close the previous pack
fd, err = os.Open(s.filename(fileNum))
if os.IsNotExist(err) {
// We reached the end.
return nil
} else if err != nil {
return err
}
r.Reset(fd)
continue
}
thisOffset := offset // of current blob's header
consumed, digest, size, err := readHeader(r)
if err != nil {
return err
}
offset += int64(consumed)
if deletedBlobRef.Match(digest) {
// Skip over deletion padding
if _, err := io.CopyN(ioutil.Discard, r, int64(size)); err != nil {
return err
}
offset += int64(size)
continue
}
ref, ok := blob.ParseBytes(digest)
if !ok {
return fmt.Errorf("diskpacked: Invalid blobref %q", digest)
}
// Finally, read and send the blob.
// TODO: remove this allocation per blob. We can make one instead
// outside of the loop, guarded by a mutex, and re-use it, only to
// lock the mutex and clone it if somebody actually calls ReadFull
// on the *blob.Blob. Otherwise callers just scanning all the blobs
// to see if they have everything incur lots of garbage if they
// don't open any blobs.
data := make([]byte, size)
if _, err := io.ReadFull(r, data); err != nil {
return err
}
offset += int64(size)
blob := blob.NewBlob(ref, size, func(context.Context) ([]byte, error) {
return data, nil
})
select {
case dest <- blobserver.BlobAndToken{
Blob: blob,
Token: fmt.Sprintf("%d %d", fileNum, thisOffset),
}:
// Nothing.
case <-ctx.Done():
return ctx.Err()
}
}
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"StreamBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blobserver",
".",
"BlobAndToken",
",",
"contToken",
"string",
")",
"error",
"{",
"defer",
"close",
"(",
"dest",
")",
"\n",
"fileNum",... | // StreamBlobs Implements the blobserver.StreamBlobs interface. | [
"StreamBlobs",
"Implements",
"the",
"blobserver",
".",
"StreamBlobs",
"interface",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L529-L635 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | append | func (s *storage) append(br blob.SizedRef, r io.Reader) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return errors.New("diskpacked: write to closed storage")
}
// to be able to undo the append
origOffset := s.size
fn := s.writer.Name()
n, err := fmt.Fprintf(s.writer, "[%v %v]", br.Ref.String(), br.Size)
s.size += int64(n)
writeVar.Add(fn, int64(n))
writeTotVar.Add(s.root, int64(n))
if err != nil {
return err
}
// TODO(adg): remove this seek and the offset check once confident
offset, err := s.writer.Seek(0, os.SEEK_CUR)
if err != nil {
return err
}
if offset != s.size {
return fmt.Errorf("diskpacked: seek says offset = %d, we think %d",
offset, s.size)
}
offset = s.size // make this a declaration once the above is removed
n2, err := io.Copy(s.writer, r)
s.size += n2
writeVar.Add(fn, int64(n))
writeTotVar.Add(s.root, int64(n))
if err != nil {
return err
}
if n2 != int64(br.Size) {
return fmt.Errorf("diskpacked: written blob size %d didn't match size %d", n, br.Size)
}
if err = s.writer.Sync(); err != nil {
return err
}
packIdx := len(s.fds) - 1
if s.size > s.maxFileSize {
if err := s.nextPack(); err != nil {
return err
}
}
err = s.index.Set(br.Ref.String(), blobMeta{packIdx, offset, br.Size}.String())
if err != nil {
if _, seekErr := s.writer.Seek(origOffset, os.SEEK_SET); seekErr != nil {
log.Printf("ERROR seeking back to the original offset: %v", seekErr)
} else if truncErr := s.writer.Truncate(origOffset); truncErr != nil {
log.Printf("ERROR truncating file after index error: %v", truncErr)
} else {
s.size = origOffset
}
}
return err
} | 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.Size)
s.size += int64(n)
writeVar.Add(fn, int64(n))
writeTotVar.Add(s.root, int64(n))
if err != nil {
return err
}
// TODO(adg): remove this seek and the offset check once confident
offset, err := s.writer.Seek(0, os.SEEK_CUR)
if err != nil {
return err
}
if offset != s.size {
return fmt.Errorf("diskpacked: seek says offset = %d, we think %d",
offset, s.size)
}
offset = s.size // make this a declaration once the above is removed
n2, err := io.Copy(s.writer, r)
s.size += n2
writeVar.Add(fn, int64(n))
writeTotVar.Add(s.root, int64(n))
if err != nil {
return err
}
if n2 != int64(br.Size) {
return fmt.Errorf("diskpacked: written blob size %d didn't match size %d", n, br.Size)
}
if err = s.writer.Sync(); err != nil {
return err
}
packIdx := len(s.fds) - 1
if s.size > s.maxFileSize {
if err := s.nextPack(); err != nil {
return err
}
}
err = s.index.Set(br.Ref.String(), blobMeta{packIdx, offset, br.Size}.String())
if err != nil {
if _, seekErr := s.writer.Seek(origOffset, os.SEEK_SET); seekErr != nil {
log.Printf("ERROR seeking back to the original offset: %v", seekErr)
} else if truncErr := s.writer.Truncate(origOffset); truncErr != nil {
log.Printf("ERROR truncating file after index error: %v", truncErr)
} else {
s.size = origOffset
}
}
return err
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"append",
"(",
"br",
"blob",
".",
"SizedRef",
",",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
... | // append writes the provided blob to the current data file. | [
"append",
"writes",
"the",
"provided",
"blob",
"to",
"the",
"current",
"data",
"file",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L661-L722 | train |
perkeep/perkeep | pkg/blobserver/diskpacked/diskpacked.go | meta | func (s *storage) meta(br blob.Ref) (m blobMeta, err error) {
ms, err := s.index.Get(br.String())
if err != nil {
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
return
}
m, ok := parseBlobMeta(ms)
if !ok {
err = fmt.Errorf("diskpacked: bad blob metadata: %q", ms)
}
return
} | go | func (s *storage) meta(br blob.Ref) (m blobMeta, err error) {
ms, err := s.index.Get(br.String())
if err != nil {
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
return
}
m, ok := parseBlobMeta(ms)
if !ok {
err = fmt.Errorf("diskpacked: bad blob metadata: %q", ms)
}
return
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"meta",
"(",
"br",
"blob",
".",
"Ref",
")",
"(",
"m",
"blobMeta",
",",
"err",
"error",
")",
"{",
"ms",
",",
"err",
":=",
"s",
".",
"index",
".",
"Get",
"(",
"br",
".",
"String",
"(",
")",
")",
"\n",
"i... | // meta fetches the metadata for the specified blob from the index. | [
"meta",
"fetches",
"the",
"metadata",
"for",
"the",
"specified",
"blob",
"from",
"the",
"index",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/diskpacked/diskpacked.go#L725-L738 | train |
perkeep/perkeep | cmd/pk-put/files.go | DumpStats | func DumpStats(sr *statspkg.Receiver, destFile string) {
sr.Lock()
defer sr.Unlock()
f, err := os.Create(destFile)
if err != nil {
log.Fatal(err)
}
var sum int64
for _, size := range sr.Have {
fmt.Fprintf(f, "%d\n", size)
}
fmt.Printf("In-memory blob stats: %d blobs, %d bytes\n", len(sr.Have), sum)
err = f.Close()
if err != nil {
log.Fatal(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 = f.Close()
if err != nil {
log.Fatal(err)
}
} | [
"func",
"DumpStats",
"(",
"sr",
"*",
"statspkg",
".",
"Receiver",
",",
"destFile",
"string",
")",
"{",
"sr",
".",
"Lock",
"(",
")",
"\n",
"defer",
"sr",
".",
"Unlock",
"(",
")",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"destFile",
"... | // DumpStats creates the destFile and writes a line per received blob,
// with its blob size. | [
"DumpStats",
"creates",
"the",
"destFile",
"and",
"writes",
"a",
"line",
"per",
"received",
"blob",
"with",
"its",
"blob",
"size",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/files.go#L310-L329 | train |
perkeep/perkeep | cmd/pk-put/files.go | statReceiver | func (up *Uploader) statReceiver(n *node) blobserver.StatReceiver {
statReceiver := up.altStatReceiver
if statReceiver == nil {
// TODO(mpl): simplify the altStatReceiver situation as well,
// see TODO in cmd/pk-put/uploader.go
statReceiver = up.Client
}
if android.IsChild() && n != nil && n.fi.Mode()&os.ModeType == 0 {
return android.StatusReceiver{Sr: statReceiver, Path: n.fullPath}
}
return statReceiver
} | 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.ModeType == 0 {
return android.StatusReceiver{Sr: statReceiver, Path: n.fullPath}
}
return statReceiver
} | [
"func",
"(",
"up",
"*",
"Uploader",
")",
"statReceiver",
"(",
"n",
"*",
"node",
")",
"blobserver",
".",
"StatReceiver",
"{",
"statReceiver",
":=",
"up",
".",
"altStatReceiver",
"\n",
"if",
"statReceiver",
"==",
"nil",
"{",
"statReceiver",
"=",
"up",
".",
... | // statReceiver returns the StatReceiver used for checking for and uploading blobs.
//
// The optional provided node is only used for conditionally printing out status info to stdout. | [
"statReceiver",
"returns",
"the",
"StatReceiver",
"used",
"for",
"checking",
"for",
"and",
"uploading",
"blobs",
".",
"The",
"optional",
"provided",
"node",
"is",
"only",
"used",
"for",
"conditionally",
"printing",
"out",
"status",
"info",
"to",
"stdout",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/files.go#L435-L446 | train |
perkeep/perkeep | cmd/pk-put/files.go | NewTreeUpload | func (up *Uploader) NewTreeUpload(dir string) *TreeUpload {
tu := up.NewRootlessTreeUpload()
tu.rootless = false
tu.base = dir
return tu
} | go | func (up *Uploader) NewTreeUpload(dir string) *TreeUpload {
tu := up.NewRootlessTreeUpload()
tu.rootless = false
tu.base = dir
return tu
} | [
"func",
"(",
"up",
"*",
"Uploader",
")",
"NewTreeUpload",
"(",
"dir",
"string",
")",
"*",
"TreeUpload",
"{",
"tu",
":=",
"up",
".",
"NewRootlessTreeUpload",
"(",
")",
"\n",
"tu",
".",
"rootless",
"=",
"false",
"\n",
"tu",
".",
"base",
"=",
"dir",
"\n... | // NewTreeUpload returns a TreeUpload. It doesn't begin uploading any files until a
// call to Start | [
"NewTreeUpload",
"returns",
"a",
"TreeUpload",
".",
"It",
"doesn",
"t",
"begin",
"uploading",
"any",
"files",
"until",
"a",
"call",
"to",
"Start"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/cmd/pk-put/files.go#L801-L806 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | ReceiveBlob | func (sto *overlayStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
sb, err = sto.upper.ReceiveBlob(ctx, br, src)
if err == nil && sto.deleted != nil {
err = sto.deleted.Delete(br.String())
}
return sb, err
} | go | func (sto *overlayStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
sb, err = sto.upper.ReceiveBlob(ctx, br, src)
if err == nil && sto.deleted != nil {
err = sto.deleted.Delete(br.String())
}
return sb, err
} | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"ReceiveBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
",",
"src",
"io",
".",
"Reader",
")",
"(",
"sb",
"blob",
".",
"SizedRef",
",",
"err",
"error",
")",
"{",
"sb",
",",... | // ReceiveBlob stores received blobs on the upper layer. | [
"ReceiveBlob",
"stores",
"received",
"blobs",
"on",
"the",
"upper",
"layer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L120-L126 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | RemoveBlobs | func (sto *overlayStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if sto.deleted == nil {
return blobserver.ErrNotImplemented
}
err := sto.upper.RemoveBlobs(ctx, blobs)
if err != nil {
return err
}
m := sto.deleted.BeginBatch()
for _, br := range blobs {
m.Set(br.String(), "1")
}
return sto.deleted.CommitBatch(m)
} | 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")
}
return sto.deleted.CommitBatch(m)
} | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"RemoveBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"blobs",
"[",
"]",
"blob",
".",
"Ref",
")",
"error",
"{",
"if",
"sto",
".",
"deleted",
"==",
"nil",
"{",
"return",
"blobserver",
".",
"ErrNotImpl... | // RemoveBlobs marks the given blobs as deleted, and removes them if they are in the upper layer. | [
"RemoveBlobs",
"marks",
"the",
"given",
"blobs",
"as",
"deleted",
"and",
"removes",
"them",
"if",
"they",
"are",
"in",
"the",
"upper",
"layer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L129-L144 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | Fetch | func (sto *overlayStorage) Fetch(ctx context.Context, br blob.Ref) (file io.ReadCloser, size uint32, err error) {
if sto.isDeleted(br) {
return nil, 0, os.ErrNotExist
}
file, size, err = sto.upper.Fetch(ctx, br)
if err != os.ErrNotExist {
return file, size, err
}
return sto.lower.Fetch(ctx, br)
} | go | func (sto *overlayStorage) Fetch(ctx context.Context, br blob.Ref) (file io.ReadCloser, size uint32, err error) {
if sto.isDeleted(br) {
return nil, 0, os.ErrNotExist
}
file, size, err = sto.upper.Fetch(ctx, br)
if err != os.ErrNotExist {
return file, size, err
}
return sto.lower.Fetch(ctx, br)
} | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"Fetch",
"(",
"ctx",
"context",
".",
"Context",
",",
"br",
"blob",
".",
"Ref",
")",
"(",
"file",
"io",
".",
"ReadCloser",
",",
"size",
"uint32",
",",
"err",
"error",
")",
"{",
"if",
"sto",
".",
"isDel... | // Fetch the blob by trying first the upper and then lower.
// The lower storage is checked only if the blob was not deleleted in sto itself. | [
"Fetch",
"the",
"blob",
"by",
"trying",
"first",
"the",
"upper",
"and",
"then",
"lower",
".",
"The",
"lower",
"storage",
"is",
"checked",
"only",
"if",
"the",
"blob",
"was",
"not",
"deleleted",
"in",
"sto",
"itself",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L165-L176 | train |
perkeep/perkeep | pkg/blobserver/overlay/overlay.go | EnumerateBlobs | func (sto *overlayStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
defer close(dest)
enums := []blobserver.BlobEnumerator{sto.lower, sto.upper}
// Ensure that we send limit blobs if possible.
sent := 0
for sent < limit {
ch := make(chan blob.SizedRef)
errch := make(chan error, 1)
go func() {
errch <- blobserver.MergedEnumerate(ctx, ch, enums, after, limit-sent)
}()
var last blob.Ref
// Yield all blobs that weren't deleted from ch to destch.
seen := 0
for sbr := range ch {
seen++
if !sto.isDeleted(sbr.Ref) {
log.Println(sent, sbr.Ref)
dest <- sbr
sent++
}
last = sbr.Ref
}
if err := <-errch; err != nil {
return err
}
// if no blob was received, enumeration is finished
if seen == 0 {
return nil
}
// resume enumeration after the last blob seen
after = last.String()
}
return nil
} | 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)
errch := make(chan error, 1)
go func() {
errch <- blobserver.MergedEnumerate(ctx, ch, enums, after, limit-sent)
}()
var last blob.Ref
// Yield all blobs that weren't deleted from ch to destch.
seen := 0
for sbr := range ch {
seen++
if !sto.isDeleted(sbr.Ref) {
log.Println(sent, sbr.Ref)
dest <- sbr
sent++
}
last = sbr.Ref
}
if err := <-errch; err != nil {
return err
}
// if no blob was received, enumeration is finished
if seen == 0 {
return nil
}
// resume enumeration after the last blob seen
after = last.String()
}
return nil
} | [
"func",
"(",
"sto",
"*",
"overlayStorage",
")",
"EnumerateBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blob",
".",
"SizedRef",
",",
"after",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"defer",
"close",
"(",
"dest",
... | // EnumerateBlobs enumerates blobs of the lower and upper layers. | [
"EnumerateBlobs",
"enumerates",
"blobs",
"of",
"the",
"lower",
"and",
"upper",
"layers",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/overlay/overlay.go#L209-L251 | train |
perkeep/perkeep | internal/geocode/geocode.go | GetAPIKeyPath | func GetAPIKeyPath() (string, error) {
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", fmt.Errorf("could not get config dir: %v", err)
}
return filepath.Join(dir, apiKeyName), nil
} | go | func GetAPIKeyPath() (string, error) {
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", fmt.Errorf("could not get config dir: %v", err)
}
return filepath.Join(dir, apiKeyName), nil
} | [
"func",
"GetAPIKeyPath",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"dir",
",",
"err",
":=",
"osutil",
".",
"PerkeepConfigDir",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not get conf... | // GetAPIKeyPath returns the file path to the Google geocoding API key. | [
"GetAPIKeyPath",
"returns",
"the",
"file",
"path",
"to",
"the",
"Google",
"geocoding",
"API",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/geocode/geocode.go#L77-L83 | train |
perkeep/perkeep | internal/geocode/geocode.go | GetAPIKey | func GetAPIKey() (string, error) {
mu.RLock()
key := apiKey
mu.RUnlock()
if apiKey != "" {
return key, nil
}
mu.Lock()
defer mu.Unlock()
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", err
}
slurp, err := wkfs.ReadFile(filepath.Join(dir, apiKeyName))
if os.IsNotExist(err) {
return "", ErrNoGoogleKey
}
if err != nil {
return "", err
}
key = strings.TrimSpace(string(slurp))
if key == "" {
return "", ErrNoGoogleKey
}
apiKey = key
return key, nil
} | 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 "", ErrNoGoogleKey
}
if err != nil {
return "", err
}
key = strings.TrimSpace(string(slurp))
if key == "" {
return "", ErrNoGoogleKey
}
apiKey = key
return key, nil
} | [
"func",
"GetAPIKey",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"mu",
".",
"RLock",
"(",
")",
"\n",
"key",
":=",
"apiKey",
"\n",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"apiKey",
"!=",
"\"\"",
"{",
"return",
"key",
",",
"nil",
"\n",
"... | // GetAPIKey returns the Google geocoding API key stored in the Perkeep
// configuration directory as google-geocode.key. | [
"GetAPIKey",
"returns",
"the",
"Google",
"geocoding",
"API",
"key",
"stored",
"in",
"the",
"Perkeep",
"configuration",
"directory",
"as",
"google",
"-",
"geocode",
".",
"key",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/geocode/geocode.go#L87-L114 | train |
perkeep/perkeep | internal/geocode/geocode.go | Lookup | func Lookup(ctx context.Context, address string) ([]Rect, error) {
if AltLookupFn != nil {
return AltLookupFn(ctx, address)
}
mu.RLock()
rects, ok := cache[address]
mu.RUnlock()
if ok {
return rects, nil
}
key, err := GetAPIKey()
if err != nil {
return nil, err
}
rectsi, err := sf.Do(address, func() (interface{}, error) {
// TODO: static data files from OpenStreetMap, Wikipedia, etc?
urlStr := "https://maps.googleapis.com/maps/api/geocode/json?address=" + url.QueryEscape(address) + "&sensor=false&key=" + url.QueryEscape(key)
res, err := ctxhttp.Get(ctx, ctxutil.Client(ctx), urlStr)
if err != nil {
log.Printf("geocode: HTTP error doing Google lookup: %v", err)
return nil, err
}
defer res.Body.Close()
rects, err := decodeGoogleResponse(res.Body)
if err != nil {
log.Printf("geocode: error decoding Google geocode response for %q: %v", address, err)
} else {
log.Printf("geocode: Google lookup (%q) = %#v", address, rects)
}
if err == nil {
mu.Lock()
cache[address] = rects
mu.Unlock()
}
return rects, err
})
if err != nil {
return nil, err
}
return rectsi.([]Rect), nil
} | 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() (interface{}, error) {
// TODO: static data files from OpenStreetMap, Wikipedia, etc?
urlStr := "https://maps.googleapis.com/maps/api/geocode/json?address=" + url.QueryEscape(address) + "&sensor=false&key=" + url.QueryEscape(key)
res, err := ctxhttp.Get(ctx, ctxutil.Client(ctx), urlStr)
if err != nil {
log.Printf("geocode: HTTP error doing Google lookup: %v", err)
return nil, err
}
defer res.Body.Close()
rects, err := decodeGoogleResponse(res.Body)
if err != nil {
log.Printf("geocode: error decoding Google geocode response for %q: %v", address, err)
} else {
log.Printf("geocode: Google lookup (%q) = %#v", address, rects)
}
if err == nil {
mu.Lock()
cache[address] = rects
mu.Unlock()
}
return rects, err
})
if err != nil {
return nil, err
}
return rectsi.([]Rect), nil
} | [
"func",
"Lookup",
"(",
"ctx",
"context",
".",
"Context",
",",
"address",
"string",
")",
"(",
"[",
"]",
"Rect",
",",
"error",
")",
"{",
"if",
"AltLookupFn",
"!=",
"nil",
"{",
"return",
"AltLookupFn",
"(",
"ctx",
",",
"address",
")",
"\n",
"}",
"\n",
... | // Lookup returns rectangles for the given address. Currently the only
// implementation is the Google geocoding service. | [
"Lookup",
"returns",
"rectangles",
"for",
"the",
"given",
"address",
".",
"Currently",
"the",
"only",
"implementation",
"is",
"the",
"Google",
"geocoding",
"service",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/geocode/geocode.go#L120-L163 | train |
perkeep/perkeep | website/pk-web/pkweb.go | htmlFmt | func htmlFmt(w io.Writer, format string, x ...interface{}) string {
writeAny(w, true, x[0])
return ""
} | go | func htmlFmt(w io.Writer, format string, x ...interface{}) string {
writeAny(w, true, x[0])
return ""
} | [
"func",
"htmlFmt",
"(",
"w",
"io",
".",
"Writer",
",",
"format",
"string",
",",
"x",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"writeAny",
"(",
"w",
",",
"true",
",",
"x",
"[",
"0",
"]",
")",
"\n",
"return",
"\"\"",
"\n",
"}"
] | // Template formatter for "html" format. | [
"Template",
"formatter",
"for",
"html",
"format",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L133-L136 | train |
perkeep/perkeep | website/pk-web/pkweb.go | htmlEscFmt | func htmlEscFmt(w io.Writer, format string, x ...interface{}) string {
var buf bytes.Buffer
writeAny(&buf, false, x[0])
template.HTMLEscape(w, buf.Bytes())
return ""
} | go | func htmlEscFmt(w io.Writer, format string, x ...interface{}) string {
var buf bytes.Buffer
writeAny(&buf, false, x[0])
template.HTMLEscape(w, buf.Bytes())
return ""
} | [
"func",
"htmlEscFmt",
"(",
"w",
"io",
".",
"Writer",
",",
"format",
"string",
",",
"x",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"writeAny",
"(",
"&",
"buf",
",",
"false",
",",
"x",
"[",
"0",
"... | // Template formatter for "htmlesc" format. | [
"Template",
"formatter",
"for",
"htmlesc",
"format",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L139-L144 | train |
perkeep/perkeep | website/pk-web/pkweb.go | writeAny | func writeAny(w io.Writer, html bool, x interface{}) {
switch v := x.(type) {
case []byte:
writeText(w, v, html)
case string:
writeText(w, []byte(v), html)
default:
if html {
var buf bytes.Buffer
fmt.Fprint(&buf, x)
writeText(w, buf.Bytes(), true)
} else {
fmt.Fprint(w, x)
}
}
} | go | func writeAny(w io.Writer, html bool, x interface{}) {
switch v := x.(type) {
case []byte:
writeText(w, v, html)
case string:
writeText(w, []byte(v), html)
default:
if html {
var buf bytes.Buffer
fmt.Fprint(&buf, x)
writeText(w, buf.Bytes(), true)
} else {
fmt.Fprint(w, x)
}
}
} | [
"func",
"writeAny",
"(",
"w",
"io",
".",
"Writer",
",",
"html",
"bool",
",",
"x",
"interface",
"{",
"}",
")",
"{",
"switch",
"v",
":=",
"x",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"byte",
":",
"writeText",
"(",
"w",
",",
"v",
",",
"htm... | // Write anything to w; optionally html-escaped. | [
"Write",
"anything",
"to",
"w",
";",
"optionally",
"html",
"-",
"escaped",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L147-L162 | train |
perkeep/perkeep | website/pk-web/pkweb.go | writeText | func writeText(w io.Writer, text []byte, html bool) {
if html {
template.HTMLEscape(w, text)
return
}
w.Write(text)
} | go | func writeText(w io.Writer, text []byte, html bool) {
if html {
template.HTMLEscape(w, text)
return
}
w.Write(text)
} | [
"func",
"writeText",
"(",
"w",
"io",
".",
"Writer",
",",
"text",
"[",
"]",
"byte",
",",
"html",
"bool",
")",
"{",
"if",
"html",
"{",
"template",
".",
"HTMLEscape",
"(",
"w",
",",
"text",
")",
"\n",
"return",
"\n",
"}",
"\n",
"w",
".",
"Write",
... | // Write text to w; optionally html-escaped. | [
"Write",
"text",
"to",
"w",
";",
"optionally",
"html",
"-",
"escaped",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L165-L171 | train |
perkeep/perkeep | website/pk-web/pkweb.go | redirectPath | func redirectPath(u *url.URL) string {
// Redirect old gitweb URLs to gerrit. Example:
// /code/?p=camlistore.git;a=commit;h=b0d2a8f0e5f27bbfc025a96ec3c7896b42d198ed
if strings.HasPrefix(u.Path, "/code/") {
m := gitwebCommit.FindStringSubmatch(u.RawQuery)
if len(m) == 2 {
return gerritURLPrefix + m[1]
}
}
if strings.HasPrefix(u.Path, "/gw/") {
path := strings.TrimPrefix(u.Path, "/gw/")
if commitHash.MatchString(path) {
// Assume it's a commit
return gerritURLPrefix + path
}
return gerritURLPrefix + "master/" + path
}
if strings.HasPrefix(u.Path, "/docs/") {
return "/doc/" + strings.TrimPrefix(u.Path, "/docs/")
}
// strip directory index files
for _, x := range indexFiles {
if strings.HasSuffix(u.Path, "/"+x) {
return strings.TrimSuffix(u.Path, x)
}
}
// strip common file extensions
for _, x := range fileExtensions {
if strings.HasSuffix(u.Path, x) {
return strings.TrimSuffix(u.Path, x)
}
}
return ""
} | 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]
}
}
if strings.HasPrefix(u.Path, "/gw/") {
path := strings.TrimPrefix(u.Path, "/gw/")
if commitHash.MatchString(path) {
// Assume it's a commit
return gerritURLPrefix + path
}
return gerritURLPrefix + "master/" + path
}
if strings.HasPrefix(u.Path, "/docs/") {
return "/doc/" + strings.TrimPrefix(u.Path, "/docs/")
}
// strip directory index files
for _, x := range indexFiles {
if strings.HasSuffix(u.Path, "/"+x) {
return strings.TrimSuffix(u.Path, x)
}
}
// strip common file extensions
for _, x := range fileExtensions {
if strings.HasSuffix(u.Path, x) {
return strings.TrimSuffix(u.Path, x)
}
}
return ""
} | [
"func",
"redirectPath",
"(",
"u",
"*",
"url",
".",
"URL",
")",
"string",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"u",
".",
"Path",
",",
"\"/code/\"",
")",
"{",
"m",
":=",
"gitwebCommit",
".",
"FindStringSubmatch",
"(",
"u",
".",
"RawQuery",
")",
... | // empty return value means don't redirect. | [
"empty",
"return",
"value",
"means",
"don",
"t",
"redirect",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L269-L307 | train |
perkeep/perkeep | website/pk-web/pkweb.go | serveFile | func serveFile(w http.ResponseWriter, r *http.Request, absPath string) {
if !strings.HasSuffix(absPath, ".html") && !strings.HasSuffix(absPath, ".md") {
http.ServeFile(w, r, absPath)
return
}
data, err := ioutil.ReadFile(absPath)
if err != nil {
serveError(w, r, absPath, err)
return
}
// AutoHeadingIDs is the only extension missing
data = blackfriday.Run(data, blackfriday.WithExtensions(blackfriday.CommonExtensions|blackfriday.AutoHeadingIDs))
title := ""
if m := h1TitlePattern.FindSubmatch(data); len(m) > 1 {
title = string(m[1])
}
servePage(w, r, pageParams{
title: title,
content: data,
})
} | 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 is the only extension missing
data = blackfriday.Run(data, blackfriday.WithExtensions(blackfriday.CommonExtensions|blackfriday.AutoHeadingIDs))
title := ""
if m := h1TitlePattern.FindSubmatch(data); len(m) > 1 {
title = string(m[1])
}
servePage(w, r, pageParams{
title: title,
content: data,
})
} | [
"func",
"serveFile",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"absPath",
"string",
")",
"{",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"absPath",
",",
"\".html\"",
")",
"&&",
"!",
"strings",
".",
"HasSuffi... | // serveFile serves a file from disk, converting any markdown to HTML. | [
"serveFile",
"serves",
"a",
"file",
"from",
"disk",
"converting",
"any",
"markdown",
"to",
"HTML",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L436-L460 | train |
perkeep/perkeep | website/pk-web/pkweb.go | runAsChild | func runAsChild(res string) {
cmdName, err := exec.LookPath(res)
if err != nil {
log.Fatalf("Could not find %v in $PATH: %v", res, err)
}
cmd := exec.Command(cmdName)
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
log.Printf("Running %v", res)
if err := cmd.Start(); err != nil {
log.Fatalf("Program %v failed to start: %v", res, err)
}
go func() {
if err := cmd.Wait(); err != nil {
log.Fatalf("Program %s did not end successfully: %v", res, err)
}
}()
} | 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 to start: %v", res, err)
}
go func() {
if err := cmd.Wait(); err != nil {
log.Fatalf("Program %s did not end successfully: %v", res, err)
}
}()
} | [
"func",
"runAsChild",
"(",
"res",
"string",
")",
"{",
"cmdName",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"res",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"Could not find %v in $PATH: %v\"",
",",
"res",
",",
"err",
"... | // runAsChild runs res as a child process and
// does not wait for it to finish. | [
"runAsChild",
"runs",
"res",
"as",
"a",
"child",
"process",
"and",
"does",
"not",
"wait",
"for",
"it",
"to",
"finish",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L490-L507 | train |
perkeep/perkeep | website/pk-web/pkweb.go | runDemoBlobServerContainer | func runDemoBlobServerContainer(name string) error {
removeContainer(name)
cmd := exec.Command("docker", "run",
"--rm",
"--name="+name,
"-e", "CAMLI_ROOT="+prodSrcDir+"/website/blobserver-example/root",
"-e", "CAMLI_PASSWORD="+randHex(20),
"-v", pkSrcDir()+":"+prodSrcDir,
"--net=host",
"--workdir="+prodSrcDir,
"camlistore/demoblobserver",
"camlistored",
"--openbrowser=false",
"--listen=:3179",
"--configfile="+prodSrcDir+"/website/blobserver-example/example-blobserver-config.json")
stderr := &writerutil.PrefixSuffixSaver{N: 32 << 10}
cmd.Stderr = stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("failed to run demo blob server: %v, stderr: %v", err, string(stderr.Bytes()))
}
return nil
} | 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="+prodSrcDir,
"camlistore/demoblobserver",
"camlistored",
"--openbrowser=false",
"--listen=:3179",
"--configfile="+prodSrcDir+"/website/blobserver-example/example-blobserver-config.json")
stderr := &writerutil.PrefixSuffixSaver{N: 32 << 10}
cmd.Stderr = stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("failed to run demo blob server: %v, stderr: %v", err, string(stderr.Bytes()))
}
return nil
} | [
"func",
"runDemoBlobServerContainer",
"(",
"name",
"string",
")",
"error",
"{",
"removeContainer",
"(",
"name",
")",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"docker\"",
",",
"\"run\"",
",",
"\"--rm\"",
",",
"\"--name=\"",
"+",
"name",
",",
"\"-e\""... | // runDemoBlobServerContainer runs the demo blobserver as name in a docker
// container. It is not run in daemon mode, so it never returns if successful. | [
"runDemoBlobServerContainer",
"runs",
"the",
"demo",
"blobserver",
"as",
"name",
"in",
"a",
"docker",
"container",
".",
"It",
"is",
"not",
"run",
"in",
"daemon",
"mode",
"so",
"it",
"never",
"returns",
"if",
"successful",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/website/pk-web/pkweb.go#L704-L725 | train |
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.JWTConfigFromJSON(jsonSlurp, logging.WriteScope)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
return jwtConf.Client(context.Background())
} | 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.JWTConfigFromJSON(jsonSlurp, logging.WriteScope)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
return jwtConf.Client(context.Background())
} | [
"func",
"httpClient",
"(",
"projID",
"string",
")",
"*",
"http",
".",
"Client",
"{",
"if",
"*",
"gceJWTFile",
"==",
"\"\"",
"{",
"log",
".",
"Fatal",
"(",
"\"Cannot initialize an authorized http Client without --gce_jwt_file\"",
")",
"\n",
"}",
"\n",
"jsonSlurp",
... | // 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 | train |
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 | train |
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(parts) < 2 {
http.Error(rw, "Malformed GET URL.", 400)
return
}
blobRef, ok := blob.Parse(parts[1])
if !ok {
http.Error(rw, "Malformed GET URL.", 400)
return
}
// only serves its ref
if blobRef != ref {
log.Printf("videothumbnail: access to %v forbidden; wrong blobref for handler", blobRef)
http.Error(rw, "Forbidden.", 403)
return
}
rw.Header().Set("Content-Type", "application/octet-stream")
fr, err := schema.NewFileReader(req.Context(), fetcher, ref)
if err != nil {
httputil.ServeError(rw, req, err)
return
}
defer fr.Close()
http.ServeContent(rw, req, "", time.Now(), fr)
} | 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(parts) < 2 {
http.Error(rw, "Malformed GET URL.", 400)
return
}
blobRef, ok := blob.Parse(parts[1])
if !ok {
http.Error(rw, "Malformed GET URL.", 400)
return
}
// only serves its ref
if blobRef != ref {
log.Printf("videothumbnail: access to %v forbidden; wrong blobref for handler", blobRef)
http.Error(rw, "Forbidden.", 403)
return
}
rw.Header().Set("Content-Type", "application/octet-stream")
fr, err := schema.NewFileReader(req.Context(), fetcher, ref)
if err != nil {
httputil.ServeError(rw, req, err)
return
}
defer fr.Close()
http.ServeContent(rw, req, "", time.Now(), fr)
} | [
"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 | train |
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 | train |
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",
":=",
"\"\"",
"\n",
"comment",
":=",
"\"camlistore\"",
"\n",
"email",
":=",
"\"\"",
"\n",
"return",
"openpgp",
".",
"NewEntity",
"(",
"name",
",",
"comme... | // 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 | train |
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 %s: %v", secRing, err)
}
if len(el) != 1 {
return "", fmt.Errorf("Secret ring file %v contained %d identities; expected 1", secRing, len(el))
}
ent := el[0]
return ent.PrimaryKey.KeyIdString(), nil
} | 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 %s: %v", secRing, err)
}
if len(el) != 1 {
return "", fmt.Errorf("Secret ring file %v contained %d identities; expected 1", secRing, len(el))
}
ent := el[0]
return ent.PrimaryKey.KeyIdString(), nil
} | [
"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 | train |
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.O_EXCL, 0600)
if err != nil {
return "", err
}
err = WriteKeyRing(f, openpgp.EntityList([]*openpgp.Entity{ent}))
if err != nil {
f.Close()
return "", fmt.Errorf("Could not write new key ring to %s: %v", secRing, err)
}
if err := f.Close(); err != nil {
return "", fmt.Errorf("Could not close %v: %v", secRing, err)
}
return ent.PrimaryKey.KeyIdString(), nil
} | 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.O_EXCL, 0600)
if err != nil {
return "", err
}
err = WriteKeyRing(f, openpgp.EntityList([]*openpgp.Entity{ent}))
if err != nil {
f.Close()
return "", fmt.Errorf("Could not write new key ring to %s: %v", secRing, err)
}
if err := f.Close(); err != nil {
return "", fmt.Errorf("Could not close %v: %v", secRing, err)
}
return ent.PrimaryKey.KeyIdString(), nil
} | [
"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 | train |
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 precludes use of any other options")
}
if inGopherJS {
c.noExtConfig = true
c.sameOrigin = true
}
if c.noExtConfig {
c.setDefaultHTTPClient()
return c, nil
}
if c.server != "" {
if !isURLOrHostPort(c.server) {
configOnce.Do(parseConfig)
serverConf, ok := config.Servers[c.server]
if !ok {
log.Fatalf("%q looks like a server alias, but no such alias found in config at %v", c.server, osutil.UserClientConfigPath())
}
c.server = serverConf.Server
}
c.setDefaultHTTPClient()
return c, nil
}
var err error
c.server, err = getServer()
if err != nil {
return nil, err
}
err = c.SetupAuth()
if err != nil {
return nil, err
}
c.setDefaultHTTPClient()
return c, nil
} | 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 precludes use of any other options")
}
if inGopherJS {
c.noExtConfig = true
c.sameOrigin = true
}
if c.noExtConfig {
c.setDefaultHTTPClient()
return c, nil
}
if c.server != "" {
if !isURLOrHostPort(c.server) {
configOnce.Do(parseConfig)
serverConf, ok := config.Servers[c.server]
if !ok {
log.Fatalf("%q looks like a server alias, but no such alias found in config at %v", c.server, osutil.UserClientConfigPath())
}
c.server = serverConf.Server
}
c.setDefaultHTTPClient()
return c, nil
}
var err error
c.server, err = getServer()
if err != nil {
return nil, err
}
err = c.SetupAuth()
if err != nil {
return nil, err
}
c.setDefaultHTTPClient()
return c, nil
} | [
"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 | train |
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",
"(",
"\"error creating client: %v\"",
",",
"err",
")",
... | // 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 | train |
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.authMode
pc.discoOnce.Do(noop)
return pc, nil
} | 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.authMode
pc.discoOnce.Do(noop)
return pc, nil
} | [
"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 | train |
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 consequence when on the
// browser.
return nil
}
if c == nil {
return nil
}
var transport http.RoundTripper
proxy := http.ProxyFromEnvironment
if tc != nil && tc.Proxy != nil {
proxy = tc.Proxy
}
if c.useHTTP2(tc) {
transport = &http2.Transport{
DialTLS: c.http2DialTLSFunc(),
}
} else {
transport = &http.Transport{
DialTLS: c.DialTLSFunc(),
Dial: c.DialFunc(),
Proxy: proxy,
MaxIdleConnsPerHost: maxParallelHTTP_h1,
}
}
httpStats := &httputil.StatsTransport{
Transport: transport,
}
if tc != nil {
httpStats.VerboseLog = tc.Verbose
}
transport = httpStats
if android.IsChild() {
transport = &android.StatsTransport{transport}
}
return transport
} | 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 consequence when on the
// browser.
return nil
}
if c == nil {
return nil
}
var transport http.RoundTripper
proxy := http.ProxyFromEnvironment
if tc != nil && tc.Proxy != nil {
proxy = tc.Proxy
}
if c.useHTTP2(tc) {
transport = &http2.Transport{
DialTLS: c.http2DialTLSFunc(),
}
} else {
transport = &http.Transport{
DialTLS: c.DialTLSFunc(),
Dial: c.DialFunc(),
Proxy: proxy,
MaxIdleConnsPerHost: maxParallelHTTP_h1,
}
}
httpStats := &httputil.StatsTransport{
Transport: transport,
}
if tc != nil {
httpStats.VerboseLog = tc.Verbose
}
transport = httpStats
if android.IsChild() {
transport = &android.StatsTransport{transport}
}
return transport
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"transportForConfig",
"(",
"tc",
"*",
"TransportConfig",
")",
"http",
".",
"RoundTripper",
"{",
"if",
"inGopherJS",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"c",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
... | // 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 | train |
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 | train |
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(opts)], OptionServer(m[1]))...)
if err != nil {
return nil, blob.Ref{}, err
}
c.discoOnce.Do(noop)
c.prefixOnce.Do(noop)
c.prefixv = m[1]
c.isSharePrefix = true
c.authMode = auth.None{}
c.via = make(map[blob.Ref]blob.Ref)
root = m[2]
req := c.newRequest(ctx, "GET", shareBlobURL, nil)
res, err := c.expect2XX(req)
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error fetching %s: %v", shareBlobURL, err)
}
defer res.Body.Close()
var buf bytes.Buffer
rootbr, ok := blob.Parse(root)
if !ok {
return nil, blob.Ref{}, fmt.Errorf("invalid root blob ref for sharing: %q", root)
}
b, err := schema.BlobFromReader(rootbr, io.TeeReader(res.Body, &buf))
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error parsing JSON from %s: %v , with response: %q", shareBlobURL, err, buf.Bytes())
}
if b.ShareAuthType() != schema.ShareHaveRef {
return nil, blob.Ref{}, fmt.Errorf("unknown share authType of %q", b.ShareAuthType())
}
target = b.ShareTarget()
if !target.Valid() {
return nil, blob.Ref{}, fmt.Errorf("no target")
}
c.via[target] = rootbr
return c, target, nil
} | 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(opts)], OptionServer(m[1]))...)
if err != nil {
return nil, blob.Ref{}, err
}
c.discoOnce.Do(noop)
c.prefixOnce.Do(noop)
c.prefixv = m[1]
c.isSharePrefix = true
c.authMode = auth.None{}
c.via = make(map[blob.Ref]blob.Ref)
root = m[2]
req := c.newRequest(ctx, "GET", shareBlobURL, nil)
res, err := c.expect2XX(req)
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error fetching %s: %v", shareBlobURL, err)
}
defer res.Body.Close()
var buf bytes.Buffer
rootbr, ok := blob.Parse(root)
if !ok {
return nil, blob.Ref{}, fmt.Errorf("invalid root blob ref for sharing: %q", root)
}
b, err := schema.BlobFromReader(rootbr, io.TeeReader(res.Body, &buf))
if err != nil {
return nil, blob.Ref{}, fmt.Errorf("error parsing JSON from %s: %v , with response: %q", shareBlobURL, err, buf.Bytes())
}
if b.ShareAuthType() != schema.ShareHaveRef {
return nil, blob.Ref{}, fmt.Errorf("unknown share authType of %q", b.ShareAuthType())
}
target = b.ShareTarget()
if !target.Valid() {
return nil, blob.Ref{}, fmt.Errorf("no target")
}
c.via[target] = rootbr
return c, target, nil
} | [
"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 | train |
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 | train |
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 | train |
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 | train |
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",
"c",... | // 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 | train |
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",
"c",
... | // 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 | train |
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",
"c",
... | // 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 | train |
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",
"c"... | // 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 | train |
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",
"if",... | // 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 such a value, the error will be
// ErrNoStorageGeneration. | [
"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 | train |
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 | train |
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 | train |
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
}
res := new(search.RecentResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | 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
}
res := new(search.RecentResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | [
"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 | train |
perkeep/perkeep | pkg/client/client.go | GetPermanodesWithAttr | func (c *Client) GetPermanodesWithAttr(ctx context.Context, req *search.WithAttrRequest) (*search.WithAttrResponse, 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
}
res := new(search.WithAttrResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | go | func (c *Client) GetPermanodesWithAttr(ctx context.Context, req *search.WithAttrRequest) (*search.WithAttrResponse, 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
}
res := new(search.WithAttrResponse)
if err := httputil.DecodeJSON(hres, res); err != nil {
return nil, err
}
if err := res.Err(); err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetPermanodesWithAttr",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"search",
".",
"WithAttrRequest",
")",
"(",
"*",
"search",
".",
"WithAttrResponse",
",",
"error",
")",
"{",
"sr",
",",
"err",
":=",
"... | // GetPermanodesWithAttr searches for permanodes that match the given search request.
// The Fuzzy option in the request must not be set, and the Attribute option
// must be set.
// Only indexed attributes may be queried. | [
"GetPermanodesWithAttr",
"searches",
"for",
"permanodes",
"that",
"match",
"the",
"given",
"search",
"request",
".",
"The",
"Fuzzy",
"option",
"in",
"the",
"request",
"must",
"not",
"be",
"set",
"and",
"the",
"Attribute",
"option",
"must",
"be",
"set",
".",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L723-L742 | train |
perkeep/perkeep | pkg/client/client.go | QueryRaw | func (c *Client) QueryRaw(ctx context.Context, req *search.SearchQuery) ([]byte, error) {
hres, err := c.query(ctx, req)
if err != nil {
return nil, err
}
defer hres.Body.Close()
return ioutil.ReadAll(hres.Body)
} | go | func (c *Client) QueryRaw(ctx context.Context, req *search.SearchQuery) ([]byte, error) {
hres, err := c.query(ctx, req)
if err != nil {
return nil, err
}
defer hres.Body.Close()
return ioutil.ReadAll(hres.Body)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"QueryRaw",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"search",
".",
"SearchQuery",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"hres",
",",
"err",
":=",
"c",
".",
"query",
"(",
"ctx",
... | // QueryRaw sends req and returns the body of the response, which should be the
// unparsed JSON of a search.SearchResult. | [
"QueryRaw",
"sends",
"req",
"and",
"returns",
"the",
"body",
"of",
"the",
"response",
"which",
"should",
"be",
"the",
"unparsed",
"JSON",
"of",
"a",
"search",
".",
"SearchResult",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L812-L819 | train |
perkeep/perkeep | pkg/client/client.go | versionMismatch | func (c *Client) versionMismatch(ctx context.Context) (bool, error) {
const shortRFC3339 = "2006-01-02"
version := buildinfo.GitInfo
if version == "" {
return false, errors.New("unknown client version")
}
version = version[:10] // keep only the date part
clientDate, err := time.Parse(shortRFC3339, version)
if err != nil {
return false, fmt.Errorf("could not parse date from version %q: %v", version, err)
}
apiChangeDate, _ := time.Parse(shortRFC3339, "2018-01-13")
if !clientDate.After(apiChangeDate) {
// client is old enough, all good.
return false, nil
}
url := c.discoRoot() + "/status/status.json"
req := c.newRequest(ctx, "GET", url)
res, err := c.doReqGated(req)
if err != nil {
return false, err
}
if res.StatusCode != 200 {
body, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1<<20))
res.Body.Close()
return false, fmt.Errorf("got status code %d from URL %s; body %s", res.StatusCode, url, body)
}
var status struct {
Version string `json:"version"`
}
if err := httputil.DecodeJSON(res, &status); err != nil {
return false, fmt.Errorf("error parsing JSON from URL %s: %v", url, err)
}
serverVersion := status.Version[:10]
serverDate, err := time.Parse(shortRFC3339, serverVersion)
if err != nil {
return false, fmt.Errorf("could not parse date from server version %q: %v", status.Version, err)
}
if serverDate.After(apiChangeDate) {
// server is recent enough, all good.
return false, nil
}
return true, nil
} | go | func (c *Client) versionMismatch(ctx context.Context) (bool, error) {
const shortRFC3339 = "2006-01-02"
version := buildinfo.GitInfo
if version == "" {
return false, errors.New("unknown client version")
}
version = version[:10] // keep only the date part
clientDate, err := time.Parse(shortRFC3339, version)
if err != nil {
return false, fmt.Errorf("could not parse date from version %q: %v", version, err)
}
apiChangeDate, _ := time.Parse(shortRFC3339, "2018-01-13")
if !clientDate.After(apiChangeDate) {
// client is old enough, all good.
return false, nil
}
url := c.discoRoot() + "/status/status.json"
req := c.newRequest(ctx, "GET", url)
res, err := c.doReqGated(req)
if err != nil {
return false, err
}
if res.StatusCode != 200 {
body, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1<<20))
res.Body.Close()
return false, fmt.Errorf("got status code %d from URL %s; body %s", res.StatusCode, url, body)
}
var status struct {
Version string `json:"version"`
}
if err := httputil.DecodeJSON(res, &status); err != nil {
return false, fmt.Errorf("error parsing JSON from URL %s: %v", url, err)
}
serverVersion := status.Version[:10]
serverDate, err := time.Parse(shortRFC3339, serverVersion)
if err != nil {
return false, fmt.Errorf("could not parse date from server version %q: %v", status.Version, err)
}
if serverDate.After(apiChangeDate) {
// server is recent enough, all good.
return false, nil
}
return true, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"versionMismatch",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"bool",
",",
"error",
")",
"{",
"const",
"shortRFC3339",
"=",
"\"2006-01-02\"",
"\n",
"version",
":=",
"buildinfo",
".",
"GitInfo",
"\n",
"if",
"ver... | // versionMismatch returns true if the server was built before 2018-01-13 and
// the client was built at or after 2018-01-13. | [
"versionMismatch",
"returns",
"true",
"if",
"the",
"server",
"was",
"built",
"before",
"2018",
"-",
"01",
"-",
"13",
"and",
"the",
"client",
"was",
"built",
"at",
"or",
"after",
"2018",
"-",
"01",
"-",
"13",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L884-L927 | train |
perkeep/perkeep | pkg/client/client.go | FileHasContents | func (c *Client) FileHasContents(ctx context.Context, f, wholeRef blob.Ref) bool {
if err := c.condDiscovery(); err != nil {
return false
}
if c.downloadHelper == "" {
return false
}
req := c.newRequest(ctx, "HEAD", c.downloadHelper+f.String()+"/?verifycontents="+wholeRef.String())
res, err := c.expect2XX(req)
if err != nil {
log.Printf("download helper HEAD error: %v", err)
return false
}
defer res.Body.Close()
return res.Header.Get("X-Camli-Contents") == wholeRef.String()
} | go | func (c *Client) FileHasContents(ctx context.Context, f, wholeRef blob.Ref) bool {
if err := c.condDiscovery(); err != nil {
return false
}
if c.downloadHelper == "" {
return false
}
req := c.newRequest(ctx, "HEAD", c.downloadHelper+f.String()+"/?verifycontents="+wholeRef.String())
res, err := c.expect2XX(req)
if err != nil {
log.Printf("download helper HEAD error: %v", err)
return false
}
defer res.Body.Close()
return res.Header.Get("X-Camli-Contents") == wholeRef.String()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"FileHasContents",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
",",
"wholeRef",
"blob",
".",
"Ref",
")",
"bool",
"{",
"if",
"err",
":=",
"c",
".",
"condDiscovery",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
... | // FileHasContents returns true iff f refers to a "file" or "bytes" schema blob,
// the server is configured with a "download helper", and the server responds
// that all chunks of 'f' are available and match the digest of wholeRef. | [
"FileHasContents",
"returns",
"true",
"iff",
"f",
"refers",
"to",
"a",
"file",
"or",
"bytes",
"schema",
"blob",
"the",
"server",
"is",
"configured",
"with",
"a",
"download",
"helper",
"and",
"the",
"server",
"responds",
"that",
"all",
"chunks",
"of",
"f",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L932-L947 | train |
perkeep/perkeep | pkg/client/client.go | initPrefix | func (c *Client) initPrefix() error {
c.isSharePrefix = false
root := c.discoRoot()
u, err := url.Parse(root)
if err != nil {
return err
}
if len(u.Path) > 1 {
c.prefixv = strings.TrimRight(root, "/")
return nil
}
return c.condDiscovery()
} | go | func (c *Client) initPrefix() error {
c.isSharePrefix = false
root := c.discoRoot()
u, err := url.Parse(root)
if err != nil {
return err
}
if len(u.Path) > 1 {
c.prefixv = strings.TrimRight(root, "/")
return nil
}
return c.condDiscovery()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"initPrefix",
"(",
")",
"error",
"{",
"c",
".",
"isSharePrefix",
"=",
"false",
"\n",
"root",
":=",
"c",
".",
"discoRoot",
"(",
")",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"root",
")",
"\n",
... | // initPrefix uses the user provided server URL to define the URL
// prefix to the blobserver root. If the server URL has a path
// component then it is directly used, otherwise the blobRoot
// from the discovery is used as the path. | [
"initPrefix",
"uses",
"the",
"user",
"provided",
"server",
"URL",
"to",
"define",
"the",
"URL",
"prefix",
"to",
"the",
"blobserver",
"root",
".",
"If",
"the",
"server",
"URL",
"has",
"a",
"path",
"component",
"then",
"it",
"is",
"directly",
"used",
"otherw... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L994-L1006 | train |
perkeep/perkeep | pkg/client/client.go | DiscoveryDoc | func (c *Client) DiscoveryDoc(ctx context.Context) (io.Reader, error) {
res, err := c.discoveryResp(ctx)
if err != nil {
return nil, err
}
defer res.Body.Close()
const maxSize = 1 << 20
all, err := ioutil.ReadAll(io.LimitReader(res.Body, maxSize+1))
if err != nil {
return nil, err
}
if len(all) > maxSize {
return nil, errors.New("discovery document oddly large")
}
if len(all) > 0 && all[len(all)-1] != '\n' {
all = append(all, '\n')
}
return bytes.NewReader(all), err
} | go | func (c *Client) DiscoveryDoc(ctx context.Context) (io.Reader, error) {
res, err := c.discoveryResp(ctx)
if err != nil {
return nil, err
}
defer res.Body.Close()
const maxSize = 1 << 20
all, err := ioutil.ReadAll(io.LimitReader(res.Body, maxSize+1))
if err != nil {
return nil, err
}
if len(all) > maxSize {
return nil, errors.New("discovery document oddly large")
}
if len(all) > 0 && all[len(all)-1] != '\n' {
all = append(all, '\n')
}
return bytes.NewReader(all), err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DiscoveryDoc",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"discoveryResp",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil... | // DiscoveryDoc returns the server's JSON discovery document.
// This method exists purely for the "camtool discovery" command.
// Clients shouldn't have to parse this themselves. | [
"DiscoveryDoc",
"returns",
"the",
"server",
"s",
"JSON",
"discovery",
"document",
".",
"This",
"method",
"exists",
"purely",
"for",
"the",
"camtool",
"discovery",
"command",
".",
"Clients",
"shouldn",
"t",
"have",
"to",
"parse",
"this",
"themselves",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1018-L1036 | train |
perkeep/perkeep | pkg/client/client.go | GetJSON | func (c *Client) GetJSON(ctx context.Context, url string, data interface{}) error {
if !strings.HasPrefix(url, c.discoRoot()) {
return fmt.Errorf("wrong URL (%q) for this server", url)
}
hreq := c.newRequest(ctx, "GET", url)
resp, err := c.expect2XX(hreq)
if err != nil {
return err
}
return httputil.DecodeJSON(resp, data)
} | go | func (c *Client) GetJSON(ctx context.Context, url string, data interface{}) error {
if !strings.HasPrefix(url, c.discoRoot()) {
return fmt.Errorf("wrong URL (%q) for this server", url)
}
hreq := c.newRequest(ctx, "GET", url)
resp, err := c.expect2XX(hreq)
if err != nil {
return err
}
return httputil.DecodeJSON(resp, data)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetJSON",
"(",
"ctx",
"context",
".",
"Context",
",",
"url",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"url",
",",
"c",
".",
"discoRoot",
"("... | // GetJSON sends a GET request to url, and unmarshals the returned
// JSON response into data. The URL's host must match the client's
// configured server. | [
"GetJSON",
"sends",
"a",
"GET",
"request",
"to",
"url",
"and",
"unmarshals",
"the",
"returned",
"JSON",
"response",
"into",
"data",
".",
"The",
"URL",
"s",
"host",
"must",
"match",
"the",
"client",
"s",
"configured",
"server",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1160-L1170 | train |
perkeep/perkeep | pkg/client/client.go | Sign | func (c *Client) Sign(ctx context.Context, server string, r io.Reader) (signed []byte, err error) {
signHandler, err := c.SignHandler()
if err != nil {
return nil, err
}
signServer := strings.TrimSuffix(server, "/") + signHandler
resp, err := c.post(ctx, signServer, "application/x-www-form-urlencoded", r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
} | go | func (c *Client) Sign(ctx context.Context, server string, r io.Reader) (signed []byte, err error) {
signHandler, err := c.SignHandler()
if err != nil {
return nil, err
}
signServer := strings.TrimSuffix(server, "/") + signHandler
resp, err := c.post(ctx, signServer, "application/x-www-form-urlencoded", r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Sign",
"(",
"ctx",
"context",
".",
"Context",
",",
"server",
"string",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"signed",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"signHandler",
",",
"err",
":=",
"c"... | // Sign sends a request to the sign handler on server to sign the contents of r,
// and return them signed. It uses the same implementation details, such as gated
// requests, as Post. | [
"Sign",
"sends",
"a",
"request",
"to",
"the",
"sign",
"handler",
"on",
"server",
"to",
"sign",
"the",
"contents",
"of",
"r",
"and",
"return",
"them",
"signed",
".",
"It",
"uses",
"the",
"same",
"implementation",
"details",
"such",
"as",
"gated",
"requests"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1186-L1198 | train |
perkeep/perkeep | pkg/client/client.go | newRequest | func (c *Client) newRequest(ctx context.Context, method, url string, body ...io.Reader) *http.Request {
var bodyR io.Reader
if len(body) > 0 {
bodyR = body[0]
}
if len(body) > 1 {
panic("too many body arguments")
}
req, err := http.NewRequest(method, url, bodyR)
if err != nil {
panic(err.Error())
}
// not done by http.NewRequest in Go 1.0:
if br, ok := bodyR.(*bytes.Reader); ok {
req.ContentLength = int64(br.Len())
}
c.authMode.AddAuthHeader(req)
return req.WithContext(ctx)
} | go | func (c *Client) newRequest(ctx context.Context, method, url string, body ...io.Reader) *http.Request {
var bodyR io.Reader
if len(body) > 0 {
bodyR = body[0]
}
if len(body) > 1 {
panic("too many body arguments")
}
req, err := http.NewRequest(method, url, bodyR)
if err != nil {
panic(err.Error())
}
// not done by http.NewRequest in Go 1.0:
if br, ok := bodyR.(*bytes.Reader); ok {
req.ContentLength = int64(br.Len())
}
c.authMode.AddAuthHeader(req)
return req.WithContext(ctx)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"newRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"method",
",",
"url",
"string",
",",
"body",
"...",
"io",
".",
"Reader",
")",
"*",
"http",
".",
"Request",
"{",
"var",
"bodyR",
"io",
".",
"Reader",
"\n... | // newRequest creates a request with the authentication header, and with the
// appropriate scheme and port in the case of self-signed TLS. | [
"newRequest",
"creates",
"a",
"request",
"with",
"the",
"authentication",
"header",
"and",
"with",
"the",
"appropriate",
"scheme",
"and",
"port",
"in",
"the",
"case",
"of",
"self",
"-",
"signed",
"TLS",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1215-L1233 | train |
perkeep/perkeep | pkg/client/client.go | expect2XX | func (c *Client) expect2XX(req *http.Request) (*http.Response, error) {
res, err := c.doReqGated(req)
if err == nil && (res.StatusCode < 200 || res.StatusCode > 299) {
buf := new(bytes.Buffer)
io.CopyN(buf, res.Body, 1<<20)
res.Body.Close()
return res, fmt.Errorf("client: got status code %d from URL %s; body %s", res.StatusCode, req.URL.String(), buf.String())
}
return res, err
} | go | func (c *Client) expect2XX(req *http.Request) (*http.Response, error) {
res, err := c.doReqGated(req)
if err == nil && (res.StatusCode < 200 || res.StatusCode > 299) {
buf := new(bytes.Buffer)
io.CopyN(buf, res.Body, 1<<20)
res.Body.Close()
return res, fmt.Errorf("client: got status code %d from URL %s; body %s", res.StatusCode, req.URL.String(), buf.String())
}
return res, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"expect2XX",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"doReqGated",
"(",
"req",
")",
"\n",
"if",
"err",
"==... | // expect2XX will doReqGated and promote HTTP response codes outside of
// the 200-299 range to a non-nil error containing the response body. | [
"expect2XX",
"will",
"doReqGated",
"and",
"promote",
"HTTP",
"response",
"codes",
"outside",
"of",
"the",
"200",
"-",
"299",
"range",
"to",
"a",
"non",
"-",
"nil",
"error",
"containing",
"the",
"response",
"body",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1237-L1246 | train |
perkeep/perkeep | pkg/client/client.go | DialFunc | func (c *Client) DialFunc() func(network, addr string) (net.Conn, error) {
if c.useTLS() {
return nil
}
if android.IsChild() {
return func(network, addr string) (net.Conn, error) {
return android.Dial(network, addr)
}
}
return nil
} | go | func (c *Client) DialFunc() func(network, addr string) (net.Conn, error) {
if c.useTLS() {
return nil
}
if android.IsChild() {
return func(network, addr string) (net.Conn, error) {
return android.Dial(network, addr)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DialFunc",
"(",
")",
"func",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"if",
"c",
".",
"useTLS",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
... | // DialFunc returns the adequate dial function when we're on android. | [
"DialFunc",
"returns",
"the",
"adequate",
"dial",
"function",
"when",
"we",
"re",
"on",
"android",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1255-L1265 | train |
perkeep/perkeep | pkg/client/client.go | Signer | func (c *Client) Signer() (*schema.Signer, error) {
c.signerOnce.Do(c.signerInit)
return c.signer, c.signerErr
} | go | func (c *Client) Signer() (*schema.Signer, error) {
c.signerOnce.Do(c.signerInit)
return c.signer, c.signerErr
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Signer",
"(",
")",
"(",
"*",
"schema",
".",
"Signer",
",",
"error",
")",
"{",
"c",
".",
"signerOnce",
".",
"Do",
"(",
"c",
".",
"signerInit",
")",
"\n",
"return",
"c",
".",
"signer",
",",
"c",
".",
"signer... | // Signer returns the client's Signer, if any. The Signer signs JSON
// mutation claims. | [
"Signer",
"returns",
"the",
"client",
"s",
"Signer",
"if",
"any",
".",
"The",
"Signer",
"signs",
"JSON",
"mutation",
"claims",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1395-L1398 | train |
perkeep/perkeep | pkg/client/client.go | signBlob | func (c *Client) signBlob(ctx context.Context, bb schema.Buildable, sigTime time.Time) (string, error) {
signer, err := c.Signer()
if err != nil {
return "", err
}
return bb.Builder().SignAt(ctx, signer, sigTime)
} | go | func (c *Client) signBlob(ctx context.Context, bb schema.Buildable, sigTime time.Time) (string, error) {
signer, err := c.Signer()
if err != nil {
return "", err
}
return bb.Builder().SignAt(ctx, signer, sigTime)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"signBlob",
"(",
"ctx",
"context",
".",
"Context",
",",
"bb",
"schema",
".",
"Buildable",
",",
"sigTime",
"time",
".",
"Time",
")",
"(",
"string",
",",
"error",
")",
"{",
"signer",
",",
"err",
":=",
"c",
".",
... | // sigTime optionally specifies the signature time.
// If zero, the current time is used. | [
"sigTime",
"optionally",
"specifies",
"the",
"signature",
"time",
".",
"If",
"zero",
"the",
"current",
"time",
"is",
"used",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1414-L1420 | train |
perkeep/perkeep | pkg/client/client.go | checkMatchingKeys | func (c *Client) checkMatchingKeys() {
serverKey, err := c.ServerKeyID()
// The server provides the full (16 digit) key fingerprint but schema.Signer only stores
// the short (8 digit) key ID.
if err == nil && len(serverKey) >= 8 {
shortServerKey := serverKey[len(serverKey)-8:]
if shortServerKey != c.signer.KeyID() {
log.Printf("Warning: client (%s) and server (%s) keys differ.", c.signer.KeyID(), shortServerKey)
}
}
} | go | func (c *Client) checkMatchingKeys() {
serverKey, err := c.ServerKeyID()
// The server provides the full (16 digit) key fingerprint but schema.Signer only stores
// the short (8 digit) key ID.
if err == nil && len(serverKey) >= 8 {
shortServerKey := serverKey[len(serverKey)-8:]
if shortServerKey != c.signer.KeyID() {
log.Printf("Warning: client (%s) and server (%s) keys differ.", c.signer.KeyID(), shortServerKey)
}
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"checkMatchingKeys",
"(",
")",
"{",
"serverKey",
",",
"err",
":=",
"c",
".",
"ServerKeyID",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"len",
"(",
"serverKey",
")",
">=",
"8",
"{",
"shortServerKey",
":=",
... | // checkMatchingKeys compares the client's and the server's keys and logs if they differ. | [
"checkMatchingKeys",
"compares",
"the",
"client",
"s",
"and",
"the",
"server",
"s",
"keys",
"and",
"logs",
"if",
"they",
"differ",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/client/client.go#L1439-L1449 | train |
perkeep/perkeep | internal/images/fastjpeg/fastjpeg.go | Factor | func Factor(w, h, sw, sh int) int {
switch {
case w>>3 >= sw && h>>3 >= sh:
return 8
case w>>2 >= sw && h>>2 >= sh:
return 4
case w>>1 >= sw && h>>1 >= sh:
return 2
}
return 1
} | go | func Factor(w, h, sw, sh int) int {
switch {
case w>>3 >= sw && h>>3 >= sh:
return 8
case w>>2 >= sw && h>>2 >= sh:
return 4
case w>>1 >= sw && h>>1 >= sh:
return 2
}
return 1
} | [
"func",
"Factor",
"(",
"w",
",",
"h",
",",
"sw",
",",
"sh",
"int",
")",
"int",
"{",
"switch",
"{",
"case",
"w",
">>",
"3",
">=",
"sw",
"&&",
"h",
">>",
"3",
">=",
"sh",
":",
"return",
"8",
"\n",
"case",
"w",
">>",
"2",
">=",
"sw",
"&&",
"... | // Factor returns the sample factor DecodeSample should use to generate a
// sampled image greater than or equal to sw x sh pixels given a source image
// of w x h pixels. | [
"Factor",
"returns",
"the",
"sample",
"factor",
"DecodeSample",
"should",
"use",
"to",
"generate",
"a",
"sampled",
"image",
"greater",
"than",
"or",
"equal",
"to",
"sw",
"x",
"sh",
"pixels",
"given",
"a",
"source",
"image",
"of",
"w",
"x",
"h",
"pixels",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/fastjpeg/fastjpeg.go#L158-L168 | train |
perkeep/perkeep | internal/images/fastjpeg/fastjpeg.go | DecodeDownsample | func DecodeDownsample(r io.Reader, factor int) (image.Image, error) {
if !Available() {
return nil, ErrDjpegNotFound
}
switch factor {
case 1, 2, 4, 8:
default:
return nil, fmt.Errorf("fastjpeg: unsupported sample factor %d", factor)
}
buf := new(bytes.Buffer)
tr := io.TeeReader(r, buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, err
}
if format != "jpeg" {
return nil, fmt.Errorf("fastjpeg: Unsupported format %q", format)
}
var bpp int
switch ic.ColorModel {
case color.YCbCrModel:
bpp = 4 // JPEG will decode to RGB, and we'll expand inplace to RGBA.
case color.GrayModel:
bpp = 1
default:
return nil, fmt.Errorf("fastjpeg: Unsupported thumnbnail color model %T", ic.ColorModel)
}
args := []string{djpegBin, "-scale", fmt.Sprintf("1/%d", factor)}
cmd := exec.Command(args[0], args[1:]...)
cmd.Stdin = readerutil.NewStatsReader(djpegBytesWrittenVar, io.MultiReader(buf, r))
// Allocate space for the RGBA / Gray pixel data plus some extra for PNM
// header info. Explicitly allocate all the memory upfront to prevent
// many smaller allocations.
pixSize := ic.Width*ic.Height*bpp/factor/factor + 128
w := bytes.NewBuffer(make([]byte, 0, pixSize))
cmd.Stdout = w
stderrW := new(bytes.Buffer)
cmd.Stderr = stderrW
if err := cmd.Run(); err != nil {
djpegFailureVar.Add(1)
return nil, DjpegFailedError{Err: fmt.Errorf("%v: %s", err, stderrW)}
}
djpegSuccessVar.Add(1)
djpegBytesReadVar.Add(int64(w.Len()))
m, err := readPNM(w)
if err != nil {
return m, DjpegFailedError{Err: err}
}
return m, nil
} | go | func DecodeDownsample(r io.Reader, factor int) (image.Image, error) {
if !Available() {
return nil, ErrDjpegNotFound
}
switch factor {
case 1, 2, 4, 8:
default:
return nil, fmt.Errorf("fastjpeg: unsupported sample factor %d", factor)
}
buf := new(bytes.Buffer)
tr := io.TeeReader(r, buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, err
}
if format != "jpeg" {
return nil, fmt.Errorf("fastjpeg: Unsupported format %q", format)
}
var bpp int
switch ic.ColorModel {
case color.YCbCrModel:
bpp = 4 // JPEG will decode to RGB, and we'll expand inplace to RGBA.
case color.GrayModel:
bpp = 1
default:
return nil, fmt.Errorf("fastjpeg: Unsupported thumnbnail color model %T", ic.ColorModel)
}
args := []string{djpegBin, "-scale", fmt.Sprintf("1/%d", factor)}
cmd := exec.Command(args[0], args[1:]...)
cmd.Stdin = readerutil.NewStatsReader(djpegBytesWrittenVar, io.MultiReader(buf, r))
// Allocate space for the RGBA / Gray pixel data plus some extra for PNM
// header info. Explicitly allocate all the memory upfront to prevent
// many smaller allocations.
pixSize := ic.Width*ic.Height*bpp/factor/factor + 128
w := bytes.NewBuffer(make([]byte, 0, pixSize))
cmd.Stdout = w
stderrW := new(bytes.Buffer)
cmd.Stderr = stderrW
if err := cmd.Run(); err != nil {
djpegFailureVar.Add(1)
return nil, DjpegFailedError{Err: fmt.Errorf("%v: %s", err, stderrW)}
}
djpegSuccessVar.Add(1)
djpegBytesReadVar.Add(int64(w.Len()))
m, err := readPNM(w)
if err != nil {
return m, DjpegFailedError{Err: err}
}
return m, nil
} | [
"func",
"DecodeDownsample",
"(",
"r",
"io",
".",
"Reader",
",",
"factor",
"int",
")",
"(",
"image",
".",
"Image",
",",
"error",
")",
"{",
"if",
"!",
"Available",
"(",
")",
"{",
"return",
"nil",
",",
"ErrDjpegNotFound",
"\n",
"}",
"\n",
"switch",
"fac... | // DecodeDownsample decodes JPEG data in r, down-sampling it by factor.
// If djpeg is not found, err is ErrDjpegNotFound and r is not read from.
// If the execution of djpeg, or decoding the resulting PNM fails, error will
// be of type DjpegFailedError. | [
"DecodeDownsample",
"decodes",
"JPEG",
"data",
"in",
"r",
"down",
"-",
"sampling",
"it",
"by",
"factor",
".",
"If",
"djpeg",
"is",
"not",
"found",
"err",
"is",
"ErrDjpegNotFound",
"and",
"r",
"is",
"not",
"read",
"from",
".",
"If",
"the",
"execution",
"o... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/fastjpeg/fastjpeg.go#L174-L226 | train |
perkeep/perkeep | pkg/schema/blob.go | ClaimDate | func (b *Blob) ClaimDate() (time.Time, error) {
var ct time.Time
claimDate := b.ss.ClaimDate
if claimDate.IsAnyZero() {
return ct, MissingFieldError("claimDate")
}
return claimDate.Time(), nil
} | go | func (b *Blob) ClaimDate() (time.Time, error) {
var ct time.Time
claimDate := b.ss.ClaimDate
if claimDate.IsAnyZero() {
return ct, MissingFieldError("claimDate")
}
return claimDate.Time(), nil
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"ClaimDate",
"(",
")",
"(",
"time",
".",
"Time",
",",
"error",
")",
"{",
"var",
"ct",
"time",
".",
"Time",
"\n",
"claimDate",
":=",
"b",
".",
"ss",
".",
"ClaimDate",
"\n",
"if",
"claimDate",
".",
"IsAnyZero",
"... | // ClaimDate returns the "claimDate" field.
// If there is no claimDate, the error will be a MissingFieldError. | [
"ClaimDate",
"returns",
"the",
"claimDate",
"field",
".",
"If",
"there",
"is",
"no",
"claimDate",
"the",
"error",
"will",
"be",
"a",
"MissingFieldError",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L92-L99 | train |
perkeep/perkeep | pkg/schema/blob.go | ByteParts | func (b *Blob) ByteParts() []BytesPart {
// TODO: move this method off Blob, and make the caller go
// through a (*Blob).ByteBackedBlob() comma-ok accessor first.
s := make([]BytesPart, len(b.ss.Parts))
for i, part := range b.ss.Parts {
s[i] = *part
}
return s
} | go | func (b *Blob) ByteParts() []BytesPart {
// TODO: move this method off Blob, and make the caller go
// through a (*Blob).ByteBackedBlob() comma-ok accessor first.
s := make([]BytesPart, len(b.ss.Parts))
for i, part := range b.ss.Parts {
s[i] = *part
}
return s
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"ByteParts",
"(",
")",
"[",
"]",
"BytesPart",
"{",
"s",
":=",
"make",
"(",
"[",
"]",
"BytesPart",
",",
"len",
"(",
"b",
".",
"ss",
".",
"Parts",
")",
")",
"\n",
"for",
"i",
",",
"part",
":=",
"range",
"b",
... | // ByteParts returns the "parts" field. The caller owns the returned
// slice. | [
"ByteParts",
"returns",
"the",
"parts",
"field",
".",
"The",
"caller",
"owns",
"the",
"returned",
"slice",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L103-L111 | train |
perkeep/perkeep | pkg/schema/blob.go | AsClaim | func (b *Blob) AsClaim() (c Claim, ok bool) {
if b.ss.Signer.Valid() && b.ss.Sig != "" && b.ss.ClaimType != "" && !b.ss.ClaimDate.IsAnyZero() {
return Claim{b}, true
}
return
} | go | func (b *Blob) AsClaim() (c Claim, ok bool) {
if b.ss.Signer.Valid() && b.ss.Sig != "" && b.ss.ClaimType != "" && !b.ss.ClaimDate.IsAnyZero() {
return Claim{b}, true
}
return
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"AsClaim",
"(",
")",
"(",
"c",
"Claim",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
".",
"ss",
".",
"Signer",
".",
"Valid",
"(",
")",
"&&",
"b",
".",
"ss",
".",
"Sig",
"!=",
"\"\"",
"&&",
"b",
".",
"ss",
".... | // AsClaim returns a Claim if the receiver Blob has all the required fields. | [
"AsClaim",
"returns",
"a",
"Claim",
"if",
"the",
"receiver",
"Blob",
"has",
"all",
"the",
"required",
"fields",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L125-L130 | train |
perkeep/perkeep | pkg/schema/blob.go | AsShare | func (b *Blob) AsShare() (s Share, ok bool) {
c, isClaim := b.AsClaim()
if !isClaim {
return
}
if ClaimType(b.ss.ClaimType) == ShareClaim && b.ss.AuthType == ShareHaveRef && (b.ss.Target.Valid() || b.ss.Search != nil) {
return Share{c}, true
}
return s, false
} | go | func (b *Blob) AsShare() (s Share, ok bool) {
c, isClaim := b.AsClaim()
if !isClaim {
return
}
if ClaimType(b.ss.ClaimType) == ShareClaim && b.ss.AuthType == ShareHaveRef && (b.ss.Target.Valid() || b.ss.Search != nil) {
return Share{c}, true
}
return s, false
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"AsShare",
"(",
")",
"(",
"s",
"Share",
",",
"ok",
"bool",
")",
"{",
"c",
",",
"isClaim",
":=",
"b",
".",
"AsClaim",
"(",
")",
"\n",
"if",
"!",
"isClaim",
"{",
"return",
"\n",
"}",
"\n",
"if",
"ClaimType",
... | // AsShare returns a Share if the receiver Blob has all the required fields. | [
"AsShare",
"returns",
"a",
"Share",
"if",
"the",
"receiver",
"Blob",
"has",
"all",
"the",
"required",
"fields",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L133-L143 | train |
perkeep/perkeep | pkg/schema/blob.go | DirectoryEntries | func (b *Blob) DirectoryEntries() (br blob.Ref, ok bool) {
if b.Type() != "directory" {
return
}
return b.ss.Entries, true
} | go | func (b *Blob) DirectoryEntries() (br blob.Ref, ok bool) {
if b.Type() != "directory" {
return
}
return b.ss.Entries, true
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"DirectoryEntries",
"(",
")",
"(",
"br",
"blob",
".",
"Ref",
",",
"ok",
"bool",
")",
"{",
"if",
"b",
".",
"Type",
"(",
")",
"!=",
"\"directory\"",
"{",
"return",
"\n",
"}",
"\n",
"return",
"b",
".",
"ss",
"."... | // DirectoryEntries the "entries" field if valid and b's type is "directory". | [
"DirectoryEntries",
"the",
"entries",
"field",
"if",
"valid",
"and",
"b",
"s",
"type",
"is",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L146-L151 | train |
perkeep/perkeep | pkg/schema/blob.go | StaticSetMembers | func (b *Blob) StaticSetMembers() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.Members))
for _, ref := range b.ss.Members {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | go | func (b *Blob) StaticSetMembers() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.Members))
for _, ref := range b.ss.Members {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"StaticSetMembers",
"(",
")",
"[",
"]",
"blob",
".",
"Ref",
"{",
"if",
"b",
".",
"Type",
"(",
")",
"!=",
"\"static-set\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"s",
":=",
"make",
"(",
"[",
"]",
"blob",
".",... | // StaticSetMembers returns the refs in the "members" field if b is a valid
// "static-set" schema. Note that if it is a large static-set, the members are
// actually spread as subsets in "mergeSets". See StaticSetMergeSets. | [
"StaticSetMembers",
"returns",
"the",
"refs",
"in",
"the",
"members",
"field",
"if",
"b",
"is",
"a",
"valid",
"static",
"-",
"set",
"schema",
".",
"Note",
"that",
"if",
"it",
"is",
"a",
"large",
"static",
"-",
"set",
"the",
"members",
"are",
"actually",
... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L156-L168 | train |
perkeep/perkeep | pkg/schema/blob.go | StaticSetMergeSets | func (b *Blob) StaticSetMergeSets() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.MergeSets))
for _, ref := range b.ss.MergeSets {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | go | func (b *Blob) StaticSetMergeSets() []blob.Ref {
if b.Type() != "static-set" {
return nil
}
s := make([]blob.Ref, 0, len(b.ss.MergeSets))
for _, ref := range b.ss.MergeSets {
if ref.Valid() {
s = append(s, ref)
}
}
return s
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"StaticSetMergeSets",
"(",
")",
"[",
"]",
"blob",
".",
"Ref",
"{",
"if",
"b",
".",
"Type",
"(",
")",
"!=",
"\"static-set\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"s",
":=",
"make",
"(",
"[",
"]",
"blob",
".... | // StaticSetMergeSets returns the refs of the static-sets in "mergeSets". These
// are the subsets of all the static-set members in the case of a large directory. | [
"StaticSetMergeSets",
"returns",
"the",
"refs",
"of",
"the",
"static",
"-",
"sets",
"in",
"mergeSets",
".",
"These",
"are",
"the",
"subsets",
"of",
"all",
"the",
"static",
"-",
"set",
"members",
"in",
"the",
"case",
"of",
"a",
"large",
"directory",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L172-L184 | train |
perkeep/perkeep | pkg/schema/blob.go | IsExpired | func (s Share) IsExpired() bool {
t := time.Time(s.b.ss.Expires)
return !t.IsZero() && clockNow().After(t)
} | go | func (s Share) IsExpired() bool {
t := time.Time(s.b.ss.Expires)
return !t.IsZero() && clockNow().After(t)
} | [
"func",
"(",
"s",
"Share",
")",
"IsExpired",
"(",
")",
"bool",
"{",
"t",
":=",
"time",
".",
"Time",
"(",
"s",
".",
"b",
".",
"ss",
".",
"Expires",
")",
"\n",
"return",
"!",
"t",
".",
"IsZero",
"(",
")",
"&&",
"clockNow",
"(",
")",
".",
"After... | // IsExpired reports whether this share has expired. | [
"IsExpired",
"reports",
"whether",
"this",
"share",
"has",
"expired",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L266-L269 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticFile | func (b *Blob) AsStaticFile() (sf StaticFile, ok bool) {
// TODO (marete) Add support for device files to
// Perkeep and change the implementation of StaticFile to
// reflect that.
t := b.ss.Type
if t == "file" || t == "symlink" || t == "fifo" || t == "socket" {
return StaticFile{b}, true
}
return
} | go | func (b *Blob) AsStaticFile() (sf StaticFile, ok bool) {
// TODO (marete) Add support for device files to
// Perkeep and change the implementation of StaticFile to
// reflect that.
t := b.ss.Type
if t == "file" || t == "symlink" || t == "fifo" || t == "socket" {
return StaticFile{b}, true
}
return
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"AsStaticFile",
"(",
")",
"(",
"sf",
"StaticFile",
",",
"ok",
"bool",
")",
"{",
"t",
":=",
"b",
".",
"ss",
".",
"Type",
"\n",
"if",
"t",
"==",
"\"file\"",
"||",
"t",
"==",
"\"symlink\"",
"||",
"t",
"==",
"\"f... | // AsStaticFile returns the Blob as a StaticFile if it represents
// one. Otherwise, it returns false in the boolean parameter and the
// zero value of StaticFile. | [
"AsStaticFile",
"returns",
"the",
"Blob",
"as",
"a",
"StaticFile",
"if",
"it",
"represents",
"one",
".",
"Otherwise",
"it",
"returns",
"false",
"in",
"the",
"boolean",
"parameter",
"and",
"the",
"zero",
"value",
"of",
"StaticFile",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L285-L295 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticSymlink | func (sf StaticFile) AsStaticSymlink() (s StaticSymlink, ok bool) {
if sf.b.ss.Type == "symlink" {
return StaticSymlink{sf}, true
}
return
} | go | func (sf StaticFile) AsStaticSymlink() (s StaticSymlink, ok bool) {
if sf.b.ss.Type == "symlink" {
return StaticSymlink{sf}, true
}
return
} | [
"func",
"(",
"sf",
"StaticFile",
")",
"AsStaticSymlink",
"(",
")",
"(",
"s",
"StaticSymlink",
",",
"ok",
"bool",
")",
"{",
"if",
"sf",
".",
"b",
".",
"ss",
".",
"Type",
"==",
"\"symlink\"",
"{",
"return",
"StaticSymlink",
"{",
"sf",
"}",
",",
"true",... | // AsStaticSymlink returns the StaticFile as a StaticSymlink if the
// StaticFile represents a symlink. Othwerwise, it returns the zero
// value of StaticSymlink and false. | [
"AsStaticSymlink",
"returns",
"the",
"StaticFile",
"as",
"a",
"StaticSymlink",
"if",
"the",
"StaticFile",
"represents",
"a",
"symlink",
".",
"Othwerwise",
"it",
"returns",
"the",
"zero",
"value",
"of",
"StaticSymlink",
"and",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L324-L330 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticFIFO | func (sf StaticFile) AsStaticFIFO() (fifo StaticFIFO, ok bool) {
if sf.b.ss.Type == "fifo" {
return StaticFIFO{sf}, true
}
return
} | go | func (sf StaticFile) AsStaticFIFO() (fifo StaticFIFO, ok bool) {
if sf.b.ss.Type == "fifo" {
return StaticFIFO{sf}, true
}
return
} | [
"func",
"(",
"sf",
"StaticFile",
")",
"AsStaticFIFO",
"(",
")",
"(",
"fifo",
"StaticFIFO",
",",
"ok",
"bool",
")",
"{",
"if",
"sf",
".",
"b",
".",
"ss",
".",
"Type",
"==",
"\"fifo\"",
"{",
"return",
"StaticFIFO",
"{",
"sf",
"}",
",",
"true",
"\n",
... | // AsStaticFIFO returns the StatifFile as a StaticFIFO if the
// StaticFile represents a fifo. Otherwise, it returns the zero value
// of StaticFIFO and false. | [
"AsStaticFIFO",
"returns",
"the",
"StatifFile",
"as",
"a",
"StaticFIFO",
"if",
"the",
"StaticFile",
"represents",
"a",
"fifo",
".",
"Otherwise",
"it",
"returns",
"the",
"zero",
"value",
"of",
"StaticFIFO",
"and",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L335-L341 | train |
perkeep/perkeep | pkg/schema/blob.go | AsStaticSocket | func (sf StaticFile) AsStaticSocket() (ss StaticSocket, ok bool) {
if sf.b.ss.Type == "socket" {
return StaticSocket{sf}, true
}
return
} | go | func (sf StaticFile) AsStaticSocket() (ss StaticSocket, ok bool) {
if sf.b.ss.Type == "socket" {
return StaticSocket{sf}, true
}
return
} | [
"func",
"(",
"sf",
"StaticFile",
")",
"AsStaticSocket",
"(",
")",
"(",
"ss",
"StaticSocket",
",",
"ok",
"bool",
")",
"{",
"if",
"sf",
".",
"b",
".",
"ss",
".",
"Type",
"==",
"\"socket\"",
"{",
"return",
"StaticSocket",
"{",
"sf",
"}",
",",
"true",
... | // AsStaticSocket returns the StaticFile as a StaticSocket if the
// StaticFile represents a socket. Otherwise, it returns the zero
// value of StaticSocket and false. | [
"AsStaticSocket",
"returns",
"the",
"StaticFile",
"as",
"a",
"StaticSocket",
"if",
"the",
"StaticFile",
"represents",
"a",
"socket",
".",
"Otherwise",
"it",
"returns",
"the",
"zero",
"value",
"of",
"StaticSocket",
"and",
"false",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L346-L352 | train |
perkeep/perkeep | pkg/schema/blob.go | SetShareTarget | func (bb *Builder) SetShareTarget(t blob.Ref) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareTarget on non-share")
}
bb.m["target"] = t.String()
return bb
} | go | func (bb *Builder) SetShareTarget(t blob.Ref) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareTarget on non-share")
}
bb.m["target"] = t.String()
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetShareTarget",
"(",
"t",
"blob",
".",
"Ref",
")",
"*",
"Builder",
"{",
"if",
"bb",
".",
"Type",
"(",
")",
"!=",
"\"claim\"",
"||",
"bb",
".",
"ClaimType",
"(",
")",
"!=",
"ShareClaim",
"{",
"panic",
"(",
... | // SetShareTarget sets the target of share claim.
// It panics if bb isn't a "share" claim type. | [
"SetShareTarget",
"sets",
"the",
"target",
"of",
"share",
"claim",
".",
"It",
"panics",
"if",
"bb",
"isn",
"t",
"a",
"share",
"claim",
"type",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L371-L377 | train |
perkeep/perkeep | pkg/schema/blob.go | SetShareExpiration | func (bb *Builder) SetShareExpiration(t time.Time) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareExpiration on non-share")
}
if t.IsZero() {
delete(bb.m, "expires")
} else {
bb.m["expires"] = RFC3339FromTime(t)
}
return bb
} | go | func (bb *Builder) SetShareExpiration(t time.Time) *Builder {
if bb.Type() != "claim" || bb.ClaimType() != ShareClaim {
panic("called SetShareExpiration on non-share")
}
if t.IsZero() {
delete(bb.m, "expires")
} else {
bb.m["expires"] = RFC3339FromTime(t)
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetShareExpiration",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Builder",
"{",
"if",
"bb",
".",
"Type",
"(",
")",
"!=",
"\"claim\"",
"||",
"bb",
".",
"ClaimType",
"(",
")",
"!=",
"ShareClaim",
"{",
"panic",
"... | // SetShareExpiration sets the expiration time on share claim.
// It panics if bb isn't a "share" claim type.
// If t is zero, the expiration is removed. | [
"SetShareExpiration",
"sets",
"the",
"expiration",
"time",
"on",
"share",
"claim",
".",
"It",
"panics",
"if",
"bb",
"isn",
"t",
"a",
"share",
"claim",
"type",
".",
"If",
"t",
"is",
"zero",
"the",
"expiration",
"is",
"removed",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L393-L403 | train |
perkeep/perkeep | pkg/schema/blob.go | SetRawStringField | func (bb *Builder) SetRawStringField(key, value string) *Builder {
bb.m[key] = value
return bb
} | go | func (bb *Builder) SetRawStringField(key, value string) *Builder {
bb.m[key] = value
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetRawStringField",
"(",
"key",
",",
"value",
"string",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetRawStringField sets a raw string field in the underlying map. | [
"SetRawStringField",
"sets",
"a",
"raw",
"string",
"field",
"in",
"the",
"underlying",
"map",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L418-L421 | train |
perkeep/perkeep | pkg/schema/blob.go | Blob | func (bb *Builder) Blob() *Blob {
json, err := mapJSON(bb.m)
if err != nil {
panic(err)
}
ss, err := parseSuperset(strings.NewReader(json))
if err != nil {
panic(err)
}
h := blob.NewHash()
h.Write([]byte(json))
return &Blob{
str: json,
ss: ss,
br: blob.RefFromHash(h),
}
} | go | func (bb *Builder) Blob() *Blob {
json, err := mapJSON(bb.m)
if err != nil {
panic(err)
}
ss, err := parseSuperset(strings.NewReader(json))
if err != nil {
panic(err)
}
h := blob.NewHash()
h.Write([]byte(json))
return &Blob{
str: json,
ss: ss,
br: blob.RefFromHash(h),
}
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"Blob",
"(",
")",
"*",
"Blob",
"{",
"json",
",",
"err",
":=",
"mapJSON",
"(",
"bb",
".",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"ss",
",",
"err",
":=... | // Blob builds the Blob. The builder continues to be usable after a call to Build. | [
"Blob",
"builds",
"the",
"Blob",
".",
"The",
"builder",
"continues",
"to",
"be",
"usable",
"after",
"a",
"call",
"to",
"Build",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L424-L440 | train |
perkeep/perkeep | pkg/schema/blob.go | SetSigner | func (bb *Builder) SetSigner(signer blob.Ref) *Builder {
bb.m["camliSigner"] = signer.String()
return bb
} | go | func (bb *Builder) SetSigner(signer blob.Ref) *Builder {
bb.m["camliSigner"] = signer.String()
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetSigner",
"(",
"signer",
"blob",
".",
"Ref",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"\"camliSigner\"",
"]",
"=",
"signer",
".",
"String",
"(",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetSigner sets the camliSigner field.
// Calling SetSigner is unnecessary if using Sign. | [
"SetSigner",
"sets",
"the",
"camliSigner",
"field",
".",
"Calling",
"SetSigner",
"is",
"unnecessary",
"if",
"using",
"Sign",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L454-L457 | train |
perkeep/perkeep | pkg/schema/blob.go | Sign | func (bb *Builder) Sign(ctx context.Context, signer *Signer) (string, error) {
return bb.SignAt(ctx, signer, time.Time{})
} | go | func (bb *Builder) Sign(ctx context.Context, signer *Signer) (string, error) {
return bb.SignAt(ctx, signer, time.Time{})
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"Sign",
"(",
"ctx",
"context",
".",
"Context",
",",
"signer",
"*",
"Signer",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"bb",
".",
"SignAt",
"(",
"ctx",
",",
"signer",
",",
"time",
".",
"Time",
"... | // Sign sets the blob builder's camliSigner field with SetSigner
// and returns the signed JSON using the provided signer. | [
"Sign",
"sets",
"the",
"blob",
"builder",
"s",
"camliSigner",
"field",
"with",
"SetSigner",
"and",
"returns",
"the",
"signed",
"JSON",
"using",
"the",
"provided",
"signer",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L461-L463 | train |
perkeep/perkeep | pkg/schema/blob.go | SignAt | func (bb *Builder) SignAt(ctx context.Context, signer *Signer, sigTime time.Time) (string, error) {
switch bb.Type() {
case "permanode", "claim":
default:
return "", fmt.Errorf("can't sign camliType %q", bb.Type())
}
if sigTime.IsZero() {
sigTime = time.Now()
}
bb.SetClaimDate(sigTime)
return signer.SignJSON(ctx, bb.SetSigner(signer.pubref).Blob().JSON(), sigTime)
} | go | func (bb *Builder) SignAt(ctx context.Context, signer *Signer, sigTime time.Time) (string, error) {
switch bb.Type() {
case "permanode", "claim":
default:
return "", fmt.Errorf("can't sign camliType %q", bb.Type())
}
if sigTime.IsZero() {
sigTime = time.Now()
}
bb.SetClaimDate(sigTime)
return signer.SignJSON(ctx, bb.SetSigner(signer.pubref).Blob().JSON(), sigTime)
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SignAt",
"(",
"ctx",
"context",
".",
"Context",
",",
"signer",
"*",
"Signer",
",",
"sigTime",
"time",
".",
"Time",
")",
"(",
"string",
",",
"error",
")",
"{",
"switch",
"bb",
".",
"Type",
"(",
")",
"{",
"c... | // SignAt sets the blob builder's camliSigner field with SetSigner
// and returns the signed JSON using the provided signer.
// The provided sigTime is the time of the signature, used mostly
// for planned permanodes. If the zero value, the current time is used. | [
"SignAt",
"sets",
"the",
"blob",
"builder",
"s",
"camliSigner",
"field",
"with",
"SetSigner",
"and",
"returns",
"the",
"signed",
"JSON",
"using",
"the",
"provided",
"signer",
".",
"The",
"provided",
"sigTime",
"is",
"the",
"time",
"of",
"the",
"signature",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L469-L480 | train |
perkeep/perkeep | pkg/schema/blob.go | SetType | func (bb *Builder) SetType(t string) *Builder {
bb.m["camliType"] = t
return bb
} | go | func (bb *Builder) SetType(t string) *Builder {
bb.m["camliType"] = t
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetType",
"(",
"t",
"string",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"\"camliType\"",
"]",
"=",
"t",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetType sets the camliType field. | [
"SetType",
"sets",
"the",
"camliType",
"field",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L483-L486 | train |
perkeep/perkeep | pkg/schema/blob.go | Type | func (bb *Builder) Type() string {
if s, ok := bb.m["camliType"].(string); ok {
return s
}
return ""
} | go | func (bb *Builder) Type() string {
if s, ok := bb.m["camliType"].(string); ok {
return s
}
return ""
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"Type",
"(",
")",
"string",
"{",
"if",
"s",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"camliType\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n",
"return",
"\"\"",
"\n",
"... | // Type returns the camliType value. | [
"Type",
"returns",
"the",
"camliType",
"value",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L489-L494 | train |
perkeep/perkeep | pkg/schema/blob.go | ClaimType | func (bb *Builder) ClaimType() ClaimType {
if s, ok := bb.m["claimType"].(string); ok {
return ClaimType(s)
}
return ""
} | go | func (bb *Builder) ClaimType() ClaimType {
if s, ok := bb.m["claimType"].(string); ok {
return ClaimType(s)
}
return ""
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"ClaimType",
"(",
")",
"ClaimType",
"{",
"if",
"s",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"claimType\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"ClaimType",
"(",
"s",
")",
"\n",
"}",
"\... | // ClaimType returns the claimType value, or the empty string. | [
"ClaimType",
"returns",
"the",
"claimType",
"value",
"or",
"the",
"empty",
"string",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L497-L502 | train |
perkeep/perkeep | pkg/schema/blob.go | SetFileName | func (bb *Builder) SetFileName(name string) *Builder {
baseName := filepath.Base(name)
if utf8.ValidString(baseName) {
bb.m["fileName"] = baseName
} else {
bb.m["fileNameBytes"] = mixedArrayFromString(baseName)
}
return bb
} | go | func (bb *Builder) SetFileName(name string) *Builder {
baseName := filepath.Base(name)
if utf8.ValidString(baseName) {
bb.m["fileName"] = baseName
} else {
bb.m["fileNameBytes"] = mixedArrayFromString(baseName)
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetFileName",
"(",
"name",
"string",
")",
"*",
"Builder",
"{",
"baseName",
":=",
"filepath",
".",
"Base",
"(",
"name",
")",
"\n",
"if",
"utf8",
".",
"ValidString",
"(",
"baseName",
")",
"{",
"bb",
".",
"m",
... | // SetFileName sets the fileName or fileNameBytes field.
// The filename is truncated to just the base. | [
"SetFileName",
"sets",
"the",
"fileName",
"or",
"fileNameBytes",
"field",
".",
"The",
"filename",
"is",
"truncated",
"to",
"just",
"the",
"base",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L506-L514 | train |
perkeep/perkeep | pkg/schema/blob.go | SetSymlinkTarget | func (bb *Builder) SetSymlinkTarget(target string) *Builder {
bb.SetType("symlink")
if utf8.ValidString(target) {
bb.m["symlinkTarget"] = target
} else {
bb.m["symlinkTargetBytes"] = mixedArrayFromString(target)
}
return bb
} | go | func (bb *Builder) SetSymlinkTarget(target string) *Builder {
bb.SetType("symlink")
if utf8.ValidString(target) {
bb.m["symlinkTarget"] = target
} else {
bb.m["symlinkTargetBytes"] = mixedArrayFromString(target)
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetSymlinkTarget",
"(",
"target",
"string",
")",
"*",
"Builder",
"{",
"bb",
".",
"SetType",
"(",
"\"symlink\"",
")",
"\n",
"if",
"utf8",
".",
"ValidString",
"(",
"target",
")",
"{",
"bb",
".",
"m",
"[",
"\"sym... | // SetSymlinkTarget sets bb to be of type "symlink" and sets the symlink's target. | [
"SetSymlinkTarget",
"sets",
"bb",
"to",
"be",
"of",
"type",
"symlink",
"and",
"sets",
"the",
"symlink",
"s",
"target",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L517-L525 | train |
perkeep/perkeep | pkg/schema/blob.go | SetClaimDate | func (bb *Builder) SetClaimDate(t time.Time) *Builder {
if !bb.IsClaimType() {
// This is a little gross, using panic here, but I
// don't want all callers to check errors. This is
// really a programming error, not a runtime error
// that would arise from e.g. random user data.
panic("SetClaimDate called on non-claim *Builder; camliType=" + bb.Type())
}
bb.m["claimDate"] = RFC3339FromTime(t)
return bb
} | go | func (bb *Builder) SetClaimDate(t time.Time) *Builder {
if !bb.IsClaimType() {
// This is a little gross, using panic here, but I
// don't want all callers to check errors. This is
// really a programming error, not a runtime error
// that would arise from e.g. random user data.
panic("SetClaimDate called on non-claim *Builder; camliType=" + bb.Type())
}
bb.m["claimDate"] = RFC3339FromTime(t)
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetClaimDate",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Builder",
"{",
"if",
"!",
"bb",
".",
"IsClaimType",
"(",
")",
"{",
"panic",
"(",
"\"SetClaimDate called on non-claim *Builder; camliType=\"",
"+",
"bb",
".",
... | // SetClaimDate sets the "claimDate" on a claim.
// It is a fatal error to call SetClaimDate if the Map isn't of Type "claim". | [
"SetClaimDate",
"sets",
"the",
"claimDate",
"on",
"a",
"claim",
".",
"It",
"is",
"a",
"fatal",
"error",
"to",
"call",
"SetClaimDate",
"if",
"the",
"Map",
"isn",
"t",
"of",
"Type",
"claim",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L539-L549 | train |
perkeep/perkeep | pkg/schema/blob.go | SetModTime | func (bb *Builder) SetModTime(t time.Time) *Builder {
bb.m["unixMtime"] = RFC3339FromTime(t)
return bb
} | go | func (bb *Builder) SetModTime(t time.Time) *Builder {
bb.m["unixMtime"] = RFC3339FromTime(t)
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"SetModTime",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Builder",
"{",
"bb",
".",
"m",
"[",
"\"unixMtime\"",
"]",
"=",
"RFC3339FromTime",
"(",
"t",
")",
"\n",
"return",
"bb",
"\n",
"}"
] | // SetModTime sets the "unixMtime" field. | [
"SetModTime",
"sets",
"the",
"unixMtime",
"field",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L552-L555 | train |
perkeep/perkeep | pkg/schema/blob.go | CapCreationTime | func (bb *Builder) CapCreationTime() *Builder {
ctime, ok := bb.m["unixCtime"].(string)
if !ok {
return bb
}
mtime, ok := bb.m["unixMtime"].(string)
if ok && ctime > mtime {
bb.m["unixCtime"] = mtime
}
return bb
} | go | func (bb *Builder) CapCreationTime() *Builder {
ctime, ok := bb.m["unixCtime"].(string)
if !ok {
return bb
}
mtime, ok := bb.m["unixMtime"].(string)
if ok && ctime > mtime {
bb.m["unixCtime"] = mtime
}
return bb
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"CapCreationTime",
"(",
")",
"*",
"Builder",
"{",
"ctime",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"unixCtime\"",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"bb",
"\n",
"}",
"\n",
... | // CapCreationTime caps the "unixCtime" field to be less or equal than "unixMtime" | [
"CapCreationTime",
"caps",
"the",
"unixCtime",
"field",
"to",
"be",
"less",
"or",
"equal",
"than",
"unixMtime"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L558-L568 | train |
perkeep/perkeep | pkg/schema/blob.go | ModTime | func (bb *Builder) ModTime() (t time.Time, ok bool) {
s, ok := bb.m["unixMtime"].(string)
if !ok {
return
}
t, err := time.Parse(time.RFC3339, s)
if err != nil {
return
}
return t, true
} | go | func (bb *Builder) ModTime() (t time.Time, ok bool) {
s, ok := bb.m["unixMtime"].(string)
if !ok {
return
}
t, err := time.Parse(time.RFC3339, s)
if err != nil {
return
}
return t, true
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"ModTime",
"(",
")",
"(",
"t",
"time",
".",
"Time",
",",
"ok",
"bool",
")",
"{",
"s",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"unixMtime\"",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"... | // ModTime returns the "unixMtime" modtime field, if set. | [
"ModTime",
"returns",
"the",
"unixMtime",
"modtime",
"field",
"if",
"set",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L571-L581 | train |
perkeep/perkeep | pkg/schema/blob.go | PartsSize | func (bb *Builder) PartsSize() int64 {
n := int64(0)
if parts, ok := bb.m["parts"].([]BytesPart); ok {
for _, part := range parts {
n += int64(part.Size)
}
}
return n
} | go | func (bb *Builder) PartsSize() int64 {
n := int64(0)
if parts, ok := bb.m["parts"].([]BytesPart); ok {
for _, part := range parts {
n += int64(part.Size)
}
}
return n
} | [
"func",
"(",
"bb",
"*",
"Builder",
")",
"PartsSize",
"(",
")",
"int64",
"{",
"n",
":=",
"int64",
"(",
"0",
")",
"\n",
"if",
"parts",
",",
"ok",
":=",
"bb",
".",
"m",
"[",
"\"parts\"",
"]",
".",
"(",
"[",
"]",
"BytesPart",
")",
";",
"ok",
"{",... | // PartsSize returns the number of bytes represented by the "parts" field. | [
"PartsSize",
"returns",
"the",
"number",
"of",
"bytes",
"represented",
"by",
"the",
"parts",
"field",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/schema/blob.go#L592-L600 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/stream.go | StreamBlobs | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
return blobserver.NewMultiBlobStreamer(
smallBlobStreamer{s},
largeBlobStreamer{s},
).StreamBlobs(ctx, dest, contToken)
} | go | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
return blobserver.NewMultiBlobStreamer(
smallBlobStreamer{s},
largeBlobStreamer{s},
).StreamBlobs(ctx, dest, contToken)
} | [
"func",
"(",
"s",
"*",
"storage",
")",
"StreamBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blobserver",
".",
"BlobAndToken",
",",
"contToken",
"string",
")",
"(",
"err",
"error",
")",
"{",
"return",
"blobserver",
".",
"NewMu... | // StreamBlobs impl. | [
"StreamBlobs",
"impl",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/stream.go#L33-L38 | train |
perkeep/perkeep | pkg/blobserver/blobpacked/stream.go | StreamBlobs | func (st smallBlobStreamer) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
small := st.sto.small
if bs, ok := small.(blobserver.BlobStreamer); ok {
return bs.StreamBlobs(ctx, dest, contToken)
}
defer close(dest)
donec := ctx.Done()
return blobserver.EnumerateAllFrom(ctx, small, contToken, func(sb blob.SizedRef) error {
select {
case dest <- blobserver.BlobAndToken{
Blob: blob.NewBlob(sb.Ref, sb.Size, func(ctx context.Context) ([]byte, error) {
return slurpSizedRef(ctx, small, sb)
}),
Token: sb.Ref.StringMinusOne(), // streamer is >=, enumerate is >
}:
return nil
case <-donec:
return ctx.Err()
}
})
} | go | func (st smallBlobStreamer) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) (err error) {
small := st.sto.small
if bs, ok := small.(blobserver.BlobStreamer); ok {
return bs.StreamBlobs(ctx, dest, contToken)
}
defer close(dest)
donec := ctx.Done()
return blobserver.EnumerateAllFrom(ctx, small, contToken, func(sb blob.SizedRef) error {
select {
case dest <- blobserver.BlobAndToken{
Blob: blob.NewBlob(sb.Ref, sb.Size, func(ctx context.Context) ([]byte, error) {
return slurpSizedRef(ctx, small, sb)
}),
Token: sb.Ref.StringMinusOne(), // streamer is >=, enumerate is >
}:
return nil
case <-donec:
return ctx.Err()
}
})
} | [
"func",
"(",
"st",
"smallBlobStreamer",
")",
"StreamBlobs",
"(",
"ctx",
"context",
".",
"Context",
",",
"dest",
"chan",
"<-",
"blobserver",
".",
"BlobAndToken",
",",
"contToken",
"string",
")",
"(",
"err",
"error",
")",
"{",
"small",
":=",
"st",
".",
"st... | // stream the loose blobs | [
"stream",
"the",
"loose",
"blobs"
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/pkg/blobserver/blobpacked/stream.go#L44-L64 | train |
perkeep/perkeep | internal/images/images.go | ScaledDimensions | func ScaledDimensions(w, h, mw, mh int) (newWidth int, newHeight int) {
if w == 0 || h == 0 || mw == 0 || mh == 0 {
imageDebug("ScaledDimensions was given as 0; returning 1x1 as dimensions.")
return 1, 1
}
newWidth, newHeight = mw, mh
if float32(h)/float32(mh) > float32(w)/float32(mw) {
newWidth = w * mh / h
} else {
newHeight = h * mw / w
}
return
} | go | func ScaledDimensions(w, h, mw, mh int) (newWidth int, newHeight int) {
if w == 0 || h == 0 || mw == 0 || mh == 0 {
imageDebug("ScaledDimensions was given as 0; returning 1x1 as dimensions.")
return 1, 1
}
newWidth, newHeight = mw, mh
if float32(h)/float32(mh) > float32(w)/float32(mw) {
newWidth = w * mh / h
} else {
newHeight = h * mw / w
}
return
} | [
"func",
"ScaledDimensions",
"(",
"w",
",",
"h",
",",
"mw",
",",
"mh",
"int",
")",
"(",
"newWidth",
"int",
",",
"newHeight",
"int",
")",
"{",
"if",
"w",
"==",
"0",
"||",
"h",
"==",
"0",
"||",
"mw",
"==",
"0",
"||",
"mh",
"==",
"0",
"{",
"image... | // ScaledDimensions returns the newWidth and newHeight obtained
// when an image of dimensions w x h has to be rescaled under
// mw x mh, while conserving the proportions.
// It returns 1,1 if any of the parameter is 0. | [
"ScaledDimensions",
"returns",
"the",
"newWidth",
"and",
"newHeight",
"obtained",
"when",
"an",
"image",
"of",
"dimensions",
"w",
"x",
"h",
"has",
"to",
"be",
"rescaled",
"under",
"mw",
"x",
"mh",
"while",
"conserving",
"the",
"proportions",
".",
"It",
"retu... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L248-L260 | train |
perkeep/perkeep | internal/images/images.go | rescaleDimensions | func (opts *DecodeOpts) rescaleDimensions(b image.Rectangle, swapDimensions bool) (width, height int, needRescale bool) {
w, h := b.Dx(), b.Dy()
mw, mh := opts.MaxWidth, opts.MaxHeight
mwf, mhf := opts.ScaleWidth, opts.ScaleHeight
if mw == 0 && mh == 0 && mwf == 0 && mhf == 0 {
return w, h, false
}
// Floating point compares probably only allow this to work if the values
// were specified as the literal 1 or 1.0, computed values will likely be
// off. If Scale{Width,Height} end up being 1.0-epsilon we'll rescale
// when it probably wouldn't even be noticeable but that's okay.
if opts.ScaleWidth == 1.0 && opts.ScaleHeight == 1.0 {
return w, h, false
}
if swapDimensions {
w, h = h, w
}
// ScaleWidth and ScaleHeight overrule MaxWidth and MaxHeight
if mwf > 0.0 && mwf <= 1 {
mw = int(mwf * float32(w))
}
if mhf > 0.0 && mhf <= 1 {
mh = int(mhf * float32(h))
}
neww, newh := ScaledDimensions(w, h, mw, mh)
if neww > w || newh > h {
// Don't scale up.
return w, h, false
}
needRescale = neww != w || newh != h
if swapDimensions {
return newh, neww, needRescale
}
return neww, newh, needRescale
} | go | func (opts *DecodeOpts) rescaleDimensions(b image.Rectangle, swapDimensions bool) (width, height int, needRescale bool) {
w, h := b.Dx(), b.Dy()
mw, mh := opts.MaxWidth, opts.MaxHeight
mwf, mhf := opts.ScaleWidth, opts.ScaleHeight
if mw == 0 && mh == 0 && mwf == 0 && mhf == 0 {
return w, h, false
}
// Floating point compares probably only allow this to work if the values
// were specified as the literal 1 or 1.0, computed values will likely be
// off. If Scale{Width,Height} end up being 1.0-epsilon we'll rescale
// when it probably wouldn't even be noticeable but that's okay.
if opts.ScaleWidth == 1.0 && opts.ScaleHeight == 1.0 {
return w, h, false
}
if swapDimensions {
w, h = h, w
}
// ScaleWidth and ScaleHeight overrule MaxWidth and MaxHeight
if mwf > 0.0 && mwf <= 1 {
mw = int(mwf * float32(w))
}
if mhf > 0.0 && mhf <= 1 {
mh = int(mhf * float32(h))
}
neww, newh := ScaledDimensions(w, h, mw, mh)
if neww > w || newh > h {
// Don't scale up.
return w, h, false
}
needRescale = neww != w || newh != h
if swapDimensions {
return newh, neww, needRescale
}
return neww, newh, needRescale
} | [
"func",
"(",
"opts",
"*",
"DecodeOpts",
")",
"rescaleDimensions",
"(",
"b",
"image",
".",
"Rectangle",
",",
"swapDimensions",
"bool",
")",
"(",
"width",
",",
"height",
"int",
",",
"needRescale",
"bool",
")",
"{",
"w",
",",
"h",
":=",
"b",
".",
"Dx",
... | // rescaleDimensions computes the width & height in the pre-rotated
// orientation needed to meet the post-rotation constraints of opts.
// The image bound by b represents the pre-rotated dimensions of the image.
// needRescale is true if the image requires a resize. | [
"rescaleDimensions",
"computes",
"the",
"width",
"&",
"height",
"in",
"the",
"pre",
"-",
"rotated",
"orientation",
"needed",
"to",
"meet",
"the",
"post",
"-",
"rotation",
"constraints",
"of",
"opts",
".",
"The",
"image",
"bound",
"by",
"b",
"represents",
"th... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L266-L305 | train |
perkeep/perkeep | internal/images/images.go | rescale | func rescale(im image.Image, sw, sh int) image.Image {
b := im.Bounds()
w, h := b.Dx(), b.Dy()
if sw == w && sh == h {
return im
}
// If it's gigantic, it's more efficient to downsample first
// and then resize; resizing will smooth out the roughness.
// (trusting the moustachio guys on that one).
if w > sw*2 && h > sh*2 {
im = resize.ResampleInplace(im, b, sw*2, sh*2)
return resize.HalveInplace(im)
}
return resize.Resize(im, b, sw, sh)
} | go | func rescale(im image.Image, sw, sh int) image.Image {
b := im.Bounds()
w, h := b.Dx(), b.Dy()
if sw == w && sh == h {
return im
}
// If it's gigantic, it's more efficient to downsample first
// and then resize; resizing will smooth out the roughness.
// (trusting the moustachio guys on that one).
if w > sw*2 && h > sh*2 {
im = resize.ResampleInplace(im, b, sw*2, sh*2)
return resize.HalveInplace(im)
}
return resize.Resize(im, b, sw, sh)
} | [
"func",
"rescale",
"(",
"im",
"image",
".",
"Image",
",",
"sw",
",",
"sh",
"int",
")",
"image",
".",
"Image",
"{",
"b",
":=",
"im",
".",
"Bounds",
"(",
")",
"\n",
"w",
",",
"h",
":=",
"b",
".",
"Dx",
"(",
")",
",",
"b",
".",
"Dy",
"(",
")... | // rescale resizes im in-place to the dimensions sw x sh, overwriting the
// existing pixel data. It is up to the caller to ensure sw & sh maintain the
// aspect ratio of im. | [
"rescale",
"resizes",
"im",
"in",
"-",
"place",
"to",
"the",
"dimensions",
"sw",
"x",
"sh",
"overwriting",
"the",
"existing",
"pixel",
"data",
".",
"It",
"is",
"up",
"to",
"the",
"caller",
"to",
"ensure",
"sw",
"&",
"sh",
"maintain",
"the",
"aspect",
"... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L310-L325 | train |
perkeep/perkeep | internal/images/images.go | forcedOrientation | func (opts *DecodeOpts) forcedOrientation() (angle int, flipMode FlipDirection, err error) {
var (
ok bool
)
if opts.forcedRotate() {
if angle, ok = opts.Rotate.(int); !ok {
return 0, 0, fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
}
}
if opts.forcedFlip() {
if flipMode, ok = opts.Flip.(FlipDirection); !ok {
return 0, 0, fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
}
}
return angle, flipMode, nil
} | go | func (opts *DecodeOpts) forcedOrientation() (angle int, flipMode FlipDirection, err error) {
var (
ok bool
)
if opts.forcedRotate() {
if angle, ok = opts.Rotate.(int); !ok {
return 0, 0, fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
}
}
if opts.forcedFlip() {
if flipMode, ok = opts.Flip.(FlipDirection); !ok {
return 0, 0, fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
}
}
return angle, flipMode, nil
} | [
"func",
"(",
"opts",
"*",
"DecodeOpts",
")",
"forcedOrientation",
"(",
")",
"(",
"angle",
"int",
",",
"flipMode",
"FlipDirection",
",",
"err",
"error",
")",
"{",
"var",
"(",
"ok",
"bool",
"\n",
")",
"\n",
"if",
"opts",
".",
"forcedRotate",
"(",
")",
... | // forcedOrientation returns the rotation and flip values stored in opts. The
// values are asserted to their proper type, and err is non-nil if an invalid
// value is found. This function ignores the orientation stored in EXIF.
// If auto-correction of the image's orientation is desired, it is the
// caller's responsibility to check via useEXIF first. | [
"forcedOrientation",
"returns",
"the",
"rotation",
"and",
"flip",
"values",
"stored",
"in",
"opts",
".",
"The",
"values",
"are",
"asserted",
"to",
"their",
"proper",
"type",
"and",
"err",
"is",
"non",
"-",
"nil",
"if",
"an",
"invalid",
"value",
"is",
"foun... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L348-L363 | train |
perkeep/perkeep | internal/images/images.go | DecodeConfig | func DecodeConfig(r io.Reader) (Config, error) {
var buf bytes.Buffer
tr := io.TeeReader(io.LimitReader(r, 8<<20), &buf)
conf, format, err := image.DecodeConfig(tr)
if err != nil {
if debug {
log.Printf("internal/images: DecodeConfig failed after reading %d bytes: %v", buf.Len(), err)
}
return Config{}, err
}
c := Config{
Format: format,
Width: conf.Width,
Height: conf.Height,
}
mr := io.LimitReader(io.MultiReader(&buf, r), 8<<20)
if format == "heic" {
hf := heif.Open(readerutil.NewBufferingReaderAt(mr))
exifBytes, err := hf.EXIF()
if err != nil {
return c, err
}
c.HEICEXIF = exifBytes
mr = bytes.NewReader(exifBytes)
}
ex, err := exif.Decode(mr)
// trigger a retry when there isn't enough data for reading exif data from a tiff file
if exif.IsShortReadTagValueError(err) {
return c, io.ErrUnexpectedEOF
}
if err != nil {
imageDebug(fmt.Sprintf("No valid EXIF, error: %v.", err))
return c, nil
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF.`)
return c, nil
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF Error: %v", err))
return c, nil
}
switch orient {
// those are the orientations that require
// a rotation of ±90
case leftSideTop, rightSideTop, rightSideBottom, leftSideBottom:
c.Width, c.Height = c.Height, c.Width
}
return c, nil
} | go | func DecodeConfig(r io.Reader) (Config, error) {
var buf bytes.Buffer
tr := io.TeeReader(io.LimitReader(r, 8<<20), &buf)
conf, format, err := image.DecodeConfig(tr)
if err != nil {
if debug {
log.Printf("internal/images: DecodeConfig failed after reading %d bytes: %v", buf.Len(), err)
}
return Config{}, err
}
c := Config{
Format: format,
Width: conf.Width,
Height: conf.Height,
}
mr := io.LimitReader(io.MultiReader(&buf, r), 8<<20)
if format == "heic" {
hf := heif.Open(readerutil.NewBufferingReaderAt(mr))
exifBytes, err := hf.EXIF()
if err != nil {
return c, err
}
c.HEICEXIF = exifBytes
mr = bytes.NewReader(exifBytes)
}
ex, err := exif.Decode(mr)
// trigger a retry when there isn't enough data for reading exif data from a tiff file
if exif.IsShortReadTagValueError(err) {
return c, io.ErrUnexpectedEOF
}
if err != nil {
imageDebug(fmt.Sprintf("No valid EXIF, error: %v.", err))
return c, nil
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF.`)
return c, nil
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF Error: %v", err))
return c, nil
}
switch orient {
// those are the orientations that require
// a rotation of ±90
case leftSideTop, rightSideTop, rightSideBottom, leftSideBottom:
c.Width, c.Height = c.Height, c.Width
}
return c, nil
} | [
"func",
"DecodeConfig",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"Config",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"tr",
":=",
"io",
".",
"TeeReader",
"(",
"io",
".",
"LimitReader",
"(",
"r",
",",
"8",
"<<",
"20",
")",... | // DecodeConfig returns the image Config similarly to
// the standard library's image.DecodeConfig with the
// addition that it also checks for an EXIF orientation,
// and sets the Width and Height as they would visibly
// be after correcting for that orientation. | [
"DecodeConfig",
"returns",
"the",
"image",
"Config",
"similarly",
"to",
"the",
"standard",
"library",
"s",
"image",
".",
"DecodeConfig",
"with",
"the",
"addition",
"that",
"it",
"also",
"checks",
"for",
"an",
"EXIF",
"orientation",
"and",
"sets",
"the",
"Width... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L395-L448 | train |
perkeep/perkeep | internal/images/images.go | decode | func decode(r io.Reader, opts *DecodeOpts, swapDimensions bool) (im image.Image, format string, err error, needRescale bool) {
if opts == nil {
// Fall-back to normal decode.
im, format, err = image.Decode(r)
return im, format, err, false
}
var buf bytes.Buffer
tr := io.TeeReader(r, &buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, "", err, false
}
mr := io.MultiReader(&buf, r)
b := image.Rect(0, 0, ic.Width, ic.Height)
sw, sh, needRescale := opts.rescaleDimensions(b, swapDimensions)
if !needRescale {
im, format, err = image.Decode(mr)
return im, format, err, false
}
imageDebug(fmt.Sprintf("Resizing from %dx%d -> %dx%d", ic.Width, ic.Height, sw, sh))
if format == "cr2" {
// Replace mr with an io.Reader to the JPEG thumbnail embedded in a
// CR2 image.
if mr, err = cr2.NewReader(mr); err != nil {
return nil, "", err, false
}
format = "jpeg"
}
if format == "jpeg" && fastjpeg.Available() {
factor := fastjpeg.Factor(ic.Width, ic.Height, sw, sh)
if factor > 1 {
var buf bytes.Buffer
tr := io.TeeReader(mr, &buf)
im, err = fastjpeg.DecodeDownsample(tr, factor)
switch err.(type) {
case fastjpeg.DjpegFailedError:
log.Printf("Retrying with jpeg.Decode, because djpeg failed with: %v", err)
im, err = jpeg.Decode(io.MultiReader(&buf, mr))
case nil:
// fallthrough to rescale() below.
default:
return nil, format, err, false
}
return rescale(im, sw, sh), format, err, true
}
}
// Fall-back to normal decode.
im, format, err = image.Decode(mr)
if err != nil {
return nil, "", err, false
}
return rescale(im, sw, sh), format, err, needRescale
} | go | func decode(r io.Reader, opts *DecodeOpts, swapDimensions bool) (im image.Image, format string, err error, needRescale bool) {
if opts == nil {
// Fall-back to normal decode.
im, format, err = image.Decode(r)
return im, format, err, false
}
var buf bytes.Buffer
tr := io.TeeReader(r, &buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, "", err, false
}
mr := io.MultiReader(&buf, r)
b := image.Rect(0, 0, ic.Width, ic.Height)
sw, sh, needRescale := opts.rescaleDimensions(b, swapDimensions)
if !needRescale {
im, format, err = image.Decode(mr)
return im, format, err, false
}
imageDebug(fmt.Sprintf("Resizing from %dx%d -> %dx%d", ic.Width, ic.Height, sw, sh))
if format == "cr2" {
// Replace mr with an io.Reader to the JPEG thumbnail embedded in a
// CR2 image.
if mr, err = cr2.NewReader(mr); err != nil {
return nil, "", err, false
}
format = "jpeg"
}
if format == "jpeg" && fastjpeg.Available() {
factor := fastjpeg.Factor(ic.Width, ic.Height, sw, sh)
if factor > 1 {
var buf bytes.Buffer
tr := io.TeeReader(mr, &buf)
im, err = fastjpeg.DecodeDownsample(tr, factor)
switch err.(type) {
case fastjpeg.DjpegFailedError:
log.Printf("Retrying with jpeg.Decode, because djpeg failed with: %v", err)
im, err = jpeg.Decode(io.MultiReader(&buf, mr))
case nil:
// fallthrough to rescale() below.
default:
return nil, format, err, false
}
return rescale(im, sw, sh), format, err, true
}
}
// Fall-back to normal decode.
im, format, err = image.Decode(mr)
if err != nil {
return nil, "", err, false
}
return rescale(im, sw, sh), format, err, needRescale
} | [
"func",
"decode",
"(",
"r",
"io",
".",
"Reader",
",",
"opts",
"*",
"DecodeOpts",
",",
"swapDimensions",
"bool",
")",
"(",
"im",
"image",
".",
"Image",
",",
"format",
"string",
",",
"err",
"error",
",",
"needRescale",
"bool",
")",
"{",
"if",
"opts",
"... | // decoder reads an image from r and modifies the image as defined by opts.
// swapDimensions indicates the decoded image will be rotated after being
// returned, and when interpreting opts, the post-rotation dimensions should
// be considered.
// The decoded image is returned in im. The registered name of the decoder
// used is returned in format. If the image was not successfully decoded, err
// will be non-nil. If the decoded image was made smaller, needRescale will
// be true. | [
"decoder",
"reads",
"an",
"image",
"from",
"r",
"and",
"modifies",
"the",
"image",
"as",
"defined",
"by",
"opts",
".",
"swapDimensions",
"indicates",
"the",
"decoded",
"image",
"will",
"be",
"rotated",
"after",
"being",
"returned",
"and",
"when",
"interpreting... | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L458-L515 | train |
perkeep/perkeep | internal/images/images.go | exifOrientation | func exifOrientation(r io.Reader) (int, FlipDirection) {
var (
angle int
flipMode FlipDirection
)
ex, err := exif.Decode(r)
if err != nil {
imageDebug("No valid EXIF; will not rotate or flip.")
return 0, 0
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF; will not rotate or flip.`)
return 0, 0
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF error: %v", err))
return 0, 0
}
switch orient {
case topLeftSide:
// do nothing
case topRightSide:
flipMode = 2
case bottomRightSide:
angle = 180
case bottomLeftSide:
angle = 180
flipMode = 2
case leftSideTop:
angle = -90
flipMode = 2
case rightSideTop:
angle = -90
case rightSideBottom:
angle = 90
flipMode = 2
case leftSideBottom:
angle = 90
}
return angle, flipMode
} | go | func exifOrientation(r io.Reader) (int, FlipDirection) {
var (
angle int
flipMode FlipDirection
)
ex, err := exif.Decode(r)
if err != nil {
imageDebug("No valid EXIF; will not rotate or flip.")
return 0, 0
}
tag, err := ex.Get(exif.Orientation)
if err != nil {
imageDebug(`No "Orientation" tag in EXIF; will not rotate or flip.`)
return 0, 0
}
orient, err := tag.Int(0)
if err != nil {
imageDebug(fmt.Sprintf("EXIF error: %v", err))
return 0, 0
}
switch orient {
case topLeftSide:
// do nothing
case topRightSide:
flipMode = 2
case bottomRightSide:
angle = 180
case bottomLeftSide:
angle = 180
flipMode = 2
case leftSideTop:
angle = -90
flipMode = 2
case rightSideTop:
angle = -90
case rightSideBottom:
angle = 90
flipMode = 2
case leftSideBottom:
angle = 90
}
return angle, flipMode
} | [
"func",
"exifOrientation",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"FlipDirection",
")",
"{",
"var",
"(",
"angle",
"int",
"\n",
"flipMode",
"FlipDirection",
"\n",
")",
"\n",
"ex",
",",
"err",
":=",
"exif",
".",
"Decode",
"(",
"r",
")",
... | // exifOrientation parses the EXIF data in r and returns the stored
// orientation as the angle and flip necessary to transform the image. | [
"exifOrientation",
"parses",
"the",
"EXIF",
"data",
"in",
"r",
"and",
"returns",
"the",
"stored",
"orientation",
"as",
"the",
"angle",
"and",
"flip",
"necessary",
"to",
"transform",
"the",
"image",
"."
] | e28bbbd1588d64df8ab7a82393afd39d64c061f7 | https://github.com/perkeep/perkeep/blob/e28bbbd1588d64df8ab7a82393afd39d64c061f7/internal/images/images.go#L519-L561 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.