Exemple #1
0
func (n *NoteEntry) save() bool {
	appDataDb, err := leveldb.OpenFile(Configs["conf/db.conf"].String("app::path"), nil)
	if err != nil {
		beego.Error(err)
		beego.Critical("unable to open " + Configs["conf/db.conf"].String("app::path"))
		return false
	}
	defer appDataDb.Close()

	tmp := int64(1014)
	if urlCountStr, err := appDataDb.Get([]byte("urlCount"), nil); err == nil {
		tmp, _ = strconv.ParseInt(string(urlCountStr), 10, 64)
	}

	if tmp < urlCount && appDataDb.Put([]byte("urlCount"), []byte(strconv.FormatInt(urlCount, 10)), nil) != nil {
		beego.Critical("unable to save to db")
		return false
	}

	urlDb, err := leveldb.OpenFile(Configs["conf/db.conf"].String("url::path"), nil)
	if err != nil {
		beego.Critical("unable to open " + Configs["conf/db.conf"].String("url::path"))
		return false
	}
	defer urlDb.Close()

	if buf, err := json.Marshal(n.toPublic()); err != nil {
		beego.Error("unable to Marshal object", n)
		return false
	} else {
		urlDb.Put([]byte(n.url), buf, nil)
	}

	return true
}
func TestLabelConversion(t *testing.T) {
	os.RemoveAll("testdata/oldformat.db")
	defer os.RemoveAll("testdata/oldformat.db")
	os.RemoveAll("testdata/newformat.db")
	defer os.RemoveAll("testdata/newformat.db")

	if err := unzip("testdata/oldformat.db.zip", "testdata"); err != nil {
		t.Fatal(err)
	}

	odb, err := leveldb.OpenFile("testdata/oldformat.db", nil)
	if err != nil {
		t.Fatal(err)
	}

	ldb, err := leveldb.OpenFile("testdata/newformat.db", nil)
	if err != nil {
		t.Fatal(err)
	}

	if err = convertKeyFormat(odb, ldb); err != nil {
		t.Fatal(err)
	}
	ldb.Close()
	odb.Close()

	inst, err := Open("testdata/newformat.db")
	if err != nil {
		t.Fatal(err)
	}

	fs := NewFileSet("default", inst)
	files, deleted, _ := fs.GlobalSize()
	if files+deleted != 953 {
		// Expected number of global entries determined by
		// ../../bin/stindex testdata/oldformat.db/ | grep global | grep -c default
		t.Errorf("Conversion error, global list differs (%d != 953)", files+deleted)
	}

	files, deleted, _ = fs.LocalSize()
	if files+deleted != 953 {
		t.Errorf("Conversion error, device list differs (%d != 953)", files+deleted)
	}

	f := NewBlockFinder(inst)
	// [block] F:"default" H:1c25dea9003cc16216e2a22900be1ec1cc5aaf270442904e2f9812c314e929d8 N:"f/f2/f25f1b3e6e029231b933531b2138796d" I:3
	h := []byte{0x1c, 0x25, 0xde, 0xa9, 0x00, 0x3c, 0xc1, 0x62, 0x16, 0xe2, 0xa2, 0x29, 0x00, 0xbe, 0x1e, 0xc1, 0xcc, 0x5a, 0xaf, 0x27, 0x04, 0x42, 0x90, 0x4e, 0x2f, 0x98, 0x12, 0xc3, 0x14, 0xe9, 0x29, 0xd8}
	found := 0
	f.Iterate([]string{"default"}, h, func(folder, file string, idx int32) bool {
		if folder == "default" && file == filepath.FromSlash("f/f2/f25f1b3e6e029231b933531b2138796d") && idx == 3 {
			found++
		}
		return true
	})
	if found != 1 {
		t.Errorf("Found %d blocks instead of expected 1", found)
	}

	inst.Close()
}
Exemple #3
0
func leveldbOpener(url *config.URL) (driver.Driver, error) {
	value := url.Value
	if !filepath.IsAbs(value) {
		value = pathutil.Relative(value)
	}
	opts := &opt.Options{}
	if url.Fragment["nocompress"] != "" {
		opts.Compression = opt.NoCompression
	}
	if url.Fragment["nocreate"] != "" {
		opts.ErrorIfMissing = true
	}
	filesDir := filepath.Join(value, "files")
	files, err := leveldb.OpenFile(filesDir, opts)
	if err != nil {
		return nil, err
	}
	copts := *opts
	copts.Filter = filter.NewBloomFilter(8 * sha1.Size)
	chunksDir := filepath.Join(value, "chunks")
	chunks, err := leveldb.OpenFile(chunksDir, &copts)
	if err != nil {
		return nil, err
	}
	return &leveldbDriver{
		files:  files,
		chunks: chunks,
		dir:    value,
	}, nil
}
Exemple #4
0
func serverMain() {
	// Database to store file version
	db, _ := leveldb.OpenFile("$GOPATH/src/github.com/aakashdeshpande/cs733/assignment1/versionMap", nil)
	files, _ := leveldb.OpenFile("$GOPATH/src/github.com/aakashdeshpande/cs733/assignment1/files", nil)
	expiry, _ := leveldb.OpenFile("$GOPATH/src/github.com/aakashdeshpande/cs733/assignment1/expiryTimes", nil)
	defer db.Close()
	defer files.Close()
	defer expiry.Close()

	var mutex = &sync.RWMutex{}

	// Listen for TCP connection on port 8080
	ln, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("Error listening:", err.Error())
		os.Exit(1)
	}

	// Keep listening for new connections
	for {
		conn, err := ln.Accept()
		if err != nil {
			fmt.Println("Error accepting: ", err.Error())
			os.Exit(1)
		}
		// Handle new connection in a new thread
		go handleConnection(conn, db, files, expiry, mutex)
	}

}
func Open(file string) (*Instance, error) {
	opts := &opt.Options{
		OpenFilesCacheCapacity: 100,
		WriteBuffer:            4 << 20,
	}

	db, err := leveldb.OpenFile(file, opts)
	if leveldbIsCorrupted(err) {
		db, err = leveldb.RecoverFile(file, opts)
	}
	if leveldbIsCorrupted(err) {
		// The database is corrupted, and we've tried to recover it but it
		// didn't work. At this point there isn't much to do beyond dropping
		// the database and reindexing...
		l.Infoln("Database corruption detected, unable to recover. Reinitializing...")
		if err := os.RemoveAll(file); err != nil {
			return nil, err
		}
		db, err = leveldb.OpenFile(file, opts)
	}
	if err != nil {
		return nil, err
	}

	return newDBInstance(db, file), nil
}
Exemple #6
0
func serverMain() {

	// Setting the port to listen on
	sock, err := net.Listen(CONNECTION_TYPE, HOST+":"+PORT)
	if err != nil {
		log.Print("Error in listening:", err.Error())
	}

	// Close the listener when the application closes.
	defer sock.Close()
	log.Println("Listening on " + HOST + ":" + PORT + " for incoming connections")

	datadb, err := leveldb.OpenFile("datadb", nil)
	defer datadb.Close()
	metadatadb, err := leveldb.OpenFile("metadatadb", nil)
	defer metadatadb.Close()

	// Keep listening for incoming connections
	for {
		conn, err := sock.Accept()
		if err != nil {
			log.Println("Error while accepting incoming connection: ", err.Error())
		}

		// Connections handled in new goroutine
		go request_handler(conn, datadb, metadatadb)
	}
}
Exemple #7
0
func (rn *RaftNode) ShutDown() {
	rn.quitCh <- true
	rn.sm.status = "Closed"
	// Database to store currentTerm
	db1, _ := leveldb.OpenFile("currentTerm", nil)
	defer db1.Close()
	// Database to store votedFor
	db2, _ := leveldb.OpenFile("votedFor", nil)
	defer db2.Close()

	db1.Put([]byte(strconv.FormatInt(rn.sm.id, 10)), []byte(strconv.FormatInt(rn.sm.Term, 10)), nil)
	db2.Put([]byte(strconv.FormatInt(rn.sm.id, 10)), []byte(strconv.FormatInt(rn.sm.votedFor, 10)), nil)

	out := CommitInfo{nil, -1, errors.New("Stop"), false}
	rn.commitCh <- out

	close(rn.clientCh)
	close(rn.commitCh)

	//fmt.Println("Stopped ", rn.Id)
	close(rn.actionCh)
	close(rn.quitCh)

	rn.timer.Stop()
	rn.server.Close()
	rn.lg.Close()
}
Exemple #8
0
func NewStateMachine(servers int64, id int64, actionCh chan events, electionTimeout int, lg *log.Log) *StateMachine {
	var sm *StateMachine = new(StateMachine)
	sm.servers = servers
	sm.id = id
	sm.status = "Follower"

	currentTerm, _ := leveldb.OpenFile("currentTerm", nil)
	defer currentTerm.Close()
	// Database to store votedFor
	voted, _ := leveldb.OpenFile("votedFor", nil)
	defer voted.Close()
	//sm.currentTerm = currentTerm
	//defer sm.currentTerm.Close()
	Term, err := currentTerm.Get([]byte(strconv.FormatInt(sm.id, 10)), nil)
	if err == nil {
		sm.Term, _ = strconv.ParseInt(string(Term), 10, 64)
	} else {
		sm.Term = int64(0)
	}

	//sm.voted = voted
	//defer sm.voted.Close()
	vote, err := voted.Get([]byte(strconv.FormatInt(sm.id, 10)), nil)
	if err == nil {
		sm.votedFor, _ = strconv.ParseInt(string(vote), 10, 64)
	} else {
		sm.votedFor = int64(-1)
	}

	sm.log = make([][]byte, 10000000)
	sm.logTerm = make(map[int64]int64)

	size := lg.GetLastIndex() + 1
	if size == 0 {
		sm.LastLogIndex = -1
		sm.LastLogTerm = 0
	} else {
		for i := int64(0); i < size; i++ {
			b, _ := lg.Get(i)
			var entry LogInfo
			json.Unmarshal(b.([]byte), &entry)
			sm.log[i] = entry.Data
			sm.logTerm[i] = entry.Term
		}
		sm.LastLogIndex = size - 1
		sm.LastLogTerm = sm.logTerm[size-1]
	}

	sm.commitIndex = -1
	sm.actionCh = actionCh
	sm.electionTimeout = time.Millisecond * time.Duration(electionTimeout)
	sm.votesMap = make(map[int64]int)
	sm.nextIndex = make(map[int64]int64)
	sm.matchIndex = make(map[int64]int64)
	//sm.acksRecieved = make(map[int64]int64)
	return sm
}
Exemple #9
0
func NewStateMachine(id int, peerIds []int, electionTimeout float64, heartbeatTimeout float64, lg *log.Log) *StateMachine {
	sm := StateMachine{
		ServerID:     id,
		State:        "follower",
		VoteGranted:  make(map[int]bool),
		NextIndex:    make(map[int]int),
		MatchIndex:   make(map[int]int),
		updateCh:     make(chan interface{}, 250000),
		netCh:        make(chan interface{}, 250000),
		actionCh:     make(chan interface{}, 250000),
		LastLogIndex: -1,
		CommitIndex:  -1,
		PeerIds:      peerIds,
		Log:          make([]LogEntry, 0), //see
	}

	sm.ELECTION_TIMEOUT = electionTimeout
	sm.HEARTBEAT_TIMEOUT = heartbeatTimeout
	NUMBER_OF_NODES = len(peerIds)

	CurrentTermDB, _ := leveldb.OpenFile(PATH+"/currentTerm", nil)
	defer CurrentTermDB.Close()

	termStr, err := CurrentTermDB.Get([]byte(strconv.FormatInt(int64(sm.ServerID), 10)), nil)
	if err == nil {
		sm.CurrentTerm, _ = strconv.Atoi(string(termStr))
	} else {
		sm.CurrentTerm = int(0)
	}

	VotedForDB, _ := leveldb.OpenFile(PATH+"/votedFor", nil)
	defer VotedForDB.Close()

	votedForStr, err := VotedForDB.Get([]byte(strconv.Itoa(sm.ServerID)), nil)
	if err == nil {
		sm.VotedFor, _ = strconv.Atoi(string(votedForStr))
	} else {
		sm.VotedFor = int(0)
	}

	lastIndex := int(lg.GetLastIndex())
	//fmt.Println("last index is ", lastIndex)
	if lastIndex != -1 {
		var i int
		for i = 0; i <= lastIndex; i++ {
			b, _ := lg.Get(int64(i)) //see
			// entry := b.([]byte).(LogEntry)
			var entry LogEntry
			json.Unmarshal(b.([]byte), &entry)
			sm.Log = append(sm.Log, entry) //see
		}
		sm.LastLogIndex = lastIndex
		sm.LastLogTerm = sm.getLogTerm(lastIndex)
	}

	return &sm
}
Exemple #10
0
func (m *Machine) loadDataFromLevelDB() (*leveldb.DB, *leveldb.DB) {

	fmt.Println("Loading Values from KVStores : logKVStore , dataKVStore")
	fmt.Println("Opening Store : ", "logKVStore"+strconv.Itoa(m.server.Pid()))
	// Remember that the contents of the returned slice should not be modified.
	logKVStore, err1 := leveldb.OpenFile("logKVStore"+strconv.Itoa(m.server.Pid()), nil)

	if err1 != nil {
		fmt.Println("\nError :- ", err1)
	} else {

		dataKVStore, err2 := leveldb.OpenFile("dataKVStore"+strconv.Itoa(m.server.Pid()), nil)
		if err2 != nil {
			fmt.Println("\nError :- ", err2)
		} else {

			m.LastLogIndex = -1
			m.CommitIndex = -1
			m.LastApplied = -1

			logIter := logKVStore.NewIterator(nil, nil)

			for logIter.Next() {
				// only valid until the next call to Next.
				key := logIter.Key()
				value := logIter.Value()
				//fmt.Println("\nKey : ",key," , Value : ",value)

				logKey, _ := strconv.Atoi(string(key))

				tempvalueKeyPart := strings.Split(string(value), ":")
				valueKeyPart, _ := strconv.Atoi(tempvalueKeyPart[0])

				logEntryValue := cluster.LogEntry{Index: int64(logKey), Term: valueKeyPart, Data: tempvalueKeyPart[1]}

				m.Log = append(m.Log, logEntryValue)

				m.CommitIndex += 1
			}

			if m.CommitIndex != -1 {
				m.LastLogIndex = m.CommitIndex
				m.LastApplied = m.CommitIndex
				m.term = m.Log[m.CommitIndex].Term
			} else {
				m.term = 0
			}

			//fmt.Println("Total Log Now : ",m.Log)
			return logKVStore, dataKVStore
		}

	}

	return nil, nil
}
Exemple #11
0
func NewFS(Id int, receiver []chan Response, input <-chan CommitInfo) *FileService {
	var f *FileService = &FileService{}
	f.Id = int64(Id)
	f.receiver = receiver
	f.input = input
	f.datadb, _ = leveldb.OpenFile("datadb"+strconv.Itoa(Id), nil)
	f.metadatadb, _ = leveldb.OpenFile("metadatadb"+strconv.Itoa(Id), nil)
	f.mutex = &sync.RWMutex{}
	return f
}
Exemple #12
0
func (rn *RaftNode) fSaveTerm(i int) {
	var currentTermDB *leveldb.DB
	var err error
	currentTermDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	for err != nil {
		currentTermDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	}
	// fmt.Println("sad", currentTermDB, reflect.TypeOf(currentTermDB), err, reflect.TypeOf(err))
	defer currentTermDB.Close()
	currentTermDB.Put([]byte(strconv.Itoa(rn.sm.ServerID)), []byte(strconv.Itoa(i)), nil)

}
Exemple #13
0
func NewFS(Id int, routes []chan Response, input <-chan CommitInfo) *FileService {
	var f *FileService = &FileService{}
	f.Id = int64(Id)
	f.routes = routes
	f.input = input
	// Database to store file version
	f.db, _ = leveldb.OpenFile("versionMap"+strconv.Itoa(Id), nil)
	f.files, _ = leveldb.OpenFile("files"+strconv.Itoa(Id), nil)
	f.expiry, _ = leveldb.OpenFile("expiryTimes"+strconv.Itoa(Id), nil)
	f.mutex = &sync.RWMutex{}
	return f
}
Exemple #14
0
func (rn *RaftNode) fSaveVotedFor(i int) {

	var votedForDB *leveldb.DB
	var err error
	votedForDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	for err != nil {
		votedForDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	}

	defer votedForDB.Close()
	votedForDB.Put([]byte(strconv.Itoa(rn.sm.ServerID)), []byte(strconv.Itoa(i)), nil)
}
Exemple #15
0
// ListenAndServe starts an instance of the API with a
// heimdall configuration.
func ListenAndServe(config *heimdall.Config) {

	authdb, err := leveldb.OpenFile(config.Auth.DBPath, nil)
	if err != nil {
		log.Fatal(err)
	}
	auth := authentication.Authenticator{authdb}

	blacklistdb, err := leveldb.OpenFile(config.Blacklist.DBPath, nil)
	if err != nil {
		log.Fatal(err)
	}
	blacklist := persistence.OpenDB(blacklistdb)

	whitelistdb, err := leveldb.OpenFile(config.Whitelist.DBPath, nil)
	if err != nil {
		log.Fatal(err)
	}
	whitelist := persistence.OpenDB(whitelistdb)

	environment := NewEnvironment(whitelist, blacklist, &auth)

	blistTTL, _ := time.ParseDuration(config.Blacklist.DefaultTTL)
	wlistTTL, _ := time.ParseDuration(config.Whitelist.DefaultTTL)

	blistHandler := Blacklist{&environment, config.Blacklist.Path, blistTTL}
	wlistHandler := Whitelist{&environment, config.Whitelist.Path, wlistTTL}

	http.Handle(blistHandler.Path, &blistHandler)
	http.Handle(wlistHandler.Path, &wlistHandler)

	pruneInterval, _ := time.ParseDuration(config.CleanupInterval)

	go blacklist.AutoPrune(pruneInterval)
	go whitelist.AutoPrune(pruneInterval)

	if config.PanOS.Enabled {
		var panosAllowedHosts []net.IP

		for _, host := range config.PanOS.AllowedHosts {
			panosAllowedHosts = append(panosAllowedHosts, net.ParseIP(host))
		}

		panosHandler := PanOS{&environment, config.PanOS.Path, panosAllowedHosts}
		http.Handle(config.PanOS.Path, &panosHandler)
	}

	if err := http.ListenAndServeTLS(config.Port, config.Cert, config.Key, nil); err != nil {
		log.Fatal(err)
	}
}
Exemple #16
0
func createNewLevelDB(path string, _ graph.Options) error {
	opts := &opt.Options{}
	db, err := leveldb.OpenFile(path, opts)
	if err != nil {
		clog.Errorf("Error: could not create database: %v", err)
		return err
	}
	defer db.Close()
	qs := &QuadStore{}
	qs.db = db
	qs.writeopts = &opt.WriteOptions{
		Sync: true,
	}
	qs.readopts = &opt.ReadOptions{}
	_, err = qs.db.Get([]byte(horizonKey), qs.readopts)
	if err != nil && err != leveldb.ErrNotFound {
		clog.Errorf("couldn't read from leveldb during init")
		return err
	}
	if err != leveldb.ErrNotFound {
		return graph.ErrDatabaseExists
	}
	// Write some metadata
	qs.Close()
	return nil
}
Exemple #17
0
func NewFileListInLevelDb(dir string) (fl *FileListInLevelDb, err error) {
	fl = &FileListInLevelDb{}
	if fl.db, err = leveldb.OpenFile(dir, nil); err != nil {
		return
	}
	return
}
// NewLDBDatabase returns a LevelDB wrapped object.
func NewLDBDatabase(file string, cache int, handles int) (*LDBDatabase, error) {
	// Calculate the cache and file descriptor allowance for this particular database
	cache = int(float64(cache) * cacheRatio[filepath.Base(file)])
	if cache < 16 {
		cache = 16
	}
	handles = int(float64(handles) * handleRatio[filepath.Base(file)])
	if handles < 16 {
		handles = 16
	}
	glog.V(logger.Info).Infof("Alloted %dMB cache and %d file handles to %s", cache, handles, file)

	// Open the db and recover any potential corruptions
	db, err := leveldb.OpenFile(file, &opt.Options{
		OpenFilesCacheCapacity: handles,
		BlockCacheCapacity:     cache / 2 * opt.MiB,
		WriteBuffer:            cache / 4 * opt.MiB, // Two of these are used internally
		Filter:                 filter.NewBloomFilter(10),
	})
	if _, corrupted := err.(*errors.ErrCorrupted); corrupted {
		db, err = leveldb.RecoverFile(file, nil)
	}
	// (Re)check for errors and abort if opening of the db failed
	if err != nil {
		return nil, err
	}
	return &LDBDatabase{
		fn: file,
		db: db,
	}, nil
}
Exemple #19
0
func (pdb *PDB) open() {
	db, err := leveldb.OpenFile(DB_PATH, nil)
	if err != nil {
		log.Fatalf("Error opening db! %s\n", err)
	}
	pdb.db = *db
}
Exemple #20
0
/*
	/Open the DATABASE
	/return leveldb Object
*/
func dbOpen() *leveldb.DB {
	temp, openError := leveldb.OpenFile("/Users/takumigashira/test.ldb", nil)
	if openError != nil {
		fmt.Println("DB Open ERROR")
	}
	return temp
}
Exemple #21
0
func New(mo store.MergeOperator, config map[string]interface{}) (store.KVStore, error) {

	path, ok := config["path"].(string)
	if !ok {
		return nil, fmt.Errorf("must specify path")
	}

	opts, err := applyConfig(&opt.Options{}, config)
	if err != nil {
		return nil, err
	}

	db, err := leveldb.OpenFile(path, opts)
	if err != nil {
		return nil, err
	}

	rv := Store{
		path:                path,
		opts:                opts,
		db:                  db,
		mo:                  mo,
		defaultReadOptions:  &opt.ReadOptions{},
		defaultWriteOptions: &opt.WriteOptions{},
	}
	rv.defaultWriteOptions.Sync = true
	return &rv, nil
}
Exemple #22
0
func NewQDB(path string, syncWrites bool) *QDB {
	// Open
	db, err := leveldb.OpenFile(path, nil)
	if err != nil {
		panic(fmt.Sprintf("goq: Unable to open db: %v", err))
	}

	log.Println("goq: Starting health check")

	// Health check each record
	iter := db.NewIterator(nil, nil)
	defer iter.Release()
	for iter.Next() {
		_, err := strconv.Atoi(string(iter.Key()))
		if err != nil {
			panic(fmt.Sprintf("goq: Health check failure (key not int): %s, %s, %v", string(iter.Key()), string(iter.Value()), err))
		}
	}

	// General
	if iter.Error() != nil {
		panic(fmt.Sprintf("goq: Error loading db: %v", err))
	}

	log.Println("goq: Health check successful")

	return &QDB{
		path: path,
		wo:   opt.WriteOptions{Sync: syncWrites},
		db:   db,
	}
}
Exemple #23
0
func main() {
	configPathPtr := flag.String("config", "config.json", "path to config file")
	flag.Parse()

	configReader, err := os.Open(*configPathPtr)
	if err != nil {
		log.Fatalf("Failed to open configuration file: %s", err)
	}
	cfg := &proto.VerifierConfig{}
	err = jsonpb.Unmarshal(configReader, cfg)
	if err != nil {
		log.Fatalf("Failed to parse configuration file: %s", err)
	}

	leveldb, err := leveldb.OpenFile(cfg.LevelDBPath, nil)
	if err != nil {
		log.Fatalf("Couldn't open DB in directory %s: %s", cfg.LevelDBPath, err)
	}
	db := leveldbkv.Wrap(leveldb)

	server, err := verifier.Start(cfg, db, getKey)
	if err != nil {
		panic(err)
	}
	defer server.Stop()

	ch := make(chan os.Signal, 1)
	signal.Notify(ch, os.Interrupt)
	<-ch
}
Exemple #24
0
func newTripleStore(path string, options graph.Options) (graph.TripleStore, error) {
	var ts TripleStore
	ts.path = path
	cache_size := DefaultCacheSize
	if val, ok := options.IntKey("cache_size_mb"); ok {
		cache_size = val
	}
	ts.dbOpts = &opt.Options{
		BlockCache: cache.NewLRUCache(cache_size * opt.MiB),
	}
	ts.dbOpts.ErrorIfMissing = true

	write_buffer_mb := DefaultWriteBufferSize
	if val, ok := options.IntKey("write_buffer_mb"); ok {
		write_buffer_mb = val
	}
	ts.dbOpts.WriteBuffer = write_buffer_mb * opt.MiB
	ts.hasher = sha1.New()
	ts.writeopts = &opt.WriteOptions{
		Sync: false,
	}
	ts.readopts = &opt.ReadOptions{}
	db, err := leveldb.OpenFile(ts.path, ts.dbOpts)
	if err != nil {
		panic("Error, couldn't open! " + err.Error())
	}
	ts.db = db
	glog.Infoln(ts.GetStats())
	ts.getSize()
	return &ts, nil
}
Exemple #25
0
func getDB(p string) (*leveldb.DB, error) {
	var err error
	if p == "" {
		p, err = DefaultCachePath()
		if err != nil {
			return nil, err
		}
	}
	err = mkDir(p)
	var version string
	if err != nil {
		return nil, err
	}
	fp := path.Join(p, dbName)
	mp := path.Join(p, metaName)
	if exists(fp) && exists(mp) {
		b, err := ioutil.ReadFile(mp)
		if err != nil {
			return nil, err
		}
		version = strings.Trim(string(b[:]), "\n\r")
	}
	err = updateDB(version, p)
	if err != nil {
		return nil, err
	}
	db, err := leveldb.OpenFile(fp, nil)
	if err != nil {
		return nil, err
	}
	return db, nil
}
Exemple #26
0
// Open a DB by fileName.
func Open(fileName string) (*DB, error) {
	db, err := leveldb.OpenFile(fileName, nil)
	if err != nil {
		return nil, err
	}
	return &DB{db}, nil
}
Exemple #27
0
func check(count int) bool {
	var allDB [6]*leveldb.DB
	var allDBMAP [6]map[string]string
	var allIterator [6]iterator.Iterator
	for i := 1; i <= count; i++ {
		allDBMAP[i] = make(map[string]string)
		allD, err := leveldb.OpenFile("db_"+strconv.Itoa(i)+".db", nil)
		if err != nil {
			panic(err)
		} else {
			allDB[i] = allD
			allIterator[i] = allD.NewIterator(nil, nil)
		}
	}

	for k := 1; k <= count; k++ {
		for allIterator[k].Next() {

			allDBMAP[k][string(allIterator[k].Key())] = string(allIterator[k].Value())

		}

	}
	for k := 1; k < count; k++ {
		if reflect.DeepEqual(allDBMAP[k], allDBMAP[k+1]) {
			log.Println(reflect.DeepEqual(allDBMAP[k], allDBMAP[k+1]), k)
		} else {
			return false
		}
	}
	return true

}
Exemple #28
0
func newTripleStore(path string, options graph.Options) (graph.TripleStore, error) {
	var qs TripleStore
	var err error
	qs.path = path
	cache_size := DefaultCacheSize
	if val, ok := options.IntKey("cache_size_mb"); ok {
		cache_size = val
	}
	qs.dbOpts = &opt.Options{
		BlockCache: cache.NewLRUCache(cache_size * opt.MiB),
	}
	qs.dbOpts.ErrorIfMissing = true

	write_buffer_mb := DefaultWriteBufferSize
	if val, ok := options.IntKey("write_buffer_mb"); ok {
		write_buffer_mb = val
	}
	qs.dbOpts.WriteBuffer = write_buffer_mb * opt.MiB
	qs.writeopts = &opt.WriteOptions{
		Sync: false,
	}
	qs.readopts = &opt.ReadOptions{}
	db, err := leveldb.OpenFile(qs.path, qs.dbOpts)
	if err != nil {
		glog.Errorln("Error, couldn't open! ", err)
		return nil, err
	}
	qs.db = db
	glog.Infoln(qs.GetStats())
	err = qs.getMetadata()
	if err != nil {
		return nil, err
	}
	return &qs, nil
}
Exemple #29
0
// Resets all logs and term, votedFor values
func termReset() {
	currentTerm, _ := leveldb.OpenFile("$GOPATH/src/github.com/aakashdeshpande/cs733/assignment3/currentTerm", nil)
	defer currentTerm.Close()
	// Database to store votedFor
	voted, _ := leveldb.OpenFile("$GOPATH/src/github.com/aakashdeshpande/cs733/assignment3/votedFor", nil)
	defer voted.Close()

	for i := 0; i < len(configs.Peers); i++ {
		currentTerm.Put([]byte(strconv.FormatInt(int64(i), 10)), []byte(strconv.FormatInt(int64(0), 10)), nil)
		voted.Put([]byte(strconv.FormatInt(int64(i), 10)), []byte(strconv.FormatInt(int64(-1), 10)), nil)

		lg, _ := log.Open("$GOPATH/src/github.com/aakashdeshpande/cs733/assignment3/Log" + strconv.Itoa(i))
		lg.TruncateToEnd(0)
		lg.Close()
	}
}
Exemple #30
0
// Resets all logs and term, votedFor values
func termReset() {
	currentTerm, _ := leveldb.OpenFile("currentTerm", nil)
	defer currentTerm.Close()
	// Database to store votedFor
	voted, _ := leveldb.OpenFile("votedFor", nil)
	defer voted.Close()

	for i := 0; i < len(configs.Peers); i++ {
		currentTerm.Put([]byte(strconv.FormatInt(int64(i), 10)), []byte(strconv.FormatInt(int64(0), 10)), nil)
		voted.Put([]byte(strconv.FormatInt(int64(i), 10)), []byte(strconv.FormatInt(int64(-1), 10)), nil)

		lg, _ := log.Open("Logs/Log" + strconv.Itoa(i))
		lg.TruncateToEnd(0)
		lg.Close()
	}
}