def readConf(self): """ Read web section of the imaging plugin configuration file """ PluginConfig.readConf(self) if not self.disabled: ImagingDatabaseConfig.setup(self, self.conffile) if self.has_section("web"): for option in self.options("web"): # option variable is lowercase setattr(self, option, self.get("web", option)) setattr(self, "network", "resolv_order") if not type(self.resolv_order) == type([]): self.resolv_order = self.resolv_order.split(' ') if self.has_option("network", "preferred_network"): self.preferred_network = self.get("network", "preferred_network") else : self.preferred_network = '' try: self.purge_interval = self.get('main', 'purge_interval') except (NoOptionError, NoSectionError): self.purge_interval = '23 0 * * 0'
def readConf(self): logger = logging.getLogger() PluginConfig.readConf(self) try: self.vDomainSupport = self.getboolean("main", "vDomainSupport") except: pass if self.vDomainSupport: self.vDomainDN = self.get("main", "vDomainDN") try: self.vAliasesSupport = self.getboolean("main", "vAliasesSupport") except: pass if self.vAliasesSupport: self.vAliasesDN = self.get("main", "vAliasesDN") try: self.zarafa = self.getboolean("main", "zarafa") except NoOptionError: pass try: self.attrs = dict(self.items("mapping")) except NoSectionError: self.attrs = {} attrs = ["mailalias", "maildrop", "mailenable", "mailbox", "mailuserquota", "mailhost"] # validate attribute mapping for attr, val in self.attrs.copy().items(): if not attr in attrs: del self.attrs[attr] logger.error("Can't map attribute %s. Attribute not supported." % attr) # add all other attributes for attr in attrs: if not attr in self.attrs: self.attrs[attr] = attr
def readConf(self): """ Read web section of the imaging plugin configuration file """ PluginConfig.readConf(self) if not self.disabled: ImagingDatabaseConfig.setup(self, self.conffile) if self.has_section("web"): for option in self.options("web"): # option variable is lowercase setattr(self, option, self.get("web", option)) setattr(self, "network", "resolv_order") if not type(self.resolv_order) == type([]): self.resolv_order = self.resolv_order.split(' ') if self.has_option("network", "preferred_network"): self.preferred_network = self.get("network", "preferred_network") else: self.preferred_network = '' try: self.purge_interval = self.get('main', 'purge_interval') except (NoOptionError, NoSectionError): self.purge_interval = '23 0 * * 0'
def readConf(self): PluginConfig.readConf(self) DatabaseConfig.setup(self, self.conffile) #update_command try: self.update_commands_cron = self.get( 'main', 'update_commands_cron') except (NoOptionError, NoSectionError): self.update_commands_cron = '10 12 * * *' try: self.enable_update_commands = int( self.get('main', 'enable_update_commands')) except: self.enable_update_commands = 1 #add_update_description try: self.add_update_description_cron = self.get( 'main', 'add_update_description_cron') except (NoOptionError, NoSectionError): self.add_update_description_cron = '0 */1 * * *' try: self.enable_update_description = int( self.get('main', 'enable_update_description')) except: self.enable_update_description = 1
def readConf(self): PluginConfig.readConf(self) try: self.samba_prefix = self.get("main", "sambaPrefix") except NoOptionError: pass try: self.conf_file = self.get("main", "sambaConfFile") except NoOptionError: pass try: self.db_dir = self.get("main", "sambaDBDir") except NoOptionError: pass self.defaultSharesPath = self.get("main", "defaultSharesPath") try: listSharePaths = self.get("main", "authorizedSharePaths") self.authorizedSharePaths = listSharePaths.replace(' ', '').split(',') except NoOptionError: self.authorizedSharePaths = [self.defaultSharesPath]
def setDefault(self): PluginConfig.setDefault(self) self.authmethod = "baseldap" self.provmethod = None self.computersmethod = "none" self.passwordscheme = "ssha" self.auditmethod = "none"
def readConf(self): PluginConfig.readConf(self) DatabaseConfig.setup(self, self.conffile) #update_command try: self.update_commands_cron = self.get('main', 'update_commands_cron') except (NoOptionError, NoSectionError): self.update_commands_cron = '10 12 * * *' try: self.enable_update_commands = int( self.get('main', 'enable_update_commands')) except: self.enable_update_commands = 1 #add_update_description try: self.add_update_description_cron = self.get( 'main', 'add_update_description_cron') except (NoOptionError, NoSectionError): self.add_update_description_cron = '0 */1 * * *' try: self.enable_update_description = int( self.get('main', 'enable_update_description')) except: self.enable_update_description = 1
def readConf(self): PluginConfig.readConf(self) self.baseComputersDN = self.get("main", "baseComputersDN") # Handle deprecated config option and correct the NoOptionError exception to the new option try: if self.has_option("main", "defaultSharesPath"): self.defaultSharesPath = self.get("main", "defaultSharesPath") else: self.defaultSharesPath = self.get("main", "sharespath") except ConfigParser.NoOptionError: raise ConfigParser.NoOptionError("defaultSharesPath", "main") try: self.samba_conf_file = self.get("main", "sambaConfFile") except: pass try: self.samba_init_script = self.get("main", "sambaInitScript") except: pass try: self.av_so = self.get("main", "sambaAvSo") except: pass try: listSharePaths = self.get("main", "authorizedSharePaths") self.authorizedSharePaths = listSharePaths.replace(' ', '').split(',') except: self.authorizedSharePaths = [self.defaultSharesPath]
def readConf(self): logger = logging.getLogger() PluginConfig.readConf(self) try: self.vDomainSupport = self.getboolean("main", "vDomainSupport") except: pass if self.vDomainSupport: self.vDomainDN = self.get("main", "vDomainDN") try: self.vAliasesSupport = self.getboolean("main", "vAliasesSupport") except: pass if self.vAliasesSupport: self.vAliasesDN = self.get("main", "vAliasesDN") try: self.zarafa = self.getboolean("main", "zarafa") except NoOptionError: pass try: self.attrs = dict(self.items("mapping")) except NoSectionError: self.attrs = {} attrs = ["mailalias", "maildrop", "mailenable", "mailbox", "mailuserquota", "mailhost", "mailproxy"] # validate attribute mapping for attr, val in self.attrs.copy().items(): if not attr in attrs: del self.attrs[attr] logger.error("Can't map attribute %s. Attribute not supported." % attr) # add all other attributes for attr in attrs: if not attr in self.attrs: self.attrs[attr] = attr
def setDefault(self): PluginConfig.setDefault(self) self.squidReload = "/etc/init.d/squid reload" self.squidUser = "******" self.squidGroup = "proxy" self.sgBinary = "/usr/bin/squidGuard" self.sgBlacklist = "/var/lib/squidguard/db/bad.destdomainlist"
def setDefault(self): """ Set default values """ PluginConfig.setDefault(self) self.dbsslenable = False self.dbpoolrecycle = 60 self.dbpoolsize = 5
def __init__(self, name="samba4"): # Default values self.samba_prefix = "/usr" self.conf_file = "/etc/samba/smb.conf" self.db_dir = "/var/lib/samba" self.defaultSharesPath = "/home/samba" self.authorizedSharePaths = [self.defaultSharesPath] PluginConfig.__init__(self, name)
def readConf(self): """ Read the configuration file using the ConfigParser API. The PluginConfig.readConf reads the "disable" option of the "main" section. """ PluginConfig.readConf(self) self.disable = self.getboolean("main", "disable")
def setDefault(self): """ Set good default for the module if a parameter is missing the configuration file. This function is called in the class constructor, so what you set here will be overwritten by the readConf method. """ PluginConfig.setDefault(self)
def readConf(self): """ Read the module configuration """ PluginConfig.readConf(self) # API Package if self.has_option("user_package_api", "server"): self.upaa_server = self.get("user_package_api", "server") if self.has_option("user_package_api", "port"): self.upaa_port = self.get("user_package_api", "port") if self.has_option("user_package_api", "mountpoint"): self.upaa_mountpoint = self.get("user_package_api", "mountpoint") if self.has_option("user_package_api", "username"): if not isTwistedEnoughForLoginPass(): logging.getLogger().warning( "your version of twisted is not high enough to use login (user_package_api/username)" ) self.upaa_username = "" else: self.upaa_username = self.get("user_package_api", "username") if self.has_option("user_package_api", "password"): if not isTwistedEnoughForLoginPass(): logging.getLogger().warning( "your version of twisted is not high enough to use password (user_package_api/password)" ) self.upaa_password = "" else: self.upaa_password = self.get("user_package_api", "password") if self.has_option("user_package_api", "tmp_dir"): self.tmp_dir = self.get("user_package_api", "tmp_dir") if self.has_option("user_package_api", "enablessl"): self.upaa_enablessl = self.getboolean("user_package_api", "enablessl") if self.upaa_enablessl: if self.has_option("user_package_api", "verifypeer"): self.upaa_verifypeer = self.getboolean("user_package_api", "verifypeer") if self.upaa_verifypeer: # we need twisted.internet.ssl.Certificate to activate certs if self.has_option("user_package_api", "cacert"): self.upaa_cacert = self.get("user_package_api", "cacert") if self.has_option("user_package_api", "localcert"): self.upaa_localcert = self.get("user_package_api", "localcert") if not os.path.isfile(self.upaa_localcert): raise Exception('can\'t read SSL key "%s"' % (self.upaa_localcert)) if not os.path.isfile(self.upaa_cacert): raise Exception('can\'t read SSL certificate "%s"' % (self.upaa_cacert)) import twisted.internet.ssl if not hasattr(twisted.internet.ssl, "Certificate"): raise Exception( 'I need at least Python Twisted 2.5 to handle peer checking' )
def readConf(self): PluginConfig.readConf(self) self.pid_path = self.safe_get("main", "pid_path", self.pid_path) self.ssh_path = self.safe_get("main", "ssh_path", self.ssh_path) self.support_url = self.safe_get("main", "support_url", self.support_url) self.support_user = self.safe_get("main", "support_user", self.support_user) self.identify_file = self.safe_get("main", "identify_file", self.identify_file) if not os.path.exists(self.identify_file): logging.getLogger().warn("File %s don't exists!" % self.identify_file) self.url = "%s@%s" % (self.support_user, self.support_url) self.check_pid_delay = int(self.safe_get("main", "check_pid_delay", self.check_pid_delay)) self.session_timeout = int(self.safe_get("main", "session_timeout", self.session_timeout)) if not os.path.exists(self.install_id_path): logging.getLogger().warn("File %s don't exists!" % self.install_id_path) else: with open(self.install_id_path, "r") as f: content = f.readlines() if len(content) > 0: self.install_uuid = content[0].strip() self.license_server_url = self.safe_get("main", "license_server_url", self.license_server_url) self.cron_search_for_updates = self.safe_get("main", "cron_search_for_updates", self.cron_search_for_updates) self._cron_randomize() self.license_tmp_file = self.safe_get("main", "license_tmp_file", self.license_tmp_file) self.country = self.safe_get("main", "country", self.country)
def readConf(self): """ Read the module configuration """ PluginConfig.readConf(self) self.disable = self.getboolean("main", "disable") Pulse2DatabaseConfig.setup(self, self.conffile) if self.has_option("main", "location"): self.location = self.get("main", "location")
def readConf(self): """ Read the configuration file using the ConfigParser API. The PluginConfig.readConf reads the "disable" option of the "main" section. """ PluginConfig.readConf(self) BackuppcDatabaseConfig.setup(self, self.conffile) self.disable = self.getboolean("main", "disable") self.tempdir = self.get("main", "tempdir")
def readConf(self): PluginConfig.readConf(self) self.journalctl_path = self.get('main', 'journalctl_path') self.services = {} for plugin, services in self.items('plugins'): self.services[plugin] = services.split(",") try: self.blacklist = self.get('main', 'blacklist').split(',') except: self.blacklist = []
def readConf(self): """ Read web section of the imaging plugin configuration file """ PluginConfig.readConf(self) if not self.disabled: ImagingDatabaseConfig.setup(self, self.conffile) if self.has_section("web"): for option in self.options("web"): # option variable is lowercase setattr(self, option, self.get("web", option))
def setDefault(self): """ Set default for the module if a parameter is missing from the configuration file. This function is called in the class constructor, so what you set here will be overwritten by the readConf method. """ PluginConfig.setDefault(self) self.showinfomaster = False self.showplugins = False self.debugmode = "NOTSET" self.ordreallagent = False
def readConf(self): PluginConfig.readConf(self) try: self.sgBinary = self.get("squidguard", "path") except (NoSectionError, NoOptionError): pass try: self.sgBlacklist = self.get("squidguard", "blacklist") except (NoSectionError, NoOptionError): pass try: self.squidReload = self.get("squidguard", "scriptReload") except (NoSectionError, NoOptionError): pass try: self.squidUser = self.get("squidguard", "user") except (NoSectionError, NoOptionError): pass try: self.squidGroup = self.get("squidguard", "group") except (NoSectionError, NoOptionError): pass
def readConf(self): PluginConfig.readConf(self) try: self.diskquotaenable = self.getboolean("diskquota", "enable") except: pass try: self.networkquotaenable = self.getboolean("networkquota", "enable") except: pass self.devicemap = self.get("diskquota", "devicemap").split(',') self.inodesperblock = self.getfloat("diskquota", "inodesperblock") self.softquotablocks = self.getfloat("diskquota", "softquotablocks") self.softquotainodes = self.getfloat("diskquota", "softquotainodes") self.setquotascript = self.get("diskquota", "setquotascript") self.delquotascript = self.get("diskquota", "delquotascript") self.runquotascript = self.get("diskquota", "runquotascript") self.networkmap = self.get("networkquota", "networkmap").split(',')
def readConf(self): PluginConfig.readConf(self) LDAPConnectionConfig.readLDAPConf(self, "ldap") AuditConfig.readAuditConf(self, "audit") # Selected authentication method try: self.authmethod = self.get("authentication", "method") except: pass # Selected provisioning method try: self.provmethod = self.get("provisioning", "method") except: pass # Selected computer management method try: self.computersmethod = self.get("computers", "method") except: pass # User password scheme try: self.passwordscheme = self.get("ldap", "passwordscheme") except: pass self.baseDN = self.getdn('ldap', 'baseDN') self.baseUsersDN = self.getdn('ldap', 'baseUsersDN') # Where LDAP computer objects are stored # For now we ignore if the option does not exist, because it breaks # all existing intallations try: self.baseComputersDN = self.get('ldap', 'baseComputersDN') except: pass self.backuptools = self.get("backup-tools", "path") self.backupdir = self.get("backup-tools", "destpath") self.username = self.getdn("ldap", "rootName") self.password = self.getpassword("ldap", "password") ######################################################### self.leak_memorytime = 3600 if self.has_option("memoryinfo", "time"): self.leak_memorytime = self.getint("memoryinfo", "time") self.fileoutresult = "/tmp/leak_memory.data" if self.has_option("memoryinfo", "outfile"): self.fileoutresult = self.get("memoryinfo", "outfile") self.leak_memory_disable = True if self.has_option("memoryinfo", "disable"): self.leak_memory_disable = self.getboolean("memoryinfo", "disable")
def readConf(self): PluginConfig.readConf(self) try: self.host = self.get("ldap", "host") except (NoSectionError, NoOptionError): self.host = "127.0.0.1" try: self.root = self.get("ldap", "rootName") except (NoSectionError, NoOptionError): self.root = "uid=LDAP Admin, ou=System Accounts, dc=localdomain" self.passw = self.get("ldap", "password") try: self.userdn = self.get("ldap", "baseUsersDN") except (NoSectionError, NoOptionError): self.userdn = "ou=People, dc=localdomain" try: self.groupdn = self.get("ldap", "baseGroupsDN") except (NoSectionError, NoOptionError): self.groupdn = "ou=Group, dc=localdomain"
def readConf(self): """ Read the module configuration """ PluginConfig.readConf(self) # API Package if self.has_option("user_package_api", "server"): self.upaa_server = self.get("user_package_api", "server") if self.has_option("user_package_api", "port"): self.upaa_port = self.get("user_package_api", "port") if self.has_option("user_package_api", "mountpoint"): self.upaa_mountpoint = self.get("user_package_api", "mountpoint") if self.has_option("user_package_api", "username"): if not isTwistedEnoughForLoginPass(): logging.getLogger().warning("your version of twisted is not high enough to use login (user_package_api/username)") self.upaa_username = "" else: self.upaa_username = self.get("user_package_api", "username") if self.has_option("user_package_api", "password"): if not isTwistedEnoughForLoginPass(): logging.getLogger().warning("your version of twisted is not high enough to use password (user_package_api/password)") self.upaa_password = "" else: self.upaa_password = self.get("user_package_api", "password") if self.has_option("user_package_api", "tmp_dir"): self.tmp_dir = self.get("user_package_api", "tmp_dir") if self.has_option("user_package_api", "enablessl"): self.upaa_enablessl = self.getboolean("user_package_api", "enablessl") if self.upaa_enablessl: if self.has_option("user_package_api", "verifypeer"): self.upaa_verifypeer = self.getboolean("user_package_api", "verifypeer") if self.upaa_verifypeer: # we need twisted.internet.ssl.Certificate to activate certs if self.has_option("user_package_api", "cacert"): self.upaa_cacert = self.get("user_package_api", "cacert") if self.has_option("user_package_api", "localcert"): self.upaa_localcert = self.get("user_package_api", "localcert") if not os.path.isfile(self.upaa_localcert): raise Exception('can\'t read SSL key "%s"' % (self.upaa_localcert)) if not os.path.isfile(self.upaa_cacert): raise Exception('can\'t read SSL certificate "%s"' % (self.upaa_cacert)) import twisted.internet.ssl if not hasattr(twisted.internet.ssl, "Certificate"): raise Exception('I need at least Python Twisted 2.5 to handle peer checking') # Appstream settings if self.has_option("appstream", "url"): self.appstream_url = self.get("appstream", "url")
def readConf(self): PluginConfig.readConf(self) self.pid_path = self.safe_get("main", "pid_path", self.pid_path) self.ssh_path = self.safe_get("main", "ssh_path", self.ssh_path) self.support_url = self.safe_get("main", "support_url", self.support_url) self.support_user = self.safe_get("main", "support_user", self.support_user) self.identify_file = self.safe_get("main", "identify_file", self.identify_file) if not os.path.exists(self.identify_file): logging.getLogger().warn("File %s don't exists!" % self.identify_file) self.url = "%s@%s" % (self.support_user, self.support_url) self.check_pid_delay = int( self.safe_get("main", "check_pid_delay", self.check_pid_delay)) self.session_timeout = int( self.safe_get("main", "session_timeout", self.session_timeout)) if not os.path.exists(self.install_id_path): logging.getLogger().warn("File %s don't exists!" % self.install_id_path) else: with open(self.install_id_path, "r") as f: content = f.readlines() if len(content) > 0: self.install_uuid = content[0].strip() self.license_server_url = self.safe_get("main", "license_server_url", self.license_server_url) self.cron_search_for_updates = self.safe_get( "main", "cron_search_for_updates", self.cron_search_for_updates) self._cron_randomize() self.license_tmp_file = self.safe_get("main", "license_tmp_file", self.license_tmp_file) self.country = self.safe_get("main", "country", self.country) self.collector_script_path = self.safe_get("main", "collector_script_path", self.collector_script_path) self.collector_archive_path = self.safe_get( "main", "collector_archive_path", self.collector_archive_path)
def readConf(self): PluginConfig.readConf(self) DatabaseConfig.setup(self, self.conffile) try: self.historization = self.get('data', 'historization') except (NoOptionError, NoSectionError): self.historization = '15 2 * * *' try: self.indicators = self.get('data', 'indicators') except (NoOptionError, NoSectionError): self.indicators = 'indicators.xml' try: self.updateTemplate = self.get('data', 'updateTemplate') except (NoOptionError, NoSectionError): self.updateTemplate = 'default.xml'
def readConf(self): PluginConfig.readConf(self) # DHCP conf try: self.dhcpEnable = self.getboolean("dhcp", "enable") except: self.dhcpEnable = True self.dhcpDN = self.getdn("dhcp", "dn") self.dhcpPidFile = self.get("dhcp", "pidfile") self.dhcpInit = self.get("dhcp", "init") self.dhcpLogFile = self.get("dhcp", "logfile") self.dhcpLeases = self.get("dhcp", "leases") try: self.dhcpHostname = self.get("dhcp", "hostname") except NoOptionError: self.dhcpHostname = socket.gethostname() # DNS conf try: self.dnsEnable = self.getboolean("dns", "enable") except: self.dnsEnable = True try: self.dnsType = self.get("dns", "type") except NoOptionError: self.dnsType = "bind" self.dnsDN = self.getdn("dns", "dn") self.dnsPidFile = self.get("dns", "pidfile") self.dnsInit = self.get("dns", "init") self.dnsLogFile = self.get("dns", "logfile") if self.dnsType == "bind": self.bindRootPath = self.get("dns", "bindroot") self.bindGroup = self.get("dns", "bindgroup") self.bindLdap = os.path.join(self.bindRootPath, "named.conf.ldap") self.bindLdapDir = os.path.join(self.bindRootPath, "named.ldap") try: self.bindLdapChrootConfPath = os.path.join( self.get("dns", "bindchrootconfpath"), "named.ldap") except NoOptionError: self.bindLdapChrootConfPath = self.bindLdapDir try: self.dnsReader = self.getdn("dns", "dnsreader") except NoOptionError: pass try: self.dnsReaderPassword = self.getpassword("dns", "dnsreaderpassword") except NoOptionError: pass
def readConf(self): PluginConfig.readConf(self) self.external_zones_names = self.get('main', 'external_zones_names').split(" ") self.internal_zones_names = self.get('main', 'internal_zones_names').split(" ") try: self.path = self.get('main', 'path') except NoOptionError: self.path = '/etc/shorewall' try: self.macros_path = self.get('main', 'macros_path') except NoOptionError: self.macros_path = '/usr/share/shorewall' try: self.macros_list = self.get('main', 'macros_list').replace(' ', '').split(',') except NoOptionError: self.macros_list = []
def readConf(self): PluginConfig.readConf(self) # DHCP conf try: self.dhcpEnable = self.getboolean("dhcp", "enable") except: self.dhcpEnable = True self.dhcpDN = self.getdn("dhcp", "dn") self.dhcpPidFile = self.get("dhcp", "pidfile") self.dhcpInit = self.get("dhcp", "init") self.dhcpLogFile = self.get("dhcp", "logfile") self.dhcpLeases = self.get("dhcp", "leases") try: self.dhcpHostname = self.get("dhcp", "hostname") except NoOptionError: self.dhcpHostname = socket.gethostname() # DNS conf try: self.dnsEnable = self.getboolean("dns", "enable") except: self.dnsEnable = True try: self.dnsType = self.get("dns", "type") except NoOptionError: self.dnsType = "bind" self.dnsDN = self.getdn("dns", "dn") self.dnsPidFile = self.get("dns", "pidfile") self.dnsInit = self.get("dns", "init") self.dnsLogFile = self.get("dns", "logfile") if self.dnsType == "bind": self.bindRootPath = self.get("dns", "bindroot") self.bindGroup = self.get("dns", "bindgroup") self.bindLdap = os.path.join(self.bindRootPath, "named.conf.ldap") self.bindLdapDir = os.path.join(self.bindRootPath, "named.ldap") try: self.bindLdapChrootConfPath = os.path.join(self.get("dns", "bindchrootconfpath"), "named.ldap") except NoOptionError: self.bindLdapChrootConfPath = self.bindLdapDir try: self.dnsReader = self.getdn("dns", "dnsreader") except NoOptionError: pass try: self.dnsReaderPassword = self.getpassword("dns", "dnsreaderpassword") except NoOptionError: pass
def readConf(self): """ Read the configuration file using the ConfigParser API. """ PluginConfig.readConf(self) # Read LDAP Password Policy configuration self.ppolicyAttributes = {} self.ppolicydn = self.get('ppolicy', 'ppolicyDN') self.ppolicydefault = self.get('ppolicy', 'ppolicyDefault') self.ppolicydefaultdn = "cn=" + self.ppolicydefault + "," + self.ppolicydn for attribute in self.items('ppolicyattributes'): if attribute[1] == 'True': self.ppolicyAttributes[attribute[0]] = True elif attribute[1] == 'False': self.ppolicyAttributes[attribute[0]] = False else: self.ppolicyAttributes[attribute[0]] = attribute[1]
def readConf(self): """ Read the configuration file using the ConfigParser API. """ PluginConfig.readConf(self) # Read LDAP Password Policy configuration self.ppolicyAttributes = {} self.ppolicydn = self.get("ppolicy", "ppolicyDN") self.ppolicydefault = self.get("ppolicy", "ppolicyDefault") self.ppolicydefaultdn = "cn=" + self.ppolicydefault + "," + self.ppolicydn for attribute in self.items("ppolicyattributes"): if attribute[1] == "True": self.ppolicyAttributes[attribute[0]] = True elif attribute[1] == "False": self.ppolicyAttributes[attribute[0]] = False else: self.ppolicyAttributes[attribute[0]] = attribute[1]
def readConf(self): PluginConfig.readConf(self) self.external_zones_names = self.get('main', 'external_zones_names') self.internal_zones_names = self.get('main', 'internal_zones_names') try: self.path = self.get('main', 'path') except NoOptionError: self.path = '/etc/shorewall' try: self.macros_path = self.get('main', 'macros_path') except NoOptionError: self.macros_path = '/usr/share/shorewall' try: self.macros_list = self.get('main', 'macros_list').replace(' ', '').split(',') except NoOptionError: self.macros_list = []
def readConf(self): """ Read web section of the imaging plugin configuration file """ PluginConfig.readConf(self) if not self.disabled: ImagingDatabaseConfig.setup(self, self.conffile) if self.has_section("web"): for i in ( "date_fmt", "default_protocol", "default_menu_name", "default_timeout", "default_background_uri", "default_message", ): full_name = "web_def_%s" % i if self.has_option("web", full_name): setattr(self, full_name, self.get("web", full_name))
def readConf(self): PluginConfig.readConf(self) try: self.samba_prefix = self.get("main", "sambaPrefix") except: pass try: self.conf_file = self.get("main", "sambaConfFile") except: pass try: self.init_script = self.get("main", "sambaInitScript") except: pass self.defaultSharesPath = self.get("main", "defaultSharesPath") try: listSharePaths = self.get("main", "authorizedSharePaths") self.authorizedSharePaths = listSharePaths.replace(' ','').split(',') except: self.authorizedSharePaths = [self.defaultSharesPath]
def setDefault(self): PluginConfig.setDefault(self) self.pid_path = "/var/run/pulse2/ssh_support" self.ssh_path = "/usr/bin/ssh" self.support_url = "rssh.mandriva.com" self.support_user = "******" self.identify_file = "/etc/mmc/plugins/support/id_rsa" self.check_pid_delay = 2 self.session_timeout = 7200 self.license_server_url = "https://serviceplace.mandriva.com/api/v1/support" self.install_id_path = "/etc/pulse-licensing/installation_id" self.install_uuid = None self.cron_search_for_updates = "0 6 * * *" self.license_tmp_file = "/var/lib/mmc/pulse_license_info" self.country = "FR"
def readConf(self): PluginConfig.readConf(self) try: self.squidBinary = self.get("squid", "squidBinary") except (NoSectionError, NoOptionError): self.squidBinary = "/usr/sbin/squid" try: self.squidRules = self.get("squid", "squidRules") except (NoSectionError, NoOptionError): self.squidRules = "/etc/squid/rules" try: self.blacklist = self.get("squid", "blacklist") except (NoSectionError, NoOptionError): self.blacklist = os.path.join(self.squidRules, "blacklist.txt") try: self.whitelist = self.get("squid", "whitelist") except (NoSectionError, NoOptionError): self.whitelist = os.path.join(self.squidRules, "whitelist.txt") try: self.blacklist_ext = self.get("squid", "blacklist_ext") except (NoSectionError, NoOptionError): self.blacklist_ext = os.path.join(self.squidRules, "blacklist_ext.txt") try: self.timeranges = self.get("squid", "timeranges") except (NoSectionError, NoOptionError): self.timeranges = os.path.join(self.squidRules, "timeranges.txt") try: self.machines = self.get("squid", "machines") except (NoSectionError, NoOptionError): self.machines = os.path.join(self.squidRules, "machines.txt") try: self.sargBinary = self.get("squid", "sargBinary") except (NoSectionError, NoOptionError): self.sargBinary = "/usr/sbin/sarg" try: self.squidInit = self.get("squid", "squidInit") except (NoSectionError, NoOptionError): self.squidInit = "/etc/init.d/squid" try: self.squidPid = self.get("squid", "squidPid") except (NoSectionError, NoOptionError): self.squidPid = "/var/run/squid.pid" try: self.groupMaster = self.get("squid", "groupMaster") except (NoSectionError, NoOptionError): self.groupMaster = "InternetMaster" self.groupMasterDesc = "Full Internet access" try: self.groupFiltered = self.get("squid", "groupFiltered") except (NoSectionError, NoOptionError): self.groupFiltered = "InternetFiltered" self.groupFilteredDesc = "Filtered Internet access"
def readConf(self): """ Read web section of the imaging plugin configuration file """ PluginConfig.readConf(self) if not self.disabled: ImagingDatabaseConfig.setup(self, self.conffile) if self.has_section("web"): for option in self.options("web"): # option variable is lowercase setattr(self, option, self.get("web", option)) setattr(self, "network", "resolv_order") if not type(self.resolv_order) == type([]): self.resolv_order = self.resolv_order.split(' ') pnp = PreferredNetworkParser(None, None) if self.has_option("network", "preferred_network"): self.preferred_network = pnp.parse(self.get("network", "preferred_network")) else : self.preferred_network = pnp.get_default()
def readConf(self): PluginConfig.readConf(self) LDAPConnectionConfig.readLDAPConf(self, "ldap") AuditConfig.readAuditConf(self, "audit") # Selected authentication method try: self.authmethod = self.get("authentication", "method") except: pass # Selected provisioning method try: self.provmethod = self.get("provisioning", "method") except: pass # Selected computer management method try: self.computersmethod = self.get("computers", "method") except: pass # User password scheme try: self.passwordscheme = self.get("ldap", "passwordscheme") except: pass self.baseDN = self.getdn('ldap', 'baseDN') self.baseUsersDN = self.getdn('ldap', 'baseUsersDN') # Where LDAP computer objects are stored # For now we ignore if the option does not exist, because it breaks # all existing intallations try: self.baseComputersDN = self.get('ldap', 'baseComputersDN') except: pass self.backuptools = self.get("backup-tools", "path") self.backupdir = self.get("backup-tools", "destpath") self.username = self.getdn("ldap", "rootName") self.password = self.getpassword("ldap", "password")
def setDefault(self): PluginConfig.setDefault(self) self.pid_path = "/var/run/pulse2/ssh_support" self.ssh_path = "/usr/bin/ssh" self.support_url = "" self.support_user = "******" self.identify_file = "/etc/mmc/plugins/support/id_rsa" self.check_pid_delay = 2 self.session_timeout = 7200 self.license_server_url = "" self.install_id_path = "/etc/pulse-licensing/installation_id" self.install_uuid = None self.cron_search_for_updates = "0 6 * * *" self.license_tmp_file = "/var/lib/mmc/pulse_license_info" self.country = "FR" self.collector_script_path = "/usr/sbin/pulse2-collect-info" self.collector_archive_path = "/tmp/pulse2-collect-info.7z"
def setDefault(self): PluginConfig.setDefault(self) self.pid_path = "/var/run/pulse2/ssh_support" self.ssh_path = "/usr/bin/ssh" self.support_url = "rssh.mandriva.com" self.support_user = "******" self.identify_file = "/etc/mmc/plugins/support/id_rsa" self.check_pid_delay = 2 self.session_timeout = 7200 self.license_server_url = "https://serviceplace.mandriva.com/api/v1/support" self.install_id_path = "/etc/pulse-licensing/installation_id" self.install_uuid = None self.cron_search_for_updates = "0 6 * * *" self.license_tmp_file = "/var/lib/mmc/pulse_license_info" self.country = "FR" self.collector_script_path = "/usr/sbin/pulse2-collect-info" self.collector_archive_path = "/tmp/pulse2-collect-info.7z"
def readConf(self): """ Read web section of the imaging plugin configuration file """ PluginConfig.readConf(self) if not self.disabled: ImagingDatabaseConfig.setup(self, self.conffile) if self.has_section("web"): for option in self.options("web"): # option variable is lowercase setattr(self, option, self.get("web", option)) setattr(self, "network", "resolv_order") if not type(self.resolv_order) == type([]): self.resolv_order = self.resolv_order.split(' ') pnp = PreferredNetworkParser(None, None) if self.has_option("network", "preferred_network"): self.preferred_network = pnp.parse( self.get("network", "preferred_network")) else: self.preferred_network = pnp.get_default()
def readConf(self): """ Read the configuration file using the ConfigParser API. The PluginConfig.readConf reads the "disable" option of the "main" section. """ PluginConfig.readConf(self) MonitoringDatabaseConfig.setup(self, self.conffile) try: self.monitoring_uri = self.get("webservices", "monitoring_url") except: self.monitoring_uri = "" # http://localhost/zabbix/ try: self.monitoring_username = self.get("webservices", "monitoring_username") except: self.monitoring_username = "" # Admin try: self.monitoring_password = self.get("webservices", "monitoring_password") except: self.monitoring_password = "" # zabbix try: self.nmap_enable = self.get("data", "nmap_enable") except: self.nmap_enable = "" # 0 try: self.nmap_task_time = self.get("data", "nmap_task_time") except: self.nmap_task_time = "" # 15 22 * * * try: self.nmap_network = self.get("data", "nmap_network") except: self.nmap_task_time = "" # "192.168.0.0/24"
def readConf(self): PluginConfig.readConf(self) DatabaseConfig.setup(self, self.conffile) report_img_path = 'file:///etc/mmc/plugins/report/img/' try: self.historization = self.get('data', 'historization') except (NoOptionError, NoSectionError): self.historization = '15 22 * * *' try: self.indicators = self.get('data', 'indicators') except (NoOptionError, NoSectionError): self.indicators = 'indicators.xml' try: self.reportTemplate = self.get('data', 'reportTemplate') except (NoOptionError, NoSectionError): self.reportTemplate = 'default.xml' try: self.reportCSS = os.path.join(reportconfdir, 'css', self.get('data', 'reportCSS')) except (NoOptionError, NoSectionError, OSError): self.reportCSS = os.path.join(reportconfdir, 'css', 'style.css') try: self.graphCSS = [os.path.join(reportconfdir, 'css', f) for f in self.get('data', 'graphCSS').replace(' ', '').split(',')] except (NoOptionError, NoSectionError, OSError): self.graphCSS = [] try: self.company = self.get('pdfvars', 'company') except (NoOptionError, NoSectionError): self.company = 'Company' try: self.company_logo_path = report_img_path + self.get('pdfvars', 'company_logo_path') except (NoOptionError, NoSectionError): self.company_logo_path = report_img_path + 'mandriva.png' try: self.pulse_logo_path = report_img_path + self.get('pdfvars', 'pulse_logo_path') except (NoOptionError, NoSectionError): self.pulse_logo_path = report_img_path + 'pulse.png'
def setDefault(self): PluginConfig.setDefault(self) self.diskquotaenable = True self.networkquotaenable = False
def __init__(self, name='report', conffile=None): if not hasattr(self, 'initdone'): PluginConfig.__init__(self, name, conffile) DatabaseConfig.__init__(self) self.initdone = True