AbstractSmartProxy (scheduling 8.4.0 API)

java.lang.Object
- org.ow2.proactive.scheduler.smartproxy.common.AbstractSmartProxy<T>

All Implemented Interfaces:

Scheduler, SchedulerEventListener, ThirdPartyCredentials, SchedulerUsage

Direct Known Subclasses:

RestSmartProxyImpl, SmartProxyImpl
```
public abstract class AbstractSmartProxy<T extends JobTracker>
extends Object
implements Scheduler, SchedulerEventListener
```
Asbtract implementation of smart proxy that factorizes code used by all smart proxy implementations.
Smart proxy is a proxy to the Scheduler with built-in support for automatic data pushing and pulling in order to provide disconnected mode for the dataspace layer.

Field Summary

Fields
Modifier and Type	Field and Description
`protected SchedulerEvent[]`	`configuredEvents`
`protected ConnectionInfo`	`connectionInfo`
`protected Set<SchedulerEventListenerExtended>`	`eventListeners`
`static String`	`GENERIC_INFO_INPUT_FOLDER_PROPERTY_NAME`
`static String`	`GENERIC_INFO_OUTPUT_FOLDER_PROPERTY_NAME`
`static String`	`GENERIC_INFO_PULL_URL_PROPERTY_NAME`
`static String`	`GENERIC_INFO_PUSH_URL_PROPERTY_NAME`
`protected T`	`jobTracker`
`static int`	`MAX_NB_OF_DATA_TRANSFER_THREADS`
`protected static SchedulerEvent[]`	`PROXY_SCHED_EVENTS`
`protected boolean`	`terminated`
`protected boolean`	`terminating`
`protected ExecutorService`	`threadPool`

Constructor Summary

Constructors
Constructor and Description

AbstractSmartProxy()

AbstractSmartProxy(T jobTracker)

Constructors
Constructor and Description
`AbstractSmartProxy()`
`AbstractSmartProxy(T jobTracker)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract Scheduler`	`_getScheduler()` Returns a proxy instance to the Scheduler.
`SchedulerState`	`addEventListener(SchedulerEventListener sel, boolean myEventsOnly, boolean getCurrentState, SchedulerEvent... events)` Add a scheduler event Listener.
`void`	`addEventListener(SchedulerEventListener sel, boolean myEventsOnly, SchedulerEvent... events)` Add a scheduler event Listener.
`void`	`addEventListener(SchedulerEventListenerExtended sel)`
`abstract void`	`addEventListener(SchedulerEventListenerExtended listener, boolean myEventsOnly, SchedulerEvent[] events)`
`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`	`changePolicy(String policyClassName)` For administrator only, change the policy of the scheduler.
`protected void`	`checkInitialized()`
`void`	`cleanDatabase()` Cleans the DataBase handled by the smart proxy, it will delete all informations tracked.
`void`	`configureEvents(SchedulerEvent... events)` Configure the scheduler events this smart proxy is listening to.
`protected abstract void`	`createFolder(String fUri)`
`protected String`	`createNewFolderName()`
`abstract void`	`disconnect()` Disconnect from the scheduler
`protected abstract void`	`downloadTaskOutputFiles(AwaitedJob awaitedjob, String jobId, String t_name, String localFolder)` Pull the output files of the given task from the pull_url either to the localFolder defined for the job or to the localFolder specified as argument, if it is not null.
`boolean`	`freeze()` For administrator only, Freeze the scheduler by terminating running tasks.
`List<JobUsage>`	`getAccountUsage(String user, Date startDate, Date endDate)` Returns details on job and task execution times for a given user's executions.
`String`	`getCurrentPolicy()` Return the name of the current Policy
`abstract List<String>`	`getGlobalSpaceURIs()` Returns the GLOBAL DataSpace URI available to all users
`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 offset, int limit, JobFilterCriteria filterCriteria, List<SortParameter<JobSortParameter>> sortParameters)` Retrieves a job list of the scheduler.
`String`	`getJobServerLogs(String id)` 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.
`abstract 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.
`SchedulerState`	`getState()` Get the list of job states that describe every jobs in the Scheduler.
`SchedulerState`	`getState(boolean myJobsOnly)` Get the list of job states that describe every jobs in the Scheduler.
`SchedulerStatus`	`getStatus()` Get the current status of the Scheduler
`TaskResult`	`getTaskResult(JobId jobId, String taskName)` Get the result for the given task name in the given jobId.
`abstract TaskResult`	`getTaskResult(String jobId, String taskName)` Get the result for the given task name in the given jobId.
`List<TaskResult>`	`getTaskResultAllIncarnations(JobId jobId, String taskName)` Get the result for the given task name and all result incarnations in the given jobId.
`List<TaskResult>`	`getTaskResultAllIncarnations(String jobId, String taskName)` Get the result for the given task name and all result incarnations in the given jobId.
`TaskResult`	`getTaskResultFromIncarnation(JobId jobId, String taskName, int inc)` Get the result for the given task name and the given incarnation in the given jobId.
`TaskResult`	`getTaskResultFromIncarnation(String jobId, String taskName, int inc)` Get the result for the given task name and the given incarnation 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 id, String taskName)` Retrieves server logs for a task with the given id.
`String`	`getTaskServerLogsByTag(String id, String taskTag)` Retrieves server logs for a set of tasks filtered by the given tag.
`List<TaskDescriptor>`	`getTasksToSchedule()` get task descriptor list with eligible tasks (running)
`List<SchedulerUserInfo>`	`getUsers()` Returns a list of connected users.
`abstract List<String>`	`getUserSpaceURIs()` Returns the USER DataSpace URIs associated with the current user
`List<SchedulerUserInfo>`	`getUsersWithJobs()` Returns a list of users having jobs.
`abstract void`	`init(ConnectionInfo connectionInfo)` Connects to the scheduler
`boolean`	`isConnected()` Test whether or not the user is connected to the ProActive Scheduler.
`void`	`jobStateUpdatedEvent(NotificationData<JobInfo> notification)` Invoked each time the state of a job has changed. If you want to maintain an up to date list of jobs, just use the `JobState.update(org.ow2.proactive.scheduler.common.job.JobInfo)` method to update the content of your job.
`void`	`jobSubmittedEvent(JobState job)` Invoked each time a new job has been submitted to the Scheduler and validated.
`void`	`jobUpdatedFullDataEvent(JobState job)` Invoked each time the state of a job has changed and each time a scheduler event occurs.
`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.
`void`	`listenJobLogs(JobId jobId, AppenderProvider appenderProvider)` Listen for the tasks user logs.
`void`	`listenJobLogs(String jobId, AppenderProvider appenderProvider)` Listen for the tasks user logs. The jobId is given as a string.
`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.
`protected String`	`prepareJobInput(Job job, String localInputFolder, List<String> pushURLs, String newFolderName)` This method will create a remote folder for the input data of this job and update the inputSpace job property.
`protected String`	`prepareJobOutput(TaskFlowJob job, String localOutputFolder, List<String> pull_urls, String newFolderName, boolean isolateTaskOutputs)` This method will create a remote folder for output of this job and update the outputSpace job property.
`void`	`pullData(String jobId, String t_name, String localFolder)` Transfer the output files associated with the given task to the specified local folder.
`void`	`putThirdPartyCredential(String key, String value)` Stores a third-party credential key-value pair in the database.
`void`	`reconnect()` Reconnects this smart proxy to the scheduler
`abstract void`	`registerAsListener()`
`protected void`	`reinitializeState()`
`boolean`	`reloadPolicyConfiguration()` For administrator only, order a reload to the policy.
`protected void`	`removeAwaitedTask(String jobId, String taskName)` The method from jobTracker is encapsulated in order to be called via the SmartProxy stub
`void`	`removeEventListener()` Remove the current event listener your listening on. If no listener is defined, this method has no effect.
`void`	`removeEventListener(SchedulerEventListenerExtended sel)`
`boolean`	`removeJob(JobId jobId)` Remove the job from the scheduler.
`boolean`	`removeJob(String jobId)` Remove the job from the scheduler.
`protected abstract void`	`removeJobIO(Job job, String pushURL, String pullURL, String newFolderName)`
`void`	`removeThirdPartyCredential(String key)`
`void`	`renewSession()` This method renew the connection lease without other side effect.
`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`	`schedulerStateUpdatedEvent(SchedulerEvent eventType)` Invoked each time a scheduler event occurs. Scheduler events are stopped,started, paused, frozen, etc.
`protected void`	`setInitialized(boolean initialized)`
`void`	`setSessionName(String name)` Sets the name of this recording session.
`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.
`abstract JobId`	`submit(Job job)` Submit a new job to the scheduler.
`JobId`	`submit(TaskFlowJob job, String localInputFolderPath, String localOutputFolderPath, boolean isolateTaskOutputs, boolean automaticTransfer)` Submits a job to the scheduler and handle data transfer via the SmartProxy, the dataspace server will be the default user space
`JobId`	`submit(TaskFlowJob job, String localInputFolderPath, String pushUrl, String localOutputFolderPath, String pullUrl, boolean isolateTaskOutputs, boolean automaticTransfer)` Submits a job to the scheduler and handle data transfer via the SmartProxy
`void`	`syncAwaitedJobs()` This method will synchronize this proxy with a remote Scheduler, it will contact the scheduler and checks the current state of every job being handled.
`void`	`taskStateUpdatedEvent(NotificationData<TaskInfo> notification)` Invoked each time the state of a task has changed. In this case you can use the `JobState.update(org.ow2.proactive.scheduler.common.task.TaskInfo)` method to update the content of the designated task inside your job.
`void`	`terminate()` Terminate the SmartProxy, and release all resources used.
`Set<String>`	`thirdPartyCredentialsKeySet()`
`protected void`	`updateJob(NotificationData<?> notification)` Check if the job concerned by this notification is awaited.
`protected void`	`updateTask(NotificationData<TaskInfo> notification)` Check if the task concerned by this notification is awaited.
`abstract boolean`	`uploadInputfiles(TaskFlowJob job, String localInputFolderPath)` Push the input files of the given job from the local input folder to the location specified by PUSH_URL.
`void`	`usersUpdatedEvent(NotificationData<UserIdentification> notification)` Invoked each time something change about users.

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
changeStartAt, checkJobPermissionMethod, finishInErrorTask, getCurrentUser, getCurrentUserData, getJobContent, getJobInfo, getPortalConfiguration, getSchedulerProperties, getTaskIds, getTaskPaginated, getTaskStates, restartAllInErrorTasks, restartInErrorTask

- Field Detail
  - GENERIC_INFO_INPUT_FOLDER_PROPERTY_NAME
```
public static final String GENERIC_INFO_INPUT_FOLDER_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - GENERIC_INFO_OUTPUT_FOLDER_PROPERTY_NAME
```
public static final String GENERIC_INFO_OUTPUT_FOLDER_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - GENERIC_INFO_PUSH_URL_PROPERTY_NAME
```
public static final String GENERIC_INFO_PUSH_URL_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - GENERIC_INFO_PULL_URL_PROPERTY_NAME
```
public static final String GENERIC_INFO_PULL_URL_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - MAX_NB_OF_DATA_TRANSFER_THREADS
```
public static final int MAX_NB_OF_DATA_TRANSFER_THREADS
```
  - PROXY_SCHED_EVENTS
```
protected static final SchedulerEvent[] PROXY_SCHED_EVENTS
```
  - configuredEvents
```
protected SchedulerEvent[] configuredEvents
```
  - jobTracker
```
protected T extends JobTracker jobTracker
```
  - connectionInfo
```
protected ConnectionInfo connectionInfo
```
  - eventListeners
```
protected Set<SchedulerEventListenerExtended> eventListeners
```
  - threadPool
```
protected final ExecutorService threadPool
```
  - terminated
```
protected boolean terminated
```
  - terminating
```
protected boolean terminating
```
- Constructor Detail
  - AbstractSmartProxy
```
public AbstractSmartProxy()
```
  - AbstractSmartProxy
```
public AbstractSmartProxy(T jobTracker)
```
- Method Detail
  - cleanDatabase
```
public void cleanDatabase()
```
    Cleans the DataBase handled by the smart proxy, it will delete all informations tracked. Warning : This method cannot be called after a call to terminate
  - terminate
```
public void terminate()
```
    Terminate the SmartProxy, and release all resources used.
  - setSessionName
```
public void setSessionName(String name)
```
    Sets the name of this recording session. The name must be an unique word composed of alphanumerical charecter The file used to persist awaited jobs will be named accordingly. If no session name is provided, a generic default name will be used.
    
    Parameters:
    
    name - name of the session to create or reuse
  - configureEvents
```
public void configureEvents(SchedulerEvent... events)
```
    Configure the scheduler events this smart proxy is listening to. Default is all events Call to this method must be done before initialization of the proxy
    
    Parameters:
    
    events -
  - init
```
public abstract void init(ConnectionInfo connectionInfo)
                   throws SchedulerException,
                          LoginException
```
    Connects to the scheduler
    
    Parameters:
    
    connectionInfo@throws - SchedulerException
    
    Throws:
    
    LoginException
    
    SchedulerException
  - disconnect
```
public abstract void disconnect()
                         throws PermissionException,
                                NotConnectedException
```
    Disconnect from the scheduler
    
    Specified by:
    
    disconnect in interface Scheduler
    
    Throws:
    
    PermissionException
    
    NotConnectedException
  - 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.
  - 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.
  - getJobServerLogs
```
public String getJobServerLogs(String id)
                        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:
    
    id - 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.
  - getTaskServerLogs
```
public String getTaskServerLogs(String id,
                                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:
    
    id - 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 id,
                                     String taskTag)
                              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:
    
    id - of the job where the task is.
    
    taskTag - 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.
  - getJobs
```
public Page<JobInfo> getJobs(int offset,
                             int limit,
                             JobFilterCriteria filterCriteria,
                             List<SortParameter<JobSortParameter>> sortParameters)
                      throws NotConnectedException,
                             PermissionException
```
    Description copied from interface: Scheduler
    
    Retrieves a job list of the scheduler.
    
    Specified by:
    
    getJobs in interface Scheduler
    
    Parameters:
    
    offset - says to start from this job is
    
    limit - max number of jobs to retrieve
    
    filterCriteria - 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.
    
    sortParameters - 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.
  - 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
  - reconnect
```
public void reconnect()
               throws SchedulerException,
                      LoginException
```
    Reconnects this smart proxy to the scheduler
    
    Throws:
    
    SchedulerException
    
    LoginException
  - submit
```
public JobId submit(TaskFlowJob job,
                    String localInputFolderPath,
                    String localOutputFolderPath,
                    boolean isolateTaskOutputs,
                    boolean automaticTransfer)
             throws NotConnectedException,
                    PermissionException,
                    SubmissionClosedException,
                    JobCreationException,
                    Exception
```
    Submits a job to the scheduler and handle data transfer via the SmartProxy, the dataspace server will be the default user space
    
    Parameters:
    
    job - job to submit
    
    localInputFolderPath - path to the local directory containing input files
    
    localOutputFolderPath - path to the local directory which will contain output files
    
    isolateTaskOutputs - if set to true, output files from each tasks will be isolated from each other in the dataspace server (to prevent overlapping)
    
    automaticTransfer - if set to true, output files will be automatically transferred from the dataspace server to the local machine as soon as the task is finished. If set to false, the files will not be automatically transferred and a call to pullData must be done to transfer files
    
    Returns:
    
    the new job id
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    SubmissionClosedException
    
    JobCreationException
    
    Exception
  - submit
```
public JobId submit(TaskFlowJob job,
                    String localInputFolderPath,
                    String pushUrl,
                    String localOutputFolderPath,
                    String pullUrl,
                    boolean isolateTaskOutputs,
                    boolean automaticTransfer)
             throws Exception,
                    SubmissionClosedException,
                    JobCreationException
```
    Submits a job to the scheduler and handle data transfer via the SmartProxy
    
    Parameters:
    
    job - job to submit
    
    localInputFolderPath - path to the local directory containing input files
    
    pushUrl - url of the dataspace server used to push input files to
    
    localOutputFolderPath - path to the local directory which will contain output files
    
    pullUrl - url of the dataspace server used to pull output files from
    
    isolateTaskOutputs - if set to true, output files from each tasks will be isolated from each other in the dataspace server (to prevent overlapping)
    
    automaticTransfer - if set to true, output files will be automatically transferred from the dataspace server to the local machine as soon as the task is finished. If set to false, the files will not be automatically transferred and a call to pullData must be done to transfer files
    
    Returns:
    
    the new job id
    
    Throws:
    
    Exception
    
    SubmissionClosedException
    
    JobCreationException
  - pullData
```
public void pullData(String jobId,
                     String t_name,
                     String localFolder)
              throws Exception
```
    Transfer the output files associated with the given task to the specified local folder. This method must be called manually if automaticTransfer was set to false at job submission
    
    Parameters:
    
    jobId - id of the job
    
    t_name - name of the task
    
    localFolder - path to the local directory which will contain output files
    
    Throws:
    
    Exception
  - checkInitialized
```
protected void checkInitialized()
```
  - setInitialized
```
protected void setInitialized(boolean initialized)
```
  - reinitializeState
```
protected void reinitializeState()
                          throws NotConnectedException,
                                 PermissionException
```
    Throws:
    
    NotConnectedException
    
    PermissionException
  - syncAwaitedJobs
```
public void syncAwaitedJobs()
```
    This method will synchronize this proxy with a remote Scheduler, it will contact the scheduler and checks the current state of every job being handled. It is called either during the proxy initialization, or after a manual reconnection.
  - prepareJobOutput
```
protected String prepareJobOutput(TaskFlowJob job,
                                  String localOutputFolder,
                                  List<String> pull_urls,
                                  String newFolderName,
                                  boolean isolateTaskOutputs)
                           throws NotConnectedException,
                                  PermissionException
```
    This method will create a remote folder for output of this job and update the outputSpace job property. If the localOutputFolder parameter is null, or pull_url no action will be performed concerning this job's output.
    
    We suppose there is file storage accessible by the client application as well as the tasks on the computation nodes.
    This storage could be different for input and for output.
    
    This output storage can be accessed, by the client application, using the pull_url and by the tasks on the nodes using the job's output space url.
    
    Prepare Output Data Transfer
    A folder will be created at pull_url/NewFolder/output (which, from the nodes side, is job.OutputSpace/NewFolder/output).
    The OutputSpace property of the job will be changed to the new location. job.OutputSpace = job.OutputSpace/NewFolder/output
    A generic information will be attached to the job containing the local output folder path If the option isolateTaskOutputs is set, a subfolder of "output" named "[TASKID]" will be created, it will behave as a tag to tell the TaskLauncher to create a subfolder with the real taskid when the task is executed.
    
    Parameters:
    
    job -
    
    localOutputFolder - path to the output folder on local machine if null, no actions will be performed concerning the output data for this job
    
    pull_urls - the urls where the data is to be retrieved after the job is finished
    
    newFolderName - name of the folder to be used for pushing the output
    
    isolateTaskOutputs - task output isolation (see method submit)
    
    Returns:
    
    a String representing the updated value of the pull_url
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - prepareJobInput
```
protected String prepareJobInput(Job job,
                                 String localInputFolder,
                                 List<String> pushURLs,
                                 String newFolderName)
                          throws NotConnectedException,
                                 PermissionException
```
    This method will create a remote folder for the input data of this job and update the inputSpace job property. If the localInputFolder parameter is null, or push_url is null, no action will be performed concerning this job's input.
    
    We suppose there is file storage accessible by the client application as well as the tasks on the computation nodes.
    This storage could be different for input and for output.
    The input storage can be accessed, by the client application, using the push_url and by the tasks on the nodes using the job's input space url.
    
    Prepare Input Data Transfer
    A folder will be created at push_url/newFolderName/input (which, from the nodes side, is the job.InputSpace/newFolderName/input) . The InputSpace property of the job will be changed to the new location. job.InputSpace = job.InputSpace/NewFolder/input
    
    A generic information will be attached to the job containing the local input folder path.
    
    Parameters:
    
    job -
    
    localInputFolder - path to the input folder on local machine if null, no actions will be performed concerning the input data for this job
    
    pushURLs - the urls where input data is to be pushed before the job submission
    
    newFolderName - name of the new folder to be created
    
    Returns:
    
    String representing the updated value of the push_url
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - createNewFolderName
```
protected String createNewFolderName()
```
  - addEventListener
```
public void addEventListener(SchedulerEventListenerExtended sel)
                      throws NotConnectedException,
                             PermissionException
```
    Throws:
    
    NotConnectedException
    
    PermissionException
  - removeEventListener
```
public void removeEventListener(SchedulerEventListenerExtended sel)
```
  - schedulerStateUpdatedEvent
```
public void schedulerStateUpdatedEvent(SchedulerEvent eventType)
```
    Description copied from interface: SchedulerEventListener
    
    Invoked each time a scheduler event occurs.
    Scheduler events are stopped,started, paused, frozen, etc.
    
    Specified by:
    
    schedulerStateUpdatedEvent in interface SchedulerEventListener
    
    Parameters:
    
    eventType - the type of the event received.
  - jobSubmittedEvent
```
public void jobSubmittedEvent(JobState job)
```
    Description copied from interface: SchedulerEventListener
    
    Invoked each time a new job has been submitted to the Scheduler and validated.
    
    Specified by:
    
    jobSubmittedEvent in interface SchedulerEventListener
    
    Parameters:
    
    job - the newly submitted job.
  - jobStateUpdatedEvent
```
public void jobStateUpdatedEvent(NotificationData<JobInfo> notification)
```
    Description copied from interface: SchedulerEventListener
    
    Invoked each time the state of a job has changed.
    If you want to maintain an up to date list of jobs, just use the JobState.update(org.ow2.proactive.scheduler.common.job.JobInfo) method to update the content of your job.
    
    Specified by:
    
    jobStateUpdatedEvent in interface SchedulerEventListener
    
    Parameters:
    
    notification - the data composed of the type of the event and the information that have change in the job.
  - jobUpdatedFullDataEvent
```
public void jobUpdatedFullDataEvent(JobState job)
```
    Description copied from interface: SchedulerEventListener
    
    Invoked each time the state of a job has changed and each time a scheduler event occurs.
    
    Specified by:
    
    jobUpdatedFullDataEvent in interface SchedulerEventListener
    
    Parameters:
    
    job - the updated job.
  - taskStateUpdatedEvent
```
public void taskStateUpdatedEvent(NotificationData<TaskInfo> notification)
```
    Description copied from interface: SchedulerEventListener
    
    Invoked each time the state of a task has changed.
    In this case you can use the JobState.update(org.ow2.proactive.scheduler.common.task.TaskInfo) method to update the content of the designated task inside your job.
    
    Specified by:
    
    taskStateUpdatedEvent in interface SchedulerEventListener
    
    Parameters:
    
    notification - the data composed of the type of the event and the information that have change in the task.
  - usersUpdatedEvent
```
public void usersUpdatedEvent(NotificationData<UserIdentification> notification)
```
    Description copied from interface: SchedulerEventListener
    
    Invoked each time something change about users.
    
    Specified by:
    
    usersUpdatedEvent in interface SchedulerEventListener
    
    Parameters:
    
    notification - the data composed of the type of the event and the data linked to the change.
  - updateJob
```
protected void updateJob(NotificationData<?> notification)
```
    Check if the job concerned by this notification is awaited. Retrieve corresponding data if needed
    
    Parameters:
    
    notification -
  - updateTask
```
protected void updateTask(NotificationData<TaskInfo> notification)
```
    Check if the task concerned by this notification is awaited. Retrieve corresponding data if needed
    
    Parameters:
    
    notification -
  - removeAwaitedTask
```
protected void removeAwaitedTask(String jobId,
                                 String taskName)
```
    The method from jobTracker is encapsulated in order to be called via the SmartProxy stub
    
    Parameters:
    
    jobId -
    
    taskName -
  - _getScheduler
```
protected abstract Scheduler _getScheduler()
```
    Returns a proxy instance to the Scheduler.
    /!\ This method must not be exposed remotely since remote calls to the proxy that is returned will fail with permission failures.
    
    Returns:
    
    a proxy instance to the Scheduler.
  - registerAsListener
```
public abstract void registerAsListener()
                                 throws NotConnectedException,
                                        PermissionException
```
    Throws:
    
    NotConnectedException
    
    PermissionException
  - uploadInputfiles
```
public abstract boolean uploadInputfiles(TaskFlowJob job,
                                         String localInputFolderPath)
                                  throws Exception
```
    Push the input files of the given job from the local input folder to the location specified by PUSH_URL.
    
    Parameters:
    
    job - job to push data for
    
    localInputFolderPath - utFolderPath local input folder
    
    Returns:
    
    true if all input files are uploaded to the location specified by the PUSH_URL.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
    
    Exception
  - downloadTaskOutputFiles
```
protected abstract void downloadTaskOutputFiles(AwaitedJob awaitedjob,
                                                String jobId,
                                                String t_name,
                                                String localFolder)
                                         throws Exception
```
    Pull the output files of the given task from the pull_url either to the localFolder defined for the job or to the localFolder specified as argument, if it is not null. The call to the method pullData is triggered by the user. If the job is configured to be handled asynchronously, call to this method will trigger a RuntimeException.
    
    Parameters:
    
    jobId - job to pull data for
    
    t_name - name of the task
    
    localFolder - local output folder, if not null, it overrides the folder specified as output folder for the job
    
    Throws:
    
    Exception
  - submit
```
public abstract 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
  - 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 abstract 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.
  - 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.
  - 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.
  - getState
```
public SchedulerState getState()
                        throws NotConnectedException,
                               PermissionException
```
    Description copied from interface: Scheduler
    
    Get the list of job states that describe every jobs in the Scheduler. The SchedulerState contains 3 list of jobs, pending, running, and finished. Every jobs will be returned depending on your right.
    If a PermissionException is thrown, try using Scheduler.getState(boolean) method with argument true.
    
    Specified by:
    
    getState in interface Scheduler
    
    Returns:
    
    the list of every jobs in the Scheduler
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular method.
  - getState
```
public SchedulerState getState(boolean myJobsOnly)
                        throws NotConnectedException,
                               PermissionException
```
    Description copied from interface: Scheduler
    
    Get the list of job states that describe every jobs in the Scheduler. The SchedulerState contains 3 list of jobs, pending, running, and finished If the given argument is true, only job that you own will be returned, otherwise every jobs will be returned depending on your right.
    
    Specified by:
    
    getState in interface Scheduler
    
    Parameters:
    
    myJobsOnly - true to get only my jobs, false to get any.
    
    Returns:
    
    the list of every jobs in the Scheduler
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you can't access to this particular method.
  - addEventListener
```
public void addEventListener(SchedulerEventListener sel,
                             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:
    
    sel - 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.
  - addEventListener
```
public SchedulerState addEventListener(SchedulerEventListener sel,
                                       boolean myEventsOnly,
                                       boolean getCurrentState,
                                       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...
    
    You may use this method once by remote or active object.
    Every call to this method will remove your previous listening settings.
    If you want to get 2 type of events, add the 2 events type you want at the end of this method. If no type is specified, all of them will be sent.
    
    If you want to received the events concerning your job only, just set the 'myEventsOnly' parameter to true. otherwise, you will received events coming from any user.
    
    Specified by:
    
    addEventListener in interface Scheduler
    
    Parameters:
    
    sel - a SchedulerEventListener on which the scheduler will talk.
    
    myEventsOnly - a boolean that indicates if you want to receive every events or just those concerning your jobs. This won't affect the scheduler state event that will be sent anyway.
    
    getCurrentState - if false, this method returns null, if true, it returns the Scheduler current state.
    
    events - An array of events that you want to receive from the scheduler.
    
    Returns:
    
    the scheduler current state containing the different lists of jobs if the getInitialState parameter is true, null if false.
    
    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.
  - getTaskResult
```
public abstract 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.
  - getTaskResultFromIncarnation
```
public TaskResult getTaskResultFromIncarnation(String jobId,
                                               String taskName,
                                               int inc)
                                        throws NotConnectedException,
                                               UnknownJobException,
                                               UnknownTaskException,
                                               PermissionException
```
    Description copied from interface: Scheduler
    
    Get the result for the given task name and the given incarnation 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. The incarnation argument represents the task result to get. If the task has failed 3 times and then has worked, then 0 represents the last result, 1 the previous, ..., and 3 represents the result of the first execution.
    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:
    
    getTaskResultFromIncarnation in interface Scheduler
    
    Parameters:
    
    jobId - the job in which the task result is.
    
    taskName - the name of the task in which the result is.
    
    inc - id of incarnation (0 is the last one, 1 the previous, and so on...)
    
    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.
  - 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.
  - listenJobLogs
```
public void listenJobLogs(String jobId,
                          AppenderProvider appenderProvider)
                   throws NotConnectedException,
                          UnknownJobException,
                          PermissionException
```
    Description copied from interface: Scheduler
    
    Listen for the tasks user logs.
    The jobId is given as a string. It's in fact the string returned by the JobId.value() method.
    A user can only listen to HIS jobs.
    
    Specified by:
    
    listenJobLogs in interface Scheduler
    
    Parameters:
    
    jobId - the id of the job to listen to.
    
    appenderProvider - a provider for an appender that must be connected on a log server on the caller side (see LogForwardingService)
    
    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(String jobId,
                        String taskName)
                 throws NotConnectedException,
                        UnknownJobException,
                        UnknownTaskException,
                        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.
    
    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.
  - 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.
  - 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.
  - 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.
  - 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.
  - getUserSpaceURIs
```
public abstract 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 abstract 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
  - 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.
  - getTaskResultFromIncarnation
```
public TaskResult getTaskResultFromIncarnation(JobId jobId,
                                               String taskName,
                                               int inc)
                                        throws NotConnectedException,
                                               UnknownJobException,
                                               UnknownTaskException,
                                               PermissionException
```
    Description copied from interface: Scheduler
    
    Get the result for the given task name and the given incarnation in the given jobId.
    A user can only get HIS result back.
    The incarnation argument represents the task result to get. If the task has failed 3 times and then has worked, then 0 represents the last result, 1 the previous, ..., and 3 represents the result of the first execution.
    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:
    
    getTaskResultFromIncarnation in interface Scheduler
    
    Parameters:
    
    jobId - the job in which the task result is.
    
    taskName - the name of the task in which the result is.
    
    inc - id of incarnation (0 is the last one, 1 the previous, and so on...)
    
    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.
  - getTaskResultAllIncarnations
```
public List<TaskResult> getTaskResultAllIncarnations(JobId jobId,
                                                     String taskName)
                                              throws NotConnectedException,
                                                     UnknownJobException,
                                                     UnknownTaskException,
                                                     PermissionException
```
    Description copied from interface: Scheduler
    
    Get the result for the given task name and all result incarnations in the given jobId.
    This method returns a list of task result attempts. If the task has failed 3 times and then has worked, then the list will contain a list of 4 task results. 0 represents the first failed result attempt, 1 the next one, ..., and 3 represents the result of the last execution. In that sense the id order is reversed comparing to individual calls to getTaskResultFromIncarnation
    
    Specified by:
    
    getTaskResultAllIncarnations 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 list of Task Results containing information about the result. If the returned list is empty, 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.
  - getTaskResultAllIncarnations
```
public List<TaskResult> getTaskResultAllIncarnations(String jobId,
                                                     String taskName)
                                              throws NotConnectedException,
                                                     UnknownJobException,
                                                     UnknownTaskException,
                                                     PermissionException
```
    Description copied from interface: Scheduler
    
    Get the result for the given task name and all result incarnations in the given jobId.
    This method returns a list of task result attempts. If the task has failed 3 times and then has worked, then the list will contain a list of 4 task results. 0 represents the first failed result attempt, 1 the next one, ..., and 3 represents the result of the last execution. In that sense the id order is reversed comparing to individual calls to
    
    Specified by:
    
    getTaskResultAllIncarnations 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 list of Task Results containing information about the result. If the returned list is empty, 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.
  - killTask
```
public boolean killTask(JobId jobId,
                        String taskName)
                 throws NotConnectedException,
                        UnknownJobException,
                        UnknownTaskException,
                        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.
    
    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(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.
  - 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.
  - 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.
  - listenJobLogs
```
public void listenJobLogs(JobId jobId,
                          AppenderProvider appenderProvider)
                   throws NotConnectedException,
                          UnknownJobException,
                          PermissionException
```
    Description copied from interface: Scheduler
    
    Listen for the tasks user logs.
    A user can only listen to HIS jobs.
    
    Specified by:
    
    listenJobLogs in interface Scheduler
    
    Parameters:
    
    jobId - the id of the job to listen to.
    
    appenderProvider - a provider for an appender that must be connected on a log server on the caller side (see LogForwardingService)
    
    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(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.
  - 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.
  - 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.
  - 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.
  - changePolicy
```
public boolean changePolicy(String policyClassName)
                     throws NotConnectedException,
                            PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, change the policy of the scheduler.
    This method will immediately change the policy and so the whole scheduling process.
    
    Specified by:
    
    changePolicy in interface Scheduler
    
    Parameters:
    
    policyClassName - the new policy full class name.
    
    Returns:
    
    true if the policy has been correctly change, 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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
    
    Returns:
    
    a List of eligible task descriptor.
    
    Throws:
    
    NotConnectedException
    
    PermissionException
  - reloadPolicyConfiguration
```
public boolean reloadPolicyConfiguration()
                                  throws NotConnectedException,
                                         PermissionException
```
    Description copied from interface: Scheduler
    
    For administrator only, order a reload to the policy.
    The default behavior reload the configuration file and update the properties available in policy. This will cause the Policy#reloadConfig() method to be called. This last method can be overridden in the policy to perform a custom behavior on reload.
    
    Specified by:
    
    reloadPolicyConfiguration in interface Scheduler
    
    Returns:
    
    true if success, false otherwise.
    
    Throws:
    
    NotConnectedException - if you are not authenticated.
    
    PermissionException - if you have not enough permission to access this method.
  - addEventListener
```
public abstract void addEventListener(SchedulerEventListenerExtended listener,
                                      boolean myEventsOnly,
                                      SchedulerEvent[] events)
                               throws NotConnectedException,
                                      PermissionException
```
    Throws:
    
    NotConnectedException
    
    PermissionException
  - removeJobIO
```
protected abstract void removeJobIO(Job job,
                                    String pushURL,
                                    String pullURL,
                                    String newFolderName)
```
  - createFolder
```
protected abstract void createFolder(String fUri)
                              throws NotConnectedException,
                                     PermissionException
```
    Throws:
    
    NotConnectedException
    
    PermissionException
  - 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
  - getAccountUsage
```
public List<JobUsage> getAccountUsage(String user,
                                      Date startDate,
                                      Date endDate)
                               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
    
    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
  - 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.
  - 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.

Class AbstractSmartProxy<T extends JobTracker>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

GENERIC_INFO_INPUT_FOLDER_PROPERTY_NAME

GENERIC_INFO_OUTPUT_FOLDER_PROPERTY_NAME

GENERIC_INFO_PUSH_URL_PROPERTY_NAME

GENERIC_INFO_PULL_URL_PROPERTY_NAME

MAX_NB_OF_DATA_TRANSFER_THREADS

PROXY_SCHED_EVENTS

configuredEvents

jobTracker

connectionInfo

eventListeners

threadPool

terminated

terminating

Constructor Detail

AbstractSmartProxy

AbstractSmartProxy

Method Detail

cleanDatabase

terminate

setSessionName

configureEvents

init

disconnect

isConnected

renewSession

getJobServerLogs

getTaskServerLogs

getTaskServerLogsByTag

getJobs

getJobsInfoList

getUsers

getUsersWithJobs

reconnect

submit

submit

pullData

checkInitialized

setInitialized

reinitializeState

syncAwaitedJobs

prepareJobOutput

prepareJobInput

createNewFolderName

addEventListener

removeEventListener

schedulerStateUpdatedEvent

jobSubmittedEvent

jobStateUpdatedEvent

jobUpdatedFullDataEvent

taskStateUpdatedEvent

usersUpdatedEvent

updateJob

updateTask

removeAwaitedTask

_getScheduler

registerAsListener

uploadInputfiles

downloadTaskOutputFiles

submit

getJobResult

getJobState

getStatus

getJobState

getState

getState

addEventListener

addEventListener

removeEventListener

getTaskResult

getTaskResult

getTaskResultFromIncarnation

removeJob

listenJobLogs