def get_scaling_state(self, instance_id, default=None, meta=None, default_date=None, do_not_return_excluded=False): if meta is not None: for i in ["action", "draining", "error", "bounced"]: meta["last_%s_date" % i] = misc.str2utc( self.get_state("ec2.instance.scaling.last_%s_date.%s" % (i, instance_id), default=self.context["now"])) r = self.get_state("ec2.instance.scaling.state.%s" % instance_id, default=default) #Special case for 'excluded': We test it here so tags will override the value i = self.get_instance_by_id(instance_id) excluded_instances = Cfg.get_list("ec2.state.excluded_instance_ids", default=[]) if (i is not None and not do_not_return_excluded and (self.instance_has_tag( i, "clonesquad:excluded", value=["1", "True", "true"]) or i in excluded_instances or self.is_static_subfleet_instance(instance_id))): r = "excluded" # Force error state for some VM (debug usage) error_instance_ids = Cfg.get_list("ec2.state.error_instance_ids", default=[]) if instance_id in error_instance_ids: r = "error" return r
def build(static_lib = False, shared_lib = False, options = '', crossbuild_options=True, libs = '', cflags = '', subdir = ''): if static_lib and shared_lib: raise ValueError('Both static_lib and shared_lib options are specified') build_dir = _add_subpath(_info.build_dir, subdir) all_options = [ _find_configure(build_dir), '--prefix=' + cmdutil.to_unix_path(_info.install_dir) ] if toolchain.crossbuild and crossbuild_options: all_options.extend([ '--build=' + toolchain.build_triplet, '--host=' + toolchain.host_triplet]) if static_lib: all_options.extend(['--enable-static', '--disable-shared']) if shared_lib: all_options.extend(['--enable-shared', '--disable-static']) all_options.extend(options.split()) all_options.extend(config.get_list('options')) all_options.extend(config.get_list(_info.name + '-options')) env = _build_configure_env(libs.split(), cflags.split()) cmdutil.unix_exec('sh', all_options, work_dir=build_dir, extra_env=env) cmdutil.unix_make([], work_dir=build_dir) cmdutil.unix_make(['install'], work_dir=build_dir)
def _build_configure_env(user_libs, user_cflags): paths = [] libs = [] cflags = [] pkg_config_paths = [] for dep_name in _info.dependency_map().iterkeys(): if dep_name == _info.name: continue p = packageinfo.get(dep_name).install_dir bin_dir = path.join(p, 'bin') lib_dir = path.join(p, 'lib') include_dir = path.join(p, 'include') pkg_config_dir = path.join(p, 'lib', 'pkgconfig') if path.exists(bin_dir): paths.append(bin_dir) if path.exists(lib_dir): libs.append('-L' + cmdutil.to_unix_path(lib_dir)) if path.exists(include_dir): cflags.append('-I' + cmdutil.to_unix_path(include_dir)) if path.exists(pkg_config_dir): pkg_config_paths.append(cmdutil.to_unix_path(pkg_config_dir)) env_libs = config.get_list('libs') + config.get_list(_info.name + '-libs') env_cflags = config.get_list('cflags') + config.get_list(_info.name + '-cflags') result_path = os.pathsep.join(paths) result_libs = ' '.join(libs + user_libs + env_libs) result_cflags = ' '.join(cflags + user_cflags + env_cflags) result_pkg_config_path = ':'.join(pkg_config_paths) result = { 'PATH' : result_path, 'LIBS' : result_libs, 'CFLAGS' : result_cflags, 'CXXFLAGS' : result_cflags, 'PKG_CONFIG_PATH' : result_pkg_config_path, } if toolchain.crossbuild: pkg_config_libdir = path.join(toolchain.sysroot, 'lib', 'pkgconfig') result.update({ 'AR' : toolchain.tool_name('ar'), 'AS' : toolchain.tool_name('as'), 'CC' : toolchain.tool_name('gcc'), 'CXX' : toolchain.tool_name('g++'), 'LD' : toolchain.tool_name('ld'), 'NM' : toolchain.tool_name('nm'), 'DLLTOOL' : toolchain.tool_name('dlltool'), 'OBJDUMP' : toolchain.tool_name('objdump'), 'RANLIB' : toolchain.tool_name('ranlib'), 'STRIP' : toolchain.tool_name('strip'), 'WINRC' : toolchain.tool_name('windres'), 'PKG_CONFIG_LIBDIR' : cmdutil.to_unix_path(pkg_config_libdir) }) return result
def display_player_name(follow_id): """ Displays the player's name in the player-name custom cvar. Censor if in the list of blacklisted words. """ follow_player = STATE.get_player_by_id(follow_id) if follow_player is not None: player_name = follow_player.n display_name = player_name if player_name.strip( ) not in config.get_list('blacklist_names') else "*" * len(player_name)
async def connect(ctx, author, args): ip = args[0] if ip.split(':')[0] not in config.get_list("whitelist_servers"): msg = f"Server \"{ip}\" is not whitelisted. Refusing connection." api.exec_command( f"cg_centertime 5;displaymessage 140 8 ^3{author} ^1{msg};") logging.info(msg) await ctx.channel.send(msg) return serverstate.connect(ip, author)
def apply_whitelist(servers_data): """ Applies the server ip whitelist to current server data object :param servers_data: :return: """ from config import get_list filtered_server_data = dict() for sv_ip, sv_data in servers_data['active'].items(): if sv_ip.split(':')[0] in get_list('whitelist_servers'): filtered_server_data[sv_ip] = sv_data return filtered_server_data
async def gamma(ctx, author, args): whitelisted_twitch_users = config.get_list('whitelist_twitchusers') if USE_WHITELIST and author not in whitelisted_twitch_users and not ctx.author.is_mod: await ctx.channel.send( f"{author}, you do not have the correct permissions to use this command." f"If you wanna be whitelisted to use such a command, please contact neyo#0382 on discord." ) return value = float(args[0]) if 0.5 <= (value) <= 1.6: logging.info("i did it..") api.exec_command(f"r_gamma {value}") MapData.save(serverstate.STATE.mapname, 'gamma', value) else: await ctx.channel.send( f"{author}, the allowed values for gamma are 1.0-1.6")
def _find_module(filename): """ wrapper for imp.find_module. Searches for the module named after filename in the configured search path (tekka, plugin_dirs). """ # get the name of the module to search for name = strip_suffix(filename) mod_info = None try: mod_info = imp.find_module( name, config.get_list("nigiri","plugin_dirs",[])) except ImportError, e: print_error("Error while finding module for '%s'" % (filename)) return None
def _find_module(filename): """ wrapper for imp.find_module. Searches for the module named after filename in the configured search path (tekka, plugin_dirs). """ # get the name of the module to search for name = strip_suffix(filename) mod_info = None try: mod_info = imp.find_module( name, config.get_list("nigiri", "plugin_dirs", [])) except ImportError, e: print_error("Error while finding module for '%s'" % (filename)) return None
async def picmip(ctx, author, args): whitelisted_twitch_users = config.get_list('whitelist_twitchusers') if USE_WHITELIST and author not in whitelisted_twitch_users and not ctx.author.is_mod: await ctx.channel.send( f"{author}, you do not have the correct permissions to use this command." f"If you wanna be whitelisted to use such a command, please contact neyo#0382 on discord." ) return value = args[0] if value.isdigit() and (0 <= int(value) <= 6): logging.info("vid_restarting..") serverstate.VID_RESTARTING = True serverstate.PAUSE_STATE = True api.exec_command(f"r_picmip {value};vid_restart") MapData.save(serverstate.STATE.mapname, 'picmip', value) else: await ctx.channel.send( f"{author}, the allowed values for picmip are 0-5.")
def is_highlighted(server, text): def has_highlight(text, needle): punctuation = string.punctuation + " \n\t" ln = len(needle) for line in text.split("\n"): line = line.lower() i = line.find(needle) if i >= 0: if (line[i - 1:i] in punctuation and line[ln + i:ln + i + 1] in punctuation): return True return False server_tab = main_window.find_server(server) highlightwords = config.get_list("chatting", "highlight_words", []) highlightwords.append(server_tab.get_nick()) for word in highlightwords: if has_highlight(text, word): return True return False
def is_highlighted (server, text): def has_highlight(text, needle): punctuation = string.punctuation + " \n\t" ln = len(needle) for line in text.split("\n"): line = line.lower() i = line.find(needle) if i >= 0: if (line[i-1:i] in punctuation and line[ln+i:ln+i+1] in punctuation): return True return False server_tab = main_window.find_server(server) highlightwords = config.get_list("chatting", "highlight_words", []) highlightwords.append(server_tab.get_nick()) for word in highlightwords: if has_highlight(text, word): return True return False
def get_prerequisites(self): """ Gather instance status by calling SSM APIs. """ if not Cfg.get_int("ssm.enable"): log.log(log.NOTICE, "SSM support is currently disabled. Set ssm.enable to 1 to enabled it.") return now = self.context["now"] self.ttl = Cfg.get_duration_secs("ssm.state.default_ttl") GroupName = self.context["GroupName"] misc.initialize_clients(["ssm"], self.context) client = self.context["ssm.client"] # Retrive all SSM maintenace windows applicable to this CloneSquad deployment mw_names = { "__globaldefault__": {}, "__default__": {}, "__main__": {}, "__all__": {} } fmt = self.context.copy() mw_names["__globaldefault__"]["Names"] = Cfg.get_list("ssm.feature.maintenance_window.global_defaults", fmt=fmt) mw_names["__default__"]["Names"] = Cfg.get_list("ssm.feature.maintenance_window.defaults", fmt=fmt) mw_names["__main__"]["Names"] = Cfg.get_list("ssm.feature.maintenance_window.mainfleet.defaults", fmt=fmt) mw_names["__all__"]["Names"] = Cfg.get_list("ssm.feature.maintenance_window.subfleet.__all__.defaults", fmt=fmt) all_mw_names = mw_names["__globaldefault__"]["Names"] all_mw_names.extend([ n for n in mw_names["__default__"]["Names"] if n not in all_mw_names]) all_mw_names.extend([ n for n in mw_names["__main__"]["Names"] if n not in all_mw_names]) all_mw_names.extend([ n for n in mw_names["__all__"]["Names"] if n not in all_mw_names]) Cfg.register({ f"ssm.feature.maintenance_window.subfleet.__all__.force_running": Cfg.get("ssm.feature.maintenance_window.subfleet.{SubfleetName}.force_running"), f"ssm.feature.events.ec2.scaling_state_changes.draining.__main__.connection_refused_tcp_ports": Cfg.get("ssm.feature.events.ec2.scaling_state_changes.draining.connection_refused_tcp_ports") }) for SubfleetName in self.o_ec2.get_subfleet_names(): fmt["SubfleetName"] = SubfleetName mw_names[f"Subfleet.{SubfleetName}"] = {} Cfg.register({ f"ssm.feature.maintenance_window.subfleet.{SubfleetName}.defaults": Cfg.get("ssm.feature.maintenance_window.subfleet.{SubfleetName}.defaults"), f"ssm.feature.maintenance_window.subfleet.{SubfleetName}.ec2.schedule.min_instance_count": Cfg.get("ssm.feature.maintenance_window.subfleet.{SubfleetName}.ec2.schedule.min_instance_count"), f"ssm.feature.maintenance_window.subfleet.{SubfleetName}.force_running": Cfg.get("ssm.feature.maintenance_window.subfleet.{SubfleetName}.force_running"), f"ssm.feature.events.ec2.scaling_state_changes.draining.{SubfleetName}.connection_refused_tcp_ports": Cfg.get("ssm.feature.events.ec2.scaling_state_changes.draining.connection_refused_tcp_ports") }) mw_names[f"Subfleet.{SubfleetName}"]["Names"] = Cfg.get_list(f"ssm.feature.maintenance_window.subfleet.{SubfleetName}.defaults", fmt=fmt) all_mw_names.extend([ n for n in mw_names[f"Subfleet.{SubfleetName}"]["Names"] if n not in all_mw_names]) names = all_mw_names mws = [] while len(names): paginator = client.get_paginator('describe_maintenance_windows') response_iterator = paginator.paginate( Filters=[ { 'Key': 'Name', 'Values': names[:20] }, ]) for r in response_iterator: for wi in r["WindowIdentities"]: if not wi["Enabled"]: log.log(log.NOTICE, f"SSM Maintenance Window '%s' not enabled. Ignored..." % wi["Name"]) continue if "NextExecutionTime" not in wi: log.log(log.NOTICE, f"/!\ SSM Maintenance Window '%s' without 'NextExecutionTime'." % wi["Name"]) if wi not in mws: mws.append(wi) names = names[20:] # Make string dates as object dates for d in mws: if "NextExecutionTime" in d: d["NextExecutionTime"] = misc.str2utc(d["NextExecutionTime"]) # Retrieve Maintenace Window tags with the resourcegroup API tagged_mws = self.context["o_state"].get_resources(service="ssm", resource_name="maintenancewindow") for tmw in tagged_mws: mw_id = tmw["ResourceARN"].split("/")[1] mw = next(filter(lambda w: w["WindowId"] == mw_id, mws), None) if mw: mw["Tags"] = tmw["Tags"] valid_mws = [] for mw in mws: mw_id=mw["WindowId"] if "Tags" not in mw: try: response = client.list_tags_for_resource(ResourceType='MaintenanceWindow', ResourceId=mw_id) mw["Tags"] = response['TagList'] if 'TagList' in response else [] except Exception as e: log.error(f"Failed to fetch Tags for MaintenanceWindow '{mw_id}'") if ("Tags" not in mw or not len(mw["Tags"])) and mw["Name"] not in mw_names["__globaldefault__"]["Names"]: log.warning(f"Please tag SSM Maintenance Window '%s/%s' with 'clonesquad:group-name': '%s'!" % (mw["Name"], mw["WindowId"], self.context["GroupName"])) continue valid_mws.append(mw) self.maintenance_windows = { "Names": mw_names, "Windows": valid_mws } # Update asynchronous results from previously launched commands self.update_pending_command_statuses() # Perform maintenance window house keeping self.manage_maintenance_windows() if len(mws): log.log(log.NOTICE, f"Found matching SSM maintenance windows: %s" % self.maintenance_windows["Windows"]) # Hard dependency toward EC2 module. We update the SSM instance initializing states self.o_ec2.update_ssm_initializing_states()
def get_prerequisites(self, only_if_not_already_done=False): if only_if_not_already_done and self.prereqs_done: return self.state_table = self.o_state.get_state_table() client = self.context["ec2.client"] # Retrieve list of instances with appropriate tag Filters = [{ 'Name': 'tag:clonesquad:group-name', 'Values': [self.context["GroupName"]] }] instances = [] response = None while (response is None or "NextToken" in response): response = client.describe_instances( Filters=Filters, MaxResults=Cfg.get_int("ec2.describe_instances.max_results"), NextToken=response["NextToken"] if response is not None else "") for reservation in response["Reservations"]: instances.extend(reservation["Instances"]) # Filter out instances with inappropriate state non_terminated_instances = [] for i in instances: if i["State"]["Name"] not in ["shutting-down", "terminated"]: non_terminated_instances.append(i) self.instances = non_terminated_instances self.instance_ids = [i["InstanceId"] for i in self.instances] # Enrich describe_instances output with instance type details if Cfg.get_int("ec2.describe_instance_types.enabled"): self.instance_types = [] [ self.instance_types.append(i["InstanceType"]) for i in self.instances if i["InstanceType"] not in self.instance_types ] if len(self.instance_types): response = client.describe_instance_types( InstanceTypes=self.instance_types) self.instance_type_details = response["InstanceTypes"] for i in self.instances: i["_InstanceType"] = next( filter( lambda it: it["InstanceType"] == i["InstanceType"], self.instance_type_details), None) # Get instances status instance_statuses = [] response = None while response is None or "NextToken" in response: q = {"InstanceIds": self.instance_ids} if response is not None and "NextToken" in response: q["NextToken"] = response["NextToken"] response = client.describe_instance_status(**q) instance_statuses.extend(response["InstanceStatuses"]) self.instance_statuses = instance_statuses # Get AZ status response = client.describe_availability_zones() self.availability_zones = response["AvailabilityZones"] if len(self.availability_zones) == 0: raise Exception("Can't have a region with no AZ...") self.az_with_issues = [] if not Cfg.get_int("ec2.az.statusmgt.disable"): for az in self.availability_zones: if az["State"] in ["impaired", "unavailable"]: self.az_with_issues.append(az) if az["State"] != "available": log.warning( "AZ %s(%s) is marked with status '%s' by EC2.describe_availability_zones() API!" % (zone_name, zone_id, zone_state)) else: log.warning( "Automatic AZ issues detection through describe_availability_zones() is DISABLED (ec2.az.statusmgt.disable != 0)..." ) # Use these config keys to simulate an AWS Large Scale Event all_az_names = [az["ZoneName"] for az in self.availability_zones] all_az_ids = [az["ZoneId"] for az in self.availability_zones] [ log.warning( "ec2.debug.availability_zones_impaired do not match local AZs! '%s'" % a) for a in Cfg.get_list("ec2.debug.availability_zones_impaired", default=[]) if a not in all_az_names and a not in all_az_ids ] [ log.warning( "ec2.az.unavailable_list do not match local AZs! '%s'" % a) for a in Cfg.get_list("ec2.az.unavailable_list", default=[]) if a not in all_az_names and a not in all_az_ids ] for az in self.availability_zones: zone_name = az["ZoneName"] zone_id = az["ZoneId"] zone_state = az["State"] if zone_name in Cfg.get_list( "ec2.debug.availability_zones_impaired", default=[]): zone_state = "impaired" if zone_id in Cfg.get_list("ec2.debug.availability_zones_impaired", default=[]): zone_state = "impaired" if zone_name in Cfg.get_list("ec2.az.unavailable_list", default=[]): zone_state = "unavailable" if zone_id in Cfg.get_list("ec2.az.unavailable_list", default=[]): zone_state = "unavailable" if zone_state != az["State"] and zone_state in [ "impaired", "unavailable" ] and az not in self.az_with_issues: self.az_with_issues.append(az) az["State"] = zone_state if zone_state != "available": log.warning( "AZ %s(%s) is marked with status '%s' by configuration keys!" % (zone_name, zone_id, zone_state)) # We need to register dynamically static subfleet configuration keys to avoid a 'key unknown' warning # when the user is going to set it static_subfleet_names = self.get_static_subfleet_names() for static_fleet in static_subfleet_names: key = "staticfleet.%s.state" % static_fleet if not Cfg.is_builtin_key_exist(key): Cfg.register({key: ""}) log.log( log.NOTICE, "Detected following static subfleet names across EC2 resources: %s" % static_subfleet_names) self.prereqs_done = True
def query(self, query): results = [] # 翻译 if query[0] != "_": # 识别语言 [SL, TL] = RecgLang(query) # 翻译 Jresponse = GoogleTranslate(SL, TL, query) # 简单翻译结果 results.append({ "IcoPath": ICO_PATH, "Title": Jresponse[0][0][0], "SubTitle": "复制到剪贴板", "JsonRPCAction": { "method": "copy", "parameters": [Jresponse[0][0][0]], "dontHideAfterAction": False, }, }) # 词(组)详情 if Jresponse[1] != None: for item in Jresponse[1]: prefix = item[0] if prefix in DICT_PREFIX: prefix = DICT_PREFIX[prefix] str = "{}. {}".format(prefix, ", ".join( item[1][:(min(len(item[1]), ITEM_MAX_LEN))])) results.append({ "IcoPath": ICO_PATH, "Title": str, "SubTitle": "浏览器查看详情", "JsonRPCAction": { "method": "openUrl", "parameters": ["https://translate.google.cn/#view=home&op=translate&sl={}&tl={}&text={}" .format(SL, TL, query)], "dontHideAfterAction": False, }, }) # 设置 else: conf = query.split() if conf[0] == "_config": f_json = get_list() flag = {} # 设置语言 if (len(conf) == 4) and (conf[1] in f_json): if f_json[conf[1]] != conf[3]: if (set_lang(conf[1], conf[3])): flag = {conf[1]: " (Successful)"} else: flag = {conf[1]: " (ERROR: Input not supported)"} for item in f_json.keys(): if item in flag: if "Success" in flag[item]: title = "{} = {}".format(item, conf[3]) else: title = "{} = {}".format(item, f_json[item]) Title = title+flag[item] else: title = "{} = {}".format(item, f_json[item]) Title = title results.append({ "IcoPath": ICO_PATH, "Title": Title, "SubTitle": "Set up {} (Modified directly in the input box)".format(item), "JsonRPCAction": { "method": "selectConfig", "parameters": [title], "dontHideAfterAction": True, }, }) else: results.append({ "IcoPath": ICO_PATH, "Title": "_config", "SubTitle": PREFIX_CONFIG + ": Set up Gtranslate", "JsonRPCAction": { "method": "openConfig", "parameters": [], "dontHideAfterAction": True, }, }) return results
async def event_message(ctx): """Activates for every message""" debounce = 1 # interval between consecutive commands and messages author = ctx.author.name message = ctx.content if ";" in message: # prevent q3 command injections message = message[:message.index(";")] # bot.py, at the bottom of event_message if message.startswith("?"): # spectator client customization and controls message = message.strip('?').lower() split_msg = message.split(' ') cmd = split_msg[0] args = split_msg[1:] if len(split_msg) > 0 else None logging.info(f"TWITCH COMMAND RECEIVED: '{cmd}' from user '{author}'") for command in TWITCH_CMDS: if cmd in command: twitch_function = getattr(twitch_commands, command[0]) await twitch_function(ctx, author, args) time.sleep(debounce) elif message.startswith(">") or message.startswith("<"): # chat bridge message = message.lstrip('>').lstrip('<').lstrip(' ') blacklisted_words = config.get_list("blacklist_chat") for word in blacklisted_words: if word in message: logging.info(f"Blacklisted word '{word}' detected in message \"{message}\" by \"{author}\". Aborting message.") return if author.lower() == 'nightbot'.lower(): # ignore twitch Nightbot's name author = '' author_color_char = 0 else: author += ' ^7> ' author_color_char = author[0] api.exec_command(f"say ^{author_color_char}{author} ^2{message}") logging.info("Chat message sent") time.sleep(debounce) elif message.startswith("**"): # team chat bridge message = message.lstrip('**') blacklisted_words = config.get_list("blacklist_chat") for word in blacklisted_words: if word in message: logging.info(f"Blacklisted word '{word}' detected in message \"{message}\" by \"{author}\". Aborting message.") return if author.lower() == 'nightbot'.lower(): # ignore twitch Nightbot's name author = '' author_color_char = 0 else: author += ' ^7> ' author_color_char = author[0] api.exec_command(f"say_team ^{author_color_char}{author} ^5{message}") logging.info("Chat message sent") time.sleep(debounce) elif message.startswith("!"): # proxy mod commands (!top, !rank, etc.) logging.info("proxy command received") api.exec_command(message) time.sleep(debounce) elif message.startswith("$"): # viewer sound commands for sound_cmd in SOUND_CMDS: if message.startswith(sound_cmd): logging.info(f"Sound command recieved ({sound_cmd})") api.play_sound(sound_cmd.replace('$', '') + '.wav') #odfe appears to only support .wav format, not mp3, so we can hardcode it time.sleep(debounce) return
def get_last_key(data): datalist = get_list(data) lastkey = datalist[-1] return lastkey
Copyright (c) 2016-2018 Uwe Krien <*****@*****.**> SPDX-License-Identifier: GPL-3.0-or-later """ __copyright__ = "Uwe Krien <*****@*****.**>" __license__ = "GPLv3" import os import config as cfg print("Gefundene ini-Dateien:") for filename in cfg.get_ini_filenames(): print(filename) for n in range(4): v = cfg.get('values', 'value{0}'.format(n + 1)) print(v, type(v)) print(cfg.get_dict('parameter')) print(cfg.get_list('something', 'members')) print(cfg.get_list('something', 'members')[1]) print(cfg.get('something', 'members')) print(cfg.get('something', 'members')[1]) try: print(os.listdir(cfg.get('paths', 'basic'))) except FileNotFoundError: print("Please create an ini-file in your home directory and add the " "correct path.")