def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.config_manager = ConfigManager()
self.jabberd_template_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/ejabberd.yml')
self.jabberd_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/ejabberd.yml')
self.cmd_ejabberd_install = "sudo apt-get install -y ejabberd=19.09.1-0"
self.jabberd_des_path = "/tmp"
self.jabberd_conf_path = "/opt/ejabberd"
self.cmd_cp_conf = "sudo cp {0}/ejabberd.yml {1}/conf"
self.cmd_chown_ejabberd = "sudo chown -R ejabberd=ejabberd {0}/conf"
self.cmd_bin_ejabberd_path = "/opt/ejabberd-19.09.1"
self.cmd_register = "sudo {0}/bin/ejabberdctl register {1} {2} {3}"
self.cmd_jabberd_start = "sudo {0}/bin/ejabberdctl start"
self.cmd_jabberd_restart = "sudo {0}/bin/ejabberdctl restart"
self.cmd_jabberd_status = "sudo {0}/bin/ejabberdctl status"
self.cmd_srg_create = "sudo {0}/bin/ejabberdctl srg-create everyone {1} /'everyone/' this_is_everyone everyone"
self.cmd_srg_user_add = "sudo {0}/bin/ejabberdctl srg-user-add @all@ {1} everyone {1}"
self.cmd_hold_ejabberd = "sudo apt-mark hold ejabberd"
self.cmd_copy_ejabberd_service = "sudo cp {0}/bin/ejabberd.service /etc/systemd/system/"
self.cmd_system_reload = "sudo systemctl daemon-reload"
self.cmd_enable_ejabberd_service = "sudo systemctl enable ejabberd.service"
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.config_manager = ConfigManager()
self.jabberd_template_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/ejabberd_temp.yml')
self.jabberd_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/ejabberd.yml')
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.util = Util()
self.config_manager = ConfigManager()
self.lider_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.cfg')
self.db_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.datasource.cfg')
self.lider_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.cfg')
self.db_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.datasource.cfg')
def __init__(self):
super(InstallManager, self).__init__()
self.util = Util()
self.ssh_status = ""
self.logger = Logger()
self.config_maneger = ConfigManager()
self.liderahenk_data_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'dist/liderahenk.json')
self.liderldap_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../dist/lider_ldap.json')
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.util = Util()
self.config_manager = ConfigManager()
self.lider_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.cfg')
self.db_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.datasource.cfg')
self.lider_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.cfg')
self.db_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.datasource.cfg')
self.tomcat_service_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tomcat.service')
self.application_properties_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/lider.properties')
self.application_properties_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/lider.properties')
self.lider_web_url = "http://liderahenk.org/downloads/ROOT.war"
self.tomcat_tar_url = "http://liderahenk.org/downloads/apache-tomcat-9.0.36.tar.gz"
self.dist_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), '../../dist')
self.liderv2_app_properties_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/liderv2/src/main/resources/lider.properties')
self.lider_war_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), '../../conf/ROOT.war')
self.tomcat_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/apache-tomcat-9.0.36.tar.gz')
def install(self, data):
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
config_manager = ConfigManager()
cfg_data = config_manager.read()
# print(cfg_data)
if self.ssh_status == "Successfully Authenticated":
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_ahenk_install"])
if result_code == 0:
self.logger.info("Ahenk paketi kuruldu")
else:
self.logger.error("Ahenk paketi kurulamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_ahenk_dep"])
if result_code == 0:
self.logger.info("Ahenk bağımlılıkları kuruldu")
self.logger.info("Ahenk kurulumu tamamlandı")
else:
self.logger.error(
"Ahenk bağımlılıkları kurulamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_ahenk_register"].format(data["host"],
data["ldap_user"],
data["ldap_user_pwd"]))
if result_code == 0:
self.logger.info("Ahenk etki alanına başarıyla alındı")
else:
self.logger.error(
"Ahenk etki alanına alınamadı, result_code: " +
str(result_code))
else:
self.logger.error(
"Ahenk kurulacak istemciye bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
def install(self, data):
config_manager = ConfigManager()
cfg_data = config_manager.read()
base_dn = self.base_dn_parse(data)
l_admin_cn = "cn=" + str(data['l_admin_cn'])
ldap_data = {
"#BASEDN": base_dn[0],
"#CNAME": data["l_base_dn"],
"#BASECN": base_dn[1],
"#ORGANIZATION": data["l_org_name"],
"#ADMINCN": l_admin_cn,
"#ADMINPASSWD": data["l_admin_pwd"],
"#CNCONFIGADMINDN": data['l_config_admin_dn'],
"#CNCONFIGADMINPASSWD": data["l_config_pwd"],
"#LIDERCONSOLEUSER": data["ladmin_user"],
"#LIDERCONSOLEPWD": data["ladmin_pwd"],
"#LIDER_SERVER_ADDR": data["lider_server_addr"],
"#SIMPLE_LDAP_USER": data["simple_ldap_user"],
"#SIMPLE_LDAP_USER_PWD": data["simple_ldap_user_pwd"]
}
# copy liderahenk.ldif file to ldap server
self.ssh_api.scp_file(self.liderahenk_ldif_path, '/tmp')
self.logger.info(
"liderahenk.ldif dosyası OpenLDAP sunucusuna koplayandı")
if data["ldap_status"] == "new":
#edit ldap_install_temp script
self.f1 = open(self.ldap_config_path, 'r+')
my_text = self.f1.read()
txt = config_manager.replace_all(my_text, ldap_data)
self.f2 = open(self.ldap_config_out_path, 'w+')
self.f2.write(txt)
self.f1.close()
self.f2.close()
if self.ssh_status == "Successfully Authenticated" or data[
'location'] == 'local':
#copy ldap_install script to ldap server
self.ssh_api.scp_file(self.ldap_config_out_path, '/tmp')
self.logger.info(
"ldapconfig betiği OpenLDAP sunucusuna kopyalandı")
self.ssh_api.scp_file(self.sudo_ldif_path, '/tmp')
### install slapd package
self.ssh_api.run_command(cfg_data["cmd_ldap_remove"])
self.ssh_api.run_command(cfg_data["ldap_deb_frontend"])
self.ssh_api.run_command(
cfg_data["ldap_debconf_generated_password"].format(
data["l_admin_pwd"]))
self.ssh_api.run_command(
cfg_data["ldap_debconf_admin_password"].format(
data["l_admin_pwd"]))
self.ssh_api.run_command(cfg_data["ldap_debconf_conf"])
self.ssh_api.run_command(
cfg_data["ldap_debconf_domain"].format(data["l_base_dn"]))
self.ssh_api.run_command(
cfg_data["ldap_debconf_organization"].format(
data["l_org_name"]))
self.ssh_api.run_command(cfg_data["ldap_debconf_pwd1"].format(
data["l_admin_pwd"]))
self.ssh_api.run_command(cfg_data["ldap_debconf_pwd2"].format(
data["l_admin_pwd"]))
self.ssh_api.run_command(cfg_data["ldap_debconf_selectdb"])
self.ssh_api.run_command(cfg_data["ldap_debconf_purgedb"])
self.ssh_api.run_command(cfg_data["ldap_debconf_movedb"])
self.logger.info("LDAP bilgileri alındı")
result_code = self.ssh_api.run_command(
cfg_data["cmd_ldap_install"])
if result_code == 0:
self.logger.info("slapd ve ldap-utils paketleri kuruldu")
else:
self.logger.error(
"slapd ve ldap-utils paketleri kurulamadı, result_code: "
+ str(result_code))
self.ssh_api.run_command(cfg_data["cmd_ldap_reconf"])
self.logger.info("slapd paketi reconfigure edildi")
self.ssh_api.run_command(cfg_data["cmd_ldapconfig_execute"])
result_code = self.ssh_api.run_command(
cfg_data["cmd_ldapconfig_run"])
if result_code == 0:
self.logger.info(
"ldap config betiği çalıştırıldı ve lider ahenk konfigürasyonları tamamlandı"
)
else:
self.logger.error(
"ldap config betiği çalıştırılırken hata oluştu ve lider ahenk konfigürasyonları tamamlanamadı"
)
self.logger.info("OpenLDAP kurulumu tamamlandı")
else:
self.logger.error(
"OpenLDAP sunucusuna bağlantı sağlanamadı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
# # print("bağlantı sağlanamadığı için kurulum yapılamadı..")
else:
self.f1 = open(self.update_ldap_path, 'r+')
my_text = self.f1.read()
txt = config_manager.replace_all(my_text, ldap_data)
self.f2 = open(self.update_ldap_out_path, 'w+')
self.f2.write(txt)
self.f1.close()
self.f2.close()
# copy ldap_config script to ldap server
self.ssh_api.scp_file(self.update_ldap_out_path, '/tmp')
self.logger.info(
"update_ldap betiği OpenLDAP sunucusuna koplayandı")
self.ssh_api.run_command(cfg_data["cmd_update_ldap_execute"])
self.ssh_api.run_command(cfg_data["cmd_update_ldap_run"])
self.logger.info(
"Varolan OpenLDAP Lider Ahenk uygulamasına göre ayarlandı")
class LiderInstaller(object):
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.util = Util()
self.config_manager = ConfigManager()
self.lider_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.cfg')
self.db_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.datasource.cfg')
self.lider_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.cfg')
self.db_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.datasource.cfg')
def install(self, data):
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
if self.ssh_status == "Successfully Authenticated" or data[
'location'] == 'local':
cfg_data = self.config_manager.read()
self.configure_lider_cfg(data)
self.configure_db_cfg(data)
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_lider_install"])
if result_code == 0:
self.logger.info("lider-server paketi kurulumu yapıldı")
else:
self.logger.error(
"lider-server paketi kurulamadı, result_code: " +
str(result_code))
self.ssh_api.scp_file(self.lider_conf_out_path,
cfg_data["lider_des_path"])
self.ssh_api.scp_file(self.db_conf_out_path,
cfg_data["lider_des_path"])
self.ssh_api.run_command(cfg_data["cmd_cp_lider_cfg"])
self.logger.info(
"lider konfigürasyon dosyası LİDER sunucusuna kopyalandı")
self.ssh_api.run_command(cfg_data["cmd_cp_db_cfg"])
self.logger.info(
"veritabanı konfigürasyon dosyası LİDER sunucusuna kopyalandı")
result_code = self.ssh_api.run_command(
cfg_data["cmd_lider_service"])
if result_code == 0:
self.logger.info("lider servisi başlatıldı")
else:
self.logger.error(
"lider servisi başlatılamadı, resuşt_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_fs_dep"])
if result_code == 0:
self.logger.info(
"sshpass ve rsync paketleri başarıyla kuruldu")
else:
self.logger.error("sshpass ve rsync paketleri kurulamadı")
agent_files_path = data['fs_agent_file_path'] + '/agent-files'
if data['location'] == 'remote':
self.ssh_api.run_command(
cfg_data["cmd_agents_files"].format(agent_files_path))
self.logger.info("agent-files dizini oluşturuldu")
self.ssh_api.run_command(
cfg_data["cmd_chown_agents_files"].format(
data["username"], agent_files_path))
self.logger.info("agent-files dizini için owner değiştirildi")
else:
if not self.util.is_exist(agent_files_path):
self.util.create_directory_local(agent_files_path)
self.logger.info("agent-files dizini oluşturuldu")
self.util.change_owner(agent_files_path, data['username'],
data['username'])
self.logger.info(
"agent-files dizini için owner değiştirildi")
else:
self.logger.info(
"{0} dizini zaten var".format(agent_files_path))
result_code = self.ssh_api.run_command(
cfg_data["cmd_enable_lider_service"])
self.logger.info("Lider servis olarak ayarlandı.")
else:
self.logger.error(
"LİDER sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
def configure_lider_cfg(self, data):
l_base_dn = self.base_dn_parse(data)
l_admin_dn = "cn=admin," + str(l_base_dn)
lider_data = {
"#LDAP_SERVER": data['ldap_servers'],
"#LDAP_ADMIN_DN": l_admin_dn,
"#LDAP_ADMIN_PWD": data['l_admin_pwd'],
"#LDAP_ROOT_DN": l_base_dn,
"#XMPP_SERVER": data['e_hosts'],
"#LIDER_USERNAME": data['lider_username'],
"#XMPP_USER_PWD": data['lider_user_pwd'],
"#XMPP_SERVICE_NAME": data['e_service_name'],
"#LDAP_BASE_DN": l_base_dn,
"#FILE_SERVER": data['file_server'],
"#FS_USERNAME": data['fs_username'],
"#FS_PASSWORD": data['fs_username_pwd'],
"#PLUGIN_PATH": data['fs_plugin_path'],
"#AGREEMENT_PATH": data['fs_agreement_path'],
"#AGENT_FILE_PATH": data['fs_agent_file_path']
}
self.f_lider = open(self.lider_conf_path, 'r+')
lider_text = self.f_lider.read()
txt = self.config_manager.replace_all(lider_text, lider_data)
self.f_lider_out = open(self.lider_conf_out_path, 'w+')
self.f_lider_out.write(str(txt))
self.f_lider.close()
self.f_lider_out.close()
self.logger.info("tr.org.liderahenk.cfg dosyası oluşturuldu")
def configure_db_cfg(self, data):
db_data = {
"#DBADDRESS": data['db_server'],
"#DBDATABASE": data['db_name'],
"#DBUSERNAME": data['db_username'],
"#DBPASSWORD": data['db_password']
}
self.f_db = open(self.db_conf_path, 'r+')
db_text = self.f_db.read()
txt = self.config_manager.replace_all(db_text, db_data)
self.f_db_out = open(self.db_conf_out_path, 'w+')
self.f_db_out.write(txt)
self.f_db.close()
self.f_db_out.close()
self.logger.info("tr.org.datasource.cfg dosyası oluşturuldu")
def base_dn_parse(self, data):
### split for get data['base_dn']: liderahenk.org #BASECN and #BASEDN
parse_dn = data["l_base_dn"].split('.')
dn_list = []
for dn in parse_dn:
message = 'dc=' + str(dn) + ','
dn_list.append(message)
base_dn = ''.join(str(x) for x in dn_list)
base_dn = base_dn.strip(',')
return base_dn
def install(self, data):
config_manager = ConfigManager()
cfg_data = config_manager.read()
# print(cfg_data)
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
if self.ssh_status == "Successfully Authenticated" or data['location'] == 'local':
result_code = self.ssh_api.run_command(cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error("software-properties-common paketi kurulamadı, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_liderahenk_repo_key"].format(data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error("Lider Ahenk repo key dosyası indirilemedi, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error("Lider Ahenk repo adresi eklenemedi, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error("Paket listesi güncellenemdi, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_deb_frontend"])
result_code = self.ssh_api.run_command(cfg_data["db_debconf_pwd"].format(data["db_password"]))
result_code = self.ssh_api.run_command(cfg_data["db_debconf_pwd_again"].format(data["db_password"]))
result_code = self.ssh_api.run_command(cfg_data["cmd_db_install"])
if result_code == 0:
self.logger.info("Mariadb paketi kuruldu")
else:
self.logger.error("Mariadb paketi kurulamadı, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_db_dep"])
if result_code == 0:
self.logger.info("Veritabanı bağımlılıkları kuruldu")
else:
self.logger.error("Veritabanı bağımlılıkları kurulamadı, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_create_db"].format(data["db_password"], data["db_name"]))
if result_code == 0:
self.logger.info("liderdb veritabanı oluşturuldu")
else:
self.logger.error("liderdb veritabanı oluşturulamadı, result_code: "+str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_db_grant_privileges"].format(data["db_password"], data["db_password"]))
if result_code == 0:
self.logger.info("Veritabanı grant yetkisi verildi")
else:
self.logger.error("Veritabanı grant yetkisi verilemedi, result_code: "+str(result_code))
# self.ssh_api.run_command(cfg_data["cmd_db_replace_bind_addr"])
result_code = self.ssh_api.run_command(cfg_data["cmd_db_service"])
if result_code == 0:
self.logger.info("Veritabanı servisi başlatıldı.")
else:
self.logger.error("Veritabanı servisi başlatılamadı, result_code: "+str(result_code))
else:
self.logger.error("Veritabanı sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!")
def install(self, data):
self.data = data
config_manager = ConfigManager()
cfg_data = config_manager.read()
if self.ssh_status == "Successfully Authenticated":
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
# result_code = self.ssh_api.run_command(self.cmd_deb_frontend)
# result_code = self.ssh_api.run_command(self.db_debconf_pwd.format(data["db_password"]))
# result_code = self.ssh_api.run_command(self.db_debconf_pwd_again.format(data["db_password"]))
result_code = self.ssh_api.run_command(self.cmd_db_install)
if result_code == 0:
self.logger.info("Mariadb paketi kuruldu")
else:
self.logger.error("Mariadb paketi kurulamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(self.cmd_db_dep)
if result_code == 0:
self.logger.info("Veritabanı bağımlılıkları kuruldu")
else:
self.logger.error(
"Veritabanı bağımlılıkları kurulamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_db_set_password.format(data['db_password']))
if result_code == 0:
self.logger.info("Veritabanı parolası tanımlandı.")
else:
self.logger.error(
"Veritabanı parolası tanımlanırken hata oluştu. Result Code: {0}"
.format(result_code))
result_code = self.ssh_api.run_command(self.cmd_db_service)
if result_code == 0:
self.logger.info("Veritabanı servisi başlatıldı.")
else:
self.logger.error(
"Veritabanı servisi başlatılamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_db_replace_bind_addr)
result_code = self.ssh_api.run_command(self.cmd_db_service)
if result_code == 0:
self.logger.info("Veritabanı servisi başlatıldı.")
else:
self.logger.error(
"Veritabanı servisi başlatılamadı, result_code: " +
str(result_code))
self.logger.info("---------->>>> " + str(
self.cmd_db_grant_privileges.format(data["db_password"],
data["db_password"])))
result_code = self.ssh_api.run_command(
self.cmd_db_grant_privileges.format(data["db_password"],
data["db_password"]))
if result_code == 0:
self.logger.info("Veritabanı grant yetkisi verildi")
else:
self.logger.error(
"Veritabanı grant yetkisi verilemedi, result_code: " +
str(result_code))
self.connect_db()
self.create_liderdb()
self.create_config_table()
self.insert_to_config()
else:
self.logger.error(
"Veritabanı sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
self.liderdb.close()
def install(self, data):
config_manager = ConfigManager()
# configuration ejabberd.yml
base_dn = self.base_dn_parse(data)
ldap_root_dn = "cn=admin," + str(
base_dn) #cn=admnin,dc=liderahenk,dc=org
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
cfg_data = config_manager.read()
conf_data = {
"#HOST": data['e_hosts'],
"#LDAP_SERVER": data['ldap_servers'],
"#LDAP_ROOT_DN": ldap_root_dn,
"#LDAP_ROOT_PWD": data['l_admin_pwd'],
"#LDAP_BASE_DN": base_dn,
"#SERVICE_NAME": data['e_service_name']
}
self.f_ejabberd_yml = open(self.jabberd_template_path, 'r+')
jabber_data = self.f_ejabberd_yml.read()
self.logger.info("Ejabberd sunucu kurulumu için veriler okundu")
txt = self.config_manager.replace_all(jabber_data, conf_data)
self.f_ejabberd_yml_out = open(self.jabberd_out_path, 'w+')
self.f_ejabberd_yml_out.write(txt)
self.f_ejabberd_yml.close()
self.f_ejabberd_yml_out.close()
self.logger.info("ejabberd.yml dosyası oluşturuldu")
#run commands of ejabberd
if self.ssh_status == "Successfully Authenticated" or data[
'location'] == 'local':
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_ejabberd_install"])
if result_code == 0:
self.logger.info("Ejabberd paketi kuruldu")
else:
self.logger.error("Ejabberd paketi kurulamadı, result_code: " +
str(result_code))
self.ssh_api.scp_file(self.jabberd_out_path,
cfg_data["jabberd_des_path"])
if result_code == 0:
self.logger.info(
"Ejabberd konfigürasyon dosyası sunucuya kopyalandı")
else:
self.logger.error(
"Ejabberd konfigürasyon dosyası sunucuya kopyalandı")
self.ssh_api.run_command(cfg_data["cmd_cp_conf"].format(
cfg_data["jabberd_des_path"], cfg_data["jabberd_conf_path"]))
result_code = self.ssh_api.run_command(
cfg_data["cmd_jabberd_start"].format(
cfg_data["cmd_bin_ejabberd_path"]))
if result_code == 0:
self.logger.info("Ejabberd servisi başlatıldı")
else:
self.logger.error(
"Ejabberd servisi başlatılamadı, result_code: " +
str(result_code))
print("---------->>>> Start : %s" % time.ctime())
time.sleep(10)
print("-------->>>>> End : %s" % time.ctime())
result_code = self.ssh_api.run_command(
cfg_data["cmd_register"].format(
cfg_data["cmd_bin_ejabberd_path"], data["e_username"],
data["e_service_name"], data["e_user_pwd"]))
if result_code == 0:
self.logger.info("{0} kullanıcısı kaydedildi".format(
data["e_username"]))
else:
self.logger.error(
"{0} kullanıcısı kaydedilemedi, result_code: ".format(
data["e_username"]) + str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_register"].format(
cfg_data["cmd_bin_ejabberd_path"], data["lider_username"],
data["e_service_name"], data["lider_user_pwd"]))
if result_code == 0:
self.logger.info("{0} kullanıcısı kaydedildi".format(
data["lider_username"]))
else:
self.logger.error(
"{0} kullanıcısı kaydedilemedi, result_code: ".format(
data["lider_username"]) + str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_srg_create"].format(
cfg_data["cmd_bin_ejabberd_path"], data["e_service_name"]))
if result_code == 0:
self.logger.info("shared roster grubu oluşturuldu.")
else:
self.logger.error(
"shared roster grubu oluşturulamadı, resuşt_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_srg_user_add"].format(
cfg_data["cmd_bin_ejabberd_path"], data["e_service_name"]))
if result_code == 0:
self.logger.info("Kullanıcılar shared roster grubuna eklendi")
else:
self.logger.error(
"Kullanıcılar shared roster grubuna eklenemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_jabberd_restart"].format(
cfg_data["cmd_bin_ejabberd_path"]))
if result_code == 0:
self.logger.info("Ejabberd servisi başlatıldı")
else:
self.logger.error(
"Ejabberd servisi başlatılamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_jabberd_status"].format(
cfg_data["cmd_bin_ejabberd_path"]))
if result_code == 0:
self.logger.info("Ejabberd servisi çalışıyor")
else:
self.logger.error("Ejabberd servisi çalışmıyor")
self.ssh_api.run_command(cfg_data["cmd_hold_ejabberd"])
self.ssh_api.run_command(
cfg_data["cmd_copy_ejabberd_service"].format(
cfg_data["cmd_bin_ejabberd_path"]))
self.logger.info(
"ejabberd.service dosyası /etc/systemd/system/ dizinine kopyalandı"
)
result_code = self.ssh_api.run_command(
cfg_data["cmd_system_reload"])
result_code = self.ssh_api.run_command(
cfg_data["cmd_enable_ejabberd_service"])
if result_code == 0:
self.logger.info("Ejabberd servis olarak ayarlandı.")
else:
self.logger.error("Ejabberd servis olarak ayarlanamadı.")
else:
# print("bağlantı sağlanamadığı için kurulum yapılamadı..")
self.logger.error(
"XMPP sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
class EjabberInstaller(object):
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.config_manager = ConfigManager()
self.jabberd_template_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/ejabberd_temp.yml')
self.jabberd_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/ejabberd.yml')
def install(self, data):
config_manager = ConfigManager()
# configuration ejabberd.yml
base_dn = self.base_dn_parse(data)
ldap_root_dn = "cn=admin," + str(
base_dn) #cn=admnin,dc=liderahenk,dc=org
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
cfg_data = config_manager.read()
conf_data = {
"#HOST": data['e_hosts'],
"#LDAP_SERVER": data['ldap_servers'],
"#LDAP_ROOT_DN": ldap_root_dn,
"#LDAP_ROOT_PWD": data['l_admin_pwd'],
"#LDAP_BASE_DN": base_dn,
"#SERVICE_NAME": data['e_service_name']
}
self.f_ejabberd_yml = open(self.jabberd_template_path, 'r+')
jabber_data = self.f_ejabberd_yml.read()
self.logger.info("Ejabberd sunucu kurulumu için veriler okundu")
txt = self.config_manager.replace_all(jabber_data, conf_data)
self.f_ejabberd_yml_out = open(self.jabberd_out_path, 'w+')
self.f_ejabberd_yml_out.write(txt)
self.f_ejabberd_yml.close()
self.f_ejabberd_yml_out.close()
self.logger.info("ejabberd.yml dosyası oluşturuldu")
#run commands of ejabberd
if self.ssh_status == "Successfully Authenticated" or data[
'location'] == 'local':
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_ejabberd_install"])
if result_code == 0:
self.logger.info("Ejabberd paketi kuruldu")
else:
self.logger.error("Ejabberd paketi kurulamadı, result_code: " +
str(result_code))
self.ssh_api.scp_file(self.jabberd_out_path,
cfg_data["jabberd_des_path"])
if result_code == 0:
self.logger.info(
"Ejabberd konfigürasyon dosyası sunucuya kopyalandı")
else:
self.logger.error(
"Ejabberd konfigürasyon dosyası sunucuya kopyalandı")
self.ssh_api.run_command(cfg_data["cmd_cp_conf"].format(
cfg_data["jabberd_des_path"], cfg_data["jabberd_conf_path"]))
result_code = self.ssh_api.run_command(
cfg_data["cmd_jabberd_start"].format(
cfg_data["cmd_bin_ejabberd_path"]))
if result_code == 0:
self.logger.info("Ejabberd servisi başlatıldı")
else:
self.logger.error(
"Ejabberd servisi başlatılamadı, result_code: " +
str(result_code))
print("---------->>>> Start : %s" % time.ctime())
time.sleep(10)
print("-------->>>>> End : %s" % time.ctime())
result_code = self.ssh_api.run_command(
cfg_data["cmd_register"].format(
cfg_data["cmd_bin_ejabberd_path"], data["e_username"],
data["e_service_name"], data["e_user_pwd"]))
if result_code == 0:
self.logger.info("{0} kullanıcısı kaydedildi".format(
data["e_username"]))
else:
self.logger.error(
"{0} kullanıcısı kaydedilemedi, result_code: ".format(
data["e_username"]) + str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_register"].format(
cfg_data["cmd_bin_ejabberd_path"], data["lider_username"],
data["e_service_name"], data["lider_user_pwd"]))
if result_code == 0:
self.logger.info("{0} kullanıcısı kaydedildi".format(
data["lider_username"]))
else:
self.logger.error(
"{0} kullanıcısı kaydedilemedi, result_code: ".format(
data["lider_username"]) + str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_srg_create"].format(
cfg_data["cmd_bin_ejabberd_path"], data["e_service_name"]))
if result_code == 0:
self.logger.info("shared roster grubu oluşturuldu.")
else:
self.logger.error(
"shared roster grubu oluşturulamadı, resuşt_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_srg_user_add"].format(
cfg_data["cmd_bin_ejabberd_path"], data["e_service_name"]))
if result_code == 0:
self.logger.info("Kullanıcılar shared roster grubuna eklendi")
else:
self.logger.error(
"Kullanıcılar shared roster grubuna eklenemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_jabberd_restart"].format(
cfg_data["cmd_bin_ejabberd_path"]))
if result_code == 0:
self.logger.info("Ejabberd servisi başlatıldı")
else:
self.logger.error(
"Ejabberd servisi başlatılamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_jabberd_status"].format(
cfg_data["cmd_bin_ejabberd_path"]))
if result_code == 0:
self.logger.info("Ejabberd servisi çalışıyor")
else:
self.logger.error("Ejabberd servisi çalışmıyor")
self.ssh_api.run_command(cfg_data["cmd_hold_ejabberd"])
else:
# print("bağlantı sağlanamadığı için kurulum yapılamadı..")
self.logger.error(
"XMPP sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
def base_dn_parse(self, data):
### split for get data['base_dn']: liderahenk.org #BASECN and #BASEDN
parse_dn = data["l_base_dn"].split('.')
dn_list = []
for dn in parse_dn:
message = 'dc=' + str(dn) + ','
dn_list.append(message)
base_dn = ''.join(str(x) for x in dn_list)
base_dn = base_dn.strip(',')
return base_dn
class LiderConsoleInstaller(object):
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.util = Util()
self.config_manager = ConfigManager()
self.lider_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.cfg')
self.db_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.datasource.cfg')
self.lider_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.cfg')
self.db_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.datasource.cfg')
def install(self, data):
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
if self.ssh_status == "Successfully Authenticated" or data[
'location'] == 'local':
cfg_data = self.config_manager.read()
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_lider_console_install"])
if result_code == 0:
self.logger.info("Lider Console paketi kurulumu yapıldı")
else:
self.logger.error(
"Lider Console paketi kurulamadı, result_code: " +
str(result_code))
else:
self.logger.error(
"Lider Arayüz makinesine bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kontrol ediniz!"
)
class LiderInstaller(object):
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.util = Util()
self.config_manager = ConfigManager()
self.lider_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.cfg')
self.db_conf_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tr.org.liderahenk.datasource.cfg')
self.lider_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.cfg')
self.db_conf_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/tr.org.liderahenk.datasource.cfg')
self.tomcat_service_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/tomcat.service')
self.application_properties_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/lider.properties')
self.application_properties_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/lider.properties')
self.lider_web_url = "http://liderahenk.org/downloads/ROOT.war"
self.tomcat_tar_url = "http://liderahenk.org/downloads/apache-tomcat-9.0.36.tar.gz"
self.dist_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), '../../dist')
self.liderv2_app_properties_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/liderv2/src/main/resources/lider.properties')
self.lider_war_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), '../../conf/ROOT.war')
self.tomcat_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/apache-tomcat-9.0.36.tar.gz')
def install(self, data):
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
if self.ssh_status == "Successfully Authenticated":
cfg_data = self.config_manager.read()
self.configure_lider_cfg(data)
self.configure_db_cfg(data)
self.configure_app_properties(data)
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
"sudo apt-get install openjdk-8-jdk-headless -y")
if result_code == 0:
self.logger.info("openjdk-8 paketi başarıyla kuruldu")
else:
self.logger.error("openjdk-8 paketi kurulamadı")
result_code = self.ssh_api.run_command("sudo groupadd tomcat")
if result_code == 0:
self.logger.info("tomcat grubu oluşturuldu")
result_code = self.ssh_api.run_command(
"sudo useradd -s /bin/false -g tomcat -d /opt/tomcat tomcat")
if result_code == 0:
self.logger.info(
"tomcat kullanıcısı oluşturuldu ve ev dizini ayarlandı.")
# result_code = self.ssh_api.run_command("wget {0}".format(self.tomcat_tar_url))
# if result_code == 0:
# self.logger.info("tomcat başarıyla indirildi.")
# else:
# self.logger.error("tomcat indirilirken hata oluştu")
self.ssh_api.scp_file(self.tomcat_path, '/tmp')
result_code = self.ssh_api.run_command("sudo mkdir /opt/tomcat")
self.logger.info("tomcat dizini oluşturuldu")
result_code = self.ssh_api.run_command(
"sudo tar xf /tmp/apache-tomcat-*tar.gz -C /opt/tomcat --strip-components=1"
)
result_code = self.ssh_api.run_command(
"sudo chgrp -R tomcat /opt/tomcat")
result_code = self.ssh_api.run_command(
"sudo chmod -R g+r /opt/tomcat/conf")
result_code = self.ssh_api.run_command(
"sudo chmod g+x /opt/tomcat/conf")
result_code = self.ssh_api.run_command(
"sudo chown -R tomcat /opt/tomcat/webapps/ /opt/tomcat/work/ /opt/tomcat/temp/ /opt/tomcat/logs/"
)
self.ssh_api.scp_file(self.tomcat_service_path, '/tmp/')
result_code = self.ssh_api.run_command(
"sudo cp /tmp/tomcat.service /etc/systemd/system/")
result_code = self.ssh_api.run_command(
"sudo systemctl daemon-reload")
result_code = self.ssh_api.run_command(
"sudo systemctl enable tomcat")
result_code = self.ssh_api.run_command(
"sudo systemctl start tomcat")
self.logger.info("tomcat konfigürastonu tamamlandı")
self.ssh_api.scp_file(self.application_properties_out_path, '/tmp')
result_code = self.ssh_api.run_command("sudo mkdir -p /etc/lider")
result_code = self.ssh_api.run_command(
"sudo cp /tmp/lider.properties /etc/lider/")
# result_code = self.ssh_api.run_command("wget {0}".format(self.lider_web_url))
# if result_code == 0:
# self.logger.info("ROOT.war başarıyla indirildi.")
# else:
# self.logger.error("ROOT.war indirilirken hata oluştu")
self.ssh_api.scp_file(self.lider_war_path, '/tmp')
result_code = self.ssh_api.run_command(
"sudo cp /tmp/ROOT.war /opt/tomcat/webapps/")
result_code = self.ssh_api.run_command(
"sudo chown tomcat:tomcat /opt/tomcat/webapps/ROOT.war")
# result_code = self.ssh_api.run_command("sudo systemctl restart tomcat.service")
result_code = self.ssh_api.run_command(
"sudo apt-get install guacd -y")
if result_code == 0:
self.logger.info("Uzak masaüstü sunucusu yapılandırıldı")
else:
self.logger.error(
"Uzak masaüstü sunucusu yapılandırılırken hata oluştu. guacd uygulaması kurulamadı"
)
# filer server configuration
self.ssh_api.run_command("mkdir -p {0}/agent-files".format(
data["fs_agent_file_path"]))
self.ssh_api.run_command(
"sudo chown {0}:{0} {1}/agent-files".format(
data['fs_username'], data['fs_agent_file_path']))
self.ssh_api.run_command("sudo apt-get install -y sshpass rsync")
self.logger.info("lider kurulumu tamamlandı")
else:
self.logger.error(
"LİDER sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
def configure_lider_cfg(self, data):
l_base_dn = self.base_dn_parse(data)
l_admin_dn = "cn=admin," + str(l_base_dn)
lider_data = {
"#LDAP_SERVER": data['ldap_servers'],
"#LDAP_ADMIN_DN": l_admin_dn,
"#LDAP_ADMIN_PWD": data['l_admin_pwd'],
"#LDAP_ROOT_DN": l_base_dn,
"#XMPP_SERVER": data['e_hosts'],
"#LIDER_USERNAME": data['lider_username'],
"#XMPP_USER_PWD": data['lider_user_pwd'],
"#XMPP_SERVICE_NAME": data['e_service_name'],
"#LDAP_BASE_DN": l_base_dn,
"#FILE_SERVER": data['file_server'],
"#FS_USERNAME": data['fs_username'],
"#FS_PASSWORD": data['fs_username_pwd'],
"#PLUGIN_PATH": data['fs_plugin_path'],
"#AGREEMENT_PATH": data['fs_agreement_path'],
"#AGENT_FILE_PATH": data['fs_agent_file_path'],
"#AD_DOMAIN_NAME": data["ad_domain_name"],
"#AD_HOSTNAME": data["ad_hostname"],
"#AD_HOST": data["ad_host"],
"#AD_USER_PWD": data["ad_user_pwd"],
"#AD_USER_NAME": data["ad_username"],
"#AD_PORT": data["ad_port"]
}
self.f_lider = open(self.lider_conf_path, 'r+')
lider_text = self.f_lider.read()
txt = self.config_manager.replace_all(lider_text, lider_data)
self.f_lider_out = open(self.lider_conf_out_path, 'w+')
self.f_lider_out.write(str(txt))
self.f_lider.close()
self.f_lider_out.close()
self.logger.info("tr.org.liderahenk.cfg dosyası oluşturuldu")
def configure_db_cfg(self, data):
db_data = {
"#DBADDRESS": data['db_server_addr'],
"#DBDATABASE": data['db_name'],
"#DBUSERNAME": data['db_username'],
"#DBPASSWORD": data['db_password']
}
self.f_db = open(self.db_conf_path, 'r+')
db_text = self.f_db.read()
txt = self.config_manager.replace_all(db_text, db_data)
self.f_db_out = open(self.db_conf_out_path, 'w+')
self.f_db_out.write(str(txt))
self.f_db.close()
self.f_db_out.close()
self.logger.info("tr.org.datasource.cfg dosyası oluşturuldu")
def base_dn_parse(self, data):
### split for get data['base_dn']: liderahenk.org #BASECN and #BASEDN
parse_dn = data["l_base_dn"].split('.')
dn_list = []
for dn in parse_dn:
message = 'dc=' + str(dn) + ','
dn_list.append(message)
base_dn = ''.join(str(x) for x in dn_list)
base_dn = base_dn.strip(',')
return base_dn
def configure_app_properties(self, data):
db_server = data["db_server_addr"]
# if data['ip'] == db_server:
# db_server = "127.0.0.1"
db_data = {
"##DATABASEADDRESS##": db_server,
"##DATABASENAME##": data['db_name'],
"##DATABASEUSERNAME##": data['db_username'],
"##DATABASAPASSWORD##": data['db_password']
}
self.f_db = open(self.application_properties_path, 'r+')
db_text = self.f_db.read()
txt = self.config_manager.replace_all(db_text, db_data)
self.f_db_out = open(self.application_properties_out_path, 'w+')
self.f_db_out.write(str(txt))
self.f_db.close()
self.f_db_out.close()
self.logger.info("application properties dosyası oluşturuldu")
class EjabberInstaller(object):
def __init__(self, ssh_api, ssh_status):
self.ssh_api = ssh_api
self.ssh_status = ssh_status
self.logger = Logger()
self.config_manager = ConfigManager()
self.jabberd_template_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../conf/ejabberd.yml')
self.jabberd_out_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'../../dist/ejabberd.yml')
self.cmd_ejabberd_install = "sudo apt-get install -y ejabberd=19.09.1-0"
self.jabberd_des_path = "/tmp"
self.jabberd_conf_path = "/opt/ejabberd"
self.cmd_cp_conf = "sudo cp {0}/ejabberd.yml {1}/conf"
self.cmd_chown_ejabberd = "sudo chown -R ejabberd=ejabberd {0}/conf"
self.cmd_bin_ejabberd_path = "/opt/ejabberd-19.09.1"
self.cmd_register = "sudo {0}/bin/ejabberdctl register {1} {2} {3}"
self.cmd_jabberd_start = "sudo {0}/bin/ejabberdctl start"
self.cmd_jabberd_restart = "sudo {0}/bin/ejabberdctl restart"
self.cmd_jabberd_status = "sudo {0}/bin/ejabberdctl status"
self.cmd_srg_create = "sudo {0}/bin/ejabberdctl srg-create everyone {1} /'everyone/' this_is_everyone everyone"
self.cmd_srg_user_add = "sudo {0}/bin/ejabberdctl srg-user-add @all@ {1} everyone {1}"
self.cmd_hold_ejabberd = "sudo apt-mark hold ejabberd"
self.cmd_copy_ejabberd_service = "sudo cp {0}/bin/ejabberd.service /etc/systemd/system/"
self.cmd_system_reload = "sudo systemctl daemon-reload"
self.cmd_enable_ejabberd_service = "sudo systemctl enable ejabberd.service"
def install(self, data):
config_manager = ConfigManager()
# configuration ejabberd.yml
base_dn = self.base_dn_parse(data)
ldap_root_dn = "cn=admin," + str(base_dn)
repo_key = data["repo_key"]
repo_key = repo_key.rsplit("/")[-1]
cfg_data = config_manager.read()
conf_data = {
"#HOST": data['e_hosts'],
"#LDAP_SERVER": data['ldap_servers'],
"#LDAP_ROOT_DN": ldap_root_dn,
"#LDAP_ROOT_PWD": data['l_admin_pwd'],
"#LDAP_BASE_DN": base_dn,
"#SERVICE_NAME": data['e_service_name']
}
self.f_ejabberd_yml = open(self.jabberd_template_path, 'r+')
jabber_data = self.f_ejabberd_yml.read()
self.logger.info("Ejabberd sunucu kurulumu için veriler okundu")
txt = self.config_manager.replace_all(jabber_data, conf_data)
self.f_ejabberd_yml_out = open(self.jabberd_out_path, 'w+')
self.f_ejabberd_yml_out.write(txt)
self.f_ejabberd_yml.close()
self.f_ejabberd_yml_out.close()
self.logger.info("ejabberd.yml dosyası oluşturuldu")
#run commands of ejabberd
if self.ssh_status == "Successfully Authenticated":
result_code = self.ssh_api.run_command(
cfg_data["cmd_soft_properties"])
if result_code == 0:
self.logger.info("software-properties-common paketi kuruldu")
else:
self.logger.error(
"software-properties-common paketi kurulamadı, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_key"].format(
data["repo_key"], repo_key))
if result_code == 0:
self.logger.info("Lider Ahenk repo key dosyası indirildi")
else:
self.logger.error(
"Lider Ahenk repo key dosyası indirilemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
cfg_data["cmd_liderahenk_repo_add"].format(data["repo_addr"]))
if result_code == 0:
self.logger.info("Lider Ahenk repo adresi eklendi")
else:
self.logger.error(
"Lider Ahenk repo adresi eklenemedi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(cfg_data["cmd_update"])
if result_code == 0:
self.logger.info("Paket listesi güncellendi(apt update)")
else:
self.logger.error(
"Paket listesi güncellenemdi, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(self.cmd_ejabberd_install)
if result_code == 0:
self.logger.info("Ejabberd paketi kuruldu")
else:
self.logger.error("Ejabberd paketi kurulamadı, result_code: " +
str(result_code))
self.ssh_api.scp_file(self.jabberd_out_path, self.jabberd_des_path)
if result_code == 0:
self.logger.info(
"Ejabberd konfigürasyon dosyası sunucuya kopyalandı")
else:
self.logger.error(
"Ejabberd konfigürasyon dosyası sunucuya kopyalandı")
self.ssh_api.run_command(
self.cmd_cp_conf.format(self.jabberd_des_path,
self.jabberd_conf_path))
result_code = self.ssh_api.run_command(
self.cmd_jabberd_start.format(self.cmd_bin_ejabberd_path))
if result_code == 0:
self.logger.info("Ejabberd servisi başlatıldı")
else:
self.logger.error(
"Ejabberd servisi başlatılamadı, result_code: " +
str(result_code))
print("---------->>>> Start : %s" % time.ctime())
time.sleep(10)
print("-------->>>>> End : %s" % time.ctime())
result_code = self.ssh_api.run_command(
self.cmd_register.format(self.cmd_bin_ejabberd_path,
data["e_username"],
data["e_service_name"],
data["e_user_pwd"]))
if result_code == 0:
self.logger.info("{0} kullanıcısı kaydedildi".format(
data["e_username"]))
else:
self.logger.error(
"{0} kullanıcısı kaydedilemedi, result_code: ".format(
data["e_username"]) + str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_register.format(self.cmd_bin_ejabberd_path,
data["lider_username"],
data["e_service_name"],
data["lider_user_pwd"]))
if result_code == 0:
self.logger.info("{0} kullanıcısı kaydedildi".format(
data["lider_username"]))
else:
self.logger.error(
"{0} kullanıcısı kaydedilemedi, result_code: ".format(
data["lider_username"]) + str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_srg_create.format(self.cmd_bin_ejabberd_path,
data["e_service_name"]))
if result_code == 0:
self.logger.info("shared roster grubu oluşturuldu.")
else:
self.logger.error(
"shared roster grubu oluşturulamadı, resuşt_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_srg_user_add.format(self.cmd_bin_ejabberd_path,
data["e_service_name"]))
if result_code == 0:
self.logger.info("Kullanıcılar shared roster grubuna eklendi")
else:
self.logger.error(
"Kullanıcılar shared roster grubuna eklenemedi, result_code: "
+ str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_jabberd_restart.format(self.cmd_bin_ejabberd_path))
if result_code == 0:
self.logger.info("Ejabberd servisi başlatıldı")
else:
self.logger.error(
"Ejabberd servisi başlatılamadı, result_code: " +
str(result_code))
result_code = self.ssh_api.run_command(
self.cmd_jabberd_status.format(self.cmd_bin_ejabberd_path))
if result_code == 0:
self.logger.info("Ejabberd servisi çalışıyor")
else:
self.logger.warning("Ejabberd servisi çalışmıyor")
self.ssh_api.run_command(self.cmd_hold_ejabberd)
self.ssh_api.run_command(
self.cmd_copy_ejabberd_service.format(
self.cmd_bin_ejabberd_path))
self.logger.info(
"ejabberd.service dosyası /etc/systemd/system/ dizinine kopyalandı"
)
result_code = self.ssh_api.run_command(self.cmd_system_reload)
result_code = self.ssh_api.run_command(
self.cmd_enable_ejabberd_service)
if result_code == 0:
self.logger.info("Ejabberd servis olarak ayarlandı.")
else:
self.logger.error("Ejabberd servis olarak ayarlanamadı.")
else:
# print("bağlantı sağlanamadığı için kurulum yapılamadı..")
self.logger.error(
"XMPP sunucusuna bağlantı sağlanamadığı için kurulum yapılamadı. Lütfen bağlantı ayarlarını kotrol ediniz!"
)
def base_dn_parse(self, data):
### split for get data['base_dn']: liderahenk.org #BASECN and #BASEDN
parse_dn = data["l_base_dn"].split('.')
dn_list = []
for dn in parse_dn:
message = 'dc=' + str(dn) + ','
dn_list.append(message)
base_dn = ''.join(str(x) for x in dn_list)
base_dn = base_dn.strip(',')
return base_dn