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()
}

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
}

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
}

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)
	}
}

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()
}

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
}

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
}

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
}

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
}

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)

}

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
}

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)
}

// 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)
	}
}

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
}

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
}

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
}

/*
	/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
}