本文整理汇总了Golang中github.com/syndtr/goleveldb/leveldb.RecoverFile函数的典型用法代码示例。如果您正苦于以下问题:Golang RecoverFile函数的具体用法?Golang RecoverFile怎么用?Golang RecoverFile使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了RecoverFile函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: NewLDBDatabase
// 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
}
示例2: Recover
func (pdb *PDB) Recover() {
db, err := leveldb.RecoverFile(DB_PATH, nil)
pdb.db = *db
if err != nil {
log.Fatal("Error recovering db!", err)
}
}
示例3: Open
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
}
示例4: open
func (l *LevelDb) open() error {
l.Lock()
defer l.Unlock()
var err error
if l.db == nil {
l.G().Log.Debug("+ LevelDb.open")
fn := l.GetFilename()
l.G().Log.Debug("| Opening LevelDB for local cache: %v %s", l, fn)
l.db, err = leveldb.OpenFile(fn, nil)
if err != nil {
if _, ok := err.(*errors.ErrCorrupted); ok {
l.G().Log.Debug("| LevelDB was corrupted; attempting recovery (%v)", err)
l.db, err = leveldb.RecoverFile(fn, nil)
if err != nil {
l.G().Log.Debug("| Recovery failed: %v", err)
} else {
l.G().Log.Debug("| Recovery succeeded!")
}
}
}
l.G().Log.Debug("- LevelDb.open -> %s", ErrToOk(err))
}
return err
}
示例5: Repair
func (s Store) Repair(path string, cfg *config.Config) error {
db, err := leveldb.RecoverFile(path, newOptions(&cfg.LevelDB))
if err != nil {
return err
}
db.Close()
return nil
}
示例6: dumpLeveldb
func dumpLeveldb(path string) error {
db, err := leveldb.OpenFile(path, &opt.Options{
ErrorIfMissing: true,
})
if err != nil {
if _, ok := err.(*leveldb_errors.ErrCorrupted); !ok {
return err
}
log.Printf("Database is corrupted, trying to recover\n")
db, err = leveldb.RecoverFile(path, nil)
if err != nil {
return fmt.Errorf("Could not recover database: %v\n", err)
}
}
defer db.Close()
i := db.NewIterator(nil, nil)
defer i.Release()
var rlog raft.Log
if i.Last() {
for bytes.HasPrefix(i.Key(), []byte("stablestore-")) {
i.Prev()
}
for {
if err := json.Unmarshal(i.Value(), &rlog); err != nil {
log.Fatalf("Corrupted database: %v\n", err)
}
if rlog.Type == raft.LogCommand {
rmsg := types.NewRobustMessageFromBytes(rlog.Data)
lastModified = time.Unix(0, rmsg.Id.Id)
break
}
i.Prev()
}
}
i.First()
fmt.Printf(fmt.Sprintf("%%%ds", padding)+"\tValue\n", "Key")
for i.Next() {
if bytes.HasPrefix(i.Key(), []byte("stablestore-")) {
// TODO: also dump the stablestore values
} else {
if err := json.Unmarshal(i.Value(), &rlog); err != nil {
log.Fatalf("Corrupted database: %v\n", err)
}
dumpLog(binary.BigEndian.Uint64(i.Key()), &rlog)
}
}
return nil
}
示例7: NewLDBDatabase
// NewLDBDatabase returns a LevelDB wrapped object. LDBDatabase does not persist data by
// it self but requires a background poller which syncs every X. `Flush` should be called
// when data needs to be stored and written to disk.
func NewLDBDatabase(file string) (*LDBDatabase, error) {
// Open the db
db, err := leveldb.OpenFile(file, &opt.Options{OpenFilesCacheCapacity: OpenFileLimit})
// check for corruption and attempt to recover
if _, iscorrupted := err.(*errors.ErrCorrupted); iscorrupted {
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
}
示例8: init
func (db *GoLevelDB) init(path string, conf *Config, repair bool) error {
if conf == nil {
conf = NewDefaultConfig()
}
// Create path if not exists first
if err := os.MkdirAll(path, 0700); err != nil {
return errors.Trace(err)
}
opts := &opt.Options{}
opts.ErrorIfMissing = false
opts.ErrorIfExist = false
opts.Filter = filter.NewBloomFilter(conf.BloomFilterSize)
opts.Compression = opt.SnappyCompression
opts.BlockSize = conf.BlockSize
opts.WriteBuffer = conf.WriteBufferSize
opts.OpenFilesCacheCapacity = conf.MaxOpenFiles
opts.CompactionTableSize = 32 * 1024 * 1024
opts.WriteL0SlowdownTrigger = 16
opts.WriteL0PauseTrigger = 64
db.path = path
db.opts = opts
db.ropt = nil
db.wopt = nil
if repair {
if rdb, err := leveldb.RecoverFile(db.path, db.opts); err != nil {
return errors.Trace(err)
} else {
db.lvdb = rdb
return nil
}
}
var err error
if db.lvdb, err = leveldb.OpenFile(path, db.opts); err != nil {
return errors.Trace(err)
}
return nil
}
示例9: NewLevelDBStore
// NewLevelDBStore opens a leveldb at the given directory to be used as a log-
// and stable storage for raft.
func NewLevelDBStore(dir string, errorIfExist bool) (*LevelDBStore, error) {
db, err := leveldb.OpenFile(dir, &opt.Options{ErrorIfExist: errorIfExist})
if err != nil {
if errorIfExist && err == os.ErrExist {
return nil, fmt.Errorf("You specified -singlenode or -join, but %q already contains data, indicating this node is already part of a RobustIRC network. THIS IS UNSAFE! It will lead to split-brain scenarios and data-loss. Please see http://robustirc.net/docs/adminguide.html#_healing_partitions if you are trying to heal a network partition.", dir)
}
if _, ok := err.(*leveldb_errors.ErrCorrupted); !ok {
return nil, fmt.Errorf("could not open: %v", err)
}
db, err = leveldb.RecoverFile(dir, nil)
if err != nil {
return nil, fmt.Errorf("could not recover: %v", err)
}
}
return &LevelDBStore{db: db}, nil
}
示例10: New
// New creates a new *info as Info.
//
// dir is the directory where the leveldb that caches responses will be written.
// client must be an authenticated client to make requests to the Android Build API.
func New(dir string, client *http.Client) (Info, error) {
db, err := leveldb.OpenFile(dir, nil)
if err != nil && errors.IsCorrupted(err) {
db, err = leveldb.RecoverFile(dir, nil)
}
if err != nil {
return nil, fmt.Errorf("Failed to open leveldb at %s: %s", dir, err)
}
c, err := newAndroidCommits(client)
if err != nil {
return nil, fmt.Errorf("Failed to create commits: %s", err)
}
i := &info{db: db, commits: c}
go i.poll()
return i, nil
}
示例11: LoadOrCreateOf
func (this *Index) LoadOrCreateOf(file string) (*Index, error) {
file = this.getFilenameFromFile(file)
//log.Printf("for debug removing : %s", file)
//TODO renewable or recache analyze
//os.RemoveAll(file)
// return this, errors.New("Not implemented")
var err error
//TODO re-get last states
//Uses recover in order to catch also unclosed
//Test upgrade size file to limit operation ???
this.db, err = leveldb.OpenFile(file, &opt.Options{
BlockSize: 32 * opt.KiB,
CompactionTableSize: 2 * opt.MiB,
CompactionTableSizeMultiplier: 8,
CompactionTotalSize: 20 * opt.MiB,
CompactionTotalSizeMultiplier: 10,
CompactionL0Trigger: 8,
})
if err != nil {
log.Printf("There seem to have a problem with the index. Will try to correct that %v", err)
this.db, err = leveldb.RecoverFile(file, &opt.Options{
BlockSize: 32 * opt.KiB,
CompactionTableSize: 2 * opt.MiB,
CompactionTableSizeMultiplier: 8,
CompactionTotalSize: 20 * opt.MiB,
CompactionTotalSizeMultiplier: 10,
CompactionL0Trigger: 8,
})
}
this.batch = new(leveldb.Batch)
this.batch_size = 32 * opt.KiB / (8 * 5)
if err != nil {
log.Printf("%v", err)
}
// stats, _ := this.db.GetProperty("leveldb.stats")
// log.Printf("stats : %v", stats)
return this, nil
}
示例12: openLevelDB
func openLevelDB(filepath string) (*leveldb.DB, error) {
o := &opt.Options{
Filter: filter.NewBloomFilter(10),
Strict: opt.StrictAll,
}
db, err := leveldb.OpenFile(filepath, o)
if err == nil {
return db, nil
}
if _, ok := err.(*errors.ErrCorrupted); ok {
log.Printf("recovering leveldb: %v", err)
db, err = leveldb.RecoverFile(filepath, o)
if err != nil {
log.Printf("failed to recover leveldb: %v", err)
return nil, err
}
return db, nil
}
log.Printf("failed to open leveldb: %v", err)
return nil, err
}
示例13: newPersistentNodeDB
// newPersistentNodeDB creates/opens a leveldb backed persistent node database,
// also flushing its contents in case of a version mismatch.
func newPersistentNodeDB(path string, version int, self NodeID) (*nodeDB, error) {
opts := &opt.Options{OpenFilesCacheCapacity: 5}
db, err := leveldb.OpenFile(path, opts)
if _, iscorrupted := err.(*errors.ErrCorrupted); iscorrupted {
db, err = leveldb.RecoverFile(path, nil)
}
if err != nil {
return nil, err
}
// The nodes contained in the cache correspond to a certain protocol version.
// Flush all nodes if the version doesn't match.
currentVer := make([]byte, binary.MaxVarintLen64)
currentVer = currentVer[:binary.PutVarint(currentVer, int64(version))]
blob, err := db.Get(nodeDBVersionKey, nil)
switch err {
case leveldb.ErrNotFound:
// Version not found (i.e. empty cache), insert it
if err := db.Put(nodeDBVersionKey, currentVer, nil); err != nil {
db.Close()
return nil, err
}
case nil:
// Version present, flush if different
if !bytes.Equal(blob, currentVer) {
db.Close()
if err = os.RemoveAll(path); err != nil {
return nil, err
}
return newPersistentNodeDB(path, version, self)
}
}
return &nodeDB{
lvl: db,
self: self,
quit: make(chan struct{}),
}, nil
}
示例14: NewDriver
// NewDriver create a leveldb store driver
func NewDriver(dbpath string) Driver {
var db *leveldb.DB
var err error
var cache *lru.Cache
_, err = os.Stat(dbpath)
if err == nil || os.IsExist(err) {
db, err = leveldb.RecoverFile(dbpath, nil)
} else {
db, err = leveldb.OpenFile(dbpath, nil)
}
if err != nil {
log.Fatal(err)
}
cache = lru.New(1000)
var RWLocker = new(sync.Mutex)
return Driver{
db: db,
cache: cache,
RWLocker: RWLocker,
}
}
示例15: Open
func Open(file string) (*Instance, error) {
opts := &opt.Options{
OpenFilesCacheCapacity: 100,
WriteBuffer: 4 << 20,
}
if _, err := os.Stat(file); os.IsNotExist(err) {
// The file we are looking to open does not exist. This may be the
// first launch so we should look for an old version and try to
// convert it.
if err := checkConvertDatabase(file); err != nil {
l.Infoln("Converting old database:", err)
l.Infoln("Will rescan from scratch.")
}
}
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), nil
}