// NewServer construct rest server listening specific host and port and routes requests by passed routes func NewServer(props properties.Properties, routes PathHandlers) error { bind := props.Get("rest.address") + ":" + props.Get("rest.port") log.Println("start rest server on", bind) listener, err := net.Listen("tcp", bind) if err != nil { return err } s := &server{ listener: listener, m: &sync.Mutex{}, alive: true, wg: &sync.WaitGroup{}, } kit.SafeGo(func() error { router := mux.NewRouter() for path := range routes { mh := handlers.MethodHandler{} for method := range routes[path] { log.Printf("setup rest handler %v %v\n", method, path) mh[method] = s.wrapHandler(routes[path][method]) } router.Path(path).Handler(mh) } handler := http.Handler(router) compression, err := strconv.ParseBool(props.Get("rest.compression")) if err == nil && compression { log.Println("enable compression for rest server") handler = handlers.CompressHandler(handler) } else { log.Println("no compression for rest server") } log.Println("rest server serves") err = http.Serve(listener, handler) if err != nil { return err } return nil }) kit.SafeGo(func() error { <-registry.DoneChannel() s.Stop() return nil }) return nil }
func NewPostgresRepository(props properties.Properties) (Repository, error) { cs := kit.PostgresConnectionString(props) log.Printf("postgres connection string `%s`\n", cs) db, err := sql.Open("postgres", cs) if err != nil { return nil, err } repo := &postgresRepository{ connectionString: cs, db: db, listener: nil, listenChannels: map[string]map[chan string]struct{}{}, m: &sync.RWMutex{}, alive: true, } kit.SafeGo(func() error { <-registry.DoneChannel() repo.Close() return nil }) return repo, nil }
func (d *direct) Forever() { doneCh := registry.DoneChannel() var err error processed := true kit.SafeGo(func() error { for { if processed { select { case <-doneCh: return nil default: } processed, err = d.iter() if err != nil { return err } } else { select { case <-doneCh: return nil case <-d.resumeCh: processed, err = d.iter() if err != nil { return err } } } } }) }
func (repo *postgresRepository) ensureListener() { repo.m.Lock() defer repo.m.Unlock() if repo.listener == nil { repo.listener = pq.NewListener(repo.connectionString, time.Second, time.Minute, nil) kit.SafeGo(repo.listenDaemon) } }
func NewFixedDelayScheduler(initialDelay time.Duration, delay time.Duration) Scheduler { scheduler := &fixedDelayScheduler{ initialDelay: initialDelay, delay: delay, alive: true, doneCh: make(chan struct{}), m: &sync.Mutex{}, wg: &sync.WaitGroup{}, } kit.SafeGo(func() error { <-registry.DoneChannel() scheduler.Stop() return nil }) return scheduler }
func NewDirectEventStore(repo repository.Repository, stream string, consumer string) (EventStore, error) { es := &direct{ repo: repo, stream: stream, consumer: consumer, locker: &sync.RWMutex{}, types: map[string]reflect.Type{}, aggregators: map[string]*list.List{}, rawAggregators: map[string][]AggregatorHandler{}, observers: map[string]*list.List{}, rawObservers: map[string][]ObserverHandler{}, newEventChannelName: "es_" + stream, resumeCh: make(chan struct{}, 1), } kit.SafeGo(es.listen) err := es.setupDB() if err != nil { return nil, err } lastID, err := fetchLastID(repo.DB(), stream, consumer) if err != nil { return nil, err } es.lastID = lastID return es, nil }