// addFileContract adds a file contract to the database. An error is returned
// if the file contract is already in the database.
func addFileContract(tx *bolt.Tx, id types.FileContractID, fc types.FileContract) {
// Add the file contract to the database.
fcBucket := tx.Bucket(FileContracts)
// Sanity check - should not be adding a zero-payout file contract.
if build.DEBUG && fc.Payout.IsZero() {
panic("adding zero-payout file contract")
}
// Sanity check - should not be adding a file contract already in the db.
if build.DEBUG && fcBucket.Get(id[:]) != nil {
panic("repeat file contract")
}
err := fcBucket.Put(id[:], encoding.Marshal(fc))
if build.DEBUG && err != nil {
panic(err)
}
// Add an entry for when the file contract expires.
expirationBucketID := append(prefixFCEX, encoding.Marshal(fc.WindowEnd)...)
expirationBucket, err := tx.CreateBucketIfNotExists(expirationBucketID)
if build.DEBUG && err != nil {
panic(err)
}
err = expirationBucket.Put(id[:], []byte{})
if build.DEBUG && err != nil {
panic(err)
}
}
func createBucket(name []byte, tx *bolt.Tx) error {
_, err := tx.CreateBucketIfNotExists(name)
if err != nil {
return fmt.Errorf("create bucket: %s", err)
}
return nil
}
func Open(dbPath string, conf *Config, create, repair bool) (*BoltDB, error) {
os.MkdirAll(dbPath, 0755)
name := path.Join(dbPath, "rpdb_bolt.db")
db := &BoltDB{
path: dbPath,
cfg: conf,
}
var err error
db.db, err = bolt.Open(name, 0600, nil)
if err != nil {
return nil, err
}
var tx *bolt.Tx
tx, err = db.db.Begin(true)
if err != nil {
return nil, err
}
_, err = tx.CreateBucketIfNotExists(bucketName)
if err != nil {
tx.Rollback()
return nil, err
}
if err = tx.Commit(); err != nil {
return nil, err
}
return db, nil
}
func depersistMessage(tx *bolt.Tx, id int64) error {
content_bucket, err := tx.CreateBucketIfNotExists(MESSAGE_CONTENT_BUCKET)
if err != nil {
return err
}
return content_bucket.Delete(binaryId(id))
}
func (bs *boltStorage) bucket(tx *bolt.Tx) (b *bolt.Bucket, err error) {
b = tx.Bucket(dbBucket)
if b == nil {
b, err = tx.CreateBucketIfNotExists(dbBucket)
}
return b, err
}
// fullSync is an internal versino of the FullSync method which allows callers
// to sync the contents of an OpenChannel while re-using an existing database
// transaction.
func (c *OpenChannel) fullSync(tx *bolt.Tx) error {
// TODO(roasbeef): add helper funcs to create scoped update
// First fetch the top level bucket which stores all data related to
// current, active channels.
chanBucket, err := tx.CreateBucketIfNotExists(openChannelBucket)
if err != nil {
return err
}
// Within this top level bucket, fetch the bucket dedicated to storing
// open channel data specific to the remote node.
nodePub := c.IdentityPub.SerializeCompressed()
nodeChanBucket, err := chanBucket.CreateBucketIfNotExists(nodePub)
if err != nil {
return err
}
// Add this channel ID to the node's active channel index if
// it doesn't already exist.
chanIDBucket, err := nodeChanBucket.CreateBucketIfNotExists(chanIDBucket)
if err != nil {
return err
}
var b bytes.Buffer
if err := writeOutpoint(&b, c.ChanID); err != nil {
return err
}
if chanIDBucket.Get(b.Bytes()) == nil {
if err := chanIDBucket.Put(b.Bytes(), nil); err != nil {
return err
}
}
return putOpenChannel(chanBucket, nodeChanBucket, c)
}
func (s Store) Open(dbPath string, cfg *config.Config) (driver.IDB, error) {
os.MkdirAll(dbPath, 0755)
name := path.Join(dbPath, "ledis_bolt.db")
db := new(DB)
var err error
db.path = name
db.cfg = cfg
db.db, err = bolt.Open(name, 0600, nil)
if err != nil {
return nil, err
}
var tx *bolt.Tx
tx, err = db.db.Begin(true)
if err != nil {
return nil, err
}
_, err = tx.CreateBucketIfNotExists(bucketName)
if err != nil {
tx.Rollback()
return nil, err
}
if err = tx.Commit(); err != nil {
return nil, err
}
return db, nil
}
func (db *DB) Open(dbPath string) error {
var (
err error
boltDB *bolt.DB
)
boltDB, err = bolt.Open(dbPath, 0600, nil)
if err != nil {
return err
}
var tx *bolt.Tx
tx, err = boltDB.Begin(true)
if err != nil {
return err
}
bucketName := []byte(base64.StdEncoding.EncodeToString([]byte(dbPath)))
_, err = tx.CreateBucketIfNotExists(bucketName)
if err != nil {
tx.Rollback()
return err
}
if err = tx.Commit(); err != nil {
return err
}
db.boltDB = boltDB
db.dbPath = dbPath
db.bucketName = bucketName
return nil
}
func (q *Queue) DepersistBoltTx(tx *bolt.Tx) error {
bucket, err := tx.CreateBucketIfNotExists(QUEUE_BUCKET_NAME)
if err != nil {
return fmt.Errorf("create bucket: %s", err)
}
return persist.DepersistOneBoltTx(bucket, q.Name)
}
func Open(cfg *Config) (*DB, error) {
os.MkdirAll(cfg.Path, os.ModePerm)
name := path.Join(cfg.Path, "ledis_bolt.db")
db := new(DB)
var err error
db.db, err = bolt.Open(name, 0600, nil)
if err != nil {
return nil, err
}
db.db.NoSync = cfg.NoSync
var tx *bolt.Tx
tx, err = db.db.Begin(true)
if err != nil {
return nil, err
}
_, err = tx.CreateBucketIfNotExists(bucketName)
if err != nil {
tx.Rollback()
return nil, err
}
if err = tx.Commit(); err != nil {
return nil, err
}
return db, nil
}
func persistIndexMessage(tx *bolt.Tx, im *amqp.IndexMessage) error {
content_bucket, err := tx.CreateBucketIfNotExists(MESSAGE_INDEX_BUCKET)
b, err := proto.Marshal(im)
if err != nil {
return err
}
return content_bucket.Put(binaryId(im.Id), b)
}
func persistMessage(tx *bolt.Tx, msg *amqp.Message) error {
content_bucket, err := tx.CreateBucketIfNotExists(MESSAGE_CONTENT_BUCKET)
b, err := proto.Marshal(msg)
if err != nil {
return err
}
return content_bucket.Put(binaryId(msg.Id), b)
}
func initBuckets(t *bolt.Tx) error {
for _, name := range [][]byte{BucketHooks, BucketStats, BucketComponents} {
if _, err := t.CreateBucketIfNotExists(name); err != nil {
return err
}
}
return nil
}
func (binding *Binding) DepersistBoltTx(tx *bolt.Tx) error {
bucket, err := tx.CreateBucketIfNotExists(BINDINGS_BUCKET_NAME)
if err != nil { // pragma: nocover
// If we're hitting this it means the disk is full, the db is readonly,
// or something else has gone irrecoverably wrong
panic(fmt.Sprintf("create bucket: %s", err))
}
return persist.DepersistOneBoltTx(bucket, string(binding.Id))
}
func depersistQueueMessage(tx *bolt.Tx, queueName string, id int64) error {
bucketName := fmt.Sprintf("queue_%s", queueName)
content_bucket, err := tx.CreateBucketIfNotExists([]byte(bucketName))
if err != nil {
return err
}
var key = binaryId(id)
return content_bucket.Delete(key)
}
func (m *Meme) writeBindata(tx *bolt.Tx, id uint64) error {
bucket, err := tx.CreateBucketIfNotExists(binBucketName)
if err != nil {
return err
}
if err := bucket.Put(itob(id), m.bindata); err != nil {
return err
}
return nil
}
func boltInit(tx *bolt.Tx) error {
gollBucket, e := tx.CreateBucketIfNotExists(BucketGollName)
if e != nil {
return e
}
gollBucket.CreateBucketIfNotExists(BucketWhatName)
gollBucket.CreateBucketIfNotExists(BucketMetaName)
gollBucket.CreateBucketIfNotExists(BucketSettingName)
return nil
}
// put an item to the corresponding store
func (b *DB) Put(tx *bolt.Tx, item Item) error {
bucket, err := tx.CreateBucketIfNotExists(item.StoreID())
if err == nil {
bytes, err := item.Bytes()
if err == nil {
bucket.Put(item.Key(), bytes)
}
}
return err
}
// Destroy deletes a meme from the DB
func (m *Meme) Destroy(tx *bolt.Tx) error {
bucket, err := tx.CreateBucketIfNotExists(bucketName)
if err != nil {
return err
}
if err := bucket.Delete(itob(m.ID)); err != nil {
return err
}
return nil
}
//Put sets one key/value pair.
func Put(tx *bolt.Tx, bucket string, key []byte, value interface{}) error {
val, err := Tob(value)
if err != nil {
return err
}
b, errr := tx.CreateBucketIfNotExists([]byte(bucket))
if errr != nil {
return fmt.Errorf("create bucket: %s", err)
}
return b.Put(key, val)
}
func putClosedChannelSummary(tx *bolt.Tx, chanID []byte) error {
// For now, a summary of a closed channel simply involves recording the
// outpoint of the funding transaction.
closedChanBucket, err := tx.CreateBucketIfNotExists(closedChannelBucket)
if err != nil {
return err
}
// TODO(roasbeef): add other info
// * should likely have each in own bucket per node
return closedChanBucket.Put(chanID, nil)
}
func persistQueueMessage(tx *bolt.Tx, queueName string, qm *amqp.QueueMessage) error {
bucketName := fmt.Sprintf("queue_%s", queueName)
content_bucket, err := tx.CreateBucketIfNotExists([]byte(bucketName))
if err != nil {
return err
}
protoBytes, err := proto.Marshal(qm)
if err != nil {
return err
}
return content_bucket.Put(binaryId(qm.Id), protoBytes)
}
func addIDToTag(tx *bolt.Tx, tag, id string) error {
buck, err := tx.CreateBucketIfNotExists(tagBucket)
if err != nil {
return err
}
buck, err = buck.CreateBucketIfNotExists([]byte(tag))
if err != nil {
return err
}
buck.Put([]byte(id), []byte{1})
return nil
}
// ClearDates clears the date schedule for the group
func (g *Group) ClearDates(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte(g.ID))
if err != nil {
return err
}
err = b.DeleteBucket(datesBucket)
if err != nil && err != bolt.ErrBucketNotFound {
return err
}
return nil
}
func saveMetaData(tx *bolt.Tx, schema []Column) error {
b, err := tx.CreateBucketIfNotExists([]byte(SCHEMABUCKET))
if err != nil {
return err
}
for i := 0; i < len(schema); i++ {
b.Put([]byte(schema[i].name), []byte(schema[i].dataType))
}
return nil
}
func createBucketIfNotExists(tx *bolt.Tx, keys ...[]byte) (*bolt.Bucket, error) {
bkt, err := tx.CreateBucketIfNotExists(keys[0])
if err != nil {
return nil, err
}
for _, key := range keys[1:] {
bkt, err = bkt.CreateBucketIfNotExists(key)
if err != nil {
return nil, err
}
}
return bkt, nil
}
// Save stores the Date in the database
func (d *Date) Save(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte(d.Group))
if err != nil {
return err
}
b, err = b.CreateBucketIfNotExists(datesBucket)
if err != nil {
return err
}
data, err := encodeDate(d)
if err != nil {
return err
}
return b.Put(d.Key(), data)
}
func ensureMsgBucket(tx *bolt.Tx, connection string, bucket string) (b *bolt.Bucket, err error) {
// make sure our connection bucket exists
b, err = tx.CreateBucketIfNotExists([]byte(connection))
if err != nil {
return b, err
}
// and make sure our sub bucket exists
b, err = b.CreateBucketIfNotExists([]byte(bucket))
if err != nil {
return b, err
}
return b, err
}
// updateDbMetadata will set the contents of the metadata bucket to be
// what is stored inside the metadata argument
func (db *BoltDatabase) updateMetadata(tx *bolt.Tx) error {
bucket, err := tx.CreateBucketIfNotExists([]byte("Metadata"))
if err != nil {
return err
}
err = bucket.Put([]byte("Header"), []byte(db.meta.Header))
if err != nil {
return err
}
err = bucket.Put([]byte("Version"), []byte(db.meta.Version))
if err != nil {
return err
}
return nil
}
func (b *BoltQ) decreaseTotalItem(tx *bolt.Tx) (err error) {
stats_bucket, err := tx.CreateBucketIfNotExists([]byte(BUCKET_STATS))
tmp_count := stats_bucket.Get([]byte(KEY_TOTALITEM))
if tmp_count != nil {
tmp, err := strconv.ParseInt(string(tmp_count), 10, 64)
if err != nil {
// log.Printf("ERROR: %v\n", err)
return err
}
b.total_item = tmp
}
// remove above codes won't boost performance ...
b.total_item -= 1
err = stats_bucket.Put([]byte(KEY_TOTALITEM), []byte(fmt.Sprintf("%d", b.total_item)))
return
}
