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
}
func (s *Subscriber) setup(nc *nats.Conn, m *nats.Msg) {
body := m.Data
input := messages.Setup{}
err := json.Unmarshal(body, &input)
if err != nil {
nc, _ := nats.Connect(nats.DefaultURL)
nc.Publish(m.Reply, []byte(`{"error":"error setting up github labels"}`))
return
}
g := getAdapter(input.Config)
g.Labels = input.States
g.Setup(input.States, input.Org, input.Repo)
nc.Publish(m.Reply, []byte(`success`))
}
// 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 natsHandler(nc *nats.Conn) http.Handler {
result := func(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
subject := vars["subject"]
msg, err := ioutil.ReadAll(r.Body)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
err = nc.Publish(subject, msg)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
}
return http.Handler(http.HandlerFunc(result))
}
// 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)
})
}
msg := mbus.RegistryMessage{
Host: "host",
App: "app",
RouteServiceURL: "https://url.example.com",
PrivateInstanceID: "id",
PrivateInstanceIndex: "index",
Port: 1111,
StaleThresholdInSeconds: 120,
Uris: []route.Uri{"test.example.com", "test2.example.com"},
Tags: map[string]string{"key": "value"},
}
data, err := json.Marshal(msg)
Expect(err).NotTo(HaveOccurred())
err = natsClient.Publish("router.register", data)
Expect(err).ToNot(HaveOccurred())
Eventually(registry.RegisterCallCount).Should(Equal(2))
for i := 0; i < registry.RegisterCallCount(); i++ {
uri, endpoint := registry.RegisterArgsForCall(i)
Expect(msg.Uris).To(ContainElement(uri))
Expect(endpoint.ApplicationId).To(Equal(msg.App))
Expect(endpoint.Tags).To(Equal(msg.Tags))
Expect(endpoint.PrivateInstanceId).To(Equal(msg.PrivateInstanceID))
Expect(endpoint.PrivateInstanceIndex).To(Equal(msg.PrivateInstanceIndex))
Expect(endpoint.RouteServiceUrl).To(Equal(msg.RouteServiceURL))
Expect(endpoint.CanonicalAddr()).To(ContainSubstring(msg.Host))
}
})
Eventually(done).Should(Receive(&answer))
Expect(answer).ToNot(Equal("A-BOGUS-REQUEST-ID"))
Expect(answer).To(MatchRegexp(uuid_regex))
Expect(logger).To(gbytes.Say("vcap-request-id-header-set"))
resp, _ := httpConn.ReadResponse()
Expect(resp.StatusCode).To(Equal(http.StatusOK))
})
It("handles a /routes request", func() {
var client http.Client
var req *http.Request
var resp *http.Response
var err error
mbusClient.Publish("router.register", []byte(`{"dea":"dea1","app":"app1","uris":["test.com"],"host":"1.2.3.4","port":1234,"tags":{},"private_instance_id":"private_instance_id"}`))
time.Sleep(250 * time.Millisecond)
host := fmt.Sprintf("http://%s:%d/routes", config.Ip, config.Status.Port)
req, err = http.NewRequest("GET", host, nil)
req.SetBasicAuth("user", "pass")
resp, err = client.Do(req)
Expect(err).ToNot(HaveOccurred())
Expect(resp).ToNot(BeNil())
Expect(resp.StatusCode).To(Equal(200))
body, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
Expect(err).ToNot(HaveOccurred())
func NatsPub(subject string, nc *nats.Conn, data []byte) {
nc.Publish(subject, data)
}
testSession, err := gexec.Start(testBinary, GinkgoWriter, GinkgoWriter)
handleError(err)
defer testSession.Kill()
var remoteClient net.Conn
go func() {
var err error
remoteClient, err = syslogServer.AcceptTCP()
remoteClient.SetReadDeadline(time.Now().Add(2 * time.Second))
handleError(err)
}()
time.Sleep(500 * time.Millisecond)
reader := bufio.NewReader(remoteClient)
defer remoteClient.Close()
natsClient.Publish("testSubject", []byte("test message"))
time.Sleep(1 * time.Second)
logLine, _, err := reader.ReadLine()
handleError(err)
Expect(string(logLine)).To(MatchRegexp(`^<6>.*nats-to-syslog.*{"Data":"test message","Reply":"","Subject":"testSubject"}`))
})
AfterEach(func() {
gnatsd.Kill()
syslogServer.Close()
})
})
func startSyslogServer() *net.TCPListener {
