Esempio n. 1
0
func CreateMarkovChain(prefixlen int, dbpath string, create bool, getchan func() (chan Token, error)) (mc *MarkovChain, err error) {
	var opts = new(kv.Options)
	var conerr error

	mc = new(MarkovChain)
	opts.Compare = bytes.Compare
	mc.prefixLen = prefixlen

	if create {
		mc.CorpusDB, conerr = kv.Create(dbpath, opts)
		if conerr != nil {
			if mc.CorpusDB, conerr = kv.Open(dbpath, opts); conerr != nil {
				err = errors.New(fmt.Sprintf("cannot create new database %s : %s", dbpath, conerr))
				return
			}
		} else {
			c, e := getchan()
			if e != nil {
				mc.CorpusDB.Close()
				os.Remove(dbpath)
				err = nil
				return
			}

			mc.PopulateCorpus(c)
		}
	} else {
		mc.CorpusDB, conerr = kv.Open(dbpath, opts)
		if conerr != nil {
			err = errors.New(fmt.Sprintf("cannot open database %s : %s", dbpath, conerr))
			return
		}
	}
	return
}
Esempio n. 2
0
// OpenAllDb opens all files with the given suffix in the given dir
func OpenAllDb(dir, suffix string) (<-chan *kv.DB, <-chan error) {
	dest := make(chan *kv.DB)
	errch := make(chan error, 1)
	var (
		db  *kv.DB
		err error
		fn  string
	)
	go func() {
		if err = MapDirItems(dir,
			func(fi os.FileInfo) bool {
				return fi.Mode().IsRegular() && (suffix == "" || strings.HasSuffix(fi.Name(), suffix))
			},
			func(fi os.FileInfo) error {
				fn = filepath.Join(dir, fi.Name())
				if db, err = kv.Open(fn, kvOptions); err != nil {
					return err
				}
				dest <- db
				return nil
			}); err != nil {
			errch <- err
		}
		close(dest)
		close(errch)
	}()
	return dest, errch
}
Esempio n. 3
0
File: store.go Progetto: postfix/pw
// Open a store at the given path.
func Open(path string) (*Store, error) {
	db, err := kv.Open(path, nil)
	if err != nil {
		return nil, err
	}

	ret := &Store{
		db: db,
	}
	return ret, nil
}
Esempio n. 4
0
// 打开或者创建KV数据库
// 当path指向的数据库存在时打开该数据库,否则尝试在该路径处创建新数据库
func OpenOrCreateKv(path string, options *kv.Options) (*kv.DB, error) {
	db, errOpen := kv.Open(path, options)
	if errOpen != nil {
		var errCreate error
		db, errCreate = kv.Create(path, options)
		if errCreate != nil {
			return db, errCreate
		}
	}

	return db, nil
}
Esempio n. 5
0
func openKVStorage(path string) (Storage, error) {
	options := &kv.Options{}
	db, errOpen := kv.Open(path, options)
	if errOpen != nil {
		var errCreate error
		db, errCreate = kv.Create(path, options)
		if errCreate != nil {
			return &kvStorage{db}, errCreate
		}
	}
	return &kvStorage{db}, nil
}
Esempio n. 6
0
func main() {

	datastore, err := kv.Open("mpush.kvdb", &kv.Options{})

	if err != nil {
		log.Fatal(err)
	}
	defer datastore.Close()

	wsContainer := restful.NewContainer()

	restful.Filter(globalLogging)

	dsl := DistributionListResource{datastore}
	dsl.Register(wsContainer)

	wsPush := new(restful.WebService)

	wsPush.Path("/api/push")
	wsPush.Route(wsPush.POST("").
		Consumes("application/x-www-form-urlencoded").
		To(func(request *restful.Request, response *restful.Response) { pushHandler(request, response, datastore) }).
		// docs
		Doc("push to a distribution list").
		Param(wsPush.BodyParameter("List", "list to send to").DataType("string")).
		Param(wsPush.BodyParameter("Title", "title of notification").DataType("string")).
		Param(wsPush.BodyParameter("Body", "body of notification").DataType("string")).
		Reads(PushNotification{})) // from the request
	wsContainer.Add(wsPush)

	// static files
	wsStatic := new(restful.WebService)
	wsStatic.Route(wsStatic.GET("/static/{resource}").To(staticFromPathParam))
	wsStatic.Route(wsStatic.GET("/static").To(staticFromQueryParam))
	wsContainer.Add(wsStatic)

	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.
	config := swagger.Config{
		WebServices:    wsContainer.RegisteredWebServices(), // you control what services are visible
		WebServicesUrl: "http://localhost:8080",
		ApiPath:        "/apidocs.json",

		// Optionally, specifiy where the UI is located
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "/home/dgryski/work/src/cvs/swagger-ui/dist"}
	swagger.RegisterSwaggerService(config, wsContainer)

	log.Printf("start listening on localhost:8080")
	server := &http.Server{Addr: ":8080", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}
Esempio n. 7
0
func Open(opts Opts) (c *Client, err error) {
	c = new(Client)
	c.cards, err = readCardData(opts.CardData)
	if err != nil {
		return
	}
	c.db, err = kv.Open(opts.Filename, &kv.Options{})
	if err != nil {
		log.Printf("Creating new database... %v", err)
		c.db, err = kv.Create(opts.Filename, &kv.Options{})
	}
	return
}
Esempio n. 8
0
File: main.go Progetto: andrebq/exp
func mustOpenShellDb(name string) *kv.DB {
	var err error
	var db *kv.DB
	_, err = os.Stat(name)
	if os.IsNotExist(err) {
		db, err = kv.Create(name, &kv.Options{})
	} else if err == nil {
		db, err = kv.Open(name, &kv.Options{})
	}
	if err != nil {
		panic(err)
	}
	return db
}
Esempio n. 9
0
File: db.go Progetto: andrebq/exp
func openOrCreate(dbfile string) (*kv.DB, error) {
	opt := &kv.Options{VerifyDbBeforeOpen: true,
		VerifyDbAfterOpen:   true,
		VerifyDbBeforeClose: true,
		VerifyDbAfterClose:  true}

	if len(dbfile) == 0 {
		// in memory database
		return kv.CreateMem(opt)
	}
	_, err := os.Stat(dbfile)
	if os.IsNotExist(err) {
		return kv.Create(dbfile, opt)
	} else {
		return kv.Open(dbfile, opt)
	}
}
Esempio n. 10
0
func (g *Globals) openDatabases() {
	log.Debug("globals.openDatabases START")
	dbOpts := &kv.Options{
		VerifyDbBeforeOpen:  true,
		VerifyDbAfterOpen:   true,
		VerifyDbBeforeClose: true,
		VerifyDbAfterClose:  true,
	}

	var err error
	if common.FileExists(g.Config.DBFilename) {
		g.db, err = kv.Open(g.Config.DBFilename, dbOpts)
	} else {
		g.db, err = kv.Create(g.Config.DBFilename, dbOpts)
	}
	if err != nil {
		log.Error("config.g open db error", "err", err)
		panic("config.g open  db error " + err.Error())
	}
	if u := g.GetUser("admin"); u == nil {
		log.Info("config.g openDatabases creating 'admin' user with password 'admin'")
		admin := &User{
			Login:  "******",
			Name:   "Administrator",
			Role:   "ADMIN",
			Active: true,
		}
		admin.UpdatePassword("admin")
		g.SaveUser(admin)
	} else {
		if !u.Active {
			log.Warn("config.g openDatabases re-active Admin user")
			u.Active = true
			g.SaveUser(u)
		}
	}
	if g.GetUser("admin") == nil {
		panic("missing admin")
	}
	log.Debug("globals.openDatabases DONE")
}
Esempio n. 11
0
func openBucket(filename string) (b wBucket, err error) {
	fh, e := os.Open(filename)
	if e != nil {
		err = e
		return
	}
	fi, e := fh.Stat()
	fh.Close()
	if e != nil {
		err = e
		return
	}
	//b = bucket{filename: filename, created: fi.ModTime()}
	b.filename, b.created = filename, fi.ModTime()
	b.db, err = kv.Open(filename, kvOptions())
	if err != nil {
		err = fmt.Errorf("error opening buckets db %s: %s", filename, err)
		return
	}
	return
}
Esempio n. 12
0
func main() {
	defer func() {
		if r := recover(); r != nil {
			log.Print(r)
		}
	}()
	log.SetFlags(0)
	flag.Parse()

	if *cpuprofile != "" {
		f, err := os.Create(*cpuprofile)
		if err != nil {
			log.Fatal(err)
		}
		pprof.StartCPUProfile(f)
		defer pprof.StopCPUProfile()
	}

	db, err := kv.Create(*dbpath, &kv.Options{})
	if err != nil {
		db, err = kv.Open(*dbpath, &kv.Options{})
		fatalif(err)
	}
	defer db.Close()

	err = db.BeginTransaction()
	fatalif(err)
	defer db.Commit()

	if *list {
		path := path.Join(kvback.TagsPrefix, flag.Arg(0))
		enum, _, _ := db.Seek([]byte(path))
		for {
			key, _, err := enum.Next()
			if err == io.EOF {
				break
			}
			fatalif(err)

			if !bytes.HasPrefix(key, []byte(kvback.TagsPrefix)) {
				break
			}

			fmt.Printf("%s\n", key)
		}
		return
	}

	for _, fname := range flag.Args() {
		fpath, err := filepath.Abs(fname)
		fatalif(err)
		f, err := os.Open(fpath)
		fatalif(err)
		h := kvback.New(db, fpath)
		fatalif(err)

		rs := rollsum.NewCustom(rollsum.DefaultWindow, 1024*8)
		fatalif(rbup.Split(f, rs, h))
		fatalif(f.Close())
	}
}