def close(self):
try:
self.connection.shutdown(socket.SHUT_RDWR)
except Exception as err:
log.error('{}\nfrom {}'.format(err, self.address))
else:
log.info('Closed connection for {address}'.format(address=self.address))
def check_status(cmd):
try:
response = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
except Exception as err:
log.error(err)
return False
else:
log.info('Response: successfully')
return response
def run(self):
self._init_tcp_server()
while self.flag_run:
response = CommonQueue.CQ.get()
log.info(response)
if not isinstance(response, dict):
log.error('<{}> must be <dict> type. <{}>'.format(response, type(response)))
elif self._get_key(response)[0] in self._get_key(self.queue_handlers):
self.queue_handlers[self._get_key(response)[0]](response[self._get_key(response)[0]])
def check_host(host=None, port=None, _socket=None):
log.info('Connecting to {}:{}:{} ...'.format(host, port, _socket))
try:
_socket.connect((host, port))
except Exception as err:
log.error('HOST: {} ERROR: {}'.format(host, err))
SystemQueue.SCQ.put(False)
else:
log.info('Connect :) HOST: {}'.format(host))
_server_identification(host, _socket)
def cp_syslog(dir_name):
log.info('cp /var/log/syslog /home/user/{}'.format(dir_name))
try:
subprocess.Popen('cp /var/log/syslog /home/user/{}'.format(dir_name),
shell=True,
stdout=subprocess.PIPE)
except Exception as err:
log.error(err)
else:
log.info('cp syslog successfully')
def mkdir_for_syslog(dir_name):
log.info('mkdir /home/user/{}'.format(dir_name))
try:
subprocess.Popen('mkdir /home/user/{}'.format(dir_name),
shell=True,
stdout=subprocess.PIPE)
except Exception as err:
log.error(err)
else:
log.info('mkdir successfully')
def commit_changes(conn):
# Make the changes to the database persistent
try:
conn.commit()
except Exception as err:
log.error(err)
return False
else:
log.info('Commit: successfully')
return True
def __get_from_queue(self, wait=False):
if wait:
Sender.while_empty(self)
try:
data = CommonQueue.CQ.get(block=False)
except Exception as err:
log.error(err)
return False
if data != 'SAVE':
return data
return False
def _f(object_to_check):
log.info('{}, args: {}'.format(f_object, object_to_check))
try:
sample = object_to_check.split('.')
except Exception as err:
log.error(err)
raise err
if len(sample) != 4:
raise Exceptions.FailCheckLenIP(
'len({}) must be 4'.format(object_to_check))
log.info('Function: {}, Status: OK'.format(f_object.__name__))
return f_object(object_to_check)
def insert_into_head_data(cursor, bat_name, dis, in_sec, in_date):
try:
cursor.execute("INSERT INTO head_data ("
"battery_name, "
"discharge_current, "
"start_at_in_sec, "
"start_at_in_date) VALUES(?, ?, ?, ?)", (bat_name, str(dis), in_sec, in_date))
except Exception as err:
log.error(err)
return False
else:
log.info('Insert in table <head_data> {} {} {} {}: successfully'.format(bat_name, str(dis), in_sec, in_date))
return True
def create_table_head_data_in_db(cursor):
# Execute a command: this creates a new table
try:
cursor.execute("CREATE TABLE head_data ("
"battery_name varchar, "
"discharge_current int, "
"start_at_in_sec timestamp, "
"start_at_in_date timestamp);")
except Exception as err:
log.error(err)
return False
else:
log.info('Create table <head_data>: successfully')
return True
def insert_into_db(cursor, in_sec, in_date, back_up):
try:
cursor.execute("INSERT INTO data ("
"time_sec, "
"time_in_date, "
"back_up) VALUES(?, ?, ?)", (in_sec, in_date, back_up))
except Exception as err:
log.error(err)
return False
else:
log.info("INSERT INTO data ("
"time_sec, "
"time_in_date, "
"back_up) VALUES({}, {}, {})".format(in_sec, in_date, back_up))
return True
def _f(*object_to_check):
log.info('init client...')
log.info(f_object)
log.info(object_to_check)
try:
_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # , 'i')
except Exception as err:
log.error(err)
SystemQueue.SCQ.put(False)
return False
else:
_socket.setblocking(False)
_socket.settimeout(1)
log.info('function: <{}>, host: {}, STATUS: OK'.format(f_object.__name__, object_to_check[0]))
return f_object(*object_to_check, _socket)
def _f(*object_to_check):
log.info('{}, args: {}'.format(f_object, *object_to_check))
# This part of function need for check input parameter that to ensure the safe execution of the function
for index, argument in enumerate(inspect.getfullargspec(f_object)[0]):
if object_to_check[index] is not None:
if not isinstance(object_to_check[index],
f_object.__annotations__[argument]):
log.error('object_to_check <{}> must be {f} type'.format(
*object_to_check,
f=f_object.__annotations__[argument]))
return False
else:
log.error('object_to_check <{}> is <None> type'.format(
*object_to_check))
return True
log.info('Function: {}, Status: OK'.format(f_object.__name__))
return f_object(*object_to_check)
def _init_tcp_server(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.sock.bind((self.ip, self.port))
except Exception as err:
log.error(err)
# raise err
return False
else:
self.sock.listen(10)
self.sock.setblocking(False)
self.sock.settimeout(1)
log.info('server start. ip: {} port: {}'.format(self.ip, self.port))
self.acceptThread.sock = self.sock
self.acceptThread.start()
self.timer.go_go()
self.flag_run = True
def create_table_in_db(cursor):
# Execute a command: this creates a new table
try:
cursor.execute("CREATE TABLE data ("
"id INTEGER PRIMARY KEY AUTOINCREMENT, "
"time_sec timestamp, "
"time_in_date timestamp, "
"back_up varchar );")
except sqlite3.OperationalError as err:
log.info(err)
return True
except Exception as err:
log.error(err)
return False
else:
log.info('Create table <data>: successfully')
return True
def init_db(name_db):
try:
conn = sqlite3.connect('{}.db'.format(name_db)) # или :memory: чтобы сохранить в RAM
except Exception as err:
print(err)
log.error(err)
return False, False
else:
log.info('Init db <{}>: successfully'.format(name_db))
try:
cursor = conn.cursor()
except Exception as err:
print(err)
log.error(err)
return False, False
else:
log.info('Create cursor for db <{}>: successfully'.format(name_db))
return conn, cursor
def _get_data_from_server(self, _socket, _sender):
try:
data = _socket.recv(1024).decode()
except socket.timeout:
if not _sender.running:
_socket = False
log.info('_socket: {}'.format(_socket))
except Exception as err:
_socket = False
self._socket_error(err, _sender)
else:
if not data:
log.error('No data from {}'.format(data))
_socket = False
self._socket_error('No data', _sender)
else:
# ADD related to key data from )_sender !!!!
if _sender.walkie_talkie_runner and data == 'READY TO NEXT\r\n':
_sender.walkie_talkie_runner = False
self.data_callback(data)
return _socket
def parse_status(integer, sting, name_service):
if 'Active: ' in sting:
# current_state = sting.split('Active: ')[1].split(' since')[0]
try:
current_at_start = sting.split('since ')[1].split(' EEST;')[0]
except Exception as err:
log.error(err)
return False
# current_ago = sting.split('EEST; ')[1].split(' ago')[0]
# current_dimention = check_time_dimention(current_ago)
else:
if hist[name_service]['start_at']:
# if check_time_dimention(hist[name_service]['ago']) == current_dimention:
if hist[name_service]['start_at'] != current_at_start:
hist[name_service]['start_at'] = current_at_start
return True
else:
return False
else:
hist[name_service]['start_at'] = current_at_start
return False
def select_from_db(cursor, name_table_in_db, param='*'):
try:
cursor.execute("SELECT {} FROM {};".format(param, name_table_in_db))
# cursor.execute("SELECT {} FROM {} WHERE volt > 2400;".format(param, name_table_in_db))
except Exception as err:
log.error(err)
return False
else:
try:
data = cursor.fetchall()
except Exception as err:
log.error(err)
return False
else:
log.info('Select {} from table {}: successfully'.format(param, name_table_in_db))
# print(len(data))
# print(data)
#
# for line in data:
# print(line)
return data
def run(self):
self.db_conn, self.db_cursor = db.init_db('PyARKio.io')
_delta_on = 0
while self.running:
response = Sender.__get_from_queue(self, wait=True)
if response:
# check data type
log.info('SEND: {}'.format(response))
try:
self.sender_socket.send(bytes(response, encoding='UTF-8'))
except Exception as err:
log.error('SENDER: {}'.format(err))
self.system_callback({'ERROR': err})
self._back_up()
else:
self.walkie_talkie_runner = True
_delta_on = time.time()
log.info('WALKIE-TALKIE: {}, _delta_on: {}'.format(
self.walkie_talkie_runner, _delta_on))
elif not self.running:
self.system_callback({'ERROR': 'SOMEBODY STOP SENDER'})
self._back_up()
self.walkie_talkie(_delta_on)
def run(self):
log.info('start for {}'.format(self.address))
while self.flag_run:
try:
log.debug('start listen')
data = self.connection.recv(10000)
log.debug('stop listen {}'.format(data))
except Exception as err:
log.error('{}\nfrom {}'.format(err, self.address))
if self.flag_run:
CommonQueue.CQ.put({'speak error': {'string': err, 'who': self.address}})
self.flag_run = False
self.close()
else:
if not data:
log.error('No data from {}'.format(self.address))
if self.flag_run:
CommonQueue.CQ.put({'speak error': {'string': 'No data', 'who': self.address}})
self.flag_run = False
self.close()
else:
if self.flag_run:
# CommonQueue.CQ.put({'speak': {'string': data.decode('cp1251'),
# 'who': self.address,
# 'certificate': self.certificate,
# 'status': self.status,
# 'time': self.time,
# 'ping': self.ping
# }
# })
self.time = time.time()
CommonQueue.CQ.put({'speak': {'string': data.decode('cp1251'),
'who': self.address,
'time': self.time,
'date': datetime.now()
}
})
def __init__(self, ip=None, _port=None, data_cb=None, sys_cb=None,
word_for_check_new_acceptance={'request': None, 'response': None}, _run_timer=False):
"""
:param ip:
:param port:
:param callback:
:param word_for_check_new_acceptance: must be list type with 2 include, for example, ['request', 'response']
:return:
"""
if not self._check_args(ip, _port, data_cb, sys_cb, word_for_check_new_acceptance, _run_timer):
log.error(Exceptions.FailCheckServerArgs('Oops :) Some args are incorrect'))
raise Exceptions.FailCheckServerArgs('Oops :) Some args are incorrect')
self.sock = None
self.ip = ip
self.port = _port
self.data_callback = data_cb
self.sys_callback = sys_cb
self.is_check_new_acceptance = word_for_check_new_acceptance
threading.Thread.__init__(self)
self.flag_run = False
self.info = dict()
self.queue_handlers = {'acceptance': self.accept_handler,
'accept error': self.accept_error_handler,
'speak': self.speak_handler,
'speak error': self.speak_error_handler,
'control': self.cmd_handler
}
self.acceptThread = Thread4Accept()
self.speakThread = dict()
if _run_timer:
self.timer = Interrupt(callback_handler=self.callback_for_timer, periodic=1)
def port(response: int):
log.info('response: {}'.format(response))
try:
result = maximum_value(subtraction_sign(response))
except Exceptions.FailCheckInt as err:
log.error(err)
except Exceptions.FailCheckMaxValue as err:
log.error(err)
except Exceptions.FailCheckErrSign as err:
log.error(err)
except Exception as err:
log.error(err)
else:
log.info(result)
return result
return False
def ip(response: str):
log.info('response: {}'.format(response))
try:
result = ip_max(ip_ever_segments(ip_digit(ip_len(response))))
except Exceptions.FailCheckStr as err:
log.error(err)
except Exceptions.FailCheckLenIP as err:
log.error(err)
except Exceptions.FailCheckDigitIP as err:
log.error(err)
except Exception as err:
log.error(err)
else:
log.info(result)
return result
return False
def accept_error_handler(self, string_err):
log.error(string_err)
self.sys_callback(str(string_err))
def _send(whom, what):
try:
whom.send(bytes(str(what) + '\r\n', encoding='UTF-8'))
except Exception as err:
log.error(err)
