Initialize the pushed configuration dictionary
        with the inner properties that are to be propagated to the satellite link.

        :return: None
171408
def prepare_for_conf(self):
        
        logger.debug("- preparing: %s", self)
        self.cfg = {
            'self_conf': self.give_satellite_cfg(),
            'schedulers': {},
            'arbiters': {}
        }
        logger.debug("- prepared: %s", self.cfg)
230280
def init(opts):
    '''
    
    '''
    proxy_dict = opts.get('proxy', {})
    opts['multiprocessing'] = proxy_dict.get('multiprocessing', False)
    netmiko_connection_args = proxy_dict.copy()
    netmiko_connection_args.pop('proxytype', None)
    netmiko_device['always_alive'] = netmiko_connection_args.pop('always_alive',
                                                                 opts.get('proxy_always_alive', True))
    try:
        connection = ConnectHandler(**netmiko_connection_args)
        netmiko_device['connection'] = connection
        netmiko_device['initialized'] = True
        netmiko_device['args'] = netmiko_connection_args
        netmiko_device['up'] = True
        if not netmiko_device['always_alive']:
            netmiko_device['connection'].disconnect()
    except NetMikoTimeoutException as t_err:
        log.error('Unable to setup the netmiko connection', exc_info=True)
    except NetMikoAuthenticationException as au_err:
        log.error('Unable to setup the netmiko connection', exc_info=True)
    return True
1347804
def init():
    
    global sqs, logs, config
    if config is None:
        with open('config.json') as fh:
            config = json.load(fh)
    if sqs is None:
        sqs = boto3.client('sqs')
    if logs is None:
        logs = boto3.client('logs')
1151930
def initialize(config):
    

    # Determine the client class to use
    if 'redis_client' in config:
        client = utils.find_entrypoint('turnstile.redis_client',
                                       config['redis_client'], required=True)
    else:
        client = redis.StrictRedis

    # Extract relevant connection information from the configuration
    kwargs = {}
    for cfg_var, type_ in REDIS_CONFIGS.items():
        if cfg_var in config:
            kwargs[cfg_var] = type_(config[cfg_var])

    # Make sure we have at a minimum the hostname
    if 'host' not in kwargs and 'unix_socket_path' not in kwargs:
        raise redis.ConnectionError("No host specified for redis database")

    # Look up the connection pool configuration
    cpool_class = None
    cpool = {}
    extra_kwargs = {}
    for key, value in config.items():
        if key.startswith('connection_pool.'):
            _dummy, _sep, varname = key.partition('.')
            if varname == 'connection_class':
                cpool[varname] = utils.find_entrypoint(
                    'turnstile.connection_class', value, required=True)
            elif varname == 'max_connections':
                cpool[varname] = int(value)
            elif varname == 'parser_class':
                cpool[varname] = utils.find_entrypoint(
                    'turnstile.parser_class', value, required=True)
            else:
                cpool[varname] = value
        elif key not in REDIS_CONFIGS and key not in REDIS_EXCLUDES:
            extra_kwargs[key] = value
    if cpool:
        cpool_class = redis.ConnectionPool

    # Use custom connection pool class if requested...
    if 'connection_pool' in config:
        cpool_class = utils.find_entrypoint('turnstile.connection_pool',
                                            config['connection_pool'],
                                            required=True)

    # If we're using a connection pool, we'll need to pass the keyword
    # arguments to that instead of to redis
    if cpool_class:
        cpool.update(kwargs)

        # Use a custom connection class?
        if 'connection_class' not in cpool:
            if 'unix_socket_path' in cpool:
                if 'host' in cpool:
                    del cpool['host']
                if 'port' in cpool:
                    del cpool['port']

                cpool['path'] = cpool['unix_socket_path']
                del cpool['unix_socket_path']

                cpool['connection_class'] = redis.UnixDomainSocketConnection
            else:
                cpool['connection_class'] = redis.Connection

        # Build the connection pool to use and set up to pass it into
        # the redis constructor...
        kwargs = dict(connection_pool=cpool_class(**cpool))

    # Build and return the database
    kwargs.update(extra_kwargs)
    return client(**kwargs)
378340
def __init(self):
        
        params = {
            "f" : "json",
        }
        json_dict = self._get(self._url, params,
                                 securityHandler=self._securityHandler,
                                 proxy_port=self._proxy_port,
                                 proxy_url=self._proxy_url)
        self._json_dict = json_dict
        self._json = json.dumps(json_dict, default=self._date_handler)
        attributes = [attr for attr in dir(self)
                      if not attr.startswith('__') and \
                      not attr.startswith('_')]
        for k,v in json_dict.items():
            if k in attributes:
                setattr(self, "_"+ k, json_dict[k])
            else:
                print("%s - attribute not implemented in Feature Layer." % k)
        if self._parentLayer is None:
            self._parentLayer = FeatureService(
                url=os.path.dirname(self._url),
                securityHandler=self._securityHandler,
                proxy_port=self._proxy_port,
                proxy_url=self._proxy_url, initialize=False)
643899
def init(self, *args):
        '''
        '''
        cfg = {}
        for k, v in self.options.items():
            if k.lower() in self.cfg.settings and v is not None:
                cfg[k.lower()] = v
        return cfg
931041
def __init(self):
        
        params = {
            "f" : "json",
        }
        json_dict = self._get(self._url, params,
                                 securityHandler=self._securityHandler,
                                 proxy_port=self._proxy_port,
                                 proxy_url=self._proxy_url)
        self._json = json.dumps(json_dict)
        self._json_dict = json_dict
        self.loadAttributes(json_dict=json_dict)
943132
def vis_init(self):
        '''
        
        '''
        init_dict = {}
        init_dict['kind'] = 'init'
        assert len(self.want_file_pos) == len(self.heads_and_tails)
        init_dict['want_file_pos'] = self.want_file_pos
        init_dict['files'] = self.file_list
        init_dict['heads_and_tails'] = self.heads_and_tails
        init_dict['num_pieces'] = self.num_pieces
        self.broadcast(init_dict)
834630
def _initilize_props(self):
        
        # if self.subject == "pyuri_aHR0cDovL3R1dHQuZWR1Lw==_":
        #     pdb.set_trace()
        try:
            # pdb.set_trace()
            for prop in self.es_props:
                self[prop] = self.properties[prop](self, self.dataset)
                setattr(self, prop, self[prop])

            self[__a__] = self.properties[__a__](self, self.dataset)
            setattr(self, __a__, self[__a__])
            # for prop, prop_class in self.properties.items():
            #     # passing in the current dataset tie
            #     self[prop] = prop_class(self, self.dataset)
            #     setattr(self, prop, self[prop])
            # bases = remove_parents((self.__class__,) +
            #                         self.__class__.__bases__)
            # for base in bases:
            #     if base.__name__ not in IGNORE_CLASSES:
            #         base_name = Uri(base.__name__)
            #         try:
            #             self['rdf_type'].append(base_name)
            #         except KeyError:
            #             self[Uri('rdf_type')] = MODULE.rdfclass.make_property({},
            #                     'rdf_type',
            #                     self.__class__.__name__)(self, self.dataset)
            #             self['rdf_type'].append(base_name)
        except (AttributeError, TypeError):
            pass
1191740
def put_settings(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.put_settings(index=self._name, **kwargs)
536575
def init_config(self, app):
        
        app.config.setdefault('REQUIREJS_BASEURL', app.static_folder)
        app.config.setdefault('COLLECT_STATIC_ROOT', app.static_folder)
        app.config.setdefault('COLLECT_STORAGE', 'flask_collect.storage.link')
        app.config.setdefault(
            'COLLECT_FILTER', partial(collect_staticroot_removal, app))
        app.config.setdefault(
            'WEBPACKEXT_PROJECT', 'invenio_assets.webpack:project')
277384
def init(cnf):
    '''
    
    '''
    CONFIG['host'] = cnf.get('proxy', {}).get('host')
    if not CONFIG['host']:
        raise MinionError(message="Cannot find 'host' parameter in the proxy configuration")

    CONFIG['user'] = cnf.get('proxy', {}).get('user')
    if not CONFIG['user']:
        raise MinionError(message="Cannot find 'user' parameter in the proxy configuration")

    CONFIG['uri'] = "/api/{0}".format(CONFIG['user'])
342211
def __init_configrs(self, rs_cfg):
        """"""
        # Use 'rs_id' to set the id for consistency, but need to rename
        # to 'id' to use with ReplicaSets.create()
        rs_cfg['id'] = rs_cfg.pop('rs_id', None)
        for member in rs_cfg.setdefault('members', [{}]):
            member['procParams'] = self._strip_auth(
                member.get('procParams', {}))
            member['procParams']['configsvr'] = True
            if self.enable_ipv6:
                common.enable_ipv6_single(member['procParams'])
        rs_cfg['sslParams'] = self.sslParams
        self._configsvrs.append(ReplicaSets().create(rs_cfg))
1157896
def init_app(self, app, **options):
        """"""
        sd = options.setdefault
        conf = app.config

        sd('app_id', conf.get('PUSHER_APP_ID'))
        sd('key', conf.get('PUSHER_KEY'))
        sd('secret', conf.get('PUSHER_SECRET'))
        sd('ssl', conf.get('PUSHER_SSL', True))
        sd('host', conf.get('PUSHER_HOST'))
        sd('port', conf.get('PUSHER_PORT'))
        sd('cluster', conf.get('PUSHER_CLUSTER'))
        sd('backend', conf.get('PUSHER_BACKEND'))
        sd('json_encoder', (conf.get('PUSHER_JSON_ENCODER')
                            or app.json_encoder))
        sd('json_decoder', (conf.get('PUSHER_JSON_DECODER')
                            or app.json_decoder))
        if conf.get('PUSHER_TIMEOUT'):
            sd('timeout', conf.get('PUSHER_TIMEOUT'))

        super(Pusher, self).__init__(**options)

        if not hasattr(app, 'extensions'):
            app.extensions = {}
        app.extensions['pusher'] = self
140413
def fill_default_configuration(self):
        
        logger.debug("Filling the unset properties with their default value:")

        types_creations = self.__class__.types_creations
        for o_type in types_creations:
            (_, _, inner_property, _, _) = types_creations[o_type]
            # Not yet for the realms and daemons links
            if inner_property in ['realms', 'arbiters', 'schedulers', 'reactionners',
                                  'pollers', 'brokers', 'receivers']:
                continue
            logger.debug("  . for %s", inner_property,)
            inner_object = getattr(self, inner_property, None)
            if inner_object is None:
                logger.debug("No %s to fill with default values", inner_property)
                continue
            inner_object.fill_default()

        # We have all monitored elements, we can create a default realm if none is defined
        if getattr(self, 'realms', None) is not None:
            self.fill_default_realm()
            self.realms.fill_default()

            # Then we create missing satellites, so no other satellites will be created after
            self.fill_default_satellites(self.launch_missing_daemons)

        types_creations = self.__class__.types_creations
        for o_type in types_creations:
            (_, _, inner_property, _, _) = types_creations[o_type]
            if getattr(self, inner_property, None) is None:
                logger.debug("No %s to fill with default values", inner_property)
                continue
            # Only for the daemons links
            if inner_property in ['schedulers', 'reactionners', 'pollers', 'brokers', 'receivers']:
                logger.debug("  . for %s", inner_property,)
                inner_object = getattr(self, inner_property)
                inner_object.fill_default()

        # Now fill some fields we can predict (like address for hosts)
        self.hosts.fill_predictive_missing_parameters()
        self.services.fill_predictive_missing_parameters()
1006141
def initialize(self):
        

        try:
            conn = ldap.initialize('{0}://{1}:{2}'.format(
                current_app.config['LDAP_SCHEMA'],
                current_app.config['LDAP_HOST'],
                current_app.config['LDAP_PORT']))
            conn.set_option(ldap.OPT_NETWORK_TIMEOUT,
                            current_app.config['LDAP_TIMEOUT'])
            conn = self._set_custom_options(conn)
            conn.protocol_version = ldap.VERSION3
            if current_app.config['LDAP_USE_TLS']:
                conn.start_tls_s()
            return conn
        except ldap.LDAPError as e:
            raise LDAPException(self.error(e.args))
128670
private static Properties initializeConfigurationProperties() {
		Properties properties = new Properties();

		InputStream in = GeoPackageProperties.class.getResourceAsStream("/"
				+ PropertyConstants.PROPERTIES_FILE);
		if (in != null) {
			try {
				properties.load(in);
			} catch (Exception e) {
				log.log(Level.SEVERE, "Failed to load properties file: "
						+ PropertyConstants.PROPERTIES_FILE, e);
			} finally {
				try {
					in.close();
				} catch (IOException e) {
					log.log(Level.WARNING, "Failed to close properties file: "
							+ PropertyConstants.PROPERTIES_FILE, e);
				}
			}
		} else {
			log.log(Level.SEVERE, "Failed to load properties, file not found: "
					+ PropertyConstants.PROPERTIES_FILE);
		}

		return properties;
	}