func (ahr AddHashRequest) Execute(database *levigo.DB, ro *levigo.ReadOptions, wo *levigo.WriteOptions) (*kminvalues.KMinValues, error) {
if ahr.Key == "" {
return nil, NoKeySpecified
}
keyBytes := []byte(ahr.Key)
data, err := database.Get(ro, keyBytes)
if err != nil {
return nil, err
}
kmv, err := kminvalues.KMinValuesFromBytes(data)
if err != nil {
if len(data) == 0 {
kmv = kminvalues.NewKMinValues(*defaultSize)
} else {
return nil, err
}
}
kmv.AddHash(ahr.Hash)
err = database.Put(wo, keyBytes, kmv.Bytes())
return kmv, err
}
func AddProc(procID int, db *levigo.DB) error {
ro := levigo.NewReadOptions()
wo := levigo.NewWriteOptions()
data, err := db.Get(ro, []byte("procs"))
spdata := bytes.Split(data, []byte(":"))
for i, e := range spdata {
if string(e) != "" {
fmt.Println("ProcID: #", i, string(e))
pid, err := strconv.Atoi(string(e))
if err != nil {
return err
}
if pid == procID {
return errors.New("Process already exists")
}
if isProcAlive(pid) == false {
removeProc(pid, db)
}
}
if err != nil {
return err
}
}
strdata := string(data)
strdata = strdata + ":" + strconv.Itoa(procID)
err = db.Put(wo, []byte("procs"), []byte(strdata))
return err
}
// Write the datastore version to a shard.
func writeDataStoreVersion(store *dataStore, ldb *levigo.DB, v uint32) error {
w := new(bytes.Buffer)
encoder := gob.NewEncoder(w)
err := encoder.Encode(&v)
if err != nil {
return err
}
return ldb.Put(store.writeOpts, []byte{VERSION_KEY}, w.Bytes())
}
func (sr SetRequest) Execute(database *levigo.DB, ro *levigo.ReadOptions, wo *levigo.WriteOptions) (*KMinValues, error) {
if sr.Key == "" {
return nil, NoKeySpecified
}
keyBytes := []byte(sr.Key)
err := database.Put(wo, keyBytes, sr.Kmv.Bytes())
return sr.Kmv, err
}
func writePlaylistToDB(db *levigo.DB, playlist []playListItem) {
wo := levigo.NewWriteOptions()
m := new(bytes.Buffer)
enc := gob.NewEncoder(m)
enc.Encode(playlist)
err := db.Put(wo, []byte("playlist"), m.Bytes())
if err != nil {
log.Fatal(err)
}
wo.Close()
}
func writeUsersToDB(db *levigo.DB, users map[string]User) {
wo := levigo.NewWriteOptions()
m := new(bytes.Buffer)
enc := gob.NewEncoder(m)
enc.Encode(users)
err := db.Put(wo, []byte("Users"), m.Bytes())
if err != nil {
log.Fatal(err)
}
wo.Close()
}
/*
PushKeyVal push KeyVal in provided DB handle.
*/
func PushKeyVal(key string, val string, db *levigo.DB) bool {
writer := levigo.NewWriteOptions()
defer writer.Close()
keyname := []byte(key)
value := []byte(val)
err := db.Put(writer, keyname, value)
if err != nil {
golerror.Boohoo("Key "+key+" insertion failed. It's value was "+val, false)
return false
}
return true
}
func write_data(data []byte, db *levigo.DB, nitems int, keysize int, valsize int) {
defer un(trace("write data"))
wo := levigo.NewWriteOptions()
keystart := 0
valstart := 0
for i := 0; i < nitems; i++ {
db.Put(wo,
data[keystart:keystart+keysize],
data[valstart:valstart+valsize])
keystart %= (len(data) - keysize)
valstart %= (len(data) - valsize)
}
fmt.Println("Wrote ", nitems, "items with key size", keysize, "and value size", valsize)
}
func (ahr AddHashRequest) Execute(database *levigo.DB, ro *levigo.ReadOptions, wo *levigo.WriteOptions) (*KMinValues, error) {
if ahr.Key == "" {
return nil, NoKeySpecified
}
keyBytes := []byte(ahr.Key)
data, err := database.Get(ro, keyBytes)
if err != nil {
return nil, err
}
kmv := KMinValuesFromBytes(data)
kmv.AddHash(ahr.Hash)
err = database.Put(wo, keyBytes, kmv.Bytes())
return kmv, err
}
func setProcStatus(db *levigo.DB, pid, status int) {
wo := levigo.NewWriteOptions()
key := "status:" + strconv.Itoa(pid)
db.Put(wo, []byte(key), []byte(strconv.Itoa(status)))
}
