_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q6200 | authenticate | train | func (c *Connection) authenticate() (err error) {
c.setDefaults()
// Flush the keepalives connection - if we are
// re-authenticating then stuff has gone wrong
flushKeepaliveConnections(c.Transport)
if c.Auth == nil {
c.Auth, err = newAuth(c)
if err != nil {
return
}
}
retries := 1
again:
var req *http.Request
req, err = c.Auth.Request(c)
if err != nil {
return
}
if req != nil {
timer := time.NewTimer(c.ConnectTimeout)
defer timer.Stop()
var resp *http.Response
resp, err = c.doTimeoutRequest(timer, req)
if err != nil {
return
}
defer func() {
drainAndClose(resp.Body, &err)
// Flush the auth connection - we don't want to keep
// it open if keepalives were enabled
flushKeepaliveConnections(c.Transport)
}()
if err = c.parseHeaders(resp, authErrorMap); err != nil {
// Try again for a limited number of times on
// AuthorizationFailed or BadRequest. This allows us
// to try some alternate forms of the request
if (err == 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.StorageUrlForEndpoint(c.EndpointType)
} else {
c.StorageUrl = c.Auth.StorageUrl(c.Internal)
}
c.AuthToken = c.Auth.Token()
if do, ok := c.Auth.(Expireser); ok {
c.Expires = do.Expires()
} else {
c.Expires = time.Time{}
}
if !c.authenticated() {
err = newError(0, "Response didn't have storage url and auth token")
return
}
return
} | go | {
"resource": ""
} |
q6201 | getUrlAndAuthToken | train | func (c *Connection) getUrlAndAuthToken(targetUrlIn string, OnReAuth func() (string, error)) (targetUrlOut, authToken string, err error) {
c.authLock.Lock()
defer c.authLock.Unlock()
targetUrlOut = targetUrlIn
if !c.authenticated() {
err = c.authenticate()
if err != nil {
return
}
if OnReAuth != nil {
targetUrlOut, err = OnReAuth()
if err != nil {
return
}
}
}
authToken = c.AuthToken
return
} | go | {
"resource": ""
} |
q6202 | flushKeepaliveConnections | train | func flushKeepaliveConnections(transport http.RoundTripper) {
if tr, ok := transport.(interface {
CloseIdleConnections()
}); ok {
tr.CloseIdleConnections()
}
} | go | {
"resource": ""
} |
q6203 | UnAuthenticate | train | func (c *Connection) UnAuthenticate() {
c.authLock.Lock()
c.StorageUrl = ""
c.AuthToken = ""
c.authLock.Unlock()
} | go | {
"resource": ""
} |
q6204 | Authenticated | train | func (c *Connection) Authenticated() bool {
c.authLock.Lock()
defer c.authLock.Unlock()
return c.authenticated()
} | go | {
"resource": ""
} |
q6205 | readLines | train | func readLines(resp *http.Response) (lines []string, err error) {
defer drainAndClose(resp.Body, &err)
reader := bufio.NewReader(resp.Body)
buffer := bytes.NewBuffer(make([]byte, 0, 128))
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
} | go | {
"resource": ""
} |
q6206 | readJson | train | func readJson(resp *http.Response, result interface{}) (err error) {
defer drainAndClose(resp.Body, &err)
decoder := json.NewDecoder(resp.Body)
return decoder.Decode(result)
} | go | {
"resource": ""
} |
q6207 | parse | train | func (opts *ContainersOpts) parse() (url.Values, Headers) {
v := url.Values{}
var h Headers
if opts != nil {
if opts.Limit > 0 {
v.Set("limit", strconv.Itoa(opts.Limit))
}
if opts.Prefix != "" {
v.Set("prefix", opts.Prefix)
}
if opts.Marker != "" {
v.Set("marker", opts.Marker)
}
if opts.EndMarker != "" {
v.Set("end_marker", opts.EndMarker)
}
h = opts.Headers
}
return v, h
} | go | {
"resource": ""
} |
q6208 | ContainerNames | train | func (c *Connection) ContainerNames(opts *ContainersOpts) ([]string, error) {
v, h := opts.parse()
resp, _, err := c.storage(RequestOpts{
Operation: "GET",
Parameters: v,
ErrorMap: ContainerErrorMap,
Headers: h,
})
if err != nil {
return nil, err
}
lines, err := readLines(resp)
return lines, err
} | go | {
"resource": ""
} |
q6209 | Containers | train | func (c *Connection) Containers(opts *ContainersOpts) ([]Container, error) {
v, h := opts.parse()
v.Set("format", "json")
resp, _, err := c.storage(RequestOpts{
Operation: "GET",
Parameters: v,
ErrorMap: ContainerErrorMap,
Headers: h,
})
if err != nil {
return nil, err
}
var containers []Container
err = readJson(resp, &containers)
return containers, err
} | go | {
"resource": ""
} |
q6210 | containersAllOpts | train | func containersAllOpts(opts *ContainersOpts) *ContainersOpts {
var newOpts ContainersOpts
if opts != nil {
newOpts = *opts
}
if newOpts.Limit == 0 {
newOpts.Limit = allContainersLimit
}
newOpts.Marker = ""
return &newOpts
} | go | {
"resource": ""
} |
q6211 | ContainersAll | train | func (c *Connection) ContainersAll(opts *ContainersOpts) ([]Container, error) {
opts = containersAllOpts(opts)
containers := make([]Container, 0)
for {
newContainers, err := c.Containers(opts)
if err != nil {
return nil, err
}
containers = append(containers, newContainers...)
if len(newContainers) < opts.Limit {
break
}
opts.Marker = newContainers[len(newContainers)-1].Name
}
return containers, nil
} | go | {
"resource": ""
} |
q6212 | ContainerNamesAll | train | func (c *Connection) ContainerNamesAll(opts *ContainersOpts) ([]string, error) {
opts = containersAllOpts(opts)
containers := make([]string, 0)
for {
newContainers, err := c.ContainerNames(opts)
if err != nil {
return nil, err
}
containers = append(containers, newContainers...)
if len(newContainers) < opts.Limit {
break
}
opts.Marker = newContainers[len(newContainers)-1]
}
return containers, nil
} | go | {
"resource": ""
} |
q6213 | parse | train | func (opts *ObjectsOpts) parse() (url.Values, Headers) {
v := url.Values{}
var h Headers
if opts != nil {
if opts.Limit > 0 {
v.Set("limit", strconv.Itoa(opts.Limit))
}
if opts.Marker != "" {
v.Set("marker", opts.Marker)
}
if opts.EndMarker != "" {
v.Set("end_marker", opts.EndMarker)
}
if opts.Prefix != "" {
v.Set("prefix", opts.Prefix)
}
if opts.Path != "" {
v.Set("path", opts.Path)
}
if opts.Delimiter != 0 {
v.Set("delimiter", string(opts.Delimiter))
}
h = opts.Headers
}
return v, h
} | go | {
"resource": ""
} |
q6214 | ObjectNames | train | func (c *Connection) ObjectNames(container string, opts *ObjectsOpts) ([]string, error) {
v, h := opts.parse()
resp, _, err := c.storage(RequestOpts{
Container: container,
Operation: "GET",
Parameters: v,
ErrorMap: ContainerErrorMap,
Headers: h,
})
if err != nil {
return nil, err
}
return readLines(resp)
} | go | {
"resource": ""
} |
q6215 | objectsAllOpts | train | func objectsAllOpts(opts *ObjectsOpts, Limit int) *ObjectsOpts {
var newOpts ObjectsOpts
if opts != nil {
newOpts = *opts
}
if newOpts.Limit == 0 {
newOpts.Limit = Limit
}
if !newOpts.KeepMarker {
newOpts.Marker = ""
}
return &newOpts
} | go | {
"resource": ""
} |
q6216 | ObjectsAll | train | func (c *Connection) ObjectsAll(container string, opts *ObjectsOpts) ([]Object, error) {
objects := make([]Object, 0)
err := c.ObjectsWalk(container, opts, func(opts *ObjectsOpts) (interface{}, error) {
newObjects, err := c.Objects(container, opts)
if err == nil {
objects = append(objects, newObjects...)
}
return newObjects, err
})
return objects, err
} | go | {
"resource": ""
} |
q6217 | ObjectNamesAll | train | func (c *Connection) ObjectNamesAll(container string, opts *ObjectsOpts) ([]string, error) {
objects := make([]string, 0)
err := c.ObjectsWalk(container, opts, func(opts *ObjectsOpts) (interface{}, error) {
newObjects, err := c.ObjectNames(container, opts)
if err == nil {
objects = append(objects, newObjects...)
}
return newObjects, err
})
return objects, err
} | go | {
"resource": ""
} |
q6218 | getInt64FromHeader | train | func getInt64FromHeader(resp *http.Response, header string) (result int64, err error) {
value := resp.Header.Get(header)
result, err = strconv.ParseInt(value, 10, 64)
if err != nil {
err = newErrorf(0, "Bad Header '%s': '%s': %s", header, value, err)
}
return
} | go | {
"resource": ""
} |
q6219 | Account | train | func (c *Connection) Account() (info Account, headers Headers, err error) {
var resp *http.Response
resp, headers, err = c.storage(RequestOpts{
Operation: "HEAD",
ErrorMap: ContainerErrorMap,
NoResponse: true,
})
if err != nil {
return
}
// Parse the headers into a dict
//
// {'Accept-Ranges': 'bytes',
// 'Content-Length': '0',
// 'Date': 'Tue, 05 Jul 2011 16:37:06 GMT',
// 'X-Account-Bytes-Used': '316598182',
// 'X-Account-Container-Count': '4',
// '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"); err != nil {
return
}
return
} | go | {
"resource": ""
} |
q6220 | AccountUpdate | train | func (c *Connection) AccountUpdate(h Headers) error {
_, _, err := c.storage(RequestOpts{
Operation: "POST",
ErrorMap: ContainerErrorMap,
NoResponse: true,
Headers: h,
})
return err
} | go | {
"resource": ""
} |
q6221 | ContainerCreate | train | func (c *Connection) ContainerCreate(container string, h Headers) error {
_, _, err := c.storage(RequestOpts{
Container: container,
Operation: "PUT",
ErrorMap: ContainerErrorMap,
NoResponse: true,
Headers: h,
})
return err
} | go | {
"resource": ""
} |
q6222 | ContainerDelete | train | func (c *Connection) ContainerDelete(container string) error {
_, _, err := c.storage(RequestOpts{
Container: container,
Operation: "DELETE",
ErrorMap: ContainerErrorMap,
NoResponse: true,
})
return err
} | go | {
"resource": ""
} |
q6223 | Container | train | func (c *Connection) Container(container string) (info Container, headers Headers, err error) {
var resp *http.Response
resp, headers, err = c.storage(RequestOpts{
Container: container,
Operation: "HEAD",
ErrorMap: ContainerErrorMap,
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
} | go | {
"resource": ""
} |
q6224 | Write | train | func (file *ObjectCreateFile) Write(p []byte) (n int, err error) {
n, err = file.pipeWriter.Write(p)
if err == io.ErrClosedPipe {
if file.err != nil {
return 0, file.err
}
return 0, newError(500, "Write on closed file")
}
if err == nil && file.checkHash {
_, _ = file.hash.Write(p)
}
return
} | go | {
"resource": ""
} |
q6225 | objectPutHeaders | train | func objectPutHeaders(objectName string, checkHash *bool, Hash string, contentType string, h Headers) Headers {
if contentType == "" {
contentType = mime.TypeByExtension(path.Ext(objectName))
if contentType == "" {
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
} | go | {
"resource": ""
} |
q6226 | ObjectPutString | train | func (c *Connection) ObjectPutString(container string, objectName string, contents string, contentType string) (err error) {
buf := strings.NewReader(contents)
h := Headers{"Content-Length": strconv.Itoa(len(contents))}
_, err = c.ObjectPut(container, objectName, buf, true, "", contentType, h)
return
} | go | {
"resource": ""
} |
q6227 | Read | train | func (file *ObjectOpenFile) Read(p []byte) (n int, err error) {
if file.overSeeked {
return 0, io.EOF
}
n, err = file.body.Read(p)
file.bytes += int64(n)
file.pos += int64(n)
if err == io.EOF {
file.eof = true
}
return
} | go | {
"resource": ""
} |
q6228 | Length | train | func (file *ObjectOpenFile) Length() (int64, error) {
if !file.lengthOk {
info, _, err := file.connection.Object(file.container, file.objectName)
file.length = info.Bytes
file.lengthOk = (err == nil)
return file.length, err
}
return file.length, nil
} | go | {
"resource": ""
} |
q6229 | Close | train | func (file *ObjectOpenFile) Close() (err error) {
// Close the body at the end
defer checkClose(file.resp.Body, &err)
// If not end of file or seeked then can't check anything
if !file.eof || file.seeked {
return
}
// Check the MD5 sum if requested
if file.checkHash {
receivedMd5 := strings.ToLower(file.resp.Header.Get("Etag"))
calculatedMd5 := fmt.Sprintf("%x", file.hash.Sum(nil))
if 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
} | go | {
"resource": ""
} |
q6230 | ObjectGetString | train | func (c *Connection) ObjectGetString(container string, objectName string) (contents string, err error) {
var buf bytes.Buffer
_, err = c.ObjectGet(container, objectName, &buf, true, nil)
contents = buf.String()
return
} | go | {
"resource": ""
} |
q6231 | ObjectDelete | train | func (c *Connection) ObjectDelete(container string, objectName string) error {
_, _, err := c.storage(RequestOpts{
Container: container,
ObjectName: objectName,
Operation: "DELETE",
ErrorMap: objectErrorMap,
})
return err
} | go | {
"resource": ""
} |
q6232 | ObjectTempUrl | train | func (c *Connection) ObjectTempUrl(container string, objectName string, secretKey string, method string, expires time.Time) string {
mac := hmac.New(sha1.New, []byte(secretKey))
prefix, _ := url.Parse(c.StorageUrl)
body := fmt.Sprintf("%s\n%d\n%s/%s/%s", method, expires.Unix(), prefix.Path, container, objectName)
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())
} | go | {
"resource": ""
} |
q6233 | parseResponseStatus | train | func parseResponseStatus(resp string, errorMap errorMap) error {
code := 0
reason := resp
t := strings.SplitN(resp, " ", 2)
if len(t) == 2 {
ncode, err := strconv.Atoi(t[0])
if err == nil {
code = ncode
reason = t[1]
}
}
if errorMap != nil {
if err, ok := errorMap[code]; ok {
return err
}
}
if 200 <= code && code <= 299 {
return nil
}
return newError(code, reason)
} | go | {
"resource": ""
} |
q6234 | urlPathEscape | train | func urlPathEscape(in string) string {
var u url.URL
u.Path = in
return u.String()
} | go | {
"resource": ""
} |
q6235 | ObjectCopy | train | func (c *Connection) ObjectCopy(srcContainer string, srcObjectName string, dstContainer string, dstObjectName string, h Headers) (headers Headers, err error) {
// Meta stuff
extraHeaders := map[string]string{
"Destination": urlPathEscape(dstContainer + "/" + dstObjectName),
}
for key, value := range h {
extraHeaders[key] = value
}
_, headers, err = c.storage(RequestOpts{
Container: srcContainer,
ObjectName: srcObjectName,
Operation: "COPY",
ErrorMap: objectErrorMap,
NoResponse: true,
Headers: extraHeaders,
})
return
} | go | {
"resource": ""
} |
q6236 | ObjectMove | train | func (c *Connection) ObjectMove(srcContainer string, srcObjectName string, dstContainer string, dstObjectName string) (err error) {
_, err = c.ObjectCopy(srcContainer, srcObjectName, dstContainer, dstObjectName, nil)
if err != nil {
return
}
return c.ObjectDelete(srcContainer, srcObjectName)
} | go | {
"resource": ""
} |
q6237 | ObjectUpdateContentType | train | func (c *Connection) ObjectUpdateContentType(container string, objectName string, contentType string) (err error) {
h := Headers{"Content-Type": contentType}
_, err = c.ObjectCopy(container, objectName, container, objectName, h)
return
} | go | {
"resource": ""
} |
q6238 | VersionEnable | train | func (c *Connection) VersionEnable(current, version string) error {
h := Headers{"X-Versions-Location": version}
if err := c.ContainerUpdate(current, h); err != nil {
return err
}
// Check to see 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
} | go | {
"resource": ""
} |
q6239 | VersionDisable | train | func (c *Connection) VersionDisable(current string) error {
h := Headers{"X-Versions-Location": ""}
if err := c.ContainerUpdate(current, h); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q6240 | resetTimer | train | func resetTimer(t *time.Timer, d time.Duration) {
t.Stop()
// Very likely this doesn't actually work if we are 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)
} | go | {
"resource": ""
} |
q6241 | StringWidth | train | func (c *Condition) StringWidth(s string) (width int) {
if c.ZeroWidthJoiner {
return c.stringWidthZeroJoiner(s)
}
return c.stringWidth(s)
} | go | {
"resource": ""
} |
q6242 | FillRight | train | func FillRight(s string, w int) string {
return DefaultCondition.FillRight(s, w)
} | go | {
"resource": ""
} |
q6243 | computeRootHash | train | func (pwl pathWithLeaf) computeRootHash() []byte {
leafHash := pwl.Leaf.Hash()
return pwl.Path.computeRootHash(leafHash)
} | go | {
"resource": ""
} |
q6244 | computeRootHash | train | func (pl PathToLeaf) computeRootHash(leafHash []byte) []byte {
hash := leafHash
for i := len(pl) - 1; i >= 0; i-- {
pin := pl[i]
hash = pin.Hash(hash)
}
return hash
} | go | {
"resource": ""
} |
q6245 | Index | train | func (pl PathToLeaf) Index() (idx int64) {
for i, node := range pl {
if node.Left == nil {
continue
} else if node.Right == nil {
if i < len(pl)-1 {
idx += node.Size - pl[i+1].Size
} else {
idx += node.Size - 1
}
} else {
return -1
}
}
return idx
} | go | {
"resource": ""
} |
q6246 | PrintTree | train | func PrintTree(tree *ImmutableTree) {
ndb, root := tree.ndb, tree.root
printNode(ndb, root, 0)
} | go | {
"resource": ""
} |
q6247 | NewNode | train | func NewNode(key []byte, value []byte, version int64) *Node {
return &Node{
key: key,
value: value,
height: 0,
size: 1,
version: version,
}
} | go | {
"resource": ""
} |
q6248 | String | train | func (node *Node) String() string {
hashstr := "<no hash>"
if len(node.hash) > 0 {
hashstr = fmt.Sprintf("%X", node.hash)
}
return fmt.Sprintf("Node{%s:%s@%d %X;%X}#%s",
cmn.ColoredBytes(node.key, cmn.Green, cmn.Blue),
cmn.ColoredBytes(node.value, cmn.Cyan, cmn.Blue),
node.version,
node.leftHash, node.rightHash,
hashstr)
} | go | {
"resource": ""
} |
q6249 | clone | train | func (node *Node) clone(version int64) *Node {
if node.isLeaf() {
panic("Attempt to copy a leaf node")
}
return &Node{
key: node.key,
height: node.height,
version: version,
size: node.size,
hash: nil,
leftHash: node.leftHash,
leftNode: node.leftNode,
rightHash: node.rightHash,
rightNode: node.rightNode,
persisted: false,
}
} | go | {
"resource": ""
} |
q6250 | has | train | func (node *Node) has(t *ImmutableTree, key []byte) (has bool) {
if bytes.Equal(node.key, key) {
return true
}
if node.isLeaf() {
return false
}
if bytes.Compare(key, node.key) < 0 {
return node.getLeftNode(t).has(t, key)
}
return node.getRightNode(t).has(t, key)
} | go | {
"resource": ""
} |
q6251 | get | train | func (node *Node) get(t *ImmutableTree, key []byte) (index int64, value []byte) {
if node.isLeaf() {
switch bytes.Compare(node.key, key) {
case -1:
return 1, nil
case 1:
return 0, nil
default:
return 0, node.value
}
}
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
} | go | {
"resource": ""
} |
q6252 | _hash | train | func (node *Node) _hash() []byte {
if node.hash != nil {
return node.hash
}
h := tmhash.New()
buf := new(bytes.Buffer)
if err := node.writeHashBytes(buf); err != nil {
panic(err)
}
h.Write(buf.Bytes())
node.hash = h.Sum(nil)
return node.hash
} | go | {
"resource": ""
} |
q6253 | hashWithCount | train | func (node *Node) hashWithCount() ([]byte, int64) {
if node.hash != nil {
return node.hash, 0
}
h := tmhash.New()
buf := new(bytes.Buffer)
hashCount, err := node.writeHashBytesRecursively(buf)
if err != nil {
panic(err)
}
h.Write(buf.Bytes())
node.hash = h.Sum(nil)
return node.hash, hashCount + 1
} | go | {
"resource": ""
} |
q6254 | writeHashBytes | train | func (node *Node) writeHashBytes(w io.Writer) cmn.Error {
err := amino.EncodeInt8(w, node.height)
if err != nil {
return cmn.ErrorWrap(err, "writing height")
}
err = amino.EncodeVarint(w, node.size)
if err != nil {
return cmn.ErrorWrap(err, "writing size")
}
err = amino.EncodeVarint(w, node.version)
if err != nil {
return cmn.ErrorWrap(err, "writing version")
}
// Key is not written for inner nodes, unlike writeBytes.
if node.isLeaf() {
err = amino.EncodeByteSlice(w, node.key)
if 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 node.leftHash == nil || node.rightHash == nil {
panic("Found an empty child hash")
}
err = amino.EncodeByteSlice(w, node.leftHash)
if err != nil {
return cmn.ErrorWrap(err, "writing left hash")
}
err = amino.EncodeByteSlice(w, node.rightHash)
if err != nil {
return cmn.ErrorWrap(err, "writing right hash")
}
}
return nil
} | go | {
"resource": ""
} |
q6255 | writeHashBytesRecursively | train | func (node *Node) writeHashBytesRecursively(w io.Writer) (hashCount int64, err cmn.Error) {
if node.leftNode != nil {
leftHash, leftCount := node.leftNode.hashWithCount()
node.leftHash = leftHash
hashCount += leftCount
}
if node.rightNode != nil {
rightHash, rightCount := node.rightNode.hashWithCount()
node.rightHash = rightHash
hashCount += rightCount
}
err = node.writeHashBytes(w)
return
} | go | {
"resource": ""
} |
q6256 | writeBytes | train | func (node *Node) writeBytes(w io.Writer) cmn.Error {
var cause error
cause = amino.EncodeInt8(w, node.height)
if cause != nil {
return cmn.ErrorWrap(cause, "writing height")
}
cause = amino.EncodeVarint(w, node.size)
if cause != nil {
return cmn.ErrorWrap(cause, "writing size")
}
cause = amino.EncodeVarint(w, node.version)
if cause != nil {
return cmn.ErrorWrap(cause, "writing version")
}
// Unlike writeHashBytes, key is written for inner nodes.
cause = amino.EncodeByteSlice(w, 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 = amino.EncodeByteSlice(w, node.leftHash)
if cause != nil {
return cmn.ErrorWrap(cause, "writing left hash")
}
if node.rightHash == nil {
panic("node.rightHash was nil in writeBytes")
}
cause = amino.EncodeByteSlice(w, node.rightHash)
if cause != nil {
return cmn.ErrorWrap(cause, "writing right hash")
}
}
return nil
} | go | {
"resource": ""
} |
q6257 | traverse | train | func (node *Node) traverse(t *ImmutableTree, ascending bool, cb func(*Node) bool) bool {
return node.traverseInRange(t, nil, nil, ascending, false, 0, func(node *Node, depth uint8) bool {
return cb(node)
})
} | go | {
"resource": ""
} |
q6258 | lmd | train | func (node *Node) lmd(t *ImmutableTree) *Node {
if node.isLeaf() {
return node
}
return node.getLeftNode(t).lmd(t)
} | go | {
"resource": ""
} |
q6259 | pathToLeaf | train | func (node *Node) pathToLeaf(t *ImmutableTree, key []byte, path *PathToLeaf) (*Node, error) {
if node.height == 0 {
if bytes.Equal(node.key, key) {
return node, nil
}
return node, cmn.NewError("key does not exist")
}
if bytes.Compare(key, node.key) < 0 {
// left side
pin := proofInnerNode{
Height: node.height,
Size: node.size,
Version: node.version,
Left: nil,
Right: node.getRightNode(t).hash,
}
*path = append(*path, 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, key, path)
return n, err
} | go | {
"resource": ""
} |
q6260 | Verify | train | func (proof *RangeProof) Verify(root []byte) error {
if proof == nil {
return cmn.ErrorWrap(ErrInvalidProof, "proof is nil")
}
err := proof.verify(root)
return err
} | go | {
"resource": ""
} |
q6261 | ComputeRootHash | train | func (proof *RangeProof) ComputeRootHash() []byte {
if proof == nil {
return nil
}
rootHash, _ := proof.computeRootHash()
return rootHash
} | go | {
"resource": ""
} |
q6262 | GetVersionedWithProof | train | func (tree *MutableTree) GetVersionedWithProof(key []byte, version int64) ([]byte, *RangeProof, error) {
if tree.versions[version] {
t, err := tree.GetImmutable(version)
if err != nil {
return nil, nil, err
}
return t.GetWithProof(key)
}
return nil, nil, cmn.ErrorWrap(ErrVersionDoesNotExist, "")
} | go | {
"resource": ""
} |
q6263 | NewImmutableTree | train | func NewImmutableTree(db dbm.DB, cacheSize int) *ImmutableTree {
if db == nil {
// In-memory Tree.
return &ImmutableTree{}
}
return &ImmutableTree{
// NodeDB-backed Tree.
ndb: newNodeDB(db, cacheSize),
}
} | go | {
"resource": ""
} |
q6264 | String | train | func (t *ImmutableTree) String() string {
leaves := []string{}
t.Iterate(func(key []byte, val []byte) (stop bool) {
leaves = append(leaves, fmt.Sprintf("%x: %x", key, val))
return false
})
return "Tree{" + strings.Join(leaves, ", ") + "}"
} | go | {
"resource": ""
} |
q6265 | Size | train | func (t *ImmutableTree) Size() int64 {
if t.root == nil {
return 0
}
return t.root.size
} | go | {
"resource": ""
} |
q6266 | Height | train | func (t *ImmutableTree) Height() int8 {
if t.root == nil {
return 0
}
return t.root.height
} | go | {
"resource": ""
} |
q6267 | Has | train | func (t *ImmutableTree) Has(key []byte) bool {
if t.root == nil {
return false
}
return t.root.has(t, key)
} | go | {
"resource": ""
} |
q6268 | Hash | train | func (t *ImmutableTree) Hash() []byte {
if t.root == nil {
return nil
}
hash, _ := t.root.hashWithCount()
return hash
} | go | {
"resource": ""
} |
q6269 | hashWithCount | train | func (t *ImmutableTree) hashWithCount() ([]byte, int64) {
if t.root == nil {
return nil, 0
}
return t.root.hashWithCount()
} | go | {
"resource": ""
} |
q6270 | Get | train | func (t *ImmutableTree) Get(key []byte) (index int64, value []byte) {
if t.root == nil {
return 0, nil
}
return t.root.get(t, key)
} | go | {
"resource": ""
} |
q6271 | GetByIndex | train | func (t *ImmutableTree) GetByIndex(index int64) (key []byte, value []byte) {
if t.root == nil {
return nil, nil
}
return t.root.getByIndex(t, index)
} | go | {
"resource": ""
} |
q6272 | Iterate | train | func (t *ImmutableTree) Iterate(fn func(key []byte, value []byte) bool) (stopped bool) {
if t.root == nil {
return false
}
return t.root.traverse(t, true, func(node *Node) bool {
if node.height == 0 {
return fn(node.key, node.value)
}
return false
})
} | go | {
"resource": ""
} |
q6273 | clone | train | func (t *ImmutableTree) clone() *ImmutableTree {
return &ImmutableTree{
root: t.root,
ndb: t.ndb,
version: t.version,
}
} | go | {
"resource": ""
} |
q6274 | nodeSize | train | func (t *ImmutableTree) nodeSize() int {
size := 0
t.root.traverse(t, true, func(n *Node) bool {
size++
return false
})
return size
} | go | {
"resource": ""
} |
q6275 | NewMutableTree | train | func NewMutableTree(db dbm.DB, cacheSize int) *MutableTree {
ndb := newNodeDB(db, cacheSize)
head := &ImmutableTree{ndb: ndb}
return &MutableTree{
ImmutableTree: head,
lastSaved: head.clone(),
orphans: map[string]int64{},
versions: map[int64]bool{},
ndb: ndb,
}
} | go | {
"resource": ""
} |
q6276 | Hash | train | func (tree *MutableTree) Hash() []byte {
if tree.version > 0 {
return tree.lastSaved.Hash()
}
return nil
} | go | {
"resource": ""
} |
q6277 | Set | train | func (tree *MutableTree) Set(key, value []byte) bool {
orphaned, updated := tree.set(key, value)
tree.addOrphans(orphaned)
return updated
} | go | {
"resource": ""
} |
q6278 | Remove | train | func (tree *MutableTree) Remove(key []byte) ([]byte, bool) {
val, orphaned, removed := tree.remove(key)
tree.addOrphans(orphaned)
return val, removed
} | go | {
"resource": ""
} |
q6279 | remove | train | func (tree *MutableTree) remove(key []byte) (value []byte, orphans []*Node, removed bool) {
if tree.root == nil {
return nil, nil, false
}
newRootHash, newRoot, _, value, orphaned := tree.recursiveRemove(tree.root, key)
if len(orphaned) == 0 {
return nil, nil, false
}
if newRoot == nil && newRootHash != nil {
tree.root = tree.ndb.GetNode(newRootHash)
} else {
tree.root = newRoot
}
return value, orphaned, true
} | go | {
"resource": ""
} |
q6280 | LoadVersion | train | func (tree *MutableTree) LoadVersion(targetVersion int64) (int64, error) {
roots, err := tree.ndb.getRoots()
if err != nil {
return 0, err
}
if len(roots) == 0 {
return 0, nil
}
latestVersion := int64(0)
var latestRoot []byte
for version, r := range roots {
tree.versions[version] = true
if version > latestVersion &&
(targetVersion == 0 || version <= targetVersion) {
latestVersion = version
latestRoot = r
}
}
if !(targetVersion == 0 || latestVersion == targetVersion) {
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 = t
tree.lastSaved = t.clone()
return latestVersion, nil
} | go | {
"resource": ""
} |
q6281 | LoadVersionForOverwriting | train | func (tree *MutableTree) LoadVersionForOverwriting(targetVersion int64) (int64, error) {
latestVersion, err := tree.LoadVersion(targetVersion)
if err != nil {
return latestVersion, err
}
tree.deleteVersionsFrom(targetVersion+1)
return targetVersion, nil
} | go | {
"resource": ""
} |
q6282 | GetImmutable | train | func (tree *MutableTree) GetImmutable(version int64) (*ImmutableTree, error) {
rootHash := tree.ndb.getRoot(version)
if rootHash == nil {
return nil, ErrVersionDoesNotExist
} else if len(rootHash) == 0 {
return &ImmutableTree{
ndb: tree.ndb,
version: version,
}, nil
}
return &ImmutableTree{
root: tree.ndb.GetNode(rootHash),
ndb: tree.ndb,
version: version,
}, nil
} | go | {
"resource": ""
} |
q6283 | Rollback | train | func (tree *MutableTree) Rollback() {
if tree.version > 0 {
tree.ImmutableTree = tree.lastSaved.clone()
} else {
tree.ImmutableTree = &ImmutableTree{ndb: tree.ndb, version: 0}
}
tree.orphans = map[string]int64{}
} | go | {
"resource": ""
} |
q6284 | GetVersioned | train | func (tree *MutableTree) GetVersioned(key []byte, version int64) (
index int64, value []byte,
) {
if tree.versions[version] {
t, err := tree.GetImmutable(version)
if err != nil {
return -1, nil
}
return t.Get(key)
}
return -1, nil
} | go | {
"resource": ""
} |
q6285 | SaveVersion | train | func (tree *MutableTree) SaveVersion() ([]byte, int64, error) {
version := tree.version + 1
if tree.versions[version] {
//version already exists, throw an error if attempting to overwrite
// Same hash means idempotent. Return success.
existingHash := tree.ndb.getRoot(version)
var newHash = tree.WorkingHash()
if bytes.Equal(existingHash, newHash) {
tree.version = version
tree.ImmutableTree = tree.ImmutableTree.clone()
tree.lastSaved = tree.ImmutableTree.clone()
tree.orphans = map[string]int64{}
return existingHash, version, nil
}
return nil, version, fmt.Errorf("version %d was already saved to different hash %X (existing hash %X)",
version, newHash, existingHash)
}
if tree.root == nil {
// There can still be orphans, for example if the root is the node being
// removed.
debug("SAVE EMPTY TREE %v\n", version)
tree.ndb.SaveOrphans(version, tree.orphans)
tree.ndb.SaveEmptyRoot(version)
} else {
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.ImmutableTree.clone()
tree.lastSaved = tree.ImmutableTree.clone()
tree.orphans = map[string]int64{}
return tree.Hash(), version, nil
} | go | {
"resource": ""
} |
q6286 | DeleteVersion | train | func (tree *MutableTree) DeleteVersion(version int64) error {
if version == 0 {
return cmn.NewError("version must be greater than 0")
}
if version == tree.version {
return cmn.NewError("cannot delete latest saved version (%d)", version)
}
if _, ok := tree.versions[version]; !ok {
return cmn.ErrorWrap(ErrVersionDoesNotExist, "")
}
tree.ndb.DeleteVersion(version, true)
tree.ndb.Commit()
delete(tree.versions, version)
return nil
} | go | {
"resource": ""
} |
q6287 | deleteVersionsFrom | train | func (tree *MutableTree) deleteVersionsFrom(version int64) error {
if version <= 0 {
return cmn.NewError("version must be greater than 0")
}
newLatestVersion := version - 1
lastestVersion := tree.ndb.getLatestVersion()
for ; version <= lastestVersion; version++ {
if version == tree.version {
return cmn.NewError("cannot delete latest saved version (%d)", version)
}
if _, ok := tree.versions[version]; !ok {
return cmn.ErrorWrap(ErrVersionDoesNotExist, "")
}
tree.ndb.DeleteVersion(version, false)
delete(tree.versions, version)
}
tree.ndb.Commit()
tree.ndb.resetLatestVersion(newLatestVersion)
return nil
} | go | {
"resource": ""
} |
q6288 | rotateRight | train | func (tree *MutableTree) rotateRight(node *Node) (*Node, *Node) {
version := tree.version + 1
// TODO: optimize balance & rotate.
node = node.clone(version)
orphaned := node.getLeftNode(tree.ImmutableTree)
newNode := orphaned.clone(version)
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
} | go | {
"resource": ""
} |
q6289 | rotateLeft | train | func (tree *MutableTree) rotateLeft(node *Node) (*Node, *Node) {
version := tree.version + 1
// TODO: optimize balance & rotate.
node = node.clone(version)
orphaned := node.getRightNode(tree.ImmutableTree)
newNode := orphaned.clone(version)
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
} | go | {
"resource": ""
} |
q6290 | GetNode | train | func (ndb *nodeDB) GetNode(hash []byte) *Node {
ndb.mtx.Lock()
defer ndb.mtx.Unlock()
if len(hash) == 0 {
panic("nodeDB.GetNode() requires hash")
}
// Check the cache.
if elem, ok := ndb.nodeCache[string(hash)]; ok {
// Already exists. Move to back of nodeCacheQueue.
ndb.nodeCacheQueue.MoveToBack(elem)
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: %v", buf, err))
}
node.hash = hash
node.persisted = true
ndb.cacheNode(node)
return node
} | go | {
"resource": ""
} |
q6291 | SaveNode | train | func (ndb *nodeDB) SaveNode(node *Node) {
ndb.mtx.Lock()
defer ndb.mtx.Unlock()
if node.hash == nil {
panic("Expected to find node.hash, but none found.")
}
if node.persisted {
panic("Shouldn't be calling save 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)
} | go | {
"resource": ""
} |
q6292 | Has | train | func (ndb *nodeDB) Has(hash []byte) bool {
key := ndb.nodeKey(hash)
if ldb, ok := ndb.db.(*dbm.GoLevelDB); ok {
exists, err := ldb.DB().Has(key, nil)
if err != nil {
panic("Got error from leveldb: " + err.Error())
}
return exists
}
return ndb.db.Get(key) != nil
} | go | {
"resource": ""
} |
q6293 | DeleteVersion | train | func (ndb *nodeDB) DeleteVersion(version int64, checkLatestVersion bool) {
ndb.mtx.Lock()
defer ndb.mtx.Unlock()
ndb.deleteOrphans(version)
ndb.deleteRoot(version, checkLatestVersion)
} | go | {
"resource": ""
} |
q6294 | saveOrphan | train | func (ndb *nodeDB) saveOrphan(hash []byte, fromVersion, toVersion int64) {
if fromVersion > toVersion {
panic(fmt.Sprintf("Orphan expires before it comes alive. %d > %d", fromVersion, toVersion))
}
key := ndb.orphanKey(fromVersion, toVersion, hash)
ndb.batch.Set(key, hash)
} | go | {
"resource": ""
} |
q6295 | deleteOrphans | train | func (ndb *nodeDB) deleteOrphans(version int64) {
// Will be zero if there is no previous version.
predecessor := ndb.getPreviousVersion(version)
// Traverse orphans with a lifetime ending at the version specified.
// TODO optimize.
ndb.traverseOrphansVersion(version, func(key, hash []byte) {
var fromVersion, toVersion int64
// See comment on `orphanKeyFmt`. Note that here, `version` and
// `toVersion` are always equal.
orphanKeyFormat.Scan(key, &toVersion, &fromVersion)
// Delete orphan key and reverse-lookup key.
ndb.batch.Delete(key)
// If there is no predecessor, or the predecessor is earlier than the
// beginning of the lifetime (ie: negative lifetime), or the lifetime
// spans a single version and that version is the one being deleted, we
// can delete the orphan. Otherwise, we shorten its lifetime, by
// moving its endpoint to the previous version.
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", predecessor, fromVersion, toVersion, hash)
ndb.saveOrphan(hash, fromVersion, predecessor)
}
})
} | go | {
"resource": ""
} |
q6296 | deleteRoot | train | func (ndb *nodeDB) deleteRoot(version int64, checkLatestVersion bool) {
if checkLatestVersion && version == ndb.getLatestVersion() {
panic("Tried to delete latest version")
}
key := ndb.rootKey(version)
ndb.batch.Delete(key)
} | go | {
"resource": ""
} |
q6297 | traverseOrphansVersion | train | func (ndb *nodeDB) traverseOrphansVersion(version int64, fn func(k, v []byte)) {
ndb.traversePrefix(orphanKeyFormat.Key(version), fn)
} | go | {
"resource": ""
} |
q6298 | traverse | train | func (ndb *nodeDB) traverse(fn func(key, value []byte)) {
itr := ndb.db.Iterator(nil, nil)
defer itr.Close()
for ; itr.Valid(); itr.Next() {
fn(itr.Key(), itr.Value())
}
} | go | {
"resource": ""
} |
q6299 | traversePrefix | train | func (ndb *nodeDB) traversePrefix(prefix []byte, fn func(k, v []byte)) {
itr := dbm.IteratePrefix(ndb.db, prefix)
defer itr.Close()
for ; itr.Valid(); itr.Next() {
fn(itr.Key(), itr.Value())
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.