CapeDwarf - JBoss Community

CapeDwarf: Running Google App Engine apps in JBossAS7

Deploy and run your Java App Engine applications on your own private JBoss Application Server (AS7) cluster or on RedHat’s OpenShift cloud.

JBoss CapeDwarf is an implementation of the Google App Engine API, which allows applications to be deployed on JBoss Application Servers without modification. Behind the scenes, CapeDwarf uses existing JBoss APIs such as Infinispan, JGroups, PicketLink, HornetQ and others.

The ultimate goal of the CapeDwarf project is to fully implement all the APIs of the Google App Engine.

AppIdentity API The AppIdentity API allows your application to assert its identity when making requests to either Google’s or third-party external systems.
CapeDwarf’s implementation currently only supports signing requests for external non-Google systems.

Blobstore API The Blobstore API allows your application to store and serve large data objects (containing either text or binary data). Compared to the Datastore API, where the size of the data is constrained, the Blobstore API imposes no such constraints on the size of the stored data objects.
The Blobstore API uses GAE’s Files API. CapeDwarf’s implementation of the Files API is implemented on top of Infinispan’s GridFileSystem, which is an API that exposes an Infinispan-backed data grid as a file system.

Capabilities API In Google AppEngine, your application can detect outages and scheduled downtime for specific API capabilities through the Capabilities API. Currently, CapeDwarf contains only a stub implement of the Capabilities API. It simply returns the ENABLED status for every capability.

Channel API The Channel API allows your Google AppEngine application to push messages from the server to the web client. This is useful for applications that must update the client immediately when new information is available (such as when a user sends a chat message to another user of a web chat application).
CapeDwarf currently contains only an initial implementation of the Channel API.

Datastore API The App Engine Datastore is a schema-less persistent data storage API, allowing applications to store, retrieve and query data. The Java Datastore SDK includes implementations of the Java Data Objects (JDO) and Java Persistence API (JPA) interfaces, as well as a low-level Datastore API.
CapeDwarf’s implementation of the Datastore API is based on Infinispan. Infinispan is an extremely scalable, highly available data grid platform - 100% open source, and written in Java. Querying is implemented through Infinispan’s Query module, which adds querying capabilities to Infinispan. It uses Hibernate Search and Lucene to index objects as they are stored in the cache.

Files API The Files API provides a service for file storage and access. The Files API is used by the Blobstore API.
CapeDwarf implements the Files API through Infinispan's GridFileSystem, which is an API that exposes an Infinispan-backed data grid as a file system.

Images API Google App Engine provides the ability to manipulate image data using a dedicated Images service. The Images service can resize, rotate, flip, and crop images. It can also enhance photographs using a predefined algorithm.
CapeDwarf currently performs all the image manipulations through Java’s java.awt.image classes. All the image operations are implemented, except the “I’m feeling lucky” operation, which is currently simply a NoOp.

Logging API Everything your application logs through java.util.logging.Logger or even to System.out, is captured and stored and can be viewed through the Admin Console.
CapeDwarf currently stores all log lines as entities in the Datastore. This will be changed soon.The log lines will be stored in a persistent Infinispan cache directly instead of through the Datastore API.

Mail API App Engine applications can send email messages on behalf of the app's administrators, and on behalf of users with Google Accounts. Apps can receive email at various addresses. Apps send messages using the Mail service and receive messages in the form of HTTP requests initiated by App Engine and posted to the app.

Memcache API High performance scalable web applications often use a distributed in-memory data cache in front of or in place of robust persistent storage for some tasks. App Engine includes a memory cache service for this purpose.
CapeDwarf’s Memcache API implementation uses Infinispan as the cache.

Multitenancy API Multitenancy is achieved through the use of the Namespace API, which allows you to set a namespace for the current context. The Datastore, Memcache and other APIs consider the currently set namespace when storing or retrieving data. This allows your data to be partitioned into different namespaces, with every tenant usually having their own namespace assigned to them.