id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c6200 | AuthorizationFailed || err == BadRequest) && retries > 0 {
retries--
goto again
}
return
}
err = c.Auth.Response(resp)
if err != nil {
return
}
}
if customAuth, isCustom := c.Auth.(CustomEndpointAuthenticator); isCustom && c.EndpointType != "" {
c.StorageUrl = customAuth.StorageUrlForEndpo... | |
c6201 | nil {
return
}
if OnReAuth != nil {
targetUrlOut, err = OnReAuth()
if err != nil {
return
}
}
}
authToken = c.AuthToken
return
} | |
c6202 |
CloseIdleConnections()
}); ok {
tr.CloseIdleConnections()
}
} | |
c6203 |
c.AuthToken = ""
c.authLock.Unlock()
} | |
c6204 | c.authLock.Unlock()
return c.authenticated()
} | |
c6205 |
var part []byte
var prefix bool
for {
if part, prefix, err = reader.ReadLine(); err != nil {
break
}
buffer.Write(part)
if !prefix {
lines = append(lines, buffer.String())
buffer.Reset()
}
}
if err == io.EOF {
err = nil
}
return
} | |
c6206 | := json.NewDecoder(resp.Body)
return decoder.Decode(result)
} | |
c6207 |
if opts.Marker != "" {
v.Set("marker", opts.Marker)
}
if opts.EndMarker != "" {
v.Set("end_marker", opts.EndMarker)
}
h = opts.Headers
}
return v, h
} | |
c6208 | h,
})
if err != nil {
return nil, err
}
lines, err := readLines(resp)
return lines, err
} | |
c6209 | h,
})
if err != nil {
return nil, err
}
var containers []Container
err = readJson(resp, &containers)
return containers, err
} | |
c6210 | newOpts.Limit = allContainersLimit
}
newOpts.Marker = ""
return &newOpts
} | |
c6211 | }
containers = append(containers, newContainers...)
if len(newContainers) < opts.Limit {
break
}
opts.Marker = newContainers[len(newContainers)-1].Name
}
return containers, nil
} | |
c6212 |
containers = append(containers, newContainers...)
if len(newContainers) < opts.Limit {
break
}
opts.Marker = newContainers[len(newContainers)-1]
}
return containers, nil
} | |
c6213 | if opts.Path != "" {
v.Set("path", opts.Path)
}
if opts.Delimiter != 0 {
v.Set("delimiter", string(opts.Delimiter))
}
h = opts.Headers
}
return v, h
} | |
c6214 | ContainerErrorMap,
Headers: h,
})
if err != nil {
return nil, err
}
return readLines(resp)
} | |
c6215 | = Limit
}
if !newOpts.KeepMarker {
newOpts.Marker = ""
}
return &newOpts
} | |
c6216 | func(opts *ObjectsOpts) (interface{}, error) {
newObjects, err := c.Objects(container, opts)
if err == nil {
objects = append(objects, newObjects...)
}
return newObjects, err
})
return objects, err
} | |
c6217 | func(opts *ObjectsOpts) (interface{}, error) {
newObjects, err := c.ObjectNames(container, opts)
if err == nil {
objects = append(objects, newObjects...)
}
return newObjects, err
})
return objects, err
} | |
c6218 | result, err = strconv.ParseInt(value, 10, 64)
if err != nil {
err = newErrorf(0, "Bad Header '%s': '%s': %s", header, value, err)
}
return
} | |
c6219 | 'X-Account-Object-Count': '1433'}
if info.BytesUsed, err = getInt64FromHeader(resp, "X-Account-Bytes-Used"); err != nil {
return
}
if info.Containers, err = getInt64FromHeader(resp, "X-Account-Container-Count"); err != nil {
return
}
if info.Objects, err = getInt64FromHeader(resp, "X-Account-Object-Count"); e... | |
c6220 | ContainerErrorMap,
NoResponse: true,
Headers: h,
})
return err
} | |
c6221 | Container: container,
Operation: "PUT",
ErrorMap: ContainerErrorMap,
NoResponse: true,
Headers: h,
})
return err
} | |
c6222 | "DELETE",
ErrorMap: ContainerErrorMap,
NoResponse: true,
})
return err
} | |
c6223 | NoResponse: true,
})
if err != nil {
return
}
// Parse the headers into the struct
info.Name = container
if info.Bytes, err = getInt64FromHeader(resp, "X-Container-Bytes-Used"); err != nil {
return
}
if info.Count, err = getInt64FromHeader(resp, "X-Container-Object-Count"); err != nil {
return
}
return... | |
c6224 | return 0, newError(500, "Write on closed file")
}
if err == nil && file.checkHash {
_, _ = file.hash.Write(p)
}
return
} | |
c6225 |
contentType = "application/octet-stream"
}
}
// Meta stuff
extraHeaders := map[string]string{
"Content-Type": contentType,
}
for key, value := range h {
extraHeaders[key] = value
}
if Hash != "" {
extraHeaders["Etag"] = Hash
*checkHash = false // the server will do it
}
return extraHeaders
} | |
c6226 | strconv.Itoa(len(contents))}
_, err = c.ObjectPut(container, objectName, buf, true, "", contentType, h)
return
} | |
c6227 |
file.bytes += int64(n)
file.pos += int64(n)
if err == io.EOF {
file.eof = true
}
return
} | |
c6228 | file.objectName)
file.length = info.Bytes
file.lengthOk = (err == nil)
return file.length, err
}
return file.length, nil
} | |
c6229 | receivedMd5 != calculatedMd5 {
err = ObjectCorrupted
return
}
}
// Check to see we read the correct number of bytes
if file.lengthOk && file.length != file.bytes {
err = ObjectCorrupted
return
}
return
} | |
c6230 | err = c.ObjectGet(container, objectName, &buf, true, nil)
contents = buf.String()
return
} | |
c6231 |
Operation: "DELETE",
ErrorMap: objectErrorMap,
})
return err
} | |
c6232 |
mac.Write([]byte(body))
sig := hex.EncodeToString(mac.Sum(nil))
return fmt.Sprintf("%s/%s/%s?temp_url_sig=%s&temp_url_expires=%d", c.StorageUrl, container, objectName, sig, expires.Unix())
} | |
c6233 | := errorMap[code]; ok {
return err
}
}
if 200 <= code && code <= 299 {
return nil
}
return newError(code, reason)
} | |
c6234 | url.URL
u.Path = in
return u.String()
} | |
c6235 | = value
}
_, headers, err = c.storage(RequestOpts{
Container: srcContainer,
ObjectName: srcObjectName,
Operation: "COPY",
ErrorMap: objectErrorMap,
NoResponse: true,
Headers: extraHeaders,
})
return
} | |
c6236 | dstObjectName, nil)
if err != nil {
return
}
return c.ObjectDelete(srcContainer, srcObjectName)
} | |
c6237 | _, err = c.ObjectCopy(container, objectName, container, objectName, h)
return
} | |
c6238 | if the header was set properly
_, headers, err := c.Container(current)
if err != nil {
return err
}
// If failed to set versions header, return Forbidden as the server doesn't support this
if headers["X-Versions-Location"] != version {
return Forbidden
}
return nil
} | |
c6239 | := c.ContainerUpdate(current, h); err != nil {
return err
}
return nil
} | |
c6240 | already
// selecting on t.C. However we've stopped the original timer
// so won't break transfers but may not time them out :-(
*t = *time.NewTimer(d)
} | |
c6241 | return c.stringWidthZeroJoiner(s)
}
return c.stringWidth(s)
} | |
c6242 | {
return DefaultCondition.FillRight(s, w)
} | |
c6243 |
return pwl.Path.computeRootHash(leafHash)
} | |
c6244 |
for i := len(pl) - 1; i >= 0; i-- {
pin := pl[i]
hash = pin.Hash(hash)
}
return hash
} | |
c6245 | += node.Size - pl[i+1].Size
} else {
idx += node.Size - 1
}
} else {
return -1
}
}
return idx
} | |
c6246 | root := tree.ndb, tree.root
printNode(ndb, root, 0)
} | |
c6247 |
key: key,
value: value,
height: 0,
size: 1,
version: version,
}
} | |
c6248 | cmn.ColoredBytes(node.value, cmn.Cyan, cmn.Blue),
node.version,
node.leftHash, node.rightHash,
hashstr)
} | |
c6249 | node.height,
version: version,
size: node.size,
hash: nil,
leftHash: node.leftHash,
leftNode: node.leftNode,
rightHash: node.rightHash,
rightNode: node.rightNode,
persisted: false,
}
} | |
c6250 | {
return node.getLeftNode(t).has(t, key)
}
return node.getRightNode(t).has(t, key)
} | |
c6251 |
if bytes.Compare(key, node.key) < 0 {
return node.getLeftNode(t).get(t, key)
}
rightNode := node.getRightNode(t)
index, value = rightNode.get(t, key)
index += node.size - rightNode.size
return index, value
} | |
c6252 | nil {
panic(err)
}
h.Write(buf.Bytes())
node.hash = h.Sum(nil)
return node.hash
} | |
c6253 | != nil {
panic(err)
}
h.Write(buf.Bytes())
node.hash = h.Sum(nil)
return node.hash, hashCount + 1
} | |
c6254 | err != nil {
return cmn.ErrorWrap(err, "writing key")
}
// Indirection needed to provide proofs without values.
// (e.g. proofLeafNode.ValueHash)
valueHash := tmhash.Sum(node.value)
err = amino.EncodeByteSlice(w, valueHash)
if err != nil {
return cmn.ErrorWrap(err, "writing value")
}
} else {
if... | |
c6255 |
rightHash, rightCount := node.rightNode.hashWithCount()
node.rightHash = rightHash
hashCount += rightCount
}
err = node.writeHashBytes(w)
return
} | |
c6256 | node.key)
if cause != nil {
return cmn.ErrorWrap(cause, "writing key")
}
if node.isLeaf() {
cause = amino.EncodeByteSlice(w, node.value)
if cause != nil {
return cmn.ErrorWrap(cause, "writing value")
}
} else {
if node.leftHash == nil {
panic("node.leftHash was nil in writeBytes")
}
cause = am... | |
c6257 | {
return node.traverseInRange(t, nil, nil, ascending, false, 0, func(node *Node, depth uint8) bool {
return cb(node)
})
} | |
c6258 |
return node.getLeftNode(t).lmd(t)
} | |
c6259 | pin)
n, err := node.getLeftNode(t).pathToLeaf(t, key, path)
return n, err
}
// right side
pin := proofInnerNode{
Height: node.height,
Size: node.size,
Version: node.version,
Left: node.getLeftNode(t).hash,
Right: nil,
}
*path = append(*path, pin)
n, err := node.getRightNode(t).pathToLeaf(t... | |
c6260 | cmn.ErrorWrap(ErrInvalidProof, "proof is nil")
}
err := proof.verify(root)
return err
} | |
c6261 |
rootHash, _ := proof.computeRootHash()
return rootHash
} | |
c6262 | nil, nil, err
}
return t.GetWithProof(key)
}
return nil, nil, cmn.ErrorWrap(ErrVersionDoesNotExist, "")
} | |
c6263 | &ImmutableTree{
// NodeDB-backed Tree.
ndb: newNodeDB(db, cacheSize),
}
} | |
c6264 | %x", key, val))
return false
})
return "Tree{" + strings.Join(leaves, ", ") + "}"
} | |
c6265 |
if t.root == nil {
return 0
}
return t.root.size
} | |
c6266 |
if t.root == nil {
return 0
}
return t.root.height
} | |
c6267 | false
}
return t.root.has(t, key)
} | |
c6268 |
hash, _ := t.root.hashWithCount()
return hash
} | |
c6269 | return nil, 0
}
return t.root.hashWithCount()
} | |
c6270 | return 0, nil
}
return t.root.get(t, key)
} | |
c6271 | return nil, nil
}
return t.root.getByIndex(t, index)
} | |
c6272 |
return false
}
return t.root.traverse(t, true, func(node *Node) bool {
if node.height == 0 {
return fn(node.key, node.value)
}
return false
})
} | |
c6273 | ndb: t.ndb,
version: t.version,
}
} | |
c6274 | {
size++
return false
})
return size
} | |
c6275 | orphans: map[string]int64{},
versions: map[int64]bool{},
ndb: ndb,
}
} | |
c6276 | tree.version > 0 {
return tree.lastSaved.Hash()
}
return nil
} | |
c6277 |
tree.addOrphans(orphaned)
return updated
} | |
c6278 | tree.remove(key)
tree.addOrphans(orphaned)
return val, removed
} | |
c6279 |
if newRoot == nil && newRootHash != nil {
tree.root = tree.ndb.GetNode(newRootHash)
} else {
tree.root = newRoot
}
return value, orphaned, true
} | |
c6280 | return latestVersion, fmt.Errorf("wanted to load target %v but only found up to %v",
targetVersion, latestVersion)
}
t := &ImmutableTree{
ndb: tree.ndb,
version: latestVersion,
}
if len(latestRoot) != 0 {
t.root = tree.ndb.GetNode(latestRoot)
}
tree.orphans = map[string]int64{}
tree.ImmutableTree... | |
c6281 |
return latestVersion, err
}
tree.deleteVersionsFrom(targetVersion+1)
return targetVersion, nil
} | |
c6282 | tree.ndb,
version: version,
}, nil
}
return &ImmutableTree{
root: tree.ndb.GetNode(rootHash),
ndb: tree.ndb,
version: version,
}, nil
} | |
c6283 |
} else {
tree.ImmutableTree = &ImmutableTree{ndb: tree.ndb, version: 0}
}
tree.orphans = map[string]int64{}
} | |
c6284 | tree.GetImmutable(version)
if err != nil {
return -1, nil
}
return t.Get(key)
}
return -1, nil
} | |
c6285 |
debug("SAVE TREE %v\n", version)
// Save the current tree.
tree.ndb.SaveBranch(tree.root)
tree.ndb.SaveOrphans(version, tree.orphans)
tree.ndb.SaveRoot(tree.root, version)
}
tree.ndb.Commit()
tree.version = version
tree.versions[version] = true
// Set new working tree.
tree.ImmutableTree = tree.Immuta... | |
c6286 | return cmn.ErrorWrap(ErrVersionDoesNotExist, "")
}
tree.ndb.DeleteVersion(version, true)
tree.ndb.Commit()
delete(tree.versions, version)
return nil
} | |
c6287 | cmn.ErrorWrap(ErrVersionDoesNotExist, "")
}
tree.ndb.DeleteVersion(version, false)
delete(tree.versions, version)
}
tree.ndb.Commit()
tree.ndb.resetLatestVersion(newLatestVersion)
return nil
} | |
c6288 |
newNoderHash, newNoderCached := newNode.rightHash, newNode.rightNode
newNode.rightHash, newNode.rightNode = node.hash, node
node.leftHash, node.leftNode = newNoderHash, newNoderCached
node.calcHeightAndSize(tree.ImmutableTree)
newNode.calcHeightAndSize(tree.ImmutableTree)
return newNode, orphaned
} | |
c6289 |
newNodelHash, newNodelCached := newNode.leftHash, newNode.leftNode
newNode.leftHash, newNode.leftNode = node.hash, node
node.rightHash, node.rightNode = newNodelHash, newNodelCached
node.calcHeightAndSize(tree.ImmutableTree)
newNode.calcHeightAndSize(tree.ImmutableTree)
return newNode, orphaned
} | |
c6290 | return elem.Value.(*Node)
}
// Doesn't exist, load.
buf := ndb.db.Get(ndb.nodeKey(hash))
if buf == nil {
panic(fmt.Sprintf("Value missing for hash %x corresponding to nodeKey %s", hash, ndb.nodeKey(hash)))
}
node, err := MakeNode(buf)
if err != nil {
panic(fmt.Sprintf("Error reading Node. bytes: %x, error... | |
c6291 | on an already persisted node.")
}
// Save node bytes to db.
buf := new(bytes.Buffer)
if err := node.writeBytes(buf); err != nil {
panic(err)
}
ndb.batch.Set(ndb.nodeKey(node.hash), buf.Bytes())
debug("BATCH SAVE %X %p\n", node.hash, node)
node.persisted = true
ndb.cacheNode(node)
} | |
c6292 | panic("Got error from leveldb: " + err.Error())
}
return exists
}
return ndb.db.Get(key) != nil
} | |
c6293 |
ndb.deleteOrphans(version)
ndb.deleteRoot(version, checkLatestVersion)
} | |
c6294 | fromVersion, toVersion))
}
key := ndb.orphanKey(fromVersion, toVersion, hash)
ndb.batch.Set(key, hash)
} | |
c6295 |
if predecessor < fromVersion || fromVersion == toVersion {
debug("DELETE predecessor:%v fromVersion:%v toVersion:%v %X\n", predecessor, fromVersion, toVersion, hash)
ndb.batch.Delete(ndb.nodeKey(hash))
ndb.uncacheNode(hash)
} else {
debug("MOVE predecessor:%v fromVersion:%v toVersion:%v %X\n", predeces... | |
c6296 | delete latest version")
}
key := ndb.rootKey(version)
ndb.batch.Delete(key)
} | |
c6297 | {
ndb.traversePrefix(orphanKeyFormat.Key(version), fn)
} | |
c6298 | nil)
defer itr.Close()
for ; itr.Valid(); itr.Next() {
fn(itr.Key(), itr.Value())
}
} | |
c6299 | dbm.IteratePrefix(ndb.db, prefix)
defer itr.Close()
for ; itr.Valid(); itr.Next() {
fn(itr.Key(), itr.Value())
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.