oracle.adf.share.sandbox

Class SandboxSupport

java.lang.Object

oracle.adf.share.sandbox.SandboxSupport

Direct Known Subclasses:

DefaultSandboxSupport

public abstract class SandboxSupport
extends java.lang.Object

A class that defines sandbox-related operations.

Constructor Summary

Constructors

Constructor and Description
SandboxSupport()

Method Summary

Modifier and Type	Method and Description
boolean	addAdministrator(Sandbox sandbox, java.lang.String userName) Adds a user to the list of administrators of a sandbox.
abstract void	addRepository(Sandbox sandbox, SandboxedRepository repos) Adds a repository in its latest certified state to a sandbox.
boolean	canSynchronizedPublish(Sandbox sandbox) Returns true if all locks needed for synchronizedPublish are available at the time of the invocation.
abstract void	destroy(Sandbox sandbox) Destroys a sandbox and deletes all information pertaining to the sandbox.
void	destroy(Sandbox sandbox, boolean retainInfo) Destroys a sandbox and optionally retains the sandbox information such as operation logs.
abstract boolean	enableFeature(Sandbox sandbox, java.lang.String featureId) Enables a feature in the sandbox.
java.util.Map<java.lang.String,java.lang.Throwable>	enableFeatures(Sandbox sandbox, java.util.List<java.lang.String> featureIdList) Enables a list of features.
abstract java.util.List<SandboxedFeature>	getEnabledFeatures(Sandbox sandbox) Returns the list of features enabled in a sandbox.
static SandboxSupport	getInstance() Returns the system default implementation of this class.
abstract java.util.List<SandboxedRepository>	getRepositories(Sandbox sandbox) Returns the list of repositories that have been branched for a sandbox.
RepositoryErrorLog	getRepositoryErrorLog(Sandbox sandbox, java.lang.String reposId) Returns the error log from the last repository operation if any.
java.util.List<RepositoryErrorLog>	getRepositoryErrorLogs(Sandbox sandbox) Returns the list of non-null error logs from the repository branches of a sandbox.
ChangeSet	getRepositoryLastChanges(Sandbox sandbox, java.lang.String reposId) Returns the changes obtained last time from a repository branch.
abstract Sandbox	getSandbox(java.lang.String id) Returns the information of an existing sandbox.
abstract SandboxArchive	getSandboxArchive(Sandbox sandbox) Returns the SandboxArchive object if the given sandbox is from an archive.
abstract SandboxLog	getSandboxOperationLog(Sandbox sandbox) Returns the log from the last sandbox operation.
abstract java.lang.Long	getSandboxOperationLogId(java.lang.String sandboxId, SandboxState.Condition condition) Returns the ID of an open log for a sandbox.
int	getSandboxOperationProgress(Sandbox sandbox) Returns an integer from 0 (inclusive) to 100 (inclusive) to indicate the progress of the current sandbox operation.
int	getSandboxOperationProgress(Sandbox sandbox, java.lang.String featureId) Returns an integer from 0 (inclusive) to 100 (inclusive) to indicate the progress of the current sandbox operation by feature.
boolean	isCompatible(SandboxedFeature feature, SandboxConstraints constraints) Returns true if the feature can be enabled in a sandbox with the specified constraints.
boolean	isLockedBySandboxArchive() Returns true if the mainline of any repository is locked by a sandbox archive at the time of invcation.
java.util.List<java.lang.String>	listAdministrators(Sandbox sandbox) Returns the list of administrators of a sandbox.
java.util.List<java.lang.String>	listOpenSandboxes() Returns the IDs of the sandboxes that are open at the time of invocation, not including the sandboxes created from archives.
abstract java.util.List<java.lang.String>	listOpenSandboxes(boolean includeArchives) Returns the IDs of the sandboxes that are open at the time of invocation.
Sandbox	listSandbox(java.lang.String name) Returns the most recently created sandbox whose name matches the specified name exactly.
abstract java.util.List<java.lang.String>	listSandboxes(java.lang.String name, boolean exactMatch) Returns the IDs of the sandboxes whose names contain or match the specified name.
protected void	logEvent(Sandbox sandbox, RepositoryEvent e) Logs a repository event.
abstract Sandbox	newSandbox(SandboxArchive archive) Creates a new sandbox from an archive as its initial contents.
abstract Sandbox	newSandbox(java.lang.String name) Creates a new sandbox.
abstract void	notifyRefreshRequired(java.lang.String reposId) Notifies sandboxes that contain a branch of a specific repository that they must be refreshed before any further sandboxed changes are made.
abstract java.util.Map<SandboxedRepository,ChangeSet>	publish(Sandbox sandbox) Merges changes in a sandbox back into the repositories.
abstract java.util.Map<SandboxedRepository,ChangeSet>	refresh(Sandbox sandbox) Merges changes made in participating repositories into a sandbox.
boolean	removeAdministrator(Sandbox sandbox, java.lang.String userName) Removes a user from the list of administrators of a sandbox.
boolean	removeProcessLock(Sandbox sandbox, int minElapsedHours) Forcefully removes the synchronization lock placed by a Java process performing a sandbox operation.
abstract void	setDescription(Sandbox sandbox, java.lang.String desc) Updates the description of a sandbox.
abstract void	setName(Sandbox sandbox, java.lang.String name) Updates the name of a sandbox.
abstract void	setPrivate(Sandbox sandbox, boolean p) Marks a sandbox private or not.
abstract void	setPublishable(Sandbox sandbox, boolean p) Marks a sandbox publishable or not.
void	setSandboxConstraints(Sandbox sandbox, SandboxConstraints constraints) Sets constraints for a sandbox.
void	setSandboxOperationChangeHint(Sandbox sandbox, ChangeHint changeHint) Gives a change hint to all repositories involved in the current operation.
java.util.Map<SandboxedRepository,ChangeSet>	synchronizedPublish(Sandbox sandbox, boolean refreshBefore) Publishes a sandbox only when all mainline exclusive locks of the branched repositories are available; in other words, a ConcurrentSandboxOperationException is thrown when another synchronizedPublish call is in progress, or when a mainline exclusive lock of any branched repository has been acquired by an archive.
boolean	tryLock(SandboxArchive archive) Tries to acquire the lock for processing a sandbox archive.
void	unlock(SandboxArchive archive) Releases the lock acquired for processing a sandbox archive.
void	unpublish(Sandbox sandbox) Unpublishes a sandbox if it's eligible.
IneligibleForUnpublishException	unpublishCheck(Sandbox sandbox) Checks if a sandbox is eligible for unpublish at this moment.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SandboxSupport

public SandboxSupport()

Method Detail

getInstance

public static SandboxSupport getInstance()

Returns the system default implementation of this class.

Returns:

the system default implementation of this class

newSandbox

public abstract Sandbox newSandbox(java.lang.String name)
                            throws SandboxException

Creates a new sandbox.

Parameters:

name - the name of the sandbox

Returns:

the new sandbox

Throws:

java.lang.IllegalArgumentException - if the name already exists

SandboxException - if an error occurs while creating a sandbox

newSandbox

public abstract Sandbox newSandbox(SandboxArchive archive)
                            throws SandboxException

Creates a new sandbox from an archive as its initial contents.

Parameters:

archive - the archive that contains the initial contents

Returns:

the new sandbox

Throws:

java.lang.IllegalArgumentException - if the name already exists

SandboxException - if an error occurs while creating a sandbox

getSandboxArchive

public abstract SandboxArchive getSandboxArchive(Sandbox sandbox)

Returns the SandboxArchive object if the given sandbox is from an archive.

Parameters:

sandbox - the sandbox the SandboxArchive object is associated with

Returns:

the SandboxArchive object if the given sandbox is from an archive; null otherwise

setName

public abstract void setName(Sandbox sandbox,
                             java.lang.String name)

Updates the name of a sandbox.

Parameters:

sandbox - the sandbox to update

name - the new name

Throws:

java.lang.IllegalArgumentException - if the given name is null

setDescription

public abstract void setDescription(Sandbox sandbox,
                                    java.lang.String desc)

Updates the description of a sandbox.

Parameters:

sandbox - the sandbox

desc - the description

setPrivate

public abstract void setPrivate(Sandbox sandbox,
                                boolean p)

Marks a sandbox private or not. A private sandbox is a sandbox that can only be accessed by its owner.

Parameters:

sandbox - the sandbox to be set private or shared

p - true if the given sandbox is to be set to private

setPublishable

public abstract void setPublishable(Sandbox sandbox,
                                    boolean p)

Marks a sandbox publishable or not. A publishable sandbox is a sandbox that can be published.

Parameters:

sandbox - the sandbox to be set publishable or not

p - true if the given sandbox is to be set to publishable

listSandboxes

public abstract java.util.List<java.lang.String> listSandboxes(java.lang.String name,
                                                               boolean exactMatch)

Returns the IDs of the sandboxes whose names contain or match the specified name. The list is sorted by the creation dates of the sandboxes from the newest to the oldest.

Parameters:

name - the name of the sandbox

exactMatch - true if the names of the returned sandboxes must match the specified name exactly

Returns:

the IDs of the sandboxes whose names match or contain the specified name in descending order of their creation dates

Throws:

java.lang.IllegalArgumentException - if the given name is null

listOpenSandboxes

public abstract java.util.List<java.lang.String> listOpenSandboxes(boolean includeArchives)

Returns the IDs of the sandboxes that are open at the time of invocation. An open sandbox is a sandbox that allows more operations than destroy to be performed on it. In other words, a sandbox that is not open can only be destroyed.

Parameters:

includeArchives - true if the returned list should include the sandboxes that are created from archives

Returns:

the IDs of the open sandboxes at the time of invocation; an empty list if no sandboxes are open

listOpenSandboxes

public java.util.List<java.lang.String> listOpenSandboxes()

Returns the IDs of the sandboxes that are open at the time of invocation, not including the sandboxes created from archives.

Returns:

the IDs of the sandboxes that are open at the time of invocation, not including the sandboxes created from archives

listSandbox

public Sandbox listSandbox(java.lang.String name)

Returns the most recently created sandbox whose name matches the specified name exactly.

Parameters:

name - the name of the sandbox

Returns:

the most recently created sandbox whose name matches the specified name exactly

Throws:

java.lang.IllegalArgumentException - if the given name is null

getSandbox

public abstract Sandbox getSandbox(java.lang.String id)

Returns the information of an existing sandbox.

Parameters:

id - the ID of the sandbox

Returns:

the sandbox information; null if there is no such sandbox

getSandboxOperationLog

public abstract SandboxLog getSandboxOperationLog(Sandbox sandbox)

Returns the log from the last sandbox operation.

Parameters:

sandbox - the sandbox where the operation was performed

Returns:

the log from the last sandbox operation; null if not available

getSandboxOperationLogId

public abstract java.lang.Long getSandboxOperationLogId(java.lang.String sandboxId,
                                                        SandboxState.Condition condition)

Returns the ID of an open log for a sandbox. In certain conditions such as sandbox refreshing, a log is created for processes involved to record the changes.

Parameters:

sandboxId - the ID of the sandbox for which the log is created

condition - the condition when the log is available

Returns:

the ID of the open log for the specified sandbox in the specified condition; null if no log is available for the given sandbox in the given condition

getSandboxOperationProgress

public int getSandboxOperationProgress(Sandbox sandbox)

Returns an integer from 0 (inclusive) to 100 (inclusive) to indicate the progress of the current sandbox operation.

Parameters:

sandbox - the sandbox on which the operation is in progress

Returns:

an integer from 0 (inclusive) to 100 (inclusive) where 100 means completion of the operation; -1 if there is no operation in progress or if progress reporting is not supported

getSandboxOperationProgress

public int getSandboxOperationProgress(Sandbox sandbox,
                                       java.lang.String featureId)

Returns an integer from 0 (inclusive) to 100 (inclusive) to indicate the progress of the current sandbox operation by feature. To improve performance, this method may not check if the specified feature is enabled in the sandbox or not. The returned value is undefined if the specified feature is not enabled in the specified sandbox.

Parameters:

sandbox - the sandbox on which the operation is in progress

featureId - the ID of the enabled feature

Returns:

an integer from 0 (inclusive) to 100 (inclusive) where 100 means completion of the operation; -1 if there is no operation in progress, the specified feature is not enabled, or if progress reporting is not supported

Throws:

java.lang.IllegalArgumentException - if the given feature is not defined

setSandboxConstraints

public void setSandboxConstraints(Sandbox sandbox,
                                  SandboxConstraints constraints)

Sets constraints for a sandbox.

Parameters:

sandbox - the sandbox with which the constraints are to be associated

constraints - the constraints for the sandbox

Throws:

java.lang.UnsupportedOperationException - if this method is not supported

setSandboxOperationChangeHint

public void setSandboxOperationChangeHint(Sandbox sandbox,
                                          ChangeHint changeHint)

Gives a change hint to all repositories involved in the current operation.

Parameters:

sandbox - the sandbox on which the current operation is in progress

changeHint - the change hint; null if the default hint should be given

Throws:

java.lang.UnsupportedOperationException - if this method is not supported

See Also:

SandboxTransaction

removeProcessLock

public boolean removeProcessLock(Sandbox sandbox,
                                 int minElapsedHours)

Forcefully removes the synchronization lock placed by a Java process performing a sandbox operation.

Normally a lock is placed on a sandbox before a process starts handling an operation and is removed after the process ends, so that a sandbox is handled by one process at a time. For example, when a process is refreshing a sandbox, a lock will prevent other processes from enabling new features in the same sandbox.

Occassionally a lock may not be removed due to unexpected situations such as the Java process that performs the operation is terminated prematurely. In such cases the lock must be removed explicitly. To avoid removing a lock while an operation is actually in progress, a minimum elapsed time may be specified, so that a lock is removed only if the duration between its placement and now is greater than the specified elapsed time.

Parameters:

sandbox - the sandbox where the lock is placed

minElapsedHours - the minimum elapsed time in hours

Returns:

true if the lock has been removed; false a lock is in place but cannot be removed because the elapsed time is shorter than or the same as the specified minimum

Throws:

java.lang.IllegalArgumentException - if the given elapsed time is invalid. Implementation of this method may put a lower bound on minElapsedHours. Usually the minimum elapsed time cannot be shorter than one hour.

java.lang.UnsupportedOperationException - If this method is not supported

enableFeature

public abstract boolean enableFeature(Sandbox sandbox,
                                      java.lang.String featureId)
                               throws IncompatibleFeatureException,
                                      SandboxException

Enables a feature in the sandbox.

Parameters:

sandbox - the sandbox

featureId - the ID of the sandboxed feature

Returns:

false if the feature was already enabled prior to this call

Throws:

java.lang.IllegalArgumentException - if the specified feature is unavailable

IncompatibleFeatureException - if the feature is incompatible with the sandbox

SandboxException - if an error occurs while enabling the feature

enableFeatures

public java.util.Map<java.lang.String,java.lang.Throwable> enableFeatures(Sandbox sandbox,
                                                                          java.util.List<java.lang.String> featureIdList)
                                                                   throws IncompatibleFeatureException,
                                                                          SandboxException

Enables a list of features. Subclasses may override this method to support concurrent processing to improve performance.

Parameters:

sandbox - the sandbox where the features are to be enabled

featureIdList - the IDs of the features to be enabled

Returns:

errors occurred during the process if any. The keys of the map are the feature IDs while the values are the errors. The caller must examine the returned map for any failures. Any empty map indicates all features are successfully enabled.

Throws:

java.lang.UnsupportedOperationException - if enabling multiple features at a time is not supported

IncompatibleFeatureException

SandboxException

isCompatible

public boolean isCompatible(SandboxedFeature feature,
                            SandboxConstraints constraints)

Returns true if the feature can be enabled in a sandbox with the specified constraints. This method may be invoked before a sandbox is created, after the constraints are known.

Parameters:

feature - the sandbox feature to be enabled

constraints - the conditions a sandbox must satisfy to enable the feature; null to indicate no constraints

Returns:

true if the feature can be enabled in a sandbox with the given constraints

addRepository

public abstract void addRepository(Sandbox sandbox,
                                   SandboxedRepository repos)
                            throws SandboxException

Adds a repository in its latest certified state to a sandbox.

Parameters:

sandbox - the sandbox

repos - the participating repository

Throws:

SandboxException - if an error occurs while adding the repository

getRepositories

public abstract java.util.List<SandboxedRepository> getRepositories(Sandbox sandbox)

Returns the list of repositories that have been branched for a sandbox.

Parameters:

sandbox - the sandbox

Returns:

the list of all branched repositories in the sandbox

getEnabledFeatures

public abstract java.util.List<SandboxedFeature> getEnabledFeatures(Sandbox sandbox)

Returns the list of features enabled in a sandbox.

Parameters:

sandbox - the sandbox

Returns:

the list of all featured enabled in the sandbox

getRepositoryLastChanges

public ChangeSet getRepositoryLastChanges(Sandbox sandbox,
                                          java.lang.String reposId)

Returns the changes obtained last time from a repository branch.

Parameters:

sandbox - the sandbox that contains the repository branch

Returns:

the changes obtained last time from a repository branch; null if such information is unavailable

getRepositoryErrorLog

public RepositoryErrorLog getRepositoryErrorLog(Sandbox sandbox,
                                                java.lang.String reposId)

Returns the error log from the last repository operation if any.

Parameters:

sandbox - the sandbox where the repository is branched

reposId - the ID of the repository

Returns:

the error log from the last repository operation; null if there is no error, or the error log is not available

getRepositoryErrorLogs

public java.util.List<RepositoryErrorLog> getRepositoryErrorLogs(Sandbox sandbox)

Returns the list of non-null error logs from the repository branches of a sandbox.

Parameters:

sandbox - the sandbox where the repositories are branched

Returns:

the list of non-null error logs from the repository branches of the sandbox; an empty list of none of the branches have errors

logEvent

protected void logEvent(Sandbox sandbox,
                        RepositoryEvent e)

Logs a repository event.

Parameters:

sandbox - the sandbox

e - the repository event

refresh

public abstract java.util.Map<SandboxedRepository,ChangeSet> refresh(Sandbox sandbox)
                                                              throws SuspendedSandboxOperationException,
                                                                     RepositoryExceptions

Merges changes made in participating repositories into a sandbox. If there is any merge conflict, all merged changes are undone. If the changes to the sandbox cannot be undone, the sandbox will be set to state SandboxState.INACTIVE.

Parameters:

sandbox - the sandbox

Returns:

the changes that have been merged; an empty map if the sandbox does contain any repositories

Throws:

RepositoryExceptions - if merge conflicts are detected or any error occurs during the process

SuspendedSandboxOperationException

notifyRefreshRequired

public abstract void notifyRefreshRequired(java.lang.String reposId)

Notifies sandboxes that contain a branch of a specific repository that they must be refreshed before any further sandboxed changes are made.

Parameters:

reposId - the ID of the repository

See Also:

Sandbox.isRefreshRequired(), refresh(oracle.adf.share.sandbox.Sandbox)

publish

public abstract java.util.Map<SandboxedRepository,ChangeSet> publish(Sandbox sandbox)
                                                              throws RepositoryExceptions

Merges changes in a sandbox back into the repositories. If there is any merge conflict, all merged changes are undone. If the changes to a repository cannot be undone, the repository will be set to state SandboxState.INACTIVE.

Parameters:

sandbox - the sandbox

Returns:

the changes that have been committed; an empty map if the sandbox does contain any repositories

Throws:

RepositoryExceptions - if merge conflicts are detected or any error occurs during the process

destroy

public abstract void destroy(Sandbox sandbox)
                      throws RepositoryExceptions

Destroys a sandbox and deletes all information pertaining to the sandbox.

Parameters:

sandbox - the sandbox to be destroyed

Throws:

RepositoryExceptions - if there is any error coming from the repositories

unpublishCheck

public IneligibleForUnpublishException unpublishCheck(Sandbox sandbox)

Checks if a sandbox is eligible for unpublish at this moment. Note that being eligible now does not guarantee the sandbox is still eligible for unpublish when unpublish is called.

Parameters:

sandbox - the sandbox to be checked

Returns:

null if the given sandbox is eligible for unpublish; otherwise an object is returned to indicate the reason

Throws:

java.lang.IllegalArgumentException - if the given sandbox is nlul

java.lang.UnsupportedOperationException - if this operation is not supported

See Also:

unpublish(oracle.adf.share.sandbox.Sandbox)

unpublish

public void unpublish(Sandbox sandbox)
               throws IneligibleForUnpublishException

Unpublishes a sandbox if it's eligible.

Parameters:

sandbox - the sandbox to be unpublished

Throws:

IneligibleForUnpublishException - if the given sandbox is ineligible for unpublish

java.lang.IllegalArgumentException - if the given sandbox is null

java.lang.UnsupportedOperationException - if this operation is not supported

See Also:

unpublishCheck(oracle.adf.share.sandbox.Sandbox)

destroy

public void destroy(Sandbox sandbox,
                    boolean retainInfo)
             throws RepositoryExceptions

Destroys a sandbox and optionally retains the sandbox information such as operation logs. If the sandbox information is retained, the state will be set to SandboxState.IRRECOVERABLE.

Parameters:

sandbox - the sandbox to be destroyed

retainInfo - true if the sandbox information should be retained

Throws:

java.lang.UnsupportedOperationException - if this method is not supported

RepositoryExceptions

See Also:

destroy(Sandbox)

tryLock

public boolean tryLock(SandboxArchive archive)

Tries to acquire the lock for processing a sandbox archive. It is assumed that at most one sandbox archive can be processed at any given time. That means the lock is considered already acquired when this method is called again before unlock(SandboxArchive). The behavior of calling this method again with a different SandboxArchive object before releasing the lock for the first call is undefined.

Parameters:

archive - the sandbox archive to be processed

Returns:

true if the lock is acquired successfully; false if the involved repositories are currently locked by other sandboxes

Throws:

java.lang.IllegalArgumentException - if the given sandbox archive is null

java.lang.UnsupportedOperationException - if this method is not supported

See Also:

unlock(oracle.adf.share.sandbox.SandboxArchive)

unlock

public void unlock(SandboxArchive archive)

Releases the lock acquired for processing a sandbox archive. It is assumed that at most one sandbox archive can be processed at any given time. This method releases the lock without consulting the given SandboxArchive object.

Parameters:

archive - the sandbox archive that was just processed; or null if the information of the archive is no longer available

Throws:

java.lang.UnsupportedOperationException - if this method is not supported

See Also:

tryLock(oracle.adf.share.sandbox.SandboxArchive)

isLockedBySandboxArchive

public boolean isLockedBySandboxArchive()

Returns true if the mainline of any repository is locked by a sandbox archive at the time of invcation. When the processing of a sandbox archive is in progress, ConcurrentSandboxOperationException may be thrown by methods that require the same locks already acquired by the archive, such as enableFeature or synchronizedPublish. The client may simply skip all operations and wait until this method returns false again.

Returns:

true if the mainline of any repository is locked by a sandbox archive at the time of invocation

See Also:

tryLock(oracle.adf.share.sandbox.SandboxArchive), unlock(oracle.adf.share.sandbox.SandboxArchive)

synchronizedPublish

public java.util.Map<SandboxedRepository,ChangeSet> synchronizedPublish(Sandbox sandbox,
                                                                        boolean refreshBefore)
                                                                 throws RepositoryExceptions,
                                                                        ConcurrentSandboxOperationException

Publishes a sandbox only when all mainline exclusive locks of the branched repositories are available; in other words, a ConcurrentSandboxOperationException is thrown when another synchronizedPublish call is in progress, or when a mainline exclusive lock of any branched repository has been acquired by an archive.

Parameters:

sandbox - the sandbox to be published

refreshBefore - true if refresh should be called first after acquiring the necessary locks. If a repository is pending resume after the first pass, the process will be resumed once with change hint ChangeHint.STOP_AT_CONFLICTS. If any repository is still pending resume after the second pass, a SsuspendedSandboxOperation is thrown.

Returns:

the changes just published

Throws:

RepositoryExceptions - if any error occurs during the publish

ConcurrentSandboxOperationException - if refreshBefore is true and any repository is still pending resume after the first resume

canSynchronizedPublish

public boolean canSynchronizedPublish(Sandbox sandbox)

Returns true if all locks needed for synchronizedPublish are available at the time of the invocation. This information serves as a hint only. A ConcurrentSandboxOperationException may still be thrown when synchronizedPublish is invoked because the locks may be acquired by another sandbox between the invocation of this method and that of synchronizedPublish. If a client must block on synchronizedPublish, skip this check and call synchronizedPublish periodically until ConcurrentSandboxOperationException is not thrown.

Parameters:

sandbox - the sandbox to be published

Returns:

true if all locks needed for synchronizedPublish are available at the time of the invocation

addAdministrator

public boolean addAdministrator(Sandbox sandbox,
                                java.lang.String userName)

Adds a user to the list of administrators of a sandbox.

Parameters:

sandbox - the sandbox administered

userName - the user to be added as an administrator

Returns:

true if the user is not an administrator prior to this call; false if the user was not added to the list because he is already an administrator of the sandbox

Throws:

java.lang.IllegalArgumentException - if the sandbox or user name is null

removeAdministrator

public boolean removeAdministrator(Sandbox sandbox,
                                   java.lang.String userName)

Removes a user from the list of administrators of a sandbox.

Parameters:

sandbox - the sandbox administered by the user

userName - the user to be removed from the list of administrators

Returns:

true if the user is an administrator prior to this call and is successfully removed from the list; false if the user is not on the list or cannot be removed because he is the owner of the sandbox

Throws:

java.lang.IllegalArgumentException - if the sandbox or user name is null

listAdministrators

public java.util.List<java.lang.String> listAdministrators(Sandbox sandbox)

Returns the list of administrators of a sandbox.

Parameters:

sandbox - the sandbox

Returns:

names of the sandbox administrator

Throws:

java.lang.IllegalArgumentException - if the sandbox is null