Initialize the digester configuration by reading values from the kernel
SystemConfiguration.
973964
private void initConfig()
    {
        SystemConfiguration config = null;
        try {
            config = EFapsSystemConfiguration.get();
            if (config != null) {
                final Properties confProps = config.getAttributeValueAsProperties(KernelSettings.PWDSTORE);
                this.digesterConfig.setAlgorithm(confProps.getProperty(PasswordStore.ALGORITHM,
                                this.digesterConfig.getAlgorithm()));
                this.digesterConfig.setIterations(confProps.getProperty(PasswordStore.ITERATIONS,
                                this.digesterConfig.getIterations().toString()));
                this.digesterConfig.setSaltSizeBytes(confProps.getProperty(PasswordStore.SALTSIZE,
                                this.digesterConfig.getSaltSizeBytes().toString()));
                this.threshold = config.getAttributeValueAsInteger(KernelSettings.PWDTH);
            }
        } catch (final EFapsException e) {
            PasswordStore.LOG.error("Error on reading SystemConfiguration for PasswordStore", e);
        }

    }
63613
private static synchronized void initialize() {
        PlatformProperties pp = PlatformProperties.getPlatformProperties();

        String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
        String pidString = processName.substring(0, processName.indexOf('@'));
        pid = Integer.valueOf(pidString);
        initialized = true;

        // get the RSS and other stats from scraping "ps" from the command line
        PSScraper.PSData psdata = PSScraper.getPSData(pid);
        assert(psdata.rss > 0);

        // figure out how much memory this thing has
        memorysize = pp.ramInMegabytes;
        assert(memorysize > 0);

        // now try to figure out the best way to get the rss size
        long rss = -1;

        // try the mac method
        try {
            rss = ExecutionEngine.nativeGetRSS();
        }
        // This catch is broad to specifically include the UnsatisfiedLinkError that arises when
        // using the hsqldb backend on linux -- along with any other exceptions that might arise.
        // Otherwise, the hsql backend would get an annoying report to stdout
        // as the useless stats thread got needlessly killed.
        catch (Throwable e) { }
        if (rss > 0) mode = GetRSSMode.MACOSX_NATIVE;

        // try procfs
        rss = getRSSFromProcFS();
        if (rss > 0) mode = GetRSSMode.PROCFS;

        // notify users if stats collection might be slow
        if (mode == GetRSSMode.PS) {
            VoltLogger logger = new VoltLogger("HOST");
            logger.warn("System statistics will be collected in a sub-optimal "
                    + "manner because either procfs couldn't be read from or "
                    + "the native library couldn't be loaded.");
        }
    }
451720
private static void setSystemProperties() {
        // KernelBootstrap also sets these properties in case the bootstrap
        // agent wasn't used for some reason.

        String loggingManager = System.getProperty("java.util.logging.manager");
        //if (loggingManager == null)
        //    System.setProperty("java.util.logging.manager", "com.ibm.ws.kernel.boot.logging.WsLogManager");

        String managementBuilderInitial = System.getProperty("javax.management.builder.initial");
        if (managementBuilderInitial == null)
            System.setProperty("javax.management.builder.initial", "com.ibm.ws.kernel.boot.jmx.internal.PlatformMBeanServerBuilder");
    }
908644
public void initConfiguration(Map<?, ?> configurationMap) {
		ConfigurationPropertyReader propertyReader = new ConfigurationPropertyReader( configurationMap );

		this.configUrl = propertyReader
				.property( InfinispanProperties.CONFIGURATION_RESOURCE_NAME, URL.class )
				.withDefault( InfinispanConfiguration.class.getClassLoader().getResource( INFINISPAN_DEFAULT_CONFIG ) )
				.getValue();

		this.jndi = propertyReader
				.property( InfinispanProperties.CACHE_MANAGER_JNDI_NAME, String.class )
				.getValue();

		log.tracef( "Initializing Infinispan from configuration file at %1$s", configUrl );
	}
652981
def _init_env(self):
        '''
        
        '''
        from salt.config import minion_config
        from salt.grains import core as g_core
        g_core.__opts__ = minion_config(self.DEFAULT_MINION_CONFIG_PATH)
        self.grains_core = g_core
1362053
def init_config(self, app):
        """"""
        # Set up API endpoints for records.
        for k in dir(config):
            if k.startswith('RECORDS_REST_'):
                app.config.setdefault(k, getattr(config, k))

        # Resolve the Elasticsearch error handlers
        handlers = app.config['RECORDS_REST_ELASTICSEARCH_ERROR_HANDLERS']
        for k, v in handlers.items():
            handlers[k] = obj_or_import_string(v)
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')
1019539
public void initialize(URI name, Configuration conf) throws IOException {
    fs.initialize(name, conf);
  }
48249
private synchronized void initialize() {

    if (this.runtimes != null) {
      return;
    }

    this.runtimes = new HashMap<>();

    for (final AvroRuntimeDefinition rd : runtimeDefinition.getRuntimes()) {
      try {

        // We need to create different injector for each runtime as they define conflicting bindings. Also we cannot
        // fork the original injector because of the same reason.
        // We create new injectors and copy form the original injector what we need.
        // rootInjector is an emptyInjector that we copy bindings from the original injector into. Then we fork
        // it to instantiate the actual runtime.
        final Injector rootInjector = Tang.Factory.getTang().newInjector();
        initializeInjector(rootInjector);

        final Configuration runtimeConfig =
            Tang.Factory.getTang().newConfigurationBuilder()
                .bindNamedParameter(RuntimeName.class, rd.getRuntimeName().toString())
                .bindImplementation(Runtime.class, RuntimeImpl.class)
                .build();

        final Configuration config =
            new AvroConfigurationSerializer().fromString(rd.getSerializedConfiguration().toString());

        final Injector runtimeInjector = rootInjector.forkInjector(config, runtimeConfig);

        this.runtimes.put(rd.getRuntimeName().toString(), runtimeInjector.getInstance(Runtime.class));

      } catch (final IOException | InjectionException e) {
        throw new RuntimeException("Unable to initialize runtimes.", e);
      }
    }
  }
852011
protected function initializeRoutesConfiguration()
    {
        if ($this->routesConfiguration === null) {
            $this->routesConfiguration = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_ROUTES);
        }
    }
1150001
private void initializeConfig() {
        mainConfig.setValue("System.Setup", true);
        mainConfig.setValue("System.QuickSetup.Enable", false);
        mainConfig.setValue("System.QuickSetup.Currency.Name", "Dollar");
        mainConfig.setValue("System.QuickSetup.Currency.NamePlural", "Dollars");
        mainConfig.setValue("System.QuickSetup.Currency.Minor", "Coin");
        mainConfig.setValue("System.QuickSetup.Currency.MinorPlural", "Coins");
        mainConfig.setValue("System.QuickSetup.Currency.Sign", "$");
        mainConfig.setValue("System.QuickSetup.StartBalance", 100.0);
        mainConfig.setValue("System.QuickSetup.PriceBank", 200.0);
        mainConfig.setValue("System.QuickSetup.DisplayMode", "long");
        mainConfig.setValue("System.CheckNewVersion", true);
        mainConfig.setValue("System.Case-sentitive", false);
        mainConfig.setValue("System.CreateOnLogin", false);
        mainConfig.setValue("System.Logging.Enabled", false);
        mainConfig.setValue("System.Database.Type", "h2");
        mainConfig.setValue("System.Database.Address", "localhost");
        mainConfig.setValue("System.Database.Port", 3306);
        mainConfig.setValue("System.Database.Username", "root");
        mainConfig.setValue("System.Database.Password", "");
        mainConfig.setValue("System.Database.Db", "craftconomy");
        mainConfig.setValue("System.Database.Prefix", "cc3_");
        mainConfig.setValue("System.Database.Poolsize", 10);
        mainConfig.setValue("System.Database.ConvertFromH2", false);
    }
301972
def _read_config(self):
        """"""
        config = configparser.ConfigParser()
        config.read(self.path)
        if config.has_section('distutils'):
            server_names = config.get('distutils', 'index-servers')
            servers = [name.strip() for name in server_names.split('\n')]
            servers = [server for server in servers if server]

            for server in servers:
                repo_config = RepositoryConfig(server)
                repo_config.fill(config, server)
                self.repositories.append(repo_config)

        repo_config = RepositoryConfig('default')
        repo_config.fill(config, 'server-login')
331964
protected function initAllConfigs()
    {
        if ($this->isInitialized) {
            return;
        }

        $this->logger->info('Checking and initializing config files');
        foreach ($this->getEnvironments() as $environment) {
            $this->initConfig($environment);
        }

        $this->isInitialized = true;
    }
290224
public void init(Configuration conf, Path generatedModel) throws IOException, InterruptedException {
		FileSystem fileSystem = FileSystem.get(conf);
		for(Category category : Category.values()) {
			wordCountPerCategory.put(category, new HashMap<String, Integer>()); // init token count
		}
		// Use a HashSet to calculate the total vocabulary size
		Set<String> vocabulary = new HashSet<String>();
		// Read tuples from generate job
		for(FileStatus fileStatus : fileSystem.globStatus(generatedModel)) {
      TupleFile.Reader reader = new TupleFile.Reader(fileSystem, conf, fileStatus.getPath());
      Tuple tuple = new Tuple(reader.getSchema());
			while(reader.next(tuple)) {
				// Read Tuple
				Integer count = (Integer) tuple.get("count");
				Category category = (Category) tuple.get("category");
				String word = tuple.get("word").toString();
				vocabulary.add(word);
				tokensPerCategory.put(category, MapUtils.getInteger(tokensPerCategory, category, 0) + count);
				wordCountPerCategory.get(category).put(word, count);
			}
			reader.close();
		}
		V = vocabulary.size();
	}
499825
public void init() {
        isDirty = false;

        // If we haven't looked at anything from the cache or the filesystem, this is bootstrap time
        boolean firstInit = cachedFeatures.isEmpty();

        autoFeatures = new ArrayList<SubsystemFeatureDefinitionImpl>();
        knownFeatures = new HashMap<File, SubsystemFeatureDefinitionImpl>();
        knownBadFeatures = new HashMap<File, BadFeature>();

        // Read feature cache, this will only toss files that no longer exist
        // stale will be marked true if feature definitions were discarded.
        readCache(firstInit);

        // Now we need to go find / update the cache with anything new/interesting/different.
        // This will happen at most twice...
        readFeatureManifests();

        // If something was out of sync with the filesystem and this is the first pass,
        // reset the installed features list so we re-figure out what should be installed.
        if (isDirty && firstInit) {
            // If stale, reset to empty list as we'll be rebuilding....
            installedFeatures = Collections.emptySet();
            configuredFeatures = Collections.emptySet();
        }
    }
583172
public void initSystem() {
        createIzouPropertiesFile();
        setSystemProperties();
        reloadFile(null);

        try {
            if (System.getProperty(IZOU_CONFIGURED).equals("false")) {
                fatal("Izou not completely configured, please configure Izou and launch again.");
                System.exit(0);
            }
        } catch (NullPointerException e) {
            fatal("Izou not completely configured, please configure Izou by editing izou.properties in the " +
                    "properties folder and launch again.");
            System.exit(0);
        }
    }
1035833
public void init(Configuration configuration)
			throws Exception
	{
		LOGGER.debug("Initializing AbstractBundleInterceptor");

		localizationBundleFactory = configuration.getLocalizationBundleFactory();

		findResourceBundleFactory(configuration);
	}