Refresh the includes/excludes information.
@throws IOException
777345
public synchronized void refreshNodes() throws IOException {
    hostsReader.refresh();
    LOG.info("After refresh Included hosts: " +
        hostsReader.getHostNames().size() +
        " Excluded hosts: " + hostsReader.getExcludedHosts().size());
    Set<String> newHosts = hostsReader.getHostNames();
    Set<String> newExcludes = hostsReader.getExcludedHosts();
    Set<ClusterNode> hostsToExclude = new HashSet<ClusterNode>();
    for (ClusterNode tmpNode : nameToNode.values()) {
      String host = tmpNode.getHost();
      // Check if not included or explicitly excluded.
      if (!newHosts.contains(host) || newExcludes.contains(host)) {
        hostsToExclude.add(tmpNode);
      }
    }
    for (ClusterNode node: hostsToExclude) {
      synchronized (node) {
        for (Map.Entry<ResourceType, RunnableIndices> entry :
          typeToIndices.entrySet()) {
          ResourceType type = entry.getKey();
          RunnableIndices r = entry.getValue();
          if (r.hasRunnable(node)) {
            LOG.info("Node " + node.getName() + " is no longer " +
              type + " runnable because it is excluded");
            r.deleteRunnable(node);
          }
        }
      }
    }
  }
248896
private Properties loadIncludes(File baseDir, Properties properties) throws IOException {
        return loadProperties(baseDir, properties, "include", false);
    }
1220194
protected boolean refreshFromSystem() {
        Lock lock = this.namespacesLock.writeLock();
        try {
            lock.lock();
            // Re-read and re-register all of the namespaces ...
            SessionCache systemCache = repository.createSystemSession(context, false);
            SystemContent system = new SystemContent(systemCache);
            Collection<Namespace> namespaces = system.readAllNamespaces();
            if (namespaces.isEmpty()) return false;
            this.cache.clear();
            this.cache.register(namespaces);
        } catch (Throwable e) {
            logger.error(e, JcrI18n.errorRefreshingNodeTypes, repository.name());
        } finally {
            lock.unlock();
        }
        return true;
    }
942372
private void updateOtherClientDisconnected() throws IOException
    {
        final byte cid = in.readByte();
        final String cname = readString();
        for (final ConnectionListener listener : listeners)
        {
            listener.notifyClientDisconnected(Byte.valueOf(cid), cname);
        }
    }
475138
public void refresh(String index) throws IOException {
        logger.debug("refresh index [{}]", index);

        String path = "/";

        if (index != null) {
            path += index + "/";
        }

        path += "_refresh";

        Response restResponse = lowLevelClient.performRequest("POST", path);
        logger.trace("refresh raw response: {}", asMap(restResponse));
    }
899215
public void refreshConnection() throws SQLException{
		this.connection.close(); // if it's still in use, close it.
		try{
			this.connection = this.pool.obtainRawInternalConnection();
		} catch(SQLException e){
			throw markPossiblyBroken(e);
		}
	}
484886
private void refresh() {
        if (!refreshCheckStart()) {
            return;
        }
        final TileStates tileStates = mTilesOverlay.getTileStates();
        do {
            mTilesOverlay.drawTiles(null, mProjection, mProjection.getZoomLevel(), mViewPort);
            boolean ready = true;
            if (mIncludeFlags != 0 && mIncludeFlags != INCLUDE_FLAGS_ALL) {
                if (ready && (mIncludeFlags & INCLUDE_FLAG_UPTODATE) == 0 && tileStates.getUpToDate() != 0) {
                    ready = false;
                }
                if (ready && (mIncludeFlags & INCLUDE_FLAG_EXPIRED) == 0 && tileStates.getExpired() != 0) {
                    ready = false;
                }
                if (ready && (mIncludeFlags & INCLUDE_FLAG_SCALED) == 0 && tileStates.getScaled() != 0) {
                    ready = false;
                }
                if (ready && (mIncludeFlags & INCLUDE_FLAG_NOTFOUND) == 0 && tileStates.getNotFound() != 0) {
                    ready = false;
                }
            }
            if (ready) {
                if (mStatus == Status.CANVAS_OK || mStatus == Status.PAINTING) {
                    return;
                }
                if (!refreshCheckFinish()) {
                    return;
                }
                mStatus = Status.PAINTING;
                if (mIsDetached) {
                    return;
                }
                draw();
                mStatus = Status.CANVAS_OK;
                final MapSnapshotable mapSnapshotable = mMapSnapshotable;
                if (mapSnapshotable != null) {
                    mapSnapshotable.callback(MapSnapshot.this);
                }
            }
        } while(refreshCheckEnd());
    }
559913
void refresh() {
    // no display, nothing to update
    if (this.viewer == null)
      return;

    Display.getDefault().asyncExec(new Runnable() {
      public void run() {
        DFSContentProvider.this.viewer.refresh();
      }
    });
  }
224793
public void refresh() {
    File configFile = new File(CONFIG_FILE_PATH);

    if (!configFile.exists()) {
      BufferedWriter writer = null;
      BufferedReader reader = null;
      try {
        configFile.createNewFile();
        InputStream in = Chemistry.class.getResourceAsStream("/org/helm/notation2/resources/MonomerStoreConfig.properties");
        reader = new BufferedReader(new InputStreamReader(in));

        writer = new BufferedWriter(new FileWriter(configFile));
        String line;
        while ((line = reader.readLine()) != null) {
          writer.write(line + System.getProperty("line.separator"));
        }

      } catch (Exception e) {
        resetConfigToDefault();
        e.printStackTrace();

      } finally {
        try {
          if (writer != null) {
            writer.close();
          }
          if (reader != null) {
            reader.close();
          }
        } catch (IOException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
    }

    try

    {
      PropertiesConfiguration conf = new PropertiesConfiguration(CONFIG_FILE_PATH);
      isUseWebservice = conf.getBoolean(USE_WEBSERVICE);
      isUpdateAutomatic = conf.getBoolean(UPDATE_AUTOMATIC);
      webserviceMonomersURL = conf.getString(WEBSERVICE_MONOMERS_URL);
      webserviceMonomersPath = conf.getString(WEBSERVICE_MONOMERS_PATH);
      webserviceMonomersPutPath = conf.getString(WEBSERVICE_MONOMERS_PUT_PATH);
      webserviceNucleotidesURL = conf.getString(WEBSERVICE_NUCLEOTIDES_URL);
      webserviceNucleotidesPath = conf.getString(WEBSERVICE_NUCLEOTIDES_PATH);
      webserviceNucleotidesPutPath = conf.getString(WEBSERVICE_NUCLEOTIDES_PUT_PATH);
      webserviceEditorCategorizationURL = conf.getString(WEBSERVICE_EDITOR_CATEGORIZATION_URL);
      webserviceEditorCategorizationPath = conf.getString(WEBSERVICE_EDITOR_CATEGORIZATION_PATH);
 
      /* load from external xml file */
      isUseExternalMonomers = conf.getBoolean(USE_EXTERNAL_MONOMERS);
      externalMonomersPath = conf.getString(EXTERNAL_MONOMERS_PATH);
      isUseExternalNucleotides = conf.getBoolean(USE_EXTERNAL_NUCLEOTIDES);
      externalNucleotidesPath = conf.getString(EXTERNAL_NUCLEOTIDES_PATH);
      isUseExternalAttachments = conf.getBoolean(USE_EXTERNAL_ATTACHMENTS);
      externalAttachmentsPath = conf.getString(EXTERNAL_ATTACHMENTS_PATH);

    } catch (ConfigurationException | NoSuchElementException e) {
      resetConfigToDefault();
      e.printStackTrace();
    }

  }
1039543
private void refresh() {
        synchronized (mTileAreas) {
            int index = 0;
            for (final MapTileArea area : mCache.getAdditionalMapTileList().getList()) {
                final MapTileArea copy;
                if (index < mTileAreas.getList().size()) {
                    copy = mTileAreas.getList().get(index);
                } else {
                    copy = new MapTileArea();
                    mTileAreas.getList().add(copy);
                }
                copy.set(area);
                index ++;
            }
            while (index < mTileAreas.getList().size()) {
                mTileAreas.getList().remove(mTileAreas.getList().size() - 1);
            }
            mTileIndices = mTileAreas.iterator();
        }
    }
428307
void reloadWhitelist() throws IOException {

    // read the entire whitelist into memory outside the
    // FSNamessytem lock.
    //
    LinkedList<String> paths = new LinkedList<String>();
    FileInputStream fstream = new FileInputStream(whitelistFile);
    DataInputStream in = new DataInputStream(fstream);
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    int count = 0;
    while (true) {
      String str = br.readLine();
      if (str == null) {
        break;                  // end of file
      }
      str = str.trim();         // remove all whitespace from start and end
      if (str.startsWith("#")) {
        continue;               // ignore lines with starting with #
      }
      paths.add(str);
      LOG.info("Whitelisted directory [" + count + "] " + str);
      count++;
    }
    in.close();

    // acquire the writelock and insert newly read entries into 
    // the Namenode's configuration.
    namesys.writeLock();
    try {
      namesys.neverDeletePaths.clear();
      for (String s: paths) {
        namesys.neverDeletePaths.add(s);
      }
    } finally {
      namesys.writeUnlock();
    }
  }
148471
protected void reload(final boolean forceReload) throws IOException {

        boolean reload = forceReload;
        for (int i = 0; i < locations.length; i++) {
            Resource location = locations[i];
            File file;

            try {
                file = location.getFile();
            } catch (IOException e) {
                // not a file resource
                // may be spring boot
                log.warn(e.toString());
                continue;
            }
            try {
                long l = file.lastModified();

                if (l > lastModified[i]) {
                    lastModified[i] = l;
                    reload = true;
                }
            } catch (Exception e) {
                // cannot access file. assume unchanged.
                if (log.isDebugEnabled()) {
                    log.debug("can't determine modification time of " + file + " for " + location, e);
                }
            }
        }
        if (reload) {
            doReload();
        }
    }
582016
public function refresh() {
        if($dir = opendir($this->dir)){
            while (false !== ($file = readdir($dir))) {
                if(!is_dir($file) && $file != '.' && $file != '..') {
                    if(strpos($file, 'u_')!==false){
                        @unlink($this->dir.$file);
                    }
                }
            }
        }
    }
877401
private synchronized void refreshCachedData() throws IOException {
    IOUtils.closeStream(committedTxnId);
    
    File currentDir = journalStorage.getSingularStorageDir().getCurrentDir();
    this.lastPromisedEpoch = new PersistentLongFile(
        new File(currentDir, LAST_PROMISED_FILENAME), 0);
    this.lastWriterEpoch = new PersistentLongFile(
        new File(currentDir, LAST_WRITER_EPOCH), 0);
    this.committedTxnId = new BestEffortLongFile(
        new File(currentDir, COMMITTED_TXID_FILENAME),
        HdfsConstants.INVALID_TXID);
    metrics.lastWriterEpoch.set(lastWriterEpoch.get());
  }
102492
public void refreshInheritedMethods(Set modifiedSuperExpandos) {
        for (Iterator i = modifiedSuperExpandos.iterator(); i.hasNext();) {
            ExpandoMetaClass superExpando = (ExpandoMetaClass) i.next();
            if (superExpando != this) {
                refreshInheritedMethods(superExpando);
            }
        }
    }
1349253
public function refresh(): void
    {
        $this->size = null;
        $this->lastModified = null;
        $this->isReadable = null;
        $this->isWritable = null;
        $this->exists = null;
        $this->created = null;
        $this->isSymLink = null;
        $this->isDir = null;
        $this->isFile = null;
        $this->isExecutable = null;
        $this->ownerId = null;
        $this->owner = null;
        $this->group = null;
        $this->groupId = null;
        $this->lastRead = null;
    }
328510
private void refreshBuffer() throws IOException {
    if (output == null) {
      // We're writing to a single buffer.
      throw new OutOfSpaceException();
    }

    // Since we have an output stream, this is our buffer
    // and buffer offset == 0
    output.write(buffer, 0, position);
    position = 0;
  }