func main() {
flag.Parse()
if *showVersion {
fmt.Printf("gocountme: v%s\n", VERSION)
return
}
if *defaultSize <= 0 {
fmt.Printf("--default-size must be greater than 0\n")
return
}
if _, err := os.Stat(*dblocation); err != nil {
if os.IsNotExist(err) {
fmt.Println("Database location does not exist:", *dblocation)
return
}
}
log.Println("Opening levelDB")
Default_KMinValues_Size = *defaultSize
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(*leveldbLRUCache))
opts.SetCreateIfMissing(true)
db, err := levigo.Open(*dblocation, opts)
defer db.Close()
if err != nil {
log.Panicln(err)
}
RequestChan = make(chan RequestCommand, *nWorkers)
workerWaitGroup := sync.WaitGroup{}
log.Printf("Starting %d workers", *nWorkers)
for i := 0; i < *nWorkers; i++ {
go func(id int) {
workerWaitGroup.Add(1)
levelDBWorker(db, RequestChan)
workerWaitGroup.Done()
}(i)
}
http.HandleFunc("/get", GetHandler)
http.HandleFunc("/delete", DeleteHandler)
http.HandleFunc("/cardinality", CardinalityHandler)
http.HandleFunc("/jaccard", JaccardHandler)
http.HandleFunc("/correlation", CorrelationMatrixHandler)
http.HandleFunc("/add", AddHandler)
http.HandleFunc("/addhash", AddHashHandler)
http.HandleFunc("/query", QueryHandler)
http.HandleFunc("/exit", ExitHandler)
log.Printf("Starting gocountme HTTP server on %s", *httpAddress)
go func() {
log.Fatal(http.ListenAndServe(*httpAddress, nil))
}()
workerWaitGroup.Wait()
}
func main() {
dbname := "leveldb"
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(3 << 20))
opts.SetCreateIfMissing(true)
_ = levigo.DestroyDatabase(dbname, opts)
db, _ := levigo.Open(dbname, opts)
wo := levigo.NewWriteOptions()
ro := levigo.NewReadOptions()
start := time.Now()
for i := 0; i < 10e4; i++ {
db.Put(wo, []byte(fmt.Sprintf("a%v", i)), []byte(strconv.Itoa(i)))
}
for i := 0; i < 10e4; i++ {
db.Get(ro, []byte(fmt.Sprintf("a%v", i)))
}
for i := 0; i < 10e4; i++ {
db.Delete(wo, []byte(fmt.Sprintf("a%v", i)))
}
duration := time.Since(start)
log.Printf("Elapsed: %v.", duration)
}
func InitDB() (*levigo.DB, error) {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(1024 * 1024))
opts.SetCreateIfMissing(true)
homedir := os.Getenv("HOME")
dbdir := homedir + "/.overseer/db"
os.MkdirAll(dbdir, 0700)
db, err := levigo.Open(dbdir, opts)
if err != nil {
fmt.Println("Failed to open database", err)
return nil, err
}
procs, err := ListProcs(db)
for p, status := range procs {
log.Printf("Proc ID: %d, status: %d", p, status)
if isProcAlive(p) == false {
setProcStatus(db, p, PROC_STOPPED)
} else {
setProcStatus(db, p, PROC_ALIVE)
}
}
return db, nil
}
func TestLevigo(t *testing.T) {
path := "/tmp/levigo_test_10101"
os.RemoveAll(path)
opts := levigo.NewOptions()
filter := levigo.NewBloomFilter(10)
opts.SetFilterPolicy(filter)
opts.SetCache(levigo.NewLRUCache(1024 << 20)) // 1G
opts.SetCreateIfMissing(true)
if ldb, err := levigo.Open(path, opts); err == nil {
key := []byte("test-test hwl0dsfds")
val := []byte("value")
if err = ldb.Put(levigo.NewWriteOptions(), key, val); err != nil {
t.Fail()
} else {
ro := levigo.NewReadOptions()
if data, err := ldb.Get(ro, key); err == nil && reflect.DeepEqual(data, val) {
ro.SetFillCache(false)
it := ldb.NewIterator(ro)
it.Seek([]byte{0})
for ; it.Valid(); it.Next() {
log.Printf("%s => %s", it.Key(), it.Value())
}
} else {
t.Fail()
}
}
} else {
t.Fail()
}
}
// Will panic if there is a problem with the database.
// Should only be called on server initialization.
func NewDatabase(databaseLocation string) *Database {
buckets := new(Database)
buckets.DBMap = make(map[string]*levigo.DB)
buckets.BaseLocation = databaseLocation
os.MkdirAll(databaseLocation, 0755)
files, err := ioutil.ReadDir(databaseLocation)
if err != nil {
panic(err)
}
for _, file := range files {
if !file.IsDir() || strings.HasPrefix(file.Name(), "_") {
continue
}
opts := levigo.NewOptions()
opts.SetCreateIfMissing(true)
opts.SetCache(levigo.NewLRUCache(4194304))
buckets.DBMap[file.Name()], err = levigo.Open(path.Join(databaseLocation, file.Name()), opts)
if err != nil {
panic(err)
}
}
return buckets
}
func NewLevelDBPersistence(storageRoot string, cacheCapacity, bitsPerBloomFilterEncoded int) (p *LevelDBPersistence, err error) {
options := levigo.NewOptions()
options.SetCreateIfMissing(true)
options.SetParanoidChecks(true)
cache := levigo.NewLRUCache(cacheCapacity)
options.SetCache(cache)
filterPolicy := levigo.NewBloomFilter(bitsPerBloomFilterEncoded)
options.SetFilterPolicy(filterPolicy)
storage, err := levigo.Open(storageRoot, options)
if err != nil {
return
}
readOptions := levigo.NewReadOptions()
writeOptions := levigo.NewWriteOptions()
writeOptions.SetSync(true)
p = &LevelDBPersistence{
cache: cache,
filterPolicy: filterPolicy,
options: options,
readOptions: readOptions,
storage: storage,
writeOptions: writeOptions,
}
return
}
func NewTree(dbname string) *Tree {
debug("New tree")
n := new(Tree)
n.closed = false
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(3 << 30))
opts.SetCreateIfMissing(true)
d, err := levigo.Open(dbname, opts)
if err != nil {
Error(err)
}
n.DB = d
if n.Root, err = n.Get(nil, 0); err != nil {
debug("could not get", err)
n.Root = &Node{Parent: 0}
if err := n.Put(nil, n.Root); err != nil {
Error("could not set", err)
}
}
n.Newid = make(chan int)
go func() {
id := n.Root.Parent + 1
for ; ; id++ {
n.Newid <- id
if n.closed {
break
}
}
log.Println("exiting Newid goroutine")
}()
return n
}
// Open returns a keyvalue DB backed by a LevelDB database at the given
// filepath. If opts==nil, the DefaultOptions are used.
func Open(path string, opts *Options) (keyvalue.DB, error) {
if opts == nil {
opts = DefaultOptions
}
options := levigo.NewOptions()
defer options.Close()
cache := levigo.NewLRUCache(opts.CacheCapacity)
options.SetCache(cache)
options.SetCreateIfMissing(!opts.MustExist)
if opts.WriteBufferSize > 0 {
options.SetWriteBufferSize(opts.WriteBufferSize)
}
db, err := levigo.Open(path, options)
if err != nil {
return nil, fmt.Errorf("could not open LevelDB at %q: %v", path, err)
}
largeReadOpts := levigo.NewReadOptions()
largeReadOpts.SetFillCache(opts.CacheLargeReads)
return &levelDB{
db: db,
cache: cache,
readOpts: levigo.NewReadOptions(),
largeReadOpts: largeReadOpts,
writeOpts: levigo.NewWriteOptions(),
}, nil
}
func NewLeveldbCache(dbname string, cacheM int) (*LeveldbCache, error) {
opts := levigo.NewOptions()
filter := levigo.NewBloomFilter(10)
cache := levigo.NewLRUCache(1024 * 1024 * cacheM)
opts.SetFilterPolicy(filter)
opts.SetCache(cache)
opts.SetCreateIfMissing(true)
opts.SetWriteBufferSize(8 * 1024 * 104) // 8M
opts.SetCompression(levigo.SnappyCompression)
if ldb, err := levigo.Open(dbname, opts); err == nil {
so := levigo.NewReadOptions()
so.SetFillCache(false)
return &LeveldbCache{
db: ldb,
fp: filter,
cache: cache,
Ro: levigo.NewReadOptions(),
Wo: levigo.NewWriteOptions(),
So: so,
}, nil
} else {
return nil, err
}
}
func (c *cache) open(path string) error {
opts := levigo.NewOptions()
opts.SetCreateIfMissing(true)
if c.options.CacheSizeM > 0 {
c.cache = levigo.NewLRUCache(c.options.CacheSizeM * 1024 * 1024)
opts.SetCache(c.cache)
}
if c.options.MaxOpenFiles > 0 {
opts.SetMaxOpenFiles(c.options.MaxOpenFiles)
}
if c.options.BlockRestartInterval > 0 {
opts.SetBlockRestartInterval(c.options.BlockRestartInterval)
}
if c.options.WriteBufferSizeM > 0 {
opts.SetWriteBufferSize(c.options.WriteBufferSizeM * 1024 * 1024)
}
if c.options.BlockSizeK > 0 {
opts.SetBlockSize(c.options.BlockSizeK * 1024)
}
db, err := levigo.Open(path, opts)
if err != nil {
return err
}
c.db = db
c.wo = levigo.NewWriteOptions()
c.ro = levigo.NewReadOptions()
return nil
}
func (db *DB) initOptions(cfg *Config) *levigo.Options {
opts := levigo.NewOptions()
opts.SetCreateIfMissing(true)
if cfg.CacheSize > 0 {
db.cache = levigo.NewLRUCache(cfg.CacheSize)
opts.SetCache(db.cache)
}
//we must use bloomfilter
db.filter = levigo.NewBloomFilter(defaultFilterBits)
opts.SetFilterPolicy(db.filter)
if !cfg.Compression {
opts.SetCompression(levigo.NoCompression)
}
if cfg.BlockSize > 0 {
opts.SetBlockSize(cfg.BlockSize)
}
if cfg.WriteBufferSize > 0 {
opts.SetWriteBufferSize(cfg.WriteBufferSize)
}
return opts
}
func NewLevelDB(path string, config interface{}) (Engine, error) {
c, ok := config.(*LevelDbConfiguration)
if !ok {
return nil, fmt.Errorf("Config is of type %T instead of %T", config, LevelDbConfiguration{})
}
// if it wasn't set, set it to 100
if c.MaxOpenFiles == 0 {
c.MaxOpenFiles = 100
}
// if it wasn't set, set it to 200 MB
if c.LruCacheSize == 0 {
c.LruCacheSize = 200 * 1024 * 1024
}
// initialize the global cache
if cache == nil {
cacheLock.Lock()
if cache == nil {
cache = levigo.NewLRUCache(int(c.LruCacheSize))
}
cacheLock.Unlock()
}
opts := levigo.NewOptions()
opts.SetCache(cache)
opts.SetCreateIfMissing(true)
opts.SetMaxOpenFiles(c.MaxOpenFiles)
db, err := levigo.Open(path, opts)
wopts := levigo.NewWriteOptions()
ropts := levigo.NewReadOptions()
return LevelDB{db, opts, wopts, ropts, path}, err
}
func initDB() (*levigo.DB, error) {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(3 << 30))
opts.SetCreateIfMissing(true)
return levigo.Open(settings.dir+"/db", opts)
}
func NewLevelDbShardDatastore(config *configuration.Configuration) (*LevelDbShardDatastore, error) {
baseDbDir := filepath.Join(config.DataDir, SHARD_DATABASE_DIR)
err := os.MkdirAll(baseDbDir, 0744)
if err != nil {
return nil, err
}
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(config.LevelDbLruCacheSize))
opts.SetCreateIfMissing(true)
opts.SetBlockSize(64 * ONE_KILOBYTE)
filter := levigo.NewBloomFilter(SHARD_BLOOM_FILTER_BITS_PER_KEY)
opts.SetFilterPolicy(filter)
opts.SetMaxOpenFiles(config.LevelDbMaxOpenFiles)
return &LevelDbShardDatastore{
baseDbDir: baseDbDir,
config: config,
shards: make(map[uint32]*LevelDbShard),
levelDbOptions: opts,
maxOpenShards: config.LevelDbMaxOpenShards,
lastAccess: make(map[uint32]int64),
shardRefCounts: make(map[uint32]int),
shardsToClose: make(map[uint32]bool),
pointBatchSize: config.LevelDbPointBatchSize,
}, nil
}
func NewLevelDbDatastore(dbDir string) (Datastore, error) {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(ONE_GIGABYTE))
opts.SetCreateIfMissing(true)
opts.SetBlockSize(TWO_FIFTY_SIX_KILOBYTES)
filter := levigo.NewBloomFilter(BLOOM_FILTER_BITS_PER_KEY)
opts.SetFilterPolicy(filter)
db, err := levigo.Open(dbDir, opts)
if err != nil {
return nil, err
}
ro := levigo.NewReadOptions()
lastIdBytes, err2 := db.Get(ro, NEXT_ID_KEY)
if err2 != nil {
return nil, err2
}
lastId := uint64(0)
if lastIdBytes != nil {
lastId, err2 = binary.ReadUvarint(bytes.NewBuffer(lastIdBytes))
if err2 != nil {
return nil, err2
}
}
wo := levigo.NewWriteOptions()
return &LevelDbDatastore{db: db, lastIdUsed: lastId, readOptions: ro, writeOptions: wo}, nil
}
func (engine *LevelDbEngine) Init(config *proto.DBConfigs) error {
if config == nil {
return proto.ErrNoEngineConfig
}
if config.LevelDbConfigs == nil {
config.LevelDbConfigs = DefaultLevelDbConf
}
options := levigo.NewOptions()
// options.SetCreateIfMissing(config.CreateIfMissing)
options.SetCreateIfMissing(true)
options.SetParanoidChecks(config.LevelDbConfigs.ParanoidCheck)
if config.LevelDbConfigs.LRUCacheSize > 0 {
options.SetCache(levigo.NewLRUCache(config.LevelDbConfigs.LRUCacheSize))
}
if config.LevelDbConfigs.BloomFilterLength > 0 {
options.SetFilterPolicy(levigo.NewBloomFilter(config.LevelDbConfigs.BloomFilterLength))
}
engine.config = config
engine.dbOptions = options
db, err := levigo.Open(engine.config.DataPath, engine.dbOptions)
if err != nil {
return err
}
engine.db = db
return nil
}
func NewLevelDbDatastore(dbDir string) (Datastore, error) {
mainDbDir := filepath.Join(dbDir, DATABASE_DIR)
requestLogDir := filepath.Join(dbDir, REQUEST_LOG_BASE_DIR)
err := os.MkdirAll(mainDbDir, 0744)
if err != nil {
return nil, err
}
previousLog, err := NewRequestLogDb(getRequestLogDirForDate(requestLogDir, time.Now().Add(-time.Hour*24)))
if err != nil {
return nil, err
}
currentLog, err := NewRequestLogDb(getRequestLogDirForDate(requestLogDir, time.Now()))
if err != nil {
return nil, err
}
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(ONE_GIGABYTE))
opts.SetCreateIfMissing(true)
opts.SetBlockSize(TWO_FIFTY_SIX_KILOBYTES)
filter := levigo.NewBloomFilter(BLOOM_FILTER_BITS_PER_KEY)
opts.SetFilterPolicy(filter)
db, err := levigo.Open(dbDir, opts)
if err != nil {
return nil, err
}
ro := levigo.NewReadOptions()
lastIdBytes, err2 := db.Get(ro, NEXT_ID_KEY)
if err2 != nil {
return nil, err2
}
lastId := uint64(0)
if lastIdBytes != nil {
lastId, err2 = binary.ReadUvarint(bytes.NewBuffer(lastIdBytes))
if err2 != nil {
return nil, err2
}
}
wo := levigo.NewWriteOptions()
leveldbStore := &LevelDbDatastore{
db: db,
lastIdUsed: lastId,
readOptions: ro,
writeOptions: wo,
requestLogDir: requestLogDir,
currentRequestLog: currentLog,
previousRequestLog: previousLog}
go leveldbStore.periodicallyRotateRequestLog()
return leveldbStore, nil
}
func (conn *DbConnection) open(path string) error {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(3 << 10))
opts.SetCreateIfMissing(true)
var err error
conn.db, err = levigo.Open(path, opts)
conn.ro = levigo.NewReadOptions()
conn.wo = levigo.NewWriteOptions()
return err
}
/*
CreateDB creates a db at provided dbpath.
*/
func CreateDB(dbpath string) *levigo.DB {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(1 << 10))
opts.SetCreateIfMissing(true)
db, err := levigo.Open(dbpath, opts)
if err != nil {
errMsg := fmt.Sprintf("DB %s Creation failed. %q", dbpath, err)
golerror.Boohoo(errMsg, true)
}
return db
}
func (buckets *Database) GetBucket(name string) (*levigo.DB, error) {
if db, ok := buckets.DBMap[name]; ok {
return db, nil
}
opts := levigo.NewOptions()
opts.SetCreateIfMissing(true)
opts.SetCache(levigo.NewLRUCache(4194304))
var err error
buckets.DBMap[name], err = levigo.Open(path.Join(buckets.BaseLocation, name), opts)
return buckets.DBMap[name], err
}
func openDB() {
opts := levigo.NewOptions()
cache := levigo.NewLRUCache(128 * 1024 * 1024) // 128MB cache
opts.SetCache(cache)
filter := levigo.NewBloomFilter(10)
opts.SetFilterPolicy(filter)
opts.SetCreateIfMissing(true)
var err error
DB, err = levigo.Open("db", opts)
maybeFatal(err)
}
// Create creates a new Log at location
func Create(location string) (LogStore, error) {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(CACHE_SIZE))
opts.SetCreateIfMissing(true)
db, err := levigo.Open(location, opts)
if err != nil {
return nil, err
}
opts.Close()
logStore := &levelDbLogStore{localDb: db, nextIndex: &utils.AtomicI64{Value: 1}, firstIndex: &utils.AtomicI64{Value: 0}}
return LogStore(logStore), err
}
func getDB() *levigo.DB {
if db == nil {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(3 << 30))
opts.SetCreateIfMissing(true)
_db, err := levigo.Open(appConfig.DbPath, opts)
if err != nil {
log.Fatalln("can not open database, ", err)
}
db = _db
}
return db
}
func openDb(path string) (*levigo.DB, error) {
opts := levigo.NewOptions()
opts.SetCreateIfMissing(true)
opts.SetFilterPolicy(levigo.NewBloomFilter(16))
opts.SetCache(levigo.NewLRUCache(10490000))
opts.SetMaxOpenFiles(500)
opts.SetWriteBufferSize(62914560)
opts.SetEnv(levigo.NewDefaultEnv())
dbn, err := levigo.Open(path, opts)
if err != nil {
return nil, fmt.Errorf("failed to open db at %s: %v\n", path, err)
}
return dbn, nil
}
func db_create() *levigo.DB {
defer un(trace("db create"))
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(3 << 30))
opts.SetCreateIfMissing(true)
db, _ := levigo.Open("/tmp/leveldb", opts)
ro := levigo.NewReadOptions()
wo := levigo.NewWriteOptions()
db.Put(wo, []byte("key1"), []byte("val1"))
data, _ := db.Get(ro, []byte("key1"))
fmt.Println(string(data))
return db
}
func (dm *DataMigrator) getShard(name string) (*LevelDbShard, error) {
dbDir := dm.shardDir(name)
cache := levigo.NewLRUCache(int(2000))
opts := levigo.NewOptions()
opts.SetCache(cache)
opts.SetCreateIfMissing(true)
opts.SetMaxOpenFiles(1000)
ldb, err := levigo.Open(dbDir, opts)
if err != nil {
return nil, err
}
return NewLevelDbShard(ldb, dm.config.StoragePointBatchSize, dm.config.StorageWriteBatchSize)
}
func TestCloseAndDeleteDB(t *testing.T) {
dbpath := "/tmp/delete-this-leveldb"
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(1 << 10))
opts.SetCreateIfMissing(true)
db, err := levigo.Open(dbpath, opts)
if err != nil {
t.Error(fmt.Sprintf("Fail: (CloseAndDeleteDB) DB %s Creation failed. %q", dbpath, err))
}
CloseAndDeleteDB(dbpath, db)
if _, err := os.Stat(dbpath); err == nil {
t.Error("Fail: CreateDB ain't working.")
}
}
func main() {
runtime.GOMAXPROCS(6)
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(1E9))
opts.SetCreateIfMissing(true)
db, err := levigo.Open("tmp/db", opts)
if err != nil {
panic(err)
}
defer db.Close()
writer := NewDbWriter(db)
cache := NewInputCache(writer)
NewInputSimulator(cache.Input, 500, 1)
select {}
}
func SetupDB() {
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(1024))
opts.SetCreateIfMissing(true)
db, err := levigo.Open("./db/tmp", opts)
if err != nil {
log.Panicln(err)
}
requestChan = make(chan RequestCommand)
go func() {
levelDBWorker(db, requestChan)
db.Close()
}()
}
func NewRequestLogDb(dir string) (*requestLogDb, error) {
err := os.MkdirAll(dir, 0744)
if err != nil {
return nil, err
}
opts := levigo.NewOptions()
opts.SetCache(levigo.NewLRUCache(ONE_MEGABYTE))
opts.SetCreateIfMissing(true)
opts.SetBlockSize(TWO_FIFTY_SIX_KILOBYTES)
filter := levigo.NewBloomFilter(BLOOM_FILTER_BITS_PER_KEY)
opts.SetFilterPolicy(filter)
db, err := levigo.Open(dir, opts)
if err != nil {
return nil, err
}
return &requestLogDb{dir: dir, db: db}, nil
}
