func main() {
stdin := bufio.NewReader(os.Stdin)
hostname, _ := os.Hostname()
server := flag.String("server", "tcp://127.0.0.1:1883", "The full URL of the MQTT server to connect to")
topic := flag.String("topic", hostname, "Topic to publish the messages on")
qos := flag.Int("qos", 0, "The QoS to send the 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().AddBroker(*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)
}
for {
message, err := stdin.ReadString('\n')
if err == io.EOF {
os.Exit(0)
}
r := client.Publish(MQTT.QoS(*qos), *topic, []byte(strings.TrimSpace(message)))
<-r
fmt.Println("Message Sent")
}
}
func (p *MQTTPublisher) start() {
logger.Println("MQTTPublisher.start()")
if p.config.Discover && p.config.URL == "" {
err := p.discoverBrokerEndpoint()
if err != nil {
logger.Println("MQTTPublisher.start() failed to start publisher:", err.Error())
return
}
}
// configure the mqtt client
p.configureMqttConnection()
// start the connection routine
logger.Printf("MQTTPublisher.start() Will connect to the broker %v\n", p.config.URL)
go p.connect(0)
qos := 1
prefix := p.config.Prefix
for resp := range p.dataCh {
if !p.client.IsConnected() {
logger.Println("MQTTPublisher.start() got data while not connected to the broker. **discarded**")
continue
}
if resp.IsError {
logger.Println("MQTTPublisher.start() data ERROR from agent manager:", string(resp.Payload))
continue
}
topic := fmt.Sprintf("%s/%s", prefix, resp.ResourceId)
p.client.Publish(MQTT.QoS(qos), topic, resp.Payload)
// We dont' wait for confirmation from broker (avoid blocking here!)
//<-r
logger.Println("MQTTPublisher.start() published to", topic)
}
}
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")
}
}
