Exemple #1
0
func ExampleConn_Subscribe_1() error {
	conn, err := stomp.Dial("tcp", "localhost:61613")
	if err != nil {
		return err
	}

	sub, err := conn.Subscribe("/queue/test-2", stomp.AckClient)
	if err != nil {
		return err
	}

	// receive 5 messages and then quit
	for i := 0; i < 5; i++ {
		msg := <-sub.C
		if msg.Err != nil {
			return msg.Err
		}

		doSomethingWith(msg)

		// acknowledge the message
		err = conn.Ack(msg)
		if err != nil {
			return err
		}
	}

	err = sub.Unsubscribe()
	if err != nil {
		return err
	}

	return conn.Disconnect()
}
Exemple #2
0
func recvMessages(subscribed chan bool) {
	defer func() {
		stop <- true
	}()

	conn, err := stomp.Dial("tcp", *serverAddr, options...)

	if err != nil {
		println("cannot connect to server", err.Error())
		return
	}

	sub, err := conn.Subscribe(*queueName, stomp.AckAuto)
	if err != nil {
		println("cannot subscribe to", *queueName, err.Error())
		return
	}
	close(subscribed)

	for i := 1; i <= *messageCount; i++ {
		msg := <-sub.C
		expectedText := fmt.Sprintf("Message #%d", i)
		actualText := string(msg.Body)
		if expectedText != actualText {
			println("Expected:", expectedText)
			println("Actual:", actualText)
		}
	}
	println("receiver finished")

}
func consume(config Config) {
	rabbitHost := fmt.Sprintf("%s:%s", config.RabbitHost, config.RabbitPort)
	conn, err := stomp.Dial("tcp", rabbitHost,
		stomp.ConnOpt.Login(config.RabbitUser, config.RabbitPassword),
		stomp.ConnOpt.AcceptVersion(stomp.V11),
		stomp.ConnOpt.AcceptVersion(stomp.V12),
		stomp.ConnOpt.Host(config.RabbitVHost),
		stomp.ConnOpt.Header("nonce", "B256B26D320A"))

	if err != nil {
		log.Fatal(err)
	}
	defer conn.Disconnect()
	subscription, err := conn.Subscribe(config.RabbitQueue, stomp.AckClient)
	if err != nil {
		log.Fatal(err)
	}

	for {
		payload := <-subscription.C
		log.Println("Received subscribed message -> ", string(payload.Body))
		err = conn.Ack(payload)
		if err != nil {
			log.Fatal(err)
		}
	}
	err = subscription.Unsubscribe()
	if err != nil {
		log.Fatal(err)
	}
}
Exemple #4
0
// Connect to a stomp server
func (p *DozerProtocolStomp) Dial(host string, port int64) error {
	bind := fmt.Sprintf("%s:%d", host, port)
	conn, err := stomp.Dial("tcp", bind, stomp.Options{})
	if err != nil {
		return err
	}
	p.conn = conn
	return nil
}
func TestConnectToActiveMQ(t *testing.T) {
	c, err := ConnectToActiveMQ(15, time.Millisecond*500, func(url string) bool {
		conn, err := stomp.Dial("tcp", url, stomp.ConnOpt.Login("admin", "admin"))
		if err != nil {
			return false
		}
		defer conn.Disconnect()
		return true
	})
	assert.Nil(t, err)
	defer c.KillRemove()
}
func run(config Config) {
	purl := fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", config.DbUser, config.DbPassword, config.DbHost, config.DbPort, config.DbName, config.SslMode)
	listener := pq.NewListener(purl, 10*time.Second, time.Minute, errorReporter)
	err := listener.Listen("usertrigger")
	if err != nil {
		log.Fatal(err)
	}

	rabbitchannel := make(chan string, 100)

	//Code for STOMP
	go func() {
		rabbitHost := fmt.Sprintf("%s:%s", config.RabbitHost, config.RabbitPort)
		conn, err := stomp.Dial("tcp", rabbitHost,
			stomp.ConnOpt.Login(config.RabbitUser, config.RabbitPassword),
			stomp.ConnOpt.AcceptVersion(stomp.V11),
			stomp.ConnOpt.AcceptVersion(stomp.V12),
			stomp.ConnOpt.Host(config.RabbitVHost),
			stomp.ConnOpt.Header("nonce", "B256B26D320A"))

		if err != nil {
			log.Fatal(err)
		}
		defer conn.Disconnect()

		for {
			payload := <-rabbitchannel
			log.Println(payload)
			err = conn.Send(config.RabbitQueue, "text/plain", []byte(payload))
			if err != nil {
				log.Fatal(err)
			}
		}
	}()

	for {
		select {
		case notification := <-listener.Notify:
			rabbitchannel <- notification.Extra
		case <-time.After(90 * time.Second):
			go func() {
				err := listener.Ping()
				if err != nil {
					log.Fatal(err)
				}
			}()
		}
	}
}
Exemple #7
0
//Connect to ActiveMQ and produce messages
func main() {
	conn, err := stomp.Dial("tcp", "localhost:61613")
	if err != nil {
		fmt.Println(err)
	}

	c := make(chan string)
	quit := make(chan string)
	go Producer(c, quit, conn)

	for {
		fmt.Println(<-c)
	}
	quit <- "read"
}
Exemple #8
0
// Connect to a STOMP server using default options.
func ExampleDial_1() error {
	conn, err := stomp.Dial("tcp", "192.168.1.1:61613")
	if err != nil {
		return err
	}

	err = conn.Send(
		"/queue/test-1",           // destination
		"text/plain",              // content-type
		[]byte("Test message #1")) // body
	if err != nil {
		return err
	}

	return conn.Disconnect()
}
Exemple #9
0
func ExampleTransaction() error {
	conn, err := stomp.Dial("tcp", "localhost:61613")
	if err != nil {
		return err
	}
	defer conn.Disconnect()

	sub, err := conn.Subscribe("/queue/test-2", stomp.AckClient)
	if err != nil {
		return err
	}

	// receive 5 messages and then quit
	for i := 0; i < 5; i++ {
		msg := <-sub.C
		if msg.Err != nil {
			return msg.Err
		}

		tx := conn.Begin()

		doAnotherThingWith(msg, tx)

		tx.Send("/queue/another-one", "text/plain",
			[]byte(fmt.Sprintf("Message #%d", i)), nil)

		// acknowledge the message
		err = tx.Ack(msg)
		if err != nil {
			return err
		}

		err = tx.Commit()
		if err != nil {
			return err
		}
	}

	err = sub.Unsubscribe()
	if err != nil {
		return err
	}

	return nil
}
Exemple #10
0
func (feed *NREFeed) Subscribe(cfg Cfg) *NREUpdates {
	addr := server + ":" + strconv.Itoa(nrePort)
	log.Println("Stomping trains from:", addr, " with user:"******"tcp", addr, stomp.ConnOpt.Login(cfg.Nre.User, cfg.Nre.Pass))
	failIf(err)
	log.Println("Dial success")

	feed.sub, err = feed.con.Subscribe("/queue/"+cfg.Nre.Queue, stomp.AckClient)
	failIf(err)
	log.Println("Subscribe success")

	results := make(NREUpdates)

	go func() {
		log.Println("Created NRE update thread")
		for {
			msg := <-feed.sub.C
			log.Print("Beginning receive")
			failIf(msg.Err)
			reader := bytes.NewReader(msg.Body)
			gz, err := gzip.NewReader(reader)
			failIf(err)
			buff := make([]byte, 1024)
			str := []byte{}
			for {
				n, _ := gz.Read(buff)
				if n == 0 {
					break
				} else {
					str = append(str, buff[:n]...)
				}
			}
			log.Println("rxed:", len(str), "bytes")
			results <- str
			err = feed.con.Ack(msg)
			failIf(err)
		}
	}()
	return &results
}
Exemple #11
0
//Connect to ActiveMQ and listen for messages
func main() {
	conn, err := stomp.Dial("tcp", "localhost:61613")
	if err != nil {
		fmt.Println(err)
	}

	sub, err := conn.Subscribe("/queue/test-1", stomp.AckAuto)
	if err != nil {
		fmt.Println(err)
	}
	for {
		msg := <-sub.C
		fmt.Println(msg)
	}

	err = sub.Unsubscribe()
	if err != nil {
		fmt.Println(err)
	}
	defer conn.Disconnect()
}
Exemple #12
0
// Connect to a STOMP server that requires authentication. In addition,
// we are only prepared to use STOMP protocol version 1.1 or 1.2, and
// the virtual host is named "dragon". In this example the STOMP
// server also accepts a non-standard header called 'nonce'.
func ExampleDial_2() error {
	conn, err := stomp.Dial("tcp", "192.168.1.1:61613",
		stomp.ConnOpt.Login("scott", "leopard"),
		stomp.ConnOpt.AcceptVersion(stomp.V11),
		stomp.ConnOpt.AcceptVersion(stomp.V12),
		stomp.ConnOpt.Host("dragon"),
		stomp.ConnOpt.Header("nonce", "B256B26D320A"))
	if err != nil {
		return err
	}

	err = conn.Send(
		"/queue/test-1",           // destination
		"text/plain",              // content-type
		[]byte("Test message #1")) // body
	if err != nil {
		return err
	}

	return conn.Disconnect()
}
Exemple #13
0
func sendMessages() {
	defer func() {
		stop <- true
	}()

	conn, err := stomp.Dial("tcp", *serverAddr, options...)
	if err != nil {
		println("cannot connect to server", err.Error())
		return
	}

	for i := 1; i <= *messageCount; i++ {
		text := fmt.Sprintf("Message #%d", i)
		err = conn.Send(*queueName, "text/plain",
			[]byte(text), nil)
		if err != nil {
			println("failed to send to server", err)
			return
		}
	}
	println("sender finished")
}