Processes pending server configuration file events (additions/modifications/removals).
519144
@Override
    public void processConfigurationChanges() {
        // The monitor ID is used to determine who is called to process file events.
        for (ServiceReference<FileMonitor> fm : fileMonitors.keySet()) {
            String monitorId = (String) fm.getProperty(com.ibm.ws.kernel.filemonitor.FileMonitor.MONITOR_IDENTIFICATION_NAME);
            if (monitorId != null && monitorId.equals("com.ibm.ws.kernel.monitor.config")) {
                fileMonitors.get(fm).processFileRefresh(false, null);
            }
        }
    }
202638
def start_processing_handler(self, event):
        """"""
        results_path = os.path.join(self.configuration['results_folder'],
                                    "filesystem.json")
        self.logger.debug("Event %s: start comparing %s with %s.",
                          event, self.checkpoints[0], self.checkpoints[1])

        results = compare_disks(self.checkpoints[0], self.checkpoints[1],
                                self.configuration)

        with open(results_path, 'w') as results_file:
            json.dump(results, results_file)

        self.processing_done.set()
369144
def on_modified(self, event):
        
        if os.path.isdir(event.src_path):
            return

        logger.debug("file modified: %s", event.src_path)

        name = self.file_name(event)

        try:
            config = yaml.load(open(event.src_path))
            self.target_class.from_config(name, config)
        except Exception:
            logger.exception(
                "Error when loading updated config file %s", event.src_path,
            )
            return

        self.on_update(self.target_class, name, config)
903765
@On(Orchid.Lifecycle.FilesChanged.class)
    public void onFilesChanges(Orchid.Lifecycle.FilesChanged event) {
        if (server != null && server.getWebsocket() != null) {
            server.getWebsocket().sendMessage("Files Changed", "");
        }
        context.build();
    }
1234901
public function onConfigUpdated()
    {
        parent::onConfigUpdated();

        if (($order = ini_get('request_order')) || ($order = ini_get('variables_order'))) {
            $this->variablesOrder = $order;
        } else {
            $this->variablesOrder = null;
        }
    }
745793
protected function configChanged() {
    if (self::$logger->isDebugEnabled()) {
      self::$logger->debug("Configuration is changed");
    }
    if (ObjectFactory::isConfigured()) {
      if (self::$logger->isDebugEnabled()) {
        self::$logger->debug("Emitting change event");
      }
      ObjectFactory::getInstance('eventManager')->dispatch(ConfigChangeEvent::NAME,
              new ConfigChangeEvent());
    }
  }
1005309
public void onFileChange(File file) {
        LOG.info("File updated : {}", file.getAbsolutePath());
        onFileDelete(file);
        onFileCreate(file);
    }
1139350
public function process()
    {
        foreach ($this->tierConfiguration->listTierConfigs(['status' => 'pending']) as $tierConfig) {
            $this->dispatchTierConfig($tierConfig);
        }

        foreach ($this->fulfillment->listRequests(['status' => 'pending']) as $request) {
            $this->dispatch($request);
        }
    }
737265
@PostConstruct
	public void preprocess() {
		// FIXME: what should this be?
		setProp(this.serviceId, DeploymentContextBasedVipAddresses.key(), this.serviceId);
		setProp(this.serviceId, EnableZoneAffinity.key(), "true");
	}
631775
protected void handleSSLChange() {

        String toBeReplaced = "http:";
        String newString = "https:";
        CmsSSLMode mode = (CmsSSLMode)m_simpleFieldEncryption.getValue();
        if (mode == null) {
            // mode is null if this is triggered by setContainerDataSource
            return;
        }
        if (mode.equals(CmsSSLMode.NO) | mode.equals(CmsSSLMode.SECURE_SERVER)) {
            toBeReplaced = "https:";
            newString = "http:";
        }
        m_simpleFieldServer.setValue(m_simpleFieldServer.getValue().replaceAll(toBeReplaced, newString));
        m_fieldSecureServer.setVisible(mode.equals(CmsSSLMode.SECURE_SERVER));
        m_fieldExclusiveError.setVisible(mode.equals(CmsSSLMode.SECURE_SERVER));
        m_fieldExclusiveURL.setVisible(mode.equals(CmsSSLMode.SECURE_SERVER));

    }
112520
def on_change(self, server_description):
        """"""
        # We do no I/O holding the lock.
        with self._lock:
            # Monitors may continue working on ismaster calls for some time
            # after a call to Topology.close, so this method may be called at
            # any time. Ensure the topology is open before processing the
            # change.
            # Any monitored server was definitely in the topology description
            # once. Check if it's still in the description or if some state-
            # change removed it. E.g., we got a host list from the primary
            # that didn't include this server.
            if (self._opened and
                    self._description.has_server(server_description.address)):
                self._process_change(server_description)
387334
public void run() {
    LOGGER.debug("begin scan for config file changes ...");
    try {
      Date lastModified = new Date(_xmlConfigFile.lastModified());

      if (_lastTimeRead == null || lastModified.after(_lastTimeRead)) {
        LOGGER.info("loading config file changes ...");
        this.loadServiceConfigFile();
        _lastTimeRead = new Date();
      }
    } catch (ConfigurationException e) {
      e.printStackTrace();
      LOGGER.error( "Error loading configuation file: ", e );
    }
    LOGGER.debug("finish scan for config file changes");
  }
292066
def process_events(args):
    """"""
    client = EventsClient.from_config()
    client.set_debug(True)
    if args.get:
        response = client.get_events()
    elif args.flush:
        response = client.flush_events()
    return response
672485
protected function update()
    {
        FileSystem::updateConfig();
        foreach (Daemon::$appInstances as $app) {
            foreach ($app as $appInstance) {
                $appInstance->handleStatus(AppInstance::EVENT_CONFIG_UPDATED);
            }
        }
    }
98024
public function onConfigUpdated()
    {
        parent::onConfigUpdated();
        if (Daemon::$process instanceof \PHPDaemon\Thread\Worker) {
            $pool = $this;
            FileSystem::readfile($this->config->file->value, function ($file, $data) use ($pool) {
                $pool->policyData = $data;
                $pool->enable();
            });
        }
    }
833478
synchronized void processFinished() {
        final InternalState required = this.requiredState;
        final InternalState state = this.internalState;
        // If the server was not stopped
        if(required == InternalState.STOPPED && state == InternalState.PROCESS_STOPPING) {
            finishTransition(InternalState.PROCESS_STOPPING, InternalState.PROCESS_STOPPED);
        } else {
            this.requiredState = InternalState.STOPPED;
            if ( !(internalSetState(getTransitionTask(InternalState.PROCESS_STOPPING), internalState, InternalState.PROCESS_STOPPING)
                    && internalSetState(getTransitionTask(InternalState.PROCESS_REMOVING), internalState, InternalState.PROCESS_REMOVING)
                    && internalSetState(getTransitionTask(InternalState.STOPPED), internalState, InternalState.STOPPED)) ){
                this.requiredState = InternalState.FAILED;
                internalSetState(null, internalState, InternalState.PROCESS_STOPPED);
            }
        }
    }
1077547
private void processFileNotifications() throws InterruptedException, TTException, IOException {
        while (true) {
            WatchKey key = mWatcher.take();
            Path dir = mKeyPaths.get(key);
            for (WatchEvent<?> evt : key.pollEvents()) {
                WatchEvent.Kind<?> eventType = evt.kind();
                if (eventType == OVERFLOW)
                    continue;
                Object o = evt.context();
                if (o instanceof Path) {
                    Path path = dir.resolve((Path)evt.context());
                    process(dir, path, eventType);
                }
            }
            key.reset();

            processFsnOnHold();
        }
    }