def __init__(self,interface,ssid,key_mgmt,pswd): self.log=Log() self._interface=interface self._ssid=ssid self._key_mgmt=key_mgmt self._pswd=pswd self._wpa_supplicant='/etc/wpa_supplicant/wpa_supplicant.conf'
def __init__(self,interface,ssid,key_mgmt,pswd): self.log=Log() self._interface=interface self._ssid=ssid self._key_mgmt=key_mgmt self._pswd=pswd self._hostapd='/etc/hostapd/hostapd.conf' self._dnsmasq='/etc/dnsmasq.conf'
def __init__(self,tid,name,lock,obj):
threading.Thread.__init__(self)
self._id=str(tid)
self._name=name
self._lock=lock
self._obj=obj
self.log=Log()
self.log.print("Creating Thread Named: "+self._name+"; ID: "+self._id,"OK")
def __init__(self, name, version, host, port, username, password):
self._name = name
self._version = version
self._host = host
self._port = port
self._username = username
self._password = password
self.log = Log()
self._CLEAN_SESSION = True
def __init__(self): self.database = Database() self._name=CONFIG['app_name'] self._version=CONFIG['app_version'] self._broker_host=CONFIG['broker_host'] self._broker_port=CONFIG['broker_port'] self._broker_username=CONFIG['broker_username'] self._broker_password=CONFIG['broker_password'] self._lock=threading.Lock() self.log=Log()
class Publisher():
def __init__(self, name, version, host, port, username, password):
self._name = name
self._version = version
self._host = host
self._port = port
self._username = username
self._password = password
self.log = Log()
self._CLEAN_SESSION = True
def publish(self, topic, data, q, r, debug=True):
try:
client = mqtt.Client("global_publisher",
clean_session=self._CLEAN_SESSION)
client.on_connect = self.on_connect
client.on_disconnect = self.on_disconnect
client.on_publish = self.on_publish
if (self._username != None):
client.username_pw_set(username=self._username,
password=self._password)
client.connect(self._host,
port=self._port,
keepalive=60,
bind_address="")
topic = self._version + "/" + self._name + "/" + topic + "/response"
client.loop_start()
rc = client.publish(topic,
payload=json.dumps(data),
qos=q,
retain=r)
client.loop_stop()
client.disconnect()
if (debug):
if rc[0] == 0:
self.log.print(
"Global publisher on topic: " + topic + " QoS:" +
str(q) + " Retain:" + str(r) + " RC:" + str(rc), "OK")
else:
self.log.print(
"Global publish unable to publish on topic: " + topic,
str(r))
except Exception as e:
self.log.print("Global Publisher error: ", format(e))
def on_connect(self, client, userdata, flags, rc):
self.log.print(
client.name + ":on_connect callback result, Flags: " + str(flags),
str(rc))
def on_disconnect(self):
pass
def on_publish(self, client, userdata, mid):
self.log.print("publish response, MID: " + mid + "...", "OK")
def __init__(self, config: IbConfig) -> None:
self._log = Log.create(Log.path(self.log_file))
self._config = config
ClientBase.__init__(self,
self._log.get_logger('coolqclient'),
kWorkerTypeConsole,
cmd_redis_ip=self._config.cmd_redis_ip,
cmd_redis_port=self._config.cmd_redis_port)
self._check_task: asyncio.Task = None
self._error_report_times = 0
self.add_dispatcher(ConsoleCommandResponse,
self.on_console_cmd_response)
def __init__(self, config: IbConfig) -> None:
self._log = Log.create(Log.path(self.log_file))
self._config: IbConfig = config
ClientBase.__init__(self,
self._log.get_logger('consoleclient'),
kWorkerTypeConsole,
cmd_redis_ip=self._config.cmd_redis_ip,
cmd_redis_port=self._config.cmd_redis_port)
self._cmd_task: asyncio.Task = None
self._prompt_session: PromptSession = PromptSession(
completer=completer, style=style)
self.add_dispatcher(ConsoleCommandResponse,
self.on_console_cmd_response)
def __init__(self, config: IbConfig) -> None:
self._config: IbConfig = config
self._log = Log.create(Log.path(self.log_file))
self._logger = self._log.get_logger('server')
self._clients: Dict[str, WorkerItem] = {}
self._redis: RedisHandler = None
self._clients: Dict[str, WorkerItem] = {}
self._available_channel_id: int = 0
self._sweep_task: asyncio.Task = None
self._console_handler: ConsoleHandler = None
self._transporter = Transporter()
self._client_id = config.client_id
self._ib_manager: IbManager = IbManager(
self._config.ib_ip, self._config.ib_port, self._client_id)
def __init__(self, api, name, version, host, port, username, password,
lock):
self._api = api
self._name = name
self._version = version
self._host = host
self._port = port
self._username = username
self._password = password
self._CLEAN_SESSION = True
self._loop_flag = 0
self._lock = lock
self.log = Log()
self.mapper = Mapper(name, version, api)
def __init__(self, ip: str, port: int, client_id: int):
self._ib = IB()
self._ib_ip: str = ip
self._ib_port: int = port
self._client_id: int = client_id
self._subscribed_mkt_contracts: List[str] = []
self._subscribed_mkt_depth_contracts: List[str] = []
self._log: Log = Log.create(Log.path(self.log_file))
self._logger = self._log.get_logger('ibmanager')
self._recorder: Recorder = Recorder(self._log)
self._market_recorder: MarketRecorder = MarketRecorder(
self._ib, self._recorder)
self._account_recorder: AccountRecorder = AccountRecorder(
self._ib, self._recorder)
self._keep_connection_task: asyncio.Task = None
self._ib.connectedEvent += self.on_ib_connected
self._ib.disconnectedEvent += self.on_ib_disconnected
self._reconnect_flag: bool = False
class Database():
def __init__(self):
self.log = Log()
def test(self):
db = pymysql.connect(CONFIG['mysql_host'], CONFIG['mysql_username'],
CONFIG['mysql_password'], CONFIG['mysql_db'])
cursor = db.cursor()
cursor.execute("SELECT VERSION()")
# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Database version : %s " % data)
# disconnect from server
db.close()
def get_user(self, token):
db = pymysql.connect(CONFIG['mysql_host'], CONFIG['mysql_username'],
CONFIG['mysql_password'], CONFIG['mysql_db'])
cursor = db.cursor()
cursor.execute(
"SELECT users.id,users.phone FROM users LEFT JOIN tracker_tokens on tracker_tokens.user_id = users.id where tracker_tokens.token = '%s'"
% token)
data = cursor.fetchone()
db.close()
return data
def post_track(self, id, lat, lng):
try:
db = pymysql.connect(CONFIG['mysql_host'],
CONFIG['mysql_username'],
CONFIG['mysql_password'], CONFIG['mysql_db'])
cursor = db.cursor()
datetime = strftime("%Y-%m-%d %H:%M:%S", localtime())
cursor.execute(
"INSERT INTO `location_histories` (`id`,`user_id`,`lat`,`lng`,`timestamp`,`created_at`, `updated_at`) VALUES (NULL, %s, %s, %s, current_timestamp(),NULL,NULL);",
(str(id), lat, lng))
db.commit()
except Exception as e:
self.log.print("Error occured in insert: ", format(e))
return 0
def __init__(self, server: BaseServer, redis: RedisHandler,
log: Log) -> None:
self._server: BaseServer = server
self._ib_manager: IbManager = server.ib_manager()
self._trade_manager: NormalTradeManager = NormalTradeManager(
self._ib_manager)
self._mock_manager: MockTradeManager = MockTradeManager(
self._ib_manager._recorder)
self._redis: RedisHandler = redis
self._logger = log.get_logger('consolehandler')
self._command_handler: CommandHandler = CommandHandler()
self._contracts: Dict[int, Contract] = {}
self._trader: RandomTrader = RandomTrader(self._ib_manager._ib,
self._ib_manager)
self._server.add_dispatcher(ConsoleCommandRequest, self.on_console_cmd)
self.add_handler('find_symbols', self._ib_manager.find_symbols)
self.add_handler(
'subscribe_market',
partial(self.contract_handler, self._ib_manager.sub_market))
self.add_handler(
'unsubscribe_market',
partial(self.contract_handler, self._ib_manager.unsub_market))
self.add_handler(
'subscribe_market_depth',
partial(self.contract_handler, self._ib_manager.sub_market_depth))
self.add_handler(
'unsubscribe_market_depth',
partial(self.contract_handler,
self._ib_manager.unsub_market_depth))
self.add_handler(
'order',
partial(self.contract_handler, self._ib_manager.place_order))
self.add_handler('cancel_order', self._ib_manager.cancel_order)
self.add_handler('contract', self.make_contract)
self.add_handler('orders', self._ib_manager.orders)
self.add_handler('portfolio', self._ib_manager.portfolio)
self.add_handler('tstart',
partial(self.contract_handler, self.start_trader))
self.add_handler('tstop', self.stop_trader)
self.add_handler('cash', self._ib_manager._account_recorder.cash)
self.add_handler('list_strategies', self.list_strategies)
self.add_handler('list_running_strategies',
self._trade_manager.list_running_strategies)
self.add_handler(
'start_strategy',
partial(self.contract_handler, self._trade_manager.start_strategy))
self.add_handler('stop_strategy', self._trade_manager.stop_strategy)
self.add_handler('run_mock_strategy', self._mock_manager.test_strategy)
self.add_handler('tod', self._trade_manager.place_order)
self.add_handler('tcod', self._trade_manager.cancel_order)
class App():
def __init__(self):
self.database = Database()
self._name=CONFIG['app_name']
self._version=CONFIG['app_version']
self._broker_host=CONFIG['broker_host']
self._broker_port=CONFIG['broker_port']
self._broker_username=CONFIG['broker_username']
self._broker_password=CONFIG['broker_password']
self._lock=threading.Lock()
self.log=Log()
def start(self):
try:
api=Api(self._name,self._version,self._broker_host,self._broker_port,self._broker_username,self._broker_password)
self.log.print("Listening to all APIs","OK")
sub=Subscriber(api,self._name,self._version,self._broker_host,self._broker_port,self._broker_username,self._broker_password,self._lock)
sub_thread = Threads(1, "Subscriber Thread",self._lock,sub)
sub_thread.start()
sub_thread.join()
except Exception as e:
self.log.print("Exception in the main thread: ",format(e))
# self.database.get_user('71f7bb0c6db392201e3c')
class Api():
def __init__(self, name, version, host, port, username, password):
self._name = name
self._version = version
self.publish = Publisher(name, version, host, port, username, password)
self.log = Log()
self.db = Database()
def track(self, topic, payload):
dat = {}
dat1 = {}
topic1 = ''
try:
temp = json.loads(payload)
if (temp['key'] == "" or temp['data']['lat'] == ""
or temp['data']['lng'] == ""):
self.log.print("Bad request...", "OK")
dat['status'] = 'error'
dat['status_code'] = 400
dat['message'] = 'Required Parameters empty'
dat['data'] = {}
dat['key'] = 'NULL'
else:
result = self.db.get_user(temp['key'])
if not result:
self.log.print("Unauthorized request...", "OK")
dat['status'] = 'error'
dat['status_code'] = 401
dat['message'] = 'Unauthorized: invalid key given'
dat['data'] = {}
dat['key'] = 'NULL'
else:
phone = result[1]
self.db.post_track(result[0], temp['data']['lat'],
temp['data']['lng'])
dat1['data'] = {
'lat': temp['data']['lat'],
'lng': temp['data']['lng']
}
topic1 = phone
dat['status'] = 'success'
dat['status_code'] = 200
dat['message'] = 'Co-ordinates successfully recorded'
dat['data'] = {}
except Exception as e:
self.log.print("Error parsing request json", format(e))
dat['status'] = 'error'
dat['status_code'] = 400
dat['message'] = 'Bad Request: error parsing json'
dat['data'] = {}
dat['key'] = 'NULL'
self.publish.publish(topic1, dat1, 0, True, False)
self.publish.publish(topic, dat, 0, False, False)
return 0
def qos(self):
return 1
class Hotspot():
def __init__(self,interface,ssid,key_mgmt,pswd):
self.log=Log()
self._interface=interface
self._ssid=ssid
self._key_mgmt=key_mgmt
self._pswd=pswd
self._hostapd='/etc/hostapd/hostapd.conf'
self._dnsmasq='/etc/dnsmasq.conf'
def create(self):
try:
self.log.print("Creating Hotspot: "+self._ssid+"...","OK")
return True
except Exception as e:
return False
def destroy(self):
try:
self.log.print("Destorying Hotspot: "+self._ssid+"...","OK")
return True
except Exception as e:
return False
class Mapper():
def __init__(self, name, version, api):
self._api = api
self._name = name
self._version = version
self.log = Log()
def map(self, topic, payload):
try:
_a = self.topic_parser(topic)
_f = self.route_parser(ROUTES[_a])
return getattr(self._api, _f)(_a, payload)
except Exception as e:
self.log.print("Mapper:Unauthorised function call", format(e))
return 0
def topic_parser(self, topic):
try:
c = 0
top = topic.split('/')
subtopic = ''
for t in top:
if (t == self._version or t == self._name or t == 'request'):
c = c + 1
else:
subtopic = subtopic + '/' + t
if (c == 3):
return subtopic[1:]
return None
except Exception as e:
self.log.print("Mapper.topic_parser() error occured: ", format(e))
return None
def route_parser(self, route):
try:
subroute = route.split('@')
return subroute[0]
except Exception as e:
self.log.print("Mapper.route_parser() error occured: ", format(e))
return None
def __init__(self):
self.log=Log()
self.log.create_log()
self.log.print("Log file created...","OK")
class Subscriber():
def __init__(self, api, name, version, host, port, username, password,
lock):
self._api = api
self._name = name
self._version = version
self._host = host
self._port = port
self._username = username
self._password = password
self._CLEAN_SESSION = True
self._loop_flag = 0
self._lock = lock
self.log = Log()
self.mapper = Mapper(name, version, api)
def start(self):
client = mqtt.Client("global_subscriber",
clean_session=self._CLEAN_SESSION)
client.on_connect = self.on_connect
client.on_disconnect = self.on_disconnect
client.on_subscribe = self.on_subscribe
client.on_unsubscribe = self.on_unsubscribe
client.on_message = self.on_message
if (self._username != None):
client.username_pw_set(username=self._username,
password=self._password)
client.connect(self._host,
port=self._port,
keepalive=60,
bind_address="")
client.loop_start()
topic = self._version + "/" + self._name + "/#"
r = client.subscribe(topic, self._api.qos())
if r[0] == 0:
self.log.print("Global Listener on topic: " + topic, "OK")
else:
self.log.print(
"Global Listener unable to subscribe to topic: " + topic,
str(r))
while (self._loop_flag == 0):
time.sleep(0.01)
client.loop_stop()
client.disconnect()
self.log.print("Destroying Subscriber Thread", "OK")
def on_connect(self, client, userdata, flags, rc):
self.log.print(
client.name + ":on_connect callback result, Flags: " + str(flags),
str(rc))
def on_disconnect(self):
pass
def on_subscribe(self, client, userdata, mid, granted_qos):
self.log.print(
client.name + ":on_subscribe callback result, MID: " + str(mid),
str(rc))
def on_unsubscribe(self, client, userdata, mid):
pass
def on_message(self, client, userdata, message):
if ('response' in str(message.topic)):
return 0
self.log.print("on_message callback, acquiring lock", "OK")
self._lock.acquire()
try:
self.log.print(
"incoming request on topic:" + str(message.topic) + " QoS:" +
str(message.qos) + " Retain Flag:" + str(message.retain), "OK")
self._loop_flag = self.mapper.map(str(message.topic),
message.payload.decode())
except Exception as e:
self.log.print("on_message callback error", format(e))
self._loop_flag = 0
self.log.print("exiting on_message callback, releasing lock", "OK")
self._lock.release()
def __init__(self, name, version, host, port, username, password):
self._name = name
self._version = version
self.publish = Publisher(name, version, host, port, username, password)
self.log = Log()
self.db = Database()
class Wifi():
def __init__(self,interface,ssid,key_mgmt,pswd):
self.log=Log()
self._interface=interface
self._ssid=ssid
self._key_mgmt=key_mgmt
self._pswd=pswd
self._wpa_supplicant='/etc/wpa_supplicant/wpa_supplicant.conf'
def connect(self):
try:
data=''
self.log.print("Connecting to "+self._ssid+"...","OK")
if(self._key_mgmt=='TRUE'):
dat = subprocess.Popen(['wpa_passphrase',self._ssid,self._pswd], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in dat.stdout:
line=line.decode()
data=data+line
#data = 'network={\nssid="'+self._ssid+'"\npsk="'+self._pswd+'"\n}\n'
else:
data = 'network={\nssid="'+self._ssid+'"\nkey_mgmt=NONE\n}\n'
if(self.write_config(data)==False):
self.log.print("Unable to connect to wifi: "+self._ssid+"...","OK")
return False
ps = subprocess.Popen(['wpa_supplicant','-q','-B','-i',self._interface,'-D','nl80211,wext','-c',self._wpa_supplicant], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(15)
self.log.print("Connection to wifi: "+self._ssid+" successful...","OK")
return True
except subprocess.CalledProcessError as e:
self.log.print("Error Initiating a new connection with: "+self._ssid+"...",format(e))
return False
except Exception as e:
self.log.print("Unable to connect...",e)
return False
def disconnect(self):
try:
self.log.print("Disconnecting from the current wifi network...","OK")
ps = subprocess.Popen(['killall','wpa_supplicant'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
time.sleep(5)
return True
except Exception as e:
self.log.print("Unable to disconnect...",e)
return False
def status(self):
try:
flag=False
self.log.print("Checking for wifi status...","OK")
ps = subprocess.Popen(['iw',self._interface,'link'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in ps.stdout:
row = line.decode()
row = row.replace('\t','')
row = row.replace('\n','')
row = row.split(' ')
if(row[0]=='Not'):
self.log.print(self._interface+" not connected to any wifi",row[0]+" "+row[1])
return -1
if(row[0]=='Connected'):
flag=True
continue
if(flag):
flag=False
ssid=''
for r in row:
if(r=='SSID:'):
continue
ssid=ssid+' '+r
if(ssid[1:]==self._ssid):
self.log.print(self._interface+" connected to...",ssid[1:])
return 1
else:
self.log.print(self._interface+" connected to...",ssid[1:])
return 0
#output = subprocess.check_output(('grep', self._ssid), stdin=ps.stdout)
#self.log.print("Wifi SSID: "+self._ssid+" found...",(output.decode()).replace('\n',''))
#return True
except subprocess.CalledProcessError as e:
self.log.print(self._interface+" not connected to: "+self._ssid+"...",format(e))
return 0
except Exception as e:
self.log.print(self._interface+" not connected to: "+self._ssid+"...",e)
return 0
def scan(self):
try:
self.log.print("Checking the availabilitly of "+self._ssid+"...","OK")
ps = subprocess.Popen(['iw',self._interface,'scan'],stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in ps.stdout:
#print(line.decode())
if('command failed: Network is down (-100)' in line.decode()):
self.log.print("Wireless Interface "+self._interface+" down...","OK")
pps = subprocess.Popen(['ip','link','set',self._interface,'up'],stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
time.sleep(5)
self.log.print("Enabling Wireless Interface "+self._interface+" up...","OK")
return False
else:
break
output = subprocess.check_output(('grep', 'SSID'), stdin=ps.stdout)
for line in (output.decode()).split('\n'):
row = line.replace('\t','')
row = row.split(': ')
if(row[1]==self._ssid):
self.log.print("ESSID "+self._ssid+" found...","OK")
return True
return False
except subprocess.CalledProcessError as e:
self.log.print("Unable to find: "+self._ssid+"...",format(e))
return False
except Exception as e:
self.log.print("Unable to find: "+self._ssid+"...",format(e))
return False
def write_config(self,data):
try:
buf=''
if(isfile(self._wpa_supplicant)):
with open(self._wpa_supplicant,'r') as cfile:
for fline in cfile:
if('network' in fline):
break
buf=buf+fline
with open(self._wpa_supplicant,'w') as conf:
conf.write(buf+data)
return True
else:
self.log.print("Unable to find: "+self._wpa_supplicant+"...",e)
return False
return True
except Exception as e:
self.log.print("Unable to write: "+self._wpa_supplicant+"...",format(e))
return False
def __init__(self, log: Log) -> None:
self._logger = log.get_logger('recorder')
self._date = str(datetime.date.today())
self._timer_task = asyncio.create_task(self._timer())
self._file_items: Dict[str, FileItem] = {}
def __init__(self, name, version, api):
self._api = api
self._name = name
self._version = version
self.log = Log()
def __init__(self):
self.log = Log()
class Boot():
def __init__(self):
self.log=Log()
self.log.create_log()
self.log.print("Log file created...","OK")
def start(self):
self.log.print("validating wifi credentials...","OK")
while True:
if(self.manage_wifi()):
break
self.log.print("Configuration complete...","OK")
self.log.print("Starting new instance of the app...","OK")
app=App(CONFIG['app_name'],CONFIG['app_key'],CONFIG['app_version'])
app.start()
def manage_wifi(self):
wifi=Wifi(CONFIG['interface'],CONFIG['wifi_ssid'],CONFIG['wifi_key_mgmt'],CONFIG['wifi_password'])
status=wifi.status()
if(status>=0):
if(status==1):
return True
if(status==0):
if(wifi.scan()):
wifi.disconnect()
wifi.connect()
return False
else:
self.log.print("Creating a hotstop to configure the device...","OK")
hotspot=Hotspot(CONFIG['interface'],CONFIG['hotspot_ssid'],CONFIG['hotspot_key_mgmt'],CONFIG['hotspot_password'])
if(hotspot.create()):
return True
else:
self.log.print("Unable to create the hotspot...","OK")
return False
else:
if(wifi.scan()):
wifi.disconnect()
wifi.connect()
return False
else:
self.log.print("Creating a hotstop to configure the device...","OK")
hotspot=Hotspot(CONFIG['interface'],CONFIG['hotspot_ssid'],CONFIG['hotspot_key_mgmt'],CONFIG['hotspot_password'])
if(hotspot.create()):
return True
else:
self.log.print("Unable to create the hotspot...","OK")
return False
async def test():
recorder = Recorder(Log.create(Log.path('test')))
manager = MockTradeManager(recorder)
strategy = MeanStrategy(0, manager)
manager.test_strategy(strategy, 'app/data/XAGUSD_5_2019-10-02.csv',
'XAGUSD_1002_random')
async def test():
logger = Log.create(Log.path('test')).get_logger('test')
client = ClientBase(logger, 1)
await client.initialize()