Reload the application & config after making changes.
501733
protected function reloadEnvironment()
    {
        // Reload the environment variables from the file.
        (new Dotenv(app()->environmentPath(), app()->environmentFile()))->overload();

        // Reload the config repository.
        $loader = new LoadConfiguration;
        $this->callSilent('config:clear');
        $loader->bootstrap(app());
    }
231103
public function reload(): void
    {
        $config = [];
        foreach($this->configSources as $src) {
            // If it's a string, then it's a file or directory path
            if (is_string($src)) {
                // If directory, get all config files within it, recursively
                if (is_dir($src)) {
                    $getConfigFiles = function(string $path) use (&$getConfigFiles) {
                        $fragments = [];
                        if (is_dir($path)) {
                            $d = dir($path);
                            while (($f = $d->read()) !== false) {
                                if ($f[0] === '.') {
                                    continue;
                                }
                                if (is_dir("$path/$f")) {
                                    $fragments = array_merge($fragments, $getConfigFiles("$path/$f"));
                                } else {
                                    $fragments[] = "$path/$f";
                                }
                            }
                        }
                        return $fragments;
                    };
                    $fragments = $getConfigFiles($src);
                    sort($fragments);
                    foreach($fragments as $c) {
                        $config = array_replace_recursive($config, $this->parseConfig(file_get_contents($c)));
                    }

                // If it's a file, just merge it's contents over the current config array
                } elseif (is_file($src)) {
                    $config = array_replace_recursive($config, $this->parseConfig(file_get_contents($src)));

                // If it doesn't exist in the filesystem, and it's not optional, throw an exception
                } elseif (array_search($src, $this->optional) === false) {
                    throw (new MissingConfigFileException("Required config file or directory `$src` is missing."))
                        ->setMissingPath($src);
                }

            // If the source is an array, just merge it in
            } elseif (is_array($src)) {
                $config = array_replace_recursive($config, $src);
            }
        }
        $this->config = $config;
    }
1029635
public function reload()
    {
        // update application components to the latest version
        if (file_exists($this->lock_file)) {
            unlink($this->lock_file);
        }

        $this->composer = $this->factory->createComposer($this->getIO());
    }
155347
def refresh(self):
        # type: () -> None
        """"""
        src = self._client.reload(self)
        self.__dict__.update(src.__dict__)
592689
def refresh(self):
        # type: () -> None
        """"""
        from pykechain.client import API_EXTRA_PARAMS
        src = self._client.reload(self, extra_params=API_EXTRA_PARAMS['activity'])
        self.__dict__.update(src.__dict__)
1246926
public void refresh() {
        this.productProperties = new Properties();
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File(this.installDir, PRODUCT_PROPERTIES_PATH));
            this.productProperties.load(fis);
        } catch (Exception e) {
        } finally {
            InstallUtils.close(fis);
        }
        featureDefs = null;
        installFeatureDefs = null;
        mfp = null;
    }
1346830
def reload_configuration(self, event):
        """"""

        super(EnrolManager, self).reload_configuration(event)
        self.log('Reloaded configuration.')
        self._setup()
158505
def app(config, src, dst, features, reload, force):
    """"""
    config = Path(config)
    if reload:
        argv = sys.argv.copy()
        argv.remove('--reload')
        monitor(config.dirname(), src, dst, argv)
    else:
        run(config, src, dst, force)
607361
protected function afterInstall()
    {
        $configSourceFile = __DIR__ . DIRECTORY_SEPARATOR . 'config.example.php';
        $configTargetFile = \Craft::$app->getConfig()->configDir . DIRECTORY_SEPARATOR . $this->handle . '.php';

        if (!file_exists($configTargetFile)) {
            copy($configSourceFile, $configTargetFile);
        }
    }
548918
def handle_config_change(self, new_config):
        
        if self.user_handler:
            self.user_handler(self.current_config, new_config)
        self._call_spec_handlers(new_config)
        self.current_config = copy.deepcopy(new_config)
1192416
final public function reload() {

		$app = Application::getInstance();
		$class = get_called_class();
		
		// properties to not reset
		$propertiesToSave = array('keyProperties', 'db', 'loadedFromDb', 'typeList', 'cache', 'errors');
		
		// save key from being unset
		$propertiesToSave = array_merge($propertiesToSave, $this->keyProperties);

		// unset all the other properties
		foreach ($this as $key => $value) {
			if (!in_array($key, $propertiesToSave)) {
				unset($this->$key);
			}
		}
		
		$this->cache  = array();
		$this->errors = array();
		
		$this->loadFromDb($this->getSqlKeyValues());
		
		// log the reload 
		$app->logEvent('Reloaded ' . $class . ' object with ' . $this->getKeyForEventlog());
		
	}
1334147
def _reload_maybe(self):
        
        ConfigModel = apps.get_model('djconfig.Config')

        data = dict(
            ConfigModel.objects
                .filter(key='_updated_at')
                .values_list('key', 'value'))

        if (not hasattr(self, '_updated_at') or
                self._updated_at != data.get('_updated_at')):
            self._reload()
63850
def _settings_changed(self, *args, **kwargs):
        """"""
        setting, value = kwargs['setting'], kwargs['value']
        if setting == self.name:
            self._reload(value)
469811
void reload(NetworkConfig config)
	{
		try
		{
			log.trace("Load config data from " + config.path + " into " + config);
			final ConfigPropertyData read = configService.read(config.path, configInstanceId, config.getLastRevision());

			// Abort if the server returns no config - we have the latest revision
			if (read == null || read.properties == null || read.properties.isEmpty())
				return;

			for (ConfigPropertyValue property : read.properties)
			{
				config.properties.set(property.getName(), property.getValue());
			}

			config.setLastRevision(read.revision);
		}
		catch (Throwable t)
		{
			log.warn("Error loading config from path " + config.path, t);
		}
	}
450793
def reload(self, reload_timeout=300, save_config=True):
        
        self.log("Reload not implemented on {} platform".format(self.platform))
300365
def refresh(self, index=None):
        """"""
        if index is None:
            index = self.get_stack_index()
        # Set current editor
        if self.get_stack_count():
            index = self.get_stack_index()
            finfo = self.data[index]
            editor = finfo.editor
            editor.setFocus()
            self._refresh_outlineexplorer(index, update=False)
            self.__refresh_statusbar(index)
            self.__refresh_readonly(index)
            self.__check_file_status(index)
            self.__modify_stack_title()
            self.update_plugin_title.emit()
        else:
            editor = None
        # Update the modification-state-dependent parameters
        self.modification_changed()
        # Update FindReplace binding
        self.find_widget.set_editor(editor, refresh=False)
682873
def reload(self):
        """"""

        app_profile_pb = self.instance_admin_client.get_app_profile(self.name)

        # NOTE: _update_from_pb does not check that the project and
        #       app_profile ID on the response match the request.
        self._update_from_pb(app_profile_pb)