Пример #1
0
def getSavedProfileNames():
    """
    Reads in the names of the saved profiles from the getwatchlist.conf
    files in default and local and returns them as a list.
    """
    profileNames = []

    # First the defaults
    parser = ConfigParser()
    parser.optionxform = str
    parser.read(getDefaultConfPath())
    profileNames = parser.sections()

    # Now the locals
    parser = ConfigParser()
    parser.optionxform = str
    parser.read(getLocalConfPath())
    localProfileNames = parser.sections()

    # Now create one list
    for profile in localProfileNames:
        if not profile in profileNames:
            profileNames.append(profile)

    return profileNames
Пример #2
0
def load_default_env(auppath=DEFAULT_AUPTIMIZER_PATH, log=logger, use_default=True):
    """Load default environment variables for aup.
    Search recursively to upper folder

    :param auppath: aup environment folder, contains `env.ini` file
    :type auppath: str
    :param log: logger obj to trace where the function is called, default is aup.utils
    :type log: logging.Logger
    :param use_default: if auppath is empty, use user's home folder instead.
    :type use_default: bool
    :return: key-value of parameters
    :rtype: dict
    """
    if not path.isfile(path.join(auppath, "env.ini")):
        if use_default:
            auppath = path.join(path.expanduser("~"), ".aup")
            log.warning("Use default env at %s" % auppath)
            if not path.isfile(path.join(auppath, "env.ini")):  # pragma: no cover
                raise Exception("Failed to find env.ini")
        else:
            raise ValueError("Auptimizer folder %s is missing" % auppath)
    log.info("Auptimizer environment at %s", auppath)
    config = ConfigParser()
    config.optionxform = str
    config.read(path.join(auppath, "env.ini"))
    return {i[0]: i[1] for i in config.items("Auptimizer")}
Пример #3
0
def main(env, cpu, gpu, node, aws, user, overwrite, log):  # pragma: no cover
    """ Create environment based on env file for Auptimizer
    \b\n
    Copyright (C) 2018  LG Electronics Inc.
    \b\n
    GPL-3.0 License. This program comes with ABSOLUTELY NO WARRANTY;
    \b\n
    Arguments:
        env {str}: Auptimizer config folder path. Default to create at `./.aup/`.  Leave empty to create a new one.
                   Or use the path of the filename (env.ini) to load predefined values (also use --overwrite).

    \b
    Raises:
        Exception: If failed to load the existing Auptimizer configuration file.
    """
    coloredlogs.install(level=LOG_LEVEL[log],
                        fmt="%(levelname)s - %(message)s")

    user = get_default_username(user)
    config = ConfigParser()
    config.optionxform = str

    if env == ".":  # interactive
        config, cpu, gpu, node, aws, user, overwrite = \
            interactive_setup(env, config, cpu, gpu, node, aws, user, overwrite)
    else:
        try:
            if not os.path.isfile(env):
                logger.info("Load default env.ini file.")
                env = os.path.join(env, "env.ini")
            config.read(env)
        except Exception as e:
            logger.fatal("failed to read %s", env)
            raise e
    setup(config, cpu, gpu, node, aws, user, overwrite, log)
Пример #4
0
def loadKeysConfig(path=None):
	"""Load keys config file.

	If path is ``None``, a file named :any:`DEFAULT_KEYS_FILE` will be looked for in the config
	directory.

	:param path: path of the keyboard configuration file
	"""

	if path is None:
		path = getConfigFilePath(DEFAULT_KEYS_FILE)

	cfg = ConfigParser()
	cfg.optionxform = str
	cfg.read([path])

	for category in cfg.sections():
		for actionName in cfg.options(category):
			keystr = cfg.get(category, actionName)

			context = Qt.WidgetShortcut
			if keystr.startswith('widget:'):
				keystr = keystr.split(':', 1)[1]
			elif keystr.startswith('window:'):
				keystr = keystr.split(':', 1)[1]
				context = Qt.WindowShortcut
			elif keystr.startswith('children:'):
				keystr = keystr.split(':', 1)[1]
				context = Qt.WidgetWithChildrenShortcut
			elif keystr.startswith('application:'):
				keystr = keystr.split(':', 1)[1]
				context = Qt.ApplicationShortcut
			qks = QKeySequence(keystr)

			registerActionShortcut(category, actionName, qks, context)
Пример #5
0
def _setup_wrapper(filename, *args):
    config = ConfigParser()
    config.optionxform = str
    config.read(filename)
    try:
        setup.setup(config, *args)
    except OSError:
        print("Above 'No module named aup.setupdb' error can be ignored")
Пример #6
0
def getDefaultSavedProfileNames():
    """
    Reads in the names of the DEFAULT saved profiles from the getwatchlist.conf
    files in default and local and returns them as a list.
    """
    parser = ConfigParser()
    parser.optionxform = str
    parser.read(getDefaultConfPath())
    profileNames = parser.sections()

    return profileNames
Пример #7
0
def read_conf():
    config_file = "conf/settings.ini"
    parser = ConfigParser()
    parser.optionxform = str
    parser.read(config_file)
    for section_name in parser.sections():
        if section_name == 'MongoDBServer':
            mongodb = {x: y for x, y in parser.items(section_name)}
        if section_name == 'SolrServer':
            solr = {x: y for x, y in parser.items(section_name)}
    return mongodb, solr
Пример #8
0
def main():

    #############################################################################
    #
    # ARGUMENT PARSING
    #
    #############################################################################

    parser = OptionParser(usage)
    parser.add_option(
        "-e",
        "--example",
        default=False,
        dest="example",
        action="store_true",
        help="Create example config.ini and an example sourcefile")
    (opts, args) = parser.parse_args()

    if opts.example:
        with open("omega_config.ini", "w") as f:
            f.write(ExampleConfig)
        with open("omegascanslist.txt", "w") as f:
            f.write(ExampleSourceFile)

        print(
            "Example files \"omega_config.ini\" and \"omegascanslist.txt\" are created"
        )
        sys.exit(0)

    if len(args) != 1:
        parser.print_help()
        sys.exit("ERROR: Must provide one config.ini")

    cp = ConfigParser()
    cp.optionxform = str
    cp.readfp(open(args[0]))

    dag = OmegaScansDAG(cp)

    dag.write_sub_files()
    dag.write_dag()
    dag.write_script()

    #fix the sub and sh files
    #This is required because pipeline.py does not yet have the ability to add
    #a specific argument before all other arguments and options ('scan' in this case)
    fix_subfile(dag.submitFile)
    fix_scriptfile(cp.get('paths', 'basedir'), dag.get_dag_file(),
                   cp.get('omegapipe', 'executable'))

    print('Successfully created DAG file.')
    fulldagpath = os.path.join(cp.get('paths', 'basedir'), dag.get_dag_file())
    print('Now run condor_submit_dag %s\n' % (fulldagpath))
Пример #9
0
    def _load_config(no_cfgfile=False):
        config = ConfigParser()
        config.optionxform = str  # make it preserve case

        # defaults
        if not six.PY3:
            config.readfp(BytesIO(_DEFAULT_CONFIG))
        else:
            config.read_file(StringIO(_DEFAULT_CONFIG))

        # update from config file
        if not no_cfgfile:
            config.read(os.path.join(_STASH_ROOT, f) for f in _STASH_CONFIG_FILES)

        return config
Пример #10
0
    def _load_config(no_cfgfile=False):
        config = ConfigParser()
        config.optionxform = str  # make it preserve case

        # defaults
        if not six.PY3:
            config.readfp(BytesIO(_DEFAULT_CONFIG))
        else:
            config.read_file(StringIO(_DEFAULT_CONFIG))

        # update from config file
        if not no_cfgfile:
            config.read(os.path.join(_STASH_ROOT, f) for f in _STASH_CONFIG_FILES)

        return config
Пример #11
0
    def _install_desktop_file(self, destdir, prefix, activity_path):
        cp = ConfigParser()
        section = 'Desktop Entry'
        cp.add_section(section)
        cp.optionxform = str  # Allow CamelCase entries

        # Get it from the activity.info for the non-translated version
        info = ConfigParser()
        info_path = os.path.join(destdir, os.path.relpath(activity_path, '/'),
                                 'activity', 'activity.info')
        info.read(info_path)
        cp.set(section, 'Name', info.get('Activity', 'name'))
        if info.has_option('Activity', 'summary'):
            cp.set(section, 'Comment', info.get('Activity', 'summary'))

        for path in sorted(
                glob(
                    os.path.join(activity_path, 'locale', '*',
                                 'activity.linfo'))):
            locale = path.split(os.path.sep)[-2]
            info = ConfigParser()
            info.read(path)
            if info.has_option('Activity', 'name'):
                cp.set(section, 'Name[{}]'.format(locale),
                       info.get('Activity', 'name'))
            if info.has_option('Activity', 'summary'):
                cp.set(section, 'Comment[{}]'.format(locale),
                       info.get('Activity', 'summary'))

        cp.set(section, 'Terminal', 'false')
        cp.set(section, 'Type', 'Application')
        cp.set(section, 'Categories', 'Education;')
        cp.set(
            section, 'Icon',
            os.path.join(activity_path, 'activity',
                         self.config.bundle.get_icon_filename()))
        cp.set(section, 'Exec', self.config.bundle.get_command())
        cp.set(section, 'Path', activity_path)  # Path == CWD for running

        name = '{}.activity.desktop'.format(self.config.bundle_id)
        path = os.path.join(destdir, os.path.relpath(prefix, '/'), 'share',
                            'applications', name)
        if not os.path.isdir(os.path.dirname(path)):
            os.makedirs(os.path.dirname(path))
        with open(path, 'w') as f:
            cp.write(f)
        print('Install %s' % (path))
Пример #12
0
def main():

  #############################################################################
  #
  # ARGUMENT PARSING
  #
  #############################################################################

  parser=OptionParser(usage)
  parser.add_option("-e","--example",default=False,dest="example",action="store_true",help="Create example config.ini and an example sourcefile")
  (opts,args) = parser.parse_args()

  if opts.example:
    with open("omega_config.ini","w") as f:
      f.write(ExampleConfig)
    with open("omegascanslist.txt","w") as f:
      f.write(ExampleSourceFile)

    print("Example files \"omega_config.ini\" and \"omegascanslist.txt\" are created")
    sys.exit(0)

  if len(args) != 1:
    parser.print_help()
    sys.exit("ERROR: Must provide one config.ini")

  cp=ConfigParser()
  cp.optionxform = str
  cp.readfp(open(args[0]))

  dag=OmegaScansDAG(cp)

  dag.write_sub_files()
  dag.write_dag()
  dag.write_script()

  #fix the sub and sh files
  #This is required because pipeline.py does not yet have the ability to add
  #a specific argument before all other arguments and options ('scan' in this case)
  fix_subfile(dag.submitFile)
  fix_scriptfile(cp.get('paths','basedir'),dag.get_dag_file(),cp.get('omegapipe','executable'))

  print('Successfully created DAG file.')
  fulldagpath=os.path.join(cp.get('paths','basedir'),dag.get_dag_file())
  print('Now run condor_submit_dag %s\n'%(fulldagpath))
Пример #13
0
    def _update_fstab(newroot):
        newfstab = Fstab("%s/etc/fstab" % newroot)

        if not newfstab.exists():
            log.info("The new layer contains no fstab, skipping.")
            return

        log.debug("Checking new fstab: %s" % newfstab)
        log.info("Updating fstab of new layer")
        rootentry = newfstab.by_target("/")
        rootentry.source = new_lv.path
        newfstab.update(rootentry)

        # Ensure that discard is used
        # This can also be done in anaconda once it is fixed
        targets = list(constants.volume_paths().keys()) + ["/"]
        for tgt in targets:
            try:
                e = newfstab.by_target(tgt)
                if "discard" not in e.options:
                    e.options += ["discard"]
                    newfstab.update(e)
            except KeyError:
                # Created with imgbased.volume?
                log.debug("{} not found in /etc/fstab. "
                          "not created by Anaconda".format(tgt))
                from six.moves.configparser import ConfigParser
                c = ConfigParser()
                c.optionxform = str

                sub = re.sub(r'^/', '', tgt)
                sub = re.sub(r'/', '-', sub)
                fname = "{}/etc/systemd/system/{}.mount".format(newroot, sub)
                c.read(fname)

                if 'discard' not in c.get('Mount', 'Options'):
                    c.set('Mount', 'Options',
                          ','.join([c.get('Mount', 'Options'), 'discard']))

                with open(fname, 'w') as mountfile:
                    c.write(mountfile)
Пример #14
0
def get_conf_stanzas(conf_name):
    '''Get stanzas of `conf_name`

    :param conf_name: Config file.
    :type conf_name: ``string``
    :returns: Config stanzas.
    :rtype: ``dict``

    Usage::
       >>> stanzas = get_conf_stanzas('server')
       >>> return: {'serverName': 'testServer', 'sessionTimeout': '1h', ...}
    '''

    if conf_name.endswith('.conf'):
        conf_name = conf_name[:-5]

    # TODO: dynamically caculate SPLUNK_HOME
    btool_cli = [
        op.join(os.environ['SPLUNK_HOME'], 'bin', 'btool'), conf_name, 'list'
    ]
    p = subprocess.Popen(btool_cli,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    out, _ = p.communicate()

    if isinstance(out, bytes):
        out = out.decode()

    out = StringIO(out)
    parser = ConfigParser()
    parser.optionxform = str
    if sys.version_info[:2] >= (3, 2):
        parser.read_file(out)
    else:
        parser.readfp(out)

    out = {}
    for section in parser.sections():
        out[section] = {item[0]: item[1] for item in parser.items(section)}
    return out
Пример #15
0
    def _install_desktop_file(self, prefix, activity_path):
        cp = ConfigParser()
        section = 'Desktop Entry'
        cp.add_section(section)
        cp.optionxform = str  # Allow CamelCase entries

        # Get it from the activity.info for the non-translated version
        info = ConfigParser()
        info.read(os.path.join(activity_path, 'activity', 'activity.info'))
        cp.set(section, 'Name', info.get('Activity', 'name'))
        if info.has_option('Activity', 'summary'):
            cp.set(section, 'Comment', info.get('Activity', 'summary'))

        for path in sorted(glob(os.path.join(activity_path, 'locale',
                                             '*', 'activity.linfo'))):
            locale = path.split(os.path.sep)[-2]
            info = ConfigParser()
            info.read(path)
            if info.has_option('Activity', 'name'):
                cp.set(section, 'Name[{}]'.format(locale),
                       info.get('Activity', 'name'))
            if info.has_option('Activity', 'summary'):
                cp.set(section, 'Comment[{}]'.format(locale),
                       info.get('Activity', 'summary'))

        cp.set(section, 'Terminal', 'false')
        cp.set(section, 'Type', 'Application')
        cp.set(section, 'Categories', 'Education;')
        cp.set(section, 'Icon', os.path.join(
            activity_path, 'activity', self.config.bundle.get_icon_filename()))
        cp.set(section, 'Exec', self.config.bundle.get_command())
        cp.set(section, 'Path', activity_path)  # Path == CWD for running

        name = '{}.activity.desktop'.format(self.config.bundle_id)
        path = os.path.join(prefix, 'share', 'applications', name)
        if not os.path.isdir(os.path.dirname(path)):
            os.makedirs(os.path.dirname(path))
        with open(path, 'w') as f:
            cp.write(f)
Пример #16
0
	def _buildInput (self):
		"""
		Build the input data
		Input could be:
		1. list: ['input', 'infile:file'] <=> ['input:var', 'infile:path']
		2. str : "input, infile:file" <=> input:var, infile:path
		3. dict: {"input": channel1, "infile:file": channel2}
		   or    {"input:var, input:file" : channel3}
		for 1,2 channels will be the combined channel from dependents, if there is not dependents, it will be sys.argv[1:]
		"""
		self.props['input'] = {}

		if self.resume in ['skip+', 'resume']:
			from six.moves.configparser import ConfigParser
			psfile = path.join(self.workdir, 'proc.settings')
			if not path.isfile(psfile):
				raise ProcInputError(psfile, 'Cannot parse input for skip+/resume process, no such file')

			cp = ConfigParser()
			cp.optionxform = str
			cp.read(psfile)
			self.props['size'] = int(json.loads(cp.get('size', 'value')))

			indata = OrderedDict(cp.items('input'))
			intype = ''
			inname = ''
			for key in indata.keys():
				if key.endswith('.type'):
					intype = indata[key]
					inname = key[:-5]
					self.props['input'][inname] = {
						'type': intype,
						'data': []
					}
				elif key.startswith(inname + '.data#'):
					if intype in Proc.IN_FILESTYPE:
						data = [json.loads(s) for s in filter(None, indata[key].splitlines())]
					else:
						data = json.loads(indata[key].strip())
					self.props['input'][inname]['data'].append(data)
			self.props['jobs'] = [None] * self.size
		else:
			indata = self.config['input']

			if not isinstance (indata, dict):
				indata   = ','.join(utils.alwaysList(indata))
				indata   = {
					indata: Channel.fromChannels (*[d.channel for d in self.depends]) \
						if self.depends else Channel.fromArgv()
				}

			inkeys   = list(indata.keys())
			pinkeys  = []
			pintypes = []
			for key in utils.alwaysList(inkeys):
				if ':' not in key:
					pinkeys.append(key)
					pintypes.append(Proc.IN_VARTYPE[0])
				else:
					k, t = key.split(':')
					if t not in Proc.IN_VARTYPE + Proc.IN_FILESTYPE + Proc.IN_FILETYPE:
						raise ProcInputError(t, 'Unknown input type')
					pinkeys.append(k)
					pintypes.append(t)

			invals = Channel.create()
			for inkey in inkeys:
				inval = indata[inkey]
				if callable(inval):
					inval = inval (*[d.channel for d in self.depends] if self.depends else Channel.fromArgv())
					invals = invals.cbind(inval)
				elif isinstance(inval, Channel):
					invals = invals.cbind(inval)
				else:
					invals = invals.cbind(Channel.create(inval))
			self.props['size'] = invals.length()
			self.props['jobs'] = [None] * self.size

			# support empty input
			pinkeys = list(filter(None, pinkeys))

			wdata   = invals.width()
			if len(pinkeys) < wdata:
				self.log('Not all data are used as input, %s column(s) wasted.' % (wdata - len(pinkeys)), 'warning')
			for i, inkey in enumerate(pinkeys):
				self.props['input'][inkey] = {}
				self.props['input'][inkey]['type'] = pintypes[i]
				if i < wdata:
					self.props['input'][inkey]['data'] = invals.flatten(i)
				else:
					self.log('No data found for input key "%s", use empty strings/lists instead.' % inkey, 'warning')
					self.props['input'][inkey]['data'] = [[] if pintypes[i] in Proc.IN_FILESTYPE else ''] * self.size
                  type='int',
                  metavar='NUM',
                  help='Number of prior samples to analyse')

(opts, args) = parser.parse_args()

if len(args) == 0:
    parser.print_help()
    sys.exit(1)

inifile = args[0]

# Set up the configuration for the sub-dags

prior_cp = ConfigParser()
prior_cp.optionxform = str
prior_cp.readfp(open(inifile))

main_cp = ConfigParser()
main_cp.optionxform = str
main_cp.readfp(open(inifile))

rundir = os.path.abspath(opts.run_path)

if opts.daglog_path is not None:
    prior_cp.set('paths', 'daglogdir',
                 os.path.join(os.path.abspath(opts.daglog_path), 'prior'))
    main_cp.set('paths', 'daglogdir',
                os.path.join(os.path.abspath(opts.daglog_path), 'main'))
    daglogdir = os.path.abspath(opts.daglog_path)
else:
Пример #18
0
def getExactSavedProfile(profileName, fromLocal=False):
    """
    Reads a single profile from the getwatchlist.conf in the default
    or local directories and returns them in a dictionary. If the profile
    is not found, it returns the default settings.
    """

    parser = ConfigParser()
    parser.optionxform = str
    if fromLocal:
        parser.read(getLocalConfPath())
    else:
        parser.read(getDefaultConfPath())

    sections = parser.sections()

    settings = getDefaultSettings()

    # We start with the globals. These can be overridden with local settings
    # in the config for the profile. The globals are just nice to have.
    realGlobalName = getRealProfileName('globals', sections, fromLocal)
    if realGlobalName is not None:
        for key, value in parser.items(realGlobalName):
            lowkey = key.lower()
            if lowkey == 'proxyhost':
                settings['proxyHost'] = value
            elif lowkey == 'proxyport':
                settings['proxyPort'] = str(value)

    # The profile name should be a URL if the profile doesn't exist
    # Otherwise, it will be overwritten by the url in the profile
    # THIS CHANGED after we have the local and default profiles
    # settings['url'] = profileName

    realProfileName = getRealProfileName(profileName, sections, fromLocal)
    # if the profile isn't in the file return defaults
    if not realProfileName:
        return settings

    # now grab all of the settings at once and assign
    for key, value in parser.items(realProfileName):
        lowKey = key.lower()
        # strip any quotes from our value
        value = value.replace('\'', '')
        value = value.replace('"', '')
        value = value.strip()
        if lowKey == 'url':
            settings['url'] = value
        elif lowKey == 'delimiter':
            settings['delimiter'] = value
        elif lowKey == 'comment':
            settings['comment'] = value
        elif lowKey == 'relevantfieldname':
            settings['relevantFieldName'] = value
        elif lowKey == 'relevantfieldcol':
            settings['relevantFieldCol'] = int(value) - 1
        elif lowKey == 'categorycol':
            settings['categoryCol'] = int(value) - 1
        elif lowKey == 'referencecol':
            settings['referenceCol'] = int(value) - 1
        elif lowKey == 'datecol':
            settings['dateCol'] = int(value) - 1
        elif lowKey == 'authuser':
            settings['authUser'] = value
        elif lowKey == 'authpass':
            settings['authPass'] = value
        elif lowKey == 'ignorefirstline':
            settings['ignoreFirstLine'] = bool(value)
        elif lowKey == 'proxyhost':
            settings['proxyHost'] = value
        elif lowKey == 'proxyport':
            settings['proxyPort'] = str(value)
        else:
            if lowKey.isdigit():
                settings['addCols'][int(key)] = value
            else:
                settings['customFields'][key] = value

    return settings
Пример #19
0
    def __spawn_instance(self):
        """
        Create and configure a new KRA instance using pkispawn.
        Creates a configuration file with IPA-specific
        parameters and passes it to the base class to call pkispawn
        """

        # Create an empty and secured file
        (cfg_fd, cfg_file) = tempfile.mkstemp()
        os.close(cfg_fd)
        pent = pwd.getpwnam(self.service_user)
        os.chown(cfg_file, pent.pw_uid, pent.pw_gid)

        # Create KRA configuration
        config = ConfigParser()
        config.optionxform = str
        config.add_section("KRA")

        # Security Domain Authentication
        config.set("KRA", "pki_security_domain_https_port", "443")
        config.set("KRA", "pki_security_domain_password", self.admin_password)
        config.set("KRA", "pki_security_domain_user", self.admin_user)

        # issuing ca
        config.set("KRA", "pki_issuing_ca_uri", "https://%s" %
                   ipautil.format_netloc(self.fqdn, 443))

        # Server
        config.set("KRA", "pki_enable_proxy", "True")
        config.set("KRA", "pki_restart_configured_instance", "False")
        config.set("KRA", "pki_backup_keys", "True")
        config.set("KRA", "pki_backup_password", self.admin_password)

        # Client security database
        config.set("KRA", "pki_client_database_dir", self.agent_db)
        config.set("KRA", "pki_client_database_password", self.admin_password)
        config.set("KRA", "pki_client_database_purge", "False")
        config.set("KRA", "pki_client_pkcs12_password", self.admin_password)

        # Administrator
        config.set("KRA", "pki_admin_name", self.admin_user)
        config.set("KRA", "pki_admin_uid", self.admin_user)
        config.set("KRA", "pki_admin_email", "root@localhost")
        config.set("KRA", "pki_admin_password", self.admin_password)
        config.set("KRA", "pki_admin_nickname", "ipa-ca-agent")
        config.set("KRA", "pki_admin_subject_dn",
                   str(DN(('cn', 'ipa-ca-agent'), self.subject_base)))
        config.set("KRA", "pki_import_admin_cert", "True")
        config.set("KRA", "pki_admin_cert_file", paths.ADMIN_CERT_PATH)
        config.set("KRA", "pki_client_admin_cert_p12", paths.DOGTAG_ADMIN_P12)

        # Directory server
        config.set("KRA", "pki_ds_ldap_port", "389")
        config.set("KRA", "pki_ds_password", self.dm_password)
        config.set("KRA", "pki_ds_base_dn", self.basedn)
        config.set("KRA", "pki_ds_database", "ipaca")
        config.set("KRA", "pki_ds_create_new_db", "False")

        self._use_ldaps_during_spawn(config)

        # Certificate subject DNs
        config.set("KRA", "pki_subsystem_subject_dn",
                   str(DN(('cn', 'CA Subsystem'), self.subject_base)))
        config.set("KRA", "pki_ssl_server_subject_dn",
                   str(DN(('cn', self.fqdn), self.subject_base)))
        config.set("KRA", "pki_audit_signing_subject_dn",
                   str(DN(('cn', 'KRA Audit'), self.subject_base)))
        config.set(
            "KRA", "pki_transport_subject_dn",
            str(DN(('cn', 'KRA Transport Certificate'), self.subject_base)))
        config.set(
            "KRA", "pki_storage_subject_dn",
            str(DN(('cn', 'KRA Storage Certificate'), self.subject_base)))

        # Certificate nicknames
        # Note that both the server certs and subsystem certs reuse
        # the ca certs.
        config.set("KRA", "pki_subsystem_nickname",
                   "subsystemCert cert-pki-ca")
        config.set("KRA", "pki_ssl_server_nickname",
                   "Server-Cert cert-pki-ca")
        config.set("KRA", "pki_audit_signing_nickname",
                   "auditSigningCert cert-pki-kra")
        config.set("KRA", "pki_transport_nickname",
                   "transportCert cert-pki-kra")
        config.set("KRA", "pki_storage_nickname",
                   "storageCert cert-pki-kra")

        # Shared db settings
        # Needed because CA and KRA share the same database
        # We will use the dbuser created for the CA
        config.set("KRA", "pki_share_db", "True")
        config.set(
            "KRA", "pki_share_dbuser_dn",
            str(DN(('uid', 'pkidbuser'), ('ou', 'people'), ('o', 'ipaca'))))

        _p12_tmpfile_handle, p12_tmpfile_name = tempfile.mkstemp(dir=paths.TMP)

        if self.clone:
            krafile = self.pkcs12_info[0]
            shutil.copy(krafile, p12_tmpfile_name)
            pent = pwd.getpwnam(self.service_user)
            os.chown(p12_tmpfile_name, pent.pw_uid, pent.pw_gid)

            # Security domain registration
            config.set("KRA", "pki_security_domain_hostname", self.master_host)
            config.set("KRA", "pki_security_domain_https_port", "443")
            config.set("KRA", "pki_security_domain_user", self.admin_user)
            config.set("KRA", "pki_security_domain_password",
                       self.admin_password)

            # Clone
            config.set("KRA", "pki_clone", "True")
            config.set("KRA", "pki_clone_pkcs12_path", p12_tmpfile_name)
            config.set("KRA", "pki_clone_pkcs12_password", self.dm_password)
            config.set("KRA", "pki_clone_setup_replication", "False")
            config.set(
                "KRA", "pki_clone_uri",
                "https://%s" % ipautil.format_netloc(self.master_host, 443))
        else:
            # the admin cert file is needed for the first instance of KRA
            cert = DogtagInstance.get_admin_cert(self)
            with open(paths.ADMIN_CERT_PATH, "w") as admin_path:
                admin_path.write(cert)

        # Generate configuration file
        with open(cfg_file, "wb") as f:
            config.write(f)

        try:
            DogtagInstance.spawn_instance(
                self, cfg_file,
                nolog_list=(self.dm_password, self.admin_password)
            )
        finally:
            os.remove(p12_tmpfile_name)
            os.remove(cfg_file)

        shutil.move(paths.KRA_BACKUP_KEYS_P12, paths.KRACERT_P12)

        export_kra_agent_pem()

        self.log.debug("completed creating KRA instance")
Пример #20
0
parser = argparse.ArgumentParser( description = description )

parser.add_argument("inifile", help="The configuation (.ini) file") # the positional argument for the configuration file
parser.add_argument("--condor-submit", action="store_true", default=False, help="Automatically submit the Condor DAG")
parser.add_argument("-r", "--run-path", dest="runpath", default=None, help="Set the directory to run the pipeline in (overwrites any value in the config.ini file)")
parser.add_argument("-p", "--pulsar", dest="pulsarlist", action='append', default=None, help="A pulsar name to search for rather than all pulsars given in a parameter file directory (this can be specified multiple times to search for more than one pulsar).")

opts = parser.parse_args()

# check that at least the ini file has been given
inifile = opts.inifile

# parser .ini file
try:
  cp = ConfigParser()
  cp.optionxform = str
  cp.readfp(open(inifile))
except:
  print("Error... problem parsing '%s' configuration file" % inifile, file=sys.stderr)
  sys.exit(1)

if opts.runpath is not None:
  cp.set('analysis', 'run_dir', opts.runpath)

# Check if we're running in automated mode or not
try:
  automated = cp.getboolean('analysis', 'autonomous')
except:
  automated = False

# Check if configuration file says to submit the DAG
Пример #21
0
    def __spawn_instance(self):
        """
        Create and configure a new KRA instance using pkispawn.
        Creates a configuration file with IPA-specific
        parameters and passes it to the base class to call pkispawn
        """

        # Create an empty and secured file
        (cfg_fd, cfg_file) = tempfile.mkstemp()
        os.close(cfg_fd)
        pent = pwd.getpwnam(self.service_user)
        os.chown(cfg_file, pent.pw_uid, pent.pw_gid)

        # Create KRA configuration
        config = ConfigParser()
        config.optionxform = str
        config.add_section("KRA")

        # Security Domain Authentication
        config.set("KRA", "pki_security_domain_https_port", "443")
        config.set("KRA", "pki_security_domain_password", self.admin_password)
        config.set("KRA", "pki_security_domain_user", self.admin_user)

        # issuing ca
        config.set("KRA", "pki_issuing_ca_uri",
                   "https://%s" % ipautil.format_netloc(self.fqdn, 443))

        # Server
        config.set("KRA", "pki_enable_proxy", "True")
        config.set("KRA", "pki_restart_configured_instance", "False")
        config.set("KRA", "pki_backup_keys", "True")
        config.set("KRA", "pki_backup_password", self.admin_password)

        # Client security database
        config.set("KRA", "pki_client_database_dir", self.agent_db)
        config.set("KRA", "pki_client_database_password", self.admin_password)
        config.set("KRA", "pki_client_database_purge", "False")
        config.set("KRA", "pki_client_pkcs12_password", self.admin_password)

        # Administrator
        config.set("KRA", "pki_admin_name", self.admin_user)
        config.set("KRA", "pki_admin_uid", self.admin_user)
        config.set("KRA", "pki_admin_email", "root@localhost")
        config.set("KRA", "pki_admin_password", self.admin_password)
        config.set("KRA", "pki_admin_nickname", "ipa-ca-agent")
        config.set("KRA", "pki_admin_subject_dn",
                   str(DN(('cn', 'ipa-ca-agent'), self.subject_base)))
        config.set("KRA", "pki_import_admin_cert", "True")
        config.set("KRA", "pki_admin_cert_file", paths.ADMIN_CERT_PATH)
        config.set("KRA", "pki_client_admin_cert_p12", paths.DOGTAG_ADMIN_P12)

        # Directory server
        config.set("KRA", "pki_ds_ldap_port", "389")
        config.set("KRA", "pki_ds_password", self.dm_password)
        config.set("KRA", "pki_ds_base_dn", six.text_type(self.basedn))
        config.set("KRA", "pki_ds_database", "ipaca")
        config.set("KRA", "pki_ds_create_new_db", "False")

        self._use_ldaps_during_spawn(config)

        # Certificate subject DNs
        config.set("KRA", "pki_subsystem_subject_dn",
                   str(DN(('cn', 'CA Subsystem'), self.subject_base)))
        config.set("KRA", "pki_ssl_server_subject_dn",
                   str(DN(('cn', self.fqdn), self.subject_base)))
        config.set("KRA", "pki_audit_signing_subject_dn",
                   str(DN(('cn', 'KRA Audit'), self.subject_base)))
        config.set(
            "KRA", "pki_transport_subject_dn",
            str(DN(('cn', 'KRA Transport Certificate'), self.subject_base)))
        config.set(
            "KRA", "pki_storage_subject_dn",
            str(DN(('cn', 'KRA Storage Certificate'), self.subject_base)))

        # Certificate nicknames
        # Note that both the server certs and subsystem certs reuse
        # the ca certs.
        config.set("KRA", "pki_subsystem_nickname",
                   "subsystemCert cert-pki-ca")
        config.set("KRA", "pki_ssl_server_nickname", "Server-Cert cert-pki-ca")
        config.set("KRA", "pki_audit_signing_nickname",
                   "auditSigningCert cert-pki-kra")
        config.set("KRA", "pki_transport_nickname",
                   "transportCert cert-pki-kra")
        config.set("KRA", "pki_storage_nickname", "storageCert cert-pki-kra")

        # Shared db settings
        # Needed because CA and KRA share the same database
        # We will use the dbuser created for the CA
        config.set("KRA", "pki_share_db", "True")
        config.set(
            "KRA", "pki_share_dbuser_dn",
            str(DN(('uid', 'pkidbuser'), ('ou', 'people'), ('o', 'ipaca'))))

        _p12_tmpfile_handle, p12_tmpfile_name = tempfile.mkstemp(dir=paths.TMP)

        if self.clone:
            krafile = self.pkcs12_info[0]
            shutil.copy(krafile, p12_tmpfile_name)
            pent = pwd.getpwnam(self.service_user)
            os.chown(p12_tmpfile_name, pent.pw_uid, pent.pw_gid)

            # Security domain registration
            config.set("KRA", "pki_security_domain_hostname", self.master_host)
            config.set("KRA", "pki_security_domain_https_port", "443")
            config.set("KRA", "pki_security_domain_user", self.admin_user)
            config.set("KRA", "pki_security_domain_password",
                       self.admin_password)

            # Clone
            config.set("KRA", "pki_clone", "True")
            config.set("KRA", "pki_clone_pkcs12_path", p12_tmpfile_name)
            config.set("KRA", "pki_clone_pkcs12_password", self.dm_password)
            config.set("KRA", "pki_clone_setup_replication", "False")
            config.set(
                "KRA", "pki_clone_uri",
                "https://%s" % ipautil.format_netloc(self.master_host, 443))
        else:
            # the admin cert file is needed for the first instance of KRA
            cert = DogtagInstance.get_admin_cert(self)
            # First make sure that the directory exists
            parentdir = os.path.dirname(paths.ADMIN_CERT_PATH)
            if not os.path.exists(parentdir):
                os.makedirs(parentdir)
            with open(paths.ADMIN_CERT_PATH, "w") as admin_path:
                admin_path.write(cert)

        # Generate configuration file
        with open(cfg_file, "w") as f:
            config.write(f)

        try:
            DogtagInstance.spawn_instance(self,
                                          cfg_file,
                                          nolog_list=(self.dm_password,
                                                      self.admin_password))
        finally:
            os.remove(p12_tmpfile_name)
            os.remove(cfg_file)

        shutil.move(paths.KRA_BACKUP_KEYS_P12, paths.KRACERT_P12)

        export_kra_agent_pem()

        self.log.debug("completed creating KRA instance")
Пример #22
0
    dest="pulsarlist",
    action='append',
    default=None,
    help=
    "A pulsar name to search for rather than all pulsars given in a parameter file directory (this can be specified multiple times to search for more than one pulsar)."
)

opts = parser.parse_args()

# check that at least the ini file has been given
inifile = opts.inifile

# parser .ini file
try:
    cp = ConfigParser()
    cp.optionxform = str
    cp.readfp(open(inifile))
except:
    print("Error... problem parsing '%s' configuration file" % inifile,
          file=sys.stderr)
    sys.exit(1)

if opts.runpath is not None:
    cp.set('analysis', 'run_dir', opts.runpath)

# Check if we're running in automated mode or not
try:
    automated = cp.getboolean('analysis', 'autonomous')
except:
    automated = False