Post on 26-Dec-2015
A Portal Architecture A Portal Architecture ReviewReview
Talk OverviewTalk Overview
Portal architectures Portal architectures JSR 168 reviewJSR 168 review A motivating exampleA motivating example Building grid clients with the Java Building grid clients with the Java
COG.COG. Combining the Java COG with Java Combining the Java COG with Java
Server Faces.Server Faces.
A Famous Web PortalA Famous Web Portal
A Famous Portal, After LoginA Famous Portal, After Login
What to NoticeWhat to Notice After logging in, my colors, layouts, and After logging in, my colors, layouts, and
content all changed.content all changed.• I get my stock list, my Bloomington weather, my I get my stock list, my Bloomington weather, my
news stories, etc.news stories, etc.• I got rid of “Garfield”I got rid of “Garfield”
As we will see later, each of these content As we will see later, each of these content fragments (encircled) is managed by a thing fragments (encircled) is managed by a thing called a called a portletportlet……• … … I don’t guarantee that this is true for Yahoo’s I don’t guarantee that this is true for Yahoo’s
web site but it is true for a large class of web site but it is true for a large class of enterprise Java portal systems.enterprise Java portal systems.
Portlets are the key to portal software reuse.Portlets are the key to portal software reuse.
Let 10,000 Flowers BloomLet 10,000 Flowers Bloom Many portal projects have been launched Many portal projects have been launched
since late ’90s. since late ’90s. • HotPage from SDSC, NCSA efforts, DOD, DOE HotPage from SDSC, NCSA efforts, DOD, DOE
Portals, NASA IPGPortals, NASA IPG• 2002 Special Issue of 2002 Special Issue of Concurrency and Concurrency and
Computation: Practice and ExperienceComputation: Practice and Experience.. The field continues to be activeThe field continues to be active
• Global Grid Forum 14 Science Gateway workshop Global Grid Forum 14 Science Gateway workshop in June 2005.in June 2005.
• About 15 gateways will be described in upcoming About 15 gateways will be described in upcoming issue of issue of Concurrency.Concurrency.
• GCE2005 workshopGCE2005 workshop at Supercomputing 05. at Supercomputing 05. http://www.ggf.org/ggf_events_lodging_ggf15.htmhttp://www.ggf.org/ggf_events_lodging_ggf15.htm
How do we share and reuse all of this work?How do we share and reuse all of this work?
Por
tal U
ser
Inte
rfac
e Grid ResourceBroker Service
Grid and Web
Protocols
Informationand
Data Services
DatabaseService Database
HPCor
Compute Cluster
Grid InformationServices, SRB
PortalClientStub
PortalClientStub
PortalClientStub
JDBC,Local, orRemote
Connection
Three-Tiered ArchitectureThree-Tiered Architecture
Three-tiered architecture is accepted standard for Three-tiered architecture is accepted standard for accessing Grid and other servicesaccessing Grid and other services
JSR 168 OverviewJSR 168 Overview
Java Portlet StadardJava Portlet Stadard
What Is a Portlet?What Is a Portlet? A portlet is a piece of Java code that manages the A portlet is a piece of Java code that manages the
content of one section of a web portal’s HTML.content of one section of a web portal’s HTML. It can do anything else that a Java web application It can do anything else that a Java web application
can do.can do.• You can connect a portlet to a database, invoke a web You can connect a portlet to a database, invoke a web
service, download an RSS feed, etc.service, download an RSS feed, etc. It lives in a It lives in a portlet containerportlet container, which creates, , which creates,
manages, and destroys all the portlets of the portal.manages, and destroys all the portlets of the portal. Portlet containers are part of portals.Portlet containers are part of portals.
• Portals must do other things like manage login, users, Portals must do other things like manage login, users, groups, layouts, etc.groups, layouts, etc.
JSR 168JSR 168 standardizes two main things: standardizes two main things:• How the portlet container manages portlet lifecyclesHow the portlet container manages portlet lifecycles• How the portlets are programmed.How the portlets are programmed.
What is JSR 168?What is JSR 168? From the portlet development point of view, From the portlet development point of view,
it is really very simple:it is really very simple:• You write a java class that extends You write a java class that extends
GenericPortletGenericPortlet..• You override/implement several methods You override/implement several methods
inherited from GenericPortlet.inherited from GenericPortlet.• You use some supporting classes/interfacesYou use some supporting classes/interfaces
Many are analogous to their Many are analogous to their servlet equivalentsservlet equivalents Some (portletsession) actually seem to be trivial Some (portletsession) actually seem to be trivial
wrappers around servlet equivalents in Pluto.wrappers around servlet equivalents in Pluto. I have a complete example in the extended I have a complete example in the extended
slides.slides.• See also tutorial slides.See also tutorial slides.
Some Open Source JSR 168 Some Open Source JSR 168 ContainersContainers
GridSphereGridSphere• http://http://www.gridsphere.orgwww.gridsphere.org
uPortaluPortal• http://http://www.uportal.orgwww.uportal.org
LifeRayLifeRay• http://http://sourceforge.net/projects/lportalsourceforge.net/projects/lportal
eXo platformeXo platform• http://http://www.exoplatform.comwww.exoplatform.com
StringBeansStringBeans• http://www.nabh.com/projects/sbportalhttp://www.nabh.com/projects/sbportal
Jetspeed2Jetspeed2• http://portals.apache.org/jetspeed-2/http://portals.apache.org/jetspeed-2/
Some GenericPortlet.java MethodsSome GenericPortlet.java MethodsMethodMethod DescriptionDescription
InitInit Called when the portlet is created. Called when the portlet is created. Override if you need to set initial params.Override if you need to set initial params.
doViewdoView Controls what happens immediately Controls what happens immediately before the portlet is displayed in view before the portlet is displayed in view mode. Normally you override this.mode. Normally you override this.
doHelp, doEditdoHelp, doEdit Other portlet display modesOther portlet display modes
processActionprocessAction Place for handling any <form> actions Place for handling any <form> actions before turning over to the display mode before turning over to the display mode method (like doView). You should override method (like doView). You should override this for web forms.this for web forms.
Some Supporting Classes/InterfacesSome Supporting Classes/InterfacesClassClass DescriptionDescription
PortletContextPortletContext Similar to servlet context; get context info and Similar to servlet context; get context info and the RequestDispatcher from here.the RequestDispatcher from here.
PortletSessionPortletSession Stores attribute information for a single portlet Stores attribute information for a single portlet application across multiple requests. application across multiple requests.
RenderRequest, RenderRequest, RenderResponseRenderResponse
The request and response objects available to The request and response objects available to the doView() method. Similar to the normal the doView() method. Similar to the normal servlet requestservlet request
ActionRequest,ActioActionRequest,ActionResponsenResponse
The request and response objects available to The request and response objects available to the processAction() method. Similar to the the processAction() method. Similar to the servlet request and response objects.servlet request and response objects.
PortletURLPortletURL Use this to create URLs that reference the portal.Use this to create URLs that reference the portal.
PortletRequestDispaPortletRequestDispatchertcher
Use this to include/forward to a JSP or servlet in Use this to include/forward to a JSP or servlet in the same portlet app.the same portlet app.
WindowStateWindowState See if you are in minimized, maximized, normal See if you are in minimized, maximized, normal state.state.
The Big PictureThe Big Picture As a portlet developer, the previous set of classes are all you As a portlet developer, the previous set of classes are all you
normally touch.normally touch. The portlet container (Pluto) is responsible for running your The portlet container (Pluto) is responsible for running your
portlets.portlets.• Init, invoke methods, destroy. Init, invoke methods, destroy.
Portlets have a very limited way of interacting with the Portlets have a very limited way of interacting with the container.container.• The API is basically one-way.The API is basically one-way.
A Comment on Portlet CodingA Comment on Portlet Coding JSR 168 seems to make some important and JSR 168 seems to make some important and
dubious assumptionsdubious assumptions• Developers will gladly ignore other development Developers will gladly ignore other development
methodologies/frameworks like methodologies/frameworks like Velocity, Struts, and Java Velocity, Struts, and Java Server Faces.Server Faces.
• Developers instead want to write a GenericPortlet Developers instead want to write a GenericPortlet extension for every single portlet they develop.extension for every single portlet they develop.
And write really complicated processAction() and doView() And write really complicated processAction() and doView() methods.methods.
• Developers will like the specific JSR 168 Developers will like the specific JSR 168 portlet-style Model-portlet-style Model-View-ControllerView-Controller that it forces on them. that it forces on them.
Fortunately, these other development environments Fortunately, these other development environments can be mapped to portlet actions. can be mapped to portlet actions. • In the OGCE project, we have developed support for In the OGCE project, we have developed support for
Velocity portlets.Velocity portlets.• We are transitioning to Java Server FacesWe are transitioning to Java Server Faces
A Grid Portlet ScenarioA Grid Portlet Scenario
Developing a Simple Grid Developing a Simple Grid Portlet ApplicationPortlet Application
A Quantum Chemistry Code A Quantum Chemistry Code Submission FormSubmission Form
You have been asked to develop a You have been asked to develop a submission form for the Democritos submission form for the Democritos group’s group’s Quantum EspressoQuantum Espresso (QE) package. (QE) package.
These forms should help users set up and These forms should help users set up and run QE applications on the run QE applications on the TeraGridTeraGrid and and other Grid installations.other Grid installations.• Mix of GT 2, GT 4, Condor, etc., for submissionMix of GT 2, GT 4, Condor, etc., for submission
You are told to initially support the You are told to initially support the Plane Plane Wave Self Consistent FieldWave Self Consistent Field (PWSCF) code. (PWSCF) code.
Other QE applications may follow.Other QE applications may follow.• These may be coupled with PWSCF into simple These may be coupled with PWSCF into simple
workflows, but this is a later problem.workflows, but this is a later problem.
Your Deployment ArchitectureYour Deployment Architecture
PortalServer@FSU
GT 4@TG
MSIPBS
GT 2@UMN
TeraGridLSF
Your portal server runs at FSU.
It acts as a common Gateway to different grid toolkit installations and resources
Some IssuesSome Issues
You decide the JSR 168 style portlets are You decide the JSR 168 style portlets are the way to go…the way to go…• But of course the PWSCF portlet doesn’t exist But of course the PWSCF portlet doesn’t exist
yet.yet. You will need to also support other You will need to also support other
Quantum Espresso codes.Quantum Espresso codes.• Would like to reuse as much code as possible.Would like to reuse as much code as possible.• But your PWSCF portlet isn’t reusable at that But your PWSCF portlet isn’t reusable at that
level.level. You also would like to simplify saving user You also would like to simplify saving user
input data and session archiving.input data and session archiving.
PWSCF Web Forms for PWSCF Web Forms for SubmissionSubmission
Your ChoicesYour Choices JSR 168JSR 168 will allow you to share your portlet code with will allow you to share your portlet code with
other collaborators.other collaborators. The The Java COG KitJava COG Kit will help hide the differences will help hide the differences
between Grid toolkits for common tasks.between Grid toolkits for common tasks. Vanilla JSFVanilla JSF will help simplify your portlet will help simplify your portlet
development in several ways.development in several ways.• JSF decouples your backing code from the Servlet APIJSF decouples your backing code from the Servlet API
You can write your backing code as pure Java Beans/Plain Old You can write your backing code as pure Java Beans/Plain Old Java Objects.Java Objects.
You don’t have to adopt, maintain HTTP parameter name You don’t have to adopt, maintain HTTP parameter name conventions.conventions.
• Your form input backing beans can be Your form input backing beans can be serialized/deserialized with Castor.serialized/deserialized with Castor.
Coupling JSF and COGCoupling JSF and COG will allow you to compose will allow you to compose your Grid actions using simple JSF taglibs.your Grid actions using simple JSF taglibs.• You can reuse your Grid taglibs in other Quantum Espresso You can reuse your Grid taglibs in other Quantum Espresso
portlets.portlets.• You can compose composite actions You can compose composite actions
The Java CoG KitThe Java CoG Kit
Gregor von LaszewskiGregor von LaszewskiArgonne National LaboratoryArgonne National Laboratory
University of ChicagoUniversity of Chicagogregor@mcs.anl.govgregor@mcs.anl.govhttp://www.cogkit.orghttp://www.cogkit.org
(as interpreted by MEP)(as interpreted by MEP)
CoG KitsCoG Kits
CoG Kits make Grid programming simple and CoG Kits make Grid programming simple and new technologies are easy to integratenew technologies are easy to integrate
We focus on a CoG Kit for JavaWe focus on a CoG Kit for Java• Python also available (K. Jackson, LBNL)Python also available (K. Jackson, LBNL)• Availability: Java CoG Kit since 1997Availability: Java CoG Kit since 1997
The CoG provides two important thingsThe CoG provides two important things• A higher level client programming environment A higher level client programming environment
than stubs.than stubs.• A shield against different versions of the Globus A shield against different versions of the Globus
toolkittoolkit Same high level API works with GT 2.4, GT 3.0.2, GT Same high level API works with GT 2.4, GT 3.0.2, GT
3.2.0, GT 3.2.1, GT 4.0.03.2.0, GT 3.2.1, GT 4.0.0
CoG Abstraction Layer
CoG CoG CoG CoG CoG
CoG Data and Task Management Layer
CoG Gridfaces Layer
CoG CoG
CoG
GridID
E
GT2GT3OGSI
classic
GT4WS-RF
Condor Unicore
Applications
SSHOthersAvakiSETI
Nanomaterials
Bio-Informatics
DisasterManagement
Portals
CoG Abstraction Layer
CoG CoG CoG CoG CoG
CoG Data and Task Management Layer
CoG Gridfaces Layer
CoG CoG
CoG
GridID
E
DevelopmentSupport
CoG Abstraction Layers CoG Abstraction Layers
TaskTask
Handler
Service
TaskSpecification
SecurityContext
ServiceContact
The class diagram is thesame for all grid tasks (running jobs, modifying files, moving data).
Classes also abstract toolkit provider differences. You set these as parameters: GT2, GT4, etc.
Java COG SummaryJava COG Summary The Java COG 4 interfaces provide high level The Java COG 4 interfaces provide high level
abstractions for building Grid clients.abstractions for building Grid clients.• Abstract out differences between Grid toolkits.Abstract out differences between Grid toolkits.• Provide task abstractions that form the basis for Provide task abstractions that form the basis for
constructing DAG-style, file-based workflow.constructing DAG-style, file-based workflow. The COG can be used to build a wide range of The COG can be used to build a wide range of
clientsclients• Desktops, grid shells, and of course portals.Desktops, grid shells, and of course portals.• Portlets are a well known way to build reusable Portlets are a well known way to build reusable
portal components.portal components.
Building Grid Portlets Building Grid Portlets with Java Server Faceswith Java Server Faces
Limitations of PortletsLimitations of Portlets Portlets provide a way to bundle and share a Portlets provide a way to bundle and share a
complete application.complete application.• RSS portlet, GridFTP portlet, SRB portlet, etc.RSS portlet, GridFTP portlet, SRB portlet, etc.• Portlets combine the user interface view and Portlets combine the user interface view and
action code.action code. But in science gateway development, we But in science gateway development, we
often need finer grained components.often need finer grained components.• ““When user clicks button, upload file, launch code, When user clicks button, upload file, launch code,
and move data someplace when done.”and move data someplace when done.”• Combines “GridFTP” and “Job Submit” portlets…Combines “GridFTP” and “Job Submit” portlets…• Or maybe OGSA-DAI or SRB or ….Or maybe OGSA-DAI or SRB or ….
We need a way for the view and action code We need a way for the view and action code must be developed from reusable parts.must be developed from reusable parts.
JSF and Science GatewaysJSF and Science Gateways JSF enables you back your science application JSF enables you back your science application
input form portlets with Java Beans.input form portlets with Java Beans.• Again, these are independent of the servlet Again, these are independent of the servlet
container, so are easy to test and to reuse in other container, so are easy to test and to reuse in other applications.applications.
But also, Java Beans can be easily serialized But also, Java Beans can be easily serialized with XML.with XML.• Castor, XML BeansCastor, XML Beans• Marshal and un-marshal user input for persistent Marshal and un-marshal user input for persistent
storage in XML storage servicesstorage in XML storage services OGSA-DAI, GPIR, WS-ContextOGSA-DAI, GPIR, WS-Context
• Potentially, can develop backing code as XML Potentially, can develop backing code as XML Schema and generate the code.Schema and generate the code.
JSF for Grid Enabled HTML JSF for Grid Enabled HTML WidgetsWidgets
Natural program: develop Java Bean Natural program: develop Java Bean wrappers around Java COG kit, OGSA-DAI wrappers around Java COG kit, OGSA-DAI client API, SRB Jargon, etc.client API, SRB Jargon, etc.• Allows simple integration with JSF.Allows simple integration with JSF.
Some issues existSome issues exist• JSF only manages individual bean instances.JSF only manages individual bean instances.• But grid portlets will need to manage an unknown But grid portlets will need to manage an unknown
number of bean instances.number of bean instances. You may launch and monitor many different jobs.You may launch and monitor many different jobs.
• We need a way of scripting composite actions We need a way of scripting composite actions created out of multiple reusable actions.created out of multiple reusable actions.
COG Bean WrappersCOG Bean Wrappers Recall the COG structureRecall the COG structure
• Executable tasks abstract basic grid Executable tasks abstract basic grid actions and hide toolkit version actions and hide toolkit version differences.differences.
• These tasks can be collected into file-These tasks can be collected into file-based DAG workflows.based DAG workflows.
First problem is simple: wrap tasks as First problem is simple: wrap tasks as beans to make them available to JSF.beans to make them available to JSF.• GenericGridBean defines the interfaceGenericGridBean defines the interface
Second problem is managing multiple Second problem is managing multiple individual tasks.individual tasks.
Managing Multiple Grid TasksManaging Multiple Grid Tasks We must create and manage multiple beans We must create and manage multiple beans
for each task.for each task.• That is, I submit the job four times in one session.That is, I submit the job four times in one session.• Similarly, we can create multiple task graph Similarly, we can create multiple task graph
clones. clones. We do this by cloning and storing each bean.We do this by cloning and storing each bean. Beans have listeners and maintain state.Beans have listeners and maintain state.
• Unsubmitted, submitted, active, suspended, Unsubmitted, submitted, active, suspended, resumed are “live”resumed are “live”
Stored in live repositoryStored in live repository
• Failed, canceled, completed, unknown are “dead” Failed, canceled, completed, unknown are “dead” Stored in archive (WS-Context or other)Stored in archive (WS-Context or other)
Alternative approach: use one bean that is a Alternative approach: use one bean that is a bean factory for GenericGridTask beans.bean factory for GenericGridTask beans.
Task Submission FormTask Submission Form
<h:panelGrid columns="3" > <h:outputText value="Hostname (*) "/> <h:inputText value="#{task.hostname}"/> </h:panelGrid> <h:panelGrid columns="3" > <h:outputText value="Provider (*) "/> <h:inputText value="#{task.provider}"/></h:panelGrid>
Corresponding JSF snippets<o:taskGraph id="myGraph" method="#{taskgraph.test}" > <o:task id="task1" method="task.create" type="FileTransfer" /> <o:task id="task2" method="task.create" type="JobSubmit" /> <o:task id="task3" method="task.create" type="FileTransfer" /> <o:taskAdd name="task1" method="taskgraph.add" /> <o:taskAdd name="task2" depends="task1" method="taskgraph.add" /> <o:taskAdd name="task3" depends="task2" method="taskgraph.add" /> </o:taskGraph>
<h:panelGrid columns="2"> <h:commandButton id="submit" value="Submit" action="#{taskgraph.submitAction}"/> <h:commandButton value="Clear" type="Reset"/> </h:panelGrid>
Task Monitoring with JSF Task Monitoring with JSF Data ModelData Model
<h:dataTable value="#{jobData.jobs}" var="job"> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Job ID" /> </f:facet> <h:outputText value="#{job.jobId}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Submit Date" /> </f:facet> <h:outputText value="#{job.submitDate}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Finish Date" /> </f:facet> <h:outputText value="#{job.finishDate}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Status" /> </f:facet> <h:outputText value="#{job.status}"/> </h:column> </h:dataTable>
Corresponding Java class.public class Job { private String jobId; private String status; private String submitDate; private String finishDate;}
Extended SlidesExtended Slides
The Java CoG KitThe Java CoG Kit
Gregor von LaszewskiGregor von LaszewskiArgonne National LaboratoryArgonne National Laboratory
University of ChicagoUniversity of Chicagogregor@mcs.anl.govgregor@mcs.anl.govhttp://www.cogkit.orghttp://www.cogkit.org
(as interpreted by MEP)(as interpreted by MEP)
CoG KitsCoG Kits
CoG Kits make Grid programming simple and CoG Kits make Grid programming simple and new technologies are easy to integratenew technologies are easy to integrate
We focus on a CoG Kit for JavaWe focus on a CoG Kit for Java• Python also available (K. Jackson, LBNL)Python also available (K. Jackson, LBNL)• Availability: Java CoG Kit since 1997Availability: Java CoG Kit since 1997
The CoG provides two important thingsThe CoG provides two important things• A higher level client programming environment A higher level client programming environment
than stubs.than stubs.• A shield against different versions of the Globus A shield against different versions of the Globus
toolkittoolkit Same high level API works with GT 2.4, GT 3.0.2, GT Same high level API works with GT 2.4, GT 3.0.2, GT
3.2.0, GT 3.2.1, GT 4.0.03.2.0, GT 3.2.1, GT 4.0.0
CoG Abstraction Layer
CoG CoG CoG CoG CoG
CoG Data and Task Management Layer
CoG Gridfaces Layer
CoG CoG
CoG
GridID
E
GT2GT3OGSI
classic
GT4WS-RF
Condor Unicore
Applications
SSHOthersAvakiSETI
Nanomaterials
Bio-Informatics
DisasterManagement
Portals
CoG Abstraction Layer
CoG CoG CoG CoG CoG
CoG Data and Task Management Layer
CoG Gridfaces Layer
CoG CoG
CoG
GridID
E
DevelopmentSupport
CoG Abstraction Layers CoG Abstraction Layers
TaskTask
Handler
Service
TaskSpecification
SecurityContext
ServiceContact
The class diagram is thesame for all grid tasks (running jobs, modifying files, moving data).
Classes also abstract toolkit provider differences. You set these as parameters: GT2, GT4, etc.
Setting Up Task and SpecificationSetting Up Task and Specification
Task task=new TaskImpl(“mytask”,Task task=new TaskImpl(“mytask”,Task.JOB_SUBMISSION);Task.JOB_SUBMISSION);
task.setProvider(“GT2”);task.setProvider(“GT2”);JobSpecification spec=JobSpecification spec=
new JobSpecificationImpl();new JobSpecificationImpl();spec.setExecutable(“rm”);spec.setExecutable(“rm”);spec.setBatchJob(true);spec.setBatchJob(true);spec.setArguments(“-r”);spec.setArguments(“-r”);……task.setSpecification(spec);task.setSpecification(spec);
Setting Up the Service and Security Setting Up the Service and Security ContextContext
Service service=new Service service=new ServiceImpl(Service.JOB_SUBMISSION);ServiceImpl(Service.JOB_SUBMISSION);
service.setProvider(“GT2”);service.setProvider(“GT2”);
SecurityContext securityContext=SecurityContext securityContext=
CoreFactory.newSecurityContext(“GT2”);CoreFactory.newSecurityContext(“GT2”);
//Use cred object from ProxyManager//Use cred object from ProxyManager
securityContext.setCredentials(cred);securityContext.setCredentials(cred);
service.setSecurityContext(service.setSecurityContext(
(SecurityContext)securityContext);(SecurityContext)securityContext);
Set Up Service Contact and Set Up Service Contact and FinishFinish
ServiceContact serviceContact=ServiceContact serviceContact=
new ServiceContact(“myhost.myorg.org”);new ServiceContact(“myhost.myorg.org”);
service.setServiceContact(serviceContact);service.setServiceContact(serviceContact);
task.setService(task.setService(
Service.JOB_SUBMISSION_SERVICE,Service.JOB_SUBMISSION_SERVICE,
service);service);
TaskHandler handler=new TaskHandler handler=new GenericTaskHandler();GenericTaskHandler();
handler.submit(task);handler.submit(task);
Coupling CoG TasksCoupling CoG Tasks
The COG The COG abstractions also abstractions also simplify creating simplify creating coupled tasks.coupled tasks.
Tasks can be Tasks can be assembled into assembled into task graphs with task graphs with dependencies.dependencies.• ““Do Task B after Do Task B after
successful Task A”successful Task A” Graphs can be Graphs can be
nested.nested.
Java COG SummaryJava COG Summary The Java COG 4 interfaces provide high level The Java COG 4 interfaces provide high level
abstractions for building Grid clients.abstractions for building Grid clients.• Abstract out differences between Grid toolkits.Abstract out differences between Grid toolkits.• Provide task abstractions that form the basis for Provide task abstractions that form the basis for
constructing DAG-style, file-based workflow.constructing DAG-style, file-based workflow. The COG can be used to build a wide range of The COG can be used to build a wide range of
clientsclients• Desktops, grid shells, and of course portals.Desktops, grid shells, and of course portals.• Portlets are a well known way to build reusable Portlets are a well known way to build reusable
portal components.portal components.
Building Grid Portlets Building Grid Portlets with Java Server Faceswith Java Server Faces
Limitations of PortletsLimitations of Portlets Portlets provide a way to bundle and share a Portlets provide a way to bundle and share a
complete application.complete application.• RSS portlet, GridFTP portlet, SRB portlet, etc.RSS portlet, GridFTP portlet, SRB portlet, etc.• Portlets combine the user interface view and Portlets combine the user interface view and
action code.action code. But in science gateway development, we But in science gateway development, we
often need finer grained components.often need finer grained components.• ““When user clicks button, upload file, launch code, When user clicks button, upload file, launch code,
and move data someplace when done.”and move data someplace when done.”• Combines “GridFTP” and “Job Submit” portlets…Combines “GridFTP” and “Job Submit” portlets…• Or maybe OGSA-DAI or SRB or ….Or maybe OGSA-DAI or SRB or ….
We need a way for the view and action code We need a way for the view and action code must be developed from reusable parts.must be developed from reusable parts.
PWSCF Web Forms for PWSCF Web Forms for SubmissionSubmission
Java Server Faces OverviewJava Server Faces Overview JSF can solve the reusable portlet JSF can solve the reusable portlet
widget problem.widget problem.• JSF can also work in “standalone” mode JSF can also work in “standalone” mode
outside of portlets.outside of portlets.• Potentially independent of Web Potentially independent of Web
applications.applications. XUL and Swing widget bindingsXUL and Swing widget bindings
We will first examine JSF generallyWe will first examine JSF generally Conclude with integrating JSF and COGConclude with integrating JSF and COG
Advantages of JSFAdvantages of JSF JSF hides communication details that connect JSF hides communication details that connect
HTML forms with backing code.HTML forms with backing code.• You don’t have to worry about servlet specific You don’t have to worry about servlet specific
request, response, and session objects.request, response, and session objects.• You don’t have to maintain fragile naming You don’t have to maintain fragile naming
conventions for <input> tags.conventions for <input> tags. Developers only need to develop JavaBeans Developers only need to develop JavaBeans
and tag libraries.and tag libraries.• Beans are independent of Web applications.Beans are independent of Web applications.• Can be easily written and tested outside of servlet Can be easily written and tested outside of servlet
containers.containers.• Compatible popular “Inversion of Control” based Compatible popular “Inversion of Control” based
systems like JSF and Springsystems like JSF and Spring
JSF and Science GatewaysJSF and Science Gateways JSF enables you back your science application JSF enables you back your science application
input form portlets with Java Beans.input form portlets with Java Beans.• Again, these are independent of the servlet Again, these are independent of the servlet
container, so are easy to test and to reuse in other container, so are easy to test and to reuse in other applications.applications.
But also, Java Beans can be easily serialized But also, Java Beans can be easily serialized with XML.with XML.• Castor, XML BeansCastor, XML Beans• Marshal and un-marshal user input for persistent Marshal and un-marshal user input for persistent
storage in XML storage servicesstorage in XML storage services OGSA-DAI, GPIR, WS-ContextOGSA-DAI, GPIR, WS-Context
• Potentially, can develop backing code as XML Potentially, can develop backing code as XML Schema and generate the code.Schema and generate the code.
A JSF ExampleA JSF Example<HTML><HTML> <HEAD> <title>Hello</title> </HEAD><HEAD> <title>Hello</title> </HEAD> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %><%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %> <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %><%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %> <body bgcolor="white"><body bgcolor="white"> <f:view><f:view> <h:form id="entryForm" ><h:form id="entryForm" > <h2> Enter some text in the form below</h2><h2> Enter some text in the form below</h2> <h:inputText id="userSt" <h:inputText id="userSt"
value="#{multiEventBean.userString}"/>value="#{multiEventBean.userString}"/> <h:commandButton id="submit" <h:commandButton id="submit"
action="success" value="Submit" >action="success" value="Submit" > <f:actionListener type="multiEventTest.Listener1"/><f:actionListener type="multiEventTest.Listener1"/> <f:actionListener type="multiEventTest.Listener2"/><f:actionListener type="multiEventTest.Listener2"/> </h:commandButton></h:commandButton> </h:form></h:form> </f:view></f:view> </body></body></HTML> </HTML>
The JSF PageThe JSF Page Note everything with <f:> or <h:> namespace Note everything with <f:> or <h:> namespace
prefix is a JSF tag. prefix is a JSF tag. • Usually, <h:> tags mimic HTML widgets.Usually, <h:> tags mimic HTML widgets.• <f:> is for non-rendered stuff. <f:> is for non-rendered stuff. • Everything else is good old HTML.Everything else is good old HTML.
There are three different Java classes here.There are three different Java classes here.• They are all in the package multiEventTestThey are all in the package multiEventTest• multiEventBean.java is just a bean with typical get/set multiEventBean.java is just a bean with typical get/set
methods.methods.• Listener1.java and Listener2.java implement the Listener1.java and Listener2.java implement the
javax.faces.event.ActionListener interface.javax.faces.event.ActionListener interface. All 3 classes are called when you click the command All 3 classes are called when you click the command
button.button. Also, take a look at <inputText>. This is roughly Also, take a look at <inputText>. This is roughly
equivalent to <input name=“” value=“”>.equivalent to <input name=“” value=“”>.• But no name needed. JSF handles parameter names for you But no name needed. JSF handles parameter names for you
and connects them to the beans you specify. and connects them to the beans you specify. • This greatly simplifies writing generic actions.This greatly simplifies writing generic actions.
A Simple Example: HtmlDataGridA Simple Example: HtmlDataGrid<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %><%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %><%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %><%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %><f:view><f:view> <h2> This shows an example of how to use <h2> This shows an example of how to use HtmlDataTable to display some results.HtmlDataTable to display some results. </h2></h2> <h:dataTable value="#{ValueBean.itemList}" var="values" border="1"><h:dataTable value="#{ValueBean.itemList}" var="values" border="1"> <h:column><h:column> <f:facet name="header"><f:facet name="header"> <h:outputText value="Column 1"/> <h:outputText value="Column 1"/> </f:facet></f:facet> <h:outputText value="#{values.value1}"/><h:outputText value="#{values.value1}"/> </h:column> </h:column> <h:column><h:column> <f:facet name="header"><f:facet name="header"> <h:outputText value="Column 2"/> <h:outputText value="Column 2"/> </f:facet></f:facet> <h:outputText value="#{values.value2}"/><h:outputText value="#{values.value2}"/> <h:outputText value="#{values.value2}"/><h:outputText value="#{values.value2}"/> </h:column> </h:column> </h:dataTable></h:dataTable></f:view></f:view>
It Looks Like ThisIt Looks Like This
Some ExplanationSome Explanation The <h:dataTable> binds to a particular data set The <h:dataTable> binds to a particular data set
with value=“ValueBean.itemList”.with value=“ValueBean.itemList”.• ValueBean.itemList must be java.util.List, java.sql.ResultSet ValueBean.itemList must be java.util.List, java.sql.ResultSet
or similar.or similar.• The values of these lists may be beans also. The values of these lists may be beans also.
The var=“” just defines a useful internal value. The var=“” just defines a useful internal value. • Here, each entry in the list is set equal to “values”.Here, each entry in the list is set equal to “values”.• In the example, the items in the list happen to be simple In the example, the items in the list happen to be simple
beans with member variables “value1” and “value2” along beans with member variables “value1” and “value2” along with appropriate getter/setters.with appropriate getter/setters.
When you load the page, it just iterates through the When you load the page, it just iterates through the entries in ValueBean.itemList and creates the table, entries in ValueBean.itemList and creates the table, as you instructed.as you instructed.
Note again there are no loops in the actual page. Note again there are no loops in the actual page. Also, you don’t know anything about the data you Also, you don’t know anything about the data you are getting.are getting.
JSF Magic: Data ModelsJSF Magic: Data Models The M in MVC is the Data ModelThe M in MVC is the Data Model
• ““Abstract” representation of a data structure Abstract” representation of a data structure That is, not tied to the display of the data (“view”)That is, not tied to the display of the data (“view”)
JSF DataModel extension classes includeJSF DataModel extension classes include• Arrays: wrap arrays of Java objectsArrays: wrap arrays of Java objects• Lists: wraps a java.util.List of Java objectsLists: wraps a java.util.List of Java objects• Results: for JSTL’s Result object, which itself wraps SQL Results: for JSTL’s Result object, which itself wraps SQL
ResultSets.ResultSets.• ResultSets: also for JDBC, wraps the ResultsSet object directly.ResultSets: also for JDBC, wraps the ResultsSet object directly.• Scalar: Wraps an individual Java object.Scalar: Wraps an individual Java object.
Typically, these should follow Bean patterns for naming Typically, these should follow Bean patterns for naming member data and their associated getter/setters.member data and their associated getter/setters.
You can write your own specialized Data Models.You can write your own specialized Data Models.• XMLDataModel, for wrapping an XML data bean, comes to mind.XMLDataModel, for wrapping an XML data bean, comes to mind.• RSSDataModel is another that I found.RSSDataModel is another that I found.
These are associated with UIData classes in the JSF page for These are associated with UIData classes in the JSF page for display. display. • HtmlDataTable is an example.HtmlDataTable is an example.
JSF Form ValidatorsJSF Form Validators
The user interface stuff (<f:> and <h:>) The user interface stuff (<f:> and <h:>) has lots of built-in validators has lots of built-in validators • Verify that input entries are integers, Verify that input entries are integers,
doubles, etc.doubles, etc.• Verify that input entries fall within the Verify that input entries fall within the
correct range (1 to 10 in the guessNumber correct range (1 to 10 in the guessNumber example).example).
• Verify the string has the right length.Verify the string has the right length. You can extend to write your own You can extend to write your own
specialized validatorsspecialized validators
Integrating JSF and COG 4
Mehmet Nacar and Marlon Pierce
JSF for Grid Enabled HTML Widgets
• Natural program: develop Java Bean wrappers around Java COG kit, OGSA-DAI client API, SRB Jargon, etc.– Allows simple integration with JSF.
• Some issues exist– JSF only manages individual bean instances.– But grid portlets will need to manage an unknown
number of bean instances.• You may launch and monitor many different jobs.
– We need a way of scripting composite actions created out of multiple reusable actions.
COG Bean Wrappers• Recall the COG structure
– Executable tasks abstract basic grid actions and hide toolkit version differences.
– These tasks can be collected into file-based DAG workflows.
• First problem is simple: wrap tasks as beans to make them available to JSF.– GenericGridBean defines the interface
• Second problem is managing multiple individual tasks.
JSF Task Management Class Structure
Managing Multiple Grid Tasks• We must create and manage multiple beans for
each task.– That is, I submit the job four times in one session.– Similarly, we can create multiple task graph clones.
• We do this by cloning and storing each bean.• Beans have listeners and maintain state.
– Unsubmitted, submitted, active, suspended, resumed are “live”
• Stored in live repository
– Failed, canceled, completed, unknown are “dead” • Stored in archive (WS-Context or other)
• Alternative approach: use one bean that is a bean factory for GenericGridTask beans.
Managing Multiple Tasks
Task Manager
Task Bean
Task Bean 1
Task Bean 3
Task Bean 2
HashMap
Managed Beans
JSF Form
JSF
JSF
retrieve
register
Creating Task Graphs• COG Task Graphs correspond to composite
JSF Web Form actions.– Do X, Y, and then Z when user clicks the button.
• Each of these actions may be reused, but the entire action is new.
• We must do two things– Wrap the COG TaskGraphHandler with a bean
and bean manager.– Provide tag bindings for defining the custom
actions.
Constructing Task Graphs
Managed Beans
JobSubmit Bean
FileTransfer Bean
FileOperation Bean
HashMapTaskGraph Manager
TaskGraphBean
TaskGraph 1
TaskGraph 3
TaskGraph 2
JSF Request Form
JSF retrieve
JSF MonitoringForm
register
Task Submission Form
<h:panelGrid columns="3" > <h:outputText value="Hostname (*) "/> <h:inputText value="#{task.hostname}"/> </h:panelGrid> <h:panelGrid columns="3" > <h:outputText value="Provider (*) "/> <h:inputText value="#{task.provider}"/></h:panelGrid>
Corresponding JSF snippets<o:taskGraph id="myGraph" method="#{taskgraph.test}" > <o:task id="task1" method="task.create" type="FileTransfer" /> <o:task id="task2" method="task.create" type="JobSubmit" /> <o:task id="task3" method="task.create" type="FileTransfer" /> <o:taskAdd name="task1" method="taskgraph.add" /> <o:taskAdd name="task2" depends="task1" method="taskgraph.add" /> <o:taskAdd name="task3" depends="task2" method="taskgraph.add" /> </o:taskGraph>
<h:panelGrid columns="2"> <h:commandButton id="submit" value="Submit" action="#{taskgraph.submitAction}"/> <h:commandButton value="Clear" type="Reset"/> </h:panelGrid>
Task Monitoring with JSF Data Model
<h:dataTable value="#{jobData.jobs}" var="job"> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Job ID" /> </f:facet> <h:outputText value="#{job.jobId}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Submit Date" /> </f:facet> <h:outputText value="#{job.submitDate}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Finish Date" /> </f:facet> <h:outputText value="#{job.finishDate}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText style="font-weight: bold" value="Status" /> </f:facet> <h:outputText value="#{job.status}"/> </h:column> </h:dataTable>
Corresponding Java class.public class Job { private String jobId; private String status; private String submitDate; private String finishDate;}
Expressing Task Graphs with Tags
<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%><%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%><%@taglib uri="http://www.ogce.org/gsf/task" prefix="o"%>………………
<o:taskGraph id="myGraph" method="#{taskgraph.test}" > <o:task id="task1" method="task.create" type="FileTransfer" /> <o:task id="task2" method="task.create" type="JobSubmit" /> <o:task id="task3" method="task.create" type="FileTransfer" /> <o:taskAdd name="task1" method="taskgraph.add" /> <o:taskAdd name="task2" depends="task1" method="taskgraph.add" /> <o:taskAdd name="task3" depends="task2" method="taskgraph.add" /> </o:taskGraph>