async def ping(ctx): latency = round(client.latency * 1000) author = f'{ctx.author.name}#{ctx.author.discriminator}' logger.i(f'ℹ️ {author} ask for latency: {latency}ms') title = f'Latency : {latency}ms' embed = discord.Embed(title=title, color=0xe6742b) await ctx.send(embed=embed)
async def advice(ctx): author = f'{ctx.author.name}#{ctx.author.discriminator}' r = requests.get('https://api.adviceslip.com/advice').json() advice = r['slip']['advice'] logger.i(f'ℹ️ {author} ask for an advice. {advice}') embed = discord.Embed(title=advice, color=0xe6742b) await ctx.send(embed=embed)
def run(self): logo.dodo() ur = update_rate while not self.stopped: if 1 > datetime.now().hour > 6: if ur == update_rate: ur = 0 json_data = vk.Wall.get() likes = vk.Wall.get_latest_post_likes(json_data) fromid = int(vk.Wall.get_from_id(json_data)) post_id = vk.Wall.get_latest_post(json_data) if not vk.Likes.is_liked(post_id): if likes < min_likes: if fromid_group == fromid: delay = rand(delay_from, delay_to) log.d("From dodo") else: delay = rand(big_delay_from, big_delay_to) log.d("Not from dodo") log.i("Delay = " + str(delay)) wait(delay) else: log.i("Delay = 0") log.i_n("Likes = " + str(vk.Likes.add(post_id)) + "\n***Text***\n" + vk.Wall.get_latest_post_text(json_data) + "\n**********") ur += 1 wait(1)
def _send_segment(self, data=b'', syn=False, ack=False, fin=False, events=[]) -> Segment: ''' Send the segment and update the sequence number. ''' seg = Segment(self._seq_num, self._ack_num, data, syn=syn, ack=ack, fin=fin) logger.i('sending {}'.format(seg)) # Update the sequence number self._seq_num += len(data) + syn + fin self._send_fn(seg, self._addr, events=events) # Will this segment need an ack? needs_ack = not seg.ack or seg.data or seg.syn or seg.fin if needs_ack: # If so, track and time it self._unacked.append(seg) if not self._timer: self._set_timer() # Set the timer if there isn't one if not self._rtt_seg: logger.w('Tracking RTT for segment {}'.format(seg.seq_num)) self._rtt_seg = seg
async def on_ready(): logger.i(f'✔️ {client.user} is connected to Discord!') if config.is_debug: await discord_helper.send_reddit_submissions_to_discord() return reddit_submissions_task.start() reset_log_filename.start()
def init(cls): if cls._instance is None: try: cls._instance = cls() logger.i("initialize gamepad is successfull.") except: logger.e("initialize gamepad failed.:" + str(sys.exc_info()[0])) logger.e(traceback.format_exc()) return cls._instance
def __init__(self, realsense): super(FrameWorker, self).__init__() context = zmq.Context() self.socket = context.socket(zmq.SUB) logger.i("Collecting updates from realsense server...") self.socket.connect("tcp://localhost:5501") self.socket.setsockopt(zmq.SUBSCRIBE, '') self.is_stop = False self.frame = None
def __init__(self, realsense, host): super(FrameWorker,self).__init__() self.context = zmq.Context() self.socket = self.context.socket(zmq.SUB) logger.i("Collecting updates from realsense server...:{0}".format(host)) self.socket.connect("tcp://{0}:5501".format(host)) self.socket.setsockopt(zmq.SUBSCRIBE, '') self.is_stop = False self.frame = None
def __init__(self, event, initial_data): super(ReadLineWorker, self).__init__() context = zmq.Context() self.socket = context.socket(zmq.SUB) logger.i("Collecting updates from gamepad server...") self.socket.connect("tcp://localhost:5602") self.socket.setsockopt(zmq.SUBSCRIBE, '') self.is_stop = False self.line = initial_data self.event = event
def run(self): try: logger.i("flask server has started. host:{0}, port:{1}".format(self.host, self.port)) self.flask_app.run( debug=False, host=self.host, port=int(self.port) ) except Exception as e: logger.e("Unexpected error:" + str(sys.exc_info()[0])) logger.e(traceback.format_exc()) self.lock.acquire() self.errors.append(e) self.lock.release()
def _do_upgrade(): """ Upgrade the database if necessary. See CHANGELOG for changes made in each version. """ dao = Dao() existing_ver = dao.get_db_version() if existing_ver > DB_VERSION: logger.e('DB version ({}) is older than the existing version ({})!' .format(DB_VERSION, existing_ver)) elif existing_ver < DB_VERSION: logger.w('DB needs to upgrade from version {} to {}' .format(existing_ver, DB_VERSION)) input('Press enter to continue...') dao.upgrade_db(existing_ver, DB_VERSION) dao.set_db_version(DB_VERSION) dao.commit() logger.i('DB upgrade complete!')
def _do_upgrade(): """ Upgrade the database if necessary. See CHANGELOG for changes made in each version. """ dao = Dao() existing_ver = dao.get_db_version() if existing_ver > DB_VERSION: logger.e( 'DB version ({}) is older than the existing version ({})!'.format( DB_VERSION, existing_ver)) elif existing_ver < DB_VERSION: logger.w('DB needs to upgrade from version {} to {}'.format( existing_ver, DB_VERSION)) input('Press enter to continue...') dao.upgrade_db(existing_ver, DB_VERSION) dao.set_db_version(DB_VERSION) dao.commit() logger.i('DB upgrade complete!')
def init(cls): try: if cls._port is None: logger.i("searching controller....") cls._port = cls.__find_controller_port() if cls._instance is None and cls._port is not None: logger.i("find port: " + str(cls._port)) try: cls._instance = cls(cls._port) except serial.SerialException: pass else: logger.w("controller is not connected.") except: logger.e('HwControllerManager.init() failed.' + str(sys.exc_info()[0])) return cls._instance
def run(self): logger.i('I started') # Start the control thread self.__ct.start() # Start listening server_sock = socket.socket() server_port = env.get_server_port() server_sock.bind(('', server_port)) server_sock.listen(env.get_tcp_listen_backlog()) logger.i('Listening on server port {}'.format(server_port)) while True: # Main loop logger.i('Waiting for a new client connection') client_sock, address = server_sock.accept() logger.i('Connection established with {}'.format(address)) # Dispatch cht = ClientHandlerThread(self, client_sock) logger.i('Starting ClientHandlerThread {}'.format(cht.name)) cht.start()
def run(self): logger.i('I started') control_sock = socket.socket() control_port = env.get_control_port() # Only allow control messages from localhost for security control_sock.bind(('localhost', control_port)) control_sock.listen(env.get_tcp_listen_backlog()) logger.i('Listening on control port {}'.format(control_port)) while True: logger.i('Waiting for a new controller connection') client_sock, address = control_sock.accept() logger.i('Connection established with controller {}' .format(address))
def __init__(self, event, host): super(ReadLineWorker, self).__init__() self.host = host self.context = zmq.Context() self.socket = self.context.socket(zmq.SUB) logger.i("Collecting updates from gamepad server...:{0}".format(host)) self.socket.connect("tcp://{0}:5602".format(self.host)) self.socket.setsockopt(zmq.SUBSCRIBE, '') self.is_stop = False self.event = event self.line = None try: self.line = self.get_initial_data() logger.i("initialize gamepad is successfull.") except: logger.w("initialize gamepad failed. trying to connect..:" + str(sys.exc_info()[0]))
def process(debug_mode): """ process. """ global conf, src_path logger.DEBUG_MODE = debug_mode conf = __get_configuration() logger.d("configuration: " + json.dumps(conf)) redis_info = __get_host_info() logger.d("redis info: {0}".format(str(redis_info))) for i in redis_info: chg_conf = __change_config(i, master) if chg_conf is not None: f = codecs.open(src_path, 'wb', encoding='utf-8') f.write(chg_conf) f.close() __set_configuration(src_path) o = __restart() logger.i(o)
def run(self): logger.i('I started') self.__st.cht_ready(self) while True: # Main loop for receiving requests try: req = self.__scrp_sock.receive_request() # Dispatch rht = RequestHandlerThread(self, req) logger.d('Starting RequestHandlerThread {}'.format(rht.name)) rht.start() except BytesMessageReceiveError as e: # Connection is broken break except (MessageDecodeError, JsonParseError, InvalidRequestDictError) as e: # Bad request raise BadRequestError except ScrpError as e: logger.e(e) logger.d('Thread terminate')
def __change_config(redis_info, master_info): """ change configuration. @param redis_info: (tuple) (host, port) for redis of logstash conf @param master_info: (tuple) (hist, port) for redis of master @return: (str) chagned configuration """ global conf convert = None if redis_info != master_info: logger.i("Change {0} to {1}".format(redis_info, master_info)) hp = r'(input.+?[{].+?redis.+?[{].+?host.+?=>.+?)"?' \ + redis_info[0] + r'"?(.+?[}])' rp = r'\1"' + master_info[0] + r'"\2' convert = re.sub(hp, rp, conf, flags=re.S) hp = r'(input.+?[{].+?redis.+?[{].+?port.+?=>.+?)"?' \ + str(redis_info[1]) + r'"?(.+?[}])' rp = r'\1"' + str(master_info[1]) + r'"\2' convert = re.sub(hp, rp, convert, flags=re.S) return convert
def __change_config(redis_info, master_info): """ change configuration. @param redis_info: (tuple) (host, port) for redis of logstash conf @param master_info: (tuple) (hist, port) for redis of master @return: (str) chagned configuration """ global conf convert = None if redis_info != master_info: logger.i("Change {0} to {1}".format(redis_info, master_info)) hp = r'(input.+?[{].+?redis.+?[{].+?host.+?=>.+?)"?' \ + redis_info[0] + r'"?(.+?[}])' rp = r'\1"' + master_info[0] + r'"\2' convert = re.sub(hp, rp, conf, flags=re.S) hp = r'(input.+?[{].+?redis.+?[{].+?port.+?=>.+?)"?' \ + str(redis_info[1]) + r'"?(.+?[}])' rp = r'\1"'+str(master_info[1])+r'"\2' convert = re.sub(hp, rp, convert, flags=re.S) return convert
def _view(self, pack): logger.i(pack)
async def log(ctx): author = f'{ctx.author.name}#{ctx.author.discriminator}' logger.i(f'ℹ️ {author} ask for log file.') await ctx.send(file=discord.File(logger.filename))
def dump(self, logger): logger.i("pid: " + repr(self._pid) + " pkg: " + self._pkg + " num_pages: " + repr(len(self._pages))) for page in self._pages: page.dump(logger, 4) return
async def restart(ctx): author = f'{ctx.author.name}#{ctx.author.discriminator}' logger.i(f'ℹ️ {author} wants to restart the reddit submissions.') await discord_helper.send_reddit_submissions_to_discord()
def stop(self): log.i("Exit. Please, wait...") self.stopped = True
def dump(self, logger, indent): logger.i(" " * indent + "title: " + self._title + " url: " + self._url + " id: " + self._id)
def _receive(self, seg: Segment, addr: (str, int)) -> None: ''' Process a segment that was received. ''' with self._lock: logger.i('received {}'.format(seg)) events = ['rcv'] # Make sure the packet comes from the correct address if not self._addr: self._addr = addr elif self._addr != addr: logger.e('[{}] Unknown source! {} {}'.format( self._state, self._addr, addr)) return # If the segment has a bit error, log it and do nothing if seg.bit_error: logger.add_bit_error_received() events.append('corr') logger.log(events, seg) return # If this segment has been acked or buffered, log it as duplicate if seg.seq_num < self._ack_num or seg.seq_num in self._buffer: logger.add_duplicate_data_segment() if self._state == States.CLOSED: logger.w('[{}] Received message in closed state'.format( self._state)) return elif self._state == States.LISTEN: if seg.syn: # Syn received, respond with syn_ack and update state self._ack_num = seg.seq_num + 1 self._set_state(States.SYN_RECEIVED) logger.log(events, seg) self._send_segment(syn=True, ack=True) else: logger.w( '[{}] Received non-syn segment in listen state'.format( self._state)) return # If this segment is an ACK if seg.ack: if seg.ack_num == self._last_ack: # We have a duplicate ack self._dup_ack_count += 1 events.append('DA') elif seg.ack_num > self._last_ack: # This acks at least the oldest unacked segment self._dup_ack_count = 0 # Stop the timer if self._timer: self._timer.cancel() self._timer = None if self._rtt_seg: r = self._rtt_seg expected_ack = r.seq_num + len(r.data) + r.syn + r.fin if expected_ack == seg.ack_num: # Calculate RTT dt = seg.created_at - self._rtt_seg.created_at rtt = dt.total_seconds() * 1000 self.addRTT(rtt) logger.w('Received RTT for segment {}, {:0.4f}'.format( self._rtt_seg.seq_num, rtt)) self._rtt_seg = None elif expected_ack < seg.ack_num: logger.w('Received ack beyond RTT seg, clearing') self._rtt_seg = None # Update the last ack received self._last_ack = seg.ack_num # Clear the unacked list for i in range(len(self._unacked)): if self._unacked[i].seq_num >= seg.ack_num: self._unacked = self._unacked[i:] break else: self._unacked.clear() # Track the ack number when this segment arrived previous_ack_num = self._ack_num # Update the ack num if this segment arrived in order. if self._ack_num == seg.seq_num: self._ack_num += len(seg.data) + seg.syn + seg.fin # Log the segment before we send other segments logger.log(events, seg) # Resend on three duplicate acks if self._dup_ack_count == 3: self._fast_retransmit(seg.ack_num) self._dup_ack_count = 0 # Process the segment's data. Define as a function, since this is # done in many states def process_data(): if seg.seq_num == previous_ack_num: logger.add_file_size(len(seg.data)) self._data_proc(seg.data + self._clear_buffer()) elif seg.seq_num > previous_ack_num: self._buffer[seg.seq_num] = seg if self._state == States.SYN_SENT: if seg.ack and seg.syn: self._set_state(States.ESTABLISHED) self._send_segment(ack=True) elif seg.data: # If the segment has data, buffer it. self._buffer[seg.seq_num] = seg elif self._state == States.SYN_RECEIVED: if seg.ack: # Acking the syn/ack we sent self._set_state(States.ESTABLISHED) elif seg.data: # If the segment has data, buffer it. self._buffer[seg.seq_num] = seg elif self._state == States.ESTABLISHED: if seg.data: process_data() if seg.fin: self._send_segment(ack=True) self._set_state(States.CLOSE_WAIT) elif self._state == States.FIN_WAIT_1: if seg.data: process_data() if seg.ack: self._set_state(States.FIN_WAIT_2) elif seg.fin: # Assume two separate segments for FIN / ACK self._set_state(States.CLOSING) elif self._state == States.FIN_WAIT_2: if seg.data: process_data() if seg.fin: self._send_segment(ack=True) self._set_state(States.FINISHED) elif self._state == States.CLOSE_WAIT: # Wait for application to close connection if seg.data: process_data() elif self._state == States.LAST_ACK: if seg.ack: self._set_state(States.FINISHED) elif self._state == States.CLOSING: if seg.ack: self._set_state(States.FINISHED) # If this is a data segment, send an ack if seg.data: events = [] if self._ack_num == previous_ack_num: events.append('DA') logger.add_duplicate_ack_sent() self._send_segment(ack=True, events=events) # Notify threads waiting on receipt of a segment self._receive_condition.notify_all()
async def pull(ctx): author = f'{ctx.author.name}#{ctx.author.discriminator}' logger.i(f'ℹ️ {author} ask for a pull on channel {ctx.channel.name}') await discord_helper.send_reddit_submissions_to_discord_channel(ctx.channel )
def main(): """Entry point of the daemon process""" logger.i('Starting ServerThread') ServerThread().start()
def _set_state(self, state: States) -> None: logger.i('State change: {} -> {}'.format(self._state.name, state.name)) self._state = state
def run(self): logger.i('I started') handler_cls = self.__req.get_handler_cls() handler = handler_cls() resp = handler.handle_request(self.__req) self.__cht.send_response(resp)