// ResumeOnReconnect contains the actual impementation of both TestResumeOnReconnectFalse and TestResumeOnReconnectTrue // the parameter b determines of resume on reconnect setting is true or false. func ResumeOnReconnect(t *testing.T, b bool) { testName := "ResumeOnReconnectFalse" if b { pubnubMessaging.SetResumeOnReconnect(true) testName = "ResumeOnReconnectTrue" } else { pubnubMessaging.SetResumeOnReconnect(false) } pubnubChannel := "testChannel" pubnubInstance := pubnubMessaging.PubnubInit("demo", "demo", "", "", false, "") returnSubscribeChannel := make(chan []byte) errorChannelSub := make(chan []byte) responseChannelSub := make(chan string) waitChannelSub := make(chan string) pubnubMessaging.SetSubscribeTimeout(12) go pubnubInstance.Subscribe(pubnubChannel, "", returnSubscribeChannel, false, errorChannelSub) go ParseSubscribeForTimetoken(pubnubInstance, pubnubChannel, returnSubscribeChannel, errorChannelSub, testName, responseChannelSub) go WaitForCompletion(responseChannelSub, waitChannelSub) ParseWaitResponse(waitChannelSub, t, testName) pubnubMessaging.SetSubscribeTimeout(310) }
// Init asks the user the basic settings to initialize to the pubnub struct. // Settings include the pubnub channel(s) to connect to. // Ssl settings // Cipher key // Secret Key // Custom Uuid // Proxy details // // The method returns false if the channel name is not provided. // // returns: a bool, true if the user completed the initail settings. func Init() (b bool) { fmt.Println("PubNub Api for go;", pubnubMessaging.VersionInfo()) fmt.Println("Please enter the channel name(s). Enter multiple channels separated by comma without spaces.") reader := bufio.NewReader(os.Stdin) line, _, err := reader.ReadLine() if err != nil { fmt.Println(err) } else { _connectChannels = string(line) if strings.TrimSpace(_connectChannels) != "" { fmt.Println("Channel: ", _connectChannels) fmt.Println("Enable SSL? Enter y for Yes, n for No.") var enableSsl string fmt.Scanln(&enableSsl) if enableSsl == "y" || enableSsl == "Y" { _ssl = true fmt.Println("SSL enabled") } else { _ssl = false fmt.Println("SSL disabled") } fmt.Println("Please enter a CIPHER key, leave blank if you don't want to use this.") fmt.Scanln(&_cipher) fmt.Println("Cipher: ", _cipher) fmt.Println("Please enter a Custom UUID, leave blank for default.") fmt.Scanln(&_uuid) fmt.Println("UUID: ", _uuid) fmt.Println("Display error messages? Enter y for Yes, n for No. Default is Yes") var enableErrorMessages = "y" fmt.Scanln(&enableErrorMessages) if enableErrorMessages == "y" || enableErrorMessages == "Y" { _displayError = true fmt.Println("Error messages will be displayed") } else { _displayError = false fmt.Println("Error messages will not be displayed") } fmt.Println("Enable resume on reconnect? Enter y for Yes, n for No. Default is Yes") var enableResumeOnReconnect = "y" fmt.Scanln(&enableResumeOnReconnect) if enableResumeOnReconnect == "y" || enableResumeOnReconnect == "Y" { pubnubMessaging.SetResumeOnReconnect(true) fmt.Println("Resume on reconnect enabled") } else { pubnubMessaging.SetResumeOnReconnect(false) fmt.Println("Resume on reconnect disabled") } fmt.Println("Set subscribe timeout? Enter numerals.") var subscribeTimeout = "" fmt.Scanln(&subscribeTimeout) val, err := strconv.Atoi(subscribeTimeout) if err != nil { fmt.Println("Entered value is invalid. Using default value.") } else { pubnubMessaging.SetSubscribeTimeout(int64(val)) } pubnubMessaging.SetOrigin("pubsub.pubnub.com") pubInstance := pubnubMessaging.PubnubInit("demo", "demo", "", _cipher, _ssl, _uuid) _pub = pubInstance SetupProxy() return true } else { fmt.Println("Channel cannot be empty.") } } return false }