Bite: Workflow Composition for the Web. Presented at the ICSOC Conference 2007

Flow Composition for the Web

Francisco Curbera, Matt Duftler, Rania
Khalaf, Douglas Lovell

Presentation of the paper: Bite: Workflow composition for the web. F Curbera, M Duftler, R Khalaf, D Lovell,
Service oriented computing: fifth international conference, Springer, 2007.

Outline
• Services and resources
• Composition
• Web flows and flow scenarios
• What is next

Services and Resources
• SOA is about composition: process or structural (so far)
• SOA assumes:
– A two level development and execution environment
(atomic services, composite services)
– Two standard assembly models, BPEL, SCA
• The Web was NOT built on a composition requirement
– Assumes HTTP exists, gives clients access to resources
– And a few shared data types
• REST resources are not compositional
– Resources are information oriented: Data composition?
– But many resources have “behavior” - drive processes
• Process composition for the Web?

End-to-end deployment view in SCA
Composite

Component/Composite

Entry Component Component External
Point A B Service

Wire Wire Wire

implementation
implementation
Composite
Composite

End-to-end business logic in WS-BPEL

Process

Partner link

WSDL porttype

The value of the end-to-end view
• Beyond component oriented use/reuse, first class SOA
compositions provide an end-to-end view of composite
applications

• Supports end-to-end configuration, validation, management,
etc.

– Policy driven configuration
• Reduce errors in QoS configuration of distributed components,
ensure correctness of complete configuration
– End-to-end static analysis, at many levels
• Tools check “compatibility” of a set of composed components:
functional and non-functional
– Runtime monitoring and validation
• Uses structural/process topology to interpret monitoring information

Some interesting trends

• Web mashups
– Quickly assemble a new end-user applications by
reusing existing ones
• Process centric programming
– Adding the flow perspective to Web apps: Spring Web
Flows, continuations
• The Web (REST) interaction model making
inroads as an alternative to enterprise models
– The SOAP vs POX debate, and other uninteresting
debates

Mashups
• Mash-up is essentially a form of
Web application composition
– Google maps are consumed and
aggregated with additional
information
– Display final result on browser
– Aggregate in the client or the
server sides
– There are security issues but the
idea is simple
• Data centric
• Composition w/o a component
model!

SOA capabilities for the Web?
• How lightweight can we make it? Who is going to use it?

• Common data model?
– But we already have one – XML + mime types
– XML is already pervasive from the DB to the UI, but it is just one of the relevant data
types

• Component model?
– Reuse is nice, when it works.
– Do we need machine readable component definitions? Or just good documentation?
– Agree on component interaction primitives based on the resource model (ATOM)

• Resource composition
– Process oriented – seems unavoidable since processes already run on the Web
– Data composition – it is data model dependent, so far
– Structural composition (???) – need good use cases probably because so far Web
apps usually don’t expand many Web components

Bite – Process Composition
for the Web

Feed Aggregation

receive

fetchYahooFeed fetchBBCFeed

aggregate

sort

Resource aggregation
Relies on a well defined data
model –ATOM/RSS reply

Feed Aggregation
receive REST interaction
HTTP GET <GET name=“sort” sortOrder=“…’”/>

fetchYahooFeed fetchBBCFeed HTTP GET

HTTP GET

Call local code (no overhead):
<action name=“aggregate” target=“java:com.ibm.Aggregator”
aggregate
operation=“aggregate”>
<input value=“fetchYahooFeed”/>
<input value=“fetchBBCFeed”/>
</action>
sort

Use an extension activity:
<sort name=“sort” sortOrder=“…’”>
<input value=“fetchYahooFeed”/>
<input value=“fetchBBCFeed”/>
reply </sort>

Feed Aggregation
<process name="sortSample">
receive
<GET name="getYahooFeed“
target="'http://newsrss.bbc.co.uk/etc…'">
</GET>
fetchYahooFeed fetchBBCFeed
<GET name="getBBCFeed"
target="'http://rss.news.yahoo.com/rss/etc..'">
</GET>
aggregate
<aggregate name="aggregate">
<input value="getBBCFeed"/>
<input value="getYahooFeed"/>
sort </aggregate>

<sort name="sort">
<input value="aggregate"/>
reply
</sort>

</process>

Operational semantics
• Data links: <receivePOST name="orderRcv"
– Carry single data item by value url=“initiateCase" />
– Implies control and data
dependency
• BPEL like execution semantics <sendMail name="sendToManager" >
– Graph style (…)
– Dead path elimination and </sendMail>
associated restrictions in place
<receive-replyGET name=“MgrApproval”>
• Control links <control value=“sendToManager/>
– When a dependency is not </receive-replyGET/>
associated with data passing
– E.g. manager approval
requirement <sendMail name="sendToSupplier"
– Data variables address="orderRcv.mfrEmail[0]" …>
• Data variables <control value="MgrApproval"/>
– Can be combined with data flows <input value="orderRcv"/>
</sendMail>

A unified flow model
• Bite supports two flow scenarios for the
Web:

– Data flows, where aggregation of
feeds is the main model.

– Interactive flows, where a flow drives
a set of Web centric interactions

– Any combination of the two – we
believe it does make sense to combine
data and interaction flows.

Another feed aggregation
GET FEED GET FEED

Fetch price and Fetch customized
availability updates catalog

Customized catalog
and prices

A document pipeline model

Adding interaction capabilities

Plus primitives to encode
business logic

Bite: language constructs
Interaction activities Notes
<receiveGET>, <replyGET>, Also *POST. Receiving and replying to messages coming
<receiveReplyGET> over HTTP. Contain a relative URL attribute used to match
an incoming message.
<GET> <PUT> Sending HTTP requests
<POST> <DELETE>
Non interactive steps
<action> Call local code
<wait> <empty> <terminate> Utility activities
Control primitives
<while> <foreach> Iteration
<control> Control link.
<input> Data dependency that serves as a control link as well if
the value is an activity

ATOM Publication Protocol
Atom collection Resources

GET resource POST to collection URI (new)
GET collection resource, returns resource URI
List of resources in DELETE to resource URI
ATOM envelope eliminates

Bite processes as resources
Deployed Bite process Process instances

[GET resource POST to collection (new)
[GET collection: Management] process instance
Management only] DELETE instance: termination
Regular termination is implicit

Collection is an implicit
process instance Note: many resources
factory may be hierarchically
associated to a process
instance

Resource oriented model
lifecycle
GET collection: POST to collection:
Runtime management Deploys new model

Deployed model collection Process models

Deployed Bite process

...

...

Data models in Bite
• Feed composition only requires support for one (two) models
– ATOM (RSS)

• The Web is designed to support an extensible set of data models
– MIME types
– HTML, XML, JSON, forms, etc.

• Web flows demand more flexibility: pluggable and dynamically
adaptable datamodel for supporting different:
– content types
• XML, Form content, URL-encoded parameters, JSON, JSON-RPC, text,
…
– expression languages for data selection and query
• Javascript, XPath, …

Extensible activity set
• Extensible tag libraries for high-level, <aggregateFeeds>
highly-reusable primitives: <input name=“feed1”>
– Community-based <input name=“feed2”>
– User-defined: binds XML syntax to code. …
</aggregate>
• Enable new activity types to be defined <email subject=“”>
directly in the syntax <to>…</to>
– Similar to ‘ant’, JSPs, etc … <cc>…</cc>
<input…/>
• Steps: <control …/>
– Register handler that read/writes/invokes </email>
– Optionaly provide human readable description
for users.
• Does NOT require:
– Write XML Schemas, fancy tools, etc ..

• Implementation not yet released

The WS-* overhead in Bite
• Not ready to pay the price? Keep it simple

– Script-like approach to data typing (versus strongly typed
interfaces)
• Usage implies definition
• Errors happen, focus is on short development cycle, typing is optional
– Standard HTTP interfaces (application defined interfaces)
• External interactions are resource centric + eMail ☺
– Single protocol – HTTP (extensible protocol set)
• All you need – ok, maybe email also.
– HTTP defines all your interactions QoS (extensible,
declarative policies)
• That gets you a long way
– One tool required: a text editor (many complex tools required
to manage all required artifacts)
• Fancier tools are available for the typing challenged

What is available now
1. Language specification
Extensive documentation – User Guide, Programming
Guide
2. Full runtime implementation
Currently on ProjectZero.org: tightly architected
according to Zero principles
Positions flow model as an extension of the basic Zero
programming model
3. Tools:
Deployment and management interface
Browser based Delivered with Zero Launch

http://www.ProjectZero.org/

What is next
• Bite profiles through extensibility
– Define new activity sets to capture typical steps in
focused use cases:
• Feed manipulation
• Complex user interaction – full browser support
• Core flow QoS: persistence, recovery
– What is the right way to expose these capabilities
• Composite applications beyond flows

Conclusions
• There is significant value in the PM in the
large approach
– Which need not be limited to the enterprise
application space
• Web application development is slowly
enabling a “service” approach to
development
– Reusing large granularity services
– How far will it go?
• A challenge and an opportunity for the SOC
community

Composition takes place all over
– in different models
al data
Relation
comp osition
Business
Web Container Logic Container

HTTP/REST Connectors

Local or remote
Calls (IIOP,
SOAP?)
Browser
Po Database
rta
lc ion
om s it
po
po om
sit tc
io Ne
n a /.
Jav

SOA Composition taking over
the middle tiers
al data
Relation
comp osition
Business


Local or remote
Calls (IIOP,
SOAP?)
Browser
Po Database
rta
lc ion
om s it
po
po om
sit tc
io Ne
n a /.
Jav

Composition coming to the
browser
al data
Relation
Browser mas
h-ups comp osition
Business


Local or remote
Calls (IIOP/SOAP?)
Browser
(Javascript/XML) Po Database
rta
lc A
om
po /SO
sit HP ition
a /P s
io n Jav mpo
co

Process-centric programming
is already here
• Method and page oriented programming has dominated the Web
– And most enterprise programming models
• Result is that end-to-end character of a process is lost
– Factored out into a set of separate PHP pages, servlets, session beans. Or have to
go through an MVC framework
– Business and compositional logic get fragmented
– It becomes hard to capture the end-to-end logic of an application, hard to track and
manage
• The focus of successful frameworks and languages has been in easing the
DB to HTML access
– PHP, Ruby on Rails
– Integration is improved across tiers but business logic integration is neglected
• Process centricity is well accepted in the enterprise in the form of WfMSs,
modeling tools etc.
– But is has barely made an impact on Web programming

Successful Web Frameworks
focus on data and presentation
al data
Relation
comp osition

PHP, Rails

Language
HTTP/REST specific
Connectors

Browser
Database

Com
pag positi
e ag on i
gre s
gat
io

Continuations in Cocoon -
JavaScript
function sellItem() { <form method="post"
(...) action="continue.#{$cocoon/
var url = "page/getRateAmt"; continuation/id}">
cocoon.sendPageAndWait(url); <para>Enter Rate:
rate = <input type="text“
cocoon.request.getParameter("rate"));
name="rate"/></para>
qty =
cocoon.request.getParameter("qty")); <para>Enter Quantity:
(...) <input type="text"
url="page/getZone"; name="qty"/></para>
cocoon.sendPageAndWait(url,...); <input type="submit"
zone=cocoon.request.getParameter("zo name="submit"
ne"); value="Next"/>
(...)
</form>
Source: http://www-128.ibm.com/developerworks/library/j-contin.html

Continuations
• Also available in: • BPEL’s pick is the real thing:
– Cocoon for Java <pick>
sendPageAndWait(url); <onMessage partnerLink="buyer“
... >
– Ruby 
cont.call </onMessage>
<onMessage partnerLink="buyer“
– Jetty 6 ... >

</onMessage>
<onAlarm>
<for>'P3DT10H'</for>

</onAlarm>

Process style applications
• Continuations enable low • Persistent continuations:
overhead flow-like – Continuations as persistent Web
programming. resources
– While not assuming thread • Concurrency
programming or consuming – Solutions (Java threads for
resources unnecessarily example) are usually too
– No need to deal with resource complex, require managing
contention resource contention
• With obvious limitations: – A native process model – flow or
– No concurrency structured- is likely to be much
– No persistence more usable
– Unclear how to guarantee • Transactional flows
consistent outcomes – no – Sure, but who really needs that!
transactional model
• How much of this is really
needed
– And how much can we deliver

Groovy DSL Example
package samples.feedsgroovy;

import com.ibm.splice.scripting.*;

def flow() {
def builder = new FlowBuilder(writer);
builder.process( name:"feedGroovyExample") {
receiveGET( name:"rssRcv", url:"getFeeds")
GET( name:"getYahooFeed",
target:"'http://newsrss.bbc.co.uk/rss/newsonline_uk_edition/world/rss.xml'") {
control( source:"rssRcv")
}
GET( name:"getBBCFeed", target:"'http://rss.news.yahoo.com/rss/topstories'") {
control( source:"rssRcv")
}
aggregate3( name:"aggregateFeeds" ) {
input( value:"getBBCFeed")
input( value:"getYahooFeed")
}
sort3( name:"sortFeeds") {
input( value:"aggregateFeeds")
input( value:"rssRcv_Output.sortOrder")
}
replyGET( name:"rssRply", url:"getFeeds") {
input( value:"sortFeeds")
}
}
}

The SCA implicit runtime
model
Portal Service Business-to-Business Interactions

Enterprise Service Bus:
Transform, Route, Notify, Augment, Side Effect

Workflow Enterprise Script, POJO, Stateless Distinguished
Business Activity Information System Session Bean Services
Adapter
Information Mgmt
XML Database

Bite: Workflow Composition for the Web. Presented at the ICSOC Conference 2007

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Bite: Workflow Composition for the Web. Presented at the ICSOC Conference 2007

Similar a Bite: Workflow Composition for the Web. Presented at the ICSOC Conference 2007 (20)

Último

Último (20)

Bite: Workflow Composition for the Web. Presented at the ICSOC Conference 2007