def run_sync(settings):
try:
# Set the system where sync'd data will be stored.
# The Kamailio DB in our case
# If already running - don't run
if os.path.isfile("./.sync-lock"):
print("Already running")
return
else:
f = open("./.sync-lock", "w+")
f.close()
# need to decrypt password if encrypted
if isinstance(settings.KAM_DB_PASS, bytes):
kam_password = AES_CTR.decrypt(
settings.KAM_DB_PASS).decode('utf-8')
else:
kam_password = settings.KAM_DB_PASS
dest = {}
dest['hostname'] = settings.KAM_DB_HOST
dest['username'] = settings.KAM_DB_USER
dest['password'] = kam_password
dest['database'] = settings.KAM_DB_NAME
# Get the list of FusionPBX's that needs to be sync'd
sources = get_sources(dest)
# Loop thru each FusionPBX system and start the sync
for key in sources:
if sync_needed(sources[key], dest):
#drop_fusionpbx_domains(sources[key], dest)
sync_db(sources[key], dest)
else:
print("[run_sync] No sync needed for source: {}".format(
sources[key][1]))
# Reload Kamailio
reloadkam(settings.KAM_KAMCMD_PATH)
# Update Nginx configuration file for HTTP Provisioning and start docker container if we have FusionPBX systems
# update_nginx(sources[key])
if sources is not None and len(sources) > 0:
sources = list(sources.keys())
update_nginx(sources)
except Exception as e:
print(str(e))
finally:
# Remove lock file
os.remove("./.sync-lock")
def setSharedSettings(fields_dict={},
address=settings.DSIP_IPC_SOCK,
authkey=None):
if authkey is None:
authkey = AES_CTR.decrypt(settings.DSIP_IPC_PASS)
class SettingsManager(SyncManager):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
SettingsManager.register("getSettings")
manager = SettingsManager(address=address, authkey=authkey)
manager.connect()
settings_proxy = manager.getSettings()
settings_proxy.update(list(fields_dict.items()))
def getDBURI():
"""
Get any and all DB Connection URI's
Facilitates HA DB Server connections through multiple host's defined in settings
:return: list of DB URI connection strings
"""
uri_list = []
# check environment vars if in debug mode
if settings.DEBUG:
settings.KAM_DB_DRIVER = os.getenv('KAM_DB_DRIVER',
settings.KAM_DB_DRIVER)
settings.KAM_DB_HOST = os.getenv('KAM_DB_HOST', settings.KAM_DB_HOST)
settings.KAM_DB_TYPE = os.getenv('KAM_DB_TYPE', settings.KAM_DB_TYPE)
settings.KAM_DB_PORT = os.getenv('KAM_DB_PORT', settings.KAM_DB_PORT)
settings.KAM_DB_NAME = os.getenv('KAM_DB_NAME', settings.KAM_DB_NAME)
settings.KAM_DB_USER = os.getenv('KAM_DB_USER', settings.KAM_DB_USER)
settings.KAM_DB_PASS = os.getenv('KAM_DB_PASS', settings.KAM_DB_PASS)
# need to decrypt password
if isinstance(settings.KAM_DB_PASS, bytes):
kampass = AES_CTR.decrypt(settings.KAM_DB_PASS).decode('utf-8')
else:
kampass = settings.KAM_DB_PASS
if settings.KAM_DB_TYPE != "":
sql_uri = settings.KAM_DB_TYPE + "{driver}" + "://" + settings.KAM_DB_USER + ":" + kampass + "@" + "{host}" + "/" + settings.KAM_DB_NAME
driver = ""
if len(settings.KAM_DB_DRIVER) > 0:
driver = '+{}'.format(settings.KAM_DB_DRIVER)
if isinstance(settings.KAM_DB_HOST, list):
for host in settings.KAM_DB_HOST:
uri_list.append(sql_uri.format(host=host, driver=driver))
else:
uri_list.append(
sql_uri.format(host=settings.KAM_DB_HOST, driver=driver))
if settings.DEBUG:
IO.printdbg('getDBURI() returned: [{}]'.format(','.join(
'"{0}"'.format(uri) for uri in uri_list)))
return uri_list
def createSettingsManager(shared_settings,
address=settings.DSIP_IPC_SOCK,
authkey=None):
if authkey is None:
authkey = AES_CTR.decrypt(settings.DSIP_IPC_PASS)
class SettingsManager(SyncManager):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
SettingsManager.register("getSettings",
lambda: shared_settings,
exposed=[
'__contains__', '__delitem__', '__getitem__',
'__len__', '__setitem__', 'clear', 'copy',
'get', 'has_key', 'items', 'keys', 'pop',
'popitem', 'setdefault', 'update', 'values'
])
manager = SettingsManager(address=address, authkey=authkey)
return manager
def sendEmail(recipients,
text_body,
html_body=None,
subject=settings.MAIL_DEFAULT_SUBJECT,
sender=settings.MAIL_DEFAULT_SENDER,
data=None,
attachments=[]):
"""
Send an Email asynchronously to recipients
:param recipients: list
:param text_body: str
:param html_body: str
:param subject: str
:param sender: str
:param data: dict
:param attachments: list
:return: None
"""
try:
if data is not None:
text_body += "\r\n\n"
for key, value in data.items():
text_body += "{}: {}\n".format(key, value)
text_body += "\n"
# print("Creating email")
msg_root = MIMEMultipart('alternative')
msg_root['From'] = sender
msg_root['To'] = ", ".join(recipients)
msg_root['Subject'] = subject
msg_root.preamble = "|-------------------MULTIPART_BOUNDARY-------------------|\n"
# print("Adding text body to email")
msg_root.attach(MIMEText(text_body, 'plain'))
if html_body is not None and html_body != "":
# print("Adding html body to email")
msg_root.attach(MIMEText(html_body, 'html'))
if len(attachments) > 0:
# print("Adding attachments to email")
for file in attachments:
with open(file, 'rb') as fp:
msg_attachments = MIMEBase('application', "octet-stream")
msg_attachments.set_payload(fp.read())
encoders.encode_base64(msg_attachments)
msg_attachments.add_header('Content-Disposition',
'attachment',
filename=os.path.basename(file))
msg_root.attach(msg_attachments)
# check environ vars if in debug mode
if settings.DEBUG:
settings.MAIL_USERNAME = os.getenv('MAIL_USERNAME',
settings.MAIL_USERNAME)
settings.MAIL_PASSWORD = os.getenv('MAIL_PASSWORD',
settings.MAIL_PASSWORD)
# need to decrypt password
if isinstance(settings.MAIL_PASSWORD, bytes):
mailpass = AES_CTR.decrypt(settings.MAIL_PASSWORD).decode('utf-8')
else:
mailpass = settings.MAIL_PASSWORD
# print("sending email")
with smtplib.SMTP(settings.MAIL_SERVER, settings.MAIL_PORT) as server:
server.connect(settings.MAIL_SERVER, settings.MAIL_PORT)
server.ehlo()
if settings.MAIL_USE_TLS:
server.starttls()
server.ehlo()
server.login(settings.MAIL_USERNAME, mailpass)
msg_root_str = msg_root.as_string()
server.sendmail(sender, recipients, msg_root_str)
server.quit()
except Exception as ex:
debugException(ex)