Initiate config on suite start

@see org.testng.ISuiteListener#onStart(org.testng.ISuite)
438460
@Override
    public void onStart(ISuite suite) {
        logger.entering(suite);
        if (ListenerManager.isCurrentMethodSkipped(this)) {
            logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
            return;
        }

        // Nothing should query for SeLionConfig values before this point.
        Config.initConfig(suite);
        ConfigSummaryData.initConfigSummary();
        ReporterConfigMetadata.initReporterMetadata();

        // Printing the JVM information.
        // This info will help us when it comes to debugging issues on fusion
        // a typical output will be as below
        // 13:42:04.312 INFO - JDK Information: Java HotSpot(TM) 64-Bit Server VM from Oracle Corporation VM ver.
        // 23.7-b01
        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        String jdkInfo = runtime.getVmName() + " from " + runtime.getSpecVendor() + " ver. "
                + System.getProperty("java.version");
        logger.info("JDK Information: " + jdkInfo);
        logger.exiting();
    }
687986
@Override
    public void start(StartContext context) throws StartException {
        this.config = this.getConfigurationBuilder().build();

        EmbeddedCacheManager container = this.getCacheContainer();
        CacheMode mode = this.config.clustering().cacheMode();
        if (mode.isClustered() && (container.getCacheManagerConfiguration().transport().transport() == null)) {
            throw InfinispanMessages.MESSAGES.transportRequired(mode, this.name, container.getCacheManagerConfiguration().globalJmxStatistics().cacheManagerName());
        }

        SecurityActions.defineContainerConfiguration(container, this.name, this.config);

        log.debugf("%s cache configuration started", this.name);
    }
198045
private synchronized void init(AlluxioConfiguration alluxioConf) {
    mJobMasterInquireClient = MasterInquireClient.Factory.createForJobMaster(alluxioConf);
    mJobMasterClientPool =
        new JobMasterClientPool(JobMasterClientContext
            .newBuilder(ClientContext.create(alluxioConf)).build());
  }
1025760
@Override
    protected void onStart()
    {
        m_serviceCollection = new ServiceCollection<T>( m_context, m_serviceClass, new CollectionListener() );
        m_serviceCollection.start();
    }
594134
public synchronized static void initConfig(Map<ConfigProperty, String> initialValues) {
        SeLionLogger.getLogger().entering(initialValues);

        // only do this if the global config is not already initialized.
        if (xmlConfig == null) {
            xmlConfig = new XMLConfiguration();
            // don't auto throw, let each config value decide
            xmlConfig.setThrowExceptionOnMissing(false);
            // because we can config on the fly, don't auto-save
            xmlConfig.setAutoSave(false);

            // Set defaults
            loadInitialValues();
        }

        /*
         * otherwise, update the global config
         */

        // Load in our supplied values (if defined)
        loadValuesFromUser(initialValues);

        // Load in environment & system variables (if defined)
        loadValuesFromEnvironment();

        // Init Selenium configuration
        boolean runLocally = xmlConfig.getBoolean(ConfigProperty.SELENIUM_RUN_LOCALLY.getName());
        if (runLocally) {
            xmlConfig.setProperty(ConfigProperty.SELENIUM_HOST.getName(), "localhost");
        }

        SeLionLogger.getLogger().exiting();
    }
167635
@Override
    protected void onStart()
    {
        m_mappings = new HashMap<Bundle, List<T>>();
        // listen to bundles events
        m_context.addBundleListener( m_bundleListener = new SynchronousBundleListener()
        {

            public void bundleChanged( final BundleEvent bundleEvent )
            {
                switch( bundleEvent.getType() )
                {
                    case BundleEvent.STARTED:
                        register( bundleEvent.getBundle() );
                        break;
                    case BundleEvent.STOPPED:
                        unregister( bundleEvent.getBundle() );
                        break;
                }
            }

        }
            );

        // scan already started bundles
        Bundle[] bundles = m_context.getBundles();
        if( bundles != null )
        {
            for( Bundle bundle : bundles )
            {
                if( bundle.getState() == Bundle.ACTIVE )
                {
                    register( bundle );
                }
            }
        }
    }
8333
private void tryInit() {
    try {
      Configuration conf = getSnapshotConfiguration();
      if (conf != null) {
        // Since this is only used for background loading of transaction snapshots, we use the no-op metrics collector,
        // as there are no relevant metrics to report
        this.storage = new HDFSTransactionStateStorage(conf, new SnapshotCodecProvider(conf),
                                                       new TxMetricsCollector());
        this.storage.startAndWait();
        this.snapshotRefreshFrequency = conf.getLong(TxConstants.Manager.CFG_TX_SNAPSHOT_INTERVAL,
                                                     TxConstants.Manager.DEFAULT_TX_SNAPSHOT_INTERVAL) * 1000;
        this.initialized = true;
      } else {
        LOG.info("Could not load configuration");
      }
    } catch (Exception e) {
      LOG.info("Failed to initialize TransactionStateCache due to: " + e.getMessage());
    }
  }
651031
function main(onStart) {
    const conf = config.read();

    initLogging(conf);
    initFsStorage(conf);

    logger.debug('Default configuration file: %s', conf.path);
    logger.debug('Configuration parameters: %s', JSON.stringify(conf));

    runWebServer(conf, onStart);
}
874118
protected final void doStart(Collection<? extends Location> locations) {

        ServiceStateLogic.setExpectedState(this, Lifecycle.STARTING);
        try {
            preStart();
            driver.start();
            log.info("Entity {} was started with driver {}", new Object[]{this, driver});

            postDriverStart();
            connectSensors();
            postStart();
            ServiceStateLogic.setExpectedState(this, Lifecycle.RUNNING);
        } catch (Throwable t) {
            ServiceStateLogic.setExpectedState(this, Lifecycle.ON_FIRE);
            log.error("Error error starting entity {}", this);
            throw Exceptions.propagate(t);
        }
    }
201334
@Inject
   public void preStart() {
      // We have to do this before start, since some components may start before the actual cache and they
      // have to have access to the default metadata on some operations
      defaultMetadata = new EmbeddedMetadata.Builder()
            .lifespan(config.expiration().lifespan()).maxIdle(config.expiration().maxIdle()).build();
      transactional = config.transaction().transactionMode().isTransactional();
      batchingEnabled = config.invocationBatching().enabled();
   }
653311
public function init()
    {
        $testConfig = $this->getTestConfig();

        $this->cleanUpExceptionLogFile();
        $this->prepareShop();
        $this->setGlobalConstants();

        if ($testConfig->shouldRestoreShopAfterTestsSuite()) {
            $this->registerResetDbAfterSuite();
        }

        if ($testConfig->shouldInstallShop()) {
            $this->installShop();
        }

        /** @var \OxidEsales\Eshop\Core\Config $config */
        $config = oxNew(\OxidEsales\Eshop\Core\Config::class);
        \OxidEsales\Eshop\Core\Registry::set(\OxidEsales\Eshop\Core\Config::class, $config);

        $config->init();
    }
126189
public void     start(boolean buildInitial) throws Exception
    {
        Preconditions.checkState(state.compareAndSet(State.LATENT, State.STARTED), "Cannot be started more than once");

        client.getConnectionStateListenable().addListener(connectionStateListener);

        if ( buildInitial )
        {
            client.checkExists().creatingParentContainersIfNeeded().forPath(path);
            internalRebuild();
        }
        reset();
    }
85653
public void start(VersionsSelectionConfiguration configuration) throws AppEngineException {
    Preconditions.checkNotNull(configuration);
    Preconditions.checkNotNull(configuration.getVersions());
    Preconditions.checkArgument(configuration.getVersions().size() > 0);

    List<String> arguments = new ArrayList<>();
    arguments.add("app");
    arguments.add("versions");
    arguments.add("start");
    arguments.addAll(commonVersionSelectionArgs(configuration));

    execute(arguments);
  }
1001509
@Handler
    public void onStart(Start event) {
        synchronized (this) {
            if (runner != null && !runner.isInterrupted()) {
                return;
            }
            runner = new Thread(this, Components.simpleObjectName(this));
            runner.start();
        }
    }
126714
@Validate
    public void start() {
        Boolean enabled = configuration.getBooleanWithDefault("ehcache.enabled", true);
        if (!enabled) {
            return;
        }

        File config = new File(configuration.getBaseDir(), CUSTOM_CONFIGURATION);
        final ClassLoader original = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
            if (config.isFile()) {
                manager = CacheManager.create(config.getAbsolutePath());
            } else {
                URL url = EhCacheService.class.getClassLoader().getResource(INTERNAL_CONFIGURATION);
                if (url != null) {
                    manager = CacheManager.create(url);
                } else {
                    throw new ExceptionInInitializerError("Cannot instantiate EhCache, " +
                            "cannot load " + INTERNAL_CONFIGURATION + " file");
                }
            }
            manager.addCache(WISDOM_KEY);
            cache = manager.getCache(WISDOM_KEY);

            registration = context.registerService(Cache.class, this, new Hashtable<String, Object>());
        } finally {
            Thread.currentThread().setContextClassLoader(original);
        }


    }
924522
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        self.refresh_nodes.emit()
        return True
321821
public Jawn onStartup(Runnable callback) {
        Objects.requireNonNull(callback);
        bootstrapper.onStartup(callback);
        return this;
    }