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)