Basic Standards for Web Services CS 696 – Services Computing Fall 2008

1. Basic Standards for Web Services CS 696 – Services Computing Fall 2008 Chapter 2: Service-Oriented Computing: Semantics, Processes, Agents– Munindar P. Singh and Michael N. Huhns, Wiley, 2005

2. Highlights of this Chapter • eXtensible Markup Language (XML) • Simple Object Access Protocol (SOAP) • Web Services Description Language (WSDL) • Directory Services • Universal Description, Discovery, and Integration (UDDI)

3. Standards for Web Services

4. XML Web Service Foundation Open and with broad industry support • Publish, Find, Use Services • UDDI • Service Interactions • SOAP • Universal Data Format • XML • Description Language • WSDL • Ubiquitous Communications • TCP/IP, HTTP, SMTP, SIP, Reliable messaging • Security (authentication and authorization) • WS-Security, SAML

5. Markup History • None, as in comma separated values • Ad hoc tags • SGML (Standard Generalized Markup L): complex, few reliable tools • HTML (HyperText ML): simple, unprincipled, mixes structure and display • XML (eXtensible ML): simple, yet extensible subset of SGML to capture new vocabularies • Machine processible • Comprehensible to people: easier debugging

6. Brief Introduction to XML • Basics • Parsing • Storage • Transformations

7. XML Basics and Namespaces <?xml version="1.0"?> <!– not part of the document per se  <arbitrary:toptag xmlns=“http://one.default.namespace/if-needed” xmlns:arbitrary=“http://wherever.it.might.be/arbit-ns”      xmlns:random=“http://another.one/random-ns”>      <arbitrary:atag attr1=“v1” attr2=“v2”> Optional text also known as PCDATA <arbitrary:btag attr1=“v1” attr2=“v2” /> </arbitrary:atag> <random:simple_tag/> <random:atag attr3=“v3”/> <!–compare with arbitrary:atag  </arbitrary:toptag>

8. XML Example <?xml version="1.0"? Encoding=‘UTF-8’?> <temperature scale=“Celsius”>      <value>25</value> <accuracy>2</accuracy> <ambience condition=“shade”/> </temperature>

9. XML Example <?xml version="1.0"?> <temperature accuracy=“2” scale=“Celsius”> 25 <ambience condition=“shade”/> </temperature>

10. HTML Example of same data <TABLE BORDER=1> <TR>      <TH>Value</TH>      <TH>Accuracy</TH>      <TH>Scale</TH>      <TH>Ambience Condition</TH> </TR> <TR> <TD>25</TD> <TD>2</TD> <TD>Celsius</TD> <TD>Shade</TD> </TR> </TABLE>

11. XML Query Languages • XPath • XPointer • XSLT • XQuery

12. XPath • Model XML documents as trees with nodes • Elements • Attributes • Text (PCDATA) • Comments • Root node: above root of document

13. XPath • Parent in XPath is like parent as traditionally in computer science • Child in XPath is confusing: • An attribute is not the child of its parent • Makes a difference for certain kinds of recursion (e.g., apply-templates discussed in XSLT)

14. XPath Paths • Leading /: root • /: indicates walking down a tree • .:current node • ..:parent node • @attr: to access values for the given attribute • text() • comment()

15. XPath Navigation • Select children according to position, e.g., [j], where j could be 1 … last() • Descendant-or-self operator, // • .//elem finds all elems under the current • //elem finds all elems in the document • Wildcard, *: • @*: finds all attribute values

16. XPath Queries • Incorporate selection conditions in XPath • Attributes: //Song[@genre=“jazz”] • Elements: //Song[starts-with(.//group, “Led”)] • Existence of attribute: //Song[@genre] • Existence of subelement: //Song[group] • Boolean operators: and, not, or • Set operator: union (|); none others • Arithmetic operators: >, <, … • String functions: contains(), concat(), length(), • Aggregates: sum(), count()

17. XPointer • Combines XPath with URLs • URL to get to a document; XPath to walk down the document • Can be used to formulate queries, e.g., • Song-URL#xpointer(//Song[@genre=“jazz”])

18. XSLT • A functional programming language • A stylesheet specifies transformations on a document <?xml version=“1.0”?> <?xml-stylesheet type=“text/xsl” href=“URL-to-dot-xsl”?> <!– the sheet to use  <main-tag> … </main-tag>

19. XSLT Stylesheets • Use the XSLT namespace, conventionally abbreviated as xsl Includes primitives: • Copy-of • <for-each select=“…”> • <if test=“…”> • <choose >

20. XML file referencing XSL stylesheet <?xml version=“1.0”?> <?xml:stylesheet type=“text/xsl” href=“TempTable.xsl”?> <TempCollection>     <temperature scale=“Celsius”>      <value>25</value>      <accuracy>2</accuracy>     </temperature> <temperature scale=“Kelvin”>      <value>123</value>      <accuracy>5</accuracy>     </temperature> <temperature scale=“Fahrenheit”>      <value>32</value>      <accuracy>1</accuracy>     </temperature> </TempCollection>

21. Stylesheet (TempTable.xsl) <xsl:Stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”> <xsl:template match=“/”> <HTML> <BODY> <xsl:apply-templates /> </BODY> </HTML> </xsl:template> <xsl:template match=“TempCollection”> <TABLE BORDER=“2”> <TR> <TH>Value</TH>      <TH>Accuracy</TH>      <TH>Scale</TH> </TR> <xsl:apply-templates/> </TABLE> </xsl:template> <xsl:template match=“temperature”> <TR> <TD><xsl:value-of select=“value”/></TD> <TD><xsl:value-of select=“accuracy”/></TD> <TD><xsl:value-of select=“@scale”/></TD> </TR> </xsl:template> </xsl:stylesheet>

22. XSLT Templates: 1 • A pattern to specify where a given transform should apply • This match only works on the root: <xsl:template match=“/”> … </xsl:template>

23. XSLT Templates: 2 • Can be applied recursively on the children via <xsl:apply-templates/> • By default, if no other template matches, recursively apply to children of current node (ignores attributes) and to root: <xsl:template match=“*|/”> <xsl:apply-templates/> </xsl:template>

24. Parsing and Validating • An XML document maps to a parse tree. • Each tag ends once: nesting structure (one root) • Each attribute occurs at most once; quoted string • Well-formed XML documents can be parsed • Applications have an explicit or implicit syntax for their particular XML-based tags • If explicit, may be expressed in DTDs and XML Schemas • Best referred to definitions elsewhere • XML Schemas, expressed in XML, are superior to DTDs • When docs are produced by external components, they should be validated

25. DTD (Document Type Definition) Example <?xml version="1.0"? Encoding=‘UTF-8’?> <TempCollection> <temperature scale=“Celsius”>      <value>25</value> <accuracy>2</accuracy> <ambience condition=“shade”/> </temperature></TempCollection> <?xml encoding="UTF-8"?> <!ELEMENT TempCollection (temperature)+> <!ELEMENT temperature (value, accuracy,ambience)> <!ELEMENT value (#PCDATA)> <!ELEMENT accuracy (#PCDATA)> <!ELEMENT ambience (#EMPTY)> <!ATTLIST temperature scale (Celsius|Fahrenheit|Kelvin) #REQUIRED> <!ATTLIST ambience condition CDATA “shade”> • #PCDATA – Parsed Character data, can contain markup • CDATA – Character data, is not parsed for markup

26. XML Schema • A data definition language for XML: defines a notion of schema validity; helps us define desired grammars for documents • Same syntax as regular XML documents • Local scoping of subelement names • Incorporates namespaces • Types • Primitive (built-in): string, ID, IDREF, integer, float, date, • simpleType constructors: list, union • Restrictions: intervals, lengths, enumerations, regex patterns, • Flexible ordering of elements • Key and referential integrity constraints

27. XML Schema example <?xml version=“1.0”?> <xsd:schema xmlns:xsd=“http://www.w3.org/2001/XMLSchema” … > <xsd:element name="TempCollection"> <xsd:complexType> <xsd:sequence> <xsd:element ref="temperature" minOccurs="1" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="temperature"> <xsd:complexType> <xsd:sequence> <xsd:element ref="value" minOccurs="1" maxOccurs="1"/> <xsd:element ref="accuracy" minOccurs="1" maxOccurs="1"/> </xsd:sequence> <xsd:attributeGroup ref="TempAttributes"/> </xsd:complexType> </xsd:element>

28. XML Schema example <xsd:attributeGroup name="TempAttributes"> <xsd:attribute name="scale" use="required"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:pattern value="Celsius"/> <xsd:pattern value="Fahrenheit"/> <xsd:pattern value="Kelvin"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:element name="value" type="xsd:integer"/> <xsd:element name="accuracy" type="xsd:nonNegativeInteger"/> </xsd:schema>

29. XML Schema: complexType • Specifies types of elements with structure: • Must use a compositor if > 1 subelements • Subelements with types • Min and max occurrences (default 1) of subelements

30. XML Schema: Compositors • Sequence: ordered • Can occur within other compositors • Allows varying min and max occurrence • All: unordered • Must occur directly below root element • Max occurrence of each element is 1 • Choice: exclusive or • Can occur within other compositors

31. XML Schema: Key Namespaces • http://www.w3.org/2001/XMLSchema • Conventional prefix: xsd • Terms for defining schemas: schema, element, attribute, … • The tag schema has an attribute targetNamespace • http://www.w3.org/2001/XMLSchema-instance • Conventional prefix: xsi • Terms for use in instances: schemaLocation, null • targetNamespace: user-defined

32. XML Schema Instance Doc <Music xmlns=http://a.b.c/Muse xmlns:xsi=“the standard-xsi” xsi:schemaLocation=“a-schema-as-a-URI a-schema-location-as-a-URL”> … </Music>

33. Creating Schema Docs: 1 <schema xmlns=“the-standard-xsd” targetNamespace=“the-target”> <include schemaLocation=“part-one.xsd”/> <include schemaLocation=“part-two.xsd”/> </schema>

34. Creating Schema Docs: 2 • Use imports instead of include • Specify namespaces from which schemas are to be imported • Location of schemas not required and may be ignored if provided

35. Document Object Model (DOM) • Basis for parsing XML, which provides a node-labeled tree in its API • Conceptually simple: traverse by requesting tag, its attribute values, and its children • Processing program reflects document structure • Can edit documents • Inefficient for large documents: parses them first entirely to build the tree even if a tiny part is needed

36. DOM Example [Simeoni 2003] Element s = d.getDocumentElement(); NodeList l = s.getElementsByTagName(“member”); Element m = (Element) l.item(0); int code = m.getAttribute(“code”); NodeList kids = m.getChildNodes(); Node kid = kids.item(0); String tagName = ((Element)kid).getTagName(); …

37. Simple API for XML (SAX) • Parser generates a sequence of events: • startElement, endElement, … • Programmer implements these as callbacks • More control for the programmer • Processing program does not reflect document structure

38. SAX Example [Simeoni 2003] class MemberProcess extends DefaultHandler { public void startElement (String uri, String n, String qName, Attributes attrs) { if (n.equals(“member”)) code = attrs.getValue(“code”); if (n.equals(“project”)) inProject = true; buffer.reset(); } public void endElement (String uri, String n, String qName) { if (n.equals(“project”)) inProject = false; if (n.equals(“member”) && !inProject) name = buffer.toString().trim(); } }

39. Programming with XML • Current approaches concentrate on structure but ignore meaning • Difficult to construct and maintain • Treat everything as a string • Inadequate type checking can hide errors • Emerging approaches (e.g., JAXB) provide superior binding from XML to programming languages • Primitives such as unmarshal to materialize an object from XML

40. Uses of XML • Exchanging information across software components • Storing information in nonproprietary format • XML documents represent structured descriptions: • Products, services, catalogs • Contracts • Queries, requests, invocations (as in SOAP) • Data-centric versus document-centric (irregular, heterogeneous data, depend on entire doc for app-specific meaning) views

41. Data-Centric View <relation> <tuple><attr1>V11</attr1>… <attrn>V1n</attrn></tuple> … <tuple><attr1>Vm1</attr1>… <attrn>Vmn</attrn></tuple> </relation> • Extract and store into DB via mapping to DB model • Regular, homogeneous tags • May be expensive if repeatedly parsed and instantiated

42. Document-Centric View • Storing docs in DBs • Use character large objects (clobs) within DB • Store paths to external files containing docs • Combine with some structured elements with search conditions for both structured elements and unstructured clobs or files • Heterogeneity also complicates mappings to traditional typed OO programming languages

43. Directions • Limitations of XML • Doesn’t represent meaning • Enables multiple representations for the same information; transform if models known • Trends: sophisticated approaches for • Querying and manipulating XML, e.g., XSLT • Binding to PLs and DBs • Semantics, e.g., RDF, DAML, OWL, …

44. XML Summary • XML enables information sharing • XML is well established • Several aspects are worked out • Lots of tools • Works with databases and programming languages • XML provides a useful substrate for service-oriented computing

45. Web Services: Basic Architecture Service Broker Registry; well-known Publish or announce (WSDL) Find or discover (UDDI) Service Provider Service Requestor Bind or invoke (SOAP) Not well-known

46. Basic Profile (BP 1.0) • The Web Services Interoperability Organization (WS-I) has specified the following Basic Profile version 1.0: • SOAP 1.1 • HTTP 1.1 • XML 1.0 • XML Schema Parts 1 and 2 • UDDI Version 2 • WSDL 1.1

47. Describing a Service • Namee.g., GetTemperature • Types of Input Parameterse.g., (String, String) • Types of Output Parameterse.g., Integer

48. Interactions Via Methods Via Messages CatalogService() invoke catalog Purchasing() confirmation # invoke Order()

49. SOAP (Simple Object Access Protocol) • Used to exchange messages via HTTP, SMTP, and SIP (Session Initiation Protocol for Internet telephony) • Originally designed for remote-procedure calls (RPC) • Works through firewalls on port 80 • Character-based, so easy to encrypt/decrypt and thus easy to secure • Inefficient due to character, not binary, data and large headers • Does not describe bidirectional or n-party interaction

50. Ex. SOAP Request POST /temp HTTP/1.1 Host: www.socweather.com Content-Type: text/xml; charset="utf-8" Content-Length: xxx SOAPAction: "http://www.socweather.com/temp" <!-- The above are HTTP headers --> <?xml version=“1.0”?> <env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/> <env:Body> <m:GetTemp xmlns:m="http://www.socweather.com/temp.xsd"> <m:City>Honolulu</m:City> <m:When>now</m:When> </m:GetTemp> </env:Body> </env:Envelope>