func main() { service, err := cocaine.NewService("echo") if err != nil { fmt.Printf("Unable to create service: %s\n", err) return } res, isOpened := <-service.Call("enqueue", "ping", "Hello, World!!!") if !isOpened { fmt.Println("Stream closed") return } if res.Err() != nil { fmt.Printf("Calling error: %s\n", res.Err()) return } var result string err = res.Extract(&result) if err != nil { fmt.Printf("Extraction error: %s", err) return } fmt.Println(result) }
func MustCreateService(name string) *cocaine.Service { service, err := cocaine.NewService(name) if err != nil { panic(fmt.Sprintf("Unable to create Cocaine service %s, but must %v", name, err)) } return service }
func NewAppWrapper(name string, endpoint string) (wa appWrapper, err error) { app, err := cocaine.NewService("flow-tools", endpoint) if err != nil { log.Printf("Error %s", err) return nil, err } wa = &wrappedApp{app} return }
func NewCocaineCache(config *configs.PluginConfig) (Cache, error) { storage, err := cocaine.NewService("storage") if err != nil { return nil, err } c := &CocaineCache{ storage: storage, } return c, nil }
func resolve(appname, endpoint string) <-chan resolveInfo { res := make(chan resolveInfo) go func() { app, err := cocaine.NewService(appname, endpoint) select { case res <- resolveInfo{ slave: NewSlave(app), err: err, }: default: if err == nil { app.Close() } } }() return res }
func main() { binds := map[string]cocaine.EventHandler{ "generate": on_generate, "generate-http": on_http_generate, } Worker, err := cocaine.NewWorker() if err != nil { panic(err) } storage, err = cocaine.NewService("storage") if err != nil { panic(err) } Worker.Loop(binds) }
func (c *cacher) create(name string) (*cocaine.Service, error) { c.mutex.Lock() defer c.mutex.Unlock() s, ok := c.get(name) if ok { return s, nil } s, err := cocaine.NewService(name) if err != nil { return nil, err } data := c.data.Load().(cache) data[name] = s c.data.Store(data) return s, nil }
func (l *localCocaineResolver) Resolve(_ context.Context, name string) (Slave, error) { cachemap := l.cache.Load().(cacheMap) if slave, ok := cachemap[name]; ok { return slave, nil } l.mu.Lock() defer l.mu.Unlock() cachemap = l.cache.Load().(cacheMap) if slave, ok := cachemap[name]; ok { return slave, nil } app, err := cocaine.NewService(name) if err != nil { return nil, err } slv := NewSlave(app) cachemap[name] = slv l.cache.Store(cachemap) return slv, nil }
func Parsing(task Task) (err error) { log := cocaine.NewLogger() log.Info("Start ", task) defer log.Close() //Wrap it log.Debug("Create configuration manager") cfgManager := cocaine.NewService(common.CFGMANAGER) defer cfgManager.Close() log.Debug("Fetch configuration file") res := <-cfgManager.Call("enqueue", "parsing", task.Config) if err = res.Err(); err != nil { return } var rawCfg []byte if err = res.Extract(&rawCfg); err != nil { return } var cfg common.ParsingConfig common.Encode(rawCfg, &cfg) res = <-cfgManager.Call("enqueue", "common", "") if err = res.Err(); err != nil { return } if err = res.Extract(&rawCfg); err != nil { return } var combainerCfg common.CombainerConfig common.Encode(rawCfg, &combainerCfg) common.MapUpdate(&(combainerCfg.CloudCfg.DF), &(cfg.DF)) cfg.DF = combainerCfg.CloudCfg.DF common.MapUpdate(&(combainerCfg.CloudCfg.DS), &(cfg.DS)) cfg.DS = combainerCfg.CloudCfg.DS common.MapUpdate(&(combainerCfg.CloudCfg.DG), &(cfg.DG)) cfg.DG = combainerCfg.CloudCfg.DG fetcherType, err := common.GetType(cfg.DF) if err != nil { return } log.Info(fmt.Sprintf("Use %s for fetching data", fetcherType)) fetcher := cocaine.NewService(fetcherType) defer fetcher.Close() fetcherTask := common.FetcherTask{ Target: task.Host, StartTime: task.PrevTime, EndTime: task.CurrTime, } ft := struct { Config map[string]interface{} "Config" Task common.FetcherTask "Task" }{cfg.DF, fetcherTask} js, _ := common.Pack(ft) res = <-fetcher.Call("enqueue", "get", js) if err = res.Err(); err != nil { return } var t []byte if err = res.Extract(&t); err != nil { return } // ParsingApp stage parserApp := cocaine.NewService(common.PARSINGAPP) defer parserApp.Close() taskToParser, err := common.Pack([]interface{}{cfg.Parser, t}) if err != nil { return } res = <-parserApp.Call("enqueue", "parse", taskToParser) if err = res.Err(); err != nil { return } var z interface{} if err = res.Extract(&z); err != nil { return } // Datagrid stage dgType, err := common.GetType(cfg.DG) if err != nil { return } log.Info(fmt.Sprintf("Use %s for handle data", dgType)) datagrid := cocaine.NewService(dgType) defer datagrid.Close() taskToDatagrid, err := common.Pack([]interface{}{cfg.DG, z}) if err != nil { return } res = <-datagrid.Call("enqueue", "put", taskToDatagrid) if err = res.Err(); err != nil { return } var token string if err = res.Extract(&token); err != nil { return } log.Info(token) defer func() { taskToDatagrid, _ = common.Pack([]interface{}{cfg.DG, token}) <-datagrid.Call("enqueue", "drop", taskToDatagrid) }() log.Info("Stop ", task) return nil }