Beispiel #1
0
func Publish(client *MQTT.MqttClient, topic, message string) error {
	topicName := config.user + "/" + topic
	qos := 0

	receipt := client.Publish(MQTT.QoS(qos), topicName, message)
	<-receipt // Publish成功を待ち受ける

	return nil
}
Beispiel #2
0
func (m *MQTTClient) Publish(topic string, payload []byte, qos int, retain bool) error {
	mqttmsg := MQTT.NewMessage(payload)
	// FIXME: validate qos number
	mqttmsg.SetQoS(MQTT.QoS(qos))
	mqttmsg.SetRetainedFlag(retain)

	receipt := m.Client.PublishMessage(topic, mqttmsg)
	<-receipt

	return nil
}
Beispiel #3
0
// connects MQTT broker
func connect(c *cli.Context, opts *MQTT.ClientOptions) (*MQTTClient, error) {
	log.Info("Connecting...")

	willPayload := c.String("will-payload")
	willQoS := c.Int("will-qos")
	willRetain := c.Bool("will-retain")
	willTopic := c.String("will-topic")
	if willPayload != "" && willTopic != "" {
		opts.SetWill(willTopic, willPayload, MQTT.QoS(willQoS), willRetain)
	}

	client := &MQTTClient{Opts: opts}
	_, err := client.Connect()
	if err != nil {
		return nil, err
	}
	log.Info("Connected")

	return client, nil
}
Beispiel #4
0
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")
	}
}
Beispiel #5
0
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")
	}
}