Recreate the hooks in the site store to trigger this SubScheduler.
421005
def migrateUp(self):
        
        te = self.store.findFirst(TimedEvent, sort=TimedEvent.time.descending)
        if te is not None:
            self._transientSchedule(te.time, None)
32485
function refreshSourceRow (target, source) {
        var row = upToSourceRow(target),
            newRow = rowFactory(source, source.getIndex());
        sourceRows.replaceChild(newRow, row);
        updateSourceRow(source);
    }
723983
function executeScheduledCall() {

	var call = scheduledCall;
	scheduledCall = undefined;

	if (call._step === 1) {
		reprocess();
	}
	else if (call._step === 2) {
		reparse();
	}
	else {
		reevaluate(call._clearContainerCache, undefined, call._contexts);
	}

}
100865
def migrateUp(self):
        
        siteStore = self.store.parent
        def _():
            # No convenience method for the following because needing to do it is
            # *rare*.  It *should* be ugly; 99% of the time if you need to do this
            # you're making a mistake. -glyph
            siteStoreSubRef = siteStore.getItemByID(self.store.idInParent)
            self.cloneInto(siteStore, siteStoreSubRef)
            IScheduler(self.store).migrateUp()
        siteStore.transact(_)
477009
def update_webhook(self, webhook_url, webhook_id, events=None):
        """"""
        hooks = self._request(MINUT_WEBHOOKS_URL, request_type='GET')['hooks']
        try:
            self._webhook = next(
                hook for hook in hooks if hook['url'] == webhook_url)
            _LOGGER.debug("Webhook: %s", self._webhook)
        except StopIteration:  # Not found
            if events is None:
                events = [e for v in EVENTS.values() for e in v if e]
            self._webhook = self._register_webhook(webhook_url, events)
            _LOGGER.debug("Registered hook: %s", self._webhook)
            return self._webhook
1316226
def _run_hooks(self):
        """"""
        for hook in self.hooks:
            getattr(self, hook)(self._state)
860198
def _run_hooks(self, name, module):
        
        hooks = self.post_load_hooks.pop(name, [])

        for hook in hooks:
            hook(module)
604936
protected void onSiteChange(String site) {

        try {
            m_treeData.removeAllItems();
            CmsObject rootCms = OpenCms.initCmsObject(A_CmsUI.getCmsObject());
            rootCms.getRequestContext().setSiteRoot("");
            CmsResource siteRootResource = rootCms.readResource(site);

            m_treeData.initRoot(rootCms, siteRootResource);
            m_fileTree.expandItem(siteRootResource.getStructureId());
            m_siteRoot = site;
            updateRoot(rootCms, siteRootResource);
        } catch (CmsException e) {
            LOG.error(e.getLocalizedMessage(), e);
        }
    }
1254804
def trigger_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/triggers"
        return self.call(api_path, method="POST", data=data, **kwargs)
813743
def dispatch_job_hook(self, link, key, job_config, logfile, stream=sys.stdout):
        """"""
        raise NotImplementedError("SysInterface.dispatch_job_hook")
950608
def trigger_repeat(execution_plan)
      request_id = ::Logging.mdc['request']
      ::Logging.mdc['request'] = SecureRandom.uuid
      if execution_plan.delay_record && recurring_logic_task_group
        args = execution_plan.delay_record.args
        logic = recurring_logic_task_group.recurring_logic
        logic.trigger_repeat_after(task.start_at, self.class, *args)
      end
    ensure
      ::Logging.mdc['request'] = request_id
    end
1145450
def init_scheduler(db_uri):
    """"""
    global scheduler
    scheduler = apscheduler.Scheduler()
    scheduler.misfire_grace_time = 3600
    scheduler.add_jobstore(
        sqlalchemy_store.SQLAlchemyJobStore(url=db_uri), 'default')
    scheduler.add_listener(
        job_listener,
        events.EVENT_JOB_EXECUTED | events.EVENT_JOB_MISSED
        | events.EVENT_JOB_ERROR)
    return scheduler
464838
private void scheduleUpdate() {
		if (!isVisible()) {
			return;
		}
		
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				try {
					container.gameLoop();
				} catch (SlickException e) {
					e.printStackTrace();
				}
				container.checkDimensions();
				scheduleUpdate();
			}
		});
	}
390064
def migrateDown(self):
        
        subStore = self.store.parent.getItemByID(self.store.idInParent)
        ssph = self.store.parent.findUnique(
            _SubSchedulerParentHook,
            _SubSchedulerParentHook.subStore == subStore,
            default=None)
        if ssph is not None:
            te = self.store.parent.findUnique(TimedEvent,
                                              TimedEvent.runnable == ssph,
                                              default=None)
            if te is not None:
                te.deleteFromStore()
            ssph.deleteFromStore()
60105
public void reloadJobs() {

        m_beanContainer.removeAllItems();
        for (CmsScheduledJobInfo job : m_manager.getAllElements()) {
            m_beanContainer.addBean(new CmsJobBean(job));
        }
        sort();
        refreshRowCache();

    }
835645
function reload () {
        sourceRows.innerHTML = ""; // Clear content
        sources.forEach(function (source, index) {
            if (flavor && !flavor[index]) {
                return;
            }
            sourceRows.appendChild(rowFactory(source, index));
            updateSourceRow(source);
        });
    }
559385
private void build() {
        // nextRecurringDate are computed based on *proposed* items, and not missing items (= proposed - existing). So
        // we need to filter out the dates for which there is no item left otherwsie we may end up in creating too many notification dates
        // and in particular that could lead to an infinite loop.
        for (final UUID subscriptionId : perSubscriptionFutureNotificationDates.keySet()) {
            final SubscriptionFutureNotificationDates tmp = perSubscriptionFutureNotificationDates.get(subscriptionId);
            if (tmp.getRecurringBillingMode() == BillingMode.IN_ADVANCE && !hasItemsForSubscription(subscriptionId, InvoiceItemType.RECURRING)) {
                tmp.resetNextRecurringDate();
            }
        }
        if (invoice != null && invoice.getInvoiceItems().isEmpty()) {
            invoice = null;
        }
    }