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 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 __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)
