All Classes and Interfaces
Class
Description
Allows command developers to declare what resources are affected by the command and what actions must be authorized
on each to allow the command to execute.
Represents an authorization check: a resource and an action to be authorized on that resource.
Declares multiple class-level
@AccessRequired authorization steps, typically each identifying different
resources and/or different actionsDeclares access control for creating a new child
ConfigBean in a collection on an existing
ConfigBean.Declares multiple authorization checks for creating the same single new
ConfigBean.Declares access control on an existing, non-null
ConfigBean.Utility methods used both from AccessCheck and from CommandSecurityChecker.
An action report is an abstract class allowing any type of server side action like a service execution, a command
execution to report on its execution to the originator of the action.
Contract interface for registering adapters to a port.
This is an admin command interface, command implementations have to be stateless and should also have a
org.jvnet.hk2.component.Scope value of PerLookupUseful services for administrative commands implementation
Most of
AdminCommandContext attributes are used in any phase of command execution (supplemental commands,
replication) but some of them must be different for every instance.Useful services for administrative commands implementation
Events broker for AdminCommands.
Listener for AdminCommand events.
Place relevant for utility methods
The implementation of the admin command lock.
The status of a suspend command attempt.
The AdminCommandLockException is generated when a command can not acquire an AdminCommandLock.
The AdminCommandLockTimeoutException is generated when a command can not acquire an AdminCommandLock within the
allotted time.
Behavior required of all command classes which provide any of their own custom authorization enforcement.
A loader of AMX MBeans.
Interface to an application container.
Useful services for application loading implementation
Provides information about the currently running environment in scenarios that are not defined by the Java enterprise
specifications
Implementations of this interface are providing deployment application metadata
An configured element which has to have application type of name.
This interface is an abstraction for accessing a module archive.
ArchiveHandlers are considered part of container implementation, hence are not available until the
corresponding container is setup.ArchiveHandlers are handling certain archive type.
ArchiveType is an extension over ModuleType defined in jsr88 API.
Admin Command implementations can use this annotation to indicate asynchronous execution of their logic.
Implementation for the @Async command capability.
A specialized CommandException that indicates an authentication failure.
Defines the API for services which provide additional information to be used during authorization.
Third party tool vendors may implement this interface to provide code instrumentation to the application server.
Used by application client container to configure default naming behavior for a client JVM.
A ClusterExecutor is responsible for remotely executing commands.
A marker annotation for annotations that indicate that an AdminCommand functionality is to be extended in a certain
way.
Empty implementation of CommandAspectImpl.
This is an extensible facade class to support options which can be passed from the client to server and uses the
CommandAspects
Interface for defining aspects for AdminCommands.
Annotation used to indicate what type of lock to acquire before executing an admin command.
The type of command lock.
Model for an administrative command
Model for a command parameter.
Interface denoting administrative commands that provide their model.
A marker interface to indicate classes that are used to pass parameters to the parameters method of the
CommandRunner.CommandInvocation API.
Base interface of progress status implementation.
CommandRunner is a service that allows you to run administrative commands.
CommandInvocation defines a command excecution context like the requested name of the command to execute, the
parameters of the command, etc...
Utility class for command framework.
ComponentInvocationHandler handles pre and post activities for a particular type of ComponentInvocation
Composite handlers are just like any other ArchiveHandler except they get a chance at looking at the archive before
the archive handlers do
The main reason for this tag interface is that some archive handlers might be tricked into thinking a composite
archive is theirs when in fact they only own a part of it.
ConfigExtension is an configuration extension that hooks itself under the config configuration.
Contract called on startup right after the configuration has been read (and potentially upgraded) but before the
startup services.
Contract for services which want to perform some upgrade on the application server configuration
This interface can be implemented to provide a custom connection validation mechanism if custom-validation is chosen
as the connection-validation-method.
This interface exists to provide a marker for locating modules which provide GUI features to be displayed in the
GlassFish admin console.
Web container related constants that other modules (e.g., security) depend on.
Tag interface for container related configuration.
Contract identifying a container implementation.
Default monitoring configuration for containers.
The
javax.sql.DataSource implementation of SunONE application server will implement this interface.Identifies a class that implements a default resource.
Parameters passed by the user to a deployment request.
A deployer is capable of deploying one type of applications.
Useful services for Deployer service implementation
Context passed at the time of CreateDomain to modules with some initial config.
Marker interface to mark inhabitants that require some minimal initial configuration to be inserted into a newly
create domain's domain.xml
Exception, which will be thrown on endpoint registration problems.
Code that wish to listen to glassfish events should implement this interface and register
it to the Events contract implementation.
Contract to register/unregister events listener.
Extensible list of event types.
Annotation to qualify when an action like a command is targeted to be run on a cluster or a set of instances.
Any execution type invocation should be passed with an instance of this context.
Defines the expected behaviour from the system when a supplemental command (could be a local or remote invocation)
fails to execute properly.
Service to monitor changes to files.
Implementations of this interface are responsible for servicing a file residing on the local file system to a
Response object.
Some operations may be asynchronous and need to provide their results as a list of future objects
The NamingManager provides an interface for various components to use naming functionality.
Identify an I18n resource associated with the annotated element.
Annotation used to indicate what type of failure action should be performed if the annotated method was to return a
failure error code or throw an exception.
This holds the late status of the instance, the commands that are Queued up while the instance was starting etc.
Providers of class loaders for GlassFish applications can optionally implements this interface to indicate their
class loader is capable of byte code enhancement.
InvocationManager provides interface to keep track of component context on a per-thread basis
A contract that describes a binding in the component namespace
Represents running (or finished) command instance.
This is the contract responsible for creating Job
This class contains information related to a job which will be persisted to jobs.xml
This class contains information of all the jobs which will be persisted to jobs.xml
This is a contract which is used to locate all the jobs.xml files on server startup
This is the contract for the JobManagerService The JobManager will be responsible for 1.
Container for checkpoint related objects
A contract to persist jobs related information to files
Contract for upgrading legacy configuration values to their new location or simply removing them if they are no
longer supported.
This class defines the types of events that get fired by the application server.
LifecycleEventContext interface exposes the server-wide runtime environment that is created by ApplicationServer.
lifecycle modules implement
com.sun.appserv.server.LifecycleListener interface.Class providing helper APIs for logging purposes.
This annotation will be added for commands which need to be managed by Job Manager
Authorized manifest entries to hook up to the module management subsystem.
MetaData associated with a Deployer.
Defines a binding to a model class, used to retrieve metadata about this model.
Tag interface for any non default monitoring configuration
An configured element which is named.
Marks a POJO class, a field, or a method as a named resource.
Goes with
Service annotation on a NamedNamingObjectProxy.A contract that manages naming load-balancing.
A proxy object that can be bound to GlassfishNamingManager.
Special Naming Object proxy whose first create() call replaces itself in naming service.
Implementors of this contract wish to be called when the NamingManager is instanciated so they have an opportunity to
register named objects to the naming manager.
Support class for all types of deployment operation parameters.
There can be cases where the container code wants to find out the command associated with the operation when the
Origin information is not sufficient
There can be so far 6 types of events that can trigger deployment activities.
Param is a parameter to a command.
Interface for defining dynamic command parameter defaults.
A parameter mapper acts as a bridge between supplied parameters (by the user on the command line for instance) and
expected parameters by a action.
Provided mapper that does not change parameters names or values from the input set.
A map from parameter name to a list of parameter values.
Resolves password alias expressions of the form ${ALIAS=aliasName} using an internal password alias store while also
accepting passwords themselves which are not translated.
Represents a fully-functional password alias store.
Interface for admin command payloads--data carried in the http request and response which flow between the admin
client and the server.
Public API for inbound payloads.
Public API for outbound Payloads.
Public API for the payload Part.
The bare minimum info contained in a FlashlightProbe that a value-add module needs The names look weird because they
match pre-existing methods.
This information needs to be shared by more than one module.
Process environment allow access to information related to the execution or process.
Enumeration of the supported process types Server is the application server ACC is the application client Other is a
standalone java.
ProgressStatus of a command.
Interface denoting administrative commands that provide their
Progress annotation.API for providing information about work progress in
AdminCommand implementations.Basic abstract implementation of
ProgressStatus.ProgressStatus is changedProgress method was called.
Progress method was called.
Progress method was called.
Change some value in ProgressStatus using set method.
ProgressStatus implementation suggested for AdminCommand implementation.This implementation is used for modeling of command execution with supplemental commands.
Annotation that holds an array of
PropertyDesc for properties eg Property.Describes properties or system properties that might exist as sub-elements.
Interface for implementing read access to an underlying archive on a unspecified medium
A lot of methods need to be written in order to implement ReadableArchive.
A configured object that can reference another configured object
This class is an alternative to ComponentInvocationHandler.
RequestDispatcher is responsible for dispatching incoming requests.
ResourceHandler provides interface to access resources handled by a component.
annotation to redirect a rest request from CRUD operations on the configuration tree to a command invocation (like
deploy, undeploy).
List of @RestRedirect
Sometimes listeners are not interested in receiving all event types, forcing them in checking the event type before
doing any type of processing.
Defines a server process type.
Represents the ability (and responsibility) of an AdminCommand implementation to provide its own authorization logic,
instead of relying on the command framework and the AccessRequired annotation to do so.
Allow access to the environment under which GlassFish operates.
Exception thrown by application server lifecycle modules and subsystems.
Value object for JNDI names used in GlassFish.
A sniffer implementation is responsible for identifying a particular application type and/or a particular file type.
This interface can be implemented to provide a mechanism to trace the SQL trace record objects.
Information related to SQL operations executed by the applications are stored in this object.
Created by IntelliJ IDEA.
Deprecated.
A startup service may be useful during the lifetime of the application server, while others need to process a task
and stop running at the end of the server startup.
The meta annotation representing the Startup RunLevel.
parameters passed to commands changing the state of a deployed application
Annotation to define a supplemental command
A supplemental command runs when a main command implementation is ran, it can be used to attach behaviours to
existing commands without modifying the original implementation.
enumeration of when a supplemental command can be invoked with regards to the supplemented command execution.
An executor responsible for executing supplemental commands registered for a main command
Convenience implementation that delegate to a provided system executor.
Created by IntelliJ IDEA.
A TelemetryProvider provides monitoring data using the flashlight framework.
The TldProvider provides an interface to get jar URL with tlds and corresponding tld entries.
Parameters passed to a deployment command.
If this annotation is applied to a command class, the asadmin client will treat any unknown option on the command
line as the start of the operands.
Service interface to define the version info for an installed product.
Provides environment settings for the virtualization/PAAS features.
Annotation that denote a class capable of handling particular URL patterns.
Represents command wrapped with
CommandWrapperImpl.Interface for implementing write access to an underlying archive on a unspecified medium
RunLevelannotation on the Service instead of implementing this interface.