Checks if the scheduler is initialized and started

@return true if the scheduler is started, false otherwise
@throws MangooSchedulerException if an error occurred accessing the scheduler
969131
public boolean isStarted() throws MangooSchedulerException {
        boolean started;
        try {
            started = this.quartzScheduler != null && this.quartzScheduler.isStarted();
        } catch (SchedulerException e) {
            throw new MangooSchedulerException(e);
        }
        
        return started;
    }
478222
def check(self):
        
        parser = get_parser(self.scheduler_adapter.name, err_file=self.err_file, out_file=self.out_file,
                            run_err_file=self.run_err_file, batch_err_file=self.batch_err_file)
        parser.parse()
        self.errors = parser.errors
        if len(self.errors) == 0:
            return False
        else:
            return True
1324366
private boolean okayToSendServerStarted() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "okayToSendServerStarted", this);

        synchronized (lockObject) {
            if (!_sentServerStarted) {
                if ((_state == STATE_STARTED) && _mainImpl.isServerStarted()) {
                    _sentServerStarted = true;
                }
            }
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "okayToSendServerStarted", new Boolean(_sentServerStarted));
        return _sentServerStarted;
    }
46496
public static boolean isInitialized()
    {
        final Cache<Long, Type> cache1 = InfinispanCache.get().<Long, Type>getCache(Type.IDCACHE);
        final Cache<String, Type> cache2 = InfinispanCache.get().<String, Type>getCache(Type.NAMECACHE);
        final Cache<UUID, Type> cache3 = InfinispanCache.get().<UUID, Type>getCache(Type.UUIDCACHE);
        return !cache1.isEmpty() || !cache2.isEmpty() || !cache3.isEmpty();
    }
56022
private boolean startUpdate(UpdateRackHeartbeat updateRack,
                              UpdatePodSystem updatePod)
  {
    long now = CurrentTime.currentTime();
    
    if (_lastHubTime + getTimeout() < now) {
    }
    else if (_lastRackCrc != updateRack.getCrc()) {
    }
    else if (updatePod != null && _lastPodCrc != updatePod.getCrc()) {
    }
    else {
      return false;
    }
    
    _lastHubTime = now;
    _lastRackCrc = updateRack.getCrc();
    
    if (updatePod != null) {
      _lastPodCrc = updatePod.getCrc();
    }
    
    return true;
  }
1317101
public TimerScheduleType<TimerType<T>> getOrCreateSchedule()
   {
      Node node = childNode.getOrCreate("schedule");
      TimerScheduleType<TimerType<T>> schedule = new TimerScheduleTypeImpl<TimerType<T>>(this, "schedule", childNode, node);
      return schedule;
   }
460214
@Override
  public boolean start()
  {
    if (! _lifecycle.toStarting()) {
      return false;
    }

    _fd = createNative();

    if (_fd == 0) {
      _lifecycle.toDestroy();
      log.finer(this + " is not available on this system.");
      return false;
    }

    String name = "resin-select-manager-" + _gId++;
    _thread = new Thread(new SelectTask(), name);
    _thread.setDaemon(true);
    _thread.setPriority(Thread.MAX_PRIORITY);

    _thread.start();

    _lifecycle.waitForActive(2000);

    if (log.isLoggable(Level.FINER))
      log.finer(this + " active");

    log.fine("Async/poll keepalive enabled with max sockets = "
             + _selectMax);

    name = "resin-select-manager-timeout-" + _gId++;
    Thread timeoutThread = new Thread(new TimeoutTask(), name);
    timeoutThread.setDaemon(true);
    timeoutThread.start();

    return true;
  }
1236275
def start(self, *_):
        
        self.logger.info('Starting Scheduler...')
        db_manager.synch_db()
        self._load_managed_entries()

        try:
            self._load_freerun_entries()
        except LookupError as e:
            self.logger.warning('DB Lookup: {0}'.format(e))

        # Scheduler is initialized and running. GarbageCollector can be safely started
        self.gc.start()

        # Job/UOW Status Listeners can be safely started
        self.uow_listener.start()
        self.job_listener.start()

        self.logger.info('Startup Sequence Completed. Starting MX.')
        # Management Extension (MX) should be the last to start
        self.mx.start()
193877
public Boolean isSchedulerPaused() {
        try {
            return this.scheduler.isInStandbyMode();
        } catch (SchedulerException e) {
            logger.error("error retrieveing scheduler condition", e);
        }
        return null;
    }
73209
private void initializeDefaults() {
    defaultUlimitMinimum = rmConf.getInt(
        "mapred.capacity-scheduler.default-minimum-user-limit-percent", 100);
    defaultSupportPriority = rmConf.getBoolean(
        "mapred.capacity-scheduler.default-supports-priority", false);
    defaultMaxJobsPerUsersToInitialize = rmConf.getInt(
        "mapred.capacity-scheduler.default-maximum-initialized-jobs-per-user",
        2);
  }
5476
public boolean isInitialized() {
        WeakReference<Holder> ref = local.get();
        if (ref != null) {
            Holder holder = ref.get();
            return holder != null && holder.value != UNINITIALISED;
        } else {
            return false;
        }
    }
52257
final void rescheduleIfNeeded() {
		if (executeEvery > 0 && !TaskScheduler.stopping) {
			synchronized (this) {
				status = Task.STATUS_NOT_STARTED;
				executeIn(executeEvery);
			}
			TaskScheduler.schedule(this);
		} else if (nextExecution > 0 && !TaskScheduler.stopping) {
			synchronized (this) {
				this.status = Task.STATUS_NOT_STARTED;
			}
			TaskScheduler.schedule(this);
		}
	}
1065582
public boolean isRestartScheduled() {
        for (UpdateCenterJob job : getJobs()) {
            if (job instanceof RestartJenkinsJob) {
                RestartJenkinsJob.RestartJenkinsJobStatus status = ((RestartJenkinsJob) job).status;
                if (status instanceof RestartJenkinsJob.Pending
                        || status instanceof RestartJenkinsJob.Running) {
                    return true;
                }
            }
        }
        return false;
    }
706801
public boolean start() {
        if (!this.isStarted.compareAndSet(false, true)) {
            return false;
        }
        final long delay = this.delayBetweenSweeps;
        this.timer.scheduleWithFixedDelay(this, delay, delay, TimeUnit.MILLISECONDS);
        LogWatchStorageSweeper.LOGGER.info(
                "Scheduled automated unreachable message sweep in {} to run every {} millisecond(s).",
                this.messaging.getLogWatch(), delay);
        return true;
    }
188865
def run(self):
        ''''''
        logger.info("scheduler starting...")

        while not self._quit:
            try:
                time.sleep(self.LOOP_INTERVAL)
                self.run_once()
                self._exceptions = 0
            except KeyboardInterrupt:
                break
            except Exception as e:
                logger.exception(e)
                self._exceptions += 1
                if self._exceptions > self.EXCEPTION_LIMIT:
                    break
                continue

        logger.info("scheduler exiting...")
        self._dump_cnt()
485048
@Override
	public void ensureJvmMembersInitialized() {
		if (jvmMemberInitializers == null)
			return;
		Set<Runnable> localRunnables = null;
		synchronized(this) {
			localRunnables = jvmMemberInitializers;
			jvmMemberInitializers = null;
			hasJvmMemberInitializers = false;
		}
		if (localRunnables == null)
			return;
		boolean wasDeliver = eDeliver();
		LinkedHashSet<Triple<EObject, EReference, INode>> before = resolving;
		try {
			eSetDeliver(false);
			if (!before.isEmpty()) {
				resolving = new LinkedHashSet<Triple<EObject, EReference, INode>>();
			}
			if (isInitializingJvmMembers) {
				throw new IllegalStateException("Reentrant attempt to initialize JvmMembers");
			}
			try {
				isInitializingJvmMembers = true;
				for (Runnable runnable : localRunnables) {
					runnable.run();
				}
			} finally {
				isInitializingJvmMembers = false;
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		} finally {
			if (!before.isEmpty()) {
				resolving = before;
			}
			eSetDeliver(wasDeliver);
		}
	}
610287
protected boolean doStart()
  {
    if (! _lifecycle.isActive()) {
      return false;
    }
    
    if (! isEnable()) {
      return false;
    }
    
    int startingCount = _startingCount.getAndIncrement();

    int threadCount = _threadCount.get() + startingCount;

    if (_threadMax < threadCount) {
      _startingCount.decrementAndGet();
      
      onThreadMax();
      
      return false;
    }
    else if (isIdleTooLow(startingCount)) {
      return true;
    }
    else {
      _startingCount.decrementAndGet();
      
      return false;
    }
  }