_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q31900 | GetPermanodesWithAttr | train | 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,... | go | {
"resource": ""
} |
q31901 | QueryRaw | train | 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 | {
"resource": ""
} |
q31902 | versionMismatch | train | 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 ... | go | {
"resource": ""
} |
q31903 | FileHasContents | train | 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... | go | {
"resource": ""
} |
q31904 | initPrefix | train | 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 | {
"resource": ""
} |
q31905 | DiscoveryDoc | train | 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 {... | go | {
"resource": ""
} |
q31906 | GetJSON | train | 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.DecodeJS... | go | {
"resource": ""
} |
q31907 | Sign | train | 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 er... | go | {
"resource": ""
} |
q31908 | newRequest | train | 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())
}
// no... | go | {
"resource": ""
} |
q31909 | expect2XX | train | 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 ... | go | {
"resource": ""
} |
q31910 | DialFunc | train | 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 | {
"resource": ""
} |
q31911 | Signer | train | func (c *Client) Signer() (*schema.Signer, error) {
c.signerOnce.Do(c.signerInit)
return c.signer, c.signerErr
} | go | {
"resource": ""
} |
q31912 | signBlob | train | 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 | {
"resource": ""
} |
q31913 | checkMatchingKeys | train | 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.Key... | go | {
"resource": ""
} |
q31914 | Factor | train | 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 | {
"resource": ""
} |
q31915 | DecodeDownsample | train | 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 :=... | go | {
"resource": ""
} |
q31916 | ClaimDate | train | 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 | {
"resource": ""
} |
q31917 | ByteParts | train | 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 | {
"resource": ""
} |
q31918 | AsClaim | train | 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 | {
"resource": ""
} |
q31919 | AsShare | train | 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 | {
"resource": ""
} |
q31920 | DirectoryEntries | train | func (b *Blob) DirectoryEntries() (br blob.Ref, ok bool) {
if b.Type() != "directory" {
return
}
return b.ss.Entries, true
} | go | {
"resource": ""
} |
q31921 | StaticSetMembers | train | 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 | {
"resource": ""
} |
q31922 | StaticSetMergeSets | train | 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 | {
"resource": ""
} |
q31923 | IsExpired | train | func (s Share) IsExpired() bool {
t := time.Time(s.b.ss.Expires)
return !t.IsZero() && clockNow().After(t)
} | go | {
"resource": ""
} |
q31924 | AsStaticFile | train | 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 | {
"resource": ""
} |
q31925 | AsStaticSymlink | train | func (sf StaticFile) AsStaticSymlink() (s StaticSymlink, ok bool) {
if sf.b.ss.Type == "symlink" {
return StaticSymlink{sf}, true
}
return
} | go | {
"resource": ""
} |
q31926 | AsStaticFIFO | train | func (sf StaticFile) AsStaticFIFO() (fifo StaticFIFO, ok bool) {
if sf.b.ss.Type == "fifo" {
return StaticFIFO{sf}, true
}
return
} | go | {
"resource": ""
} |
q31927 | AsStaticSocket | train | func (sf StaticFile) AsStaticSocket() (ss StaticSocket, ok bool) {
if sf.b.ss.Type == "socket" {
return StaticSocket{sf}, true
}
return
} | go | {
"resource": ""
} |
q31928 | SetShareTarget | train | 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 | {
"resource": ""
} |
q31929 | SetShareExpiration | train | 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 | {
"resource": ""
} |
q31930 | SetRawStringField | train | func (bb *Builder) SetRawStringField(key, value string) *Builder {
bb.m[key] = value
return bb
} | go | {
"resource": ""
} |
q31931 | Blob | train | 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 | {
"resource": ""
} |
q31932 | SetSigner | train | func (bb *Builder) SetSigner(signer blob.Ref) *Builder {
bb.m["camliSigner"] = signer.String()
return bb
} | go | {
"resource": ""
} |
q31933 | Sign | train | func (bb *Builder) Sign(ctx context.Context, signer *Signer) (string, error) {
return bb.SignAt(ctx, signer, time.Time{})
} | go | {
"resource": ""
} |
q31934 | SignAt | train | 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.SignJSO... | go | {
"resource": ""
} |
q31935 | SetType | train | func (bb *Builder) SetType(t string) *Builder {
bb.m["camliType"] = t
return bb
} | go | {
"resource": ""
} |
q31936 | Type | train | func (bb *Builder) Type() string {
if s, ok := bb.m["camliType"].(string); ok {
return s
}
return ""
} | go | {
"resource": ""
} |
q31937 | ClaimType | train | func (bb *Builder) ClaimType() ClaimType {
if s, ok := bb.m["claimType"].(string); ok {
return ClaimType(s)
}
return ""
} | go | {
"resource": ""
} |
q31938 | SetFileName | train | 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 | {
"resource": ""
} |
q31939 | SetSymlinkTarget | train | 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 | {
"resource": ""
} |
q31940 | SetClaimDate | train | 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 o... | go | {
"resource": ""
} |
q31941 | SetModTime | train | func (bb *Builder) SetModTime(t time.Time) *Builder {
bb.m["unixMtime"] = RFC3339FromTime(t)
return bb
} | go | {
"resource": ""
} |
q31942 | CapCreationTime | train | 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 | {
"resource": ""
} |
q31943 | ModTime | train | 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 | {
"resource": ""
} |
q31944 | PartsSize | train | 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 | {
"resource": ""
} |
q31945 | StreamBlobs | train | 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 | {
"resource": ""
} |
q31946 | StreamBlobs | train | 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.Enumera... | go | {
"resource": ""
} |
q31947 | ScaledDimensions | train | 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
... | go | {
"resource": ""
} |
q31948 | rescaleDimensions | train | 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... | go | {
"resource": ""
} |
q31949 | rescale | train | 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*... | go | {
"resource": ""
} |
q31950 | forcedOrientation | train | 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.(... | go | {
"resource": ""
} |
q31951 | DecodeConfig | train | 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{}, e... | go | {
"resource": ""
} |
q31952 | decode | train | 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 :=... | go | {
"resource": ""
} |
q31953 | exifOrientation | train | 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 EXI... | go | {
"resource": ""
} |
q31954 | Decode | train | func Decode(r io.Reader, opts *DecodeOpts) (image.Image, Config, error) {
var (
angle int
buf bytes.Buffer
c Config
flipMode FlipDirection
)
tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
if opts.useEXIF() {
angle, flipMode = exifOrientation(tr)
} else {
var err error
angle, flipM... | go | {
"resource": ""
} |
q31955 | localImageMagick | train | func localImageMagick() string {
bin, err := exec.LookPath("magick")
if err != nil {
return ""
}
magickHasHEIC.Lock()
defer magickHasHEIC.Unlock()
if magickHasHEIC.checked {
if magickHasHEIC.heic {
return bin
}
return ""
}
magickHasHEIC.checked = true
out, err := exec.Command(bin, "-version").Combin... | go | {
"resource": ""
} |
q31956 | HEIFToJPEG | train | func HEIFToJPEG(fr io.Reader, maxSize *Dimensions) ([]byte, error) {
convertGate.Start()
defer convertGate.Done()
useDocker := false
bin := localImageMagick()
if bin == "" {
if err := setUpThumbnailContainer(); err != nil {
return nil, NoHEICTOJPEGError{fmt.Errorf("recent ImageMagick magick binary not found i... | go | {
"resource": ""
} |
q31957 | enumerateQueuedBlobs | train | func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseUint(it.Value(), 10, 32)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q... | go | {
"resource": ""
} |
q31958 | startValidatePrefix | train | func (sh *SyncHandler) startValidatePrefix(ctx context.Context, pfx string, doDest bool) (<-chan blob.SizedRef, <-chan error) {
var e blobserver.BlobEnumerator
if doDest {
e = sh.to
} else {
e = sh.from
}
c := make(chan blob.SizedRef, 64)
errc := make(chan error, 1)
go func() {
defer close(c)
var last st... | go | {
"resource": ""
} |
q31959 | hourlyCompare | train | func (sh *SyncHandler) hourlyCompare(hourlyBytes uint64) {
ctx := context.TODO()
ticker := time.NewTicker(time.Hour).C
for {
content := make([]byte, 16)
if _, err := rand.Read(content); err != nil {
panic(err)
}
after := blob.RefFromBytes(content).String()
var roundBytes uint64
var roundBlobs int
er... | go | {
"resource": ""
} |
q31960 | urlFileRef | train | func (r *run) urlFileRef(urlstr, filename string) string {
im := r.im
im.mu.Lock()
if br, ok := im.imageFileRef[urlstr]; ok {
im.mu.Unlock()
return br.String()
}
im.mu.Unlock()
if urlstr == "" {
return ""
}
res, err := ctxutil.Client(r.Context()).Get(urlstr)
if err != nil {
log.Printf("swarm: couldn't... | go | {
"resource": ""
} |
q31961 | auth | train | func auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth2.Config{
ClientID: clientID,
ClientSecret: secret,
Endpoint: oauth2.Endpoint{
AuthURL: authURL,
TokenURL: tokenURL,
},
RedirectURL: ctx.Ca... | go | {
"resource": ""
} |
q31962 | mixedArrayFromString | train | func mixedArrayFromString(s string) (parts []interface{}) {
for len(s) > 0 {
if n := utf8StrLen(s); n > 0 {
parts = append(parts, s[:n])
s = s[n:]
} else {
parts = append(parts, s[0])
s = s[1:]
}
}
return parts
} | go | {
"resource": ""
} |
q31963 | utf8StrLen | train | func utf8StrLen(s string) int {
for i, r := range s {
for r == utf8.RuneError {
// The RuneError value can be an error
// sentinel value (if it's size 1) or the same
// value encoded properly. Decode it to see if
// it's the 1 byte sentinel value.
_, size := utf8.DecodeRuneInString(s[i:])
if size =... | go | {
"resource": ""
} |
q31964 | FileNameString | train | func (ss *superset) FileNameString() string {
v := ss.FileName
if v == "" {
v = stringFromMixedArray(ss.FileNameBytes)
}
if v != "" {
if strings.Contains(v, "/") {
// Bogus schema blob; ignore.
return ""
}
if strings.Contains(v, "\\") {
// Bogus schema blob; ignore.
return ""
}
}
return v
} | go | {
"resource": ""
} |
q31965 | NewUnsignedPermanode | train | func NewUnsignedPermanode() *Builder {
bb := base(1, "permanode")
chars := make([]byte, 20)
_, err := io.ReadFull(rand.Reader, chars)
if err != nil {
panic("error reading random bytes: " + err.Error())
}
bb.m["random"] = base64.StdEncoding.EncodeToString(chars)
return bb
} | go | {
"resource": ""
} |
q31966 | NewHashPlannedPermanode | train | func NewHashPlannedPermanode(h hash.Hash) *Builder {
return NewPlannedPermanode(blob.RefFromHash(h).String())
} | go | {
"resource": ""
} |
q31967 | PopulateParts | train | func (bb *Builder) PopulateParts(size int64, parts []BytesPart) error {
return populateParts(bb.m, size, parts)
} | go | {
"resource": ""
} |
q31968 | NewDelAttributeClaim | train | func NewDelAttributeClaim(permaNode blob.Ref, attr, value string) *Builder {
return newClaim(&claimParam{
permanode: permaNode,
claimType: DelAttributeClaim,
attribute: attr,
value: value,
})
} | go | {
"resource": ""
} |
q31969 | NewDeleteClaim | train | func NewDeleteClaim(target blob.Ref) *Builder {
return newClaim(&claimParam{
target: target,
claimType: DeleteClaim,
})
} | go | {
"resource": ""
} |
q31970 | IsZoneKnown | train | func IsZoneKnown(t time.Time) bool {
if t.Location() == UnknownLocation {
return false
}
if _, off := t.Zone(); off == -60 {
return false
}
return true
} | go | {
"resource": ""
} |
q31971 | SetServerConfig | train | func (hh *HelpHandler) SetServerConfig(config jsonconfig.Obj) {
if hh.serverConfig == nil {
hh.serverConfig = config
}
} | go | {
"resource": ""
} |
q31972 | UpdateShareChain | train | func (c *Client) UpdateShareChain(b blob.Ref, r io.Reader) error {
c.viaMu.Lock()
defer c.viaMu.Unlock()
if c.via == nil {
// Not in sharing mode, so return immediately.
return ErrNotSharing
}
// Slurp 1 MB to find references to other blobrefs for the via path.
var buf bytes.Buffer
const maxSlurp = 1 << 20
... | go | {
"resource": ""
} |
q31973 | RunOnce | train | func (a *Archiver) RunOnce(ctx context.Context) error {
if a.Source == nil {
return errors.New("archiver: nil Source")
}
if a.Store == nil {
return errors.New("archiver: nil Store func")
}
pz := &potentialZip{a: a}
err := blobserver.EnumerateAll(ctx, a.Source, func(sb blob.SizedRef) error {
if err := pz.add... | go | {
"resource": ""
} |
q31974 | EnumerateAll | train | func EnumerateAll(ctx context.Context, src BlobEnumerator, fn func(blob.SizedRef) error) error {
return EnumerateAllFrom(ctx, src, "", fn)
} | go | {
"resource": ""
} |
q31975 | EnumerateAllFrom | train | func EnumerateAllFrom(ctx context.Context, src BlobEnumerator, after string, fn func(blob.SizedRef) error) error {
const batchSize = 1000
var mu sync.Mutex // protects returning with an error while fn is still running
errc := make(chan error, 1)
for {
ch := make(chan blob.SizedRef, 16)
n := 0
go func() {
v... | go | {
"resource": ""
} |
q31976 | updatePrimaryPhoto | train | func (r *run) updatePrimaryPhoto(photoNode *importer.Object) error {
photoId := photoNode.Attr(attrFlickrId)
for album, photo := range r.primaryPhoto {
if photoId != photo {
continue
}
setsNode, err := r.getTopLevelNode("sets", "Sets")
if err != nil {
return fmt.Errorf("could not set %v as primary photo... | go | {
"resource": ""
} |
q31977 | pull | train | func pull(image string) error {
var stdout, stderr bytes.Buffer
cmd := exec.Command("docker", "pull", image)
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
out := stdout.String()
// TODO(mpl): if it turns out docker respects conventions and the
// "Authentication is required" message does come from ... | go | {
"resource": ""
} |
q31978 | updateScan | train | func (h *handler) updateScan(ctx context.Context, pn blob.Ref, new, old *mediaObject) error {
if old == nil {
mo, err := h.fetchScan(pn)
if err != nil {
return fmt.Errorf("scan %v not found: %v", pn, err)
}
old = &mo
}
if new.contentRef.Valid() && old.contentRef != new.contentRef {
if err := h.setAttrib... | go | {
"resource": ""
} |
q31979 | persistDocAndPages | train | func (h *handler) persistDocAndPages(ctx context.Context, newDoc document) (blob.Ref, error) {
br := blob.Ref{}
pn, err := h.createDocument(ctx, newDoc)
if err != nil {
return br, err
}
for _, page := range newDoc.pages {
if err := h.setAttribute(ctx, page, "document", pn.String()); err != nil {
return br, ... | go | {
"resource": ""
} |
q31980 | dateOrZero | train | func dateOrZero(datestr, format string) (time.Time, error) {
if datestr == "" {
return time.Time{}, nil
}
if format == "" {
format = time.RFC3339
}
return time.Parse(format, datestr)
} | go | {
"resource": ""
} |
q31981 | breakAndDeleteDoc | train | func (h *handler) breakAndDeleteDoc(ctx context.Context, docRef blob.Ref) error {
doc, err := h.fetchDocument(docRef)
if err != nil {
return fmt.Errorf("document %v not found: %v", docRef, err)
}
if err := h.deleteNode(ctx, docRef); err != nil {
return fmt.Errorf("could not delete document %v: %v", docRef, err)... | go | {
"resource": ""
} |
q31982 | NewOwner | train | func NewOwner(keyID string, ref blob.Ref) *Owner {
return &Owner{
keyID: []string{keyID},
blobByKeyID: map[string]SignerRefSet{keyID: SignerRefSet{ref.String()}},
}
} | go | {
"resource": ""
} |
q31983 | RefSet | train | func (o *Owner) RefSet(keyID string) SignerRefSet {
if o == nil || len(o.blobByKeyID) == 0 {
return nil
}
refs := o.blobByKeyID[keyID]
if len(refs) == 0 {
return nil
}
return refs
} | go | {
"resource": ""
} |
q31984 | SetReindexMaxProcs | train | func SetReindexMaxProcs(n int) {
reindexMaxProcs.Lock()
defer reindexMaxProcs.Unlock()
reindexMaxProcs.v = n
} | go | {
"resource": ""
} |
q31985 | integrityCheck | train | func (x *Index) integrityCheck(timeout time.Duration) error {
t0 := time.Now()
x.logf("starting integrity check...")
defer func() {
x.logf("integrity check done (after %v)", time.Since(t0).Round(10*time.Millisecond))
}()
if x.blobSource == nil {
return errors.New("index: can't check sanity of index: no blobSou... | go | {
"resource": ""
} |
q31986 | schemaVersion | train | func (x *Index) schemaVersion() int {
schemaVersionStr, err := x.s.Get(keySchemaVersion.name)
if err != nil {
if err == sorted.ErrNotFound {
return 0
}
panic(fmt.Sprintf("Could not get index schema version: %v", err))
}
schemaVersion, err := strconv.Atoi(schemaVersionStr)
if err != nil {
panic(fmt.Sprin... | go | {
"resource": ""
} |
q31987 | initDeletesCache | train | func (x *Index) initDeletesCache() (err error) {
x.deletes = newDeletionCache()
it := x.queryPrefix(keyDeleted)
defer closeIterator(it, &err)
for it.Next() {
cl, ok := kvDeleted(it.Key())
if !ok {
return fmt.Errorf("Bogus keyDeleted entry key: want |\"deleted\"|<deleted blobref>|<reverse claimdate>|<deleter ... | go | {
"resource": ""
} |
q31988 | isDeleted | train | func (x *Index) isDeleted(br blob.Ref) bool {
deletes, ok := x.deletes.m[br]
if !ok {
return false
}
for _, v := range deletes {
if !x.isDeleted(v.deleter) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q31989 | GetRecentPermanodes | train | func (x *Index) GetRecentPermanodes(ctx context.Context, dest chan<- camtypes.RecentPermanode, owner blob.Ref, limit int, before time.Time) (err error) {
defer close(dest)
keyId, err := x.KeyId(ctx, owner)
if err == sorted.ErrNotFound {
x.logf("no recent permanodes because keyId for owner %v not found", owner)
... | go | {
"resource": ""
} |
q31990 | HasLegacySHA1 | train | func (x *Index) HasLegacySHA1() (ok bool, err error) {
if x.corpus != nil {
return x.corpus.hasLegacySHA1, err
}
it := x.queryPrefix(keyWholeToFileRef, "sha1-")
defer closeIterator(it, &err)
for it.Next() {
return true, err
}
return false, err
} | go | {
"resource": ""
} |
q31991 | signerRefs | train | func (x *Index) signerRefs(ctx context.Context, keyID string) (SignerRefSet, error) {
if x.corpus != nil {
return x.corpus.signerRefs[keyID], nil
}
it := x.queryPrefixString(keySignerKeyID.name)
var err error
var refs SignerRefSet
defer closeIterator(it, &err)
prefix := keySignerKeyID.name + ":"
for it.Next()... | go | {
"resource": ""
} |
q31992 | SearchPermanodesWithAttr | train | func (x *Index) SearchPermanodesWithAttr(ctx context.Context, dest chan<- blob.Ref, request *camtypes.PermanodeByAttrRequest) (err error) {
defer close(dest)
if request.FuzzyMatch {
// TODO(bradfitz): remove this for now? figure out how to handle it generically?
return errors.New("TODO: SearchPermanodesWithAttr: ... | go | {
"resource": ""
} |
q31993 | ExistingFileSchemas | train | func (x *Index) ExistingFileSchemas(wholeRef ...blob.Ref) (WholeRefToFile, error) {
schemaRefs := make(WholeRefToFile)
for _, v := range wholeRef {
newRefs, err := x.existingFileSchemas(v)
if err != nil {
return nil, err
}
schemaRefs[v.String()] = newRefs
}
return schemaRefs, nil
} | go | {
"resource": ""
} |
q31994 | kvImageInfo | train | func kvImageInfo(v []byte) (ii camtypes.ImageInfo, ok bool) {
pipei := bytes.IndexByte(v, '|')
if pipei < 0 {
return
}
w, err := strutil.ParseUintBytes(v[:pipei], 10, 16)
if err != nil {
return
}
h, err := strutil.ParseUintBytes(v[pipei+1:], 10, 16)
if err != nil {
return
}
ii.Width = uint16(w)
ii.Heig... | go | {
"resource": ""
} |
q31995 | GetDirMembers | train | func (x *Index) GetDirMembers(ctx context.Context, dir blob.Ref, dest chan<- blob.Ref, limit int) (err error) {
defer close(dest)
sent := 0
if x.corpus != nil {
children, err := x.corpus.GetDirChildren(ctx, dir)
if err != nil {
return err
}
for child := range children {
dest <- child
sent++
if s... | go | {
"resource": ""
} |
q31996 | Close | train | func (x *Index) Close() error {
if cl, ok := x.s.(io.Closer); ok {
return cl.Close()
}
return nil
} | go | {
"resource": ""
} |
q31997 | initNeededMaps | train | func (x *Index) initNeededMaps() (err error) {
x.deletes = newDeletionCache()
it := x.queryPrefix(keyMissing)
defer closeIterator(it, &err)
for it.Next() {
key := it.KeyBytes()
pair := key[len("missing|"):]
pipe := bytes.IndexByte(pair, '|')
if pipe < 0 {
return fmt.Errorf("Bogus missing key %q", key)
... | go | {
"resource": ""
} |
q31998 | NewUnlocked | train | func NewUnlocked(maxEntries int) *Cache {
c := New(maxEntries)
c.nolock = true
return c
} | go | {
"resource": ""
} |
q31999 | RemoveOldest | train | func (c *Cache) RemoveOldest() (key string, value interface{}) {
if !c.nolock {
c.mu.Lock()
defer c.mu.Unlock()
}
return c.removeOldest()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.