func putChanCommitTxns(nodeChanBucket *bolt.Bucket, channel *OpenChannel) error {
var bc bytes.Buffer
if err := writeOutpoint(&bc, channel.ChanID); err != nil {
return err
}
txnsKey := make([]byte, len(commitTxnsKey)+bc.Len())
copy(txnsKey[:3], commitTxnsKey)
copy(txnsKey[3:], bc.Bytes())
var b bytes.Buffer
if err := channel.OurCommitTx.Serialize(&b); err != nil {
return err
}
if err := wire.WriteVarBytes(&b, 0, channel.OurCommitSig); err != nil {
return err
}
// TODO(roasbeef): should move this into putChanFundingInfo
scratch := make([]byte, 4)
byteOrder.PutUint32(scratch, channel.LocalCsvDelay)
if _, err := b.Write(scratch); err != nil {
return err
}
byteOrder.PutUint32(scratch, channel.RemoteCsvDelay)
if _, err := b.Write(scratch); err != nil {
return err
}
return nodeChanBucket.Put(txnsKey, b.Bytes())
}
func getGrantScopes(bucket *bolt.Bucket, grant string) map[string]bool {
scopesByte := bucket.Get([]byte(grant))
if scopesByte == nil {
return nil
}
return database.StringToSet(string(scopesByte))
}
// Params returns the currently stored configuration parameters for hook h
// from bucket b.
func (GithubValidator) Params(h Hook, b *bolt.Bucket) map[string]string {
m := make(map[string]string)
for _, k := range []string{"secret"} {
m[k] = string(b.Get([]byte(fmt.Sprintf("%s-%s", h.ID, k))))
}
return m
}
func addCityToIndex(
bucket *bolt.Bucket, id string, name string, locale string, population uint32,
) error {
var err error
var cityName *ds.CityName
if locale == "" {
locale = "en"
}
cityNameKey := []byte(ds.PrepareCityNameKey(name))
if conflict := bucket.Get(cityNameKey); conflict != nil {
cityName, err = ds.CityNameFromString(string(cityNameKey), string(conflict))
if strconv.Itoa(cityName.CityId) != id {
cityNameKey = []byte(string(cityNameKey) + "|" + id)
}
}
err = bucket.Put(
cityNameKey, []byte(
name+"\t"+id+"\t"+locale+"\t"+strconv.Itoa(int(population)),
),
)
return err
}
func fillBucket(b *bolt.Bucket, prefix []byte) error {
n := 10 + rand.Intn(50)
for i := 0; i < n; i++ {
v := make([]byte, 10*(1+rand.Intn(4)))
_, err := crypto.Read(v)
if err != nil {
return err
}
k := append(prefix, []byte(fmt.Sprintf("k%d", i))...)
if err := b.Put(k, v); err != nil {
return err
}
}
// limit depth of subbuckets
s := 2 + rand.Intn(4)
if len(prefix) > (2*s + 1) {
return nil
}
n = 1 + rand.Intn(3)
for i := 0; i < n; i++ {
k := append(prefix, []byte(fmt.Sprintf("b%d", i))...)
sb, err := b.CreateBucket(k)
if err != nil {
return err
}
if err := fillBucket(sb, append(k, '.')); err != nil {
return err
}
}
return nil
}
// Params returns the currently stored configuration parameters for hook h
// from bucket b.
func (ForwardRequestAction) Params(h Hook, b *bolt.Bucket) map[string]string {
m := make(map[string]string)
for _, k := range []string{"url"} {
m[k] = string(b.Get([]byte(fmt.Sprintf("%s-%s", h.ID, k))))
}
return m
}
func PutTokenInfo(tokenInfo *TokenInfo) error {
oldTokenInfo, err := GetTokenInfo(tokenInfo.Token, tokenInfo.Client)
if err != nil {
return err
}
if oldTokenInfo != nil {
return errors.New("duplicate token")
}
err = db.Update(func(tx *bolt.Tx) error {
var clientBucket *bolt.Bucket
clientBucket = tx.Bucket([]byte(tokenInfo.Client))
if clientBucket == nil {
clientBucket, err = tx.CreateBucket([]byte(tokenInfo.Client))
if err != nil {
return err
}
}
tokenBucket, err := clientBucket.CreateBucket([]byte(tokenInfo.Token))
if err != nil {
return err
}
tokenBucket.Put([]byte("token"), []byte(tokenInfo.Token))
tokenBucket.Put([]byte("client"), []byte(tokenInfo.Client))
tokenBucket.Put([]byte("user"), []byte(tokenInfo.User))
tokenBucket.Put([]byte("scopes"), []byte(tokenInfo.Scopes))
expireBinary, err := tokenInfo.ExpireTime.MarshalBinary()
if err != nil {
return err
}
tokenBucket.Put([]byte("expire-time"), expireBinary)
return nil
})
return err
}
func (store *BoltStore) Get(uri string, nested bool) (interface{}, error) {
namespace, key := util.NamespaceKey(uri)
bucketkeys := util.PathFolders(namespace)
var bucket *bolt.Bucket = nil
var result interface{}
e := store.db.View(func(tx *bolt.Tx) error {
for _, bucketkey := range bucketkeys {
if bucket == nil {
bucket = tx.Bucket([]byte(bucketkey))
if bucket == nil {
return errors.New(uri + " not exists")
}
} else {
bucket = bucket.Bucket([]byte(bucketkey))
if bucket == nil {
return errors.New(uri + " not exists")
}
}
}
if bucket == nil {
return errors.New(uri + " not exists")
}
val, err := store.get(bucket, key, nested)
if err != nil {
return err
}
result = val
return nil
})
return result, e
}
// Params returns the currently stored configuration parameters for hook h
// from bucket b.
func (EmailAction) Params(h Hook, b *bolt.Bucket) map[string]string {
m := make(map[string]string)
for _, k := range []string{"token", "domain", "address", "subject", "template"} {
m[k] = string(b.Get([]byte(fmt.Sprintf("%s-%s", h.ID, k))))
}
return m
}
func (store *BoltStore) MultiGet(uri string, suffix string, nested bool) ([]interface{}, error) {
results := []interface{}{}
bucketkeys := util.PathFolders(uri)
var bucket *bolt.Bucket = nil
e := store.db.View(func(tx *bolt.Tx) error {
for _, bucketkey := range bucketkeys {
if bucket == nil {
bucket = tx.Bucket([]byte(bucketkey))
if bucket == nil {
return errors.New(uri + " not exists")
}
} else {
bucket = bucket.Bucket([]byte(bucketkey))
if bucket == nil {
return errors.New(uri + " not exists")
}
}
}
if bucket == nil {
return errors.New(uri + " not exists")
}
vals, err := store.multi_get(bucket, suffix, nested)
if err != nil {
return err
}
results = append(results, vals...)
return nil
})
return results, e
}
func (store *BoltStore) Size(uri string) (int64, error) {
namespace, key := util.NamespaceKey(uri)
bucketkeys := util.PathFolders(namespace)
var bucket *bolt.Bucket = nil
var result int64 = 0
e := store.db.View(func(tx *bolt.Tx) error {
for _, bucketkey := range bucketkeys {
if bucket == nil {
bucket = tx.Bucket([]byte(bucketkey))
if bucket == nil {
return errors.New(uri + " not exists")
}
} else {
bucket = bucket.Bucket([]byte(bucketkey))
if bucket == nil {
return errors.New(uri + " not exists")
}
}
}
if bucket == nil {
return errors.New(uri + " not exists")
}
result = store.size(bucket, key, nil)
return nil
})
return result, e
}
func (this *DB) getData(bucket *bolt.Bucket) (map[string]int, ipQueue, error) {
var addrQ ipQueue
heapRaw := bucket.Get(boltAddrHeapKey)
if heapRaw == nil {
addrQ = ipQueue(make([]*ipEntry, 0, 1))
} else {
dec := gob.NewDecoder(bytes.NewReader(heapRaw))
if err := dec.Decode(&addrQ); err != nil {
return nil, nil, err
}
}
var addrMap map[string]int
mapRaw := bucket.Get(boltAddrMapKey)
if mapRaw == nil {
addrMap = make(map[string]int)
} else {
dec := gob.NewDecoder(bytes.NewReader(mapRaw))
if err := dec.Decode(&addrMap); err != nil {
return nil, nil, err
}
}
return addrMap, addrQ, nil
}
// Store a word,word -> word sequence
func storeWords(bucket *bolt.Bucket, word1, word2, word3 string) error {
key := []byte(word1 + " " + word2)
// Get value from bucket and decode it
rawValue := bucket.Get(key)
var value []string
if rawValue == nil {
value = make([]string, 0, 1)
} else {
if err := json.Unmarshal(rawValue, &value); err != nil {
log.Printf("Cannot decode raw value for key '%v': %v; starting new empty key; old value is: %v", string(key), string(rawValue))
value = make([]string, 0, 1)
}
}
// Add new word to value
value = append(value, word3)
// Encode value and store it in bucket
rawValue, err := json.Marshal(value)
if err != nil {
return err
}
if err := bucket.Put(key, rawValue); err != nil {
return err
}
// All done
return nil
}
func (self *TX) dig(keys [][]byte, create bool) (buckets []*bolt.Bucket, err error) {
var bucket *bolt.Bucket
if create {
if bucket, err = self.tx.CreateBucketIfNotExists(keys[0]); err != nil {
return
}
} else {
if bucket = self.tx.Bucket(keys[0]); bucket == nil {
err = ErrNotFound
return
}
}
buckets = append(buckets, bucket)
for keys = keys[1:]; len(keys) > 0; keys = keys[1:] {
if create {
if bucket, err = bucket.CreateBucketIfNotExists(keys[0]); err != nil {
return
}
} else {
if bucket = bucket.Bucket(keys[0]); bucket == nil {
err = ErrNotFound
return
}
}
buckets = append(buckets, bucket)
}
return
}
func executeSelect(stmt *boltq.SelectStatement, db *bolt.DB) error {
return db.View(func(tx *bolt.Tx) error {
var bucket *bolt.Bucket
for _, name := range stmt.BucketPath {
log.Debugln("navigating to bucket", name)
bucket = tx.Bucket([]byte(name))
if bucket == nil {
return fmt.Errorf("cannot find bucket %s", name)
}
}
if containsAsterisk(stmt.Fields) {
log.Debugln("interating keys")
cursor := bucket.Cursor()
for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
emitKeypair(k, v)
}
} else {
for _, k := range stmt.Fields {
keyBytes := []byte(k)
v := bucket.Get(keyBytes)
emitKeypair(keyBytes, v)
}
}
return nil
})
}
// earliestChildTimestamp returns the earliest timestamp that a child node
// can have while still being valid. See section 'Timestamp Rules' in
// Consensus.md.
//
// To boost performance, earliestChildTimestamp is passed a bucket that it can
// use from inside of a boltdb transaction.
func earliestChildTimestamp(blockMap *bolt.Bucket, pb *processedBlock) types.Timestamp {
// Get the previous MedianTimestampWindow timestamps.
windowTimes := make(types.TimestampSlice, types.MedianTimestampWindow)
windowTimes[0] = pb.Block.Timestamp
parent := pb.Parent
for i := uint64(1); i < types.MedianTimestampWindow; i++ {
// If the genesis block is 'parent', use the genesis block timestamp
// for all remaining times.
if parent == (types.BlockID{}) {
windowTimes[i] = windowTimes[i-1]
continue
}
// Get the next parent's bytes. Because the ordering is specific, the
// parent does not need to be decoded entirely to get the desired
// information. This provides a performance boost. The id of the next
// parent lies at the first 32 bytes, and the timestamp of the block
// lies at bytes 40-48.
parentBytes := blockMap.Get(parent[:])
copy(parent[:], parentBytes[:32])
windowTimes[i] = types.Timestamp(encoding.DecUint64(parentBytes[40:48]))
}
sort.Sort(windowTimes)
// Return the median of the sorted timestamps.
return windowTimes[len(windowTimes)/2]
}
func findData(backetName string, option Option) error {
var bucket *bolt.Bucket
return db.View(func(tx *bolt.Tx) error {
tx.ForEach(func(name []byte, b *bolt.Bucket) error {
if backetName == string(name) {
bucket = b
}
return nil
})
if bucket == nil {
return errors.New("bucket not found")
}
c := bucket.Cursor()
prefix := []byte(option.key)
data := map[string]interface{}{}
OUTER:
for pk, v := c.Seek(prefix); bytes.HasPrefix(pk, prefix); pk, v = c.Next() {
u := map[string]interface{}{}
json.Unmarshal(v, &u)
for fk, fv := range option.params {
if u[fk] != fv {
continue OUTER
}
}
data[string(pk)] = u
}
showData(data)
return nil
})
}
// targetAdjustmentBase returns the magnitude that the target should be
// adjusted by before a clamp is applied.
func (cs *ConsensusSet) targetAdjustmentBase(blockMap *bolt.Bucket, pb *processedBlock) *big.Rat {
// Grab the block that was generated 'TargetWindow' blocks prior to the
// parent. If there are not 'TargetWindow' blocks yet, stop at the genesis
// block.
var windowSize types.BlockHeight
parent := pb.Block.ParentID
current := pb.Block.ID()
for windowSize = 0; windowSize < types.TargetWindow && parent != (types.BlockID{}); windowSize++ {
current = parent
copy(parent[:], blockMap.Get(parent[:])[:32])
}
timestamp := types.Timestamp(encoding.DecUint64(blockMap.Get(current[:])[40:48]))
// The target of a child is determined by the amount of time that has
// passed between the generation of its immediate parent and its
// TargetWindow'th parent. The expected amount of seconds to have passed is
// TargetWindow*BlockFrequency. The target is adjusted in proportion to how
// time has passed vs. the expected amount of time to have passed.
//
// The target is converted to a big.Rat to provide infinite precision
// during the calculation. The big.Rat is just the int representation of a
// target.
timePassed := pb.Block.Timestamp - timestamp
expectedTimePassed := types.BlockFrequency * windowSize
return big.NewRat(int64(timePassed), int64(expectedTimePassed))
}
func RepoCreateOrder(order CheckoutCartPlayLoad) interface{} {
var newOrder interface{}
GlobalDB.Update(func(tx *bolt.Tx) error {
orderBucket, err := tx.CreateBucketIfNotExists([]byte(OrderTable))
if err != nil {
HandleError(err)
return err
}
var cusOrderBuck *bolt.Bucket
if order.ChannelAccountId == nil {
cusOrderBuck, err = orderBucket.CreateBucketIfNotExists([]byte("GUESTUSER"))
} else {
cusOrderBuck, err = orderBucket.CreateBucketIfNotExists([]byte(order.ChannelAccountId.(string)))
}
if err != nil {
HandleError(err)
return err
}
newId, _ := orderBucket.NextSequence()
newOrder = GenerateOrder(order, newId)
orderBytes, _ := json.Marshal(newOrder)
cusOrderBuck.Put(TableId(newId).ToBytes(), orderBytes)
return nil
})
return newOrder
}
// Process verifies the signature and uniqueness of the random roken.
func (MailgunValidator) Process(h Hook, r Request, b *bolt.Bucket) error {
// Check HMAC
apikey := b.Get([]byte(fmt.Sprintf("%s-apikey", h.ID)))
if apikey == nil {
return errors.New("mailgun validator not initialized")
}
if r.Headers["Content-Type"] != "application/x-www-form-urlencoded" {
return fmt.Errorf("unexpected Content-Type: %q", r.Headers["Content-Type"])
}
form, err := url.ParseQuery(string(r.Body))
if err != nil {
return fmt.Errorf("error parsing request body: %s", err)
}
timestamp := form.Get("timestamp")
signature := []byte(form.Get("signature"))
token := form.Get("token")
mac := hmac.New(sha256.New, apikey)
mac.Write([]byte(timestamp + token))
expected := []byte(hex.EncodeToString(mac.Sum(nil)))
if !hmac.Equal(signature, expected) {
return errors.New("invalid signature")
}
// Check uniqueness
tokens := b.Bucket([]byte("tokens"))
if p := tokens.Get([]byte(token)); p != nil {
return errors.New("duplicate request token received")
}
return tokens.Put([]byte(token), []byte{})
}
// Save saves an Entry in the database.
func (e *Entry) Save() error {
if !database.Main.Opened {
return fmt.Errorf("db must be opened before saving")
}
return database.Main.DB.Update(func(tx *bolt.Tx) error {
var err error
var b *bolt.Bucket
var enc []byte
var id uint64
if b, err = tx.CreateBucketIfNotExists([]byte(Bucket)); err != nil {
return fmt.Errorf("Error creating bucket : %s", err)
}
if enc, err = e.Encode(); err != nil {
return fmt.Errorf("Could not encode : %s", err)
}
if e.ID == 0 {
if id, err = b.NextSequence(); err != nil {
return fmt.Errorf("Could not generate ID : %s", err)
}
e.ID = int(id)
}
return b.Put([]byte(strconv.Itoa(e.ID)), enc)
})
}
func (rpcMethod *RPCMethod) listIDs(response *ResponseParameters) error {
//open a read transaction
rpcMethod.rpcServer.boltDB.View(func(tx *bolt.Tx) error {
var cursor *bolt.Cursor
cursor = tx.Cursor()
var bucket *bolt.Bucket
response.Result = make([]interface{}, 0, 10)
//traverse through all keys
for k, _ := cursor.First(); k != nil; k, _ = cursor.Next() {
bucket = tx.Bucket(k)
//traverse through all relation and value pairs
bucket.ForEach(func(relation, value []byte) error {
tuple := make([]string, 2)
rpcMethod.rpcServer.logger.Println(string(k), string(relation), string(value))
//make an array of 2 strings [key,relation]
tuple[0] = string(k)
tuple[1] = string(relation)
response.Result = append(response.Result, tuple)
return nil
})
}
return nil
})
response.Error = nil
return nil
}
func instrumentsToDB(b *bolt.Bucket) error {
d, err := ioutil.ReadFile("instruments")
if err != nil {
return err
}
lines := strings.Split(string(d), "\n")
lines = lines[:len(lines)-1]
instruments = make([]Instrument, len(lines))
for i, line := range lines {
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
s := strings.Split(line, ",")
inst := Instrument{ID: i, Name: s[0], Tuned: s[1] == "1"}
instruments[i] = inst
err = enc.Encode(inst)
if err != nil {
return err
}
err = b.Put([]byte(s[0]), buf.Bytes())
if err != nil {
return err
}
}
return nil
}
func PersistOneBoltTx(bucket *bolt.Bucket, key string, obj proto.Marshaler) error {
exBytes, err := obj.Marshal()
if err != nil { // pragma: nocover -- no idea how to produce this error
return fmt.Errorf("Could not marshal object")
}
return bucket.Put([]byte(key), exBytes)
}
// Params returns the currently stored configuration parameters for hook h
// from bucket b.
func (ExecuteAction) Params(h Hook, b *bolt.Bucket) map[string]string {
m := make(map[string]string)
for _, k := range []string{"command"} {
m[k] = string(b.Get([]byte(fmt.Sprintf("%s-%s", h.ID, k))))
}
return m
}
// Allocate returns the next available inode number, and marks it
// used.
//
// Returns OutOfInodes if there are no free inodes.
func Allocate(bucket *bolt.Bucket) (uint64, error) {
c := bucket.Cursor()
var i uint64
k, _ := c.Last()
if k != nil {
i = bytesToInode(k)
}
// reserve a few inodes for internal use
if i < tokens.MaxReservedInode {
i = tokens.MaxReservedInode
}
i++
if i&tokens.InodeKindMask != tokens.InodeKindNormal {
return 0, OutOfInodes
}
var buf [8]byte
inodeToBytes(i, buf[:])
err := bucket.Put(buf[:], nil)
if err != nil {
return 0, err
}
return i, nil
}
// NewCursor creates a C cursor from a Bucket.
func NewCursor(b *bolt.Bucket) *Cursor {
info := b.Tx().DB().Info()
root := b.Root()
c := &Cursor{C: new(C.bolt_cursor)}
C.bolt_cursor_init(c.C, unsafe.Pointer(&info.Data[0]), C.size_t(info.PageSize), C.pgid(root))
return c
}
func executeUpdate(stmt *boltq.UpdateStatement, db *bolt.DB) error {
return db.Update(func(tx *bolt.Tx) error {
var bucket *bolt.Bucket
var err error
for _, name := range stmt.BucketPath {
log.Debugln("navigating to bucket", name)
bucket, err = tx.CreateBucketIfNotExists([]byte(name))
if err != nil {
return err
}
if bucket == nil {
return fmt.Errorf("cannot find bucket %s", name)
}
}
for k, v := range stmt.Fields {
log.Debugf("putting %s -> %v", k, v)
b, err := encode(v)
if err != nil {
return err
}
if err = bucket.Put([]byte(k), b); err != nil {
return err
}
}
return nil
})
}
// mustContainKeys checks that a bucket contains a given set of keys.
func mustContainKeys(b *bolt.Bucket, m map[string]string) {
found := make(map[string]string)
b.ForEach(func(k, _ []byte) error {
found[string(k)] = ""
return nil
})
// Check for keys found in bucket that shouldn't be there.
var keys []string
for k, _ := range found {
if _, ok := m[string(k)]; !ok {
keys = append(keys, k)
}
}
if len(keys) > 0 {
sort.Strings(keys)
panic(fmt.Sprintf("keys found(%d): %s", len(keys), strings.Join(keys, ",")))
}
// Check for keys not found in bucket that should be there.
for k, _ := range m {
if _, ok := found[string(k)]; !ok {
keys = append(keys, k)
}
}
if len(keys) > 0 {
sort.Strings(keys)
panic(fmt.Sprintf("keys not found(%d): %s", len(keys), strings.Join(keys, ",")))
}
}
func fetchChanCommitKeys(nodeChanBucket *bolt.Bucket, channel *OpenChannel) error {
// Construct the key which stores the commitment keys: ckk || channelID.
// TODO(roasbeef): factor into func
var bc bytes.Buffer
if err := writeOutpoint(&bc, channel.ChanID); err != nil {
return err
}
commitKey := make([]byte, len(commitKeys)+bc.Len())
copy(commitKey[:3], commitKeys)
copy(commitKey[3:], bc.Bytes())
var err error
keyBytes := nodeChanBucket.Get(commitKey)
channel.TheirCommitKey, err = btcec.ParsePubKey(keyBytes[:33], btcec.S256())
if err != nil {
return err
}
channel.OurCommitKey, err = btcec.ParsePubKey(keyBytes[33:], btcec.S256())
if err != nil {
return err
}
return nil
}