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)