// Main method. Will panic if things are so bad that the application
// will not start.
func main() {
flag.Parse()
log.Println("Event store to use:", *eventStorePath)
log.Println("Command socket path:", *commandSocketZPath)
log.Println("Event publishing socket path:", *eventPublishZPath)
log.Println()
var stor storage.Storage
if *inMemoryStore {
log.Println("!!! WARNING: Using in-memory store.")
log.Println("!!! Events will not be persisted.")
log.Println()
stor = &storage.MemStorage{}
} else {
stor, err := storage.OpenFile(*eventStorePath)
if err != nil {
log.Panicln("could not create DB storage")
}
defer stor.Close()
}
estore, err := eventstore.New(stor)
if err != nil {
log.Panicln(os.Stderr, "could not create event store")
}
context, err := zmq.NewContext()
if err != nil {
log.Panicln(err)
}
initParams := server.InitParams{
Store: estore,
CommandSocketZPath: commandSocketZPath,
EvPubSocketZPath: eventPublishZPath,
ZMQContext: context,
}
serv, err := server.New(&initParams)
if err != nil {
panic(err.Error())
}
sigchan := make(chan os.Signal, 5)
serverStopper := func() {
sig := <-sigchan
if sig == os.Interrupt {
serv.Stop()
}
}
go serverStopper()
signal.Notify(sigchan)
serv.Start()
serv.Wait()
}
func openSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
if stor == nil || o == nil {
return nil, os.ErrInvalid
}
storLock, err := stor.Lock()
if err != nil {
return
}
s = new(session)
s.stor = stor
s.storLock = storLock
s.cmp = &iComparer{o.GetComparer()}
s.o = newIOptions(s, *o)
s.tops = newTableOps(s, s.o.GetMaxOpenFiles())
s.setVersion(&version{s: s})
return
}
func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
if stor == nil {
return nil, os.ErrInvalid
}
storLock, err := stor.Lock()
if err != nil {
return
}
s = &session{
stor: stor,
storLock: storLock,
}
s.setOptions(o)
s.tops = newTableOps(s, s.o.GetMaxOpenFiles())
s.setVersion(&version{s: s})
return
}
// Creates new initialized session instance.
func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
if stor == nil {
return nil, os.ErrInvalid
}
storLock, err := stor.Lock()
if err != nil {
return
}
s = &session{
stor: stor,
storLock: storLock,
}
s.setOptions(o)
s.tops = newTableOps(s, s.o.GetMaxOpenFiles())
s.setVersion(&version{s: s})
s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock D·DeletedEntry L·Level Q·SeqNum T·TimeElapsed")
return
}
// Creates new initialized session instance.
func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
if stor == nil {
return nil, os.ErrInvalid
}
storLock, err := stor.Lock()
if err != nil {
return
}
s = &session{
stor: stor,
storLock: storLock,
stCompPtrs: make([]iKey, o.GetNumLevel()),
}
s.setOptions(o)
s.tops = newTableOps(s, s.o.GetCachedOpenFiles())
s.setVersion(newVersion(s))
s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed")
return
}
// Creates new initialized session instance.
func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
if stor == nil {
return nil, os.ErrInvalid
}
storLock, err := stor.Lock()
if err != nil {
return
}
s = &session{
stor: stor,
storLock: storLock,
fileRef: make(map[int64]int),
}
s.setOptions(o)
s.tops = newTableOps(s)
s.setVersion(newVersion(s))
s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed")
return
}