|
Extending the Administration Console DRAFT |
| Previous | Next | Contents |
The Administration Console is a browser-based tool for administering Eclipse GlassFish Server. It features an easy-to-navigate interface and online help. Extending the Administration Console enables you to provide a graphical user interface for administering your add-on component. You can use any of the user interface features of the Administration Console, such as tree nodes, links on the Common Tasks page, tabs and sub-tabs, property sheets, and Jakarta Server Faces pages. Your add-on component implements a marker interface and provides a configuration file that describes how your customizations integrate with the Administration Console.
This chapter refers to a simple example called console-sample-ip that
illustrates how to provide Administration Console features for a
hypothetical add-on component.
The following topics are addressed here:
The Administration Console is a web application that is composed of OSGi
bundles. These bundles provide all the features of the Administration
Console, such as the Web Applications, Update Center, and Security
content. To provide support for your add-on component, create your own
OSGi bundle that implements the parts of the user interface that you
need. Place your bundle in the modules directory of your GlassFish
Server installation, along with the other Administration Console
bundles.
To learn how to package the Administration Console features for an
add-on component, go to the modules directory of your GlassFish Server
installation and examine the contents of the files named
console-`componentname-plugin.jar`. Place the console-sample-ip
project bundle in the same place to deploy it and examine the changes
that it makes to the Administration Console.
The Administration Console includes a Console Add-On Component Service.
The Console Add-On Component Service is an HK2 service that acts as a
façade to all theAdministration Console add-on components. The Console
Add-On Component Service queries the various console providers for
integration points so that it can perform the actions needed for the
integration (adding a tree node or a new tab, for example). The
interface name for this service is
org.glassfish.api.admingui.ConsolePluginService.
For details about the Hundred-Kilobyte Kernel (HK2) project, see Hundred-Kilobyte Kernel and HK2 Component Model.
Each add-on component must contain a console provider implementation.
This is a Java class that implements the
org.glassfish.api.admingui.ConsoleProvider interface and uses the HK2
@Service annotation. The console provider allows your add-on component
to specify where your integration point configuration file is located.
This configuration file communicates to the Console Add-On Component
Service the customizations that your add-on component makes to the
Administration Console.
The org.glassfish.api.admingui.ConsoleProvider interface has one
required method, getConfiguration. The getConfiguration method
returns the location of the console-config.xml file as a
java.net.URL. If getConfiguration returns null, the default
location, META-INF/admingui/console-config.xml, is used. The
console-config.xml file is described in About Integration
Points.
To implement the console provider for your add-on component, write a Java class that is similar to the following example.
Example 3-1 Example ConsoleProvider Implementation
This example shows a simple implementation of the ConsoleProvider
interface:
package org.glassfish.admingui.plugin;
import org.glassfish.api.admingui.ConsoleProvider;
import org.jvnet.hk2.annotations.Service;
import java.net.URL;
@Service
public class SamplePlugin implements ConsoleProvider {
public URL getConfiguration() { return null; }
}This implementation of getConfiguration returns null to specify that
the configuration file is in the default location. If you place the file
in a nonstandard location or give it a name other than
console-config.xml, your implementation of getConfiguration must
return the URL where the file can be found.
GlassFish Server includes a set of templates that make it easier to create Jakarta Server Faces pages for your add-on component. These templates use Templating for Jakarta Server Faces Technology, which is also known as JSFTemplating.
Examples of JSFTemplating technology can be found in the following sections of this chapter:
The integration points for your add-on component are the individual Administration Console user interface features that your add-on component will extend. You can implement the following kinds of integration points:
Nodes in the navigation tree
Elements on the Common Tasks page of the Administration Console
Jakarta Server Faces pages
Tabs and sub-tabs
Specify all the integration points in a file named console-config.xml.
In the example, this file is in the directory
project/src/main/resources/META-INF/admingui/. The following sections
describe how to create this file.
In addition, create Jakarta Server Faces pages that contain JSF code
fragments to implement the integration points. In the example, these
files are in the directory project/src/main/resources/. The content of
these files depends on the integration point you are implementing. The
following sections describe how to create these JavaServer Faces pages.
For reference information on integration points, see Integration Point Reference.
The console-config.xml file consists of a console-config element
that encloses a series of integration-point elements. The
console-config element has one attribute, id, which specifies a
unique name or ID value for the add-on component.
In the example, the element is declared as follows:
<console-config id="sample">
...
</console-config>You will also specify this ID value when you construct URLs to images, resources and pages in your add-on component. See Adding a Node to the Navigation Tree for an example.
For example, a URL to an image named my.gif might look like this:
<sun:image url="/resource/sample/images/my.gif" />The URL is constructed as follows:
/resource is required to locate any resource URL.
sample is the add-on component ID. You must choose a unique ID
value.
images is a folder under the root of the add-on component JAR file.
The integration-point elements in the console-config.xml file
specify attributes for the user interface features that you choose to
implement. The example file provides examples of most of the available
kinds of integration points at this release. Your own add-on component
can use some or all of them.
For each integration-point element, specify the following attributes.
idAn identifier for the integration point.
parentIdThe ID of the integration point’s parent.
typeThe type of the integration point.
priorityA numeric value that specifies the relative ordering of integration
points for add-on components that specify the same parentId. A lower
number specifies a higher priority (for example, 100 represents a
higher priority than 400). The integration points for add-on
components are always placed after those in the basic Administration
Console. You might need to experiment to place the integration point
where you want it. This attribute is optional.
contentThe content for the integration point, typically a JavaServer Faces
page. In the example, you can find the JavaServer Faces pages in the
directory project/src/main/resources/.
Note: The order in which these attributes are specified does not matter, and
in the example |
The following topics are addressed here:
You can add a node to the navigation tree, either at the top level or
under another node. To add a node, use an integration point of type
org.glassfish.admingui:navNode. Use the parentId attribute to
specify where the new node should be placed. Any tree node, including
those added by other add-on components, can be specified. Examples
include the following:
treeAt the top level
applicationServerUnder the GlassFish Server node
applicationsUnder the Applications node
resourcesUnder the Resources node
configurationUnder the Configuration node
webContainerUnder the Web Container node
httpServiceUnder the HTTP Service node
Note: The |
If you do not specify a parentId, the new content is added to the root
of the integration point, in this case the top level node, tree.
Example 3-2 Example Tree Node Integration Point
For example, the following integration-point element uses a parentId
of tree to place the new node at the top level.
<integration-point
id="samplenode"
parentid="tree"
type="org.glassfish.admingui:treeNode"
priority="200"
content="sampleNode.jsf"
/>This example specifies the following values in addition to the
parentId:
The id value, sampleNode, specifies the integration point ID.
The type value, org.glassfish.admingui:treeNode, specifies the
integration point type as a tree node.
The priority value, 200, specifies the order of the node on the
tree.
The content value, sampleNode.jsf, specifies the JavaServer Faces
page that displays the node.
The example console-config.xml file provides other examples of tree
nodes under the Resources and Configuration nodes.
Creating a Jakarta Server Faces Page for Your Node
A Jakarta Server Faces page for a task uses the tag sun:commonTask. This
tag provides all the capabilities of the Project Woodstock tag
webuijsf:commonTask.
Example 3-8 Example Jakarta Server Faces Page for a Task
In the example, the sampleCommonTask.jsf file has the following
content:
<sun:commonTask
text="Sample Application Page"
toolTip="Sample Application Page"
onClick="return admingui.woodstock.commonTaskHandler('treeForm:tree:applications:ejb',
'#{request.contextPath}/sample/page/testPage.jsf?name=Sample%20Application%20Page');">
</sun:commonTask>Note: In the actual file, there is no line break in the |
This file uses the sun:commonTask tag to specify the task. In your own
Jakarta Server Faces pages, specify the attributes of this tag as follows:
textThe task name that appears on the Common Tasks page.
toolTipThe text that appears when a user places the mouse cursor over the task name.
onClickScripting code that is to be executed when a user clicks the task name.
You can add a new group of tasks to the Common Tasks page to display the
most important tasks for your add-on component. To add a task group, use
an integration point of type org.glassfish.admingui:commonTask.
Example 3-9 Example Task Group Integration Point
In the example console-config.xml file, the following
integration-point element adds a new task group to the Common Tasks
page:
<integration-point
id="samplegroup"
parentid="commontaskssection"
type="org.glassfish.admingui:commonTask"
priority="500"
content="sampleTaskGroup.jsf"
/>This example specifies the following values:
The id value, sampleGroup, specifies the integration point ID.
The parentId value, commonTasksSection, specifies that the task
group is to be placed on the Common Tasks page.
The type value, org.glassfish.admingui:commonTask, specifies the
integration point type as a common task.
The priority value, 500, specifies the order of the task group on
the Common Tasks page. The low value places it at the end of the page.
The content value, sampleTaskGroup.jsf, specifies the JavaServer
Faces page that displays the task.
Creating a Jakarta Server Faces Page for Your Task Group
| Previous | Next | Contents |
Copyright © 2020, Oracle and/or its affiliates. All rights reserved.
DRAFT