func main() {
origin := "http://localhost:8000/"
url := os.Args[1]
secret := os.Args[2]
clients, _ := strconv.Atoi(os.Args[3])
fmt.Printf("clients: %d\n", clients)
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
token := auth.GenerateClientToken(secret, "test", timestamp, "")
connectMessage := fmt.Sprintf("{\"params\": {\"timestamp\": \"%s\", \"token\": \"%s\", \"user\": \"test\"}, \"method\": \"connect\"}", timestamp, token)
subscribeMessage := "{\"params\": {\"channel\": \"test\"}, \"method\": \"subscribe\"}"
done := make(chan struct{})
for i := 0; i < clients; i += 1 {
chSub := make(chan struct{})
go subscriber(chSub, url, origin, connectMessage, subscribeMessage)
<-chSub
fmt.Printf("\r%d", i+1)
}
// Just run until interrupted keeping connections open.
<-done
}
func NewClient(num int, wg *sync.WaitGroup, done chan bool) *Client {
user := strconv.Itoa(num)
timestamp := centrifuge.Timestamp()
token := auth.GenerateClientToken(*secret, user, timestamp, "")
client := &Client{wg: wg, done: done}
creds := ¢rifuge.Credentials{
User: user,
Timestamp: timestamp,
Info: "",
Token: token,
}
events := ¢rifuge.EventHandler{
OnDisconnect: client.DisconnectHandler,
OnPrivateSub: nil,
OnRefresh: nil,
}
cent := centrifuge.NewCentrifuge(wsUrl, creds, events, centrifuge.DefaultConfig)
delay := time.Duration(*msgDelay) * time.Millisecond
client.creds = creds
client.cent = cent
client.delay = delay
return client
}
func newConnection(n int) centrifuge.Centrifuge {
secret := "secret"
// Application user ID.
user := strconv.Itoa(n)
// Current timestamp as string.
timestamp := centrifuge.Timestamp()
// Empty info.
info := ""
// Generate client token so Centrifugo server can trust connection parameters received from client.
token := auth.GenerateClientToken(secret, user, timestamp, info)
creds := ¢rifuge.Credentials{
User: user,
Timestamp: timestamp,
Info: info,
Token: token,
}
wsURL := "ws://localhost:8000/connection/websocket"
c := centrifuge.NewCentrifuge(wsURL, creds, nil, centrifuge.DefaultConfig)
err := c.Connect()
if err != nil {
log.Fatalln(err)
}
return c
}
func testRefreshCmd(timestamp string) clientCommand {
token := auth.GenerateClientToken("secret", "user1", timestamp, "")
refreshCmd := RefreshClientCommand{
Timestamp: timestamp,
User: UserID("user1"),
Info: "",
Token: token,
}
cmdBytes, _ := json.Marshal(refreshCmd)
cmd := clientCommand{
Method: "refresh",
Params: cmdBytes,
}
return cmd
}
func testConnectCmd(timestamp string) clientCommand {
token := auth.GenerateClientToken("secret", "test1", "user1", timestamp, "")
connectCmd := connectClientCommand{
Project: ProjectKey("test1"),
Timestamp: timestamp,
User: UserID("user1"),
Info: "",
Token: token,
}
cmdBytes, _ := json.Marshal(connectCmd)
cmd := clientCommand{
Method: "connect",
Params: cmdBytes,
}
return cmd
}
func credentials() *centrifuge.Credentials {
secret := "secret"
// Application user ID.
user := "******"
// Current timestamp as string.
timestamp := centrifuge.Timestamp()
// Empty info.
info := ""
// Generate client token so Centrifugo server can trust connection parameters received from client.
token := auth.GenerateClientToken(secret, user, timestamp, info)
return ¢rifuge.Credentials{
User: user,
Timestamp: timestamp,
Info: info,
Token: token,
}
}
func main() {
origin := "http://localhost:8000/"
url := os.Args[1]
secret := os.Args[2]
maxClients, _ := strconv.Atoi(os.Args[3])
increment, _ := strconv.Atoi(os.Args[4])
repeats, _ := strconv.Atoi(os.Args[5])
fmt.Printf("max clients: %d\n", maxClients)
fmt.Printf("increment: %d\n", increment)
fmt.Printf("repeat: %d\n", repeats)
messagesReceived := 0
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
token := auth.GenerateClientToken(secret, "test", timestamp, "")
connectMessage := fmt.Sprintf("{\"params\": {\"timestamp\": \"%s\", \"token\": \"%s\", \"user\": \"test\"}, \"method\": \"connect\"}", timestamp, token)
subscribeMessage := "{\"params\": {\"channel\": \"test\"}, \"method\": \"subscribe\"}"
publishMessage := "{\"params\": {\"data\": {\"input\": \"I am benchmarking Centrifuge at moment\"}, \"channel\": \"test\"}, \"method\": \"publish\"}"
chSub := make(chan int)
chMsg := make(chan int)
chStart := make(chan int)
chTrigger := make(chan int)
chTime := make(chan time.Time)
var startTime time.Time
totalTime := 0.0
fullTime := 0.0
go func() {
publisher(chTrigger, chTime, url, origin, connectMessage, subscribeMessage, publishMessage)
}()
for i := 0; i < maxClients; i += increment {
time.Sleep(50 * time.Millisecond)
totalTime = 0
for j := 0; j < increment; j++ {
time.Sleep(5 * time.Millisecond)
go func() {
subscriber(chSub, chMsg, chStart, url, origin, connectMessage, subscribeMessage, publishMessage)
}()
<-chSub
}
currentClients := i + increment
// repeat several times to get average time value
for k := 0; k < repeats; k++ {
time.Sleep(100 * time.Millisecond)
fullTime = 0.0
messagesReceived = 0
// publish message
chTrigger <- 1
startTime = <-chTime
for {
<-chMsg
messagesReceived += 1
elapsed := time.Since(startTime)
fullTime += float64(elapsed)
if messagesReceived == currentClients {
break
}
}
totalTime += fullTime / float64(currentClients)
}
fmt.Printf("%d\t%d\n", currentClients, int(totalTime/float64(repeats)))
}
}
func main() {
// Never show secret to client of your application. Keep it on your application backend only.
secret := "secret"
// Application user ID.
user := "******"
// Current timestamp as string.
timestamp := centrifuge.Timestamp()
// Empty info.
info := ""
// Generate client token so Centrifugo server can trust connection parameters received from client.
token := auth.GenerateClientToken(secret, user, timestamp, info)
creds := ¢rifuge.Credentials{
User: user,
Timestamp: timestamp,
Info: info,
Token: token,
}
started := time.Now()
wsURL := "ws://localhost:8000/connection/websocket"
c := centrifuge.NewCentrifuge(wsURL, creds, nil, centrifuge.DefaultConfig)
defer c.Close()
err := c.Connect()
if err != nil {
log.Fatalln(err)
}
onMessage := func(sub centrifuge.Sub, msg centrifuge.Message) error {
log.Println(fmt.Sprintf("New message received in channel %s: %#v", sub.Channel(), msg))
return nil
}
onJoin := func(sub centrifuge.Sub, msg centrifuge.ClientInfo) error {
log.Println(fmt.Sprintf("User %s joined channel %s with client ID %s", msg.User, sub.Channel(), msg.Client))
return nil
}
onLeave := func(sub centrifuge.Sub, msg centrifuge.ClientInfo) error {
log.Println(fmt.Sprintf("User %s with clientID left channel %s with client ID %s", msg.User, msg.Client, sub.Channel()))
return nil
}
events := ¢rifuge.SubEventHandler{
OnMessage: onMessage,
OnJoin: onJoin,
OnLeave: onLeave,
}
sub, err := c.Subscribe("public:chat", events)
if err != nil {
log.Fatalln(err)
}
data := map[string]string{
"input": "test",
}
dataBytes, _ := json.Marshal(data)
err = sub.Publish(dataBytes)
if err != nil {
log.Fatalln(err)
}
history, err := sub.History()
if err != nil {
log.Fatalln(err)
}
log.Printf("%d messages in channel %s history", len(history), sub.Channel())
presence, err := sub.Presence()
if err != nil {
log.Fatalln(err)
}
log.Printf("%d clients in channel %s", len(presence), sub.Channel())
err = sub.Unsubscribe()
if err != nil {
log.Fatalln(err)
}
log.Printf("%s", time.Since(started))
}