func (s *BoltStore) removeFromRootLabel(tx *bolt.Tx, itemType string, itemID uint64, userid []byte) {
index := tx.Bucket(boltBucketLabelRootIndex)
id := index.Get(userid)
if id != nil {
label := itemType + "/" + strconv.FormatUint(itemID, 10)
b := tx.Bucket(boltBucketLabels)
v := b.Get(id)
root := &Label{}
root.UnmarshalMsg(v)
if strings.Contains(root.Content, ","+label) {
root.Content = strings.Replace(root.Content, ","+label, "", 1)
} else if strings.HasPrefix(root.Content, label+",") {
root.Content = strings.Replace(root.Content, label+",", "", 1)
} else {
root.Content = strings.Replace(root.Content, label, "", 1)
}
v, err := root.MarshalMsg(nil)
if err != nil {
return
}
b.Put(id, v)
}
}
// Inserts a key into the database.
func simulatePutHandler(tx *bolt.Tx, qdb *QuickDB) {
var err error
keys, value := randKeys(), randValue()
// Retrieve root bucket.
b := tx.Bucket(keys[0])
if b == nil {
b, err = tx.CreateBucket(keys[0])
if err != nil {
panic("create bucket: " + err.Error())
}
}
// Create nested buckets, if necessary.
for _, key := range keys[1 : len(keys)-1] {
child := b.Bucket(key)
if child != nil {
b = child
} else {
b, err = b.CreateBucket(key)
if err != nil {
panic("create bucket: " + err.Error())
}
}
}
// Insert into database.
if err := b.Put(keys[len(keys)-1], value); err != nil {
panic("put: " + err.Error())
}
// Insert into in-memory database.
qdb.Put(keys, value)
}
// Retrieves a key from the database and verifies that it is what is expected.
func simulateGetHandler(tx *bolt.Tx, qdb *QuickDB) {
// Randomly retrieve an existing exist.
keys := qdb.Rand()
if len(keys) == 0 {
return
}
// Retrieve root bucket.
b := tx.Bucket(keys[0])
if b == nil {
panic(fmt.Sprintf("bucket[0] expected: %08x\n", trunc(keys[0], 4)))
}
// Drill into nested buckets.
for _, key := range keys[1 : len(keys)-1] {
b = b.Bucket(key)
if b == nil {
panic(fmt.Sprintf("bucket[n] expected: %v -> %v\n", keys, key))
}
}
// Verify key/value on the final bucket.
expected := qdb.Get(keys)
actual := b.Get(keys[len(keys)-1])
if !bytes.Equal(actual, expected) {
fmt.Println("=== EXPECTED ===")
fmt.Println(expected)
fmt.Println("=== ACTUAL ===")
fmt.Println(actual)
fmt.Println("=== END ===")
panic("value mismatch")
}
}
func (s *BoltStore) getLabel(tx *bolt.Tx, id []byte) *Label {
b := tx.Bucket(boltBucketLabels)
v := b.Get(id)
if v != nil {
label := &Label{}
label.UnmarshalMsg(v)
return label
}
return nil
}
func (s *BoltStore) addEvent(tx *bolt.Tx, event *Event, userid uint64) error {
b := tx.Bucket(boltBucketEvents)
eventID, err := b.NextSequence()
if err != nil {
return err
}
v, err := event.MarshalMsg(nil)
if err != nil {
return err
}
id := make([]byte, 24)
binary.BigEndian.PutUint64(id[:8], userid)
binary.BigEndian.PutUint64(id[8:16], event.ClientTS)
binary.BigEndian.PutUint64(id[16:], eventID)
return b.Put(id, v)
}
func (s *BoltStore) saveEpisode(tx *bolt.Tx, ep *Episode) error {
index := tx.Bucket(boltBucketEpisodeGUIDIndex)
guid := []byte(ep.GUID)
if index.Get(guid) != nil {
return nil
}
var err error
b := tx.Bucket(boltBucketEpisodes)
ep.ID, err = b.NextSequence()
if err != nil {
return err
}
ep.EncodeFeed()
v, err := ep.MarshalMsg(nil)
if err != nil {
return err
}
id := uint64Bytes(ep.ID)
err = index.Put(guid, id)
if err != nil {
return err
}
idxID := make([]byte, 16)
binary.BigEndian.PutUint64(idxID[:8], ep.CastID)
binary.BigEndian.PutUint64(idxID[8:], ep.ID)
castIndex := tx.Bucket(boltBucketEpisodeCastIDIndex)
err = castIndex.Put(idxID, id)
if err != nil {
return err
}
crawlTSIndex := tx.Bucket(boltBucketEpisodeCrawlTSIndex)
idxID = make([]byte, 24)
binary.BigEndian.PutUint64(idxID[:8], uint64(ep.CrawlTS))
binary.BigEndian.PutUint64(idxID[8:16], ep.ID)
binary.BigEndian.PutUint64(idxID[16:], ep.CastID)
err = crawlTSIndex.Put(idxID, id)
if err != nil {
return err
}
return b.Put(id, v)
}
func (s *BoltStore) addToRootLabel(tx *bolt.Tx, itemType string, itemID uint64, userid []byte) {
var err error
label := itemType + "/" + strconv.FormatUint(itemID, 10)
b := tx.Bucket(boltBucketLabels)
index := tx.Bucket(boltBucketLabelRootIndex)
id := index.Get(userid)
if id != nil {
v := b.Get(id)
root := &Label{}
root.UnmarshalMsg(v)
if strings.Contains(root.Content, label) {
return
}
if root.Content != "" {
root.Content += ","
}
root.Content += label
v, err = root.MarshalMsg(nil)
if err != nil {
return
}
b.Put(id, v)
} else {
root := &Label{
Name: "root",
Content: itemType + "/" + strconv.FormatUint(itemID, 10),
Root: true,
}
root.ID, err = b.NextSequence()
if err != nil {
return
}
v, err := root.MarshalMsg(nil)
if err != nil {
return
}
id = uint64Bytes(root.ID)
index.Put(userid, id)
idxID := []byte{}
idxID = append(idxID, userid...)
idxID = append(idxID, id...)
index = tx.Bucket(boltBucketLabelUserIDIndex)
err = index.Put(idxID, id)
if err != nil {
return
}
b.Put(id, v)
}
}