Boot enabled addons
166388
public function boot()
    {
        $entries = AddonModel::query()
                             ->where('enabled', true)
                             ->get();

        /** @var AddonModel $entry */
        foreach ($entries as $entry) {
            if ($addon = $entry->resolveAddon()) {
                $addon->boot();
            }
        }

        PlatformBootedEvent::dispatch();
    }
1198336
public static function boot()
    {
        $extension = static::getInstance();

        Admin::extend($extension->name, get_called_class());

        if ($extension->disabled()) {
            return false;
        }

        if (!empty($css = $extension->css())) {
            Admin::css($css);
        }

        if (!empty($js = $extension->js())) {
            Admin::js($js);
        }

        return true;
    }
1207682
protected function bootConfiguration()
    {
        $path = $this->extensionPath . '/../';
        $this->addConfigComponent($this->routeGroup, $this->routeGroup, "{$path}/resources/config");
        $this->addLanguageComponent($this->routeGroup, $this->routeGroup, "{$path}/resources/lang");
        $this->addViewComponent($this->routeGroup, $this->routeGroup, "{$path}/resources/views");
    }
823208
public function boot()
    {
        $configFile = realpath(__DIR__ . '/../config/json-api.php');

        $this->mergeConfigFrom($configFile, 'json-api');
        $this->publishes([
            $configFile => config_path('json-api.php'),
        ]);

        if (config('json-api.routes.configure', false)) {
            if (!$this->app->routesAreCached()) {
                Route::group([], function (Router $router) {
                    require __DIR__ . '/../routes/api.php';
                });
            }
        }
    }
479138
public function boot()
    {
        \spl_autoload_register(__NAMESPACE__ . '\Loader::class_autoload', true);
        \spl_autoload_register(__NAMESPACE__ . '\Loader::alias_autoload', true);

        static::$aliases = Config::get('services.aliases');

        if (\is_admin() || Request::is_wp_login()) {
            $this->class_list[] = \Snap\Admin\Whitelabel::class;
            $this->class_list[] = \Snap\Admin\Columns\Post_Template::class;
            $this->class_list[] = \Snap\Media\Admin::class;

            $this->conditional_load('admin.snap_admin_theme', 'Snap\Admin\Theme');
        } else {
            $this->class_list[] = \Snap\Http\Middleware\Is_Logged_In::class;
        }

        $this->conditional_load('theme.disable_comments', 'Snap\Admin\Disable_Comments');
        $this->conditional_load('theme.disable_customizer', 'Snap\Admin\Disable_Customizer');
        $this->conditional_load('theme.disable_tags', 'Snap\Admin\Disable_Tags');

        foreach ($this->class_list as $module) {
            Container::resolve($module)->run();
        }

        $this->init_widgets();

        // Now all core files are loaded, turn on output buffer until a view is dispatched.
        \ob_start();
    }
281433
public function boot(): void
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                MakeIntentCommand::class,
                MakeInteractionCommand::class,
                MakeActivatorCommand::class,
                ListDriversCommand::class,
                InstallDriverCommand::class,
                ListChannelsCommand::class,
                ListIntentsCommand::class,
            ]);
        }
    }
1355640
public function boot()
    {
        view()->composer([
            'webed-theme::front._partials.sidebar',
        ], SidebarViewComposer::class);

        view()->composer([
            'webed-theme::front._partials.header',
        ], HeaderViewComposer::class);

        view()->composer([
            'webed-theme::front._partials.footer',
        ], FooterViewComposer::class);

        view()->composer([
            'webed-theme::front.errors.401',
            'webed-theme::front.errors.403',
            'webed-theme::front.errors.404',
            'webed-theme::front.errors.405',
            'webed-theme::front.errors.500',
            'webed-theme::front.errors.503',
        ], HttpErrorsViewComposer::class);
    }
1211114
def bootstrap(options):
    """"""
    try:
        import virtualenv
    except ImportError, e:
        raise RuntimeError("virtualenv is needed for bootstrap")

    bdir = options.bootstrap_dir
    if not os.path.exists(bdir):
        os.makedirs(bdir)
    bscript = "boostrap.py"

    options.virtualenv.script_name = os.path.join(options.bootstrap_dir,
                                                  bscript)
    options.virtualenv.no_site_packages = True
    options.bootstrap.no_site_packages = True
    print options.virtualenv.script_name
    call_task('paver.virtual.bootstrap')
    sh('cd %s; %s %s' % (bdir, sys.executable, bscript))
1017915
public static function bootstrap()
    {
        on('install',        'Pyrite\Users::install');
        on('user_fromemail', 'Pyrite\Users::fromEmail');
        on('user_resolve',   'Pyrite\Users::resolve');
        on('authenticate',   'Pyrite\Users::login');
        on('user_update',    'Pyrite\Users::update');
        on('user_create',    'Pyrite\Users::create');
        on('user_search',    'Pyrite\Users::search');
        on('ban_user',       'Pyrite\Users::ban');
        on('unban_user',     'Pyrite\Users::unban');
        on('clean_userids',  'Pyrite\Users::cleanList');
        on('all_users',      'Pyrite\Users::listAll');
    }
261804
public function boot()
	{
		$this->package('wardrobe/core');
		$this->setConnection();
		$this->bindRepositories();
		$this->bootCommands();

		require_once __DIR__.'/../../themeHelpers.php';
		require_once __DIR__.'/../../routes.php';
		require_once __DIR__.'/../../filters.php';
	}
480864
public function boot()
    {
        $finder = $this->app->make('orchestra.extension.finder');

        foreach ($this->extensions as $name => $path) {
            if (\is_numeric($name)) {
                $finder->addPath($path);
            } else {
                $finder->registerExtension($name, $path);
            }
        }
    }
365178
private function boot() {
        /**
         * making this loop for all type of assets
         * that we include and user in out sub classes
         */
        $this->loop = [
            'include' => $this->include,
            'ignore'  => $this->ignore,
            'css'     => $this->css,
            'js'      => $this->js,
        ];
        
        //modifying the baseDir for use
        $temp_base_dir = $this->baseDir;
        if ( ! is_dir($temp_base_dir)) {
            $temp_base_dir = config('asset.bower_dir') . $temp_base_dir;
        }
        $temp_base_dir = rtrim($temp_base_dir, '/') . '/';
        
        /**
         * foreach contents we search glob patterns or arrays
         * and list of the file that should be included
         */
        foreach ($this->loop as $kind => $contents) {
            if ( ! empty($contents)) {
                if ( ! is_array($contents)) {
                    $contents = [$contents];
                }
                $contentTemp = [];
                foreach ($contents as $content) {
                    if (preg_match("/\*/", $content)) {
                        $temp = $this->glob($temp_base_dir . $content);
                        foreach ($temp as $k => $contentFile) {
                            $contentTemp[] = str_replace($temp_base_dir, '', $contentFile);
                        }
                    } else {
                        $contentTemp[] = $content;
                    }
                }
                $this->loop[$kind] = $contentTemp;
            }
        }
    }
205799
def get_enabled():
    '''
    
    '''
    ret = []
    for rconf in ('/etc/rc.conf', '/etc/rc.conf.local'):
        if os.access(rconf, os.R_OK):
            with salt.utils.files.fopen(rconf, 'r') as _fp:
                for line in _fp:
                    line = salt.utils.stringutils.to_unicode(line)
                    if not line.strip():
                        continue
                    if not line.startswith('jail_list='):
                        continue
                    jails = line.split('"')[1].split()
                    for j in jails:
                        ret.append(j)
    return ret
839863
def bootstrap(**kwargs):
    
    # the user for the image is `ec2-user`, there is no sudo, but we can su to root w/o password
    original_host = env.host_string
    env.host_string = 'ec2-user@%s' % env.instance.uid
    bootstrap_files = env.instance.config.get('bootstrap-files', 'bootstrap-files')
    put('%s/authorized_keys' % bootstrap_files, '/tmp/authorized_keys')
    put(join(bsdploy_path, 'enable_root_login_on_daemonology.sh'), '/tmp/', mode='0775')
    run("""su root -c '/tmp/enable_root_login_on_daemonology.sh'""")
    # revert back to root
    env.host_string = original_host
    # give sshd a chance to restart
    sleep(2)
    run('rm /tmp/enable_root_login_on_daemonology.sh')

    # allow overwrites from the commandline
    env.instance.config.update(kwargs)

    bu = BootstrapUtils()
    bu.ssh_keys = None
    bu.upload_authorized_keys = False
    bu.bootstrap_files_yaml = 'daemonology-files.yml'
    bu.print_bootstrap_files()

    bu.create_bootstrap_directories()
    bu.upload_bootstrap_files({})
    # we need to install python here, because there is no way to install it via
    # ansible playbooks
    bu.install_pkg('/', chroot=False, packages=['python27'])
77495
public function boot()
    {
        $app = $this->app;

        (new Registrar)->boot($app, $this->environment->addons());

        $app['events']->fire(new Events\AddonBooted($this->environment));
    }
1056977
function addonsManager_enableAddon(aSpec) {
    var spec = aSpec || { };
    spec.button = "enable";

    var button = this.getAddonButton(spec);
    this._controller.click(button);
  }
554926
protected function bootCommand()
    {
        foreach ($this->commands as $command) {
            $this->add($this->app->make($command));
        }
    }