def upload_code(ci_dir_path, source_path, des_path, service, cleanup): """ Upload code to remote machine Example: upload_code ws/ci ws/dist/tenant.tar.gz /tmp/tenant.tar.gz :param ci_dir_path: CI folder path where all CI scripts are located :param source_path: Path the source code :param des_path: Destination folder to save the code :param service: backupservice or middleware :param cleanup: Execute cleanup scripts or not (True or False) :return: Output with status True or False """ # Get master details from Yaml file yaml_file_path = os.path.join(ci_dir_path, 'config.yaml') server_ip = get_config(service, 'SERVER_IP') server_username = get_config(service, 'SERVER_USERNAME') server_pwd = get_config(service, 'SERVER_PASSWORD') # Connect to remote machine ssh_obj = SSHUtil(host=server_ip, username=server_username, password=server_pwd, timeout=10) # Add proxy command = """ export http_proxy="http://10.131.236.9:3128" export https_proxy="https://10.131.236.9:3128" && export PATH=$PATH:$https_proxy && export PATH=$PATH:$http_proxy && echo $http_proxy && echo $https_proxy """ result = ssh_obj.execute_command(command) return_value = '' for line in result['output'].readlines(): return_value = return_value + line print('############################') print("Proxy settings info") print(return_value) # Clearing the existing tar.gz files in remote machine command = """cd /home/tas/ && sudo rm -rf *.gz""" result = ssh_obj.execute_command(command) # Upload code to remote machine ssh_obj.upload_file(source_path, des_path) # Upload installation shell script into remote machine installation_scripts = get_config( service, 'INSTALLATION_SCRIPT', ) if cleanup == 'True': stop_service_list = get_config(service, 'STOP_SERVICES') # Stop the service for process in stop_service_list: command = "sudo systemctl stop {}".format(process) ssh_obj.execute_command(command) print('{} has been stopped'.format(process))
def send_bot_message(chat_id: str, message: str, disable_notification: bool = False) -> None: url = cf.get_config("TELEGRAM_BOT_URL", "") if not url or cf.get_config("DEBUG", False): Logger.debug(__name__, f"{chat_id} <-- {message}") else: _send_bot_message(url, chat_id, message, disable_notification)
def get_calendar_period( ctx: dataclasses.dataclass) -> ResultE[dataclasses.dataclass]: if ctx.base_date is None: ctx.base_date = timezone.localdate(timezone=pytz.timezone( ctx.house.timezone or cf.get_config('TIME_ZONE'))) ctx.start_date = ctx.base_date + relativedelta.relativedelta(days=-2) ctx.end_date = ctx.base_date + relativedelta.relativedelta(months=1, days=2) return Success(ctx)
def languages_menu(context) -> Dict[str, Any]: languages = [] for code, __ in cf.get_config("LANGUAGES", []): languages.append( (code, _(f"common:language:{code}"), f"corporate/flags/{code}.png") ) language_code = context["LANGUAGE_CODE"] return { "languages": languages, "language": _(f"common:language:{language_code}"), "language_flag": f"corporate/flags/{language_code}.png", }
def __find_class_name_by_method__(self, method_name): """ This method will Map factory method's to respective subclasses. Args: method_name(string): Name of the factory method. Return: string: Output will be Class name for the factory method. """ class_name = get_config('API', method_name, self.API_CONFIG_PATH) return class_name
def _load_from_file(lang: str) -> Dict[str, str]: project_root = cf.get_config("PROJECT_ROOT") filename = project_root.joinpath("_i18n", f"{lang}.json") if not filename.exists(): Logger.warning(__name__, f"Translation file [{filename}] not exists") return {} try: with open(filename, "r") as f: return json.load(f) except Exception as err: Logger.warning(__name__, f"Error load translation from {filename} : {err}") return {}
def __init__(self, login=None, password=None, host=None, api_version=None): if login is None: self.login = get_config(KEY_PLATFORMA, "username") else: self.login = login if password is None: self.password = get_config(KEY_PLATFORMA, "password") else: self.password = password if host is None: self.host = get_config(KEY_PLATFORMA, "host") else: self.host = host if api_version is None: self.api_version = get_config(KEY_PLATFORMA, "api_version") else: self.api_version = api_version self.request_header = {} self.XTM_TOKEN = None self.tenant_id = None
def __init__(self, platformburl=None, platformbresourceserverclientid=None, platformbresourceserversecret=None, platformbcorrugateclientcolonsecret=None, platformbcorrugateclient=None, platformbhypervisorid=None, platformbcorrugatesecret=None): """ :param platformburl: apiurl. :param platformbresourceserverclientid: resourceserverclientid. :param platformbresourceserversecret: resourceserversecret. :param platformbcorrugateclientcolonsecret: corrugateclientcolonsecret. :param platformbcorrugateclient: corrugateclient. :param platformbhypervisorid: hypervisorid. :param platformbcorrugatesecret: corrugatesecret. """ try: self.url_base = platformburl self.resource_server_clientid = platformbresourceserverclientid self.resource_server_secret = platformbresourceserversecret self.corrugate_client = platformbcorrugateclient self.corrugate_secret = platformbcorrugatesecret self.hypervisor_id = platformbhypervisorid if not platformburl: self.url_base = '{}'.format(get_config(KEY_PLATFORMB, "platformburl")) self.servicea_url = 'https://kratos.{}'.format(self.url_base) if not platformbresourceserverclientid: rsc = get_config(KEY_PLATFORMB, "platformbresourceserverclientid") self.resource_server_clientid = '{}'.format(rsc) if not platformbresourceserversecret: rss = get_config(KEY_PLATFORMB, "platformbresourceserversecret") self.resource_server_secret = '{}'.format(rss) # resource_server_colon_secret_b64 as rscs rscs = Utils.get_b64_colon_secret(self.resource_server_clientid, self.resource_server_secret) self.resource_server_colon_secret_b64 = rscs if not platformbcorrugateclient: self.corrugate_client = '{}'.format(get_config(KEY_PLATFORMB, "platformbcorrugateclient")) if not platformbcorrugatesecret: self.corrugate_secret = '{}'.format(get_config(KEY_PLATFORMB, "platformbcorrugatesecret")) # corrugate_colon_secret_b64 as ccs. ccs = Utils.get_b64_colon_secret(self.corrugate_client, self.corrugate_secret) self.corrugate_colon_secret_b64 = ccs if not platformbhypervisorid: self.hypervisor_id = '{}'.format(get_config(KEY_PLATFORMB, "platformbhypervisorid")) except KeyError as e: message = 'Required variable {} missing'.format(e) logger.critical(message) raise KeyError(message)
def configure() -> None: project_root = cf.get_config("PROJECT_ROOT") log_dir = project_root.joinpath("logs") # Reset all configuration logger.remove(None) # Global Console logger.add( sys.stdout, level="DEBUG", catch=True, backtrace=True, diagnose=False, format=Logger.console_format ) # ODOO API logger.add( log_dir.joinpath("odoo.log"), level="DEBUG", format=Logger.odoo_file_format, filter=lambda x: "odoo" in x["extra"].get("name", ""), catch=True, diagnose=False, rotation=datetime.timedelta(days=1), ) # OTA Channels API logger.add( log_dir.joinpath("channels.log"), level="DEBUG", format=Logger.channel_file_format, filter=lambda x: "channels" in x["extra"].get("name", ""), catch=True, diagnose=False, rotation=datetime.timedelta(days=1), ) # Errors & Warnings logger.add( log_dir.joinpath("errors.log"), level="WARNING", format=Logger.global_file_format, catch=True, diagnose=False, rotation=datetime.timedelta(days=1), )
def apply_routing(routing: Dict[str, Any] = None) -> Optional[str]: if routing is None or not routing: return None name = Logger.get_house_log_name(routing) if name == "": return None if Logger.configured_handlers is None: Logger.configured_handlers = [] if name not in Logger.configured_handlers: project_root = cf.get_config("PROJECT_ROOT") logger.add( project_root.joinpath("logs").joinpath(f"{name}.log"), level="DEBUG", format=Logger.channel_file_format, filter=lambda x: x["extra"].get("name", "") == name, catch=True, diagnose=False, rotation=datetime.timedelta(days=1), ) Logger.configured_handlers.append(name) return name
def translate(origin: str, lang: str = None, store: DefaultCacheProxy = None, params: dict = None) -> str: try: if store is None: store = cache if lang is None: lang = get_language() or cf.get_config("LANGUAGE_CODE") _store = _load_from_file(lang) text = _store.get(origin) # key = cache_key_for_i18n(lang, origin) # text = store.get(key) if text is not None and isinstance(text, bytes): text = text.decode("utf8") tmpl = Template(text or origin) return tmpl.safe_substitute(params or {}) except Exception as err: Logger.error(__name__, f'Error translate "{origin}": {err}') return origin
def notify_warning(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_WARNING", ""), message)
def main(): args = setup_args() try: si = SmartConnectNoSSL(host=args.host, user=args.user, pwd=args.password, port=args.port) atexit.register(Disconnect, si) except Exception as e: print("Unable to connect to %s" % args.host) return 1 if args.datacenter: dc = get_dc(si, args.datacenter) else: dc = si.content.rootFolder.childEntity[0] if args.resource_pool: rp = get_rp(si, dc, args.resource_pool) else: rp = get_largest_free_rp(si, dc) if args.datastore: ds = get_ds(dc, args.datastore) else: ds = get_largest_free_ds(dc) ovf_handle = OvfHandler(args.ova_path) ovfManager = si.content.ovfManager # CreateImportSpecParams can specify many useful things such as # diskProvisioning (thin/thick/sparse/etc) # networkMapping (to map to networks) # propertyMapping (descriptor specific properties) propertyMappingDict = get_config(args.service, 'properties', args.configpath) mapping = [] network_mappings = [] for k in propertyMappingDict: v = propertyMappingDict[k] mapping.append(vim.KeyValue(key=k, value=v)) # datacenter_list = si.content.rootFolder.childEntity # resourcepool_obj = get_obj_in_list('network_adapter_1', datacenter_list) network = find_network_by_name(si.content, 'VLAN_358') network_map = vim.OvfManager.NetworkMapping() network_map.name = 'VLAN_358' network_map.network = network network_mappings.append(network_map) cisp = vim.OvfManager.CreateImportSpecParams( networkMapping=network_mappings, propertyMapping=mapping, entityName=propertyMappingDict['Hostname'], diskProvisioning='thin') print(cisp) cisr = ovfManager.CreateImportSpec(ovf_handle.get_descriptor(), rp, ds, cisp) # These errors might be handleable by supporting the parameters in # CreateImportSpecParams if len(cisr.error): print("The following errors will prevent import of this OVA:") for error in cisr.error: print("%s" % error) return 1 ovf_handle.set_spec(cisr) lease = rp.ImportVApp(cisr.importSpec, dc.vmFolder) while lease.state == vim.HttpNfcLease.State.initializing: print("Waiting for lease to be ready...") time.sleep(1) if lease.state == vim.HttpNfcLease.State.error: print("Lease error: %s" % lease.error) return 1 if lease.state == vim.HttpNfcLease.State.done: return 0 print("Starting deploy...") return ovf_handle.upload_disks(lease, args.host)
def for_develop(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_DEV_USER", ""), message)
def notify_double_booking(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_DOUBLE_BOOKING", ""), message)
def notify_site_debug(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_LOGGING", ""), message)
def notify_info(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_INFO", ""), message)
def test_utils_yaml_positive(self): # Write YAML file functions.dict_to_yaml(self.data, self.configPath_postive) self.assertEqual(functions.get_config('another_dict', 'foo', self.configPath_postive), 'bar')
def notify_fatal(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_FATAL", ""), message)
def notify_payments(message: str) -> None: send_bot_message(cf.get_config("TELEGRAM_PAYMENTS", ""), message)