public RemoteScheduler(SchedulingContext schedCtxt,
    String schedId,
    String host,
    int port) 
{
        this.schedCtxt = schedCtxt;
        this.schedId = schedId;
        this.rmiHost = host;
        this.rmiPort = port;
}

Construct a RemoteScheduler instance to proxy the given RemoteableQuartzScheduler instance, and with the given SchedulingContext.

 public  void addCalendar(String calName,
    Calendar calendar,
    boolean replace,
    boolean updateTriggers) throws SchedulerException 
{
        try {
            getRemoteScheduler().addCalendar(schedCtxt, calName, calendar,
                    replace, updateTriggers);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void addGlobalJobListener(JobListener jobListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void addGlobalTriggerListener(TriggerListener triggerListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void addJob(JobDetail jobDetail,
    boolean replace) throws SchedulerException 
{
        try {
            getRemoteScheduler().addJob(schedCtxt, jobDetail, replace);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void addJobListener(JobListener jobListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void addSchedulerListener(SchedulerListener schedulerListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void addTriggerListener(TriggerListener triggerListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean deleteCalendar(String calName) throws SchedulerException 
{
        try {
            return getRemoteScheduler().deleteCalendar(schedCtxt, calName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public boolean deleteJob(String jobName,
    String groupName) throws SchedulerException 
{
        try {
            return getRemoteScheduler()
                    .deleteJob(schedCtxt, jobName, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public Calendar getCalendar(String calName) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getCalendar(schedCtxt, calName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public String[] getCalendarNames() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getCalendarNames(schedCtxt);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public SchedulerContext getContext() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getSchedulerContext();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Returns the SchedulerContext of the Scheduler.

 public List getCurrentlyExecutingJobs() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getCurrentlyExecutingJobs();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public JobListener getGlobalJobListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public List getGlobalJobListeners() throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public TriggerListener getGlobalTriggerListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public List getGlobalTriggerListeners() throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public JobDetail getJobDetail(String jobName,
    String jobGroup) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getJobDetail(schedCtxt, jobName,
                    jobGroup);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public String[] getJobGroupNames() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getJobGroupNames(schedCtxt);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public JobListener getJobListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public Set getJobListenerNames() throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public String[] getJobNames(String groupName) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getJobNames(schedCtxt, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public SchedulerMetaData getMetaData() throws SchedulerException 
{
        try {
            RemotableQuartzScheduler sched = getRemoteScheduler();
            return new SchedulerMetaData(getSchedulerName(),
                    getSchedulerInstanceId(), getClass(), true, isStarted(), 
                    isInStandbyMode(), isShutdown(), sched.runningSince(), 
                    sched.numJobsExecuted(), sched.getJobStoreClass(), 
                    sched.supportsPersistence(), sched.getThreadPoolClass(), 
                    sched.getThreadPoolSize(), sched.getVersion());
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

 public Set getPausedTriggerGroups() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getPausedTriggerGroups(schedCtxt);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

 protected RemotableQuartzScheduler getRemoteScheduler() throws SchedulerException 
{
        if (rsched != null) {
            return rsched;
        }
        try {
            Registry registry = LocateRegistry.getRegistry(rmiHost, rmiPort);
            rsched = (RemotableQuartzScheduler) registry.lookup(schedId);
        } catch (Exception e) {
            SchedulerException initException = new SchedulerException(
                    "Could not get handle to remote scheduler: "
                            + e.getMessage(), e);
            initException
                    .setErrorCode(SchedulerException.ERR_COMMUNICATION_FAILURE);
            throw initException;
        }
        return rsched;
}

 public String getSchedulerInstanceId() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getSchedulerInstanceId();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Returns the instance Id of the Scheduler.

 public List getSchedulerListeners() throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public String getSchedulerName() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getSchedulerName();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Returns the name of the Scheduler.

 public Trigger getTrigger(String triggerName,
    String triggerGroup) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getTrigger(schedCtxt, triggerName,
                    triggerGroup);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public String[] getTriggerGroupNames() throws SchedulerException 
{
        try {
            return getRemoteScheduler().getTriggerGroupNames(schedCtxt);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public TriggerListener getTriggerListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public Set getTriggerListenerNames() throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public String[] getTriggerNames(String groupName) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getTriggerNames(schedCtxt, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public int getTriggerState(String triggerName,
    String triggerGroup) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getTriggerState(schedCtxt, triggerName,
                    triggerGroup);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public Trigger[] getTriggersOfJob(String jobName,
    String groupName) throws SchedulerException 
{
        try {
            return getRemoteScheduler().getTriggersOfJob(schedCtxt, jobName,
                    groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public boolean interrupt(String jobName,
    String groupName) throws UnableToInterruptJobException 
{
        try {
            return getRemoteScheduler().interrupt(schedCtxt, jobName, groupName);
        } catch (RemoteException re) {
            throw new UnableToInterruptJobException(invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re));
        } catch (SchedulerException se) {
            throw new UnableToInterruptJobException(se);
        }
}

 protected SchedulerException invalidateHandleCreateException(String msg,
    Exception cause) 
{
        rsched = null;
        SchedulerException ex = new SchedulerException(msg, cause);
        ex.setErrorCode(SchedulerException.ERR_COMMUNICATION_FAILURE);
        return ex;
}

 public boolean isInStandbyMode() throws SchedulerException 
{
        try {
            return getRemoteScheduler().isInStandbyMode();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean isPaused() throws SchedulerException 
{
        return this.isInStandbyMode();
}

 public boolean isShutdown() throws SchedulerException 
{
        try {
            return getRemoteScheduler().isShutdown();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean isStarted() throws SchedulerException 
{
        try {
            return (getRemoteScheduler().runningSince() != null);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Whether the scheduler has been started.

Note: This only reflects whether #start() has ever been called on this Scheduler, so it will return true even if the Scheduler is currently in standby mode or has been since shutdown.

 public  void pause() throws SchedulerException 
{
        this.standby();
}

 public  void pauseAll() throws SchedulerException 
{
        try {
            getRemoteScheduler().pauseAll(schedCtxt);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void pauseJob(String jobName,
    String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().pauseJob(schedCtxt, jobName, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void pauseJobGroup(String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().pauseJobGroup(schedCtxt, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void pauseTrigger(String triggerName,
    String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler()
                    .pauseTrigger(schedCtxt, triggerName, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void pauseTriggerGroup(String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().pauseTriggerGroup(schedCtxt, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public boolean removeGlobalJobListener(JobListener jobListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean removeGlobalJobListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean removeGlobalTriggerListener(TriggerListener triggerListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean removeGlobalTriggerListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean removeJobListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean removeSchedulerListener(SchedulerListener schedulerListener) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public boolean removeTriggerListener(String name) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public Date rescheduleJob(String triggerName,
    String groupName,
    Trigger newTrigger) throws SchedulerException 
{
        try {
            return getRemoteScheduler().rescheduleJob(schedCtxt, triggerName,
                    groupName, newTrigger);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void resumeAll() throws SchedulerException 
{
        try {
            getRemoteScheduler().resumeAll(schedCtxt);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void resumeJob(String jobName,
    String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().resumeJob(schedCtxt, jobName, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void resumeJobGroup(String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().resumeJobGroup(schedCtxt, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void resumeTrigger(String triggerName,
    String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().resumeTrigger(schedCtxt, triggerName,
                    groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void resumeTriggerGroup(String groupName) throws SchedulerException 
{
        try {
            getRemoteScheduler().resumeTriggerGroup(schedCtxt, groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public Date scheduleJob(Trigger trigger) throws SchedulerException 
{
        try {
            return getRemoteScheduler().scheduleJob(schedCtxt, trigger);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public Date scheduleJob(JobDetail jobDetail,
    Trigger trigger) throws SchedulerException 
{
        try {
            return getRemoteScheduler().scheduleJob(schedCtxt, jobDetail,
                    trigger);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void setJobFactory(JobFactory factory) throws SchedulerException 
{
        throw new SchedulerException(
                "Operation not supported for remote schedulers.",
                SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}

 public  void shutdown() throws SchedulerException 
{
        try {
            String schedulerName = getSchedulerName();
            getRemoteScheduler().shutdown();
            SchedulerRepository.getInstance().remove(schedulerName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void shutdown(boolean waitForJobsToComplete) throws SchedulerException 
{
        try {
            String schedulerName = getSchedulerName();
            getRemoteScheduler().shutdown(waitForJobsToComplete);
            SchedulerRepository.getInstance().remove(schedulerName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void standby() throws SchedulerException 
{
        try {
            getRemoteScheduler().standby();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void start() throws SchedulerException 
{
        try {
            getRemoteScheduler().start();
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler.

 public  void triggerJob(String jobName,
    String groupName) throws SchedulerException 
{
        triggerJob(jobName, groupName, null);
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void triggerJob(String jobName,
    String groupName,
    JobDataMap data) throws SchedulerException 
{
        try {
            getRemoteScheduler().triggerJob(schedCtxt, jobName, groupName, data);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void triggerJobWithVolatileTrigger(String jobName,
    String groupName) throws SchedulerException 
{
        triggerJobWithVolatileTrigger(jobName, groupName, null);
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public  void triggerJobWithVolatileTrigger(String jobName,
    String groupName,
    JobDataMap data) throws SchedulerException 
{
        try {
            getRemoteScheduler().triggerJobWithVolatileTrigger(schedCtxt,
                    jobName, groupName, data);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.

 public boolean unscheduleJob(String triggerName,
    String groupName) throws SchedulerException 
{
        try {
            return getRemoteScheduler().unscheduleJob(schedCtxt, triggerName,
                    groupName);
        } catch (RemoteException re) {
            throw invalidateHandleCreateException(
                    "Error communicating with remote scheduler.", re);
        }
}

Calls the equivalent method on the 'proxied' QuartzScheduler, passing the SchedulingContext associated with this instance.