SchedulerClient (scheduling 8.4.0 API)

java.lang.Object
- org.ow2.proactive.scheduler.rest.ClientBase
- - org.ow2.proactive.scheduler.rest.SchedulerClient

All Implemented Interfaces:

Scheduler, ThirdPartyCredentials, SchedulerUsage, ISchedulerClient
```
public class SchedulerClient
extends ClientBase
implements ISchedulerClient
```

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addEventListener(SchedulerEventListener listener, boolean myEventsOnly, SchedulerEvent... events)` Add a scheduler event Listener.
`void`	`changeJobPriority(JobId jobId, JobPriority priority)` Change the priority of the job represented by jobId. Only administrator can change the priority to HIGH, HIGEST, IDLE.
`void`	`changeJobPriority(String jobId, JobPriority priority)` Change the priority of the job represented by jobId. Only administrator can change the priority to HIGH, HIGEST, IDLE. The jobId is given as a string.
`boolean`	`changeStartAt(JobId jobId, String startAt)` Change the START_AT generic information at job level and reset the scheduledAt at task level
`boolean`	`checkJobPermissionMethod(String sessionId, String jobId, String method)` Check if the user has the permission to execute the method passed as argument
`static ISchedulerClient`	`createInstance()` Creates an ISchedulerClient instance.
`boolean`	`deleteFile(String space, String pathname)` Deletes the specified file from the server.
`void`	`disconnect()` Disconnect properly the user from the scheduler.
`boolean`	`finishInErrorTask(String jobId, String taskName)`
`boolean`	`freeze()` For administrator only, Freeze the scheduler by terminating running tasks.
`List<JobUsage>`	`getAccountUsage(String user, Date start, Date end)` Returns details on job and task execution times for a given user's executions.
`ConnectionInfo`	`getConnectionInfo()` Returns the connection info, if initialized previously
`String`	`getCurrentPolicy()` Return the name of the current Policy
`String`	`getCurrentUser()` Returns the user currently connected
`UserData`	`getCurrentUserData()` Returns the user data object associated with the user currently connected
`List<String>`	`getGlobalSpaceURIs()` Returns the GLOBAL DataSpace URI available to all users
`String`	`getJobContent(JobId jobId)`
`JobInfo`	`getJobInfo(String jobId)` Retrieve a job info by it id.
`JobResult`	`getJobResult(JobId jobId)` Get the result for the given jobId.
`JobResult`	`getJobResult(String jobId)` Get the result for the given jobId. The jobId is given as a string.
`Page<JobInfo>`	`getJobs(int index, int range, JobFilterCriteria criteria, List<SortParameter<JobSortParameter>> arg3)` Retrieves a job list of the scheduler.
`String`	`getJobServerLogs(String jobId)` Retrieves server logs for a job with the given id.
`List<JobInfo>`	`getJobsInfoList(List<String> jobsId)` Returns a list of jobs info corresponding to the given job IDs (in the same order)
`JobState`	`getJobState(JobId jobId)` Return the state of the given job. The state contains informations about the job, every tasks and informations about the tasks. A user can only get the state of HIS job. If the job does not exist, a schedulerException is sent with the proper message.
`JobState`	`getJobState(String jobId)` Return the state of the given job. The state contains informations about the job, every tasks and informations about the tasks. The jobId is given as a string.
`Map`	`getJobsToSchedule()` get job Descriptor Map with eligible jobs (running and pending)
`List<JobUsage>`	`getMyAccountUsage(Date startDate, Date endDate)` Returns details on job and task execution times for the caller's executions.
`Map<Object,Object>`	`getPortalConfiguration()`
`Map<String,Object>`	`getSchedulerProperties()` Returns the scheduler properties associated with the user currently connected
`String`	`getSession()` Retrieves the current session identifier, or null if the session was not initialized yet.
`SchedulerStatus`	`getStatus()` Get the current status of the Scheduler
`Page<TaskId>`	`getTaskIds(String taskTag, long from, long to, boolean mytasks, boolean running, boolean pending, boolean finished, int offset, int limit)` Retrieve a tasks names list from the scheduler.
`TaskStatesPage`	`getTaskPaginated(String jobId, int offset, int limit)` Return the page of tasks of the given job.
`TaskResult`	`getTaskResult(JobId jobId, String taskName)` Get the result for the given task name in the given jobId.
`TaskResult`	`getTaskResult(String jobId, String taskName)` Get the result for the given task name in the given jobId.
`List<TaskResult>`	`getTaskResultsByTag(JobId jobId, String taskTag)` Get the results for a set of tasks in the given jobId and filtered by a given tag.
`List<TaskResult>`	`getTaskResultsByTag(String jobId, String taskTag)` Get the results for a set of tasks in the given jobId and filtered by a given tag.
`String`	`getTaskServerLogs(String jobId, String taskName)` Retrieves server logs for a task with the given id.
`String`	`getTaskServerLogsByTag(String jobId, String tag)` Retrieves server logs for a set of tasks filtered by the given tag.
`Page<TaskState>`	`getTaskStates(String taskTag, long from, long to, boolean mytasks, boolean running, boolean pending, boolean finished, int offset, int limit, SortSpecifierContainer sortParams)` Retrieve a taskstates list from the scheduler.
`List<TaskDescriptor>`	`getTasksToSchedule()` get task descriptor list with eligible tasks (running)
`List<SchedulerUserInfo>`	`getUsers()` Returns a list of connected users.
`List<String>`	`getUserSpaceURIs()` Returns the USER DataSpace URIs associated with the current user
`List<SchedulerUserInfo>`	`getUsersWithJobs()` Returns a list of users having jobs.
`void`	`init(ConnectionInfo connectionInfo)` Initialize this instance.
`boolean`	`isConnected()` Test whether or not the user is connected to the ProActive Scheduler.
`boolean`	`isJobFinished(JobId jobId)` Returns `true`, if the scheduler has finished the execution of the specified job.
`boolean`	`isJobFinished(String jobId)` Returns `true`, if the scheduler has terminated the execution of the specified job.
`boolean`	`isTaskFinished(String jobId, String taskName)` Returns `true`, if the scheduler has finished the execution of the task.
`boolean`	`kill()` For administrator only, Kill the scheduler. Will stop the scheduling, and shutdown the scheduler.
`boolean`	`killJob(JobId jobId)` Kill the job represented by jobId. This method will kill every running tasks of this job, and remove it from the scheduler. The job won't be terminated, it won't have result.
`boolean`	`killJob(String jobId)` Kill the job represented by jobId. This method will kill every running tasks of this job, and remove it from the scheduler. The job won't be terminated, it won't have result. The jobId is given as a string.
`boolean`	`killTask(JobId jobId, String taskName)` Try to kill the task with the given task name in the given jobId.
`boolean`	`killTask(String jobId, String taskName)` Try to kill the task with the given task name in the given jobId.
`boolean`	`linkResourceManager(String rmUrl)` For administrator only, Reconnect a new Resource Manager to the scheduler.
`boolean`	`pause()` For administrator only, Pause the scheduler by terminating running jobs.
`boolean`	`pauseJob(JobId jobId)` Pause the job represented by jobId. This method will finish every running tasks of this job, and then pause the job. The job will have to be resumed in order to finish.
`boolean`	`pauseJob(String jobId)` Pause the job represented by jobId. This method will finish every running tasks of this job, and then pause the job. The job will have to be resumed in order to finish. The jobId is given as a string.
`boolean`	`preemptTask(JobId jobId, String taskName, int restartDelay)` Try to stop the task execution represented by the given task name in the given jobId.
`boolean`	`preemptTask(String jobId, String taskName, int restartDelay)` Try to stop the task execution represented by the given task name in the given jobId. If the job does not exist, an UnknownJobException is sent with the proper message. So, if you have the right to stop this task and if the job and task name exist and is running, the task will be stopped and restarted later and this method will return `true`. The given delay is the delay between the task termination and it's eligibility to be re-scheduled.
`void`	`pullFile(String space, String pathname, String outputFile)` Retrieves the specified file from the server.
`boolean`	`pushFile(String spacename, String pathname, String filename, String file)` Transfers the specified file from the local file system to the specified dataspace at the server
`void`	`putThirdPartyCredential(String key, String value)` Stores a third-party credential key-value pair in the database.
`void`	`removeEventListener()` Remove the current event listener your listening on. If no listener is defined, this method has no effect.
`boolean`	`removeJob(JobId jobId)` Remove the job from the scheduler.
`boolean`	`removeJob(String jobId)` Remove the job from the scheduler.
`void`	`removeThirdPartyCredential(String key)`
`void`	`renewSession()` This method renew the connection lease without other side effect.
`boolean`	`restartAllInErrorTasks(String jobId)` Restart all in error tasks in the job represented by jobId. This method will restart every in error tasks of this job. The jobId is given as a string.
`boolean`	`restartInErrorTask(String jobId, String taskName)`
`boolean`	`restartTask(JobId jobId, String taskName, int restartDelay)` Try to restart the task represented by the given task name in the given jobId.
`boolean`	`restartTask(String jobId, String taskName, int restartDelay)` Try to restart the task represented by the given task name in the given jobId.
`boolean`	`resume()` For administrator only, Resume the scheduler.
`boolean`	`resumeJob(JobId jobId)` Resume the job represented by jobId. This method will restart every non-finished tasks of this job.
`boolean`	`resumeJob(String jobId)` Resume the job represented by jobId. This method will restart every non-finished tasks of this job. The jobId is given as a string.
`void`	`setSession(String sid)` Sets the session identifier explicitly.
`boolean`	`shutdown()` For administrator only, Terminate the scheduler after all currently running tasks are finished.
`boolean`	`start()` For administrator only, Start the scheduler.
`boolean`	`stop()` For administrator only, Stop the scheduler. Once done, you won't be able to submit job, and the scheduling will be stopped. Every running jobs will be terminated.
`JobId`	`submit(File job)` Submit a new job to the scheduler.
`JobId`	`submit(File job, Map<String,String> variables)` Submit a new job to the scheduler with provided variables.
`JobId`	`submit(File job, Map<String,String> variables, Map<String,String> genericInfos)` Submit a new job to the scheduler with provided variables.
`JobId`	`submit(Job job)` Submit a new job to the scheduler.
`JobId`	`submit(Map<String,String> genericInfos, URL job, Map<String,String> variables)` Submit a new job to the scheduler with provided variables.
`JobId`	`submit(URL job)` Submit a new job to the scheduler.
`JobId`	`submit(URL job, Map<String,String> variables)` Submit a new job to the scheduler with provided variables.
`JobId`	`submit(URL job, Map<String,String> variables, Map<String,String> requestHeaderParams)` Submit a new job to the scheduler with provided variables.
`JobId`	`submit(URL job, Map<String,String> variables, Map<String,String> genericInfos, Map<String,String> requestHeaderParams)` Submit a new job to the scheduler with provided variables.
`JobId`	`submitFromCatalog(String catalogRestURL, String calledWorkflow)` Submit a new job to the scheduler from the catalogRestURL without provided variables.
`JobId`	`submitFromCatalog(String catalogRestURL, String calledWorkflow, Map<String,String> variables)` Submit a new job to the scheduler from the catalogRestURL with provided variables.
`JobId`	`submitFromCatalog(String catalogRestURL, String calledWorkflow, Map<String,String> variables, Map<String,String> genericInfo)` Submit a new job to the scheduler from the catalogRestURL with provided variables ang generic information.
`JobId`	`submitFromCatalog(String catalogRestURL, String bucketName, String workflowName)` Submit a new job to the scheduler from the catalogRestURL without variables.
`JobId`	`submitFromCatalog(String catalogRestURL, String bucketName, String workflowName, Map<String,String> variables)` Submit a new job to the scheduler from the catalogRestURL with provided variables.
`JobId`	`submitFromCatalog(String catalogRestURL, String bucketName, String workflowName, Map<String,String> variables, Map<String,String> genericInfo)` Submit a new job to the scheduler from the catalogRestURL with provided variables.
`Set<String>`	`thirdPartyCredentialsKeySet()`
`List<JobResult>`	`waitForAllJobs(List<String> jobIds, long timeout)` Causes the current thread to wait until the execution of all specified jobs has finished or the elapse of specified wait time.
`List<Map.Entry<String,TaskResult>>`	`waitForAllTasks(String jobId, List<String> taskNames, long timeout)` Causes the current thread to wait until all the executions of specified tasks finish or the elapse of specified amount of time.
`Map.Entry<String,JobResult>`	`waitForAnyJob(List<String> jobIds, long timeout)` Causes the current thread to wait until the execution of any job finishes or the elapse of the specified wait time.
`Map.Entry<String,TaskResult>`	`waitForAnyTask(String jobId, List<String> taskNames, long timeout)` Causes the current thread to wait until any of the specified tasks finishes or the elapse of specified amount of time.
`JobResult`	`waitForJob(JobId jobId, long timeout)` Causes the current thread to wait until the scheduler has finished the execution of the specified job or the specified amount of time has elapsed.
`JobResult`	`waitForJob(String jobId, long timeout)` Causes the current thread to wait until the scheduler has finished the execution of the specified job or the specified amount of time has elapsed.
`TaskResult`	`waitForTask(String jobId, String taskName, long timeout)` Causes the current thread to wait until the scheduler has finished executing the specified task or the elapse of specified elapse time.

Methods inherited from class org.ow2.proactive.scheduler.rest.ClientBase
addEventListener, changePolicy, getState, getState, getTaskResultAllIncarnations, getTaskResultAllIncarnations, getTaskResultFromIncarnation, getTaskResultFromIncarnation, listenJobLogs, listenJobLogs, reloadPolicyConfiguration

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.ow2.proactive.scheduler.common.Scheduler
addEventListener, changePolicy, getState, getState, getTaskResultAllIncarnations, getTaskResultAllIncarnations, getTaskResultFromIncarnation, getTaskResultFromIncarnation, listenJobLogs, listenJobLogs, reloadPolicyConfiguration

- Method Detail
  - createInstance
```
public static ISchedulerClient createInstance()
```
    Creates an ISchedulerClient instance.
    
    Returns:
    
    an ISchedulerClient instance
  - init
```
public void init(ConnectionInfo connectionInfo)
          throws Exception
```
    Description copied from interface: ISchedulerClient
    
    Initialize this instance.
    
    Specified by:
    
    init in interface ISchedulerClient
    
    Parameters:
    
    connectionInfo - various info about the connection attempt
    
    Throws:
    
    Exception - if an error occurs during the initialization
  - getConnectionInfo
```
public ConnectionInfo getConnectionInfo()
```
    Description copied from interface: ISchedulerClient
    
    Returns the connection info, if initialized previously
    
    Specified by:
    
    getConnectionInfo in interface ISchedulerClient
    
    Returns:
    
    the connection info
  - getAccountUsage
```
public List<JobUsage> getAccountUsage(String user,
                                      Date start,
                                      Date end)
                               throws NotConnectedException,
                                      PermissionException
```
    Description copied from interface: SchedulerUsage
    
    Returns details on job and task execution times for a given user's executions.
    Only the jobs finished between the start date and the end date will be returned: i.e startDate <= job.finishedTime <= endDate.
    If user is the same as the caller, then it will fallback to to SchedulerUsage.getMyAccountUsage(Date, Date).
    
    Specified by:
    
    getAccountUsage in interface SchedulerUsage
    
    Parameters:
    
    user - must match a username as defined in the Scheduler's users
    
    start - must not be null, inclusive
    
    end - must not be null, inclusive
    
    Returns:
    
    a list of JobUsage objects where job finished times are between start date and end date
    
    Throws:
    
    NotConnectedException - if the caller is not connected
    
    PermissionException - if the caller hasn't the permission to call this method
  - getMyAccountUsage
```
public List<JobUsage> getMyAccountUsage(Date startDate,
                                        Date endDate)
                                 throws NotConnectedException,
                                        PermissionException
```
    Description copied from interface: SchedulerUsage
    
    Returns details on job and task execution times for the caller's executions.
    Only the jobs finished between the start date and the end date will be returned: i.e startDate <= job.finishedTime <= endDate.
    
    Specified by:
    
    getMyAccountUsage in interface SchedulerUsage
    
    Parameters:
    
    startDate - must not be null, inclusive
    
    endDate - must not be null, inclusive
    
    Returns:
    
    a list of JobUsage objects where job finished times are between start date and end date
    
    Throws:
    
    NotConnectedException - if the caller is not connected
    
    PermissionException - if the caller hasn't the permission to call this method
  - changeJobPriority
```
public void changeJobPriority(JobId jobId,
                              JobPriority priority)
                       throws NotConnectedException,
                              UnknownJobException,
                              PermissionException,
                              JobAlreadyFinishedException
```
    Description copied from interface: Scheduler
    
    Change the priority of the job represented by jobId.
    Only administrator can change the priority to HIGH, HIGEST, IDLE.
    
    Specified by:
    
    changeJobPriority in interface Scheduler
    
    Parameters:
    
    jobId - the job on which to change the priority.
    
    priority - The new priority to apply to the job.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
    
    JobAlreadyFinishedException - if you want to change the priority on a finished job.
  - changeJobPriority
```
public void changeJobPriority(String jobId,
                              JobPriority priority)
                       throws NotConnectedException,
                              UnknownJobException,
                              PermissionException,
                              JobAlreadyFinishedException
```
    Description copied from interface: Scheduler
    
    Change the priority of the job represented by jobId.
    Only administrator can change the priority to HIGH, HIGEST, IDLE.
    
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only change HIS job priority.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    changeJobPriority in interface Scheduler
    
    Parameters:
    
    jobId - the job on which to change the priority.
    
    priority - The new priority to apply to the job.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
    
    JobAlreadyFinishedException - if you want to change the priority on a finished job.
  - disconnect
```
public void disconnect()
                throws NotConnectedException,
                       PermissionException
```
    Description copied from interface: Scheduler
    
    Disconnect properly the user from the scheduler.
    
    Specified by:
    
    disconnect in interface Scheduler
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular method.
  - freeze
```
public boolean freeze()
               throws NotConnectedException,
                      PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Freeze the scheduler by terminating running tasks.
    
    Specified by:
    
    freeze in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - getJobResult
```
public JobResult getJobResult(JobId jobId)
                       throws NotConnectedException,
                              PermissionException,
                              UnknownJobException
```
    Description copied from interface: Scheduler
    
    Get the result for the given jobId. A user can only get HIS result back except if he is admin.
    If the job does not exist, a schedulerException is sent with the proper message.
    So, if you have the right to get the job result represented by the given jobId and if the job exists, so you will receive the result. In any other cases a schedulerException will be thrown.
    
    Specified by:
    
    getJobResult in interface Scheduler
    
    Parameters:
    
    jobId - the job on which the result will be send
    
    Returns:
    
    a job Result containing information about the result. If the job result is not yet available (job not finished), null is returned.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular job.
    
    UnknownJobException - if the job does not exist.
  - getJobResult
```
public JobResult getJobResult(String jobId)
                       throws NotConnectedException,
                              PermissionException,
                              UnknownJobException
```
    Description copied from interface: Scheduler
    
    Get the result for the given jobId.
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only get HIS result back except if he is admin.
    If the job does not exist, a schedulerException is sent with the proper message.
    So, if you have the right to get the job result represented by the given jobId and if the job exists, so you will receive the result. In any other cases a schedulerException will be thrown.
    
    Specified by:
    
    getJobResult in interface Scheduler
    
    Parameters:
    
    jobId - the job on which the result will be send
    
    Returns:
    
    a job Result containing information about the result. If the job result is not yet available (job not finished), null is returned.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular job.
    
    UnknownJobException - if the job does not exist.
  - getJobState
```
public JobState getJobState(String jobId)
                     throws NotConnectedException,
                            UnknownJobException,
                            PermissionException
```
    Description copied from interface: Scheduler
    
    Return the state of the given job.
    The state contains informations about the job, every tasks and informations about the tasks.
    
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only get the state of HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    getJobState in interface Scheduler
    
    Parameters:
    
    jobId - the job on which to get the state.
    
    Returns:
    
    the current state of the given job
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - getJobState
```
public JobState getJobState(JobId jobId)
                     throws NotConnectedException,
                            UnknownJobException,
                            PermissionException
```
    Description copied from interface: Scheduler
    
    Return the state of the given job.
    The state contains informations about the job, every tasks and informations about the tasks.
    
    A user can only get the state of HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    getJobState in interface Scheduler
    
    Parameters:
    
    jobId - the job on which to get the state.
    
    Returns:
    
    the current state of the given job
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - getJobs
```
public Page<JobInfo> getJobs(int index,
                             int range,
                             JobFilterCriteria criteria,
                             List<SortParameter<JobSortParameter>> arg3)
                      throws NotConnectedException,
                             PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieves a job list of the scheduler.
    
    Specified by:
    
    getJobs in interface Scheduler
    
    Parameters:
    
    index - says to start from this job is
    
    range - max number of jobs to retrieve
    
    criteria - defines types of job (myonly, pending, running, finished). Important! If user tries to get all jobs (myonly is false) but does not have permissions to do it (namely HandleOnlyMyJobsPermission(true)) user will get his own jobs instead of a PermissionException. This behavior should simplify the client design.
    
    arg3 - defines in how jobs must be sorted
    
    Returns:
    
    jobs list according to all criteria
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - getJobsInfoList
```
public List<JobInfo> getJobsInfoList(List<String> jobsId)
                              throws PermissionException,
                                     NotConnectedException
```
    Description copied from interface: Scheduler
    
    Returns a list of jobs info corresponding to the given job IDs (in the same order)
    
    Specified by:
    
    getJobsInfoList in interface Scheduler
    
    Parameters:
    
    jobsId - the list of id of the jobs to return, in the same order
    
    Returns:
    
    jobs list of the given list of id
    
    Throws:
    
    PermissionException - if you have not enough permission to access this method.
    
    NotConnectedException - if you are not authenticated.
  - getJobServerLogs
```
public String getJobServerLogs(String jobId)
                        throws UnknownJobException,
                               NotConnectedException,
                               PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieves server logs for a job with the given id. Only the job owner of admin if the scheduler can request these logs. It's a combination of corresponding tasks logs belonging to this job plus some extra job specific information.
    
    Specified by:
    
    getJobServerLogs in interface Scheduler
    
    Parameters:
    
    jobId - of the job for which logs are requested
    
    Returns:
    
    job's logs
    
    Throws:
    
    UnknownJobException - if the job does not exist.
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - getStatus
```
public SchedulerStatus getStatus()
                          throws NotConnectedException,
                                 PermissionException
```
    Description copied from interface: Scheduler
    
    Get the current status of the Scheduler
    
    Specified by:
    
    getStatus in interface Scheduler
    
    Returns:
    
    the current status of the Scheduler
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular method.
  - getTaskResult
```
public TaskResult getTaskResult(String jobId,
                                String taskName)
                         throws NotConnectedException,
                                UnknownJobException,
                                UnknownTaskException,
                                PermissionException
```
    Description copied from interface: Scheduler
    
    Get the result for the given task name in the given jobId.
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only get HIS result back.
    If the job does not exist, a schedulerException is sent with the proper message.
    So, if you have the right to get the task result that is in the job represented by the given jobId and if the job and task name exist, so you will receive the result. In any other cases a schedulerException will be thrown.
    
    Specified by:
    
    getTaskResult in interface Scheduler
    
    Parameters:
    
    jobId - the job in which the task result is.
    
    taskName - the name of the task in which the result is.
    
    Returns:
    
    a job Result containing information about the result. If null is returned, this task is not yet terminated or not available.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    PermissionException - if you can't access to this particular job.
  - getTaskResult
```
public TaskResult getTaskResult(JobId jobId,
                                String taskName)
                         throws NotConnectedException,
                                UnknownJobException,
                                UnknownTaskException,
                                PermissionException
```
    Description copied from interface: Scheduler
    
    Get the result for the given task name in the given jobId. A user can only get HIS result back.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to get the task result that is in the job represented by the given jobId and if the job and task name exist, so you will receive the result. In any other cases a schedulerException will be thrown.
    
    Specified by:
    
    getTaskResult in interface Scheduler
    
    Parameters:
    
    jobId - the job in which the task result is.
    
    taskName - the name of the task in which the result is.
    
    Returns:
    
    a job Result containing information about the result. If the task result is not yet available, null is returned.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    PermissionException - if you can't access to this particular job.
  - getTaskResultsByTag
```
public List<TaskResult> getTaskResultsByTag(JobId jobId,
                                            String taskTag)
                                     throws NotConnectedException,
                                            UnknownJobException,
                                            PermissionException
```
    Description copied from interface: Scheduler
    
    Get the results for a set of tasks in the given jobId and filtered by a given tag. A user can only get HIS result back.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to get the task result that is in the job represented by the given jobId and if the job and task name exist, so you will receive the result. In any other cases a schedulerException will be thrown.
    
    Specified by:
    
    getTaskResultsByTag in interface Scheduler
    
    Parameters:
    
    jobId - the job in which the task result is.
    
    taskTag - the tag used to filter the tasks in which the result is.
    
    Returns:
    
    a job Result containing information about the result. If the task result is not yet available, null is returned.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - getTaskResultsByTag
```
public List<TaskResult> getTaskResultsByTag(String jobId,
                                            String taskTag)
                                     throws NotConnectedException,
                                            UnknownJobException,
                                            PermissionException
```
    Description copied from interface: Scheduler
    
    Get the results for a set of tasks in the given jobId and filtered by a given tag.
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only get HIS result back.
    If the job does not exist, a schedulerException is sent with the proper message.
    So, if you have the right to get the task result that is in the job represented by the given jobId and if the job and task name exist, so you will receive the result of these tasks. In any other cases a schedulerException will be thrown.
    
    Specified by:
    
    getTaskResultsByTag in interface Scheduler
    
    Parameters:
    
    jobId - the job in which the task result is.
    
    taskTag - the tag used to filter the tasks in which the result is.
    
    Returns:
    
    the list of task result containing information about the result. If null is returned, this task is not yet terminated or not available.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - getTaskServerLogs
```
public String getTaskServerLogs(String jobId,
                                String taskName)
                         throws UnknownJobException,
                                UnknownTaskException,
                                NotConnectedException,
                                PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieves server logs for a task with the given id. Only the job owner of admin if the scheduler can request these logs. It's a combination of corresponding tasks logs belonging to this job plus some extra job specific information.
    
    Specified by:
    
    getTaskServerLogs in interface Scheduler
    
    Parameters:
    
    jobId - of the job where the task is.
    
    taskName - the name of the task.
    
    Returns:
    
    tasks's logs
    
    Throws:
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - getTaskServerLogsByTag
```
public String getTaskServerLogsByTag(String jobId,
                                     String tag)
                              throws UnknownJobException,
                                     NotConnectedException,
                                     PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieves server logs for a set of tasks filtered by the given tag. Only the job owner of admin if the scheduler can request these logs. It's a combination of corresponding tasks logs belonging to this job plus some extra job specific information.
    
    Specified by:
    
    getTaskServerLogsByTag in interface Scheduler
    
    Parameters:
    
    jobId - of the job where the task is.
    
    tag - the tag used to filter tasks.
    
    Returns:
    
    tasks's logs
    
    Throws:
    
    UnknownJobException - if the job does not exist.
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - getUsers
```
public List<SchedulerUserInfo> getUsers()
                                 throws NotConnectedException,
                                        PermissionException
```
    Description copied from interface: Scheduler
    
    Returns a list of connected users.
    
    Specified by:
    
    getUsers in interface Scheduler
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getUsersWithJobs
```
public List<SchedulerUserInfo> getUsersWithJobs()
                                         throws NotConnectedException,
                                                PermissionException
```
    Description copied from interface: Scheduler
    
    Returns a list of users having jobs. These are meaningful users for accounting SchedulerUsage
    
    Specified by:
    
    getUsersWithJobs in interface Scheduler
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - isConnected
```
public boolean isConnected()
```
    Description copied from interface: Scheduler
    
    Test whether or not the user is connected to the ProActive Scheduler. Note that a call to this method DOES NOT renew the connection lease.
    
    Specified by:
    
    isConnected in interface Scheduler
    
    Returns:
    
    true if the user connected to a Scheduler, false otherwise.
  - getCurrentPolicy
```
public String getCurrentPolicy()
                        throws NotConnectedException,
                               PermissionException
```
    Description copied from interface: Scheduler
    
    Return the name of the current Policy
    
    Specified by:
    
    getCurrentPolicy in interface Scheduler
    
    Returns:
    
    the name of the current policy.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getJobsToSchedule
```
public Map getJobsToSchedule()
                      throws NotConnectedException,
                             PermissionException
```
    Description copied from interface: Scheduler
    
    get job Descriptor Map with eligible jobs (running and pending)
    
    Specified by:
    
    getJobsToSchedule in interface Scheduler
    
    Returns:
    
    a Map of eligible jobs.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getTasksToSchedule
```
public List<TaskDescriptor> getTasksToSchedule()
                                        throws NotConnectedException,
                                               PermissionException
```
    Description copied from interface: Scheduler
    
    get task descriptor list with eligible tasks (running)
    
    Specified by:
    
    getTasksToSchedule in interface Scheduler
    
    Overrides:
    
    getTasksToSchedule in class ClientBase
    
    Returns:
    
    a List of eligible task descriptor.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - kill
```
public boolean kill()
             throws NotConnectedException,
                    PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Kill the scheduler.
    Will stop the scheduling, and shutdown the scheduler.
    
    Specified by:
    
    kill in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - killJob
```
public boolean killJob(JobId jobId)
                throws NotConnectedException,
                       UnknownJobException,
                       PermissionException
```
    Description copied from interface: Scheduler
    
    Kill the job represented by jobId.
    This method will kill every running tasks of this job, and remove it from the scheduler.
    The job won't be terminated, it won't have result.
    
    Specified by:
    
    killJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to kill.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - killJob
```
public boolean killJob(String jobId)
                throws NotConnectedException,
                       UnknownJobException,
                       PermissionException
```
    Description copied from interface: Scheduler
    
    Kill the job represented by jobId.
    This method will kill every running tasks of this job, and remove it from the scheduler.
    The job won't be terminated, it won't have result.
    
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only kill HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    killJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to kill.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - killTask
```
public boolean killTask(JobId jobId,
                        String taskName)
                 throws NotConnectedException,
                        UnknownJobException,
                        PermissionException
```
    Description copied from interface: Scheduler
    
    Try to kill the task with the given task name in the given jobId. A user can only kill HIS task.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to kill this task and if the job and task name exist and is running, the task will be killed and this method will return true. In any other cases a SchedulerException will be thrown.
    
    Specified by:
    
    killTask in interface Scheduler
    
    Parameters:
    
    jobId - the job containing the task to be killed.
    
    taskName - the name of the task to kill.
    
    Returns:
    
    true if the action to kill the task has succeed, false if the task cannot be killed because it's not running.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job and task.
  - killTask
```
public boolean killTask(String jobId,
                        String taskName)
                 throws NotConnectedException,
                        UnknownJobException,
                        PermissionException
```
    Description copied from interface: Scheduler
    
    Try to kill the task with the given task name in the given jobId. A user can only kill HIS task.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to kill this task and if the job and task name exist and is running, the task will be killed and this method will return true.
    In any other cases a SchedulerException will be thrown.
    
    Specified by:
    
    killTask in interface Scheduler
    
    Parameters:
    
    jobId - the job containing the task to be killed.
    
    taskName - the name of the task to kill.
    
    Returns:
    
    true if the action to kill the task has succeed, false if the task cannot be killed because it's not running.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job and task.
  - linkResourceManager
```
public boolean linkResourceManager(String rmUrl)
                            throws NotConnectedException,
                                   PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Reconnect a new Resource Manager to the scheduler.
    Can be used if the resource manager has crashed.
    
    Specified by:
    
    linkResourceManager in interface Scheduler
    
    Parameters:
    
    rmUrl - the URL of the new Resource Manager to link to the scheduler. Example: //host/RM_node_name
    
    Returns:
    
    true if success, false otherwise.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - pause
```
public boolean pause()
              throws NotConnectedException,
                     PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Pause the scheduler by terminating running jobs.
    
    Specified by:
    
    pause in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - pauseJob
```
public boolean pauseJob(JobId jobId)
                 throws NotConnectedException,
                        UnknownJobException,
                        PermissionException
```
    Description copied from interface: Scheduler
    
    Pause the job represented by jobId.
    This method will finish every running tasks of this job, and then pause the job.
    The job will have to be resumed in order to finish.
    
    Specified by:
    
    pauseJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to pause.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - pauseJob
```
public boolean pauseJob(String jobId)
                 throws NotConnectedException,
                        UnknownJobException,
                        PermissionException
```
    Description copied from interface: Scheduler
    
    Pause the job represented by jobId.
    This method will finish every running tasks of this job, and then pause the job.
    The job will have to be resumed in order to finish.
    
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only pause HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    pauseJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to pause.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - restartAllInErrorTasks
```
public boolean restartAllInErrorTasks(String jobId)
                               throws NotConnectedException,
                                      UnknownJobException,
                                      PermissionException
```
    Description copied from interface: Scheduler
    
    Restart all in error tasks in the job represented by jobId.
    This method will restart every in error tasks of this job.
    
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only restart HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    restartAllInErrorTasks in interface Scheduler
    
    Parameters:
    
    jobId - the job to resume.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - preemptTask
```
public boolean preemptTask(JobId jobId,
                           String taskName,
                           int restartDelay)
                    throws NotConnectedException,
                           UnknownJobException,
                           UnknownTaskException,
                           PermissionException
```
    Description copied from interface: Scheduler
    
    Try to stop the task execution represented by the given task name in the given jobId.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to stop this task and if the job and task name exist and is running, the task will be stopped and restarted later and this method will return true.
    The given delay is the delay between the task termination and it's eligibility to be re-scheduled. In any other cases a SchedulerException will be thrown.
    
    Specified by:
    
    preemptTask in interface Scheduler
    
    Parameters:
    
    jobId - the job containing the task to be stopped.
    
    taskName - the name of the task to stop.
    
    restartDelay - the delay between the task termination and it's eligibility to be re-scheduled (in sec)
    
    Returns:
    
    true if the action to stop the task has succeed, false if the task cannot be stopped because it's not running.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    PermissionException - if you can't access to this particular job and task.
  - preemptTask
```
public boolean preemptTask(String jobId,
                           String taskName,
                           int restartDelay)
                    throws NotConnectedException,
                           UnknownJobException,
                           UnknownTaskException,
                           PermissionException
```
    Description copied from interface: Scheduler
    
    Try to stop the task execution represented by the given task name in the given jobId.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to stop this task and if the job and task name exist and is running, the task will be stopped and restarted later and this method will return true.
    The given delay is the delay between the task termination and it's eligibility to be re-scheduled. In any other cases a SchedulerException will be thrown.
    
    Specified by:
    
    preemptTask in interface Scheduler
    
    Parameters:
    
    jobId - the job containing the task to be stopped.
    
    taskName - the name of the task to stop.
    
    restartDelay - the delay between the task termination and it's eligibility to be re-scheduled (in sec)
    
    Returns:
    
    true if the action to stop the task has succeed, false if the task cannot be stopped because it's not running.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    PermissionException - if you can't access to this particular job and task.
  - removeJob
```
public boolean removeJob(JobId jobId)
                  throws NotConnectedException,
                         UnknownJobException,
                         PermissionException
```
    Description copied from interface: Scheduler
    
    Remove the job from the scheduler.
    
    Specified by:
    
    removeJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to be removed.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - removeJob
```
public boolean removeJob(String jobId)
                  throws NotConnectedException,
                         UnknownJobException,
                         PermissionException
```
    Description copied from interface: Scheduler
    
    Remove the job from the scheduler.
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only remove HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    removeJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to be removed.
    
    Returns:
    
    true if success, false if job is not terminated.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - restartTask
```
public boolean restartTask(JobId jobId,
                           String taskName,
                           int restartDelay)
                    throws NotConnectedException,
                           UnknownJobException,
                           UnknownTaskException,
                           PermissionException
```
    Description copied from interface: Scheduler
    Try to restart the task represented by the given task name in the given jobId. A user can only restart HIS task.
    If the job does not exist, an UnknownJobException is sent with the proper message. So, if you have the right to restart this task and if the job and task name exist and is running, the task will be restarted and this method will return true.
    The given delay is the delay between the task termination and it's eligibility to be re-scheduled. In any other cases a SchedulerException will be thrown.
    After this call, the following situations can occur :
    - The task has not yet reached its max number of execution : it will be re-scheduled after delay
    - The task has reached its max number of execution : it becomes faulty
    - The task has reached its max number of execution and is cancelJobOnError : it becomes faulty and the job is terminated
    Specified by:
    
    restartTask in interface Scheduler
    
    Parameters:
    
    jobId - the job containing the task to be restarted.
    
    taskName - the name of the task to restart.
    
    restartDelay - the delay between the task termination and it's eligibility to be re-scheduled (in sec)
    
    Returns:
    
    true if the action to restart the task has succeed, false if the task cannot be restarted because it's not running.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    PermissionException - if you can't access to this particular job and task.
  - restartTask
```
public boolean restartTask(String jobId,
                           String taskName,
                           int restartDelay)
                    throws NotConnectedException,
                           UnknownJobException,
                           UnknownTaskException,
                           PermissionException
```
    Description copied from interface: Scheduler
    Try to restart the task represented by the given task name in the given jobId. A user can only restart HIS task.
    If the job does not exist, an UnknownJobException is sent with the proper message.
    So, if you have the right to restart this task and if the job and task name exist and is running, the task will be restarted and this method will return true.
    The given delay is the delay between the task termination and it's eligibility to be re-scheduled. In any other cases a SchedulerException will be thrown.
    After this call, the following situations can occur :
    - The task has not yet reached its max number of execution : it will be re-scheduled after delay
    - The task has reached its max number of execution : it becomes faulty
    - The task has reached its max number of execution and is cancelJobOnError : it becomes faulty and the job is terminated
    Specified by:
    
    restartTask in interface Scheduler
    
    Parameters:
    
    jobId - the job containing the task to be restarted.
    
    taskName - the name of the task to restart.
    
    restartDelay - the delay between the task termination and it's eligibility to be re-scheduled (in sec)
    
    Returns:
    
    true if the action to restart the task has succeed, false if the task cannot be restarted because it's not running.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    UnknownTaskException - if this task does not exist in the job.
    
    PermissionException - if you can't access to this particular job and task.
  - finishInErrorTask
```
public boolean finishInErrorTask(String jobId,
                                 String taskName)
                          throws NotConnectedException,
                                 UnknownJobException,
                                 UnknownTaskException,
                                 PermissionException
```
    Specified by:
    
    finishInErrorTask in interface Scheduler
    
    Throws:
    
    NotConnectedException
    
    UnknownJobException
    
    UnknownTaskException
    
    PermissionException
  - restartInErrorTask
```
public boolean restartInErrorTask(String jobId,
                                  String taskName)
                           throws NotConnectedException,
                                  UnknownJobException,
                                  UnknownTaskException,
                                  PermissionException
```
    Specified by:
    
    restartInErrorTask in interface Scheduler
    
    Throws:
    
    NotConnectedException
    
    UnknownJobException
    
    UnknownTaskException
    
    PermissionException
  - resume
```
public boolean resume()
               throws NotConnectedException,
                      PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Resume the scheduler.
    
    Specified by:
    
    resume in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - resumeJob
```
public boolean resumeJob(JobId jobId)
                  throws NotConnectedException,
                         UnknownJobException,
                         PermissionException
```
    Description copied from interface: Scheduler
    
    Resume the job represented by jobId.
    This method will restart every non-finished tasks of this job.
    
    Specified by:
    
    resumeJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to resume.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - resumeJob
```
public boolean resumeJob(String jobId)
                  throws NotConnectedException,
                         UnknownJobException,
                         PermissionException
```
    Description copied from interface: Scheduler
    
    Resume the job represented by jobId.
    This method will restart every non-finished tasks of this job.
    
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only resume HIS job.
    If the job does not exist, a schedulerException is sent with the proper message.
    
    Specified by:
    
    resumeJob in interface Scheduler
    
    Parameters:
    
    jobId - the job to resume.
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - shutdown
```
public boolean shutdown()
                 throws NotConnectedException,
                        PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Terminate the scheduler after all currently running tasks are finished.
    
    Specified by:
    
    shutdown in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - start
```
public boolean start()
              throws NotConnectedException,
                     PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Start the scheduler.
    
    Specified by:
    
    start in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - stop
```
public boolean stop()
             throws NotConnectedException,
                    PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, Stop the scheduler.
    Once done, you won't be able to submit job, and the scheduling will be stopped.
    Every running jobs will be terminated.
    
    Specified by:
    
    stop in interface Scheduler
    
    Returns:
    
    true if success, false if not.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - submit
```
public JobId submit(Job job)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: Scheduler
    
    Submit a new job to the scheduler. A user can only managed their jobs.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    It is possible to get a listener on the scheduler. (see Scheduler.addEventListener(SchedulerEventListener, boolean, SchedulerEvent...) for more details)
    
    Specified by:
    
    submit in interface Scheduler
    
    Parameters:
    
    job - the new job to submit.
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular method.
    
    SubmissionClosedException - if the submit action could not be performed.
    
    JobCreationException - if Their was a problem while creation the job
  - submit
```
public JobId submit(File job)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a local File
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(File job,
                    Map<String,String> variables)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a local File
    
    variables - job variables to use during the job execution
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(File job,
                    Map<String,String> variables,
                    Map<String,String> genericInfos)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a local File
    
    variables - job variables to use during the job execution
    
    genericInfos - map with generic informations
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(URL job)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a url
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(URL job,
                    Map<String,String> variables)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a url
    
    variables - job variables to use during the job execution
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(Map<String,String> genericInfos,
                    URL job,
                    Map<String,String> variables)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    genericInfos - map with generic informations
    
    job - a job provided as a url
    
    variables - job variables to use during the job execution
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(URL job,
                    Map<String,String> variables,
                    Map<String,String> requestHeaderParams)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a url
    
    variables - job variables to use during the job execution
    
    requestHeaderParams - map with request header parameters
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submit
```
public JobId submit(URL job,
                    Map<String,String> variables,
                    Map<String,String> genericInfos,
                    Map<String,String> requestHeaderParams)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submit in interface ISchedulerClient
    
    Parameters:
    
    job - a job provided as a url
    
    variables - job variables to use during the job execution
    
    genericInfos - map with generic informations
    
    requestHeaderParams - map with request header parameters
    
    Returns:
    
    the generated new job ID.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submitFromCatalog
```
public JobId submitFromCatalog(String catalogRestURL,
                               String bucketName,
                               String workflowName)
                        throws NotConnectedException,
                               PermissionException,
                               SubmissionClosedException,
                               JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler from the catalogRestURL without variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submitFromCatalog in interface ISchedulerClient
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submitFromCatalog
```
public JobId submitFromCatalog(String catalogRestURL,
                               String bucketName,
                               String workflowName,
                               Map<String,String> variables)
                        throws NotConnectedException,
                               PermissionException,
                               SubmissionClosedException,
                               JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler from the catalogRestURL with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submitFromCatalog in interface ISchedulerClient
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submitFromCatalog
```
public JobId submitFromCatalog(String catalogRestURL,
                               String bucketName,
                               String workflowName,
                               Map<String,String> variables,
                               Map<String,String> genericInfo)
                        throws NotConnectedException,
                               PermissionException,
                               SubmissionClosedException,
                               JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler from the catalogRestURL with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submitFromCatalog in interface ISchedulerClient
    
    genericInfo - map with generic information
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submitFromCatalog
```
public JobId submitFromCatalog(String catalogRestURL,
                               String calledWorkflow)
                        throws NotConnectedException,
                               PermissionException,
                               SubmissionClosedException,
                               JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler from the catalogRestURL without provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submitFromCatalog in interface ISchedulerClient
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submitFromCatalog
```
public JobId submitFromCatalog(String catalogRestURL,
                               String calledWorkflow,
                               Map<String,String> variables)
                        throws NotConnectedException,
                               PermissionException,
                               SubmissionClosedException,
                               JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler from the catalogRestURL with provided variables.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submitFromCatalog in interface ISchedulerClient
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - submitFromCatalog
```
public JobId submitFromCatalog(String catalogRestURL,
                               String calledWorkflow,
                               Map<String,String> variables,
                               Map<String,String> genericInfo)
                        throws NotConnectedException,
                               PermissionException,
                               SubmissionClosedException,
                               JobCreationException
```
    Description copied from interface: ISchedulerClient
    
    Submit a new job to the scheduler from the catalogRestURL with provided variables ang generic information.
    It will execute the tasks of the jobs as soon as resources are available. The job will be considered as finished once every tasks have finished (error or success). Thus, user could get the job result according to the precious result.
    
    Specified by:
    
    submitFromCatalog in interface ISchedulerClient
    
    genericInfo - map with generic information
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
  - isJobFinished
```
public boolean isJobFinished(JobId jobId)
                      throws NotConnectedException,
                             UnknownJobException,
                             PermissionException
```
    Description copied from interface: ISchedulerClient
    
    Returns true, if the scheduler has finished the execution of the specified job.
    
    Specified by:
    
    isJobFinished in interface ISchedulerClient
    
    Parameters:
    
    jobId - the job identifier object
    
    Returns:
    
    true if the scheduler has finished the execution of the job
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    UnknownJobException - if the job identifier is invalid
    
    PermissionException - if the user does not have permission to view the state of the specified job
  - isJobFinished
```
public boolean isJobFinished(String jobId)
                      throws NotConnectedException,
                             UnknownJobException,
                             PermissionException
```
    Description copied from interface: ISchedulerClient
    
    Returns true, if the scheduler has terminated the execution of the specified job.
    
    Specified by:
    
    isJobFinished in interface ISchedulerClient
    
    Parameters:
    
    jobId - the job identifier string
    
    Throws:
    
    NotConnectedException
    
    UnknownJobException
    
    PermissionException
    
    See Also:
    
    ISchedulerClient.isJobFinished(JobId)
  - waitForJob
```
public JobResult waitForJob(JobId jobId,
                            long timeout)
                     throws NotConnectedException,
                            UnknownJobException,
                            PermissionException,
                            TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until the scheduler has finished the execution of the specified job or the specified amount of time has elapsed.
    If the job execution finishes before the elapse of wait time, the result of the job is returned. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForJob in interface ISchedulerClient
    
    Parameters:
    
    jobId - the job identifier object
    
    timeout - the maximum amount of time to wait
    
    Returns:
    
    the result associated to the job which has been executed
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    UnknownJobException - if the job identifier is invalid
    
    PermissionException - if the user does not have permission to view the state of the specified job
    
    TimeoutException - if the job execution does not finish before the elapse of wait time
  - waitForJob
```
public JobResult waitForJob(String jobId,
                            long timeout)
                     throws NotConnectedException,
                            UnknownJobException,
                            PermissionException,
                            TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until the scheduler has finished the execution of the specified job or the specified amount of time has elapsed.
    If the job execution finishes before the elapse of wait time, the result of the job is returned. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForJob in interface ISchedulerClient
    
    Parameters:
    
    jobId - the job identifier string
    
    Throws:
    
    NotConnectedException
    
    UnknownJobException
    
    PermissionException
    
    TimeoutException
    
    See Also:
    
    ISchedulerClient.waitForJob(JobId, long)
  - isTaskFinished
```
public boolean isTaskFinished(String jobId,
                              String taskName)
                       throws UnknownJobException,
                              NotConnectedException,
                              PermissionException,
                              UnknownTaskException
```
    Description copied from interface: ISchedulerClient
    
    Returns true, if the scheduler has finished the execution of the task.
    
    Specified by:
    
    isTaskFinished in interface ISchedulerClient
    
    Parameters:
    
    jobId - the string identifier of the job to which the task is belong
    
    taskName - the task name
    
    Returns:
    
    the task result
    
    Throws:
    
    UnknownJobException - if the job identifier is invalid
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    PermissionException - if the user does not have permission to view the state of the task
    
    UnknownTaskException - if the task name is invalid
  - waitForTask
```
public TaskResult waitForTask(String jobId,
                              String taskName,
                              long timeout)
                       throws UnknownJobException,
                              NotConnectedException,
                              PermissionException,
                              UnknownTaskException,
                              TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until the scheduler has finished executing the specified task or the elapse of specified elapse time.
    If the task execution finishes before the elapse of wait time, the result of the task is returned. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForTask in interface ISchedulerClient
    
    Parameters:
    
    jobId - the string identifier of the job to which the task is belong
    
    taskName - the task name
    
    Returns:
    
    the task result
    
    Throws:
    
    UnknownJobException - if the job identifier is invalid
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    PermissionException - if the user does not have permission to view the state of task
    
    UnknownTaskException - if the task name is invalid
    
    TimeoutException - if the task execution does not finish before the elapse of wait time
  - waitForAllJobs
```
public List<JobResult> waitForAllJobs(List<String> jobIds,
                                      long timeout)
                               throws NotConnectedException,
                                      UnknownJobException,
                                      PermissionException,
                                      TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until the execution of all specified jobs has finished or the elapse of specified wait time.
    Returns a list of job results, if the execution of all jobs specified finishes before the elapse of the wait time. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForAllJobs in interface ISchedulerClient
    
    Parameters:
    
    jobIds - the list of job identifier stings
    
    timeout - the maximum amount of wait time
    
    Returns:
    
    a list of job results
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    UnknownJobException - if one of jobs specified is invalid
    
    PermissionException - if the user does not have permission to view the state of one of the specified jobs
    
    TimeoutException - if the execution of all jobs specified does not finish before the elapse of specified wait time
  - waitForAnyJob
```
public Map.Entry<String,JobResult> waitForAnyJob(List<String> jobIds,
                                                 long timeout)
                                          throws NotConnectedException,
                                                 UnknownJobException,
                                                 PermissionException,
                                                 TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until the execution of any job finishes or the elapse of the specified wait time.
    Returns the string identifier and result of the finished job, if any of the execution of the jobs finishes before the elapse of wait time. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForAnyJob in interface ISchedulerClient
    
    Parameters:
    
    jobIds - the list of job identifier strings
    
    timeout - the maximum amount of wait time
    
    Returns:
    
    the identifier and the result of a finished job
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    UnknownJobException - if only of the job identifiers is invalid
    
    PermissionException - if the user does not have permission to view the job state
    
    TimeoutException - if none of the executions of jobs finishes before the elapse of wait time
  - waitForAnyTask
```
public Map.Entry<String,TaskResult> waitForAnyTask(String jobId,
                                                   List<String> taskNames,
                                                   long timeout)
                                            throws UnknownJobException,
                                                   NotConnectedException,
                                                   PermissionException,
                                                   UnknownTaskException,
                                                   TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until any of the specified tasks finishes or the elapse of specified amount of time.
    Returns name and the result of a finished task. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForAnyTask in interface ISchedulerClient
    
    Parameters:
    
    jobId - the job identifier of the job to which the specified tasks belong
    
    taskNames - the names of the tasks
    
    timeout - the maximum amount of wait time
    
    Returns:
    
    the name and the result of a finished task
    
    Throws:
    
    UnknownJobException - if the job identifier is invalid
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    PermissionException - if the user does not have permission to view the state of the tasks
    
    UnknownTaskException - if the name of a task is invalid
    
    TimeoutException - if none of the executions of tasks finish before the elapse of wait time
  - waitForAllTasks
```
public List<Map.Entry<String,TaskResult>> waitForAllTasks(String jobId,
                                                          List<String> taskNames,
                                                          long timeout)
                                                   throws UnknownJobException,
                                                          NotConnectedException,
                                                          PermissionException,
                                                          UnknownTaskException,
                                                          TimeoutException
```
    Description copied from interface: ISchedulerClient
    
    Causes the current thread to wait until all the executions of specified tasks finish or the elapse of specified amount of time.
    Returns a list of task name and task result pairs, if all the executions of specified tasks finishes before the elapse of wait time. Otherwise a timeout exception is thrown.
    
    Specified by:
    
    waitForAllTasks in interface ISchedulerClient
    
    Parameters:
    
    jobId - the identifier of the job to which all the specified tasks belong
    
    taskNames - the task names
    
    timeout - the maximum amount of wait time
    
    Returns:
    
    a list of task name and task result pairs
    
    Throws:
    
    UnknownJobException - if the job identifier is invalid
    
    NotConnectedException - if the client is not logged in or the session has expired.
    
    PermissionException - if the user does not have permission to view the state of the tasks
    
    UnknownTaskException - if a task name is invalid
    
    TimeoutException - if all the executions of the tasks do not finish before the elapse of maximum wait time
  - pushFile
```
public boolean pushFile(String spacename,
                        String pathname,
                        String filename,
                        String file)
                 throws NotConnectedException,
                        PermissionException
```
    Description copied from interface: ISchedulerClient
    
    Transfers the specified file from the local file system to the specified dataspace at the server
    
    Specified by:
    
    pushFile in interface ISchedulerClient
    
    Parameters:
    
    spacename - the dataspace name
    
    pathname - the path of the stored file with respect to the dataspace
    
    filename - the name of the stored file with respect to the dataspace
    
    file - the local file
    
    Returns:
    
    true, if the file transfer completes successfully
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    PermissionException - if the user does not have permission to upload the file to the specified dataspace
  - pullFile
```
public void pullFile(String space,
                     String pathname,
                     String outputFile)
              throws NotConnectedException,
                     PermissionException
```
    Description copied from interface: ISchedulerClient
    
    Retrieves the specified file from the server.
    
    Specified by:
    
    pullFile in interface ISchedulerClient
    
    Parameters:
    
    space - the dataspace name
    
    pathname - the pathname of the file with respect the dataspace
    
    outputFile - the name of the output file
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    PermissionException - if the user does not have permission to retrieve the specified file from the server
  - deleteFile
```
public boolean deleteFile(String space,
                          String pathname)
                   throws NotConnectedException,
                          PermissionException
```
    Description copied from interface: ISchedulerClient
    
    Deletes the specified file from the server.
    
    Specified by:
    
    deleteFile in interface ISchedulerClient
    
    Parameters:
    
    space - the dataspace name
    
    pathname - the pathname of the file with respect to the dataspace
    
    Returns:
    
    true if the specified file has been deleted successfully
    
    Throws:
    
    NotConnectedException - if the client is not logged in or the session has expired
    
    PermissionException - if the user does not have permission to delete the file from the server
  - getUserSpaceURIs
```
public List<String> getUserSpaceURIs()
                              throws NotConnectedException,
                                     PermissionException
```
    Description copied from interface: Scheduler
    
    Returns the USER DataSpace URIs associated with the current user
    
    Specified by:
    
    getUserSpaceURIs in interface Scheduler
    
    Returns:
    
    USER Space URIs (one element for each available protocol)
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException
  - getGlobalSpaceURIs
```
public List<String> getGlobalSpaceURIs()
                                throws NotConnectedException,
                                       PermissionException
```
    Description copied from interface: Scheduler
    
    Returns the GLOBAL DataSpace URI available to all users
    
    Specified by:
    
    getGlobalSpaceURIs in interface Scheduler
    
    Returns:
    
    GLOBAL Space URIs (one element for each available protocol)
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException
  - renewSession
```
public void renewSession()
                  throws NotConnectedException
```
    Description copied from interface: Scheduler
    
    This method renew the connection lease without other side effect.
    
    Specified by:
    
    renewSession in interface Scheduler
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
  - setSession
```
public void setSession(String sid)
```
    Description copied from interface: ISchedulerClient
    
    Sets the session identifier explicitly. This might run on an uninitialized client.
    
    Specified by:
    
    setSession in interface ISchedulerClient
    
    Parameters:
    
    sid - session identifier
  - getSession
```
public String getSession()
```
    Description copied from interface: ISchedulerClient
    
    Retrieves the current session identifier, or null if the session was not initialized yet.
    
    Specified by:
    
    getSession in interface ISchedulerClient
    
    Returns:
    
    the current session identifier if initialize, null otherwise
  - addEventListener
```
public void addEventListener(SchedulerEventListener listener,
                             boolean myEventsOnly,
                             SchedulerEvent... events)
                      throws NotConnectedException,
                             PermissionException
```
    Description copied from interface: Scheduler
    
    Add a scheduler event Listener. this listener provides method to notice of new coming job, started task, finished task, running job, finished job, etc...
    
    This method behaves exactly the same as a call to addEventListener(sel, myEventsOnly, false, events); but return nothing
    
    Specified by:
    
    addEventListener in interface Scheduler
    
    Parameters:
    
    listener - a SchedulerEventListener on which the scheduler will talk.
    
    myEventsOnly - a boolean that indicates if you want to receive every event or just the one concerning your jobs. This won't affect the scheduler state event that will be sent anyway.
    
    events - An array of events that you want to receive from the scheduler.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular job.
  - removeEventListener
```
public void removeEventListener()
                         throws NotConnectedException,
                                PermissionException
```
    Description copied from interface: Scheduler
    
    Remove the current event listener your listening on.
    If no listener is defined, this method has no effect.
    
    Specified by:
    
    removeEventListener in interface Scheduler
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular method.
  - putThirdPartyCredential
```
public void putThirdPartyCredential(String key,
                                    String value)
                             throws NotConnectedException,
                                    PermissionException,
                                    KeyException
```
    Description copied from interface: ThirdPartyCredentials
    
    Stores a third-party credential key-value pair in the database.
    
    Specified by:
    
    putThirdPartyCredential in interface ThirdPartyCredentials
    
    Parameters:
    
    key - the third-party credential key to store
    
    value - the third-party credential value to store, it will be encrypted
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access this particular method.
    
    KeyException - if encryption of value fails
  - thirdPartyCredentialsKeySet
```
public Set<String> thirdPartyCredentialsKeySet()
                                        throws NotConnectedException,
                                               PermissionException
```
    Specified by:
    
    thirdPartyCredentialsKeySet in interface ThirdPartyCredentials
    
    Returns:
    
    all third-party credential keys stored for the current user
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access this particular method.
  - removeThirdPartyCredential
```
public void removeThirdPartyCredential(String key)
                                throws NotConnectedException,
                                       PermissionException
```
    Specified by:
    
    removeThirdPartyCredential in interface ThirdPartyCredentials
    
    Parameters:
    
    key - the third-party credential key to remove
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access this particular method.
  - getTaskIds
```
public Page<TaskId> getTaskIds(String taskTag,
                               long from,
                               long to,
                               boolean mytasks,
                               boolean running,
                               boolean pending,
                               boolean finished,
                               int offset,
                               int limit)
                        throws NotConnectedException,
                               PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieve a tasks names list from the scheduler.
    
    Specified by:
    
    getTaskIds in interface Scheduler
    
    Parameters:
    
    taskTag - a complete tag to use to filter tasks
    
    from - the starting date to fetch tasks from. The format is in Epoch time.
    
    to - the end date to stop fetching tasks. The format is in Epoch time.
    
    mytasks - True will only fetch the user tasks, False will fetch everyones.
    
    running - fetch the running tasks.
    
    pending - fetch the pending tasks.
    
    finished - fetch the finished tasks.
    
    offset - the starting task to include in the paginated list.
    
    limit - the last task (not included) before stopping fetching tasks in the paginated list.
    
    Returns:
    
    the paginated list of tasks names satisfying the given criterias. The total number of tasks (without pagination() is also returned.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getTaskStates
```
public Page<TaskState> getTaskStates(String taskTag,
                                     long from,
                                     long to,
                                     boolean mytasks,
                                     boolean running,
                                     boolean pending,
                                     boolean finished,
                                     int offset,
                                     int limit,
                                     SortSpecifierContainer sortParams)
                              throws NotConnectedException,
                                     PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieve a taskstates list from the scheduler.
    
    Specified by:
    
    getTaskStates in interface Scheduler
    
    Parameters:
    
    taskTag - a complete tag to use to filter tasks
    
    from - the starting date to fetch tasks from. The format is in Epoch time.
    
    to - the end date to stop fetching tasks. The format is in Epoch time.
    
    mytasks - True will only fetch the user tasks, False will fetch everyones.
    
    running - fetch the running tasks.
    
    pending - fetch the pending tasks.
    
    finished - fetch the finished tasks.
    
    offset - the starting task to include in the paginated list.
    
    limit - the last task (not included) before stopping fetching tasks in the paginated list.
    
    Returns:
    
    the paginated list of taskstates satisfying the given criterias. The total number of tasks (without pagination() is also returned.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getJobInfo
```
public JobInfo getJobInfo(String jobId)
                   throws UnknownJobException,
                          NotConnectedException,
                          PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieve a job info by it id.
    
    Specified by:
    
    getJobInfo in interface Scheduler
    
    Parameters:
    
    jobId - the id of the job we want to fetch info.
    
    Returns:
    
    the JobInfo associated to the given id
    
    Throws:
    
    UnknownJobException
    
    NotConnectedException
    
    PermissionException
  - changeStartAt
```
public boolean changeStartAt(JobId jobId,
                             String startAt)
                      throws NotConnectedException,
                             UnknownJobException,
                             PermissionException
```
    Description copied from interface: Scheduler
    
    Change the START_AT generic information at job level and reset the scheduledAt at task level
    
    Specified by:
    
    changeStartAt in interface Scheduler
    
    Parameters:
    
    jobId - id of the job that needs to be updated
    
    startAt - its value should be ISO 8601 compliant
    
    Throws:
    
    NotConnectedException
    
    UnknownJobException
    
    PermissionException
  - getJobContent
```
public String getJobContent(JobId jobId)
                     throws NotConnectedException,
                            PermissionException,
                            UnknownJobException,
                            JobCreationException,
                            SubmissionClosedException
```
    Specified by:
    
    getJobContent in interface Scheduler
    
    Parameters:
    
    jobId - job id of existing job
    
    Returns:
    
    copy of the xml which was submitted to the scheduler
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    UnknownJobException
    
    JobCreationException
    
    SubmissionClosedException
  - getPortalConfiguration
```
public Map<Object,Object> getPortalConfiguration()
                                          throws NotConnectedException,
                                                 PermissionException
```
    Specified by:
    
    getPortalConfiguration in interface Scheduler
    
    Returns:
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getCurrentUser
```
public String getCurrentUser()
                      throws NotConnectedException
```
    Description copied from interface: Scheduler
    
    Returns the user currently connected
    
    Specified by:
    
    getCurrentUser in interface Scheduler
    
    Returns:
    
    user name
    
    Throws:
    
    NotConnectedException
  - getCurrentUserData
```
public UserData getCurrentUserData()
                            throws NotConnectedException
```
    Description copied from interface: Scheduler
    
    Returns the user data object associated with the user currently connected
    
    Specified by:
    
    getCurrentUserData in interface Scheduler
    
    Returns:
    
    a user data object
    
    Throws:
    
    NotConnectedException
  - getSchedulerProperties
```
public Map<String,Object> getSchedulerProperties()
                                          throws NotConnectedException,
                                                 PermissionException
```
    Description copied from interface: Scheduler
    
    Returns the scheduler properties associated with the user currently connected
    
    Specified by:
    
    getSchedulerProperties in interface Scheduler
    
    Returns:
    
    scheduler properties
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - getTaskPaginated
```
public TaskStatesPage getTaskPaginated(String jobId,
                                       int offset,
                                       int limit)
                                throws NotConnectedException,
                                       UnknownJobException,
                                       PermissionException
```
    Description copied from interface: Scheduler
    
    Return the page of tasks of the given job.
    
    Specified by:
    
    getTaskPaginated in interface Scheduler
    
    Parameters:
    
    jobId - the job on which to get the state.
    
    offset - the starting index of the sublist of tasks to get
    
    limit - the last index (non inclusive) of the sublist of tasks to get
    
    Returns:
    
    the current state of the given job
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    UnknownJobException - if the job does not exist.
    
    PermissionException - if you can't access to this particular job.
  - checkJobPermissionMethod
```
public boolean checkJobPermissionMethod(String sessionId,
                                        String jobId,
                                        String method)
                                 throws NotConnectedException,
                                        UnknownJobException
```
    Description copied from interface: Scheduler
    
    Check if the user has the permission to execute the method passed as argument
    
    Specified by:
    
    checkJobPermissionMethod in interface Scheduler
    
    Returns:
    
    true if the user has the permission to execute the java method
    
    Throws:
    
    NotConnectedException
    
    UnknownJobException

Class SchedulerClient

Method Summary

Methods inherited from class org.ow2.proactive.scheduler.rest.ClientBase

Methods inherited from class java.lang.Object

Methods inherited from interface org.ow2.proactive.scheduler.common.Scheduler

Method Detail

createInstance

init

getConnectionInfo

getAccountUsage

getMyAccountUsage

changeJobPriority

changeJobPriority

disconnect

freeze

getJobResult

getJobResult

getJobState

getJobState

getJobs

getJobsInfoList

getJobServerLogs

getStatus

getTaskResult

getTaskResult

getTaskResultsByTag

getTaskResultsByTag

getTaskServerLogs

getTaskServerLogsByTag

getUsers

getUsersWithJobs

isConnected

getCurrentPolicy

getJobsToSchedule

getTasksToSchedule

kill

killJob

killJob

killTask

killTask

linkResourceManager

pause

pauseJob

pauseJob

restartAllInErrorTasks

preemptTask

preemptTask

removeJob

removeJob

restartTask

restartTask

finishInErrorTask

restartInErrorTask

resume

resumeJob

resumeJob

shutdown

start

stop

submit

submit

submit

submit

submit

submit

submit

submit

submit

submitFromCatalog

submitFromCatalog

submitFromCatalog

submitFromCatalog

submitFromCatalog

submitFromCatalog

isJobFinished

isJobFinished

waitForJob

waitForJob

isTaskFinished

waitForTask