func SetUpChannelGroup() { errorChannel := make(chan []byte) successChannel := make(chan []byte) done := make(chan bool) pubnub := messaging.NewPubnub(config.Keys.Pub, config.Keys.Sub, "", "", false, "") pubnub.SetAuthenticationKey(bootstrapAuth) // Remove Group go pubnub.ChannelGroupRemoveGroup(config.StocksChannelGroup, successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done // Create it from the scratch go pubnub.ChannelGroupAddChannel(config.StocksChannelGroup, stockNames, successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done }
func GrantPermissions() { errorChannel := make(chan []byte) successChannel := make(chan []byte) done := make(chan bool) pubnub := messaging.NewPubnub(config.Keys.Pub, config.Keys.Sub, config.Keys.Secret, "", false, "") pubnub.SetAuthenticationKey(bootstrapAuth) // Allow current Pubnub instance to managet the channel group go pubnub.GrantChannelGroup(config.StocksChannelGroup, false, true, config.GrantTTL, bootstrapAuth, successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done // Allow unauthorized users to subscribe to stockblast channel group go pubnub.GrantChannelGroup(config.StocksChannelGroup, true, false, config.GrantTTL, "", successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done // Unauthorized users can both read and write on chat channel go pubnub.GrantSubscribe(config.ChatChannel, true, true, config.GrantTTL, "", successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done // Unauthorized users can only read history go pubnub.GrantSubscribe(config.HistoryChannel, true, false, config.GrantTTL, "", successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done // Allow stock tickers authorized by auths.Auth key to publish to stock // channels go pubnub.GrantSubscribe(stockNames, false, true, config.GrantTTL, config.Keys.Auth, successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) <-done }
// publishRoutine asks the user the message to send to the pubnub channel(s) and // calls the Publish routine of the messaging package as a parallel // process. If we have multiple pubnub channels then this method will spilt the // channel by comma and send the message on all the pubnub channels. func publishRoutine(channels string, message string) { errorChannel := make(chan []byte) successChannel := make(chan []byte) fmt.Println("Publishing message: ", message) go pub.Publish(channels, message, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Publish") }
// UnsubscribePresenceRoutine calls the PresenceUnsubscribe routine of the messaging package as a parallel // process. All the channels in the _connectChannels string will be unsubscribed. func unsubscribePresenceRoutine(channels string) { var errorChannel = make(chan []byte) channel := make(chan []byte) channelArray := strings.Split(channels, ",") go pub.PresenceUnsubscribe(channels, channel, errorChannel) go handleUnsubscribeResult(channel, errorChannel, messaging.GetNonSubscribeTimeout(), "UnsubscribePresence", len(channelArray)*2) }
func grantSubscribe(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() ch := q.Get("ch") read := q.Get("r") write := q.Get("w") ttl := q.Get("ttl") bRead := false if read == "1" { bRead = true } bWrite := false if write == "1" { bWrite = true } iTTL := 1440 if ival, err := strconv.Atoi(ttl); err == nil { iTTL = ival } uuid := q.Get("uuid") pubInstance := messaging.NewPubnub(publishKey, subscribeKey, secretKey, "", true, uuid) errorChannel := make(chan []byte) successChannel := make(chan []byte) go pubInstance.GrantSubscribe(ch, bRead, bWrite, iTTL, "", successChannel, errorChannel) handleResult(w, r, uuid, successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Revoke Subscribe") }
// WhereNowRoutine func whereNowRoutine(uuid string) { fmt.Println("WhereNow ", uuid) var errorChannel = make(chan []byte) successChannel := make(chan []byte) go pub.WhereNow(uuid, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "WhereNow") }
func globalHereNowRoutine(showUuid bool, includeUserState bool) { fmt.Println("Global here now ", uuid) var errorChannel = make(chan []byte) successChannel := make(chan []byte) go pub.GlobalHereNow(showUuid, includeUserState, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Global Here Now") }
// detailedHistoryRoutine calls the History routine of the messaging package as a parallel // process. If we have multiple pubnub channels then this method will spilt the _connectChannels // by comma and send the message on all the pubnub channels. func detailedHistoryRoutine(channels string, startTime int64) { errorChannel := make(chan []byte) channel := make(chan []byte) fmt.Println(fmt.Sprintf("Page Size :%d", pageSize)) go pub.History(channels, pageSize, startTime, 0, false, channel, errorChannel) go handleDetailedHistoryResult(channel, errorChannel, messaging.GetNonSubscribeTimeout(), "Detailed History") }
func addChannelToChannelGroupRoutine(group, channels string) { errorChannel := make(chan []byte) successChannel := make(chan []byte) go pub.ChannelGroupAddChannel(group, channels, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Channel Group Add Channel") }
func removeChannelGroupRoutine(group string) { errorChannel := make(chan []byte) successChannel := make(chan []byte) go pub.ChannelGroupRemoveGroup(group, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Channel Group Remove") }
func pamAuditChannelGroupRoutine(groups, auth string) { var errorChannel = make(chan []byte) var pamChannel = make(chan []byte) go pub.AuditChannelGroup(groups, auth, pamChannel, errorChannel) go handleResult(pamChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Channel Group Audit") }
func pamGrantChannelGroupRoutine(groups, auth string, read, manage bool, ttl int) { var errorChannel = make(chan []byte) var pamChannel = make(chan []byte) go pub.GrantChannelGroup(groups, read, manage, ttl, auth, pamChannel, errorChannel) go handleResult(pamChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Channel Group Grant") }
// pamAuditRoutine calls the AuditPresence or AuditSubscribe routine of the messaging package // as a parallel process. func pamAuditRoutine(channels string, isPresence bool) { var errorChannel = make(chan []byte) var pamChannel = make(chan []byte) if isPresence { go pub.AuditPresence(channels, "", pamChannel, errorChannel) } else { go pub.AuditSubscribe(channels, "", pamChannel, errorChannel) } go handleResult(pamChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Audit") }
func revokeSubscribe(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() ch := q.Get("ch") uuid := q.Get("uuid") pubInstance := messaging.NewPubnub(publishKey, subscribeKey, secretKey, "", true, uuid) errorChannel := make(chan []byte) successChannel := make(chan []byte) go pubInstance.GrantSubscribe(ch, false, false, 0, "", successChannel, errorChannel) handleResult(w, r, uuid, successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Revoke Subscribe") }
func getTime(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() uuid := q.Get("uuid") errorChannel := make(chan []byte) successChannel := make(chan []byte) pubInstance := messaging.NewPubnub(publishKey, subscribeKey, secretKey, "", true, uuid) go pubInstance.GetTime(successChannel, errorChannel) handleResult(w, r, uuid, successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Time") }
// PublishRoutine asks the user the message to send to the pubnub channel(s) and // calls the Publish routine of the messaging package as a parallel // process. If we have multiple pubnub channels then this method will spilt the // channel by comma and send the message on all the pubnub channels. func publishRoutine(channels string, message string) { var errorChannel = make(chan []byte) channelArray := strings.Split(channels, ",") for i := 0; i < len(channelArray); i++ { ch := strings.TrimSpace(channelArray[i]) fmt.Println("Publish to channel: ", ch) channel := make(chan []byte) go pub.Publish(ch, message, channel, errorChannel) go handleResult(channel, errorChannel, messaging.GetNonSubscribeTimeout(), "Publish") } }
// HereNowRoutine calls the HereNow routine of the messaging package as a parallel // process. If we have multiple pubnub channels then this method will spilt the _connectChannels // by comma and send the message on all the pubnub channels. func hereNowRoutine(channels string, showUuid bool, includeUserState bool) { var errorChannel = make(chan []byte) channelArray := strings.Split(channels, ",") for i := 0; i < len(channelArray); i++ { channel := make(chan []byte) ch := strings.TrimSpace(channelArray[i]) fmt.Println("HereNow for channel: ", ch) go pub.HereNow(ch, showUuid, includeUserState, channel, errorChannel) go handleResult(channel, errorChannel, messaging.GetNonSubscribeTimeout(), "HereNow") } }
func setUserStateJSON(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() ch := q.Get("ch") j := q.Get("j") uuid := q.Get("uuid") pubInstance := messaging.NewPubnub(publishKey, subscribeKey, secretKey, "", true, uuid) errorChannel := make(chan []byte) successChannel := make(chan []byte) go pubInstance.SetUserStateJSON(ch, j, successChannel, errorChannel) handleResult(w, r, uuid, successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Set User State JSON") }
// DetailedHistoryRoutine calls the History routine of the messaging package as a parallel // process. If we have multiple pubnub channels then this method will spilt the _connectChannels // by comma and send the message on all the pubnub channels. func detailedHistoryRoutine(channels string) { var errorChannel = make(chan []byte) channelArray := strings.Split(channels, ",") for i := 0; i < len(channelArray); i++ { ch := strings.TrimSpace(channelArray[i]) fmt.Println("DetailedHistory for channel: ", ch) channel := make(chan []byte) //go _pub.History(ch, 100, 13662867154115803, 13662867243518473, false, channel) go pub.History(ch, 100, 0, 0, false, channel, errorChannel) go handleResult(channel, errorChannel, messaging.GetNonSubscribeTimeout(), "Detailed History") } }
func detailedHistory(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() ch := q.Get("ch") uuid := q.Get("uuid") start := q.Get("start") var iStart int64 if strings.TrimSpace(start) != "" { bi := big.NewInt(0) if _, ok := bi.SetString(start, 10); !ok { iStart = 0 } else { iStart = bi.Int64() } } end := q.Get("end") var iEnd int64 if strings.TrimSpace(end) != "" { bi := big.NewInt(0) if _, ok := bi.SetString(end, 10); !ok { iEnd = 0 } else { iEnd = bi.Int64() } } limit := q.Get("limit") reverse := q.Get("reverse") iLimit := 100 if ival, err := strconv.Atoi(limit); err == nil { iLimit = ival } bReverse := false if reverse == "1" { bReverse = true } pubInstance := messaging.NewPubnub(publishKey, subscribeKey, secretKey, "", true, uuid) errorChannel := make(chan []byte) successChannel := make(chan []byte) go pubInstance.History(ch, iLimit, iStart, iEnd, bReverse, false, successChannel, errorChannel) handleResult(w, r, uuid, successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Detailed History") }
func globalHereNow(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() uuid := q.Get("uuid") globalHereNowShowUUID := q.Get("showUUID") globalHereNowIncludeUserState := q.Get("includeUserState") disableUUID := false includeUserState := false if globalHereNowShowUUID == "1" { disableUUID = true } if globalHereNowIncludeUserState == "1" { includeUserState = true } errorChannel := make(chan []byte) successChannel := make(chan []byte) pubInstance := messaging.NewPubnub(publishKey, subscribeKey, secretKey, "", true, uuid) go pubInstance.GlobalHereNow(disableUUID, includeUserState, successChannel, errorChannel) handleResult(w, r, uuid, successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Global Here Now") }
// PublishMessages calls the publish method of messaging package numberOfMessages times // and appends the count with the message to distinguish from the others. // // Parameters: // pubnubInstance: a reference of *messaging.Pubnub, // channel: the pubnub channel to publish the messages, // t: a reference to *testing.T, // startMessagesFrom: the message identifer, // numberOfMessages: number of messages to send, // message: message to send. // // returns a bool if the publish of all messages is successful. func PublishMessages(pubnubInstance *messaging.Pubnub, channel string, t *testing.T, startMessagesFrom int, numberOfMessages int, message string) bool { messagesReceived := 0 messageToSend := "" tOut := messaging.GetNonSubscribeTimeout() messaging.SetNonSubscribeTimeout(30) for i := startMessagesFrom; i < startMessagesFrom+numberOfMessages; i++ { messageToSend = message + strconv.Itoa(i) returnPublishChannel := make(chan []byte) errorChannel := make(chan []byte) go pubnubInstance.Publish(channel, messageToSend, returnPublishChannel, errorChannel) messagesReceived++ //time.Sleep(500 * time.Millisecond) time.Sleep(1500 * time.Millisecond) } if messagesReceived == numberOfMessages { return true } messaging.SetNonSubscribeTimeout(tOut) return false }
func (stock *Stock) UpdateValuesAndPublish(pubnub *messaging.Pubnub, cycle chan bool) { if stock.CurrentPrice == 0 { stock.CurrentPrice = stock.InitialPrice } rand.Seed(int64(time.Now().Nanosecond())) change := float64(rand.Intn(stock.Volatility)-stock.Volatility/2) / 100 stock.CurrentPrice = stock.CurrentPrice + float64(change) delta := stock.CurrentPrice - stock.InitialPrice percentage := Roundn((1-stock.InitialPrice/stock.CurrentPrice)*100, 2) vol := Randn(stock.Volatility, 1000) * 10 streamMessage := StreamMessage{ Time: time.Now().Format(TIME_FORMAT), Price: fmt.Sprintf("%.2f", stock.CurrentPrice), Delta: fmt.Sprintf("%.2f", delta), Percentage: fmt.Sprintf("%.2f", percentage), Vol: vol} if math.Abs(percentage) > float64(stock.MaxDelta)/100 { stock.CurrentPrice = stock.InitialPrice } errorChannel := make(chan []byte) successChannel := make(chan []byte) done := make(chan bool) go pubnub.Publish(stock.Name, streamMessage, successChannel, errorChannel) go handleResponse(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), done) sleep := Randn(stock.MinTrade, stock.MaxTrade) time.Sleep(time.Duration(sleep) * time.Microsecond) cycle <- <-done }
// PublishMessages calls the publish method of messaging package numberOfMessages times // and appends the count with the message to distinguish from the others. // // Parameters: // pubnubInstance: a reference of *messaging.Pubnub, // channel: the pubnub channel to publish the messages, // t: a reference to *testing.T, // startMessagesFrom: the message identifer, // numberOfMessages: number of messages to send, // message: message to send. // // returns a bool if the publish of all messages is successful. func PublishMessages(pubnubInstance *messaging.Pubnub, channel string, t *testing.T, startMessagesFrom int, numberOfMessages int, message string, sleep func(int)) bool { assert := assert.New(t) messagesReceived := 0 messageToSend := "" tOut := messaging.GetNonSubscribeTimeout() messaging.SetNonSubscribeTimeout(30) successChannel := make(chan []byte) errorChannel := make(chan []byte) for i := startMessagesFrom; i < startMessagesFrom+numberOfMessages; i++ { messageToSend = message + strconv.Itoa(i) go pubnubInstance.Publish(channel, messageToSend, successChannel, errorChannel) select { case <-successChannel: messagesReceived++ case err := <-errorChannel: assert.Fail("Failed to get channel list", string(err)) case <-messaging.Timeout(): assert.Fail("WhereNow timeout") } } sleep(3) if messagesReceived == numberOfMessages { return true } messaging.SetNonSubscribeTimeout(tOut) return false }
// pamPresenceRoutine calls the GrantPresence routine of the messaging package // as a parallel process. This is used to grant or revoke the R, W permissions // to revoke set read and write false and ttl as -1 func pamPresenceRoutine(channels string, read bool, write bool, ttl int) { var errorChannel = make(chan []byte) var pamChannel = make(chan []byte) go pub.GrantPresence(channels, read, write, ttl, "", pamChannel, errorChannel) go handleResult(pamChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Presence Grant") }
// TimeRoutine calls the GetTime routine of the messaging package as a parallel // process. func timeRoutine() { var errorChannel = make(chan []byte) channel := make(chan []byte) go pub.GetTime(channel, errorChannel) go handleResult(channel, errorChannel, messaging.GetNonSubscribeTimeout(), "Time") }
func setUserStateJSON(channel string, jsonString string) { var errorChannel = make(chan []byte) var successChannel = make(chan []byte) go pub.SetUserStateJSON(channel, jsonString, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Set User State JSON") }
func getUserState(channel string) { var errorChannel = make(chan []byte) var successChannel = make(chan []byte) go pub.GetUserState(channel, successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Get User State") }
func delUserState(channel string, key string) { var errorChannel = make(chan []byte) var successChannel = make(chan []byte) go pub.SetUserStateKeyVal(channel, key, "", successChannel, errorChannel) go handleResult(successChannel, errorChannel, messaging.GetNonSubscribeTimeout(), "Del User State") }