Manakin An XMLdriven interface to DSpace

1
ManakinAn XML-driven interface to DSpace

• By Alexey Maslov
• 6/16/2006

2
DSpace in general

• A digital library tool useful for storage,
  maintenance, and retrieval of digital documents
• Two types of interaction
• Command line
• Automatically generated user interface

3
The standard DSpace Interface

• https//dspace.mit.edu/index.jsp
• http//txspace.tamu.edu/
• Automatically created upon installation and
  deployment
• Fully functional from the onset
• Dynamically generated through interaction between
  Java Servlets and Java Server Pages

4
The original DSpace Interface Architecture

• HTTP Request
• Tomcat identifies the Java servlet
• Java Servlets
• Processes form data
• Determines flow control
• Invokes the JSP Manager
• JSP Manager
• Calls and applies the JSP pages
• JSP Pages
• Create the HTML
• HTTP Response
• Transmits HTML to the user

5
Editing The JSPs

• The JSPs are stored in the DSpace source
  directory under the /jsp subdirectory
• They can be edited by
• Copying the .jsp file to be edited into the
  /jsp/local subdirectory
• Modifying it as needed
• The changed JSP will override the one that came
  with the installation

6
Issues with the JSP DSpace Interface

• JSP pages create the HTML directly, in most cases
  complete with the styling information.
• There is a one to one mapping of JSPs to DSpace
  pages, so changes to all DSpace pages require
  modification of all JSPs. This leads to
  maintenance problems in the long run.
• Creating a unique look and feel for a particular
  set of communities or collections is difficult.
• Most adopters of DSpace do not modify the UI
  extensively.
• http//txspace.tamu.edu/

7
An XML-based UI solution

• DSpace XML UI was developed to address the issues
  associated with the JSP based UI
• Allows easy application and modification of a
  repository-wide look and feel
• Allows each collection and community to maintain
  a look and feel that is distinct from the one
  used by the rest of the repository
• Separates business logic from stylistic design
• The first version of XMLUI, called Moa, was
  created in 2004 and has since then undergone
  several major revisions.
• The second version of XMLUI, called Manakin, was
  created as a result of those revisions and is
  currently under development.

8
XML UI Architecture

• HTTP Request
• A request for a DSpace page is received and sent
  off to content generation
• Content Generation
• The business logic of DSpace
• Interacts with the DSpace API
• Creates an XML representation of the requested
  DSpace page
• Style Application
• Converts the DSpace page from the XML
  representation into a user-readable format
• Performs further styling on the processed XML
  document
• Final Output
• Transmits the result to the user

HTTP Request
Content Generation
XML Document
Style Application
Processed XML Document
Final Output
9
JSPUI vs. XMLUI

• The fundamental difference between the JSP-based
  UI and the XML-based one is the separation of
  content and presentation done by the latter.
• Content generation in JSPUI is perfomed by
  interaction of Java servletts and JSP pages. Its
  end result is the HTML that will be sent to the
  browser.
• Content generation in XMLUI is currently handled
  by Cocoon-based Aspects. Its end result is an XML
  document that contains all the information
  necessary to build a DSpace page, but none of the
  visual formatting
• Styles Application is then performed on the XML
  document in a generic fashion, converting the XML
  into HTML and imparting a specific look and feel
  upon it. Style Application is handled by Themes.
• The XML document exchanged between Aspects and
  Themes is encoded in schema that is understood by
  both

10
A word on XML

• XML, or eXtensible Markup Language, is a data
  encoding format.
• Proper use of XML markup imparts hierarchical
  structure onto the data.
• An XML document that is properly marked up
  (following nesting rules and naming restrictions)
  is said to be well-formed.
• However, an XML document, well-formed or
  otherwise, does not actually do anything on its
  own.

11
XML schemas

• XML schemas dictate the structure that a
  particular XML document adheres to, allowing that
  XML document to be used for storage and exchange
  of information.
• An XML document that is well-formed and follows
  the constraints set by its chosen schema is said
  to be valid.
• There are many examples of XML schemas
• XHTML
• TEI
• SOAP
• SVG
• METS, MODS, Dublin Core
• XSL
• XSD, RNG

12
Digital Repository Interface Schema

• In Manakin the XML Document that is created
  during the Content Generation stage is encoded in
  a schema called Digital Repository Interface, or
  DRI.
• The DRI document serves as a representation of a
  DSPace page, being able to encode its structure,
  content and metadata.
• Since both Aspects (which generate the content)
  and Themes (which interpret and style that
  content) understand the DRI schema, it servers as
  a protocol between them.
• Additionally, the DRI schema is used internally
  between Aspects during content generation.

13
Digital Repository Interface Schema
14
Manakin XML UI Architecture

• HTTP Request
• A request for a DSpace page is received and sent
  off to content generation
• Content Generation (Aspects)
• Processes the request
• Uses the Aspect Chain to Generate a DRI document,
  an XML representation of the requested DSpace
  page
• Style Application (Themes)
• Converts the DSpace page from the DRI XML
  representation into a user-readable format via
  XSLT
• Performs further styling on the processed
  document using CSS
• Final Output
• Transmits the result to the user

HTTP Request
Content Generation
DRI XML Document
Style Application
Processed and styled Document
Final Output
15
Content Generation

• Processes the request and generates the content
  of the requested page.
• Can be performed via variety of programming
  tools
• Moa (XML UI v1) used Java Servlets and a
  DOM-based approach
• Manakin (XML UI v2) uses the Cocoon XML framework
  and a SAX-based approach
• Currently involves a process called Aspect
  chaining to incrementally generate the content
  of the requested DSpace page.
• The end result is a XML document, encoded in the
  DRI schema, that contains all the content,
  structure and metadata necessary to render the
  DSpace page, but none of the visual styling.
• Dspace page as an XML document encoded in DRI
  schema

HTTP Request
Content Generation
Style Application
Final Output
16
Aspect Chaining

• Manakin uses autonomous sets of Cocoon components
  called Aspects to generate the XML document.
• Each Aspect is responsible for a particular
  feature of the requested page and several Aspects
  can be chained together to produce a complete
  page.
• The chain is started off with a DRI
  Protodocument, an XML document that does not yet
  have any content, but still conforms to the DRI
  schema.
• Each Aspect receives a DRI-encoded XML document
  as input, adds in its content and passes the
  resulting XML document (also DRI-encoded) to the
  next aspect in the chain.
• The chain is completed when the last Aspects adds
  in its data and sends the completed DRI document
  to the Styling step.

HTTP Request
Content Generation
Generate Protodocument
DRI Document
Apply Aspects
Apply Aspects
Apply Aspects
DRI Document
Style Application
Final Output
17
Style Application

• Once Content Generation is complete and the DRI
  Document is created a Theme is chosen to perform
  the Style Application step.
• A themes purpose is to convert the DRI document
  to a user-readable format (like HTML) and style
  it with its own look and feel.
• Different Themes can be configured to apply to
  different set of pages, from the entire
  repository, to a specific community or
  collection, and even to individual items.
• Since the DRI Document contains all the
  information about the DSpace page, including
  structure, content and metadata, themes have a
  lot of power in determining the final look and
  feel of the page.
• Dspace page as an XML document encoded in XHTML
  schema

HTTP Request
Content Generation
Style Application
Final Output
18
Theme processing

• A theme work in two stages
• First it converts the XML Document from the DRI
  schema to final output format, most commonly
  XHTML
• Second, it performs visual styling of the
  resulting document
• Step 1 is currently performed by XSL templates,
  but could be performed by any XML processing tool
  like STX, XPathScript, or even a Java program.
• Step 2 is currently performed by Cascading Style
  Sheet rules, but could be performed by other
  tools or omitted depending on the output of the
  XSL step.
• The result is a document that possesses a
  specific look and feel and is ready for viewing.
• Final output of a DSpace page as processed by
  Manakin

HTTP Request
Content Generation
DRI Document
Style Application
Theme Selection
XSLT Processing
HTML Document
CSS styling
Final Output
19
Manakin-specific overview

• Aspect Tier fundamental changes/additions to the
  content and structure of a DSpace page
• XSLT Tier major changes to structure and layout
  as well as minor changes/additions to content
• CSS Tier presentation and layout of the final
  result

20
Conclusion

• Most of the visual changes are done in CSS
• XSLT templates can also be overridden to make
  structural and content modifications
• The theme manager can be configured to apply
  certain themes to specific DSpace components
• Finally, aspects can be added to the aspect chain
  to introduce new content to existing DSpace
  pages.
• http//dev.di.tamu.edu8039/dspace-xmlui/

21
Useful Links

• XML Tutorial
• http//www.w3schools.com/xml/default.asp
• HTML Tutorial
• http//www.w3schools.com/html/default.asp
• CSS Tutorial
• http//www.w3schools.com/css/default.asp
• XSLT Tutorial
• http//www.w3schools.com/xsl/default.asp
• Apache Cocoon Project
• http//cocoon.apache.org/

22
Questions?