func main() {
opts := MQTT.NewClientOptions().SetBroker("tcp://test.mosquitto.org:1883").SetClientId("router-sample")
opts.SetTraceLevel(MQTT.Off)
opts.SetCleanSession(true)
c := MQTT.NewClient(opts)
_, err := c.Start()
if err != nil {
panic(err)
}
loadFilter, _ := MQTT.NewTopicFilter("$SYS/broker/load/#", 0)
if receipt, err := c.StartSubscription(brokerLoadHandler, loadFilter); err != nil {
fmt.Println(err)
os.Exit(1)
} else {
<-receipt
}
connectionFilter, _ := MQTT.NewTopicFilter("$SYS/broker/connection/#", 0)
if receipt, err := c.StartSubscription(brokerConnectionHandler, connectionFilter); err != nil {
fmt.Println(err)
os.Exit(1)
} else {
<-receipt
}
clientsFilter, _ := MQTT.NewTopicFilter("$SYS/broker/clients/#", 0)
if receipt, err := c.StartSubscription(brokerClientsHandler, clientsFilter); err != nil {
fmt.Println(err)
os.Exit(1)
} else {
<-receipt
}
num_bload := 0
num_bconns := 0
num_bclients := 0
for i := 0; i < 100; i++ {
select {
case <-broker_load:
num_bload++
case <-broker_connection:
num_bconns++
case <-broker_clients:
num_bclients++
}
}
fmt.Printf("Received %3d Broker Load messages\n", num_bload)
fmt.Printf("Received %3d Broker Connection messages\n", num_bconns)
fmt.Printf("Received %3d Broker Clients messages\n", num_bclients)
c.Disconnect(250)
}
func main() {
opts := MQTT.NewClientOptions().AddBroker("tcp://test.mosquitto.org:1883").SetClientId("trivial")
opts.SetDefaultPublishHandler(f)
c := MQTT.NewClient(opts)
_, err := c.Start()
if err != nil {
panic(err)
}
filter, _ := MQTT.NewTopicFilter("/go-mqtt/sample", 0)
if receipt, err := c.StartSubscription(nil, filter); err != nil {
fmt.Println(err)
os.Exit(1)
} else {
<-receipt
}
for i := 0; i < 5; i++ {
text := fmt.Sprintf("this is msg #%d!", i)
receipt := c.Publish(MQTT.QOS_ONE, "/go-mqtt/sample", []byte(text))
<-receipt
}
time.Sleep(3 * time.Second)
if receipt, err := c.EndSubscription("/go-mqtt/sample"); err != nil {
fmt.Println(err)
os.Exit(1)
} else {
<-receipt
}
c.Disconnect(250)
}
func main() {
myNoOpStore := &NoOpStore{}
opts := MQTT.NewClientOptions()
opts.AddBroker("tcp://test.mosquitto.org:1883")
opts.SetClientId("custom-store")
opts.SetStore(myNoOpStore)
var callback MQTT.MessageHandler = func(client *MQTT.MqttClient, msg MQTT.Message) {
fmt.Printf("TOPIC: %s\n", msg.Topic())
fmt.Printf("MSG: %s\n", msg.Payload())
}
c := MQTT.NewClient(opts)
_, err := c.Start()
if err != nil {
panic(err)
}
filter, _ := MQTT.NewTopicFilter("/go-mqtt/sample", 0)
c.StartSubscription(callback, filter)
for i := 0; i < 5; i++ {
text := fmt.Sprintf("this is msg #%d!", i)
c.Publish(MQTT.QOS_ONE, "/go-mqtt/sample", []byte(text))
}
for i := 1; i < 5; i++ {
time.Sleep(1 * time.Second)
}
c.Disconnect(250)
}
func main() {
tlsconfig := NewTlsConfig()
opts := MQTT.NewClientOptions()
opts.AddBroker("ssl://hushbox.net:17004")
opts.SetClientId("ssl-sample").SetTlsConfig(tlsconfig)
opts.SetDefaultPublishHandler(f)
// Start the connection
c := MQTT.NewClient(opts)
_, err := c.Start()
if err != nil {
panic(err)
}
filter, _ := MQTT.NewTopicFilter("/go-mqtt/sample", 0)
c.StartSubscription(nil, filter)
i := 0
for _ = range time.Tick(time.Duration(1) * time.Second) {
if i == 5 {
break
}
text := fmt.Sprintf("this is msg #%d!", i)
c.Publish(MQTT.QOS_ZERO, "/go-mqtt/sample", []byte(text))
i++
}
c.Disconnect(250)
}
func Subscribe(client *MQTT.MqttClient, topic string) {
filter, _ := MQTT.NewTopicFilter(topic, byte(MQTT.QOS_ZERO))
if receipt, err := client.StartSubscription(f, filter); err != nil {
fmt.Println(err)
os.Exit(1)
} else {
<-receipt
}
}
func (b *Bus) listen() {
b.log.Infof("connecting to the bus")
opts := mqtt.NewClientOptions().AddBroker(b.conf.LocalUrl).SetClientId("mqtt-bridgeify-bus")
b.client = mqtt.NewClient(opts)
_, err := b.client.Start()
if err != nil {
b.log.Errorf("Can't start connection: %s", err)
} else {
b.log.Infof("Connected as %s\n", b.conf.LocalUrl)
}
topicFilter, _ := mqtt.NewTopicFilter(connectTopic, 0)
if receipt, err := b.client.StartSubscription(b.handleConnect, topicFilter); err != nil {
b.log.Errorf("Subscription Failed: %s", err)
panic(err)
} else {
<-receipt
b.log.Infof("Subscribed to: %+v", topicFilter)
}
topicFilter, _ = mqtt.NewTopicFilter(disconnectTopic, 0)
if receipt, err := b.client.StartSubscription(b.handleDisconnect, topicFilter); err != nil {
b.log.Errorf("Subscription Failed: %s", err)
panic(err)
} else {
<-receipt
b.log.Infof("Subscribed to: %+v", topicFilter)
}
ev := &statusEvent{Status: "started"}
b.client.PublishMessage(statusTopic, b.encodeRequest(ev))
b.setupBackgroundJob()
}
func (m *MQTTClient) Subscribe(topic string, qos int) error {
topicFilter, err := MQTT.NewTopicFilter(topic, byte(qos))
if err != nil {
return err
}
_, err = m.Client.StartSubscription(onMessageReceived, topicFilter)
if err != nil {
return err
}
for {
time.Sleep(1 * time.Second)
}
return nil
}
func main() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
go func() {
<-c
fmt.Println("signal received, exiting")
os.Exit(0)
}()
hostname, _ := os.Hostname()
server := flag.String("server", "tcp://127.0.0.1:1883", "The full url of the MQTT server to connect to ex: tcp://127.0.0.1:1883")
topic := flag.String("topic", "#", "Topic to subscribe to")
qos := flag.Int("qos", 0, "The QoS to subscribe to messages at")
//retained := flag.Bool("retained", false, "Are the messages sent with the retained flag")
clientid := flag.String("clientid", hostname+strconv.Itoa(time.Now().Second()), "A clientid for the connection")
username := flag.String("username", "", "A username to authenticate to the MQTT server")
password := flag.String("password", "", "Password to match username")
flag.Parse()
connOpts := MQTT.NewClientOptions().SetBroker(*server).SetClientId(*clientid).SetCleanSession(true)
if *username != "" {
connOpts.SetUsername(*username)
if *password != "" {
connOpts.SetPassword(*password)
}
}
client := MQTT.NewClient(connOpts)
_, err := client.Start()
if err != nil {
panic(err)
} else {
fmt.Printf("Connected to %s\n", *server)
}
filter, e := MQTT.NewTopicFilter(*topic, byte(*qos))
if e != nil {
fmt.Println(e)
os.Exit(1)
}
client.StartSubscription(onMessageReceived, filter)
for {
time.Sleep(1 * time.Second)
}
}
func readFromMqttChannel(t *testing.T, wg *sync.WaitGroup) {
log.Println("try to connect to MQTT for getting data")
opts := MQTT.NewClientOptions().AddBroker("tcp://localhost:1883").SetClientId("myReader")
c := MQTT.NewClient(opts)
_, err := c.Start()
log.Println("client connected")
if err != nil {
panic(err)
}
filter, _ := MQTT.NewTopicFilter("/mackristof/weather-mtp/davis1", 1)
_, err = c.StartSubscription(onMessageReceived, filter)
assert.Nil(t, err)
for {
time.Sleep(2 * time.Second)
log.Println("sleeping for 2 sec")
}
c.Disconnect(250)
wg.Done()
}
func Subscribe(client *MQTT.MqttClient, topic string) error {
topicName := config.user + "/" + topic
// 無料枠はQoS 0のみ
qos := 0
// Subscribeするtopicを設定します
topicFilter, err := MQTT.NewTopicFilter(topicName, byte(qos))
if err != nil {
return err
}
// Subscribeします
// onMessageReceived はメッセージが届いたら呼び出されるコールバックです
_, err = client.StartSubscription(onMessageReceived, topicFilter)
if err != nil {
return err
}
// そのままではプロセスが終わってしまいますので、待ち受けます
for {
time.Sleep(1 * time.Second)
}
}
func (self *Subscriber) addChannel(filter eventFilter, topics []string) eventChannel {
// subscribe topics not yet subscribed to
for _, topic := range topics {
_, exists := self.topicCount[topic]
if !exists {
filter, _ := MQTT.NewTopicFilter(topicName(topic), 1)
// fmt.Printf("StartSubscription: %+v\n", filter)
// nil = all messages go to the default handler
self.broker.client.StartSubscription(nil, filter)
}
self.topicCount[topic] += 1
}
ch := eventChannel{
C: make(chan *pubsub.Event, 16),
filter: filter,
topics: topics,
}
self.channelsLock.Lock()
self.channels = append(self.channels, ch)
self.channelsLock.Unlock()
return ch
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
openPorts()
defer closePorts()
waitCh := make(chan bool)
go func() {
total := 0
for {
v := <-outCh
if !v {
log.Println("An OUT port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
// At least one output ports are opened
if total >= 1 && waitCh != nil {
waitCh <- true
}
}
}()
log.Println("Waiting for options to arrive...")
var (
ip [][]byte
clientOptions *mqtt.ClientOptions
client *mqtt.MqttClient
defaultTopic string
qos mqtt.QoS
)
// Setup socket poll items
poller := zmq.NewPoller()
poller.Add(optsPort, zmq.POLLIN)
poller.Add(tmplPort, zmq.POLLIN)
for {
sockets, err := poller.Poll(-1)
if err != nil {
log.Println("Error polling ports:", err.Error())
continue
}
for _, socket := range sockets {
if socket.Socket == nil {
log.Println("ERROR: could not find socket in polling items array")
continue
}
ip, err = socket.Socket.RecvMessageBytes(0)
if err != nil {
log.Println("Error receiving message:", err.Error())
continue
}
if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
log.Println("Invalid IP:", ip)
continue
}
switch socket.Socket {
case optsPort:
err = json.Unmarshal(ip[1], &options)
if err != nil {
log.Println("ERROR: failed to unmarshal options:", err.Error())
continue
}
clientOptions, defaultTopic, qos, err = helper.ParseOptionsURI(options.OptionsURI)
if err != nil {
log.Printf("Failed to parse connection uri. Error: %s", err.Error())
continue
}
log.Println("Options specified:", options)
case tmplPort:
err = json.Unmarshal(ip[1], &propTemplate)
if err != nil {
log.Println("ERROR: failed to unmarshal template:", err.Error())
continue
}
log.Printf("Template specified: %+v", propTemplate)
default:
log.Println("ERROR: IP from unhandled socket received!")
continue
}
if defaultTopic != "" && clientOptions != nil && propTemplate != nil {
log.Println("Component configured. Moving on...")
break
}
}
client = mqtt.NewClient(clientOptions)
if _, err = client.Start(); err != nil {
log.Printf("Failed to create MQTT client. Error: %s", err.Error())
continue
}
defer client.Disconnect(1e6)
optsPort.Close()
tmplPort.Close()
break
}
log.Println("Started...")
topicFilter, err := mqtt.NewTopicFilter(defaultTopic, byte(qos))
utils.AssertError(err)
_, err = client.StartSubscription(messageHandler, topicFilter)
utils.AssertError(err)
ticker := time.Tick(1 * time.Second)
for _ = range ticker {
}
}
func TestPahoGoClient(t *testing.T) {
var wg sync.WaitGroup
ready1 := make(chan struct{})
ready2 := make(chan struct{})
uri := "tcp://127.0.0.1:1883"
u, err := url.Parse(uri)
require.NoError(t, err, "Error parsing URL")
// Start listener
wg.Add(1)
go startServiceN(t, u, &wg, ready1, ready2, 1)
<-ready1
opts := MQTT.NewClientOptions().AddBroker("tcp://localhost:1883").SetClientId("trivial")
opts.SetDefaultPublishHandler(f)
c := MQTT.NewClient(opts)
_, err = c.Start()
require.NoError(t, err)
filter, _ := MQTT.NewTopicFilter("/go-mqtt/sample", 0)
receipt, err := c.StartSubscription(nil, filter)
require.NoError(t, err)
select {
case <-receipt:
case <-time.After(time.Millisecond * 100):
require.FailNow(t, "Test timed out")
}
for i := 0; i < 100; i++ {
text := fmt.Sprintf("this is msg #%d!", i)
receipt := c.Publish(MQTT.QOS_ONE, "/go-mqtt/sample", []byte(text))
select {
case <-receipt:
case <-time.After(time.Millisecond * 100):
require.FailNow(t, "Test timed out")
}
}
time.Sleep(3 * time.Second)
receipt, err = c.EndSubscription("/go-mqtt/sample")
require.NoError(t, err)
select {
case <-receipt:
case <-time.After(time.Millisecond * 100):
require.FailNow(t, "Test timed out")
}
c.Disconnect(250)
close(ready2)
wg.Wait()
}
func main() {
topic := flag.String("topic", "", "The topic name to/from which to publish/subscribe")
broker := flag.String("broker", "", "The broker URI. ex: tcp://10.10.1.1:1883")
password := flag.String("password", "", "The password (optional)")
user := flag.String("user", "", "The User (optional)")
id := flag.String("id", "", "The ClientID (optional)")
cleansess := flag.Bool("clean", false, "Set Clean Session (default false)")
qos := flag.Int("qos", 0, "The Quality of Service 0,1,2 (default 0)")
num := flag.Int("num", 1, "The number of messages to publish or subscribe (default 1)")
payload := flag.String("message", "", "The message text to publish (default empty)")
action := flag.String("action", "", "Action publish or subscribe (required)")
store := flag.String("store", ":memory:", "The Store Directory (default use memory store)")
flag.Parse()
if *broker == "" {
fmt.Println("Invalid setting for -broker")
return
}
if *action != "pub" && *action != "sub" {
fmt.Println("Invalid setting for -action, must be pub or sub")
return
}
if *topic == "" {
fmt.Println("Invalid setting for -topic, must not be empty")
return
}
fmt.Printf("Sample Info:\n")
fmt.Printf("\taction: %s\n", *action)
fmt.Printf("\tbroker: %s\n", *broker)
fmt.Printf("\tclientid: %s\n", *id)
fmt.Printf("\tuser: %s\n", *user)
fmt.Printf("\tpassword: %s\n", *password)
fmt.Printf("\ttopic: %s\n", *topic)
fmt.Printf("\tmessage: %s\n", *payload)
fmt.Printf("\tqos: %d\n", *qos)
fmt.Printf("\tcleansess: %v\n", *cleansess)
fmt.Printf("\tnum: %d\n", *num)
fmt.Printf("\tstore: %s\n", *store)
opts := MQTT.NewClientOptions()
opts.AddBroker(*broker)
opts.SetClientId(*id)
opts.SetUsername(*user)
opts.SetPassword(*password)
opts.SetCleanSession(*cleansess)
if *store != ":memory:" {
opts.SetStore(MQTT.NewFileStore(*store))
}
if *action == "pub" {
client := MQTT.NewClient(opts)
_, err := client.Start()
gotareceipt := make(chan bool)
if err != nil {
panic(err)
}
fmt.Println("Sample Publisher Started")
for i := 0; i < *num; i++ {
fmt.Println("---- doing publish ----")
receipt := client.Publish(MQTT.QoS(*qos), *topic, []byte(*payload))
go func() {
<-receipt
fmt.Println(" message delivered!")
gotareceipt <- true
}()
}
for i := 0; i < *num; i++ {
<-gotareceipt
}
client.Disconnect(250)
fmt.Println("Sample Publisher Disconnected")
} else {
num_received := 0
choke := make(chan [2]string)
opts.SetDefaultPublishHandler(func(client *MQTT.MqttClient, msg MQTT.Message) {
choke <- [2]string{msg.Topic(), string(msg.Payload())}
})
client := MQTT.NewClient(opts)
_, err := client.Start()
if err != nil {
panic(err)
}
filter, e := MQTT.NewTopicFilter(*topic, byte(*qos))
if e != nil {
fmt.Println(e)
os.Exit(1)
}
client.StartSubscription(nil, filter)
for num_received < *num {
incoming := <-choke
fmt.Printf("RECEIVED TOPIC: %s MESSAGE: %s\n", incoming[0], incoming[1])
num_received++
}
client.Disconnect(250)
fmt.Println("Sample Subscriber Disconnected")
}
}