Use Boltdb directly.

Author: averagesecurityguy

config.go

@@ -7,7 +7,7 @@ import (
 	"regexp"
 	"time"
 
-	"github.com/asggo/store"
+	"github.com/boltdb/bolt"
 )
 
 type Keyword struct {
@@ -24,7 +24,7 @@ type Regex struct {
 
 type Config struct {
 	keys     map[string]time.Time
-	ds       *store.Store
+	db       *bolt.DB
 	Keywords []*Keyword // A list of keywords to search for in the data.
 	Regexes  []*Regex   // A list of regular expressions to test against data.
 	Buckets  []string   `json:"buckets"`       // List of buckets we need to create.

process.go

@@ -14,7 +14,7 @@ func savePaste(key, content string) {
 		return
 	}
 
-	conf.ds.Write("pastes", key, []byte(content))
+	writeDB(conf.db, "pastes", key, []byte(content))
 }
 
 func processRegexes(key, content string) {
@@ -32,15 +32,15 @@ func processRegexes(key, content string) {
 
 			for k := range items {
 				rKey := fmt.Sprintf("%s-%s-%d", r.Prefix, key, k)
-				conf.ds.Write("regexes", rKey, []byte(items[k]))
+				writeDB(conf.db, "regexes", rKey, []byte(items[k]))
 			}
 		case "one":
 			match := r.compiled.FindString(content)
 			rKey := fmt.Sprintf("%s-%s", r.Prefix, key)
 
 			if match != "" {
 				save = true
-				conf.ds.Write("regexes", rKey, []byte(match))
+				writeDB(conf.db, "regexes", rKey, []byte(match))
 			}
 		default:
 		}
@@ -59,7 +59,7 @@ func processKeywords(key, content string) {
 
 		if strings.Contains(strings.ToLower(content), strings.ToLower(kwd.Keyword)) {
 			save = true
-			conf.ds.Write("keywords", kwdKey, []byte(key))
+			writeDB(conf.db, "keywords", kwdKey, []byte(key))
 		}
 	}
 
@@ -68,10 +68,9 @@ func processKeywords(key, content string) {
 	}
 }
 
-
 func processContent(key, content string) {
-	conf.ds = getStoreConn()
-	defer conf.ds.Close()
+	conf.db = getDBConn()
+	defer conf.db.Close()
 
 	processRegexes(key, content)
 	processKeywords(key, content)

scrape.go

@@ -1,38 +1,11 @@
 package main
 
 import (
-	"log"
 	"time"
-
-	"github.com/asggo/store"
 )
 
 var conf Config
 
-func getStoreConn() *store.Store {
-	var ds *store.Store
-	var err error
-
-	for tries := 1; tries < 20; tries += 2 {
-		// Create our connection to the key value store.
-		ds, err = store.NewStore(conf.DbFile)
-		if err != nil {
-			log.Printf("[-] Cannot open database: %s\n", err)
-			time.Sleep(1 << uint(tries) * time.Millisecond)
-		} else {
-			break
-		}
-	}
-
-	return ds
-}
-
-func initStore(s *store.Store) {
-	for _, bucket := range conf.Buckets {
-		s.CreateBucket(bucket)
-	}
-}
-
 func cleanKeys() {
 	now := time.Now()
 	max := time.Duration(conf.MaxTime) * time.Second
@@ -51,11 +24,7 @@ func scrape() {
 
 func main() {
 	conf = newConfig()
-
-	// Ensure our database is initialized.
-	ds := getStoreConn()
-	initStore(ds)
-	ds.Close()
+	initDB()
 
 	for {
 		scrape()

store.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"log"
+	"time"
+
+	"github.com/boltdb/bolt"
+)
+
+func getDBConn() *bolt.DB {
+	for tries := 1; tries < 20; tries += 2 {
+		timeout := 1 << uint(tries) * time.Millisecond
+
+		db, err := bolt.Open(conf.DbFile, 0640, &bolt.Options{Timeout: timeout})
+		if err == nil {
+			return db
+		}
+
+		log.Printf("[-] Database locked waiting...\n")
+	}
+
+	return nil
+}
+
+func initDB() {
+	db := getDBConn()
+
+	for _, bucket := range conf.Buckets {
+		createBucket(db, bucket)
+	}
+
+	db.Close()
+}
+
+func createBucket(db *bolt.DB, bucket string) error {
+	return db.Update(func(tx *bolt.Tx) error {
+		_, err := tx.CreateBucketIfNotExists([]byte(bucket))
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
+
+func writeDB(db *bolt.DB, bucket, key string, value []byte) error {
+	return db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(bucket))
+
+		return b.Put([]byte(key), []byte(value))
+	})
+}
+
+func readDB(db *bolt.DB, bucket, key string) []byte {
+	var val []byte
+
+	db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(bucket))
+		val = b.Get([]byte(key))
+
+		return nil
+	})
+
+	return val
+}
+
+func deleteDB(db *bolt.DB, bucket, key string) error {
+	return db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(bucket))
+
+		return b.Delete([]byte(key))
+	})
+}