def run(self): l.debug("Running listener") while True: l.debug("Awaiting new connection") try: # wait for new connection (n_sock, n_addr) = self.sock.accept() except Exception, e: l.error("Error accepting connection: " + str(e)) break l.debug("New connection from: %s" % str(n_addr)) # if there are more queued connections than allowed qc = conn_q.qsize() if qc >= int(params.max_queued_conns): l.warning("Queued %i connections, limit is %i" % (qc, int(params.max_queued_conns))) # if we were switching, than sorry, but not anymore l.info("Enabling relaying") relay.set("connection limit reached") try: conn_q.put([n_sock, n_addr], False) cbpx_stats.c_qc += 1 l.debug("Enqueued connection: %s" % str(n_addr)) except Full: l.error("Queue is full with %i elements!" % qc) l.info("Enabling relaying") relay.set("connection queue full") except Exception, e: l.warning("Exception during connection enqueue: %s" % str(e))
async def on_message(message): ch = message.channel is_private = isinstance(ch, discord.DMChannel) or isinstance( ch, discord.GroupChannel) l.info( f"[#{ch.id if is_private else ch.name}] {message.author.display_name}: {message.content}" )
async def shutdown_(self, ctx, noconfirm=False): if noconfirm: result = "y" else: m = await ctx.send(embed=make_embed( color=colors.EMBED_ASK, title="Shutdown?", description= "This action may be difficult to undo without phsyical or remote access to the host machine. Are you sure?", )) result = await react_yes_no(ctx, m) await (ctx.send if noconfirm else m.edit)(embed=make_embed( color={ "y": colors.EMBED_INFO if noconfirm else colors.EMBED_CONFIRM, "n": colors.EMBED_CANCEL, "t": colors.EMBED_TIMEOUT, }[result], title={ "y": "Shutting down...", "n": "Shutdown cancelled.", "t": "Shutdown timed out.", }[result], )) if result is "y": l.info( f"Shutting down at the command of {ctx.message.author.display_name}..." ) await self.bot.logout()
async def load_all_extensions(self, reload=False): """Attempt to load all .py files in cogs/ as cog extensions. Return a dictionary which maps cog names to a boolean value (True = successfully loaded; False = not successfully loaded). """ succeeded = {} disabled_extensions = set() if not info.DEV: disabled_extensions.add('tests') for extension in get_extensions(disabled=disabled_extensions): try: if reload or extension not in self.cogs_loaded: self.load_extension(f'cogs.{extension}') l.info(f"Loaded extension '{extension}'") self.cogs_loaded.add(extension) succeeded[extension] = True except Exception as exc: l.error( f"Failed to load extension {extension!r} due to {type(exc).__name__}: {exc}" ) if hasattr(exc, 'original'): l.error( f"More details: {type(exc.original).__name__}: {exc.original}" ) succeeded[extension] = False if succeeded: l.info(LOG_SEP) return succeeded
async def shutdown_(self, ctx, noconfirm=False): if noconfirm: response = 'y' else: m, response = await utils.discord.get_confirm_embed( ctx, title="Shutdown?", description= "This action may be difficult to undo without phsyical or remote access to the host machine. Are you sure?", ) if response == 'y': title = "Shutting down\N{HORIZONTAL ELLIPSIS}" else: title = f"Shutdown {strings.YESNO[response]}" if noconfirm: color = colors.INFO else: color = colors.YESNO[response] await (ctx.send if noconfirm else m.edit)( embed=discord.Embed(color=color, title=title)) if response == 'y': l.info( f"Shutting down at the command of {utils.discord.fake_mention(ctx.author)}..." ) await self.bot.logout()
async def load_extensions(extensions): for extension in extensions: await asyncio.sleep(0) try: bot.load_extension("cogs." + extension) except Exception: continue bot.loaded_extensions.add(extension) l.info("Loaded all extensions")
async def on_ready(self): self.app_info = await self.application_info() l.info(LOG_SEP) l.info(f"Logged in as: {self.user.name}") l.info(f"discord.py: {discord.__version__}") l.info(f"Owner: {self.app_info.owner}") l.info(LOG_SEP) await self.load_all_extensions() await self.ready_status()
async def load_extensions(extensions): for extension in extensions: await asyncio.sleep(0) try: bot.load_extension("cogs." + extension) except Exception as e: print(f"Failed to load {extension}: {type(e).__name__}: {e}") continue bot.loaded_extensions.add(extension) l.info("Loaded all extensions")
def __init__(self): l.debug("Starting readline user interface") self.__print_logo() try: readline.read_history_file(params.history_file) except IOError: file(params.history_file, "w") l.info("Create history file. File path: %s" % (params.history_file)) print " Ready for your commands, my master.\n"
def main(): l.info("Starting IP Rotator version %s" % (__version__)) odl = opendaylight() while True: ip_address = ip() for switch in params.switch: flow = { 'name_in': '%s_in_%s' % (params.flow_prefix, ip_address.replace('.','_')), 'name_out': '%s_out_%s' % (params.flow_prefix, ip_address.replace('.','_')), 'priority': params.flow_priority } current_flows = odl.get_flow(node={'id': switch}) #Check priority of current flows for name, value in current_flows.items(): if re.search(params.flow_prefix, name): if int(flow['priority']) == int(value['priority']): flow['priority'] = str(int(value['priority'])+1) l.debug("Priority for flows: %s" % (flow['priority'])) #Add new flows try: for port in params.flow_port: odl.add_flow(name=flow['name_in']+'_'+port, installInHw='true', node={"id":switch, "type": "OF"}, priority=flow['priority'], etherType='0x800', protocol='tcp', nwDst=ip_address, tpSrc=port, actions=['SET_NW_DST='+params.outgoing_ip, 'HW_PATH'] ) odl.add_flow(name=flow['name_out']+'_'+port, installInHw='true', node={"id":switch, "type": "OF"}, priority=flow['priority'], etherType='0x800', protocol='tcp', tpDst=port, tosBits=params.flow_tos_bits, actions=['SET_NW_SRC='+ip_address, 'HW_PATH'] ) finally: l.info("I've set IP %s" % (ip_address)) for name, value in current_flows.items(): if re.search(params.flow_prefix, name): odl.delete_flow(node={"id":switch}, name=name) time.sleep(params.rotate_time)
async def shutdown(self, ctx): """Shuts down the bot without asking for confirmation. See `shutdown` for more details. """ await ctx.send( embed=make_embed(color=colors.EMBED_INFO, title="Shutting down...") ) l.info( f"Shutting down at the command of {ctx.message.author.display_name}..." ) await self.bot.close()
def load_data(filename): try: with open(path.join(DATA_DIR, filename), 'r', encoding='utf-8') as f: data = json.load(f) l.info(f"Loaded data file {filename}") return data except: l.warning( f"There was an error loading {filename}; backing up file and assuming empty dictionary" ) rename(filename, f'{filename}.{int(datetime.now().timestamp())}.bak') return {}
def delete_flow(self,**kwargs): api_url=("%s/controller/nb/v2/flowprogrammer/default/node/OF/%s/staticFlow/%s" % (params.odl_server, kwargs['node']['id'], kwargs['name'])) self.__auth(api_url) request = urllib2.Request(api_url) request.get_method = lambda: 'DELETE' connection = urllib2.urlopen(request) if connection.code == 204: l.info("Flow has been deleted, name: %s" % kwargs['name']) else: l.error("Error during deleting flow entry, name: %s, http error: %s" % (kwargs['name'], connection.code))
def load_data(filename: str) -> dict: fullpath = path.join(DATA_DIR, filename) try: with open(fullpath, 'r', encoding='utf-8') as f: data = json.load(f) l.info(f"Loaded data file {path.relpath(filename)!r}") return data except Exception: msg = f"Error loading {path.relpath(filename)!r};" try: rename(fullpath, f'{fullpath}.{int(datetime.now().timestamp())}.bak') msg += f" backing up existing file and" except Exception: pass msg += " assuming empty dictionary" l.warning(msg) return {}
def save_data(filename: str, data: dict) -> None: # Use a temporary file so that the original one doesn't get corrupted in the # case of an error. fullpath = path.join(DATA_DIR, filename) try: if not path.isdir(path.dirname(fullpath)): makedirs(path.dirname(fullpath)) tempfile, tempfile_path = mkstemp(dir=DATA_DIR) with open(tempfile, 'w', encoding='utf-8') as f: json.dump(data, f, indent='\t') rename(tempfile_path, path.join(DATA_DIR, filename)) l.info(f"Saved data file {path.relpath(filename)!r}") except Exception: l.warning(f"Error saving {path.relpath(filename)!r}") finally: try: remove(tempfile_path) except Exception: pass
async def load_all_extensions(self, reload=False): """ Attempts to load all .py files in cogs/ as cog extensions. Returns a dictionary which maps cog names to a boolean value (True = successfully loaded; False = not successfully loaded). """ succeeded = {} for extension in get_extensions(): try: if reload or extension not in self.cogs_loaded: self.load_extension(f'cogs.{extension}') l.info(f"Loaded extension '{extension}'") self.cogs_loaded.add(extension) succeeded[extension] = True except Exception as e: error = f"{extension}\n {type(e).__name__} : {e}" l.error(f"Failed to load extension '{error}'") succeeded[extension] = False if succeeded: l.info(LOG_SEP) return succeeded
def process_command(self): try: line = self.ui.read() if not line: return l.info("Got command: '%s'" % line) l_cmd = line.split(" ")[0] l_args = line.split(" ")[1:] if l_cmd and (l_cmd not in self.commands.keys()): self.ui.write(" Unknown command: '%s'" % l_cmd) self.ui.finish() else: res = self.commands[l_cmd][0](l_args) self.ui.finish() return res except KeyboardInterrupt: l.debug("Got KeyboardInterrupt, ignoring") self.ui.write("") except EOFError: self.ui.write("") except Exception, e: l.warning("Exception %s: %s" % (type(e), str(e)))
def cmd_switch(self, args): active = relay.get_active() (ai, ap) = active (si, sp) = relay.get_standby() self.ui.write(" Starting switch: %s:%i -> %s:%i, timeout: %2.2f s, %i connections buffer\n" % (ai, ap, si, sp, float(params.switch_max_time), int(params.max_queued_conns))) l.info("Starting switch: %s:%i -> %s:%i, timeout: %2.2f s, %i connections buffer" % (ai, ap, si, sp, float(params.switch_max_time), int(params.max_queued_conns))) # stop relaying connections now relay.clear("switch started") # set the timer for max switch time switch_timer = SwitchTimer(float(params.switch_max_time)) switch_timer.start() switch_start = time.time() # print initial stats self.print_stats(True, 0) l.debug("About to enter switch loop") while not relay.isSet(): try: l.debug("Switch loop wait") threading.Event().wait(float(params.switch_loop_wait)) # print stats waited = time.time() - switch_start self.print_stats(False, waited) l.debug("Switch active, waited: %2.2f" % waited) except Exception, e: l.info("Exception in 'switch' loop: %s" % str(e)) except KeyboardInterrupt: l.warning("Ctrl-c in switch loop, break") self.ui.write(" Ctrl-c") relay.set("ctrl-c")
def switch_finalize(): if not params.switch_script: l.info("No switch finalize script to run, finishing switch immediately") relay.switch_backend("all connections closed") return try: global script devnull = open(os.devnull, "rw") (ai, ap) = relay.get_active() (si, sp) = relay.get_standby() l.info("Running script: '%s' with arguments: %s %i %s %i" % (params.switch_script, ai, ap, si, sp)) script = subprocess.Popen([params.switch_script, ai, str(ap), si, str(sp)], stdin=devnull, stdout=devnull, stderr=devnull, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0) r = script.wait() except Exception, e: l.error("Exception while executing switch finalize script (%s): %s" % (params.switch_script, str(e))) relay.set("script exec failed: %s" % str(e)) return
async def on_ready(self): self.app_info = await self.application_info() l.info(LOG_SEP) l.info(f"Logged in as: {self.user.name}") l.info(f"Using discord.py version: {discord.__version__}") l.info(f"Owner: {self.app_info.owner}") l.info(f"Template Maker: SourSpoon / Spoon#7805") l.info(LOG_SEP) await self.load_all_extensions() await self.ready_status()
async def on_ready(): l.info(f"Logged in as {bot.user.name}#{bot.user.discriminator}")
async def on_resume(): l.info("Resumed session")
async def on_ready(): bot.owner_id = (await bot.application_info()).owner.id l.info(f"Ready") await wait_until_loaded() await bot.change_presence(status=discord.Status.online)
async def on_connect(self): l.info(f"Connected as {self.user}") await self.change_presence(status=discord.Status.idle)
async def on_resumed(self): l.info("Resumed session.") await self.ready_status()
async def on_guild_join(self, guild): """This event triggers when the bot joins a guild.""" l.info(f"Joined {guild.name} with {guild.member_count} users!")
devnull = open(os.devnull, "rw") (ai, ap) = relay.get_active() (si, sp) = relay.get_standby() l.info("Running script: '%s' with arguments: %s %i %s %i" % (params.switch_script, ai, ap, si, sp)) script = subprocess.Popen([params.switch_script, ai, str(ap), si, str(sp)], stdin=devnull, stdout=devnull, stderr=devnull, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0) r = script.wait() except Exception, e: l.error("Exception while executing switch finalize script (%s): %s" % (params.switch_script, str(e))) relay.set("script exec failed: %s" % str(e)) return l.info("Script exit: %i" % r) if r is None: # shouldn't happen relay.set("unexpected script finish with no return code") if r < 0: # terminated relay.set("script terminated by signal: %i" % -r) elif r > 0: # exited with error relay.set("script exited with code: %i" % r) else: # switch is done, change backend relay.switch_backend("all connections closed, script returned: %i" % r) l.info("Switch finalize script done.")
async def on_resumed(): await wait_until_loaded() await bot.change_presence(status=discord.Status.online) l.info("Resumed session")
async def on_connect(): l.info(f"Connected as {bot.user}") await wait_until_loaded() await bot.change_presence(status=discord.Status.idle)
async def on_ready(): l.info(f"Ready") await wait_until_loaded() await bot.change_presence(status=discord.Status.online)
except KeyboardInterrupt: l.warning("Ctrl-c in switch loop, break") self.ui.write(" Ctrl-c") relay.set("ctrl-c") switch_timer.cancel() l.debug("Loop done, checking conditions") # check what happened and report to user reason = relay.get_reason() if relay.get_active() == active: l.warning("Backend not switched: %s" % reason) self.ui.write("\n Switch failed: %s" % reason) else: l.info("Backend switched: %s" % reason) self.ui.write("\n Switch OK!: %s " % reason) # -------------------------------------------------------------------- def print_stats(self, header, switch): sw = "[n/a] " if switch != -1: try: sw = "%2.2f" % float(switch) except: pass if header: self.ui.write(" SWtime Current backend active in queue ->cps cps-> q total") self.ui.write(" ------ --------------------- ------ -------- ----- ----- -------") (ai, ap) = relay.get_active()