func TestNilConnection(t *testing.T) {
var nc *nats.Conn
data := []byte("ok")
// Publish
if err := nc.Publish("foo", data); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if err := nc.PublishMsg(nil); err == nil || err != nats.ErrInvalidMsg {
t.Fatalf("Expected ErrInvalidMsg error, got %v\n", err)
}
if err := nc.PublishMsg(&nats.Msg{}); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if err := nc.PublishRequest("foo", "reply", data); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
// Subscribe
if _, err := nc.Subscribe("foo", nil); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.SubscribeSync("foo"); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.QueueSubscribe("foo", "bar", nil); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
ch := make(chan *nats.Msg)
if _, err := nc.ChanSubscribe("foo", ch); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.ChanQueueSubscribe("foo", "bar", ch); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.QueueSubscribeSyncWithChan("foo", "bar", ch); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
// Flush
if err := nc.Flush(); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if err := nc.FlushTimeout(time.Millisecond); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
// Nil Subscribers
var sub *nats.Subscription
if sub.Type() != nats.NilSubscription {
t.Fatalf("Got wrong type for nil subscription, %v\n", sub.Type())
}
if sub.IsValid() {
t.Fatalf("Expected IsValid() to return false")
}
if err := sub.Unsubscribe(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected Unsubscribe to return proper error, got %v\n", err)
}
if err := sub.AutoUnsubscribe(1); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.NextMsg(time.Millisecond); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.QueuedMsgs(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, _, err := sub.Pending(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, _, err := sub.MaxPending(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if err := sub.ClearMaxPending(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, _, err := sub.PendingLimits(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if err := sub.SetPendingLimits(1, 1); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.Delivered(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.Dropped(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
}
func (c *VcapComponent) Register(mbusClient *nats.Conn) error {
mbusClient.Subscribe("vcap.component.discover", func(msg *nats.Msg) {
if msg.Reply == "" {
log.Info(fmt.Sprintf("Received message with empty reply on subject %s", msg.Subject))
return
}
c.Varz.Uptime = c.Varz.StartTime.Elapsed()
b, e := json.Marshal(c.Varz)
if e != nil {
log.Error("error-json-marshaling", e)
return
}
mbusClient.Publish(msg.Reply, b)
})
b, e := json.Marshal(c.Varz)
if e != nil {
log.Error("error-json-marshaling", e)
return e
}
mbusClient.Publish("vcap.component.announce", b)
log.Info(fmt.Sprintf("Component %s registered successfully", c.Varz.Type))
return nil
}
func NewElectronConn(opt *nats.Options) (ec *ElectronConn, err error) {
var nc *nats.Conn
if opt == nil {
nc, err = nats.Connect(nats.DefaultURL)
} else {
nc, err = opt.Connect()
}
if err != nil {
return nil, err
}
ec = &ElectronConn{conn: nc}
f := func(m *nats.Msg) {
ID := atomic.AddUint32(&ec.genID, 1)
if err := nc.Publish(m.Reply, []byte(fmt.Sprintf("%d", ID))); err != nil {
logrus.Error(err)
return
}
ec.Lock()
ec.clients = append(ec.clients, ID)
ec.Unlock()
}
if _, err = nc.Subscribe("register", f); err != nil {
nc.Close()
return nil, fmt.Errorf("nats: %v", err)
}
if ec.jsonConn, err = nats.NewEncodedConn(nc, "json"); err != nil {
nc.Close()
return nil, fmt.Errorf("nats: %v", err)
}
return
}
// Subscribe to workflow.states.all and return all valid states
// for the given issue
func (w *WFStatesAll) Subscribe(nc *nats.Conn) {
e := ErrorMessage{}
nc.Subscribe("workflow.states.all", func(m *nats.Msg) {
i := Issue{}
s := i.AllStates()
json, err := json.Marshal(s)
if err != nil {
e.Error = err.Error()
nc.Publish(m.Reply, e.toJSON())
return
}
nc.Publish(m.Reply, json)
})
}
func connect(conn *nats.Conn, subj string, timeout time.Duration) (*nats.Msg, string, error) {
inbox := nats.NewInbox()
s, err := conn.Subscribe(inbox, nil)
if err != nil {
return nil, "", err
}
s.AutoUnsubscribe(1)
err = conn.PublishRequest(subj, inbox, nil)
if err != nil {
return nil, "", err
}
msg, err := s.NextMsg(timeout)
if err != nil {
return nil, "", err
}
return msg, inbox, nil
}
// Subscribe to workflow.move in order to move an issue to its
// new status and execute proper hooks
func (w *WFMove) Subscribe(nc *nats.Conn) {
e := ErrorMessage{}
nc.Subscribe("workflow.move", func(m *nats.Msg) {
input, err := w.mapInput(string(m.Data))
if err != nil {
e.Error = err.Error()
nc.Publish(m.Reply, e.toJSON())
return
}
i, err := w.executeTransition(input)
if err != nil {
e.Error = err.Error()
nc.Publish(m.Reply, e.toJSON())
return
}
nc.Publish(m.Reply, ToJSON(i))
})
}
// Subscribe to workflow.states.available in order to return
// all available status for the current status of the issue
func (w *WFStatesAvailable) Subscribe(nc *nats.Conn) {
e := ErrorMessage{}
nc.Subscribe("workflow.states.available", func(m *nats.Msg) {
i, err := w.mapInput(m.Data)
if err != nil {
e.Error = err.Error()
nc.Publish(m.Reply, e.toJSON())
return
}
s := i.Issue.AvailableExitStates()
json, err := json.Marshal(s)
if err != nil {
e.Error = err.Error()
nc.Publish(m.Reply, e.toJSON())
return
}
nc.Publish(m.Reply, json)
})
}
if config.PidFile != "" {
// remove pid file
err := os.Remove(config.PidFile)
Expect(err).ToNot(HaveOccurred())
}
}
})
Context("NATS", func() {
Context("Router Greetings", func() {
It("RouterGreets", func() {
response := make(chan []byte)
mbusClient.Subscribe("router.greet.test.response", func(msg *nats.Msg) {
response <- msg.Data
})
mbusClient.PublishRequest("router.greet", "router.greet.test.response", []byte{})
var msg []byte
Eventually(response).Should(Receive(&msg))
var message common.RouterStart
err := json.Unmarshal(msg, &message)
Expect(err).NotTo(HaveOccurred())
Expect(message.MinimumRegisterIntervalInSeconds).To(Equal(5))
Expect(message.PruneThresholdInSeconds).To(Equal(120))
})
component.Varz.Type = "TestType"
component.Logger = logger
err := component.Start()
Expect(err).ToNot(HaveOccurred())
err = component.Register(mbusClient)
Expect(err).ToNot(HaveOccurred())
_, err = mbusClient.Subscribe("subject", func(msg *nats.Msg) {
defer GinkgoRecover()
data := make(map[string]interface{})
err := json.Unmarshal(msg.Data, &data)
Expect(err).ToNot(HaveOccurred())
for _, key := range members {
_, ok := data[key]
Expect(ok).To(BeTrue())
}
close(done)
})
Expect(err).ToNot(HaveOccurred())
err = mbusClient.PublishRequest("vcap.component.discover", "subject", []byte(""))
Expect(err).ToNot(HaveOccurred())
Eventually(done).Should(BeClosed())
})
It("publishes to vcap.component.announce on start-up", func() {
