def ws_run():
    if __name__ == "__main__":
        global play_args
        # check args
        play_args = play_args_aplay
        if len(sys.argv) == 2:
            if sys.argv[1] == 'sox':
                play_args = play_args_sox

        global WS_DEBUG
        if WS_DEBUG:
            websocket.enableTrace(True)
        else:
            websocket.enableTrace(False)
        ws = websocket.WebSocketApp("ws://aprs.hamclub.net:20880/mtracker/talkbox0?type=sub&udid=bg5hhp-1",
        #ws = websocket.WebSocketApp("ws://localhost:8080/mclub/talk0?type=sub&udid=bg5hxe",
                                   #on_message = ws_on_message,
                                    on_data = ws_on_data,
                                    on_error = ws_on_error,
                                    on_close = ws_on_close)
        ws.on_open = ws_on_open

        stopFlag = Event()
        timer = KeepAliveThread(stopFlag,ws)
        timer.start()
        gpio_init()
        ws.run_forever()
        stopFlag.set() #stop the timer
        gpio_reset()

def main():
    config = configparser.ConfigParser()
    config.read('config.ini')

    url = "https://slack.com/api/rtm.start"
    token = config['slack']['token']

    parameters = {
        "token": token
    }

    data = urllib.parse.urlencode(parameters)
    data = data.encode('utf-8')

    req = urllib.request.Request(url, data)
    with urllib.request.urlopen(req) as response:
        downloadedPage = response.read()

    pageJson = json.loads(downloadedPage.decode('utf-8'))

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp(pageJson.get('url'),
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.run_forever()

    def __init__(self):
        #create database
#        file = "myDB.db"
#        self.path = "d:/git/bitbot/"+file
#        self.db = sqlite3.connect(self.path)
#        self.cursor = self.db.cursor()
#        self.cursor.execute(
#            """CREATE TABLE ok_btcusd_depth(
#            bid REAL,
#            bid_amount REAL,
#            ask REAL,
#            ask_amount REAL)
#            """)
#        self.cursor.execute(
#            """CREATE TABLE ok_btcusd_trades(
#               price REAL,
#               amount REAL,
#               time TEXT,
#               type TEXT)
#               """)
#        self.db.commit()
        #connect to websocket
        websocket.enableTrace(True)
        url = "wss://ws-feed.exchange.coinbase.com"
        self.ws = websocket.WebSocketApp(url,
                                         on_message=self.on_message,
                                         on_error=self.on_error
                                         )
        self.ws.on_open = self.on_open
        self.ws.run_forever()

def pqrgn_pull():
    def cycle(ws):
        print 'Starting pull cycle...'

        print 'Starting Pull Messages of Shard [%s - %s] from CM...' % (0, 7)
        ws.send(json.dumps(range(8)))

    def on_message(ws, message):
        print 'Got Response from CM Side. Response is %s' % message

        # Simulate Persisting message
        time.sleep(2)
        print 'Finish Persisting Message from CM Side'

        cycle(ws)

    def on_error(ws, error):
        print error

    def on_close(ws):
        print "#Connection Closed..."

    def on_open(ws):
        cycle(ws)

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("%s/pull/" % HOST,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.run_forever()

def main():
    while True:  # infinite loop
        websocket.enableTrace(False)
        url = "ws://websocket.mtgox.com/mtgox"
        ws = websocket.WebSocket()
        ws.LASTTICKER = time.time() - 15  # sets the last ticker 30 seconds prior to now, so it shows up on first run.
        ws.LASTLAG = time.time() - 30  # same for the lag counter
        try:
            ws.connect(url)  # try to connect
        except (socket.error, websocket.WebSocketConnectionClosedException) as error:
            on_error(error)
            on_reconnect()
            continue
        on_open()
        subscribeto = serialize({"op": "mtgox.subscribe", "type": "lag"})
        # serialize({"op":"unsubscribe", "channel":"24e67e0d-1cad-4cc0-9e7a-f8523ef460fe"})
        ws.send(subscribeto)

        try:
            while True:
                data = ws.recv()  # start receiving data
                on_message(ws, data)
        except KeyboardInterrupt as e:
            on_close(ws)
            return
        except Exception as error:
            traceback.print_exc()
            on_error(error)
            on_close(ws)
            on_reconnect()  # try to reconnect

def pqrgn_push():
    def cycle(ws):
        print 'Starting push cycle...'

        # Simulate Query Message for CM
        time.sleep(2)

        rec = ['rec3', 'rec4']
        print 'Starting Push Message %s to CM...' % rec
        ws.send(json.dumps(rec))
        print 'Finish Pushing Message %s to CM...' % rec

    def on_message(ws, message):
        print 'Got Response from CM Side. Response is %s' % message
        cycle(ws)

    def on_error(ws, error):
        print error

    def on_close(ws):
        print "#Connection Closed..."

    def on_open(ws):
        cycle(ws)

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("%s/push/" % HOST,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.run_forever()

    def connect(self, apiKey, secretKey, trace=False):
        """
        连接网关
        :param apiKey   : 申请的API key
        :param secretKey: 签名key
        :param trace    : 是否开启websocket的日志跟踪功能，输出到StreamHandler
        :return:
        """
        # 更新websocket服务器地址/API key/
        self.host = OKEX_USD_SPOT
        self.apiKey = apiKey
        self.secretKey = secretKey

        # 是否开启日志
        websocket.enableTrace(trace)

        # 创建websocket，绑定本地回调函数 onMessage/onError/onClose/onOpen
        self.ws = websocket.WebSocketApp(self.host, 
                                             on_message=self.onMessage,
                                             on_error=self.onError,
                                             on_close=self.onClose,
                                             on_open=self.onOpen)        
            
        self.thread = Thread(target=self.ws.run_forever)
        self.thread.start()

    def connect(self):
        screepsConnection = API(u=self.user,p=self.password,ptr=self.ptr,host=self.host,secure=self.secure, token=self.atoken)
        me = screepsConnection.me()
        self.user_id = me['_id']
        self.token = screepsConnection.token

        if self.logging:
            logging.getLogger('websocket').addHandler(logging.StreamHandler())
            websocket.enableTrace(True)
        else:
            logging.getLogger('websocket').addHandler(logging.NullHandler())
            websocket.enableTrace(False)

        if self.host:
            url = 'wss://' if self.secure else 'ws://'
            url += self.host + '/socket/websocket'
        elif not self.ptr:
            url = 'wss://screeps.com/socket/websocket'
        else:
            url = 'wss://screeps.com/ptr/socket/websocket'

        self.ws = websocket.WebSocketApp(url=url,
                                    on_message=self.on_message,
                                    on_error=self.on_error,
                                    on_close=self.on_close,
                                    on_open=self.on_open)

        ssl_defaults = ssl.get_default_verify_paths()
        sslopt_ca_certs = {'ca_certs': ssl_defaults.cafile}
        if 'http_proxy' in self.settings and self.settings['http_proxy'] is not None:
            http_proxy_port = self.settings['http_proxy_port'] if 'http_proxy_port' in self.settings else 8080
            self.ws.run_forever(http_proxy_host=self.settings['http_proxy'], http_proxy_port=http_proxy_port, ping_interval=1, sslopt=sslopt_ca_certs)
        else:
            self.ws.run_forever(ping_interval=1, sslopt=sslopt_ca_certs)

def send_request_to_agent(ip_host, instance_data, task):
    distribution, version, arch = instance_data['operating_system'].split('-')

    data = {'task_uuid': task['uuid'],
            'instance_uuid': task['object_uuid'],
            'action': 'create',
            'driver': instance_data['driver'],
            'name': instance_data['name'], 
            'distribution': distribution,
            'version': version,
            'arch': arch,
            'launch':1,
            'cpus':1,
            'provisioner': instance_data['provisioner'],
            'executor': instance_data['executor'],
            'user':'virtshell',
            'password':'virtshell',            
            'memory':1024}

    websocket.enableTrace(True)
    ws = websocket.create_connection("ws://%s:8080/" % (ip_host))
    ws.send(json.dumps(data))
    result = ws.recv()
    ws.close()
    return result

def main(*args):
    p = ProtoMGMT()

    if len(args) > 0:
        if args[0] == "--list":
            try:
                get_list()
            except:
                print "Cannot get list"
            return 0

        for a in args:
            p.add_proto(a)
    if len(p.l_proto) == 0:
        print "Listen ALL protocols"
    else:
        print "Listen :", p.l_proto

    websocket.enableTrace(False)
    ws = websocket.WebSocketApp("ws://192.168.1.137:9000/admin",
                                on_message = on_message,
                                on_error = on_error,
                                on_close = on_close)
    ws.on_open = on_open

    try:
        ws.run_forever()
    except KeyboardInterrupt:
        print "Stopping..."
    return 0

    def connect(self):
        if self.state != State.DISCONNECTED:
            self.disconnect()

        print "Connecting..."

        # start new connection
        websocket.enableTrace(self.enable_trace)
        ws = websocket.WebSocketApp(
            "ws://localhost:8888/",
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close,
            on_open=self.on_open,
            on_ping=self.on_ping,
            on_pong=self.on_pong)

        socket_options = [
            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
            (socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 10),
            (socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 5),
            (socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 1)
        ]

        ssl_options = {
            'cert_reqs': ssl.CERT_NONE
        }

        ws.run_forever(sockopt=socket_options, sslopt=ssl_options)

def main(api_url, ws_url, teamname):
    global_things['API_URL']  = api_url
    global_things['WS_URL']   = ws_url
    global_things['TEAMNAME'] = teamname

    log("API Url:  {}".format(global_things['API_URL']))
    log("WS Url:   {}".format(global_things['WS_URL']))
    log("Teamname: {}".format(global_things['TEAMNAME']))
    print("API Url:  {}".format(global_things['API_URL']))
    print("WS Url:   {}".format(global_things['WS_URL']))
    print("Teamname: {}".format(global_things['TEAMNAME']))

    register_team()

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp(
        global_things['WS_URL'],
        on_message = receive_message,
        on_error   = receive_error,
        on_close   = connection_closed
    )
    ws.on_open = open_connection
    try:
        ws.run_forever()
    except KeyboardInterrupt:
        log("Terminating")
        print("Terminating")

def main():
    global WEB_SOCKET
    data_dir = os.path.join(os.getcwd(), DATA_DIRECTORY)
    if not os.path.exists(data_dir):
        os.makedirs(data_dir)

    while(RUNNING):
        retry_time = 0
        if WEB_SOCKET is not None:
            if hasattr(WEB_SOCKET, 'retry_time'):
                retry_time = WEB_SOCKET.retry_time
            else:
                retry_time = 10

        print("Retry wait time: " + str(retry_time))
        # sys.stdout.flush()
        time.sleep(retry_time)

        token = _get_token()
        url = STATS_API + "?jwt=" +token
#        url = "ws://192.168.1.2:9999/"
        print(url)
        websocket.enableTrace(True)
        WEB_SOCKET = websocket.WebSocketApp(url,
                                  on_message = _on_message,
                                  on_error = _on_error,
                                  on_close = _on_close)

        WEB_SOCKET.retry_time = retry_time
        WEB_SOCKET.on_open = _on_open
        WEB_SOCKET.run_forever(ping_interval=None)

 def on_connect(self):
     print "Servidor conectado"
     if not self.ws == None:
         websocket.enableTrace(True)
     # code that runs when a connection is created
     # (to init the serivce, if needed)
     pass

def update_client(task_queue):

    def on_message(ws, message):
        print message

    def on_error(ws, error):
        print error

    def on_close(ws):
        print "### closed ###"

    def on_open(ws):
        def run(*args):
            while True:
                next_task = task_queue.get()
                time.sleep(5)
                if next_task:
                    # Poison pill means shutdown
                    #print '%s: Exiting' % proc_name
                    ws.send(str(next_task))
                    print value_global
                    task_queue.task_done()

    print "something"
    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("ws://localhost:8888/ws",
                                    on_message = on_message,
                                    on_error = on_error,
                                    on_close = on_close)
    ws.on_open = on_open
    ws.run_forever()

def load_justdice(secret_url=None, proxy=None, headers=None, debug=False):
    """
    "proxy" is expected to be a map from protocol to a proxy server.
        e.g., proxy={'https': 'myproxy:port'} would use a proxy
        for https requests.

    "headers" should be a sequence of tuples to be added in each
    request. e.g, headers=[('User-Agent', 'bot')]
    """
    handler = []
    if debug:
        websocket.enableTrace(True)
        handler.append(urllib2.HTTPSHandler(debuglevel=1))
    cookie_handler = urllib2.HTTPCookieProcessor(cj)
    handler.append(cookie_handler)
    if proxy is not None:
        proxy_handler = urllib2.ProxyHandler(proxy)
        handler.append(proxy_handler)
    opener = urllib2.build_opener(*handler)

    headers = headers or []
    headers.append(('Origin', BASE_URL))
    opener.addheaders = headers

    if secret_url is not None:
        opener.open('%s/%s' % (BASE_URL, secret_url))
    else:
        opener.open(BASE_URL)
    req = opener.open('%s/socket.io/1' % BASE_URL)
    # Grab the session in order to allow the websocket connection.
    response = req.read()
    return response

def main():
    config = ConfigParser.ConfigParser()
    config.read('config.ini')

    url = config.get('server', 'url')

    websocket.enableTrace(config.get('debug', 'trace'))

    ws = websocket.WebSocketApp(url,
                                on_open=on_open,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.state = "initialize"
    ws.appid = appid
    ws.version = version
    ws.success = False
    ws.run_forever()
    print("leaving")
    print "=============="
    if ws.success:
        print "Smoke test was successful"
    else:
        print "Smoke test failed."
    print "=============="

def run_websocket_watcher():
	global ws
	Log('Starting websocket listener')
	websocket.enableTrace(True)
	ws = websocket.WebSocketApp("ws://" + Prefs['PLEX_ADDRESS'] + "/:/websockets/notifications?X-Plex-Token=" + ACCESS_TOKEN, on_message = on_message)
	Log("Up and running, listening")
	ws.run_forever()

def main():
    config = read_config('config.ini')

    url = config.get('server', 'url')

    websocket.enableTrace(config.get('debug', 'trace'))

    ws = websocket.WebSocketApp(url,
                                on_open=on_open,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.state = "initialize"
    ws.chid = chid
    ws.version = version
    ws.success = False
    ws.run_forever()
    print("leaving")
    print "=============="
    result = True
    if ws.success:
        print "Smoke test was successful"
    else:
        print "Smoke test failed."
        result = False;
    print "=============="

    if not result:
        sys.exit(-1)

    def connect(self):
		#Connect to the websocket server
        websocket.enableTrace(True)
        ws=websocket.WebSocketApp("ws://"+self.theurl+"?id="+self.id+"&type="+self.type, on_open=self.on_open, on_message=self.on_message, on_error=self.on_error, on_close=self.on_close)
        print self.theurl
        ws.run_forever()
        self.connected=0