Given by Tom Haupt at Tutorials at ACM Java Grande Meeting on June 14 99. Foils prepared July 6 99
Outside Index
Summary of Material
Computing Portals and Web-based PSE's |
WebFlow CORBA and Middle Tier
|
WebFlow Applications
|
Gateway in Detail
|
Outside Index Summary of Material
Web Portals for Scientific and Engineering communities |
Tom Haupt NPAC |
Seamless access to HPC resources |
Seamless access to instruments |
Data storage |
Application specific data base |
Visualization Tools |
Collaboratory |
Scientific notepads |
Remote Resources |
FRONT-END: |
high-level user friendly |
- visual programming and authoring tools - application GUI |
RESOURCES: |
all hardware and software |
components needed to complete the user task, including, but not limited to, |
compute engines from |
workstations to supercomputers, |
storage, databases, instruments, |
codes, libraries, and licenses. |
Desktop/Laptop |
Seamless |
Access |
Create an illusion that all resources needed to complete the user tasks are available locally. |
In particular, an authorized user can allocate the resources she needs without explicit login to the host controlling the resources. |
An analogy: NSF mounted disk or a network printer. |
Advantages: |
- platform independent mini-language (RSL) for specification of resources |
- can be layered on top of different schedulers - enables interoperability between resources (can allocate many resources at a time, file transfer, monitoring, etc.) Disadvantage: |
- a bag of low level tools |
GRAM Client |
Contact address Resource Language Specification |
MDS |
Directory |
Service |
GSS-API |
PSE: problem description (physics, chemistry, ...) |
Task description: I need 64 nodes of SP-2 at Argonne to run my |
MPI-based executable "a.out" you can find in "/tmp/users/haupt" on marylin.npac.syr.edu. In addition, I need any idle workstation with jdk1.1 installed. Make sure that the output of my a.out is |
transferred to that workstation |
Middle-Tier: map the user's task description onto the resource specification; this may include resource discovery, and other services |
Resource Specification |
Resource Allocation: run, transfer data, run |
Remote Resources |
We need a third tier! |
CTA specific knowledge databases |
Visual |
Authoring |
Tools |
User and |
Group |
Profiles |
Resource Identification and Access |
Visualizations |
Collaboration |
WebFlow |
Back-End Resources |
Problem Solving Environment |
Navigate and choose an existing application to solve the problem at hand. Import all necessary data. |
Retrieve data |
Pre/post-processing |
Run simulations |
Select host |
Select model |
Set parameters |
Run |
Ken Flurchick, http://www.osc.edu/~kenf/Gateway |
1 .Define your problem |
2. Identify resources (software and hardware) |
3. Create input file |
4. Run your application |
5. Analyze results |
Compose interactively |
your application |
from pre-existing |
modules |
Data-Flow Front-End |
WebFlow |
Object Oriented, follows JavaBeans model
|
Firing event E by object A causes invocation of method M of object B. The association of event E and method M is achieved by an event registration mechanism. An event is also an object and it carries data. |
(a digression) |
more information on Java, Corba, Distributed Object: |
http://www.npac.syr.edu/projects/cps616spring96/index.html |
Typically WebFlow objects live in different address spaces. We use CORBA to invoke methods of the remote objects. |
Object A |
(event source) |
Object B |
(event target) |
Fire event E |
Method M(){ |
...} |
ORB |
ORB2 |
Object A |
(event source) |
Object B |
(event target) |
Fire event E |
Method M(){ |
...} |
ORB1 |
IIOP |
- Objects A and B are CORBA objects (thus not Java objects) |
- Objects are defined in IDL (Interface Definition Language) |
- IDL definitions are compiled using (Java)IDL compiler |
- The IDL compiler generates new classes to be used by the Java compiler |
(javac) instead of the original ones, on both the client and server side |
- The IDL compiler generates either classes to be extended, or interfaces to be implemented |
Object Adapter |
serves also as a daemon |
#include "..\BC.idl" module WebFlow { |
module lms{ |
interface runEdys:BeanContextChild { void run(); void receiveData(); |
void setParameter(in string p); |
}; interface runCasc2d:BeanContextChild{ void run(); void runAgain(); |
}; interface DoneEvent{ Object getSource(); }; |
}; }; |
We will create 3 CORBA objects |
* two modules: - runEdys - runCasc2d * one event - DoneEvent They will be added to package WebFlow.lms |
WebFlow objects are developed independently of each other (reusable modules): we cannot assume that the event source knows anything about the event target and vice versa |
addEventListener |
rmEventListener |
fireEvent(E,M) |
method M |
Event Source |
Event Target |
Adapter |
Event |
ORB |
binding |
table |
DII |
DSI |
Proxy Module |
Module |
ActionButton1 |
ActionButton2 |
.... |
IIOP |
Another complication: |
Java sandbox! |
Local Host |
Add module |
Module Factory |
Proxy Module |
Remote Host |
FE |
request |
Add module |
Module Factory |
Module |
Mesh of WebFlow Servers |
implemented as CORBA objects |
that manage and coordinate |
distributed computation. |
Gatekeeper |
Authentication |
Authorization |
The WebFlow server is a container object, a.k.a. context - in fact it implements JavaBeanContext class (Java1.2) |
The BeanContext acts as a logical container for JavaBeans ("WebFlow modules and services") and BeanContexts. |
User 1 |
User 2 |
Application 1 |
Application 2 |
App 2 |
App 1 |
WebFlow server is given |
by a hierarchy of containers |
and components |
WebFlow server hosts users and services |
Each user maintains a number of applications composed of custom modules and common services |
WebFlow Services |
Master Server (Gatekeeper) |
Slave Server |
Slave Server |
User Context |
Application Context |
Module |
Slave Server Proxy |
Services |
User Modules |
Browser based Front-End |
Browser |
based |
Front-End |
User Space Definition and Task Specification |
Metacomputing Services |
Back-End Resources |
Similar to JavaBeans
|
May serve as Proxies
|
Services are modules provided by the system and offers a generic functionality
|
Generate Data |
Run Job |
Analyze |
The Run Job module is a proxy module. It generates the RSL on-the-fly |
and submits the job for execution using globusrun function. |
The module knows only exec name, location and its arguments/parameters. |
In order to run WebFlow over Globus there must be at least one WebFlow node capable of executing Globus commands, such as globusrun |
Jobs that require computational power of massively parallel computers are directed to the Globus domain, while other jobs can be launched on much more modest platforms, such as the user's desktop or even a laptop running Windows NT. |
Bridge between WebFlow and Globus |
Access Control (or Authorization)
|
Authentication
|
Integrity
|
Accountability (or non-repudiation)
|
Privacy
|
Mutual authentication of servers and users
|
Access control
|
Privacy |
Integrity |
SECIOP |
Front End Applet |
https |
authentication |
& authorization |
Gatekeeper |
delegation |
Stakeholders |
HPCC resources |
GSSAPI |
GSSAPI |
Layer 1: secure Web |
Layer 2: secure CORBA |
Layer 3: Secure access to resources |
Policies defined by resource owners |
https (SSL) |
AKENTI |
CORBA security service |
GSSAPI (Globus) |
can play both client and server
|
evolve continually
|
interactions are not well defined
|
are polymorphic (ideal for Trojan horses!) |
can scale without limit
|
are very dynamic |
Secure Communications |
Authentication |
Client |
User |
Encryption |
Audit |
Authorization |
Server |
Encryption |
Credentials |
Object |
Adapter |
ORB |
A principal is authenticated once by ORB and given a set of credentials, including one or more roles, privileges, and an authenticated ID. |
An authenticated ID is automatically propagated by a secure ORB; it is part of the caller context |
Principal |
Credentials |
Current |
Client |
Server |
set_credentials |
get_attributes |
authenticate |
No delegation
|
Simple delegation
|
Composite delegation
|
Client |
Target |
Client |
Target |
Client |
Target |
Client |
Target |
Object |
IIOP |
Based on a trusted ORB model: you must trust that your ORB will enforce the access policy on the server resource |
The ORB determines: if this client on behalf of this principal can do this operation on this object |
Server uses Access Control Lists (ACL) to control user access |
Principal |
Role |
Rights |
Operation |
WebFlow Applications |
Applications vary by the functionality of their Front-Ends
|
Applications vary by how they are composed from modules
|
The modules can interact with each other in different ways:
|
Applications vary on how the Front-End interacts with the Middle-Tier
|
(CEWES) |
To develop a web based system that implements a "navigate-and-choose" paradigm and allows the end user to:
|
Anytime, anywhere, using any platform |
(e.g., a connected to the Internet laptop PC)
|
A decision maker (the end user of the system) wants to evaluate changes in vegetation in a geographical region over a long time period caused by short term disturbances such as a fire or human activity. |
One of the critical parameters of the vegetation model (EDYS) is soil condition at the time of the disturbance. |
This in turn is dominated by rainfall that possibly occurs at that time (CASC2D simulation) |
Input data for the simulations are available from the Internet, such as Data Elevation Models (DEM) from USGS web site or from custom databases (spices characteristics) |
Data retrieval |
Data preprocessing |
Simulation: two interacting codes
|
Visualization |
WMS |
EDYS |
CASC2D |
DEM |
Land Use |
Soil |
Texture |
Vegetation |
EDYS: vegetation model |
CASC2D: watershed model |
WMS: Watershed Modeling System |
Data retrieval |
Data pre- and post-processing |
Simulations |
The data wizard allows the user to interactively select the data and |
download them to the local machine. The raw data are then fed to the WMS system launched from the browser to generate input files for simulations. |
Launching coupled simulations on different Back-End computational resources |
The results of the |
simulations are send |
back to the Front-End, |
and can be visualized |
using tools included |
in WMS package |
Front-End (client) is a Java application
|
"navigate and choose" - no interactive composition of applications
|
modules exchange data through message passing mediated by WebFlow |
client keeps the module references |
slave |
runCasc2d |
master |
UNIX |
WinNT |
slave |
runEdys |
lms.class |
Data wizard |
WMS |
exeCasc2d |
Web |
Server |
Web |
Server |
WebFlow Servers |
Client |
- WebFlow modules |
try { |
//add modules |
p1 = slaveNT.addNewModule("runEdys"); //as defined in conf.file |
runEdys re = runEdysHelper.narrow(p1); |
p2 = slaveUNIX.addNewModule("runCasc2d"); //as defined in conf.file |
runCasc2d rc = runCasc2dHelper.narrow(p2); |
//bind events |
master.attachEvent(p2,"Casc2dDone","Casc2dDone",p1,"run"); |
master.attachEvent(p1,"EdysStarted","EdysStarted",p2,"run"); |
master.attachEvent(p1,"EdysDone","EdysDone",p2,"runAgain"); |
//invoke methods of runCasc2dImp |
rc.run(); |
} |
catch(COMM_FAILURE ex) |
{System.err.println(ex.getMessage()); System.exit(1);} |
Write |
slave |
runCasc2d |
master |
UNIX |
WinNT |
slave |
runEdys |
lms.class |
Data wizard |
WMS |
exeCasc2d |
Web |
Server |
Web |
Server |
casc2d |
IIOP |
http |
Write |
http |
Front-End (client) is a Java applet |
applications are created dynamically from pre-existing modules |
modules exchange data through ports (data flow model) |
server keeps the module references; the references are published on a web site |
XML |
A visual representation is converted into a XML |
document |
XML |
service |
Web |
Server |
save |
parse |
ApplContext |
Generates Java code to add modules to ApplContext |
Publishes IOR |
Front-End Applet |
Middle-Tier |
<!DOCTYPE taskspec [ |
<!ELEMENT taskspec (task)+> |
<!ATTLIST taskspec |
UserContextRef CDATA #REQUIRED |
AppName CDATA #REQUIRED> |
<!ELEMENT task ((task | module)*,connection*) > |
<!ELEMENT module (#PCDATA) > |
<!ATTLIST module |
modulename CDATA #REQUIRED |
host CDATA #REQUIRED > |
<!ELEMENT connection (out,in)> |
<!ELEMENT in EMPTY> |
<!ELEMENT out EMPTY> |
<!ATTLIST out |
modulename CDATA #REQUIRED |
eventname CDATA #REQUIRED |
<!ATTLIST in |
modulename CDATA #REQUIRED |
method CDATA #REQUIRED > |
]> |
<taskspec UserContextRef="123as321" AppName="TestApplication"> |
<task> |
<module modulename="FileBrowser" host="localhost"> |
</module> |
<module modulename="FileEditor" host="localhost"> |
</module> |
<module modulename="Gaussian" host="localhost"> |
</module> |
<connection> |
<out modulename="FileBrowser" eventname="FileEvent" event="File"/> |
<in modulename="FileEditor" method="run"/> |
</connection> |
<connection> |
<out modulename="FileEditor" eventname="FileEvent" event="File"/> |
<in modulename="Gaussian" method="run"/> |
</connection> |
</task> |
</taskspec> |
Coordinates transformations |
Remote HPCC resources |
- Web interface to store data in DB in variable format - Data transfer from DB to a visualization engine |
- Coordinates transformations on |
a remote server - Launching simulations on remote |
hosts with interactive input |
Gateway: Portal for Computing |
CTA specific knowledge databases |
Visual |
Authoring |
Tools |
User and |
Group |
Profiles |
Resource Identification and Access |
Visualizations |
Collaboration |
WebFlow |
Back-End Resources |
Problem Solving Environment |
Support for a seamless access (security) |
Support for distributed, heterogeneous Back-End services (HPCC, DBMS, Internet, ...) managed independently from Gateway |
Variable pool of resources: support for discovery and dynamical incorporation into the system |
Scalable, extensible, low-maintenance Middle Tier |
Web-based, extensible, customizable, self-adjusting to varying capacities and capabilities of clients (humans, software and hardware) front end |
Distributed, object-oriented middle tier
|
Gateway operates in a keberized environment [Support for a seamless access]
|
Task Specification is expressed in XML
|
Resource Specification is expressed in XML
|
[Support for distributed, heterogeneous Back-End services; Variable pool of resources; Scalable, extensible, low-maintenance Middle Tier] |
Component-based Front-End [extensible] |
Front-End Components ("toolbox interfaces") are
|
All components (Front End, Middle-Tier) are defined in XML and contain metadata (used for component mining) |
requires server side support (both the middle tier and the back-end) through well defined interfaces |
should be constructed from reusable or cloneable components |
allows for identification of software components best suited to solve the problem at hand |
Allows for composition of the computational task from components (reusable modules) |
Different tools to support various programming models such as data parallel, task parallel, data flow, object oriented |
No assumption on granularity |
Metadata about components and support for archiving and mining the components |
Support for instrumentation and steering |
Controls the user/group environment
|
Allows for customization
|
History of actions |
Scientific notebook |
Computational resources
|
Data
|
Networks |
Portal Page |
User Context |
Control Applet |
Navigator (extensible, customizable) |
PSE specific toolboxes
|
Other (Collaboration, Visualizations, ...) |
Represents a Gateway session. |
The session is associated with a user (or group) profile. |
WebFlow extends the notion of the UNIX profile via the 'User Data Base' (UDB). This UDB contains information about submitted jobs, history of the users actions, and other user state information. The user context may also contain application/front-end specific information. |
The control applet is responsible for maintaining the session, and direct communication with the middle-tier. |
Direct communication is the most efficient, but since it is buried into an applet, this mechanism is not readily customizable. |
The generic services, such as file service (upload, download, edit, copy, move, delete) and job services (show current jobs/show queues/kill jobs) will be supported this way. [combination of the user context and a query] |
The Gateway will also support a non-direct communication with the middle-tier through servelts. |
The navigator allows the user to select and customize toolboxes. |
Embedded in a separate frame, it consists of menus, buttons, links, etc, derived from an XML document. |
The navigator is a hierarchical, extensible and customizable. |
The problem description is application specific, and the Gateway only provides a general framework for creating a PSE. |
The most important part is the specification of what services (middle and back tier) are needed, what is their API, and how to add new services. |
Example services: access to databases, XML parsing, generating HTML in-the-fly, file services. |
The end user see it as a mapping between the problem description and software to be used to solve the problem. Actually, it identifies WebFlow modules and their parameters to be used to construct the application (see resource request toolbox below). |
The module parameters may include input files, and if necessary, the input files are generated at this stage (using this or a separate toolbox). In addition, some parameters will be constructed from information stored in data bases, including UDB, and other sources. |
The front-end activities result in an abstract task specification. |
Abstract in the sense that the user may not know nor care what actual resources are used. |
The task is composed of independently developed modules and services following different programming models. |
Visualizations |
Collaboration |
Scientific notebook |
... |
User 1 |
User 2 |
Application 1 |
Application 2 |
App 2 |
App 1 |
WebFlow server is given |
by a hierarchy of containers |
and components |
WebFlow server hosts users and services |
Each user maintains a number of applications composed of custom modules and common services |
WebFlow Services |
Mesh of WebFlow Servers |
implemented as CORBA objects |
that manage and coordinate |
distributed computation. |
Gatekeeper |
Authentication |
Authorization |
Access to HPCC (via Globus) |
Access to distributed databases (via JDBC) |
Access to mass storage |
Access to the Internet resources |
Access to desktop application and local data |
Access to code repositories |
SECIOP |
Front End Applet |
SECIOP |
authentication |
& authorization |
Gatekeeper |
delegation |
HPCC resources |
GSSAPI |
GSSAPI |
Layer 1: secure Web |
Layer 2: secure CORBA |
Layer 3: Secure access to resources |
Policies defined by resource owners |
. |
Gateway applications are composed of independent reusable modules |
Modules are written by module developers who have only limited knowledge of the system on which the modules will run. |
The WebFlow system hides module management and coordination functions |
Back-end service |
Middle-tier proxy |
Front-end controls |
Often, your job do not need to interact.
|
If you need to interact
|
Many come as a standard Gateway modules |
User's modules
|
seamless access to remote resources
|
high-level user friendly visual programming and runtime environment for HPDC |
portable system based on industry standards and commodity software components |
Contact person: Tomasz Haupt |
haupt@npac.syr.edu |
voice (315) 443-2087 |
http://www.npac.syr.edu/users/haupt/WebFlow/ |