예제 #1
0
파일: main.go 프로젝트: scozssfork/mqtt
func client(i int) {
	log.Print("starting client ", i)
	conn, err := net.Dial("tcp", *host)
	if err != nil {
		log.Fatal("dial: ", err)
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump

	if err := cc.Connect(*user, *pass); err != nil {
		log.Fatalf("connect: %v\n", err)
		os.Exit(1)
	}

	half := int32(*pace / 2)

	for {
		cc.Publish(&proto.Publish{
			Header:    proto.Header{},
			TopicName: topic,
			Payload:   payload,
		})
		sltime := rand.Int31n(half) - (half / 2) + int32(*pace)
		time.Sleep(time.Duration(sltime) * time.Second)
	}
}
예제 #2
0
파일: msgr.go 프로젝트: josh-kaplan/go-mqtt
/**
 * A subscriber impementation. The subscriber listens for incoming
 * messages from the publisher and handles those messages.
 */
func sub() {
	if flag.NArg() < 2 {
		fmt.Fprintln(os.Stderr, "usage: sub topic [topic topic...]")
		return
	}

	conn, err := net.Dial("tcp", "localhost:4000")
	if err != nil {
		die(err)
	}
	cc := mqtt.NewClientConn(conn)
	//cc.Dump = false
	//cc.ClientId = ""

	tq := make([]proto.TopicQos, flag.NArg())
	for i := 1; i < flag.NArg(); i++ {
		tq[i].Topic = flag.Arg(i)
		tq[i].Qos = proto.QosAtMostOnce
	}

	if err := cc.Connect("no-user", "no-pass"); err != nil {
		fmt.Fprintf(os.Stderr, "connect: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("Connected with client id ", cc.ClientId)
	cc.Subscribe(tq)

	for m := range cc.Incoming {
		fmt.Print("\033[94m\033[1m", m.TopicName, ": \033[0m\033[1m")
		m.Payload.WritePayload(os.Stdout)
		fmt.Println("\033[0m")
		// fmt.Println("\tr: ", m.Header.Retain)
	}
}
예제 #3
0
파일: mqtt.go 프로젝트: x4rMa/jeebus
// Start listening and subscribing to MQTT.
func (w *MQTTSub) Run() {
	port := getInputOrConfig(w.Port, "MQTT_PORT")
	sock, err := net.Dial("tcp", port)
	flow.Check(err)
	client := mqtt.NewClientConn(sock)
	err = client.Connect("", "")
	flow.Check(err)

	for t := range w.In {
		topic := t.(string)
		glog.V(2).Infoln("mqtt-sub", topic)
		if strings.HasSuffix(topic, "/") {
			topic += "#" // if it looks like a prefix, append "#" for MQTT
		}
		client.Subscribe([]proto.TopicQos{{
			Topic: topic,
			Qos:   proto.QosAtMostOnce,
		}})
	}

	for m := range client.Incoming {
		payload := []byte(m.Payload.(proto.BytesPayload))
		// try to decode as JSON, but leave as []byte if that fails
		var any interface{}
		if err = json.Unmarshal(payload, &any); err != nil {
			any = payload
		}
		w.Out.Send(flow.Tag{m.TopicName, any})
	}
}
예제 #4
0
파일: main.go 프로젝트: rexpie/mqtt
func main() {
	flag.Parse()

	if flag.NArg() != 2 {
		fmt.Fprintln(os.Stderr, "usage: pub topic message")
		return
	}

	conn, err := net.Dial("tcp", *host)
	if err != nil {
		fmt.Fprint(os.Stderr, "dial: ", err)
		return
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump

	if err := cc.Connect(*user, *pass); err != nil {
		fmt.Fprintf(os.Stderr, "connect: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("Connected with client id ", cc.ClientId)

	cc.Publish(&proto.Publish{
		Header:    proto.Header{Retain: *retain},
		TopicName: flag.Arg(0),
		Payload:   proto.BytesPayload([]byte(flag.Arg(1))),
	})

	if *wait {
		<-make(chan bool)
	}

	cc.Disconnect()
}
예제 #5
0
파일: msgr.go 프로젝트: josh-kaplan/go-mqtt
/**
 * A publisher implementation. The publisher sends messages to the
 * subscriber.
 */
func pub() {
	conn, err := net.Dial("tcp", "localhost:4000")
	if err != nil {
		die(err)
	}

	cc := mqtt.NewClientConn(conn)
	cc.Dump = false

	if err := cc.Connect("your-username", "your-password"); err != nil {
		die(err)
	}
	fmt.Println("\033[92mConnected with client id ", cc.ClientId)

	cc.Publish(&proto.Publish{
		Header:    proto.Header{Retain: false},
		TopicName: flag.Arg(1),
		Payload:   proto.BytesPayload([]byte(flag.Arg(2))),
	})

	wait := false
	if wait {
		<-make(chan bool)
	}

	cc.Disconnect()
}
예제 #6
0
파일: udpgw.go 프로젝트: kaaLabs15/widuino
func main() {
	flag.Parse()

	// MQTT connection

	mqttSock, err := net.Dial("tcp", *host)
	if err != nil {
		log.Fatalf("MQTT broker: %s", err)
	}
	cc := mqtt.NewClientConn(mqttSock)
	cc.ClientId = *id
	if err := cc.Connect(*user, *pass); err != nil {
		log.Fatalf("Mqtt connect failed: %v\n", err)
	}
	log.Println("Connected with client id", cc.ClientId)

	// UDP Socket

	udpAddr := net.UDPAddr{Port: *udp}
	udpSock, err := net.ListenUDP("udp4", &udpAddr)
	if err != nil {
		log.Fatalf("Can't listen to UDP :%d : %s", *udp, err.Error())
	}
	log.Printf("Listening on UDP port %d", *udp)
	go udpServer(udpSock, cc)

	// do some work..
	mqttServer(cc, udpSock)
}
예제 #7
0
//Publish MQTT message, takes topic as a string, data as a byte array and retain flag as bool
func (c *Client) Publish(topic string, data string, retain bool) error {

	con, err := net.Dial("tcp", c.Port)
	if err != nil {
		return err
	}

	ccPub := mqtt.NewClientConn(con)

	err = ccPub.Connect("", "")
	if err != nil {
		return err
	}

	ccPub.Publish(&proto.Publish{
		Header: proto.Header{
			Retain: retain,
		},
		TopicName: topic,
		Payload:   proto.BytesPayload(data),
	})

	ccPub.Disconnect()

	return nil
}
예제 #8
0
파일: service.go 프로젝트: jeffallen/mqtt
func mqttConnect() (*mqtt.ClientConn, *sync.Mutex, error) {
	conn, err := net.Dial("tcp", *host)
	if err != nil {
		return nil, nil, err
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump
	cc.ClientId = *id

	if err := cc.Connect(*user, *pass); err != nil {
		return nil, nil, err
	}
	return cc, &sync.Mutex{}, err
}
예제 #9
0
파일: main.go 프로젝트: jeffallen/mqtt
func main() {
	flag.Parse()

	conn, err := net.Dial("tcp", *host)
	if err != nil {
		fmt.Fprint(os.Stderr, "dial: ", err)
		return
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump
	cc.ClientId = *id

	tq := []proto.TopicQos{
		{Topic: "tick", Qos: proto.QosAtMostOnce},
	}

	if err := cc.Connect(*user, *pass); err != nil {
		fmt.Fprintf(os.Stderr, "connect: %v\n", err)
		os.Exit(1)
	}

	cc.Subscribe(tq)

	// Sender
	go func() {
		for {
			now := time.Now()
			what := fmt.Sprintf("%v at %v", *who, now)

			cc.Publish(&proto.Publish{
				Header:    proto.Header{Retain: false},
				TopicName: "tick",
				Payload:   proto.BytesPayload([]byte(what)),
			})

			time.Sleep(*delay)
		}
	}()

	// Receiver
	for m := range cc.Incoming {
		fmt.Print(m.TopicName, "\t")
		m.Payload.WritePayload(os.Stdout)
		fmt.Println("\tr: ", m.Header.Retain)
	}
}
예제 #10
0
//Subscribe to MQTT Topic, takes topic as a string
func (c *MqttClient) Subscribe(tl []proto.TopicQos) chan *proto.Publish {

	if ccSub == nil {

		con, err := net.Dial("tcp", c.Port)
		gotError(err)

		ccSub = mqtt.NewClientConn(con)

		err = ccSub.Connect("", "")
		gotError(err)
	}

	ccSub.Subscribe(tl)

	return ccSub.Incoming
}
예제 #11
0
func main() {
	flag.Parse()

	if flag.NArg() < 1 {
		log.Fatal("usage: mqttlog topic [topic topic...]")
	}

	// Connect to MQTT broker
	conn, err := net.Dial("tcp", *host)
	if err != nil {
		log.Fatalf("MQTT broker: ", err)
	}
	cc := mqtt.NewClientConn(conn)

	// Send connect message
	if err := cc.Connect(*user, *pass); err != nil {
		log.Fatalf("connect: %s", err)
	}

	// Subscribe to requested topics
	tq := make([]proto.TopicQos, flag.NArg())
	for i := 0; i < flag.NArg(); i++ {
		tq[i].Topic = flag.Arg(i)
		tq[i].Qos = proto.QosAtMostOnce
	}
	cc.Subscribe(tq)

	// Print everything we receive
	log.Println("Connected with client id", cc.ClientId)
	for m := range cc.Incoming {
		payload := []byte(m.Payload.(proto.BytesPayload))
		log.Printf("%s (%d bytes)", m.TopicName, len(payload))
		printable := true
		for _, c := range payload {
			printable = printable && c >= ' ' && c <= '~'
		}
		if printable {
			log.Printf("  %s", payload)
		} else {
			log.Printf("  %q", payload)
		}
	}
}
예제 #12
0
파일: main.go 프로젝트: rexpie/mqtt
func connect() *mqtt.ClientConn {
	conn, err := net.Dial("tcp", *host)
	if err != nil {
		fmt.Fprintf(os.Stderr, "dial: %v\n", err)
		os.Exit(2)
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump
	cc.ClientId = *id

	err = cc.Connect(*user, *pass)
	if err != nil {
		fmt.Println(err)
		return nil
	}

	cwg.Done()
	return cc
}
예제 #13
0
//Publish MQTT message, takes topic as a string, data as a byte array and retain flag as bool
func (c *MqttClient) Publish(topic string, data string, retain bool) {

	if ccPub == nil {
		con, err := net.Dial("tcp", c.Port)
		gotError(err)

		ccPub = mqtt.NewClientConn(con)

		err = ccPub.Connect("", "")
		gotError(err)
	}

	ccPub.Publish(&proto.Publish{
		Header: proto.Header{
			Retain: retain,
		},
		TopicName: topic,
		Payload:   proto.BytesPayload(data),
	})

}
예제 #14
0
파일: main.go 프로젝트: scozssfork/mqtt
func connect(who string) *mqtt.ClientConn {
	tok := <-tokens
	defer func() { tokens <- tok }()

	conn, err := net.Dial("tcp", *host)
	if err != nil {
		fmt.Fprintf(os.Stderr, "dial: %v\n", err)
		os.Exit(2)
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump
	cc.ClientId = who

	err = cc.Connect(*user, *pass)
	if err != nil {
		fmt.Println(err)
		return nil
	}

	cwg.Done()
	return cc
}
예제 #15
0
파일: main.go 프로젝트: rexpie/mqtt
func main() {
	flag.Parse()

	if flag.NArg() < 1 {
		fmt.Fprintln(os.Stderr, "usage: sub topic [topic topic...]")
		return
	}

	conn, err := net.Dial("tcp", *host)
	if err != nil {
		fmt.Fprint(os.Stderr, "dial: ", err)
		return
	}
	cc := mqtt.NewClientConn(conn)
	cc.Dump = *dump
	cc.ClientId = *id

	tq := make([]proto.TopicQos, flag.NArg())
	for i := 0; i < flag.NArg(); i++ {
		tq[i].Topic = flag.Arg(i)
		tq[i].Qos = proto.QosAtMostOnce
	}

	if err := cc.Connect(*user, *pass); err != nil {
		fmt.Fprintf(os.Stderr, "connect: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("Connected with client id ", cc.ClientId)
	cc.Subscribe(tq)

	for m := range cc.Incoming {
		fmt.Print(m.TopicName, "\t")
		m.Payload.WritePayload(os.Stdout)
		fmt.Println("\tr: ", m.Header.Retain)
	}
}
예제 #16
0
파일: mqtt.go 프로젝트: x4rMa/jeebus
// Start publishing to MQTT.
func (w *MQTTPub) Run() {
	port := getInputOrConfig(w.Port, "MQTT_PORT")
	sock, err := net.Dial("tcp", port)
	flow.Check(err)
	client := mqtt.NewClientConn(sock)
	err = client.Connect("", "")
	flow.Check(err)

	for m := range w.In {
		msg := m.(flow.Tag)
		glog.V(1).Infoln("mqtt-pub", msg.Tag, msg.Msg)
		data, ok := msg.Msg.([]byte)
		if !ok {
			data, err = json.Marshal(msg.Msg)
			flow.Check(err)
		}
		retain := len(msg.Tag) > 0 && msg.Tag[0] == '/'
		client.Publish(&proto.Publish{
			Header:    proto.Header{Retain: retain},
			TopicName: msg.Tag,
			Payload:   proto.BytesPayload(data),
		})
	}
}