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.
MetadataRevision	certifyRepositoryMainline(java.util.Set<java.lang.String> reposIdSet, java.lang.String revisionNote) Certifies the state of the mainlines of the specified repositories at the time of invocation.
MetadataRevision	certifyRepositoryMainline(java.lang.String reposId, java.lang.String revisionNote) Certifies the state of the mainline of a specified repository.
void	checkNewSandboxName(java.lang.String name) Checks if a String can be used to name a new sandbox.
boolean	completeSandboxPendingUpdates(Sandbox sandbox) Completes all pending updates.
void	completeSandboxPendingUpdates(java.lang.String sandboxId, SandboxBackgroundTask.Proxy<java.lang.Boolean> proxy) Completes all pending updates in a background thread.
boolean	containsRepositoryErrorLogs(Sandbox sandbox) Returns true if an error occurred to any repository during the last sandbox operation.
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.
void	destroy(java.lang.String sandboxId, boolean retainInfo, SandboxBackgroundTask.Proxy<java.lang.Object> proxy) Destroys a sandbox in a background thread.
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.
void	enableFeatures(java.lang.String sandboxId, java.util.List<java.lang.String> featureIdList, SandboxBackgroundTask.Proxy<java.util.Map<java.lang.String,java.lang.Throwable>> proxy) Enables a list of features in a background thread.
Sandbox	findSandbox(java.lang.String nameOrId) Finds a sandbox by its name or ID.
java.util.List<java.lang.String>	getEnabledFeatureIdList(Sandbox sandbox) Gets the IDs of the features enabled in a sandbox.
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.
int	getNumberOfOpenSandboxes() Returns the number of sandboxes that are currently open, excluding the sandboxes created from archives.
int	getNumberOfOpenSandboxes(boolean includeArchives) Returns the number of sandboxes that are currently open.
abstract java.util.List<SandboxedRepository>	getRepositories(Sandbox sandbox) Returns the list of repositories that have been branched for a sandbox.
java.util.Map<java.lang.String,ChangeHint>	getRepositoryChangeHints(Sandbox sandbox) Returns the hints taken by the current operation.
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.
java.util.List<java.lang.String>	getRepositoryIdList(Sandbox sandbox) Returns the IDs of the repositories that have been branched for 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.
SandboxInfoCache	getSandboxInfoCache(java.lang.String id) Returns the information of an existing sandbox and caches some of the information upon the first access.
java.util.Map<java.lang.String,SandboxUpdateErrorInfo>	getSandboxLastUpdateErrors(Sandbox sandbox) Gets the errors from the last failed update.
java.lang.String	getSandboxNameOrId(java.lang.String sandboxId) Returns the name or a URI representation of the ID of a sandbox if the sandbox exists.
abstract SandboxLog	getSandboxOperationLog(Sandbox sandbox) Returns the log from the current or 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.
java.util.List<SandboxUpdate>	getSandboxPendingUpdates(Sandbox sandbox) Gets the list of pending updates if any.
java.util.Date	getSandboxPendingUpdatesDueDate(Sandbox sandbox) Returns the nearest due date of the pending updates.
boolean	hasUncommittedChanges(Sandbox sandbox) Returns true if the sandbox is open and any of the repository branches in the sandbox has uncommitted changes.
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.
boolean	isSandboxOperationProcessRunning(Sandbox sandbox) Returns true if a process that performs an operation of the sandbox is running at the time of the invocation.
boolean	isSandboxPendingUpdates(Sandbox sandbox) Returns true if there is any pending update for this sandbox.
boolean	isVisualBuilder(SandboxedFeature feature) Returns true if the given sandboxed feature is Visual Builder.
boolean	isVisualBuilder(java.lang.String featureId) Returns true if the given sandboxed feature is Visual Builder.
boolean	isVisualBuilderEnabled(java.lang.String sandboxId) Deprecated. Use Sandbox.isVisualBuilderEnabled instead.
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.
java.util.List<SandboxLogRef>	listSandboxLogs(Sandbox sandbox, java.lang.Class<? extends SandboxLog> type) Returns a list of sandbox logs from the latest to the oldest.
protected void	logEvent(Sandbox sandbox, RepositoryEvent e) Logs a repository event.
void	markSandboxesForUpdate(SandboxUpdatePatchInfo patchInfo) Marks all open sandboxes for update.
void	markSandboxForUpdate(SandboxUpdatePatchInfo patchInfo, Sandbox sandbox) Marks a sandbox for update.
java.util.Set<java.lang.String>	newRepositoryBaselines(java.lang.String note) Requests that all available repositories in the system establish new baselines for the current state of the repositories.
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.
void	newSandbox(java.lang.String name, SandboxBackgroundTask.Proxy<Sandbox> proxy) Creates a new sandbox in a background thread.
RepositoryExceptions	prepareForRefresh(Sandbox sandbox) Explicitly invokes SandboxedRepository.prepareForRefresh to start the refresh process.
abstract java.util.Map<SandboxedRepository,ChangeSet>	publish(Sandbox sandbox) Merges changes in a sandbox back into the repositories.
void	publish(java.lang.String sandboxId, SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy) Publishes a sandbox in a background thread.
abstract java.util.Map<SandboxedRepository,ChangeSet>	refresh(Sandbox sandbox) Merges changes made in participating repositories into a sandbox.
java.util.Map<SandboxedRepository,ChangeSet>	refresh(Sandbox sandbox, ChangeHint.Provider hintProvider) Merges changes made in participating repositories into a sandbox.
void	refresh(java.lang.String sandboxId, ChangeHint.Provider hintProvider, SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy) Refreshes a sandbox in a background thread.
void	refresh(java.lang.String sandboxId, SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy) Refreshes a sandbox in a background thread.
boolean	removeAdministrator(Sandbox sandbox, java.lang.String userName) Removes a user from the list of administrators of a sandbox.
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	setSandboxConstraintsSummary(Sandbox sandbox, java.lang.String constraintsSummary) Sets the summary of constraints for a sandbox.
void	setSandboxOperationChangeHint(Sandbox sandbox, ChangeHint changeHint) Deprecated. Use ChangeHint.Provider on operations that support it. This method itself cannot be synchronized with the operations that need the hints.
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.
void	synchronizedPublish(java.lang.String sandboxId, SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy) Publishes a sandbox in a background thread when all mainline exclusive locks of the branched repositories are available This method does not wait for the operation to complete.
void	timeoutSandboxOperationProcesses() Marks sandboxes that are being processed for a duration that is longer than the default time allowed.
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:

SandboxNameTakenException - if the name is already taken

SandboxNameTooLongException - if the name is too long to be a sandbox name

IllegalCharSequenceException - if the name contains illegal character sequences

IllegalSandboxNameException - if the name is null or illegal accoridng to a rule that has not been documented. Note that IllegalSandboxNameException is the super class of all other exceptions thrown indiciating a name cannot be used for the new sandbox

TooManyOpenSandboxesException - if the system imposes a maximum number of open sandboxes and the number has been reached

SandboxException - if an error occurs while creating a sandbox

checkNewSandboxName

public void checkNewSandboxName(java.lang.String name)

Checks if a String can be used to name a new sandbox.

Parameters:

name - the name to be checked

Throws:

SandboxNameTakenException - if the name is already taken

SandboxNameTooLongException - if the name is too long to be a sandbox name

IllegalCharSequenceException - if the name contains illegal character sequences

IllegalSandboxNameException - if the name is null or illeal accoridng to a rule that has not been documented. Note that IllegalSandboxNameException is the super class of all other exceptions thrown indiciating a name cannot be used for the new sandbox

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

See Also:

newSandbox(String)

newSandbox

public void newSandbox(java.lang.String name,
                       SandboxBackgroundTask.Proxy<Sandbox> proxy)

Creates a new sandbox in a background thread. This method does not wait for the operation to complete.

Parameters:

name - the name of the sandbox

proxy - the proxy object that handles the background task

Throws:

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

newSandbox

public abstract Sandbox newSandbox(SandboxArchive archive)
                            throws SandboxException

Creates a new sandbox from an archive as its initial contents. The name of the sandbox will be the name of the archive.

Parameters:

archive - the archive that contains the initial contents

Returns:

the new sandbox

Throws:

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

getNumberOfOpenSandboxes

public int getNumberOfOpenSandboxes(boolean includeArchives)

Returns the number of sandboxes that are currently open.

Parameters:

includeArchives - true if the sandboxes created from archives should be included if open

Returns:

the number of sandboxes that are currently open

Throws:

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

getNumberOfOpenSandboxes

public int getNumberOfOpenSandboxes()

Returns the number of sandboxes that are currently open, excluding the sandboxes created from archives.

Returns:

the number of sandboxes that are currently open, excluding the sandboxes created from archives

Throws:

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

findSandbox

public Sandbox findSandbox(java.lang.String nameOrId)

Finds a sandbox by its name or ID. The search starts by matching the argument to the name of a sandbox; if no match, the search continues by treating the argument as the ID of the sandbox to be found. If multiple sandboxes have the same name that matches the argument, the most recently created sandbox is returned.

Parameters:

nameOrId - the name or ID

Returns:

the sandbox whose name or ID matches the argument; null if no match

See Also:

getSandboxNameOrId(java.lang.String)

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

getSandboxNameOrId

public java.lang.String getSandboxNameOrId(java.lang.String sandboxId)

Returns the name or a URI representation of the ID of a sandbox if the sandbox exists. This is a convenience method that checks the existence of a sandbox and return its name when the sandbox exists. When the sandbox exists, the returned value is never null. If the sandbox exists but the name of the sandbox is null, the URI representation of the sandbox ID as specified by MetadataRevisionNoteURI.SandboxId is returned.

Parameters:

sandboxId - the ID of the sandbox to be checked

Returns:

a non-null String if a sandbox exists for the given ID; null if no sandbox can be found for the given ID

See Also:

findSandbox(java.lang.String)

getSandboxInfoCache

public SandboxInfoCache getSandboxInfoCache(java.lang.String id)

Returns the information of an existing sandbox and caches some of the information upon the first access.

Parameters:

id - the ID of the sandbox

Returns:

the sandbox information which is partially cached upon the first access

listSandboxLogs

public java.util.List<SandboxLogRef> listSandboxLogs(Sandbox sandbox,
                                                     java.lang.Class<? extends SandboxLog> type)

Returns a list of sandbox logs from the latest to the oldest.

Parameters:

sandbox - the sandbox associated with the logs

type - the type of the logs; null if all types should be returned

Returns:

a list of logs associated with the given sandbox from the latest to the oldest; an empty list if no log of the given type is associated with the given sandbox

Throws:

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

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

getSandboxOperationLog

public abstract SandboxLog getSandboxOperationLog(Sandbox sandbox)

Returns the log from the current or last sandbox operation. If the operation is still in progress, the returned log reflects what has been logged so far. A log in progress will not be in the list returned by listSandboxLogs. If an operation is successful and a log is produced, this method continues to return the log from the successful operation until the next operation begins. During this time, the returned log is the same as the first log returned by listSandboxLogs.

Parameters:

sandbox - the sandbox where the operation was performed

Returns:

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

See Also:

listSandboxLogs(oracle.adf.share.sandbox.Sandbox, java.lang.Class<? extends oracle.adf.share.sandbox.logging.SandboxLog>)

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

setSandboxConstraintsSummary

public void setSandboxConstraintsSummary(Sandbox sandbox,
                                         java.lang.String constraintsSummary)

Sets the summary of constraints for a sandbox. The summary is for display only.

Parameters:

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

constraintsSummary - the summary of constraints for the sandbox

Throws:

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

setSandboxOperationChangeHint

@Deprecated
public void setSandboxOperationChangeHint(Sandbox sandbox,
                                                      ChangeHint changeHint)

Deprecated. Use ChangeHint.Provider on operations that support it. This method itself cannot be synchronized with the operations that need the hints.

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

getRepositoryChangeHints

public java.util.Map<java.lang.String,ChangeHint> getRepositoryChangeHints(Sandbox sandbox)

Returns the hints taken by the current operation. If no operation is in progress, the hints may be for the last operation. Note that the returned hints may not be the same as the hints taken by the operation if any client has updated the hints using the deprecated setSandboxOperationChangeHint method.

Parameters:

sandbox - the sandbox being operated

Returns:

the hints used by the current operation

Throws:

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

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

enableFeatures

public void enableFeatures(java.lang.String sandboxId,
                           java.util.List<java.lang.String> featureIdList,
                           SandboxBackgroundTask.Proxy<java.util.Map<java.lang.String,java.lang.Throwable>> proxy)

Enables a list of features in a background thread. This method does not wait for the operation to complete.

Parameters:

sandboxId - the ID of the sandbox

featureIdList - the list of the IDs of the features to be enabled

proxy - the proxy object that handles the background task

Throws:

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

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

getRepositoryIdList

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

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

Parameters:

sandbox - the sandbox where the repositories are branched for

Returns:

the IDs of the repositories that have been branched for the sandbox; an empty list if no repository is branched for the sandbox

Throws:

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

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

getEnabledFeatureIdList

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

Gets the IDs of the features enabled in a sandbox.

Parameters:

sandbox - the sandbox where the features are enabled

Returns:

the IDs of the features enabled in the sandbox; an empty list if no feature is enabled

Throws:

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

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

hasUncommittedChanges

public boolean hasUncommittedChanges(Sandbox sandbox)

Returns true if the sandbox is open and any of the repository branches in the sandbox has uncommitted changes.

Parameters:

sandbox - the sandbox to be checked

Returns:

true if the sandbox is open and any of the repository branches in the sandbox has uncommitted changes

Throws:

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

See Also:

SandboxedRepository.hasChanges(oracle.adf.share.sandbox.Sandbox)

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

See Also:

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

containsRepositoryErrorLogs

public boolean containsRepositoryErrorLogs(Sandbox sandbox)

Returns true if an error occurred to any repository during the last sandbox operation.

Parameters:

sandbox - the sandbox where the repositories are branched

Returns:

true if an error occurred to any branched repository during the last sandbox operation

logEvent

protected void logEvent(Sandbox sandbox,
                        RepositoryEvent e)

Logs a repository event.

Parameters:

sandbox - the sandbox

e - the repository event

prepareForRefresh

public RepositoryExceptions prepareForRefresh(Sandbox sandbox)

Explicitly invokes SandboxedRepository.prepareForRefresh to start the refresh process. The purpose of this method is to allow an administrator to put a sandbox in "refresh state" without starting the actual refresh process immediately. It is expected that a call to refresh will follow shortly if not immediately.

It is possible to call refresh without calling this method first; in that case, SandboxedRepository.prepareForRefresh will be invoked implicitly if it has not been called. From a repository's point of view, SandboxedRepository.prepareForRefresh is always executed before SandboxedRepository.refresh in all cases.

If SandboxedRepository.prepareForRefresh fails, the errors are returned; when that happens, invoking any refresh methods of this class will result in the same exception. Note that a call to a refresh method of this class is still required even though it's expected that refresh will fail. Only a refresh method can move the sandbox out of the refresh state.

Parameters:

sandbox - the sandbox that is about to be refreshed

Returns:

exceptions from repositories that fail the operation, or null if all repositories have succeeded

Throws:

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

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:

SuspendedSandboxOperationException - if the refresh process is suspended because more information is needed

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

refresh

public java.util.Map<SandboxedRepository,ChangeSet> refresh(Sandbox sandbox,
                                                            ChangeHint.Provider hintProvider)
                                                     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

hintProvider - the hint provider; null if the hint should come from the deprecated setSandboxOperationChangeHint. To provide null as hint, pass in new ChangeHint.Provider(), not null.

Returns:

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

Throws:

SuspendedSandboxOperationException - if the refresh process is suspended because more information is needed

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

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

refresh

public void refresh(java.lang.String sandboxId,
                    SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy)

Refreshes a sandbox in a background thread. This method does not wait for the operation to complete.

Parameters:

sandboxId - the ID of the sandbox to be refreshed

proxy - the proxy object that handles the background task

Throws:

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

refresh

public void refresh(java.lang.String sandboxId,
                    ChangeHint.Provider hintProvider,
                    SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy)

Refreshes a sandbox in a background thread. This method does not wait for the operation to complete.

Parameters:

sandboxId - the ID of the sandbox to be refreshed

hintProvider - the hint provider; null if the hint should come from the deprecated setSandboxOperationChangeHint. To provide null as hint, pass in new ChangeHint.Provider(), not null.

proxy - the proxy object that handles the background task

Throws:

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

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

publish

public void publish(java.lang.String sandboxId,
                    SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy)

Publishes a sandbox in a background thread. This method does not wait for the operation to complete.

Parameters:

sandboxId - the ID of the sandbox to be published

proxy - the proxy object that handles the background task

Throws:

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

newRepositoryBaselines

public java.util.Set<java.lang.String> newRepositoryBaselines(java.lang.String note)

Requests that all available repositories in the system establish new baselines for the current state of the repositories. New baselines will not be established for those repositories that do not support creation of new certified labels without sandboxes. If any repository fails creating a new certified label, an exception is thrown immediately and no baselines will be established. Note that when an exception is thrown, some repositories may have already created their new certified labels successfully. Those labels will remain in the repositories.

Parameters:

note - a short identifier indicating what the new repository baseline are for

Returns:

the IDs of the repositories whose baselines have been successfully estabalished; an empty set if no repository supports creation of new certified labels without sandboxes

Throws:

java.lang.UnsupportedOperationException - if this operation is unsupported

See Also:

SandboxedRepository.newCertifiedLabel(java.lang.String)

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)

certifyRepositoryMainline

public MetadataRevision certifyRepositoryMainline(java.util.Set<java.lang.String> reposIdSet,
                                                  java.lang.String revisionNote)

Certifies the state of the mainlines of the specified repositories at the time of invocation. A new baseline will be established for each given repository. A new metadata revision will be created and returned. The implementation of this method is similar to the "publish" operation of a sandbox except that no transaction is published by this method. This method is usually invoked immediately after metadata changes are published via external transactions.

Parameters:

reposIdSet - the IDs of the repositories that have changed

revisionNote - a short note that describes the revision. The length of the note must not exceed 100 bytes.

Returns:

the new metadata revision as the result of certification

Throws:

java.lang.IllegalArgumentException - if the set of repository IDs is null or empty, or if any of the repository does not exist, or if the revision note is null, or if the length of the revision note exceeds 100 bytes

java.lang.UnsupportedOperationException - if this method is not supported, or if any of the given repositories does not support baseline certification without the use of a sandbox

ConcurrentOperationException - if the mainline of any given repository is being certified at the time of invocation either via a sandbox, CSM archive or this method

certifyRepositoryMainline

public MetadataRevision certifyRepositoryMainline(java.lang.String reposId,
                                                  java.lang.String revisionNote)

Certifies the state of the mainline of a specified repository. See certifyRepositoryMainline(Set,String) for more details.

Parameters:

reposId - the ID of the repository that has changed

revisionNote - a short note that describes the revision. The length of the note must not exceed 100 bytes.

Returns:

the new metadata revision as the result of certification

Throws:

java.lang.IllegalArgumentException - if the given repository ID is null, or if the given repository does not exist, or if the revision note is null, or if the length of the revision note exceeds 100 bytes

java.lang.UnsupportedOperationException - if this method is not supported, or if the given repository does not support baseline certification without the use of a sandbox

ConcurrentOperationException - if the mainline of the given repository is being certified at the time of invocation either via a sandbox, CSM archive or this method

See Also:

certifyRepositoryMainline(Set,String)

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.DESTROYED.

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)

destroy

public void destroy(java.lang.String sandboxId,
                    boolean retainInfo,
                    SandboxBackgroundTask.Proxy<java.lang.Object> proxy)

Destroys a sandbox in a background thread. This method does not wait for the operation to complete.

Parameters:

sandboxId - the ID of the sandbox to be destroyed

retainInfo - true if the sandbox information should be retained

proxy - the proxy object that handles the background task

Throws:

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

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 SuspendedSandboxOperation 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

synchronizedPublish

public void synchronizedPublish(java.lang.String sandboxId,
                                SandboxBackgroundTask.Proxy<java.util.Map<SandboxedRepository,ChangeSet>> proxy)

Publishes a sandbox in a background thread when all mainline exclusive locks of the branched repositories are available This method does not wait for the operation to complete.

Parameters:

sandboxId - the ID of the sandbox to be published

proxy - the proxy object that handles the background task

Throws:

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

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

markSandboxesForUpdate

public void markSandboxesForUpdate(SandboxUpdatePatchInfo patchInfo)

Marks all open sandboxes for update.

Parameters:

patchInfo - the information of the patch that initiates the update

Throws:

java.lang.IllegalArgumentException - if the patch information is null

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

markSandboxForUpdate

public void markSandboxForUpdate(SandboxUpdatePatchInfo patchInfo,
                                 Sandbox sandbox)

Marks a sandbox for update. If this sandbox is not open, this operation has no effect.

Parameters:

patchInfo - the information of the patch that initiates the update

sandbox - the sandbox to be marked

Throws:

java.lang.IllegalArgumentException - if the patch information or sandbox is null

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

isSandboxPendingUpdates

public boolean isSandboxPendingUpdates(Sandbox sandbox)

Returns true if there is any pending update for this sandbox.

Parameters:

sandbox - the sandbox to be checked

Returns:

true if there is any pending update for this sandbox

Throws:

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

getSandboxPendingUpdatesDueDate

public java.util.Date getSandboxPendingUpdatesDueDate(Sandbox sandbox)

Returns the nearest due date of the pending updates.

Parameters:

sandbox - the sandbox to be checked

Returns:

the nearest due date of the pending updates, null if there is no pending updates. Certain dates before January 1, 1970, 00:00:00 GMT are designated as constants that represent special event points. For example, SandboxUpdate.DUE_NOW indicates that this sandbox must be updated immediately before they can be used again. SandboxUpdate.DUE_NEXT_REFRESH indicates the updates may be deferred until the next time this sandbox is refreshed.

Throws:

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

See Also:

SandboxUpdate

getSandboxPendingUpdates

public java.util.List<SandboxUpdate> getSandboxPendingUpdates(Sandbox sandbox)

Gets the list of pending updates if any.

Parameters:

sandbox - the sandbox to be checked

Returns:

the list of pending updates if any; an empty list if there is no pending updates

Throws:

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

completeSandboxPendingUpdates

public boolean completeSandboxPendingUpdates(Sandbox sandbox)
                                      throws SandboxUpdateException

Completes all pending updates.

Parameters:

sandbox - the sandbox to be updated

Returns:

true if this sandbox has been updated successfully and refresh is required

Throws:

SandboxUpdateException - if an error occurs while updating the sandbox

completeSandboxPendingUpdates

public void completeSandboxPendingUpdates(java.lang.String sandboxId,
                                          SandboxBackgroundTask.Proxy<java.lang.Boolean> proxy)

Completes all pending updates in a background thread.

Parameters:

sandboxId - the ID of the sandbox to be updated

proxy - the proxy object that handles the background task

Throws:

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

getSandboxLastUpdateErrors

public java.util.Map<java.lang.String,SandboxUpdateErrorInfo> getSandboxLastUpdateErrors(Sandbox sandbox)

Gets the errors from the last failed update.

Parameters:

sandbox - the sandbox that was updated

Returns:

the errors from the SandboxUpdateSupport classes from the last failed update. The keys of the map are the full names of the SandboxUpdateSupport classes. An empty map is returned if there is no pending updates, or if the pending updates have not been started, or if the updates were successful.

Throws:

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

isSandboxOperationProcessRunning

public boolean isSandboxOperationProcessRunning(Sandbox sandbox)

Returns true if a process that performs an operation of the sandbox is running at the time of the invocation. If the returned value is true, a ConcurrentSandboxOperationException may be thrown when initiating another sandbox operation. Note that the returned value false does not necessarily mean no operation is going on. Some operation such as "refresh" requires a series of processes to complete. There may be no process running but the operation as a whole is still in progress.

Parameters:

sandbox - the sandbox that may be being processed

Returns:

true if a process that performs an operation of the sandbox is running at the time of invocation

Throws:

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

timeoutSandboxOperationProcesses

public void timeoutSandboxOperationProcesses()

Marks sandboxes that are being processed for a duration that is longer than the default time allowed. Once a sandbox is marked as timed out, the sandbox may be suspended for recovery; or in the simplest implementation, a repository error is logged to indicate that the operation has timed out and the sandbox is placed in a state where the same operation may be attempted again if possible. Note that this method does not and cannot terminate any sandbox operation process. The only thing it does is to mark a sandbox internally when it detects that the elapsed time of a process associated with the sandbox is longer than the default time allowed. Whether the process is still alive or not is unknown.

isVisualBuilderEnabled

@Deprecated
public boolean isVisualBuilderEnabled(java.lang.String sandboxId)

Deprecated. Use Sandbox.isVisualBuilderEnabled instead.

Returns true if Visual Builder feature is enabled in the given sandbox and at least one associated repository used by the feature reports changes.

Parameters:

sandboxId - the ID of the sandbox

Returns:

true if Visual Builder feature is enabled in the given sandbox and at least one associated repository used by the feature reports changes

Throws:

java.lang.IllegalArgumentException - if the sandbox ID is null or invalid

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

See Also:

AssociatedRepository, RepositoryAssociation

isVisualBuilder

public boolean isVisualBuilder(java.lang.String featureId)

Returns true if the given sandboxed feature is Visual Builder.

Parameters:

featureId - the ID of the sandboxed feature to be checked

Returns:

true if the given sandboxed feature is Visual Builder

Throws:

java.lang.IllegalArgumentException - if the given feature ID is null

isVisualBuilder

public boolean isVisualBuilder(SandboxedFeature feature)

Returns true if the given sandboxed feature is Visual Builder.

Parameters:

feature - the sandboxed feature to be checked

Returns:

true if the given sandboxed feature is Visual Builder

Throws:

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