func (self *Service) Start() chan bool { //SIGINT or SIGTERM is caught quitChannel := make(chan os.Signal) signal.Notify(quitChannel, syscall.SIGINT, syscall.SIGTERM) shutdownCallerChannel := make(chan bool) go func() { <-quitChannel self.shutdownChannel <- true shutdownCallerChannel <- true }() self.Status = proto.RUNNING // Immediately publish heartbeat self.lastHBMsg.CurrentDatetime = time.Now().UTC().Format(time.RFC3339) self.lastHBMsg.Status = self.Status if data, _ := self.lastHBMsg.Marshal(); data != nil { self.messageBus.Publish("service.Heartbeat."+self.Config.ServiceName, data) } log.Infof("Service [%v] Started", self.Config.ServiceName) return shutdownCallerChannel }
func NewService(c Config) *Service { // Hardware Info uuid = fmt.Sprint(hostname, ":", pid) log.Infof("Service [%v] starting @ %v", c.ServiceName, uuid) // Service handle svc := &Service{ Config: c, Status: proto.STARTING, shutdownChannel: make(chan bool), } // Messaging bus messageBus, err := messagebus.Connect(svc.Config.MessageBusURL) svc.messageBus = messageBus if err != nil { log.WithField("MessageBusURL", svc.Config.MessageBusURL).Fatal("error: Cannot connect to message bus") } //Heartbeating currDateTime := time.Now().UTC().Format(time.RFC3339) hbMsg := &proto.Heartbeat{ Name: svc.Config.ServiceName, Id: uuid, Status: proto.STARTING, Machine: hostname, CreationDatetime: currDateTime, CurrentDatetime: currDateTime, } svc.lastHBMsg = hbMsg hbTicker := time.NewTicker(time.Second * time.Duration(svc.Config.HeartbeatFreq)) go func(shutdownChannel chan bool) { publish_address := "service.Heartbeat." + svc.Config.ServiceName for range hbTicker.C { hbMsg.CurrentDatetime = time.Now().UTC().Format(time.RFC3339) hbMsg.Status = svc.Status if data, _ := hbMsg.Marshal(); data != nil { messageBus.Publish(publish_address, data) } select { case <-shutdownChannel: hbTicker.Stop() //Publish Stop heartbeat if svc.Status != proto.ERROR { svc.Status = proto.STOPPED } hbMsg.CurrentDatetime = time.Now().UTC().Format(time.RFC3339) hbMsg.Status = svc.Status if data, _ := hbMsg.Marshal(); data != nil { messageBus.Publish(publish_address, data) } messageBus.Close() log.Info("Server Terminated") return } } }(svc.shutdownChannel) return svc }
func TestLogger_printf(t *testing.T) { l.Infof("logged in %s", "Chao") }
// Initialise OrderRouter instance and set up topic subscribers func NewOrderRouter(c Config) *OrderRouter { or := &OrderRouter{ Config: c, // internal variables stopChan: make(chan bool), mclist: map[string]time.Time{}, mcChan: make(chan *service.Heartbeat), reqChan: make(chan OrderRequest), } // Connect to database storage driver if storage, err := database.NewOrderStore(c.DatabaseDriver, c.DatabaseUrl, nil); err != nil { log.Fatalf("error: Cannot connect to database driver %v @ %v", c.DatabaseDriver, c.DatabaseUrl) } else { or.orderStore = storage } // Keep a list of active MarketConnectors if ncSvc, err := messagebus.Connect(c.ServiceMessageBusURL); err != nil { log.Fatalf("error: Cannot connect to service message bus @ %v", c.ServiceMessageBusURL) } else { or.msgbusService = ncSvc ncSvc.Subscribe("service.Heartbeat.MC.>", func(m *messagebus.Msg) { hbMsg := &service.Heartbeat{} if err := hbMsg.Unmarshal(m.Data); err == nil { or.mcChan <- hbMsg } }) } // Order requests processors subscribing if msgbus, err := messagebus.Connect(c.MessageBusURL); err != nil { log.Fatalf("error: Cannot connect to order message bus @ %v", c.MessageBusURL) } else { or.msgbus = msgbus //CL->OR order NEW request msgbus.Subscribe("order.NewOrderRequest", func(m *messagebus.Msg) { request := new(proto.NewOrderRequest) if err := request.Unmarshal(m.Data); err == nil && len(m.Reply) > 0 { // validate basic fields if request.Order == nil { // empty request return } if request.Order.MarketConnector == "" { // empty market connect return } orReq := OrderRequest{ ReplyAddr: m.Reply, RequestType: REQ_NEW, Request: request, } oO := order.Order{ Order: request.Order, } log.Infof("CL->OR NEW %v", oO.String()) or.reqChan <- orReq } }) //CL->OR order CANCEL request msgbus.Subscribe("order.CancelOrderRequest", func(m *messagebus.Msg) { request := new(proto.CancelOrderRequest) if err := request.Unmarshal(m.Data); err == nil && len(m.Reply) > 0 { // validate basic fields if request.OrderId == 0 { // request without order id return } orReq := OrderRequest{ ReplyAddr: m.Reply, RequestType: REQ_CANCEL, Request: request, OrderId: request.OrderId, } log.Infof("CL->OR CXL OrderKey := %v OrderId := %v", request.OrderKey, request.OrderId) or.reqChan <- orReq } }) //CL->OR order REPLACE request msgbus.Subscribe("order.ReplaceOrderRequest", func(m *messagebus.Msg) { request := new(proto.ReplaceOrderRequest) if err := request.Unmarshal(m.Data); err == nil && len(m.Reply) > 0 { // validate basic fields if request.Order == nil { // empty request return } if request.Order.OrderId == 0 { // request without order id return } if request.Order.MarketConnector == "" { // empty market connect return } orReq := OrderRequest{ ReplyAddr: m.Reply, RequestType: REQ_REPLACE, Request: request, OrderId: request.Order.OrderId, } log.Infof("CL->OR RPL OrderKey := %v OrderId := %v", request.Order.OrderKey, request.Order.OrderId) or.reqChan <- orReq } }) } return or }
//Use Message Cracker on Incoming Application Messages func (e *Executor) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (reject quickfix.MessageRejectError) { log.Infof("FIX->SIM: FIX44NewOrderSingle \n%v", msg.String()) return e.Route(msg, sessionID) }
func (app FIXClient) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (reject quickfix.MessageRejectError) { log.Infof("FIX->MC EXEC: \n%v", msg.String()) return app.Route(msg, sessionID) }