class Zookeeper(object):
"""Zookeeper-Backup main methods"""
def __init__(self):
super(Zookeeper, self).__init__()
self.ZookeeperRemoteAppDir = ZOOKEEPER_REMOTE_APP_DIR
self.ZookeeperRemoteSystemdFile = ZOOKEEPER_REMOTE_SYSTEMD_FILE
self.ZookeeperRemoteLogRotate = ZOOKEEPER_REMOTE_LOGROTATE
self.ZookeeperLocalAppDir = ZOOKEEPER_LOCAL_APP_DIR
self.ZookeeperLocalSystemdFile = ZOOKEEPER_LOCAL_SYSTEMD_FILE
self.ZookeeperLocalLogRotate = ZOOKEEPER_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" First Backup: /opt/zookeeper """
home_stdout = self.action.rsync(Host, self.ZookeeperRemoteAppDir,
self.ZookeeperLocalAppDir)
""" Second Backup: zookeeper.service """
systemd_stdout = self.action.rsync(Host, self.ZookeeperRemoteSystemdFile, \
self.ZookeeperLocalSystemdFile)
""" Second Backup: zookeeper.service """
logrotate_stdout = self.action.rsync(Host, self.ZookeeperRemoteLogRotate, \
self.ZookeeperLocalLogRotate)
logger = '{home_stdout}\n{systemd_stdout}\n{logrotate_stdout}\n'.format(home_stdout=home_stdout,\
systemd_stdout=systemd_stdout, logrotate_stdout=logrotate_stdout)
return logger
class Curator(object):
"""Curator-Backup main methods"""
def __init__(self):
super(Curator, self).__init__()
self.CuratorRemoteConfFiles = CURATOR_REMOTE_CONF_FILES
self.CuratorRemoteCronFiles = CURATOR_REMOTE_CRON_FILES
self.CuratorRemoteLogrotateFiles = CURATOR_REMOTE_LOGROTATE_FILE
self.CuratorLocalConfFiles = CURATOR_LOCAL_CONF_FILES
self.CuratorLocalCronFiles = CURATOR_LOCAL_CRON_FILES
self.CuratorLocalLogrotateFiles = CURATOR_LOCAL_LOGROTATE_FILES
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /opt/elasticsearch-curator/conf/ """
home_stdout = self.action.rsync(Host, self.CuratorRemoteConfFiles,
self.CuratorLocalConfFiles)
cron_stdout = self.action.rsync(Host, self.CuratorRemoteCronFiles,
self.CuratorLocalCronFiles)
logrotate_stdout = self.action.rsync(Host,
self.CuratorRemoteLogrotateFiles,
self.CuratorLocalLogrotateFiles)
logger = '{home_stdout}\n{cron_stdout}\n{logrotate_stdout}\n'.format(
home_stdout=home_stdout,
cron_stdout=cron_stdout,
logrotate_stdout=logrotate_stdout)
return logger
class Kaa(object):
"""Kaa-Backup main methods"""
def __init__(self):
super(Kaa, self).__init__()
self.KaaRemoteFiles = KAA_REMOTE_FILES
self.KaaRemoteDefaultFile = KAA_REMOTE_DEFAULT_FILE
self.KaaRemoteSystemdFile = KAA_REMOTE_SYSTEMD_FILE
self.KaaLocalFiles = KAA_LOCAL_FILES
self.KaaLocalSystemdFile = KAA_LOCAL_SYSTEMD_FILE
self.KaaLocalDefaultFile = KAA_LOCAL_DEFAULT_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /usr/lib/kaa-node/conf/ """
confFiles_stdout = self.action.rsync(Host, self.KaaRemoteFiles,
self.KaaLocalFiles)
""" Backup: /etc/default/kaa-node """
defaultFile_stdout = self.action.rsync(Host, self.KaaRemoteDefaultFile,
self.KaaLocalDefaultFile)
""" Backup: /lib/systemd/system/kaa.service """
systemd_stdout = self.action.rsync(Host, self.KaaRemoteSystemdFile, \
self.KaaLocalSystemdFile)
logger = '{confFiles_stdout}\n{defaultFile_stdout}\n{systemd_stdout}\n'.format(confFiles_stdout=confFiles_stdout,\
defaultFile_stdout=defaultFile_stdout,systemd_stdout=systemd_stdout)
return logger
class Centreon(object):
"""Centreon-Backup main methods"""
def __init__(self):
super(Centreon, self).__init__()
self.CentreonRemoteConfFile = CENTREON_REMOTE_CONF_FILE
self.CentreonLocalConfFile = CENTREON_LOCAL_CONF_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" First Backup: /usr/local/nagios/etc/nrpe.cfg """
CentreonLocalHostnameConfFile = '{CentreonLocalConfFile}/{host}'.format(host=Host,
CentreonLocalConfFile=self.CentreonLocalConfFile)
if not os.path.isdir(CentreonLocalHostnameConfFile):
os.mkdir(CentreonLocalHostnameConfFile)
home_stdout = self.action.rsync(Host, self.CentreonRemoteConfFile, CentreonLocalHostnameConfFile)
else:
home_stdout = self.action.rsync(Host, self.CentreonRemoteConfFile, CentreonLocalHostnameConfFile)
logger = home_stdout
return logger
class Mosquitto(object):
"""Mosquitto-Backup main methods"""
def __init__(self):
super(Mosquitto, self).__init__()
self.MosquittoRemoteConfFiles = MOSQUITTO_REMOTE_CONFIG_FILE
self.MosquittoRemoteConfDir = MOSQUITTO_REMOTE_CONFIG_DIR
self.MosquittoRemoteSystemdFile = MOSQUITTO_REMOTE_SYSTEMD_FILE
self.MosquittoRemoteLogrotateFile = MOSQUITTO_REMOTE_LOGROTATE
self.MosquittoLocalConfFiles = MOSQUITTO_LOCAL_CONFIG_FILE
self.MosquittoLocalConfDir = MOSQUITTO_LOCAL_CONFIG_DIR
self.MosquittoLocalSystemdFile = MOSQUITTO_LOCAL_SYSTEMD_FILE
self.MosquittoLocalLogrotateFile = MOSQUITTO_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/mosquitto/mosquitto.conf """
confFile_stdout = self.action.rsync(Host, self.MosquittoRemoteConfFiles, self.MosquittoLocalConfFiles)
""" Backup: /etc/mosquitto/conf.d """
confDir_stdout = self.action.rsync(Host, self.MosquittoRemoteConfDir, self.MosquittoLocalConfDir)
""" Backup: /lib/systemd/system/mosquitto.service """
systemd_stdout = self.action.rsync(Host, self.MosquittoRemoteSystemdFile, self.MosquittoLocalSystemdFile)
""" Backup: /etc/logrotate.d/mosquitto """
logrotateFile_stdout = self.action.rsync(Host, self.MosquittoRemoteLogrotateFile, self.MosquittoLocalLogrotateFile)
logger = '{confFile_stdout}\n{confDir_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n'.format(
confFile_stdout=confFile_stdout,confDir_stdout=confDir_stdout, logrotateFile_stdout=logrotateFile_stdout,
systemd_stdout=systemd_stdout)
return logger
class Hdfs(object):
"""Hdfs-Backup main methods"""
def __init__(self):
super(Hdfs, self).__init__()
self.HadoopRemoteAppDir = HADOOP_REMOTE_APP_DIR
self.HadoopRemoteSystemdFiles = HADOOP_REMOTE_SYSTEMD_FILES
self.HadoopRemoteLogrotateFile = HADOOP_REMOTE_LOGROTATE_FILE
self.HadoopLocalAppDir = HADOOP_LOCAL_APP_DIR
self.HadoopLocalSystemdFile = HADOOP_LOCAL_SYSTEMD_FILE
self.HadoopLocalLogrotateFile = HADOOP_LOCAL_LOGROTATE_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
systemd_stdout = []
""" Backup: /opt/hadoop """
home_stdout = self.action.rsync(Host, self.HadoopRemoteAppDir,
self.HadoopLocalAppDir)
""" Backup: /etc/logrotate.d/hadoop """
logrotateFile_stdout = self.action.rsync(
Host, self.HadoopRemoteLogrotateFile,
self.HadoopLocalLogrotateFile)
""" Backup: namenode.service, datanode.service, secondarynamenode.service """
for systemdFile in self.HadoopRemoteSystemdFiles:
stdoutRsync = self.action.rsync(Host, systemdFile,
self.HadoopLocalSystemdFile)
systemd_stdout.append(stdoutRsync)
#systemd_stdout_str = str(systemd_stdout)
logger = '{home_stdout}\n{logrotateFile_stdout}\n{systemd_stdout_str}\n'.format(
home_stdout=home_stdout,
logrotateFile_stdout=logrotateFile_stdout,
systemd_stdout_str=systemd_stdout)
return logger
class Cerebro(object):
"""Cerebro-Backup main methods"""
def __init__(self):
super(Cerebro, self).__init__()
self.CerebroRemoteAppDir = CEREBRO_REMOTE_APP_DIR
self.CerebroRemoteSystemdFile = CEREBRO_REMOTE_SYSTEMD_FILE
self.CerebroRemoteLogRotate = CEREBRO_REMOTE_LOGROTATE
self.CerebroLocalAppDir = CEREBRO_LOCAL_APP_DIR
self.CerebroLocalSystemdFile = CEREBRO_LOCAL_SYSTEMD_FILE
self.CerebroLocalLogRotate = CEREBRO_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" First Backup: /opt/cerebro """
home_stdout = self.action.rsync(Host, self.CerebroRemoteAppDir,
self.CerebroLocalAppDir)
""" Second Backup: Cerebro.service """
systemd_stdout = self.action.rsync(Host, self.CerebroRemoteSystemdFile, \
self.CerebroLocalSystemdFile)
logrotate_stdout = self.action.rsync(Host, self.CerebroRemoteLogRotate, \
self.CerebroLocalLogRotate)
logger = '{home_stdout}\n{systemd_stdout}\n{logrotate_stdout}\n'.format(home_stdout=home_stdout,\
systemd_stdout=systemd_stdout, logrotate_stdout=logrotate_stdout)
return logger
class Nodered(object):
"""Nodered-Backup main methods"""
def __init__(self):
super(Nodered, self).__init__()
self.NoderedRemoteConfFiles = NODERED_REMOTE_CONFIG_FILE
self.NoderedRemoteSystemdFile = NODERED_REMOTE_SYSTEMD_FILE
self.NoderedRemoteFlowFile = NODERED_REMOTE_FLOW_FILE
self.NoderedLocalConfFiles = NODERED_LOCAL_CONFIG_FILE
self.NoderedLocalSystemdFile = NODERED_LOCAL_SYSTEMD_FILE
self.NoderedLocalFlowFile = NODERED_LOCAL_FLOW_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /opt/nodered/settings.js """
confFile_stdout = self.action.rsync(Host, self.NoderedRemoteConfFiles,
self.NoderedLocalConfFiles)
""" Backup: /lib/systemd/system/nodered.service """
systemd_stdout = self.action.rsync(Host, self.NoderedRemoteSystemdFile,
self.NoderedLocalSystemdFile)
""" Backup: /opt/nodered/flow/ """
flow_stdout = self.action.rsync(Host, self.NoderedRemoteFlowFile,
self.NoderedLocalFlowFile)
logger = '{confFile_stdout}\n{systemd_stdout}\n{flow_stdout}'.format(
confFile_stdout=confFile_stdout,
systemd_stdout=systemd_stdout,
flow_stdout=flow_stdout)
return logger
class Postgresql10(object):
"""postgresql10-Backup main methods"""
def __init__(self):
super(Postgresql10, self).__init__()
self.Postgresql10RemoteConfFiles = POSTGRESQL10_REMOTE_CONFIG_FILE
self.Postgresql10RemoteHbaFile = POSTGRESQL10_REMOTE_HBA_FILE
self.Postgresql10LocalConfFiles = POSTGRESQL10_LOCAL_CONFIG_FILE
self.Postgresql10LocalHbaFile = POSTGRESQL10_LOCAL_HBA_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/postgresql/10/main/posgresql.conf """
confFile_stdout = self.action.rsync(Host,
self.Postgresql10RemoteConfFiles,
self.Postgresql10LocalConfFiles)
""" Backup: /etc/postgresql/10/main/pg_hba.conf """
hbaFile_stdout = self.action.rsync(Host,
self.Postgresql10RemoteHbaFile,
self.Postgresql10LocalHbaFile)
logger = '{confFile_stdout}\n{hbaFile_stdout}\n'.format(
confFile_stdout=confFile_stdout, hbaFile_stdout=hbaFile_stdout)
return logger
class Dnsmasq(object):
"""Dnsmasq-Backup main methods"""
def __init__(self):
super(Dnsmasq, self).__init__()
self.DnsmasqRemoteConfFile = DNSMASQ_REMOTE_CONF_FILE
self.DnsmasqRemoteSystemdFile = DNSMASQ_REMOTE_SYSTEMD_FILE
self.DmsmasqRemoteLogRotate = DNSMASQ_REMOTE_LOGROTATE
self.DnsmasqLocalConfFile = DNSMASQ_LOCAL_CONF_FILE
self.DnsmasqLocalSystemdFile = DNSMASQ_LOCAL_SYSTEMD_FILE
self.DnsmasqLocalLogRotate = DNSMASQ_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/dnsmasq.conf """
confFile_stdout = self.action.rsync(Host, self.DnsmasqRemoteConfFile,
self.DnsmasqLocalConfFile)
#""" Backup: /etc/logrotate.d/dnsmasq """
logrotate_stdout = self.action.rsync(Host, self.DmsmasqRemoteLogRotate,
self.DnsmasqLocalLogRotate)
""" Backup: /lib/systemd/system/dnsmasq.service """
systemd_stdout = self.action.rsync(Host, self.DnsmasqRemoteSystemdFile,
self.DnsmasqLocalSystemdFile)
logger = '{confFile_stdout}\n{systemd_stdout}\n{logrotate_stdout}\n'.format(
confFile_stdout=confFile_stdout,systemd_stdout=systemd_stdout,\
logrotate_stdout=logrotate_stdout)
return logger
class Postgresqlcommon(object):
"""postgresql-common-Backup main methods"""
def __init__(self):
super(Postgresqlcommon, self).__init__()
self.PostgresqlcommonRemoteLogrotate = POSTGRESQLCOMMON_REMOTE_LOGROTATE
self.PostgresqlcommonRemoteSystemdFile = POSTGRESQLCOMMON_REMOTE_SYSTEMD_FILE
self.PostgresqlcommonLocalLogrotate = POSTGRESQLCOMMON_LOCAL_LOGROTATE
self.PostgresqlcommonLocalSystemdFile = POSTGRESQLCOMMON_LOCAL_SYSTEMD_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/logrotate.d/postgresql-common """
logrotate_stdout = self.action.rsync(
Host, self.PostgresqlcommonRemoteLogrotate,
self.PostgresqlcommonLocalLogrotate)
""" Backup: /lib/systemd/system/postgresql* """
systemdFile_stdout = self.action.rsync(
Host, self.PostgresqlcommonRemoteSystemdFile,
self.PostgresqlcommonLocalSystemdFile)
logger = '{logrotate_stdout}\n{systemdFile_stdout}\n'.format(
logrotate_stdout=logrotate_stdout,
systemdFile_stdout=systemdFile_stdout)
return logger
class Spark(object):
"""Spark-Backup main methods"""
def __init__(self):
super(Spark, self).__init__()
self.SparkRemoteAppDir = SPARK_REMOTE_APP_DIR
self.SparkRemoteSystemdFiles = SPARK_REMOTE_SYSTEMD_FILES
self.SparkRemoteLogRotate = SPARK_REMOTE_LOGROTATE
self.SparkLocalAppDir = SPARK_LOCAL_APP_DIR
self.SparkLocalSystemdFile = SPARK_LOCAL_SYSTEMD_FILE
self.SparkLocalLogRotate = SPARK_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
systemd_stdout = []
""" First Backup: /opt/spark """
home_stdout = self.action.rsync(Host, self.SparkRemoteAppDir,
self.SparkLocalAppDir)
""" Second Backup: spark-master.service, spark-worker.service """
for systemdFile in self.SparkRemoteSystemdFiles:
stdoutRsync = self.action.rsync(Host, systemdFile,
self.SparkLocalSystemdFile)
systemd_stdout.append(stdoutRsync)
""" Third Backup: /opt/spark """
logrotate_stdout = self.action.rsync(Host, self.SparkRemoteLogRotate,
self.SparkLocalLogRotate)
logger = '{home_stdout}\n{systemd_stdout_str}\n'.format(home_stdout=home_stdout,\
systemd_stdout_str=systemd_stdout, logrotate_stdout=logrotate_stdout)
return logger
class Logstash(object):
"""Logstash-Backup main methods"""
def __init__(self):
super(Logstash, self).__init__()
self.LogstashRemoteConfFiles = LOGSTASH_REMOTE_CONF_FILES
self.LogstashRemoteDefaultFile = LOGSTASH_REMOTE_DEFAULT_FILE
self.LogstashRemoteSystemdFile = LOGSTASH_REMOTE_SYSTEMD_FILE
self.LogstashRemoteLogrotateFile = LOGSTASH_REMOTE_LOGROTATE_FILE
self.LogstashLocalConfFiles = LOGSTASH_LOCAL_CONF_FILES
self.LogstashLocalSystemdFile = LOGSTASH_LOCAL_SYSTEMD_FILE
self.LogstashLocalDefaultFile = LOGSTASH_LOCAL_DEFAULT_FILE
self.LogstashLocalLogrotateFile = LOGSTASH_LOCAL_LOGROTATE_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/logstash/conf.d/ """
confFiles_stdout = self.action.rsync(Host, self.LogstashRemoteConfFiles, self.LogstashLocalConfFiles)
""" Backup: /etc/default/logstash """
defaultFile_stdout = self.action.rsync(Host, self.LogstashRemoteDefaultFile, self.LogstashLocalDefaultFile)
""" Backup: /etc/logrotate.d/logstash """
logrotateFile_stdout = self.action.rsync(Host, self.LogstashRemoteLogrotateFile, self.LogstashLocalLogrotateFile)
""" Backup: /etc/init.d/logstash """
systemd_stdout = self.action.rsync(Host, self.LogstashRemoteSystemdFile, \
self.LogstashLocalSystemdFile)
logger = '{confFiles_stdout}\n{defaultFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n'.format(
confFiles_stdout=confFiles_stdout,defaultFile_stdout=defaultFile_stdout,
logrotateFile_stdout=logrotateFile_stdout,systemd_stdout=systemd_stdout)
return logger
class Rabbitmq(object):
"""Rabbitmq-Backup main methods"""
def __init__(self):
super(Rabbitmq, self).__init__()
self.RabbitmqRemoteConfFiles = RABBITMQ_REMOTE_CONFIG_FILE
self.RabbitmqRemoteSystemdFile = RABBITMQ_REMOTE_SYSTEMD_FILE
self.RabbitmqRemoteLogrotateFile = RABBITMQ_REMOTE_LOGROTATE
self.RabbitmqLocalConfFiles = RABBITMQ_LOCAL_CONFIG_FILE
self.RabbitmqLocalSystemdFile = RABBITMQ_LOCAL_SYSTEMD_FILE
self.RabbitmqLocalLogrotateFile = RABBITMQ_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/rabbitmq/ """
confFile_stdout = self.action.rsync(Host, self.RabbitmqRemoteConfFiles, self.RabbitmqLocalConfFiles)
""" Backup: /lib/systemd/system/rabbitmq-server.service """
systemd_stdout = self.action.rsync(Host, self.RabbitmqRemoteSystemdFile, self.RabbitmqLocalSystemdFile)
""" Backup: /etc/logrotate.d/rabbitmq-server """
logrotateFile_stdout = self.action.rsync(Host, self.RabbitmqRemoteLogrotateFile, self.RabbitmqLocalLogrotateFile)
logger = '{confFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n'.format(
confFile_stdout=confFile_stdout,logrotateFile_stdout=logrotateFile_stdout,
systemd_stdout=systemd_stdout)
return logger
class Mongodb(object):
"""Mongodb-Backup main methods"""
def __init__(self):
super(Mongodb, self).__init__()
self.MongodbRemoteConfFiles = MONGODB_REMOTE_CONFIG_FILE
self.MongodbRemoteSystemdFile = MONGODB_REMOTE_SYSTEMD_FILE
self.MongodbRemoteLogrotateFile = MONGODB_REMOTE_LOGROTATE
self.MongodbLocalConfFiles = MONGODB_LOCAL_CONFIG_FILE
self.MongodbLocalSystemdFile = MONGODB_LOCAL_SYSTEMD_FILE
self.MongodbLocalLogrotateFile = MONGODB_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/mongod.conf """
confFile_stdout = self.action.rsync(Host, self.MongodbRemoteConfFiles,
self.MongodbLocalConfFiles)
""" Backup: /lib/systemd/system/mongod.service """
systemd_stdout = self.action.rsync(Host, self.MongodbRemoteSystemdFile,
self.MongodbLocalSystemdFile)
""" Backup: /etc/logrotate.d/mongodb-server """
logrotateFile_stdout = self.action.rsync(
Host, self.MongodbRemoteLogrotateFile,
self.MongodbLocalLogrotateFile)
logger = '{confFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n'.format(
confFile_stdout=confFile_stdout,
logrotateFile_stdout=logrotateFile_stdout,
systemd_stdout=systemd_stdout)
return logger
class Nifiregistry(object):
"""NifiRegistry-Backup main methods"""
def __init__(self):
super(Nifiregistry, self).__init__()
self.NifiregistryRemoteConfFiles = NIFI_REGISTRY_REMOTE_CONF_FILES
self.NifiregistryRemoteSystemdFile = NIFI_REGISTRY_REMOTE_SYSTEMD_FILE
self.NifiregistryRemoteSslTrustore = NIFI_REGISTRY_REMOTE_SSL_TRUSTORE
self.NifiregistryLocalConfFiles = NIFI_REGISTRY_LOCAL_CONF_FILES
self.NifiregistryLocalSslTrustore = NIFI_REGISTRY_LOCAL_SSL_TRUSTORE
self.NifiregistryLocalSystemdFile = NIFI_REGISTRY_LOCAL_SYSTEMD_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /opt/nifi-registry/conf """
confFile_stdout = self.action.rsync(Host,
self.NifiregistryRemoteConfFiles,
self.NifiregistryLocalConfFiles)
""" Backup: /lib/systemd/system/nifi-registry.service """
systemd_stdout = self.action.rsync(Host,
self.NifiregistryRemoteSystemdFile,
self.NifiregistryLocalSystemdFile)
""" Backup: /opt/nifi-registry/ssl/nificluster_trustore.jks """
trustore_stdout = self.action.rsync(Host,
self.NifiregistryRemoteSslTrustore,
self.NifiregistryLocalSslTrustore)
logger = '{confFile_stdout}\n{systemd_stdout}\n{trustore_stdout}'.format(
confFile_stdout=confFile_stdout,
systemd_stdout=systemd_stdout,
trustore_stdout=trustore_stdout)
return logger
class Vernemq(object):
"""Vernemq-Backup main methods"""
def __init__(self):
super(Vernemq, self).__init__()
self.VernemqRemoteConfFiles = VERNEMQ_REMOTE_CONF_FILES
self.VernemqRemoteSystemdFile = VERNEMQ_REMOTE_SYSTEMD_FILE
self.VernemqRemoteStore = VERNEMQ_REMOTE_STORE
self.VernemqRemoteInitd = VERNEMQ_REMOTE_INITD
self.VernemqRemoteShare = VERNEMQ_REMOTE_SHARE
self.VernemqLocalConfFiles = VERNEMQ_LOCAL_CONF_FILES
self.VernemqLocalSystemdFile = VERNEMQ_LOCAL_SYSTEMD_FILE
self.VernemqLocalStore = VERNEMQ_LOCAL_STORE
self.VernemqLocalInitd = VERNEMQ_LOCAL_INITD
self.VernemqLocalShare = VERNEMQ_LOCAL_SHARE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/vernemq/ """
confFile_stdout = self.action.rsync(Host, self.VernemqRemoteConfFiles, self.VernemqLocalConfFiles)
#""" Backup: /etc/logrotate.d/vernemq """
#logrotateFile_stdout = rsync(Host, self.VernemqRemoteLogrotateFile, self.VernemqLocalLogrotateFile)
""" Backup: /lib/systemd/system/vernemq.service """
systemd_stdout = self.action.rsync(Host, self.VernemqRemoteSystemdFile, self.VernemqLocalSystemdFile)
#logger = '{confFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n'.format(
# confFile_stdout=confFile_stdout,logrotateFile_stdout=logrotateFile_stdout,
# systemd_stdout=systemd_stdout)
""" Backup: /opt/store/vernemq """
store_stdout = self.action.rsync(Host, self.VernemqRemoteStore, self.VernemqLocalStore)
""" Backup: /etc/initd.d/vernemq """
initd_stdout = self.action.rsync(Host, self.VernemqRemoteInitd, self.VernemqLocalInitd)
""" Backup: /usr/share/vernemq """
share_stdout = self.action.rsync(Host, self.VernemqRemoteShare, self.VernemqLocalShare)
logger = '{confFile_stdout}\n{systemd_stdout}\n{store_stdout}\n{initd_stdout}\n{share_stdout}'.format(
confFile_stdout=confFile_stdout,systemd_stdout=systemd_stdout,
store_stdout=store_stdout,initd_stdout=initd_stdout,share_stdout=share_stdout)
return logger
class Elasticsearch(object):
"""Elasticsearch-Backup main methods"""
def __init__(self):
super(Elasticsearch, self).__init__()
self.ElasticsearchRemoteConfFiles = ELASTICSEARCH_REMOTE_CONF_FILES
self.ElasticsearchRemoteDefaultFile = ELASTICSEARCH_REMOTE_DEFAULT_FILE
self.ElasticsearchRemoteLogrotateFile = ELASTICSEARCH_REMOTE_LOGROTATE_FILE
self.ElasticsearchRemoteSystemdFile = ELASTICSEARCH_REMOTE_SYSTEMD_FILE
self.ElasticsearchRemoteShareFiles = ELASTICSEARCH_REMOTE_SHARE
self.ElasticsearchLocalConfFiles = ELASTICSEARCH_LOCAL_CONF_FILES
self.ElasticsearchLocalSystemdFile = ELASTICSEARCH_LOCAL_SYSTEMD_FILE
self.ElasticsearchLocalDefaultFile = ELASTICSEARCH_LOCAL_DEFAULT_FILE
self.ElasticsearchLocalLogrotateFile = ELASTICSEARCH_LOCAL_LOGROTATE_FILE
self.ElasticsearchLocalShareFiles = ELASTICSEARCH_LOCAL_SHARE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/elasticsearch/ """
confFile_stdout = self.action.rsync(Host,
self.ElasticsearchRemoteConfFiles,
self.ElasticsearchLocalConfFiles)
""" Backup: /etc/default/elasticsearch """
defaultFile_stdout = self.action.rsync(
Host, self.ElasticsearchRemoteDefaultFile,
self.ElasticsearchLocalDefaultFile)
""" Backup: /etc/logrotate.d/elasticsearch """
logrotateFile_stdout = self.action.rsync(
Host, self.ElasticsearchRemoteLogrotateFile,
self.ElasticsearchLocalLogrotateFile)
""" Backup: /usr/lib/systemd/system/elasticsearch.service """
systemd_stdout = self.action.rsync(Host,
self.ElasticsearchRemoteSystemdFile,
self.ElasticsearchLocalSystemdFile)
""" Backup: /usr/share/elasticsearch """
share_stdout = self.action.rsync(Host,
self.ElasticsearchRemoteShareFiles,
self.ElasticsearchLocalShareFiles)
logger = '{confFile_stdout}\n{defaultFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n{share_stdout}\n'.format(
confFile_stdout=confFile_stdout,
logrotateFile_stdout=logrotateFile_stdout,
defaultFile_stdout=defaultFile_stdout,
systemd_stdout=systemd_stdout,
share_stdout=share_stdout)
return logger
class Haproxy(object):
"""HAproxy-Backup main methods"""
def __init__(self):
super(Haproxy, self).__init__()
self.HaproxyRemoteConfFiles = HAPROXY_REMOTE_CONF_FILES
self.HaproxyRemoteDefaultFile = HAPROXY_REMOTE_DEFAULT_FILE
self.HaproxyRemoteLogrotateFile = HAPROXY_REMOTE_LOGROTATE_FILE
self.HaproxyRemoteSystemdFile = HAPROXY_REMOTE_SYSTEMD_FILE
self.HaproxyRemoteRsyslogFile = HAPROXY_REMOTE_RSYSLOG
self.HaproxyLocalConfFiles = HAPROXY_LOCAL_CONF_FILES
self.HaproxyLocalSystemdFile = HAPROXY_LOCAL_SYSTEMD_FILE
self.HaproxyLocalDefaultFile = HAPROXY_LOCAL_DEFAULT_FILE
self.HaproxyLocalLogrotateFile = HAPROXY_LOCAL_LOGROTATE_FILE
self.HaproxyLocalRsyslogFile = HAPROXY_LOCAL_RSYSLOG
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/haproxy/ """
confFile_stdout = self.action.rsync(Host, self.HaproxyRemoteConfFiles,
self.HaproxyLocalConfFiles)
""" Backup: /etc/default/haproxy """
defaultFile_stdout = self.action.rsync(Host,
self.HaproxyRemoteDefaultFile,
self.HaproxyLocalDefaultFile)
""" Backup: /etc/logrotate.d/haproxy """
logrotateFile_stdout = self.action.rsync(
Host, self.HaproxyRemoteLogrotateFile,
self.HaproxyLocalLogrotateFile)
""" Backup: /lib/systemd/system/haproxy.service """
systemd_stdout = self.action.rsync(Host, self.HaproxyRemoteSystemdFile,
self.HaproxyLocalSystemdFile)
""" Backup: /etc/rsyslog.d/49-haproxy.conf """
rsyslog_stdout = self.action.rsync(Host, self.HaproxyRemoteRsyslogFile,
self.HaproxyLocalRsyslogFile)
logger = '{confFile_stdout}\n{defaultFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n{rsyslog_stdout}\n'.format(
confFile_stdout=confFile_stdout,
logrotateFile_stdout=logrotateFile_stdout,
defaultFile_stdout=defaultFile_stdout,
systemd_stdout=systemd_stdout,
rsyslog_stdout=rsyslog_stdout)
return logger
class Kibana(object):
"""Kibana-Backup main methods"""
def __init__(self):
super(Kibana, self).__init__()
self.KibanaRemoteConfFile = KIBANA_REMOTE_CONF_FILE
self.KibanaRemoteDefaultFile = KIBANA_REMOTE_DEFAULT_FILE
self.KibanaRemoteLogrotateFile = KIBANA_REMOTE_LOGROTATE_FILE
self.KibanaRemoteSystemdFile = KIBANA_REMOTE_SYSTEMD_FILE
self.KibanaRemoteInitFile = KIBANA_REMOTE_INIT_FILE
self.KibanaLocalConfFile = KIBANA_LOCAL_CONF_FILE
self.KibanaLocalSystemdFile = KIBANA_LOCAL_SYSTEMD_FILE
self.KibanaLocalInitFile = KIBANA_LOCAL_INIT_FILE
self.KibanaLocalDefaultFile = KIBANA_LOCAL_DEFAULT_FILE
self.KibanaLocalLogrotateFile = KIBANA_LOCAL_LOGROTATE_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/kibana/kibana.yml """
confFile_stdout = self.action.rsync(Host, self.KibanaRemoteConfFile, self.KibanaLocalConfFile)
""" Backup: /etc/default/kibana """
defaultFile_stdout = self.action.rsync(Host, self.KibanaRemoteDefaultFile, self.KibanaLocalDefaultFile)
""" Backup: /etc/logrotate.d/kibana """
logrotateFile_stdout = self.action.rsync(Host, self.KibanaRemoteLogrotateFile, self.KibanaLocalLogrotateFile)
""" Backup: /etc/init.d/kibana """
systemd_stdout = self.action.rsync(Host, self.KibanaRemoteSystemdFile, \
self.KibanaLocalSystemdFile)
init_stdout = self.action.rsync(Host, self.KibanaRemoteInitFile, \
self.KibanaLocalInitFile)
logger = '{confFile_stdout}\n{defaultFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n{init_stdout}\n'.format(
confFile_stdout=confFile_stdout,logrotateFile_stdout=logrotateFile_stdout,
defaultFile_stdout=defaultFile_stdout,systemd_stdout=systemd_stdout,init_stdout=init_stdout)
return logger
class Influxdb(object):
"""Influxdb-Backup main methods"""
def __init__(self):
super(Influxdb, self).__init__()
self.InfluxdbRemoteConfFiles = INFLUXDB_REMOTE_CONFIG_FILE
self.InfluxdbRemoteSystemdFile = INFLUXDB_REMOTE_SYSTEMD_FILE
self.InfluxdbRemoteLogrotateFile = INFLUXDB_REMOTE_LOGROTATE
self.InfluxdbRemoteRsyslogFile = INFLUXDB_REMOTE_RSYSLOG
self.InfluxdbLocalConfFiles = INFLUXDB_LOCAL_CONFIG_FILE
self.InfluxdbLocalSystemdFile = INFLUXDB_LOCAL_SYSTEMD_FILE
self.InfluxdbLocalLogrotateFile = INFLUXDB_LOCAL_LOGROTATE
self.InfluxdbLocalRsyslogFile = INFLUXDB_LOCAL_RSYSLOG
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/influxdb.conf """
confFile_stdout = self.action.rsync(Host, self.InfluxdbRemoteConfFiles,
self.InfluxdbLocalConfFiles)
""" Backup: /lib/systemd/system/influxdb.service """
systemd_stdout = self.action.rsync(Host,
self.InfluxdbRemoteSystemdFile,
self.InfluxdbLocalSystemdFile)
""" Backup: /etc/logrotate.d/influxdb """
logrotateFile_stdout = self.action.rsync(
Host, self.InfluxdbRemoteLogrotateFile,
self.InfluxdbLocalLogrotateFile)
""" Backup: /etc/rsyslog.d/49-influxdb.conf """
rsyslogFile_stdout = self.action.rsync(Host,
self.InfluxdbRemoteRsyslogFile,
self.InfluxdbLocalRsyslogFile)
logger = '{confFile_stdout}\n{logrotateFile_stdout}\n{systemd_stdout}\n{rsyslogFile_stdout}\n'.format(
confFile_stdout=confFile_stdout,
logrotateFile_stdout=logrotateFile_stdout,
systemd_stdout=systemd_stdout,
rsyslogFile_stdout=rsyslogFile_stdout)
return logger
class Redis(object):
"""Redis-Backup main methods"""
def __init__(self):
super(Redis, self).__init__()
self.RedisRemoteConfFile = REDIS_REMOTE_CONF_FILE
self.RedisRemoteLogrotateFile = REDIS_REMOTE_LOGROTATE_FILE
self.RedisRemoteDefaultFile = REDIS_REMOTE_DEFAULT_FILE
self.RedisRemoteSystemdFile = REDIS_REMOTE_SYSTEMD_FILE
self.RedisLocalConfFile = REDIS_LOCAL_CONF_FILE
self.RedisLocalSystemdFile = REDIS_LOCAL_SYSTEMD_FILE
self.RedisLocalDefaultFile = REDIS_LOCAL_DEFAULT_FILE
self.RedisLocalLogrotateFile = REDIS_LOCAL_LOGROTATE_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
""" Backup: /etc/redis/redis.conf """
confFile_stdout = self.action.rsync(Host, self.RedisRemoteConfFile,
self.RedisLocalConfFile)
""" Backup: /etc/logrotate.d/redis-server """
logrotateFile_stdout = self.action.rsync(Host,
self.RedisRemoteLogrotateFile,
self.RedisLocalLogrotateFile)
""" Backup: /etc/default/redis-server """
defaultFile_stdout = self.action.rsync(Host,
self.RedisRemoteDefaultFile,
self.RedisLocalDefaultFile)
""" Backup: /lib/systemd/system/redis-server.service """
systemd_stdout = self.action.rsync(Host, self.RedisRemoteSystemdFile, \
self.RedisLocalSystemdFile)
logger = '{confFile_stdout}\n{logrotateFile_stdout}\n{defaultFile_stdout}\n{systemd_stdout}\n'.format(
confFile_stdout=confFile_stdout,
logrotateFile_stdout=logrotateFile_stdout,
defaultFile_stdout=defaultFile_stdout,
systemd_stdout=systemd_stdout)
return logger
class Druid(object):
"""Druid-Backup main methods"""
def __init__(self):
super(Druid, self).__init__()
self.DruidRemoteAppDir = DRUID_REMOTE_APP_DIR
self.DruidRemoteSystemdFiles = DRUID_REMOTE_SYSTEMD_FILES
self.DruidRemoteBins = DRUID_REMOTE_BINS
self.DruidRemoteLogRotate = DRUID_REMOTE_LOGROTATE
self.DruidLocalAppDir = DRUID_LOCAL_APP_DIR
self.DruidLocalSystemdFile = DRUID_LOCAL_SYSTEMD_FILE
self.DruidLocalBins = DRUID_LOCAL_BINS
self.DruidLocalLogRotate = DRUID_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
systemd_stdout = [ ]
""" First Backup: /opt/druid """
home_stdout = self.action.rsync(Host, self.DruidRemoteAppDir, self.DruidLocalAppDir)
""" Second Backup: overlord.service, middlemanager.service, historical.service
broker.service, coordinator.service"""
for systemdFile in self.DruidRemoteSystemdFiles:
stdoutRsync = self.action.rsync(Host, systemdFile, self.DruidLocalSystemdFile)
systemd_stdout.append(stdoutRsync)
""" First Backup: /usr/bin/druid_* """
hardreload_stdout = self.action.rsync(Host, self.DruidRemoteBins, self.DruidLocalBins)
""" First Backup: /opt/c_tools/druid_hard_reload """
logrotate_stdout = self.action.rsync(Host, self.DruidRemoteLogRotate, self.DruidLocalLogRotate)
logger = '{home_stdout}\n{systemd_stdout_str}\n{hardreload_stdout}\n{logrotate_stdout}\n'.format(
home_stdout=home_stdout,systemd_stdout_str=systemd_stdout,\
hardreload_stdout=hardreload_stdout, logrotate_stdout=logrotate_stdout)
return logger
class Kafka(object):
"""Kafka-Backup main methods"""
def __init__(self):
super(Kafka, self).__init__()
self.KafkaRemoteAppDir = KAFKA_REMOTE_APP_DIR
self.KafkaRemoteSystemdFile = KAFKA_REMOTE_SYSTEMD_FILE
self.KafkaRemoteBins = KAFKA_REMOTE_BINS
self.KafkaRemoteLogRotate = KAFKA_REMOTE_LOGROTATE
self.KafkaLocalAppDir = KAFKA_LOCAL_APP_DIR
self.KafkaLocalSystemdFile = KAFKA_LOCAL_SYSTEMD_FILE
self.KafkaLocalBins = KAFKA_LOCAL_BINS
self.KafkaLocalLogRotate = KAFKA_LOCAL_LOGROTATE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
# TODO Check if exits app in host
""" Backup: /opt/kafka """
home_stdout = self.action.rsync(Host, self.KafkaRemoteAppDir,
self.KafkaLocalAppDir)
""" Backup: kafka.service """
systemd_stdout = self.action.rsync(Host, self.KafkaRemoteSystemdFile, \
self.KafkaLocalSystemdFile)
""" Backup: /usr/bin/create-kafka-topics """
create_topics_stdout = self.action.rsync(Host, self.KafkaRemoteBins, \
self.KafkaLocalBins)
""" Backup: /etc/logrotate.d/kafka """
logrotate_stdout = self.action.rsync(Host, self.KafkaRemoteLogRotate, \
self.KafkaLocalLogRotate)
logger = '{home_stdout}\n{systemd_stdout}\n{create_topics_stdout}\n{logrotate_stdout}'.format(
home_stdout=home_stdout, logrotate_stdout=logrotate_stdout, \
systemd_stdout=systemd_stdout,create_topics_stdout=create_topics_stdout)
return logger
class Tranquility(object):
"""Tranquility-Backup main methods"""
def __init__(self):
super(Tranquility, self).__init__()
self.TranquilityRemoteAppDir = TRANQUILITY_REMOTE_APP_DIR
self.TranquilityRemoteSystemdFile = TRANQUILITY_REMOTE_SYSTEMD_FILE
self.TranquilityLocalAppDir = TRANQUILITY_LOCAL_APP_DIR
self.TranquilityLocalSystemdFile = TRANQUILITY_LOCAL_SYSTEMD_FILE
self.action = Actions()
def backup(self, RemoteHost):
Host = RemoteHost
systemd_stdout = []
""" Backup: /opt/tranquility """
home_stdout = self.action.rsync(Host, self.TranquilityRemoteAppDir,
self.TranquilityLocalAppDir)
""" Backup: tranquility-rt-tasks.service"""
systemd_stdout = self.action.rsync(Host, self.TranquilityRemoteSystemdFile, \
self.TranquilityLocalSystemdFile)
logger = '{home_stdout}\n{systemd_stdout_str}\n'.format(home_stdout=home_stdout,\
systemd_stdout_str=systemd_stdout)
return logger
