def test_notif(self):
# simulate the daemon already having created
# a valid token (which it usually does when
# starting the WalletService:
self.daemon.wss_factory.valid_token = encoded_token
self.client_factory = WebSocketClientFactory("ws://127.0.0.1:" +
str(self.wss_port))
self.client_factory.protocol = ClientTProtocol
self.client_connector = connectWS(self.client_factory)
d = task.deferLater(reactor, 0.1, self.fire_tx_notif)
# create a small delay between the instruction to send
# the notification, and the checking of its receipt,
# otherwise the client will be queried before the notification
# arrived:
d.addCallback(self.wait_to_receive)
return d
def _create_client_service(self, nodeurl, api_token):
url = parse(nodeurl)
wsurl = url.replace(scheme="ws").child("private", "logs", "v1")
factory = WebSocketClientFactory(
url=wsurl.to_uri().to_text(),
headers={
"Authorization": "{} {}".format("tahoe-lafs", api_token),
},
)
factory.protocol = TahoeLogReader
factory.streamedlogs = self
endpoint = TCP4ClientEndpoint(self._reactor, url.host, url.port)
client_service = ClientService(endpoint, factory, clock=self._reactor)
return client_service
def _start_socket(self,
path,
callback,
update_time=WEBSOCKET_UPDATE_1SECOND):
if update_time != WEBSOCKET_UPDATE_1SECOND:
path = '{}@{}'.format(path, update_time)
if path in self._conns:
return False
factory = WebSocketClientFactory(BINANCE_STREAM_URL + path)
factory.protocol = BinanceClientProtocol
factory.callback = callback
context_factory = ssl.ClientContextFactory()
self._conns[path] = connectWS(factory, context_factory)
return path
def stop_socket(self, conn_key):
"""Stop a websocket given the connection key
:param conn_key: Socket connection key
:type conn_key: string
:returns: connection key string if successful, False otherwise
"""
if conn_key not in self._conns:
return
# disable reconnecting if we are closing
self._conns[conn_key].factory = WebSocketClientFactory(self.STREAM_URL + 'tmp_path')
self._conns[conn_key].disconnect()
del(self._conns[conn_key])
# check if we have a user stream socket
if len(conn_key) >= 60 and conn_key[:60] == self._user_listen_key:
self._stop_user_socket()
def connect_to_websocket(self):
logger.info('Connecting to websocket')
factory = WebSocketClientFactory(
'wss://ws-feed.exchange.coinbase.com',
debug=False,
)
# This actually creates a new Instance of CoinbaseOrderbook.
factory.protocol = type(self)
if factory.isSecure:
context_factor = ssl.ClientContextFactory()
else:
context_factor = None
connectWS(factory, context_factor)
def test():
import sys
import ssl
from twisted.python import log
from twisted.internet import reactor, ssl
import numpy as np
log.startLogging(sys.stdout)
numb = np.random.randint(0, 1000)
server_num = np.random.randint(0, 200)
randstr = str(uuid.uuid1())[:8]
url = f"wss://stream{server_num}.forexpros.com/echo/{numb}/{randstr}/websocket"
factory = WebSocketClientFactory(url) # , #headers=headers)
factory.setProtocolOptions(autoPingInterval=1)
factory.protocol = InvestingdotcomProtocol.make_subids([1, 2]) # .set_timeout(100)
connectWS(factory)
reactor.run()
def onTicker(self, data):
"""
Called upon reception of the initial 'ticker' data, triggers WebSocket market data subscription
"""
self.log('onTicker, data[{0}'.format(data))
ticker = json.loads(data)
self.log('received ticker from exchange {0}'.format(data))
price = ticker.get("price", None)
if price is None:
self.fatal("could not retrieve price")
self.basePrice = Decimal(price)
self.log('retrieved base price for {0}: {1}'.format(
self.product, self.basePrice))
self.log('starting websocket connection')
factory = WebSocketClientFactory(self.wsAddress)
factory.protocol = CoinbaseWebSocketClient
factory.coinbaseClient = self
connectWS(factory)
def __init__(self, url, username, password):
super(ETPClient, self).__init__()
log.startLogging(sys.stdout)
headers = {
'Authorization':
'Basic {}'.format(
b64encode(b'ilab.user:n@6C5rN!').decode("utf-8"))
}
factory = WebSocketClientFactory(
"wss://witsmlstudio.pds.software/staging/api/etp",
headers=headers,
protocols=["energistics-tp"])
self.factory = factory
self.factory.protocol = ETPClientProtocol
self.factory.on_etp_message = self.on_etp_message
def runpatch(patch):
print 'running patch'
print patch
factory = WebSocketClientFactory("ws://%s:7682/ws" % addr,
debug=options.debug,
protocols=['shell'])
factory.info = {
'cmd': 'build.py',
'repo': 'git://github.com/zedblue/leds',
'dir': '',
'username': '******',
'branch': 'master',
'boardname': 'zedboard',
'listfiles': 0,
'update': 0,
'patch': patch
}
factory.protocol = ShellClientProtocol
reactor.connectTCP(addr, 7682, factory)
def stop_socket(self, conn_key):
"""Stop a websocket given the connection key
Parameters
----------
conn_key : str
Socket connection key
Returns
-------
str, bool
connection key string if successful, False otherwise
"""
if conn_key not in self._conns:
return
# disable reconnecting if we are closing
self._conns[conn_key].factory = WebSocketClientFactory(self.STREAM_URL)
self._conns[conn_key].disconnect()
del self._conns[conn_key]
def listen(pid, q):
print("{} STARTING".format(pid))
# Import in method.. fix side effect of tornado
from app.cfxws.exchange import Binance
def act(_, msg):
q.put(str(msg))
def handle_response(_, response, type):
return response
factory = WebSocketClientFactory("wss://stream.binance.com:9443/ws/btcusdt@depth5")
MyWs = WSClient
MyWs._handle_response = handle_response
MyWs.handle_method = act
factory.protocol = MyWs
contextFactory = ssl.ClientContextFactory()
connectWS(factory, contextFactory)
reactor.run()
def create_websocket_client(app, websocket_id, local=False, callback=False):
if local:
class PytigonClientProtocol(PytigonClientProtocolBase):
def __init__(self, app):
self.app = app
self.websocket_id = websocket_id
self.input_queue = asyncio.Queue()
self.callbacks = []
self.status = 1
async def send_message(self, msg):
await self.input_queue.put(json_dumps(msg))
app.websockets[websocket_id] = PytigonClientProtocol(app)
else:
class PytigonClientProtocol(PytigonClientProtocolBase,
WebSocketClientProtocol):
def __init__(self):
nonlocal app, websocket_id
PytigonClientProtocolBase.__init__(self)
WebSocketClientProtocol.__init__(self)
self.app = app
self.websocket_id = websocket_id
app.websockets[websocket_id] = self
self.status = 0
def send_message(self, msg):
super().sendMessage(json_dumps(msg).encode("utf-8"))
ws_address = app.base_address.replace("http",
"ws").replace("https", "wss")
ws_address += websocket_id
factory = WebSocketClientFactory(ws_address)
factory.protocol = PytigonClientProtocol
connectWS(factory)
if callback:
app.add_websoket_callback(websocket_id, callback)
def onConnect(self, request):
"""
Websocket (not HTTP) connection start
"""
self.request = request
print("Client connecting: {0}".format(self.request))
# this might be a valid request, so we'll start a BACKEND connection
backendurl = os.environ.get("BACKEND")
if self.request.params:
# add the GET parameters to the backend request
backendurl += "?" + parse.urlencode(self.request.params,
doseq=True)
print("{1}: starting proxy backend connection attempt: {0}".format(
backendurl, self.request.peer))
self.proxyfactory = WebSocketClientFactory(url=backendurl)
self.proxyfactory.setProtocolOptions(autoPingInterval=10,
autoPingTimeout=3)
self.proxyfactory.protocol = WebsocketInfoProxyProtocol
self.proxyfactory.proxyproto = None
# this will be None until the connection to BACKEND
# is successfully connected
self.proxyfactory.messagecache = None
self.proxyfactory.clientconnection = self
sslfactory = None
if os.environ.get("SSL_CLIENT_CERT", False) and os.environ.get(
"SSL_CLIENT_KEY", False):
cert = ssl.Certificate.loadPEM(os.environ.get("SSL_CLIENT_CERT"))
key = ssl.KeyPair.load(os.environ.get("SSL_CLIENT_KEY"),
crypto.FILETYPE_PEM)
privatecert = ssl.PrivateCertificate.fromCertificateAndKeyPair(
cert, key)
print("{1}: loaded client cert {0}".format(privatecert,
self.request.peer))
if os.environ.get("SSL_CLIENT_CA", False):
cacerts = ssl.Certificate.loadPEM(
os.environ.get("SSL_CLIENT_CA"))
print("{1}: CA cert {0}".format(cacerts, self.request.peer))
sslfactory = privatecert.options(cacerts)
else:
sslfactory = privatecert.options()
connectWS(self.proxyfactory, contextFactory=sslfactory)
def connect(self):
factory = WebSocketClientFactory("ws://%s:%s/ws/" %
(self.host, self.port),
debug=False)
factory.noisy = True
factory.protocol = MdcloudWebsocketClientProtocol
factory.protocol.client = self
self.onc = defer.Deferred()
key_path = os.path.expanduser('~/.mcloud/%s.key' % self.host)
crt_path = os.path.expanduser('~/.mcloud/%s.crt' % self.host)
class NoKeyError(Exception):
pass
try:
if not self.no_ssl and self.host != '127.0.0.1':
if not os.path.exists(key_path):
raise NoKeyError(
'Key for server "%s" not found in file "%s"' %
(self.host, key_path))
if not os.path.exists(crt_path):
raise NoKeyError(
'Key for server "%s" not found in file "%s"' %
(self.host, crt_path))
from mcloud.ssl import CtxFactory
reactor.connectSSL(self.host, self.port, factory,
CtxFactory(key_path, crt_path))
else:
reactor.connectTCP(self.host, self.port, factory)
except NoKeyError:
print 'No key found - fallback to no-ssl'
reactor.connectTCP(self.host, self.port, factory)
return self.onc
def main():
global command_library
command_library = CommandLibrary()
address = "ws://" + 'localhost'
keyboard = Keyboard_Input()
stdio.StandardIO(keyboard)
multicast = reactor.listenMulticast(udpbport,
MulticastProtocol(),
listenMultiple=True)
factory = WebSocketClientFactory(address + ":8084", debug=False)
factory.setProtocolOptions(failByDrop=False)
factory.protocol = MyClientProtocol
try:
connectWS(factory)
command_library.factory = factory
command_library.multicast = multicast
factory.command_library = command_library
except twisted.internet.error.CannotListenError:
print "Can't listen"
def test_cbor_raw(self):
test_client_received = []
class TestClientProtocol(WebSocketClientProtocol):
def onOpen(self):
self.sendMessage(
json.dumps({
'op': 'subscribe',
'topic': TOPIC,
'compression': 'cbor-raw',
}))
def onMessage(self, payload, binary):
test_client_received.append(payload)
protocol = os.environ.get('PROTOCOL')
port = rospy.get_param('/rosbridge_websocket/actual_port')
url = protocol + '://127.0.0.1:' + str(port)
factory = WebSocketClientFactory(url)
factory.protocol = TestClientProtocol
reactor.connectTCP('127.0.0.1', port, factory)
pub = rospy.Publisher(TOPIC, String, queue_size=1)
def publish_timer():
rospy.sleep(WARMUP_DELAY)
pub.publish(String(STRING))
rospy.sleep(TIME_LIMIT)
reactor.stop()
reactor.callInThread(publish_timer)
reactor.run()
self.assertEqual(len(test_client_received), 1)
websocket_message = decode_cbor(test_client_received[0])
self.assertEqual(websocket_message['topic'], TOPIC)
buff = io.BytesIO()
String(STRING).serialize(buff)
self.assertEqual(websocket_message['msg']['bytes'], buff.getvalue())
def ws_keep_alive(self):
ssl_context = ssl.SSLContext()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
ua_file = open("user_agents.json", "r+")
user_agents = json.load(ua_file)
ua_file.close()
ws_url = "wss://api.irccloud.com/"
ws_origin = "https://api.irccloud.com"
irc_cloud_header = {
"Connection": "Upgrade",
"Host": "api.irccloud.com",
"Origin": ws_origin,
"User-Agent": random.choice(user_agents),
"Cookie": "session={0}".format(irccloud.SessionId),
"Sec-WebSocket-Key": self.get_secure_key(),
"Sec-WebSocket-Version": "13",
"Upgrade": "WebSocket"
}
factory = WebSocketClientFactory(ws_url, headers=irc_cloud_header)
connectWS(factory)
reactor.run()
def main(reactor):
from twisted.python import log
log.startLogging(sys.stdout)
tahoe_dir = "testgrid/alice"
cfg = read_config(tahoe_dir, "portnum")
token = cfg.get_private_config("api_auth_token").strip()
webport = cfg.get_config("node", "web.port")
if webport.startswith("tcp:"):
port = webport.split(':')[1]
else:
port = webport
factory = WebSocketClientFactory(
url=u"ws://127.0.0.1:{}/private/logs/v1".format(port),
headers={
"Authorization": "tahoe-lafs {}".format(token),
}
)
factory.on_open = Deferred()
factory.on_close = Deferred()
factory.protocol = TahoeLogProtocol
endpoint = HostnameEndpoint(reactor, "127.0.0.1", int(port))
try:
port = yield endpoint.connect(factory)
except ConnectError as e:
print("Connection failed: {}".format(e))
return
print("port: {}".format(port))
yield factory.on_open
print("opened")
yield factory.on_close
print("closed")
def test_smoke(self):
protocol = os.environ.get('PROTOCOL')
port = rospy.get_param('/rosbridge_websocket/actual_port')
url = protocol + '://127.0.0.1:' + str(port)
factory = WebSocketClientFactory(url)
factory.protocol = TestClientProtocol
reactor.connectTCP('127.0.0.1', port, factory)
ros_received = []
TestClientProtocol.received = []
rospy.Subscriber(A_TOPIC, String, ros_received.append)
pub = rospy.Publisher(B_TOPIC, String, queue_size=NUM_MSGS)
def publish_timer():
rospy.sleep(WARMUP_DELAY)
msg = String(B_STRING)
for _ in range(NUM_MSGS):
pub.publish(msg)
def shutdown_timer():
rospy.sleep(WARMUP_DELAY + TIME_LIMIT)
reactor.stop()
reactor.callInThread(publish_timer)
reactor.callInThread(shutdown_timer)
reactor.run()
for received in TestClientProtocol.received:
msg = json.loads(received)
self.assertEqual('publish', msg['op'])
self.assertEqual(B_TOPIC, msg['topic'])
self.assertEqual(B_STRING, msg['msg']['data'])
self.assertEqual(NUM_MSGS, len(TestClientProtocol.received))
for msg in ros_received:
self.assertEqual(A_STRING, msg.data)
self.assertEqual(NUM_MSGS, len(ros_received))
def addnewnode(host):
ws = "ws://{}:9000".format(host)
#factory = WebSocketClientFactory(u"ws://127.0.0.1:9000")
factory = WebSocketClientFactory(ws)
factory.protocol = MyClientProtocol
reactor.connectTCP(host, 9000, factory)
senderwallet=x["senderwallet"],
receiver=x["receiver"],
prevblockhash=x["prevblockhash"],
blockhash=x["blockhash"],
amount=x["amount"],
nonce=x["nonce"],
first_timestamp=x["first_timestamp"],
P2PKH=x["P2PKH"],
verification=x["verification"])
newtrans.save()
print("everyting is up-da-te")
if __name__ == '__main__':
import sys, argparse
parser = argparse.ArgumentParser()
parser.add_argument("--host", help="Please fill ip address")
args = parser.parse_args()
syncfirst(args.host)
ServerFactory = BroadcastServerFactory
factory = ServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = BroadcastServerProtocol
reactor.listenTCP(9000, factory)
ws = "ws://{}:9000".format(args.host)
factory = WebSocketClientFactory(ws)
factory.protocol = MyClientProtocol
reactor.connectTCP(args.host, 9000, factory)
reactor.run()
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Need the WebSocket server address, i.e. ws://localhost:9000")
sys.exit(1)
if len(sys.argv) > 2 and sys.argv[2] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
factory = WebSocketClientFactory(sys.argv[1],
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoClientProtocol
# Enable WebSocket extension "permessage-deflate".
##
# The extensions offered to the server ..
offers = [PerMessageDeflateOffer()]
factory.setProtocolOptions(perMessageCompressionOffers=offers)
# Function to accept responses from the server ..
def accept(response):
if isinstance(response, PerMessageDeflateResponse):
return PerMessageDeflateResponseAccept(response)
class PingClientProtocol(WebSocketClientProtocol):
def onOpen(self):
self.pingsReceived = 0
self.pongsSent = 0
def onClose(self, wasClean, code, reason):
reactor.stop()
def onPing(self, payload):
self.pingsReceived += 1
print("Ping received from {} - {}".format(self.peer,
self.pingsReceived))
self.sendPong(payload)
self.pongsSent += 1
print("Pong sent to {} - {}".format(self.peer, self.pongsSent))
if __name__ == '__main__':
log.startLogging(sys.stdout)
if len(sys.argv) < 2:
print("Need the WebSocket server address, i.e. ws://127.0.0.1:9000")
sys.exit(1)
factory = WebSocketClientFactory(sys.argv[1])
factory.protocol = PingClientProtocol
connectWS(factory)
reactor.run()
def onOpen(self):
self.sendHello()
def onMessage(self, payload, isBinary):
if not isBinary:
print("Text message received: {}".format(payload.decode('utf8')))
reactor.callLater(1, self.sendHello)
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Need the WebSocket server address, i.e. ws://127.0.0.1:9000")
sys.exit(1)
if len(sys.argv) < 3:
print("Need the Proxy, i.e. 192.168.1.100:8050")
sys.exit(1)
proxyHost, proxyPort = sys.argv[2].split(":")
proxy = {'host': proxyHost, 'port': int(proxyPort)}
log.startLogging(sys.stdout)
factory = WebSocketClientFactory(sys.argv[1], proxy=proxy)
factory.protocol = EchoClientProtocol
connectWS(factory)
reactor.run()
def onConnect(self, response):
print("Server connected: {0}".format(response.peer))
@inlineCallbacks
def onOpen(self):
print("WebSocket connection open.")
# start sending messages every second ..
while True:
self.sendMessage(u"1".encode('utf8'))
yield sleep(5)
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
print("Text message received: {0}".format(payload.decode('utf8')))
def onClose(self, was_clean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WebSocketClientFactory("ws://localhost:9000/add", debug=False)
factory.protocol = MyClientProtocol
reactor.connectTCP("127.0.0.1", 9000, factory)
reactor.run()
fh = logging.FileHandler(args.filename)
fh.setLevel(level)
ch = logging.StreamHandler()
ch.setLevel(level)
formatter = logging.Formatter(
'%(asctime)s-%(name)s:-%(levelname)s: %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
logger.addHandler(fh)
logger.addHandler(ch)
#factory=WebSocketClientFactory( 'ws://162.243.154.223:8888/v1/websocket/feed_id=53dde5e6a52633d704000003&format=json&isFront=False',
#factory=WebSocketClientFactory( 'ws://192.168.1.37:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=False',
factory = WebSocketClientFactory(
'ws://{}:{}/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=False'
.format(args.ip, args.port),
debug=args.loglevel,
debugCodePaths=False)
factory.protocol = EchoClientProtocol
#factoryVideo=WebSocketClientFactory('ws://162.243.154.223:8888/v1/websocket/feed_id=53dde5e6a52633d704000003&format=video&isFront=False',
#factoryVideo=WebSocketClientFactory('ws://192.168.1.37:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=video&isFront=False',
factoryVideo = WebSocketClientFactory(
'ws://{}:{}/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=video&isFront=False'
.format(args.ip, args.port),
debug=args.loglevel,
debugCodePaths=False)
factoryVideo.protocol = EchoClientVideoProtocol
# connectWS(factory)
connectWS(factoryVideo)
reactor.run()
def onMessage(self, payload, isBinary):
print "onMessage() receive video from robot at: %s " % str(
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
def onClose(self, wasClean, code, reason):
self.sendClose()
if __name__ == '__main__':
debug = True
#factory=WebSocketClientFactory('ws://162.243.154.223:8888/v1/websocket/feed_id=53dde5e6a52633d704000003&format=json&isFront=True',
#factory=WebSocketClientFactory('ws://192.168.1.37:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=True',
factory = WebSocketClientFactory(
'ws://143.89.46.81:9090/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=True',
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoClientProtocol
#factoryVideo=WebSocketClientFactory('ws://162.243.154.223:8888/v1/websocket/feed_id=53dde5e6a52633d704000003&format=video&isFront=True',
#factoryVideo=WebSocketClientFactory('ws://192.168.1.37:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=video&isFront=True',
factoryVideo = WebSocketClientFactory(
'ws://143.89.46.81:9090/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=video&isFront=True',
debug=debug,
debugCodePaths=debug)
factoryVideo.protocol = EchoClientVideoProtocol
connectWS(factory)
#connectWS(factoryVideo)
reactor.run()
if i:
self.answer = sys.stdin.readline().strip()
else:
logger.info('Answering time out')
buzzing_lock.release()
msg = {
'type': MSG_TYPE_BUZZING_ANSWER,
'text': self.answer,
'qid': self.qid,
'position': self.position
}
self.sendMessage(json.dumps(msg).encode('utf-8'))
class KeyPoller(threading.Thread):
def run(self):
global buzzed
while True:
with buzzing_lock:
ch = sys.stdin.read(1)
if ch == 'b':
buzzed.set()
time.sleep(0.1)
if __name__ == '__main__':
KeyPoller().start()
factory = WebSocketClientFactory(u"ws://127.0.0.1:9000")
factory.protocol = KeyboardProtocol
connectWS(factory)
reactor.run()
hello()
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
print(payload.decode())
else:
# printing the size of the encoded image which is received
print("Encoded size of the received text: {0} bytes".format(len(payload)))
print(payload.decode())
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
import sys
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
factory = WebSocketClientFactory("ws://localhost:9000")
factory.protocol = MyClientProtocol
reactor.connectTCP("127.0.0.1", 9000, factory)
reactor.run()
def main():
parser = argparse.ArgumentParser(
description="Process blinktrade withdrawals requests")
parser.add_argument('-c',
"--config",
action="store",
dest="config",
help='Configuration file',
type=str)
arguments = parser.parse_args()
candidates = [
os.path.join(site_config_dir('blinktrade'),
'blinktrade_withdrawer.ini'),
os.path.expanduser('~/.blinktrade/blinktrade_withdrawer.ini')
]
if arguments.config:
candidates.append(arguments.config)
config = ConfigParser.SafeConfigParser()
config.read(candidates)
if config.has_section('blockchain_info'):
blockchain_main_password = getpass.getpass(
'Blockchain.info main password: '******'Blockchain.info second password: '******'blinktrade password: '******'blinktrade second factor authentication: ')
blinktrade_port = 443
should_connect_on_ssl = True
blinktrade_url = urlparse(config.get("blinktrade", "webscoket_url"))
if blinktrade_url.port is None and blinktrade_url.scheme == 'ws':
should_connect_on_ssl = False
blinktrade_port = 80
db_engine = config.get("database", "sqlalchemy_engine") + ':///' +\
os.path.expanduser(config.get("database", "sqlalchemy_connection_string"))
engine = create_engine(db_engine,
echo=config.getboolean('database',
'sqlalchmey_verbose'))
Base.metadata.create_all(engine)
factory = WebSocketClientFactory(blinktrade_url.geturl())
factory.db_session = scoped_session(sessionmaker(bind=engine))
factory.verbose = config.getboolean("blinktrade", "verbose")
factory.blinktrade_user = config.get("blinktrade", "user")
factory.blinktrade_broker_id = config.get("blinktrade", "broker_id")
factory.currencies = json.loads(config.get("blinktrade", "currencies"))
factory.methods = json.loads(config.get("blinktrade", "methods"))
factory.blinktrade_password = blinktrade_password
factory.blinktrade_2fa = blinktrade_2fa
factory.blocked_accounts = json.loads(
config.get("blinktrade", "blocked_accounts"))
if config.has_section('blockchain_info'):
from blockchain_info import BlockchainInfoWithdrawalProtocol
factory.blockchain_guid = config.get("blockchain_info", "guid")
factory.from_address = config.get("blockchain_info", "from_address")
factory.note = config.get("blockchain_info", "note")
factory.blockchain_main_password = blockchain_main_password
factory.blockchain_second_password = blockchain_second_password
factory.protocol = BlockchainInfoWithdrawalProtocol
if config.has_section('mailer'):
from mailer_protocol import MailerWithdrawalProtocol
factory.mandrill_apikey = config.get("mailer", "mandrill_apikey")
factory.mandrill_template_name = config.get("mailer", "template_name")
factory.mandrill_from_email = config.get("mailer", "from_email")
factory.mandrill_from_name = config.get("mailer", "from_name")
factory.mandrill_to_email = config.get("mailer", "to_email")
factory.mandrill_to_name = config.get("mailer", "to_name")
factory.mandrill_website = config.get("mailer", "website")
factory.protocol = MailerWithdrawalProtocol
if should_connect_on_ssl:
reactor.connectSSL(blinktrade_url.netloc, blinktrade_port, factory,
ssl.ClientContextFactory())
else:
reactor.connectTCP(blinktrade_url.netloc, blinktrade_port, factory)
reactor.run()
