Once a Discovery is updated we update each associated Service to reset
        its up/down status so that the next iteration of the `check_loop`
        loop does the proper reporting again.
979693
def on_discovery_update(self, name, new_config):
        
        for service in self.configurables[Service].values():
            if service.discovery == name:
                service.reset_status()
74497
protected void refreshSREListUI() {
		// Refreshes the SRE listing after a SRE install notification, might not
		// happen on the UI thread.
		final Display display = Display.getDefault();
		if (display.getThread().equals(Thread.currentThread())) {
			if (!this.sresList.isBusy()) {
				this.sresList.refresh();
			}
		} else {
			display.syncExec(new Runnable() {
				@SuppressWarnings("synthetic-access")
				@Override
				public void run() {
					if (!SREsPreferencePage.this.sresList.isBusy()) {
						SREsPreferencePage.this.sresList.refresh();
					}
				}
			});
		}
	}
1000359
private void initDiscovery() {
    if (discoveryServiceClient == null) {
      LOG.info("No DiscoveryServiceClient provided. Skipping service discovery.");
      return;
    }

    endpointStrategy = new TimeLimitEndpointStrategy(
      new RandomEndpointStrategy(
        discoveryServiceClient.discover(
          configuration.get(TxConstants.Service.CFG_DATA_TX_DISCOVERY_SERVICE_NAME,
                            TxConstants.Service.DEFAULT_DATA_TX_DISCOVERY_SERVICE_NAME))),
      2, TimeUnit.SECONDS);
  }
911552
void reportRestoredCheckpoint(RestoredCheckpointStats restored) {
		checkNotNull(restored, "Restored checkpoint");

		statsReadWriteLock.lock();
		try {
			counts.incrementRestoredCheckpoints();
			latestRestoredCheckpoint = restored;

			dirty = true;
		} finally {
			statsReadWriteLock.unlock();
		}
	}
685958
private final void setPersNew() {
		status = ObjectState.PERSISTENT_NEW;
		stateFlags = PS_PERSISTENT | PS_TRANSACTIONAL | PS_DIRTY | PS_NEW;
		context.getSession().internalGetCache().notifyDirty(this);
	}
601763
public function resetRemindStatus()
    {
        if ($this->oxarticles__oxremindactive->value == 2 &&
            $this->oxarticles__oxremindamount->value <= $this->oxarticles__oxstock->value
        ) {
            $this->oxarticles__oxremindactive->value = 1;
        }
    }
1035684
private function resetDynamicSettings()
    {
        // Ensure to reset services that need to be.
        foreach ($this->resettableServiceIds as $serviceId) {
            if (!$this->container->initialized($serviceId)) {
                continue;
            }

            $this->container->set($serviceId, null);
        }

        // Update services that can be updated.
        foreach ($this->updatableServices as $serviceId => $methodCalls) {
            if (!$this->container->initialized($serviceId)) {
                continue;
            }

            $service = $this->container->get($serviceId);
            foreach ($methodCalls as $callConfig) {
                list($method, $expression) = $callConfig;
                $argument = $this->expressionLanguage->evaluate($expression, ['container' => $this->container]);
                call_user_func_array([$service, $method], [$argument]);
            }
        }
    }
547877
def do_restart_service(self, service):
        
        if not self.has_cluster():
            return None

        if self.service_action(service=service, action="restart"):
            print("%s is being restarted" % (service))
        else:
            print("Error restarting service")
            return None
402360
async def _on_status_change(self, update):
        """"""

        info = update['payload']
        new_number = info['new_status']
        name = update['service']

        if name not in self.services:
            return

        with self._state_lock:
            is_changed = self.services[name].state != new_number
            self.services[name].state = new_number

        # Notify about this service state change if anyone is listening
        if self._on_change_callback and is_changed:
            self._on_change_callback(name, self.services[name].id, new_number, False, False)
30924
def reset_state(self):
        
        self.active_message = None
        self.measurement = None
        if self.is_waiting_to_shutdown:
            self.shutdown_connections()
        elif self.is_processing:
            self.set_state(self.STATE_IDLE)
        elif self.is_idle or self.is_connecting or self.is_shutting_down:
            pass
        else:
            LOGGER.critical('Unexepected state: %s', self.state_description)
        LOGGER.debug('State reset to %s (%s in pending)',
                     self.state_description, len(self.pending))
1242229
def _reset_changes(self):
        """"""
        self._original = {}
        if self.last_updated is not None:
            self._original['last_updated'] = self.last_updated
1331822
def updater_loop(self):
        
        self.updater_running = True
        while (self.updater_running):
            self.send_updates()
            sleep(self.updateinterval)
431448
@Override
    public void reset() {
        // just replace accumulator, gc will do the rest
        accumulator = new ThreadLocal<>();

        // resetting this counter too
        workersCounter.set(0);

        // reset indexes too
        index = new ThreadLocal<>();

        // throw away message queues
        for (int i = 0; i < parties; i++) {
            messages.get(i).clear();
        }
    }
659197
protected function resetup() {
		$this->setup_instance();

		$this->metadata = $this->fetch_metadata();
		$this->setup_metadata();

		$this->setup();
	}
625393
public static synchronized void resetAllCounters() {
		initializeCount.set(0);
		deployCount.set(0);
		undeployCount.set(0);
		startCount.set(0);
		stopCount.set(0);
		updateCount.set(0);
		errorCount.set( 0 );
	}
168696
private synchronized void myupdate(WSStats newStats, boolean keepOld, boolean recursiveUpdate) {
        if (newStats == null)
            return;

        StatsImpl newStats1 = (StatsImpl) newStats;
        // update the level and description of this collection
        this.instrumentationLevel = newStats1.getLevel();

        // update data
        updateMembers(newStats, keepOld);

        // update subcollections
        if (recursiveUpdate)
            updateSubcollection(newStats, keepOld, recursiveUpdate);
    }
267394
def refresh(self):
        
        self.invalidate()
        full = not self._manager._list_has_name
        res_list = self._manager.list(full_properties=full)
        self.update_from(res_list)