Reload configuration document from store.
@throws AccessException If file could not be read.
558421
public function reload()
    {
        if ($this->root !== $this) {
            $this->root->reload();
            return;
        }
        if (! isset($this->store)) {
            return;
        }
        if (! $this->store->touch()) {
            return;
        }
        try {
            $this->store->open(false);
            $this->data = $this->store->read();
        } catch (AccessException $e) {
            throw new AccessException('Could not read configration: ' . $e->getMessage(), null, $e);
        }
        $this->store->close();
    }
1115475
public function reload($defaultSettingsFiles = array(), $userSettingsFile = null)
    {
        if (!empty($defaultSettingsFiles)
            || !empty($userSettingsFile)
        ) {
            $this->resetSettingsChain($defaultSettingsFiles, $userSettingsFile);
        }

        $reader = new IniReader();
        foreach ($this->settingsChain as $file => $ignore) {
            if (is_readable($file)) {
                try {
                    $contents = $reader->readFile($file);
                    $this->settingsChain[$file] = $this->decodeValues($contents);
                } catch (IniReadingException $ex) {
                    throw new IniReadingException('Unable to read INI file {' . $file . '}: ' . $ex->getMessage() . "\n Your host may have disabled parse_ini_file().");
                }

                $this->decodeValues($this->settingsChain[$file]);
            }
        }

        $merged = $this->mergeFileSettings();
        // remove reference to $this->settingsChain... otherwise dump() or compareElements() will never notice a difference
        // on PHP 7+ as they would be always equal
        $this->mergedSettings = $this->copy($merged);
    }
180066
public void load() {

        try {
            File f = new File(persistFile.toString());
            if (f.exists()) {
                // we have V4 config
                loadVer4(persistFile.toString());
            } else {
                String s1 = persistFile.toString().replace("3.xml", "2.xml");
                f = new File(s1);

                if (f.exists()) {
                    loadVer3(s1);
                    this.store();
                    f.delete();
                } else {
                    s1 = persistFile.toString().replace("3.xml", ".xml");
                    f = new File(s1);

                    if (f.exists()) {
                        if (!loadVer1(s1)) {
                            loadVer2(s1);
                        }
                    }

                    this.store();
                    f.delete();
                }
            }

//            File f = new File(persistFile.toString());
//            if (f.exists()) {
//                // we have V3 config
//                loadVer3(persistFile.toString());
//            } else {
//                String s1 = persistFile.toString().replace("2.xml", ".xml");
//                f = new File(s1);
//
//                if (f.exists()) {
//                    if (!loadVer1(s1)) {
//                        loadVer2(s1);
//                    }
//                }
//
//                this.store();
//                f.delete();
//            }
        } catch (XMLStreamException ex) {
            ex.printStackTrace();
            logger.error(String.format("Failed to load the SS7 configuration file. \n%s", ex.getMessage()));
        } catch (FileNotFoundException e) {
            logger.warn(String.format("Failed to load the SS7 configuration file. \n%s", e.getMessage()));
        } catch (IOException e) {
            logger.error(String.format("Failed to load the SS7 configuration file. \n%s", e.getMessage()));
        }
    }
1054580
public void configure(Config config) {
    LOGGER.debug("Reloading configuration.");
    this.configWriteLock.lock();
    try {
      this.config = config;
      processAppPackages(config);
    } finally {
      this.configWriteLock.unlock();
    }
  }
1119147
void reopen() {

        boolean isNew;

        setState(DATABASE_OPENING);

        try {
            databaseProperties = new HsqlDatabaseProperties(this);
            isNew = !DatabaseURL.isFileBasedDatabaseType(databaseType)
                    || !databaseProperties.checkFileExists();

            if (isNew && urlProperties.isPropertyTrue(
                    HsqlDatabaseProperties.url_ifexists)) {
                throw Error.error(ErrorCode.DATABASE_NOT_EXISTS, sName);
            }

            databaseProperties.load();
            databaseProperties.setURLProperties(urlProperties);
            compiledStatementManager.reset();

            nameManager    = new HsqlNameManager(this);
            granteeManager = new GranteeManager(this);
            userManager    = new UserManager(this);
            schemaManager  = new SchemaManager(this);
            persistentStoreCollection =
                new PersistentStoreCollectionDatabase();
            bReferentialIntegrity = true;
            sessionManager        = new SessionManager(this);
            txManager             = new TransactionManager(this);
            collation             = collation.getDefaultInstance();
            dbInfo = DatabaseInformation.newDatabaseInformation(this);

            databaseProperties.setDatabaseVariables();

            String version = databaseProperties.getProperty(
                HsqlDatabaseProperties.db_version);

            if (version.substring(0, 3).equals("1.7")) {
                schemaManager.createPublicSchema();
            }

            if (DatabaseURL.isFileBasedDatabaseType(databaseType)) {
                logger.openLog(this);
            }

            if (version.substring(0, 3).equals("1.7")
                    || version.substring(0, 5).equals("1.8.0")) {
                HsqlName name = schemaManager.findSchemaHsqlName(
                    SqlInvariants.PUBLIC_SCHEMA);

                if (name != null) {
                    schemaManager.setDefaultSchemaHsqlName(name);
                }
            }

            if (isNew) {
                String tableType = urlProperties.getProperty(
                    HsqlDatabaseProperties.hsqldb_default_table_type,
                    "MEMORY");

                if ("CACHED".equalsIgnoreCase(tableType)) {
                    schemaManager.setDefaultTableType(TableBase.CACHED_TABLE);
                }

                HsqlName name = nameManager.newHsqlName("SA", false,
                    SchemaObject.GRANTEE);

                userManager.createUser(name, "");

                Session session = sessionManager.getSysSession();

                granteeManager.grant(name.name,
                                     SqlInvariants.DBA_ADMIN_ROLE_NAME,
                                     granteeManager.getDBARole());
                logger.writeToLog(session,
                                  "CREATE USER SA PASSWORD \'\' ADMIN");
                schemaManager.createPublicSchema();
                logger.writeToLog(session,
                                  "CREATE SCHEMA PUBLIC AUTHORIZATION DBA");
                logger.writeToLog(
                    session, "SET DATABASE DEFAULT INITIAL SCHEMA PUBLIC");

                if (schemaManager.getDefaultTableType()
                        == Table.CACHED_TABLE) {
                    logger.writeToLog(
                        session, "SET DATABASE DEFAULT TABLE TYPE CACHED");
                }

                logger.synchLogForce();
            }

            dbInfo.setWithContent(true);
        } catch (Throwable e) {
            logger.closeLog(Database.CLOSEMODE_IMMEDIATELY);
            logger.releaseLock();
            setState(DATABASE_SHUTDOWN);
            clearStructures();
            DatabaseManager.removeDatabase(this);

            if (!(e instanceof HsqlException)) {
                e = Error.error(ErrorCode.GENERAL_ERROR, e.toString());
            }

            throw (HsqlException) e;
        }

        setState(DATABASE_ONLINE);
    }
531709
void reload() {

        CmsRpcAction<CmsResourceStatusBean> action = new CmsRpcAction<CmsResourceStatusBean>() {

            @Override
            public void execute() {

                start(0, true);
                CmsCoreProvider.getVfsService().getResourceStatus(
                    m_structureId,
                    CmsCoreProvider.get().getLocale(),
                    m_includeTargets,
                    m_detailContentId,
                    null,
                    this);
            }

            @Override
            protected void onResponse(CmsResourceStatusBean result) {

                reinitContent(result);
            }
        };
        action.execute();
    }
368341
private void load() throws IOException
   {
      if (PrivilegedFileHelper.exists(storage))
      {
         InputStream in = PrivilegedFileHelper.fileInputStream(storage);
         try
         {
            Properties props = new Properties();
            log.debug("loading namespace mappings...");
            props.load(in);

            // read mappings from properties
            Iterator<Object> iter = props.keySet().iterator();
            while (iter.hasNext())
            {
               String prefix = (String)iter.next();
               String uri = props.getProperty(prefix);
               log.debug(prefix + " -> " + uri);
               prefixToURI.put(prefix, uri);
               uriToPrefix.put(uri, prefix);
            }
            prefixCount = props.size();
            log.debug("namespace mappings loaded.");
         }
         finally
         {
            in.close();
         }
      }
   }
838910
def reload(self):
        """"""
        self.read_notmuch_config(self._notmuchconfig.filename)
        self.read_config(self._config.filename)
1069310
def reload(self):
        
        if not isinstance(self.filename, string_types):
            raise ReloadError()

        filename = self.filename
        current_options = {}
        for entry in OPTION_DEFAULTS:
            if entry == 'configspec':
                continue
            current_options[entry] = getattr(self, entry)

        configspec = self._original_configspec
        current_options['configspec'] = configspec

        self.clear()
        self._initialise(current_options)
        self._load(filename, configspec)
297304
public static function reload()
    {
        global $PPHP;
        $db = $PPHP['db'];
        $_SESSION['ACL_INFO'] = null;
        if (!array_key_exists('id', $_SESSION['user'])) {
            return;
        };
        $userId = $_SESSION['user']['id'];

        $flat = $db->selectArray(
            "
            SELECT action, objectType, objectId
            FROM acl_users
            WHERE userId=?
            ",
            array($userId)
        );
        self::_load($flat);

        $flat = $db->selectArray(
            "
            SELECT action, objectType, objectId
            FROM users_roles
            INNER JOIN acl_roles ON acl_roles.role=users_roles.role
            WHERE users_roles.userId=?
            ",
            array($userId)
        );
        self::_load($flat);

        $_SESSION['ACL_ROLES'] = self::getRoles($userId);
    }
1146534
void showFilesConfiguration() {

        // Message to communicate the resolved configuration:
        String message;
        if (filesUrl != null) {
            String reload = filesReloadable ? "reloadable" : "non-reloadable";
            message = "Files will be served from: " + filesUrl + " (" + reload + ")";
        } else {
            message = "No static files will be served.";
        }
        log.info("Files: {}", message);
    }
1046751
public void load(FileConfiguration config) {
        this.config = config;
        
        try {
            parse();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }
606250
public synchronized boolean reloadConfigsIfNecessary() {
    long time = RaidNode.now();
    if (time > lastReloadAttempt + reloadInterval) {
      lastReloadAttempt = time;
      try {
        File file = new File(configFileName);
        long lastModified = file.lastModified();
        if (lastModified > lastSuccessfulReload &&
            time > lastModified + RELOAD_WAIT) {
          reloadConfigs();
          lastSuccessfulReload = time;
          lastReloadAttemptFailed = false;
          return true;
        }
      } catch (Exception e) {
        if (!lastReloadAttemptFailed) {
          LOG.error("Failed to reload config file - " +
              "will use existing configuration.", e);
        }
        lastReloadAttemptFailed = true;
      }
    }
    return false;
  }
689582
def reload_root_document
      {}.merge(collection.find({ _id: _id }, session: _session).read(mode: :primary).first || {})
    end
796362
public function load() {
		if( !$this->path ) {
			throw new \Exception('Unable to load AppConfig from undefined path');
		}
		$this->data	= json_decode(file_get_contents($this->path), true);
	}
1134374
protected function _load()
    {
        $file = new File($this->_file, "r");

        $data = @parse_ini_string($file->read(), true);
        if ($data === false) {
            throw new Exception\ParserErrorException(
                "Error parsing configuration file {$this->_file}"
            );
        }
        $this->_data = $data;
    }
1255347
public void reload() {
        try {
            if (_toplevel.specifics != null) _toplevel.specifics.clear();
            _toplevel.global = null;

            for (T object: _toplevel.retriever.call()) {
                _toplevel.insert(object, _toplevel.coordinates, 0);
            }
            if (_toplevel.global == null) throw new IllegalStateException("***GlobalDataObjectMissing");

            _toplevel.spread();
        } catch (Exception x) {
            throw new RuntimeException(x.getMessage(), x);
        }
    }