Example #1
0
// publish
func publish(ccmd *cobra.Command, args []string) error {

	// missing tags
	if tags == nil {
		fmt.Println("Unable to publish - Missing tags")
		return fmt.Errorf("")
	}

	// missing data
	if data == "" {
		fmt.Println("Unable to publish - Missing data")
		return fmt.Errorf("")
	}

	client, err := clients.New(host, viper.GetString("token"))
	if err != nil {
		fmt.Printf("Failed to connect to '%v' - %v\n", host, err)
		return err
	}

	err = client.Publish(tags, data)
	if err != nil {
		fmt.Printf("Failed to publish message - %v\n", err)
		return err
	}

	fmt.Println("success")

	return nil
}
Example #2
0
func startPulse(ccmd *cobra.Command, args []string) error {
	// re-initialize logger
	lumber.Level(lumber.LvlInt(viper.GetString("log-level")))

	plex := plexer.NewPlexer()

	if viper.GetString("mist-address") != "" {
		mist, err := mist.New(viper.GetString("mist-address"), viper.GetString("mist-token"))
		if err != nil {
			return fmt.Errorf("Mist failed to start - %s", err.Error())
		}
		plex.AddObserver("mist", mist.Publish)
		defer mist.Close()
	}

	plex.AddBatcher("influx", influx.Insert)

	err := pulse.Listen(viper.GetString("server-listen-address"), plex.Publish)
	if err != nil {
		return fmt.Errorf("Pulse failed to start - %s", err.Error())
	}
	// begin polling the connected servers
	pollSec := viper.GetInt("poll-interval")
	if pollSec == 0 {
		pollSec = 60
	}
	go pulse.StartPolling(nil, nil, time.Duration(pollSec)*time.Second, nil)

	queries := []string{
		"CREATE DATABASE statistics",
		"CREATE RETENTION POLICY one_day ON statistics DURATION 8h REPLICATION 1 DEFAULT",
		fmt.Sprintf("CREATE RETENTION POLICY one_week ON statistics DURATION %dw REPLICATION 1", viper.GetInt("retention")), // todo: ALTER as well?
	}

	for _, query := range queries {
		_, err := influx.Query(query)
		if err != nil {
			return fmt.Errorf("Failed to query influx - %s", err.Error())
		}
	}

	go influx.KeepContinuousQueriesUpToDate()

	if viper.GetString("kapacitor-address") != "" {
		err := kapacitor.Init()
		if err != nil {
			return fmt.Errorf("Kapacitor failed to start - %s", err.Error())
		}
	}

	err = api.Start()
	if err != nil {
		return fmt.Errorf("Api failed to start - %s", err.Error())
	}

	return nil
}
Example #3
0
func (m *Mist) retryPublish(tags []string, data string) error {
	c, err := mistCore.New(m.address, config.PubAuth)
	if err != nil {
		return fmt.Errorf("Failed to redial mist - %v", err)
	}

	m.mist = c

	return m.mist.Publish(tags, data)
}
Example #4
0
// TestBadTCPClientConnect tests to ensure a client can connect to a running server
func TestBadTCPClientConnect(t *testing.T) {
	client, err := clients.New("321321321", "")
	if err == nil {
		t.Fatalf("Client succeeded to connect")
	}
	client, err = clients.New(testAddr, "hil")
	if err != nil {
		t.Fatalf("Client failed to connect - %v", err.Error())
		t.FailNow()
	}
	defer client.Close()

	//
	if err := client.Ping(); err != nil {
		t.Fatalf("ping failed")
	}
	if msg := <-client.Messages(); msg.Data != "pong" {
		t.Fatalf("Unexpected data: Expecting 'pong' got %s", msg.Data)
	}
	client.Ping()
}
Example #5
0
// NewMistClient creates a new mist publisher
func NewMistClient(address string) (*Mist, error) {
	c, err := mistCore.New(address, config.PubAuth)
	if err != nil {
		return nil, err
	}

	m := Mist{
		address: address,
		mist:    c,
	}

	return &m, nil
}
Example #6
0
// ping
func ping(ccmd *cobra.Command, args []string) error {

	client, err := clients.New(host, viper.GetString("token"))
	if err != nil {
		fmt.Printf("Failed to connect to '%v' - %v\n", host, err)
		return err
	}

	err = client.Ping()
	if err != nil {
		fmt.Printf("Failed to ping - %v\n", err)
		return err
	}

	msg := <-client.Messages()
	fmt.Println(msg.Data)

	return nil
}
Example #7
0
File: who.go Project: nanopack/mist
// who gets connection stats for a mist server
func who(ccmd *cobra.Command, args []string) error {

	// create new mist client
	client, err := clients.New(host, viper.GetString("token"))
	if err != nil {
		fmt.Printf("Failed to connect to '%v' - %v\n", host, err)
		return err
	}

	// who related
	err = client.Who()
	if err != nil {
		fmt.Printf("Failed to who - %v\n", err)
		return err
	}

	msg := <-client.Messages()
	fmt.Println(msg.Data)

	return nil
}
Example #8
0
// subscribe
func subscribe(ccmd *cobra.Command, args []string) error {

	// missing tags
	if tags == nil {
		fmt.Println("Unable to subscribe - Missing tags")
		return fmt.Errorf("")
	}

	client, err := clients.New(host, viper.GetString("token"))
	if err != nil {
		fmt.Printf("Failed to connect to '%v' - %v\n", host, err)
		return err
	}

	//
	if err := client.Subscribe(tags); err != nil {
		fmt.Printf("Unable to subscribe - %v\n", err.Error())
		return fmt.Errorf("")
	}

	// listen for messages on tags
	fmt.Printf("Listening on tags '%v'\n", tags)
	for msg := range client.Messages() {

		// skip handler messages
		if msg.Data != "success" {
			if viper.GetString("log-level") == "DEBUG" {
				fmt.Printf("Message: %#v\n", msg)
			} else {
				fmt.Println(msg.Data)
			}
		}
	}

	return nil
}
Example #9
0
// TestTCPClient tests to ensure a client can run all of its expected commands;
// we don't have to actually test any of the results of the commands since those
// are already tested in other tests (proxy_test and subscriptions_test in the
// core package)
func TestTCPClient(t *testing.T) {

	//
	client, err := clients.New(testAddr, "")
	if err != nil {
		t.Fatalf("failed to connect - %v", err.Error())
		t.FailNow()
	}
	defer client.Close()

	// subscribe should fail with no tags
	if err := client.Subscribe([]string{}); err == nil {
		t.Fatalf("Subscription succeeded with missing tags!")
	}

	// test ability to subscribe
	if err := client.Subscribe([]string{"a"}); err != nil {
		t.Fatalf("client subscriptions failed %v", err.Error())
	}

	// test ability to list (subscriptions)
	if err := client.List(); err != nil {
		t.Fatalf("listing subscriptions failed %v", err.Error())
	}
	if msg := <-client.Messages(); msg.Data == "\"a\"" {
		t.Fatalf("Failed to 'list' - '%v' '%#v'", msg.Error, msg.Data)
	}

	// test publish
	if err := client.Publish([]string{"a"}, "testpublish"); err != nil {
		t.Fatalf("publishing failed %v", err.Error())
	}
	if err := client.Publish([]string{}, "nopublish"); err == nil {
		t.Fatalf("publishing no tags succeeded %v", err.Error())
	}
	if err := client.Publish([]string{"a"}, ""); err == nil {
		t.Fatalf("publishing no data succeeded %v", err.Error())
	}

	// test PublishAfter
	if err := client.PublishAfter([]string{"a"}, "testpublish", time.Second); err != nil {
		t.Fatalf("publishing failed %v", err.Error())
	}
	time.Sleep(time.Millisecond * 1500)

	// test ability to unsubscribe
	if err := client.Unsubscribe([]string{"a"}); err != nil {
		t.Fatalf("client unsubscriptions failed %v", err.Error())
	}
	if err := client.Unsubscribe([]string{}); err == nil {
		t.Fatalf("client unsubscriptions no tags succeeded %v", err.Error())
	}

	// test ability to list (no subscriptions)
	if err := client.List(); err != nil {
		t.Fatalf("listing subscriptions failed %v", err.Error())
	}
	if msg := <-client.Messages(); msg.Data != "" {
		t.Fatalf("Failed to 'list' - %v", msg.Error)
	}
}