Initialize the Rack builder instance for this server

 @return ::Rack::Builder instance
324150
def initialize_rack_builder
      roger_env = Class.new do
        class << self
          attr_accessor :project
        end

        def initialize(app)
          @app = app
        end

        def call(env)
          env["roger.project"] = self.class.project
          @app.call(env)
        end
      end

      roger_env.project = project

      builder = ::Rack::Builder.new
      builder.use roger_env
      builder.use ::Rack::ShowExceptions
      builder.use ::Rack::Lint
      builder.use ::Rack::ConditionalGet
      builder.use ::Rack::Head

      builder
    end
709430
protected function initializeFramework()
    {
        $this->registerAutoloader();

        $this->dependencyInjectionManager = new DependencyInjectionManager($this);
        
        $this->requestManager = new RequestManager($this);
        $this->request = $this->requestManager->buildRequest();
        
        $this->response = new Response($this->request);
        
        $this->dataSourceManager = new DataSourceManager($this, $this->getInstance('Zepi\\Turbo\\Backend\\VirtualDataSourceBackend'));
        $this->dataSourceManager->initializeDataSourceManager();
        
        $this->moduleManager = new ModuleManager($this, $this->getInstance('Zepi\\Turbo\\Backend\\VirtualModuleBackend'));
        $this->moduleManager->initializeModuleSystem();
        
        $this->runtimeManager = new RuntimeManager($this, $this->getInstance('Zepi\\Turbo\\Backend\\VirtualHandlerBackend'));
        $this->runtimeManager->initializeManager();
        
        $this->routeManager = new RouteManager($this, $this->getInstance('Zepi\\Turbo\\Backend\\VirtualRouteBackend'));
        $this->routeManager->initializeRoutingTable();
    }
1043556
protected function initialize()
    {
        if ($this->initialized) {
            return;
        }

        foreach ($this->classes as $class) {
            $this->providers[] = new $class;
        }

        foreach ($this->providers as $provider) {
            if ($provider instanceof BuilderAwareInterface) {
                $provider->setSchemaBuilder($this->schemaBuilder);
            }
        }

        $this->initialized = true;
    }
611388
protected function initialize(): void
	{
		// Create container instance and register it in itself so that it can be injected

		$this->container = $this->containerFactory();

		$this->container->registerInstance([Container::class, 'container'], $this->container);

		// Register self so that the application instance can be injected

		$this->container->registerInstance([Application::class, 'app'], $this);

		// Register file system instance

		$this->container->registerInstance([FileSystem::class, 'fileSystem'], new FileSystem);

		// Register config instance

		$this->config = $this->configFactory();

		$this->container->registerInstance([Config::class, 'config'], $this->config);
	}
269835
protected function registerBuilder() : void {
		$this->app->singleton('basset.builder', function($app) {
			return new Builder($app['files'], $app['basset.manifest'], $app['basset.path.build']);
		});

		$this->app->singleton('basset.builder.cleaner', function($app) {
			return new FilesystemCleaner($app['basset'], $app['basset.manifest'], $app['files'], $app['basset.path.build']);
		});
	}
143780
private function init()
    {
        // return the configurations from the config file
        $this->configurations = $this->helper->getConfigurations();

        // return an instance of the corresponding Provider concrete according to the configuration
        $this->provider = $this->provider_factory->create($this->configurations);
    }
818653
public function setup()
    {
        $this->di->set('config', $this->config);

        $this->initEnvironment($this->config);
        $this->initErrorHandler($this->config);
        $this->initLoader($this->config);
        $this->initModules($this->config);
        $this->initRoutes($this->config);
        $this->initServices($this->config);
        $this->initDispatcher();

        $this->application->setDI($this->di);
        DI::setDefault($this->di);

        return $this;
    }
1127971
protected function init() {
        $this->container->set('logger', function($c) {
            $configuration = $c->get('configuration');

            $logger = new Logger($configuration['logger']);

            return $logger;
        });

        $this->container->set(MiddlewareFactory::class, function($c) {
            return new MiddlewareFactory();
        });

        $this->container->set('request', function($c) {
            $psr17Factory = new Psr17Factory();

            $creator = new ServerRequestCreator(
                $psr17Factory, // ServerRequestFactory
                $psr17Factory, // UriFactory
                $psr17Factory, // UploadedFileFactory
                $psr17Factory  // StreamFactory
            );

            return $creator->fromGlobals();
        });

        $this->container->set('router', function($c) {
            return new Router();
        });

        $this->container->set('response', function($c) {
            return new Response();
        });

        $this->container->set('view', function($c) {
            $configuration = $c->get('configuration')['view'];
            $viewFunctions = isset($configuration['viewFunctions']) ? $configuration['viewFunctions'] : [];
            return new Plates($configuration['viewPath'], $viewFunctions);
        });

        $this->registerErrorHandler();
    }
495936
public function init()
    {
        $client = ClientBuilder::create();
        if (true === is_array($this->hosts) && count($this->hosts) > 0) {
            $client->setHosts($this->hosts);
        }
        $this->client = $client->build();
        try {
            $e = $this->client->search(['index' => '_all', '_source' => false, 'body' => []]);
            /** @var null | Watch $watcher */
            $watcher = null;
            if (null !== $this->watcherClass) {
                if (true === class_exists($this->watcherClass)) {
                    $class = $this->watcherClass;
                    $watcher = new $class;
                }
            } else {
                $watcher = new $this->defaultWatcherClass;
            }
            if (null !== $watcher) {
                $watcher->setClient($this->client);
                $watcher->init();
                $this->watcher = $watcher;
                $this->started = true;
            } else {
                Yii::warning('There is no correct class defined for elasticsearch Watch. Search rolls back to common.');
            }
        } catch (NoNodesAvailableException $e) {
            Yii::warning('Elasticsearch said:' . $e->getMessage());
        }
    }
521352
public function initialize()
    {
        $vendorPath = $this->findVendorPath();

        $autoloader = $this->createAutoloader($vendorPath);

        return new Application($autoloader, array('composer.vendor_path' => $vendorPath));
    }
315754
static public function initialize()
    {
        if (!self::$_instance) {
            $cn = get_called_class();
            self::$_instance = new $cn();
            self::$_instance->name = substr($cn, 0, strpos($cn, '\\'));
        }
        self::$_instance->boot();
        
        if (Rails::cli())
            Rails::console()->run();
    }
919118
def create_rack(self):
        """"""
        return Rack(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
538580
private static function initInstance(): Instance
    {
        $instance = new Instance();
        if ($data = Config::get('registry')) {
            $instance->setFromArray($data);
        }
        return $instance;
    }
1279503
public function build() : ContainerInterface
    {
        try{
            foreach($this->modules as $module)
            {
                $module->install($this->container);
            }
        }
        catch(\Throwable $e)
        {
            throw new ContainerBuildingException($e);
        }
        return $this->container;
    }
843395
public function init()
    {
        $this->socketurl = sprintf($this->config->mastersocket->value,
            crc32(Daemon::$config->pidfile->value . "\x00" . Daemon::$config->user->value . "\x00" . Daemon::$config->group->value));
        if (Daemon::$process instanceof Thread\IPC) {
            $this->pool = MasterPool::getInstance(['listen' => $this->socketurl]);
            $this->pool->appInstance = $this;
            $this->pool->onReady();
        }
    }
400533
public function init()
    {
        foreach (self::$registered as $path => $module) {
            $path = trailingslashit($path);
            $source = $path . $module . '.php';
            $namespace = \Modularity\Helper\File::getNamespace($source);

            if (!$namespace) {
                continue;
            }

            require_once $source;
            $class = $namespace . '\\' . $module;
            $class = new $class();

            $this->register($class, $path);
        }

        do_action('Modularity/Init', $this);
    }
85165
public function init() {
		foreach ( self::$modules as $key => $module_class ) {
			if ( class_exists( $module_class ) ) {
				// Use this syntax instead of $module_class::get_instance()
				// for PHP 5.2 compatibility.
				self::$active_modules[ $key ] = call_user_func( [ $module_class, 'get_instance' ] );
			}
		}
	}