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