Dashboard

Main Page > Development > Development documentation > Dashboard

Design

This page proposes a new feature and reviews design options

Development

This page describes a feature that's in development

Documentation

This page documents an implemented feature

Technical Requirements

The Dashboard is a web-based tool that is developed using Python-based Django MVC framework.

Functional Requirements

• provide a web-based, multi-user interface that will report on the status of system events and make it simpler to control and trigger specific micro-services.
• provide a user-friendly interface to add/edit metadata
• coordinate the read and write operations of the AIP to file storage and the syncing of metadata updates between the AIPs and the access system.
• process Consumer AIP requests
• provide statistical information about Archivematica operation
• provide preservation planning information

Release 0.7-alpha

1) Provide updates on the Archivematica processes by reading rows from the MCP 'Task' table in its MySQL dbase.

• This will likely have to happen through some kind of polling by the Django app of the MySQL database.
• One other implementation option we've discussed is having Archivematica publish a RSS/Atom feed that the Django app reads.

2) Provide notification of errors

• Can deduce from values in the Tasks table whether an error output has occured
• Will need to backtrack to MCP Task config XML file to identify the Error output directory where the files that incurred the error will be sitting

3) Interact with the the Archivematica API:

1. getListOfJobsAwaitingApproval
2. approveJob

• i.e. at certain stages in the Archivematica workflow we will stop and await the explicit approval from an archivist to trigger the next series of Archivematica tasks. So somewhere in the Django Dashboard there will be a list of jobs awaiting approval (retrieved from the Archivematica API) and then the ability for an archivist to click a button thereby approving a job and notifiying Archivematica MCP of that action (again, via the Archivematica API).

Post release 0.7-alpha

• create Accession Record & add appraisal metadata via Dashboard
• API:
  • listActiveTasks
  • taskCompleteNotification
• list/search AIP locations on archival storage (ideally a URI but will depend on chosen storage platform)
• sync access system metadata updates with matching metadata elements in AIP's METS.xml
• process AIP request
• preservation monitoring
  • list format types in storage
  • link to media-type preservation plans (URI starting with wiki-page can evolve to RDF registry)
  • notify when preservation actions required for format types
• solr index

User interface

Archivematica-dashboard-0.6.2-dev-29Nov.png

Early mockup (March 2010)

Real-time interaction

The Ajax web application model came to made the Web UI experience dynamic and asynchronous, as a replacement of the classic page-by-page web application model. However, Ajax applications don't offer a duplex communication where both client and server can send messages at any time. A new model of web applications frequently called Comet appeared providing bi-directional communications using persistent long-lasting HTTP connections between the server and the client. Comet is similar to Ajax in that it's asynchronous, but applications following the Comet model can communicate state changes on the server with almost negligible latency, which makes it suitable for monitoring or multi-user collaboration applications.

There exists different methods of implementing a Comet streaming transport, but all of them are based in existing browser features: iframe HTML element, XMLHttpRequest or script tags. Between these methods, I think that we have two candidates:

• XMLHttpRequest long polling: firstly, the browser creates an asynchronous XMLHttpRequest with a long time-out. When we receive a response, the server closes the connection and we launch another XHR request immediately afterward, waiting for a new event.
• Script tag long polling: the browser creates script HTML elements dinamically and setting their source ("src" attribute) to the location of the server, which then send back JavaScript code. Each time the script requests is completed, the browser opens a new one, just like XHR long polling design does. This method bypass the same-origin policy security mechanism implemented in modern browsers.

Alternatives

There exists other alternatives that we should consider:

• Simple polling: ...
• WebSockets: this technology is part of HTML5 and provides full-duplex communications channels over a single TCP socket between the browser and the server. The WebSocket API is being standardized by the W3C and the WebSocket protocol is being standardized by the IETF (HyBi working group). Chrome 4, Safari 5, Firefox 4 (not yet in FF3) and Opera 11 support WebSockets. However, the last two ones have disabled this protocol by default. HTML5 Labs at Microsoft interoperability group recently launched a prototype compatible with IE8 and IE9 based in Silverlight. WebSockets is a promissing technology but unfortunately in the development phase yet.
• Socket.IO: this open source product includes a client side feature detection library which is able to choose between different transports to establish realtime communications with the server: WebSocket, Adobe® Flash® Socket, Ajax long polling, etc... however, the server module was designed for Node.JS. Several implementations have been started for other languages / frameworks that are compatible with the Socket.IO client

Scalability

• classic vs ajax:
• ajax vs comet:

Deployment

See

• http://code.google.com/p/modwsgi/wiki/IntegrationWithDjango
• http://code.google.com/p/modwsgi/wiki/ReloadingSourceCode

Development

See

• http://docs.djangoproject.com/en/dev/internals/contributing/#coding-style