[UPDATE: Posted this yesterday for >140k requests/day, updating now with >430k requests..]

TheRealURL had a particularly busy Thanksgiving Day Black Friday for some reason. Just for curiosity’s sake, here’s the quota usage for a GAE application under a relatively high load. The quotas that aren’t pictured are all on %0. Billing is now turned on (for the Incoming Bandwidth) but limited to up to $1/day – and was never used yet.

Bear in mind this is a pretty minimal app, of course, but still – not too shabby.

Comparison between Amazon EC2 and Google GAE

Though different cloud service providers are following different strategies, these are the two uniquely different approaches. Others either are similar to one of these or fall somewhere in between.

I have excluded SaaS from this discussion – you can see the comparison between IaaS, PaaS and SaaS on this post on Cloud Strategy.

Why is GAE potentially disruptive?

• Over the last decade, Google has build a huge cloud infrastructure for its search and other services

• The infrastructure has been build using very cost effective hardware
• Fault tolerance is designed into the architecture
• They have perfected technologies and algorithms like MapReduce and BigTable created for such infrastructure
• It is highly scalable

• Google is following a strategy of opening up their infrastructure for developers to use – for example Closure JavaScript Toolset
• They will optimize cloud access through Chrome OS and Android Mobile OS

Their economy of scale will be difficult to match.

What about Microsoft – they are constrained by the fact that they have to defend their desktop business – which will prevent them from following optimal cloud strategy!

In Winter ‘10, Salesforce.com released the Apex Scheduler. This feature allows you to schedule Apex classes to run at specific times. The features appears to be widely popular (200+ votes on the IdeaExchange) but is only in limited release. I’ve heard from a number of companies that they were not able to get on the pilot. The L1 Support Rep told me that an org would need 5000+ seats to qualify for the Apex Scheduler.

Hopefully Apex Scheduler will be GA next release but in the meantime here’s a short-term solution that Kyle Roche and I were discussing last week. You can sign up for a free Google App Engine account and then schedule tasks with cron in either Java or Python.

The solution is relative straight forward and you can find all the info you need in our book Beginning Java Google App Engine. We not only cover cron jobs but have a number of examples using the Force.com for Google App Engine Java toolkit.

Pre-order your copy now just in time for Christmas. It goes nicely with eggnog and figgy pudding.

Em conferência anual, companhia aponta para foco na integração entre redes sociais, ferramentas colaborativas e aplicativos corporativos 

É praticamente inevitável para uma companhia ignorar processos de colaboração, troca de ideias, redes sociais e outras funcionalidades que vieram com o apogeu da web 2.0, ainda que a empresa não tenha aplicado essa realidade ao seu dia a dia. A indústria assiste de perto a esta movimentação ávida para encontrar uma forma de ganhar sua fatia nessa chamada evolução social. E algumas têm conseguido algum sucesso. O Google tem capitalizado com sua plataforma Google Apps que, aos poucos, amplia presença no mercado empresarial e a Salesfoce.com, uma das pioneiras na oferta de programas no modelo software como serviço (SaaS, da sigla em inglês), mostra que está com os dois pés nesta era.

Prova dessa determinação é o lançamento do Salesforce Chatter, apresentado durante o Dreamforce 2009, conferência que a companhia realiza anualmente em São Francisco, Estados Unidos, cidade onde a empresa foi fundada, e que neste ano ocorre entre os dias 17 e 20 de novembro. Trata-se de uma espécie de Google Wave, mas totalmente voltado para o mundo das corporações. Como explica a própria empresa, o Chatter é, ao mesmo tempo, uma aplicação de colaboração corporativa e uma plataforma de desenvolvimento social. Por meio de uma interface aparentemente fácil, o funcionário pode acessar um aplicativo financeiro, observar dicas, criar fóruns, acessar redes sociais compartilhadas.

CEO da Salesforce diz que produtos das rivais são lentos ou complexos e caros 

De acordo com a companhia, os 135 mil aplicativos Salesforce se converterão para a plataforma social. Para Marc Benioff, CEO e chairman da empresa, o produto é uma forma de aproximar os funcionários da empresa, já que essas pessoas passam a acessar ferramentas que encontram fora da companhia e que podem contribuir com o processo de colaboração e inovação. É uma complexa combinação, em tempo real, de ferramentas de redes familiares e aplicativos empresariais dentro de um formato de compartilhamento seguro.

“Não conheço ninguém que discorde que Twitter e Facebook sejam fenômenos e trouxeram novas possibilidades para a indústria com meio bilhão de usuários. Eu uso Facebook e Twitter”, comentou Benioff, sobre a realidade das redes, diante de uma plateia formada por milhares de pessoas (foram 19 mil inscritos) entre analistas, clientes, jornalistas e desenvolvedores. “A mágica é levar a inteligência por meio da rede social. Une conteúdo, aplicativo e pessoas no mesmo espaço. Nas empresas, isso está separado. Por que não levar inteligência para as empresas? Você tem conteúdo por meio de compartilhamento de arquivo, intranet, Lotus Notes; tem aplicativo da Salesforce, Oracle, SAP e tem pessoas que utilizam e-mail, outlook e mensagem instantânea e porque não usar tudo isso junto?”, questionou o CEO da Salesforce.

De acordo com Benioff, a colaboração por meio do Chatter será tão fácil como ocorre no Facebook e os aplicativos “conversarão com o usuário”. Em relação à segurança e privacidade, ele esclareceu que a ferramenta traz funcionalidades que permitem determinar quem tem acesso à determinada apresentação que será compartilhada na rede, quais pessoas podem ingressar em um grupo recém criado. Os filtros funcionam inclusive para os aplicativos.

Logo após a apresentação que também marcou a abertura do evento, Benioff participou de um bate-papo com jornalistas. Ele explicou que a estratégia da companhia está, sobretudo, em criar produtos que possam ser integrados. Mas adiantou que, no caso do Chatter, “o primeiro passo é colocar o produto como a próxima geração de colaboração. Não é um software de rede social, é uma plataforma de colaboração e o segundo passo é diferenciar os produtos como CRM da plataforma de integração.”

Versões atualizadas
Além do lançamento do Chatter, a Salesforce.com apresentou versões atualizadas do Sales Cloud2 e Service Cloud2. Ambos produtos receberam ferramentas colaborativas e integração com redes sociais. Tudo para facilitar o trabalho, melhorar o desempenho das companhias e deixar tudo dentro do conceito integração e colaboração.

No caso do Service Cloud, Benioff avisou que se trata de uma nova geração de serviço ao cliente e apresentou um slide com dado creditado à Frost & Sullivan que, em 2009, a Salesforce terá 55% de market share em CRM no modelo SaaS. “Os contacts center estão desconectados e os clientes estão nas redes sociais. As empresas investem em SAP, Oracle e Microsoft, mas os clientes estão em outros lugares”, provocou o executivo.

O vice-presidente de marketing da companhia, Kraig Swensrud, mostrou que a Dell, por exemplo, adotou o CRM da Salesforce, já nesta nova era e lembrou que os usuários têm, na mesma tela, acesso a todos os canais como telefone, redes sociais, e-mail e site. “O sistema é totalmente integrado. Pode saber de onde e o que as pessoas estão falando. É possível fazer filtros por perfil de clientes ou produtos, por exemplo.”

The term “Cloud Computing” has gained a lot of attention by now and the momentum seems to be rising even in 2010.Cloud Computing appears in Gartner’s list of Top 10 Strategic Technologies for 2010 and as per the report:

Cloud computing is a style of computing that characterizes a model in which providers deliver a variety of IT-enabled capabilities to consumers. Cloud-based services can be exploited in a variety of ways to develop an application or a solution. Using cloud resources does not eliminate the costs of IT solutions, but does re-arrange some and reduce others. In addition, consuming cloud services enterprises will increasingly act as cloud providers and deliver application, information or business process services to customers and business partners.

Today I started looking into Google’s offering in this space “Google App Engine“.App Engine allows to host web applications in Google Cloud infrastructure which can scale up in terms of processing and storage needs as per demand and the billing model is pay as you use.

To host the applications in App Engine the application has to necessarily comply to the technical standards and constraints enforced by the platform.So we have got the Google App Engine SDK which provides a set of libraries and utilities for developing and deploying applications in App Engine.It also provides a simulation environment where we can run the programs in developer machine before uploading them to App Engine.

As far programming languages are concerned Google App Engine SDK is currently available for the Java and Python environments.I have started looking into the Python environment to start with.

The key components of the App Engine based application is shown below:

• Web App Framework – The App Engine web server and the web application interacts based on CGI protocol.The webapp framework is a simple web application framework provided by App Engine which contains Request Handlers,Request and Response objects.The webapp is also compatible with WSGI protocol widely used by the Python web containers.It’s not mandatory to use the webapp framework other frameworks like Django can be used well in conjunction with the App Engine.
• DataStore – App Engine uses a non relational schemaless database which is suited for web applications and specifically suited for scalable read and query performance.
• API for App Engine Datastore – App Engine provide a rich set of Python API to access the datastore and also a SQL like query language called GQL.
• Services
  • Memcache – A distributed in-memory caching service
  • URL Fetch – A service for accesing services hosted in other web servers outside google app engine.
  • Mail – A service for sending/receiving email
  • Images – Service to manipulate image data like resize,rotate,flip,crop etc.
  • Google Accounts – This provides an authentication service with Google accounts.

This is all for now.In the next post I will explain the simple steps I have followed to build my first App Engine application.

Thanks to Vineet Manohar!

Please visit the following link to see step by step guide to create Java Hello World program for Google App. Engine:

Writing Java Hello World for Google app engine
http://www.vineetmanohar.com/2009/04/11/writing-java-hello-world-for-google-app-engine/

Thanks

Kashi

Note: The complete source and necessary jars are available in github here. For just downloading, unzipping and importing the project into Eclipse, press on the github site.
Important: this is a collection of projects, the relevant project for this post is gae-rest-sample and spring3-resttemplate.

Finally I succeeded in getting REST (with the new REST support in Spring 3) done in the Google App Engine.
It wouldn’t be an easy task, but thanks to one brilliant blog post, a forum post and a very helpful JIRA issue, it can be resolved just by searching.

1. The brilliant blog post about Spring REST in general by Eyal Lupu.
   This post is just a rewrite of that one, just adding the GAE-related stuff.
   All details about REST content negotiation and how the Spring MVC works with REST is explained there.
2. The forum post about problems with GAE and XStream.
   This helps to unterstand the reason for the sun.reflect.ReflectionFactory is a restricted class exception when using XStream on GAE.
3. The JIRA issue 566, which investigates the problem in more detail and provides a solution which is valid for at least the usage in this context (note the last entry).

I finally took the snapshot jar attached to the JIRA issue, which works well for the samples in this post. Nevertheless, there might still be difficulties with XStream on the GAE, so be aware.

The client

Eyal Lupu also provides a JSON-Client in his post. The client itself is straightforward – it uses the Spring RestTemplate. The JsonHttpMessageConverter uses Spring’s FileCopyUtils for InputStream String conversion which is quite cool.

Spring RestTemplate:

    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setMessageConverters(new HttpMessageConverter[]{new JsonHttpMessageConverter()});

    JSONObject result = restTemplate.getForObject("http://localhost:8080/users/.js", JSONObject.class);

    JSONArray aresult = result.getJSONArray("payload");
    for (int x=0; x<aresult.length(); ++x) {
        JSONObject currResult = (JSONObject) aresult.get(x);
        System.out.format("%-100s | %s%n", currResult.get("name"), currResult.get("lastLoggedInAt"));
    }

JSON-Unmarshaller:

	@Override
	protected JSONObject readInternal(Class<JSONObject> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
                MediaType contentType = inputMessage.getHeaders().getContentType();
		Charset charset = contentType.getCharSet() != null ? contentType.getCharSet() : Charset.forName("utf-8");
		String stringResult =  FileCopyUtils.copyToString(new InputStreamReader(inputMessage.getBody(), charset));

		JSONObject jObject;
		try {
			jObject = new JSONObject(stringResult);
		} catch (JSONException e) {
			throw new IOException (e);
		}
		return jObject;
	}

Annoyances

Here are some things I don’t understand and I had to work around.
Please comment if you know more about the problem.

1. In the web.xml, the url-pattern has to be / instead of /* (or /rest in the original sample) to get it working in the GAE
2. Usually, I would prefer having the jsp-views in /WEB-INF/*. However, this does not work in GAE (doesn’t find WEB-INF or anything below WEB-INF)

Azure. EC2. App Engine.

Do any of those names sound familiar? If so then join us for the first meeting of the McHenry Cloud Developers Group in Crystal Lake, Illinois!

Our first meeting will be an informal discussion of the goal of the group, ideas for projects and presentations. Also, we want to know what you are looking to get out of the group.

The meeting is Monday, December 14th from 7:00 PM until 8:00 PM. We’ll be meeting in the downstairs Ames-1 meeting room.

Please join us in Crystal Lake and join the projects or hang back and soak up some info!

Our first meeting will be held at the Crystal Lake Public Library.

Register here!

Directions:
Crystal Lake Public Library
126 W Paddock St
Crystal Lake, IL 60014-6194

View Larger Map

Also, we have a brand new site up. http://www.clouddevelopersgroup.com. It’s a very early draft but feel free to check it out.

The xml transaction configuration file.

<?xml version="1.0" encoding="UTF-8"?>

<beans:beans
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!-- the transactionManager is declared in the                          -->
    <!-- src/main/resources/spring/jdo-<whatever>-context.xml file.         -->
    <!-- the transactional advice; what 'happens'; used by the              -->
    <!-- <aop:advisor/> bean.                                               -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- for read only, propagation=NOT_SUPPORTED suspends any      -->
            <!-- current transaction, if there is one. I.e., read only      -->
            <!-- queries are run without a transaction.  With this,    -->
            <!-- we can do queries on multiple unowned entities.            -->
            <tx:method
                name="find*"
                read-only="true"
                propagation="NOT_SUPPORTED"
            />

            <!-- always starts a transaction.  if any exception is thrown   -->
            <!-- the transaction is rolled back.                            -->
            <tx:method
                name="*"
                rollback-for="Throwable"
                propagation="REQUIRED"
            />
        </tx:attributes>
    </tx:advice>

    <!-- ordinarily you'd only wrap the service layer classes with -->
    <!-- transactions but I needed transactions around the dao classes -->
    <!-- for testing.  but that's when I was doing things differently -->
    <!-- and now I don't know if I still need them around the dao classes. -->
    <!-- it shouldn't hurt to leave them this way; the inner transactions -->
    <!-- (the daos) are combined with the outer ones (the services). -->
    <aop:config>
        <aop:pointcut
            id="waitlistServiceOperation"
            expression="execution(* com.objecteffects.waitlist.service.api.*.*(..))"
        />

        <aop:pointcut
            id="waitlistDaoOperation"
            expression="execution(* com.objecteffects.waitlist.db.api.dao.*.*(..))"
        />

        <aop:advisor
            advice-ref="transactionAdvice"
            pointcut-ref="waitlistServiceOperation"
            order="99"
        />

        <aop:advisor
            advice-ref="transactionAdvice"
            pointcut-ref="waitlistDaoOperation"
            order="99"
        />

        <aop:aspect id="retryAspect" ref="transactionRetryer">
            <aop:around
                method="retry"
                pointcut-ref="waitlistServiceOperation"
            />

            <aop:around
                method="retry"
                pointcut-ref="waitlistDaoOperation"
            />
        </aop:aspect>
    </aop:config>

    <beans:bean id="transactionRetryer" class="com.objecteffects.waitlist.db.transaction.TransactionRetryer">
        <beans:property
            name="order"
            value="1"
        />
    </beans:bean>
</beans:beans>

The dummy dao interface with its dummy method.

package com.objecteffects.waitlist.db.api.dao;

import javax.jdo.JDOCanRetryException;

/**
 * This interface is used for testing transactions.  It needs to be in
 * this package because the xml configuration file for transactions
 * says to proxy all classes in this package.
 *
 * @author Rusty Wright
 */
public interface IDummyDao {
    /**
     * always throws the exception.
     *
     * @throws JDOCanRetryException
     */
    void dummy() throws JDOCanRetryException;

    /**
     * throws the exception the first time it's called and doesn't
     * throw it after that on subsequent calls.
     *
     * @throws JDOCanRetryException
     */
    void dummyOnce() throws JDOCanRetryException;
}

The dummy dao implementation.
All it does is throw an exception.

package com.objecteffects.waitlist.db.transaction;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Repository;

import com.objecteffects.waitlist.db.api.dao.IDummyDao;

/**
 * @author Rusty Wright
 */
@Repository("dummyDao")
public class DummyDao implements IDummyDao {
    private final transient Logger log = LoggerFactory.getLogger(getClass());

    static int count = 0;

    public void dummy() {
        this.log.debug("called");

        throw (new javax.jdo.JDOCanRetryException("urk"));
    }

    public void dummyOnce() {
        if (DummyDao.count++ == 0)
            throw (new javax.jdo.JDOCanRetryException("urk"));
    }
}

The test.

package com.objecteffects.waitlist.db.transaction;

import javax.annotation.Resource;
import javax.jdo.JDOCanRetryException;

import org.junit.Test;
import org.junit.runner.RunWith;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;

import com.objecteffects.gaeutils.LocalDatastoreTestCase;
import com.objecteffects.waitlist.db.api.dao.IDummyDao;

/**
 * @author Rusty Wright
 */
@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners({
    DependencyInjectionTestExecutionListener.class
})
@ContextConfiguration(locations = {
        "classpath:spring/jdo-tx-context.xml",
        "classpath:spring/applicationContext.xml",
        "classpath:spring/jdo-gae-context.xml",
        "classpath:gae-utils.xml"
})
public class TransactionRetryerTest extends LocalDatastoreTestCase {
    private final transient Logger log = LoggerFactory.getLogger(getClass());

    @Resource(name="dummyDao")
    private IDummyDao dummyDao;

    /** */
    @Test(expected = JDOCanRetryException.class)
    public void testDummy() {
        this.log.debug("called");

        this.dummyDao.dummy();

    }

    /** */
    @Test
    public void testDummyOnce() {
        this.log.debug("called");

        this.dummyDao.dummyOnce();

    }
}

The transaction retryer.

package com.objecteffects.waitlist.db.transaction;

import java.util.ConcurrentModificationException;

import org.aspectj.lang.ProceedingJoinPoint;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.core.Ordered;

/**
 * @author Rusty Wright
 */
public class TransactionRetryer implements Ordered {
    private final transient Logger log = LoggerFactory.getLogger(getClass());

    private int order;
    private int maxRetries = 3;

    /**
     * @param pjp
     * @return next caller's return value
     * @throws Throwable
     */
    public Object retry(final ProceedingJoinPoint pjp) throws Throwable {
        this.log.debug("called");

        Throwable exception = new Throwable("oops");

        int retryCount = 0;

        while (retryCount++ < this.maxRetries) {
            try {
                return (pjp.proceed());
            }
            catch (final JDOCanRetryException ex) {
                exception = ex;

                // retry
            }
            catch (final JDOException ex) {
                /**
                 * to quote Google's documentation: If any action
                 * fails due to the requested entity group being in
                 * use by another process, JDO throws a
                 * JDODataStoreException or a JDOException, caused by a
                 * java.util.ConcurrentModificationException.
                 */
                if (!(ex.getCause() instanceof ConcurrentModificationException))
                    throw (ex); // fail

                exception = ex;

                // retry
            }

            this.log.debug("retryCount: {}, exception: {}",
                    Integer.valueOf(retryCount),
                    ExceptionUtils.getFullStackTrace(exception));
        }

        throw (exception);
    }

    /**
     * @param _order
     */
    public void setOrder(final int _order) {
        this.order = _order;
    }

    /**
     * @return the order
     */
    public int getOrder() {
        return (this.order);
    }

    /**
     * @param _maxRetries the maxRetries to set
     */
    public void setMaxRetries(final int _maxRetries) {
        if (_maxRetries <= 0)
            throw (new IllegalArgumentException("maxRetries must be > 0"));

        this.maxRetries = _maxRetries;
    }
}

The logs.
Hover your mouse over this and in its top right corner are some gizmos where you can view source, or copy it to the clip board; that will make it easier to read with less line wrapping.

2009-11-16 23:24:20.184 PST, DEBUG: [main] org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource.addTransactionalMethod.94: Adding transactional method [find*] with attribute [PROPAGATION_NOT_SUPPORTED,ISOLATION_DEFAULT,readOnly]
2009-11-16 23:24:20.184 PST, DEBUG: [main] org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource.addTransactionalMethod.94: Adding transactional method [*] with attribute [PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-Throwable]
2009-11-16 23:24:20.184 PST, DEBUG: [main] org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource.addTransactionalMethod.94: Adding transactional method [*] with attribute [PROPAGATION_NEVER,ISOLATION_DEFAULT]
2009-11-16 23:24:20.450 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryerTest.testDummy.44: called
2009-11-16 23:24:20.466 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryer.retry.25: called
2009-11-16 23:24:20.466 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction.367: Creating new transaction with name [com.objecteffects.waitlist.db.api.dao.IDummyDao.dummy]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-Throwable
2009-11-16 23:24:20.481 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doBegin.310: Opened new PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@159ea8e] for JDO transaction
2009-11-16 23:24:20.481 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.DummyDao.dummy.20: called
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback.856: Initiating transaction rollback
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doRollback.449: Rolling back JDO transaction on PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@159ea8e]
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doCleanupAfterCompletion.501: Closing JDO PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@159ea8e] after transaction
2009-11-16 23:24:20.497 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryer.retry.46: retryCount: 1, exception: javax.jdo.JDOCanRetryException: urk
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction.367: Creating new transaction with name [com.objecteffects.waitlist.db.api.dao.IDummyDao.dummy]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-Throwable
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doBegin.310: Opened new PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@170984c] for JDO transaction
2009-11-16 23:24:20.497 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.DummyDao.dummy.20: called
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback.856: Initiating transaction rollback
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doRollback.449: Rolling back JDO transaction on PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@170984c]
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doCleanupAfterCompletion.501: Closing JDO PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@170984c] after transaction
2009-11-16 23:24:20.497 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryer.retry.46: retryCount: 2, exception: javax.jdo.JDOCanRetryException: urk
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction.367: Creating new transaction with name [com.objecteffects.waitlist.db.api.dao.IDummyDao.dummy]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-Throwable
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doBegin.310: Opened new PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@45aa2c] for JDO transaction
2009-11-16 23:24:20.497 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.DummyDao.dummy.20: called
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback.856: Initiating transaction rollback
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doRollback.449: Rolling back JDO transaction on PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@45aa2c]
2009-11-16 23:24:20.497 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doCleanupAfterCompletion.501: Closing JDO PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@45aa2c] after transaction
2009-11-16 23:24:20.497 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryer.retry.46: retryCount: 3, exception: javax.jdo.JDOCanRetryException: urk
2009-11-16 23:24:20.513 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryerTest.testDummyOnce.56: called
2009-11-16 23:24:20.513 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryer.retry.25: called
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction.367: Creating new transaction with name [com.objecteffects.waitlist.db.api.dao.IDummyDao.dummyOnce]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-Throwable
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doBegin.310: Opened new PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@1c19919] for JDO transaction
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback.856: Initiating transaction rollback
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doRollback.449: Rolling back JDO transaction on PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@1c19919]
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doCleanupAfterCompletion.501: Closing JDO PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@1c19919] after transaction
2009-11-16 23:24:20.513 PST, DEBUG: [main] com.objecteffects.waitlist.db.transaction.TransactionRetryer.retry.46: retryCount: 1, exception: javax.jdo.JDOCanRetryException: urk
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction.367: Creating new transaction with name [com.objecteffects.waitlist.db.api.dao.IDummyDao.dummyOnce]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-Throwable
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doBegin.310: Opened new PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@413fc6] for JDO transaction
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit.765: Initiating transaction commit
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doCommit.432: Committing JDO transaction on PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@413fc6]
2009-11-16 23:24:20.513 PST, DEBUG: [main] org.springframework.orm.jdo.JdoTransactionManager.doCleanupAfterCompletion.501: Closing JDO PersistenceManager [org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManager@413fc6] after transaction

The project that this is for is at wait list. It’s a work in progress.

Voicify is the product of one weekend’s efforts by Michael Potter’s team at Atlanta Startup Weekend. It does an automated telephone survey using the questions you specify from a web form. (Caution – being a simple proof-of-concept, it does not check against the FTC Do Not Call list.)

It uses Python and Django on Google App Engine and BigTable.

Try it out – every user gets a $2.00 credit to begin with, and it costs 10¢ per call.

And all I did with my weekend was rake leaves.

In the last post, I talked about the first day of The Developers Conference. Now lets talk about day number 2.

Very different from the previous day, this one started full of coding. And during the day, we kept seeing lighting talks and Vinicius’ toys. The only real problem we had was that the place ran out of eletricity for a while… but at least it didn’t last too long and the event could finish right.

Rod Johnson

The first speech was again from Rod Johnson. But this time, it was not philosophical at all. He presented Spring Roo, a project that aims at bringing to Java the productivity found in Rails. After seeing what he showed, I believe it. And love it.

In summary, the tool generates a lot of boilerplate code that we would otherwise have to write ourselves. And keeps it all out of the way while you develop your project.

I liked this so much that Spring Roo will be covered in a new post, exclusive to it, soon enough. And look, I don’t like Spring, but this thing can make me change my mind.

Rod Johnson on SpringRoo

Lightning Talks

One of these lightning talks was about Spring best practices, which followed Spring Roo’s presentation. Ricardo Jun presented it, and mentioned things like how people tend to simply want to totally discard xml, instead of using it in moderation; the importance of using tools; the importance of modularization and also that we should always mind concurrency.

Jun and Spring Best Practices

Another quick demonstration about robotics had an application server installed in a device, which was accessed through http. This device was connected to a lamp, and Vinicius turned it on and off through a web interface. Meaning: I want all the power plugs in my house accessible through the internet!! =D

On the note of excited people, I must talk about Vinicius Senger again. When presenting the balloon robot for the second time now, he breathed Helium, the gas used in the balloon to make it float. The effect was that his voice got very thin for a few seconds, creating a very funny moment.

Balloon Robot

Another lightning talk was about what was previously called Web Beans – now Weld: the reference implementation of JSR 299: Contexts and Dependency Injection. Alessandro Lazzarotti, from Red Hat, gave a quick demo on the implementation which is, of course, full of annotations everywhere.

An interesting lightning talk was about performance in JPA. Alberto “Spock” talked about how the Open Session in View filter pattern can be a little bit outdated when it comes to ajax applications – an environment which wasn’t there when the pattern was created.

Alberto "Spock" on Ajax and JPA Performance

In Globalcode’s blog here, he explains this problem better. During the presentation, he also mentioned the Apache Myfaces Orchestra project, which should also help minimize the problem bringing the conversation scope to your application. The conversation scope was first introduced by JBoss Seam, and brings us a scope bigger than request, and smaller than session, which can really help us manage resources in a lot of situations.

Mike Keith

This time Mike Keith presented about JPA 2.0. The goal of JPA 2.0 is basically to standartise what we currently do with, for example, hibernate, because we can’t with JPA 1. Nothing really new was presented – unless you didn’t know anything about JPA 2 already. But a few topics are worth mentioning.

A new evictall function was added. Useful to completetly clear cache between test cases. Small change but sounds interesting.

Now my pet peeve: the new criteria API. He presented it and showed a few examples and comparisons between the criteria code and the JPQL code. Just made me dislike it more. Just as a reminder, I already said that I don’t like this thing when I wrote about Globalcode’s Casual Class #006. Trying to access a database completely through OO code is just too much purism. At least, Mike is a very funny presenter to watch =)

Mike Keith on JPA 2.0

Francisco Gioelli (Google)

The original plan was to have Chris Schalk talking about Google App Engine. Unfortunatelly, he had problems with the immigration and couldn’t get into the country. So google sent Francisco Gioelli, who did a nice job instead.

Among other languages, Google App Engine allows us to write Java web applications and publish them on the google cloud, leaveraging from the monstruous google scalability. A few features available include possibility of scheduling cron tasks through a xml file and the Big Table, their (non-relational) database. This last feature is the only thing that makes me a little bit worried about using google’s cloud.

Francisco on Google App Engine

This talk had a demo and was complemented by another one from Rafael (from Globalcode) – this last one using JSF 2.0 – nice! Two little extras mentioned by him: each request can take at the very most 30 seconds and the internal server used seems to be Jetty.

Alejandro Guizar (Red Hat Mexico)

This one was about BPEL. This is not a topic I can talk too much, so I won’t. The only thing that took my attention was something called BPEL Unit. I never heard of it and found interesting that such a thing exists. But I couldn’t find any good references…

Alejandro on BPEL

Cloud Computing Panel

To close the event, a panel on Cloud Computing, featuring the main speakers that were present. This is a trendy topic nowadays, full of buzz words, but interesting, it was!

Ed Burns started talking that Sun have something (I forgot the name…) since 2000. Makes sense… very tipical of Sun: great products, terrible marketing. He also mentioned Zembly.com. If you are insterested, go to the site now. I just went there and found out that they are closing the service permanently from November 30th. Nice… (no, not really).

From Rod Johnson, we learnt that Springsource have their hand on Cloud Computing in the form of CloudFoundry. Also, he made sure to say how important it is to have multiple players in the market. Agreed.

Some points were easily agreed by the panelists:

• private clouds will have big importance in the future;
• a good thing of the cloud is the economy;
• but a bad thing is the loss of control in a lot of senses, but probably mainly data;
• we need easy of migration between cloud providers.

Someone asked about cloud computing and peer-to-peer. The panelists didn’t seem to believe too much in this possibility. Well, who knows…

A lot of gurus on Cloud Computing

Last picture, to change the mood a litle bit:

Relaxing between presentations

And so it ends this year’s event. I’m already waiting for the one next year! =D

Note: Github available here. It works best with the current SpringSource Tool Suite.

Having had evening to spare, together with a colleague I came up with the following nano-project:

Write a prototype for creating a chart from some series of numbers, which is hosted in a cheap cloud.

So this brings me to: “Write a prototype (Groovy) for creating a chart (Google Chart API) from some series of numbers (taken from spreadsheets of Google Docs), which is hosted in a cheap cloud (Google App Engine).”
Some day, I will have to fix this Google addiction – however, Groovy is not affiliated to Google at all.

Evaluation of Frameworks

Wanting to combine Groovy and the Google App Engine, I immediately came across two different frameworks, the almighty and ubiquitous Grails and the much more pragmatic Gaelyk.
Since for this purpose Gaelyk is more than enough and because I wanted to try it, I used this for prototyping. By downloading the sources from Github, the typical Gaelyk project setup can be concluded if analyzed together with the information given in the Gaelyk tutorial – it’s quite easy.

The data (about 100-1000 random numbers between 5000 to 6000) should come from a web based, private (authorization-based) available data source – even though many possibilities exist, I chose Google Docs for two reasons:

1. Easy creation of “some” random numbers
2. Authorization based on Google Authorization
3. Access class already exists (cmp. this post)

The last important feature should be the creation of a chart. Here, really a lot compelling solutions exist. Mainly, there are three different ways to realize Chart creation:

1. Java based, eg. JFreeChart
2. Javascript based, eg. JQuery plugin flot
3. Pure Web based, eg. Google Chart API

Since I want to have it simple & easy, the third option is really great for this use case. A chart can very easily be created, compare this, which is rendered dynamically:

which is:

http://chart.apis.google.com/chart?chxl=0:||1:|&cht=lc&chxt=x,y&chs=500x150&chco=0077CC&chm=B,E6F2FA,0,0,0&chd=t:5563.0,5807.0,5096.0,5898.0,5306.0,5944.0,5932.0,5510.0,5088.0,5791.0,5039.0,5145.0,5459.0,5395.0,5997.0,5075.0,5587.0,5760.0,5561.0,5719.0,5108.0,5339.0,5321.0,5686.0,5213.0,5987.0,5228.0,5670.0,5594.0,5292.0,5909.0,5616.0,5978.0,5375.0,5504.0,5558.0,5840.0,5233.0,5947.0,5028.0,5592.0,5992.0,5020.0,5991.0,5953.0,5471.0,5243.0,5784.0,5472.0,5801.0,5652.0,5700.0,5183.0,5949.0,5809.0,5426.0,5130.0,5394.0,5919.0,5741.0,5134.0,5402.0,5801.0,5567.0,5478.0,5740.0,5563.0,5677.0,5346.0,5020.0,5243.0,5137.0,5787.0,5241.0,5351.0,5834.0,5630.0,5542.0,5238.0,5242.0,5312.0,5642.0,5424.0,5988.0,5796.0,5912.0,5599.0,5567.0,5832.0,5559.0,5760.0,5061.0,5629.0,5951.0,5095.0,5585.0,5602.0,5686.0,5562.0,5700.0,5267.0,5656.0,5757.0,5023.0,5498.0,5935.0,5650.0,5807.0,5345.0,5080.0,5919.0,5308.0,5316.0,5076.0,5154.0,5399.0,5537.0,5923.0,5968.0,5973.0,5528.0,5640.0,5097.0,5369.0,5374.0,5248.0,5955.0,5243.0,5949.0,5126.0,5659.0,5010.0,5473.0,5012.0,5536.0,5274.0,5115.0,5809.0,5212.0,5400.0,5550.0,5274.0,5931.0,5762.0,5343.0,5655.0,5434.0,5981.0,5844.0,5277.0,5823.0,5905.0,5741.0,5168.0,5057.0,5956.0,5841.0,5804.0,5421.0,5933.0,5667.0,5171.0,5083.0,5322.0,5410.0,5459.0,5092.0,5678.0,5401.0,5817.0,5526.0,5663.0,5753.0,5802.0,5289.0,5917.0,5020.0,5372.0,5993.0,5023.0,5773.0,5469.0,5681.0,5442.0,5736.0,5552.0,5678.0,5493.0,5758.0,5726.0,5713.0,5103.0,5201.0,5435.0,5583.0,5318.0,5501.0,5076.0,5004.0&chds=4000,7000

Now, was this easy?

Preparation/Implementation

First, the Groovy file which dispatches the request is as follows (must go to the groovy folder):

import java.net.URLConnection;

def labels = ["A", "B", "C", "D", "E"]
int ivalue = new Random().nextInt(5);

String link;
if (memcacheService.get(labels.get(ivalue)) == null) {
	def ts = new com.commons.gse.TestSheets();
	link = ts.getData(labels.get(ivalue));
	memcacheService.put(labels.get(ivalue), link)
} else {
	link = memcacheService.get(labels.get(ivalue))
}
request.setAttribute ('counter', com.commons.gse.TestSheets.counter++)
request.setAttribute ('appendix', link)
forward '/data.gtpl'

The interesting part is the usage of the predefined object memcacheService which makes it possible to just use Google App Engine’s memcache without having to deal with creation, exception handling, etc.
One of five (“A-E”) cached number series is used. If no cache for the character is found, the number is extracted from a speadsheet called data in Google Docs (see screenshots below).
After having calculated or retrieved the numerb series from the cache, the values (which is the complete link with the numbers included) are put into the ServletRequest (in this case the predefined object request). Finally, the request is dispatched to the view, a Groovy template (data.tgpl).

<html>
<head/>
<body>
  <span>counter:<%= request.getAttribute('counter') %></span>
  <form>
    <input type="button" value="Reload" onClick="window.location='/data.groovy'">
  </form>
  <img src='<%= request.getAttribute('appendix') %>'/>
</body>
</html>

A final note: if you want to use this from Github, you will have to change the Google authorization data in TestSheets.java (which is completely left out here, but is described here).

Here is the setup of the Google Docs spreadsheets:

Running

If you have installed the SpringSource Tool Suite, you can just import the Eclipse project and choose “Run as…/Web Application”. The local server should be startet. Afterwards, you can call http://localhost:8080/data.groovy.

Note: Be sure to change the username/password combination in TestSheets.java

The promising technology of Cloud computing recently suffered its first serious bout of growing pains when Microsoft/Danger, which provides cloud computing services crashed and lost all of T-Mobile Sidekick customers’ mobile phone information on their servers and back-up. That has to have cast a pall of concern over corporate customers evaluating the wisdom of outsourcing their relationship with their customers to a third party. Microsoft was at fault, but T-Mobile gets the blame. The other reasoning that has to be running through customers’ mind is that with an emerging technology, what can go wrong will. Anyone who has experienced Microsoft’s blue screen of death can attest to this.

The other vulnerability cloud computing customers face is security. Imagine if the T-Mobile Sidekick disaster had been a raid by hackers instead of a server farm and back-up meltdown. In a world of computer hackers that have become expert at finding the flaws in each new release of software, cloud computing has to offer an appealing target. And it’s not only financial records. Cracking into a server farm is the equivalent of breaking into the vault of a Swiss bank: personal records in the millions and not just one credit card company but charge accounts for them all. All of these problems will get solved in time as vulnerabilities get identified and fixes are implemented. The question for anyone contemplating being an early adopter is “do I want to be the guinea pig that finds the bug?” like T-Mobile.

Perhaps the greatest vulnerability is the lack of a single point of contact ensuring the security of the cloud computing solution. If a client buys the computing resource and storage capacity from Amazon, Microsoft, Google, or another cloud supplier; he purchases middleware from one or more third parties; and he gets applications software from someone else, the only one that has a vested interest in security across these different vendors is the client buying the service. If a break-in occurs finger pointing ensues. More importantly, hackers understand this vulnerability and seek out the weakest link in the collection of elements comprising a solution for any given client. For example, they might find the back door in a middleware program that can be used to gain entry into the main database.

Google’s cloud computing solution is called the Google App Engine. When asked after his introductory remarks at the Google Internet Summit May 5 and 6, 2009, in Mountain View, California to comment of security not being built into the architecture for cloud computing, Google CEO Eric Schmidt made the following statement. “The answer to your question depends upon where you think security should lie. Do you think it should be at the application layer? Or do you think it should be at some middleware layer… I think it’s too early to really know. It’s very strategic for us that people build—think of them as Ajax applications, Ajax++ (see note) with all the extensions—because that displaces the traditional PC dedicated client architecture… I don’t know how security will play out. I’m not aware within Google of a lot of activity at the applications level in security because the kinds of questions that are asked are still relatively early. Maybe we should fix that.”

Cloud computing is relearning all the security lessons that previous computing generation—the early mainframes, the minicomputers, and the PCs—already experienced. For those not familiar with them, the book “Cyberpunk” by Katie Hafner and John Markoff is an entertaining and informative place to start. You’ll follow the exploits of, among others, Kevin Mitnick who exploited the lax security that protected most minicomputer systems 30 years ago. In 1979, Mitnick gained unauthorized access to Ark, the computer system Digital Equipment Corp. (now part of Hewlett Packard) and stole DEC’s next generation RSTS/E operating system software—then in development, a crime for which he was charged and convicted in 1988.

Maybe security should be given more consideration in the development of cloud computing architectures.

Note: according to Wikipedia, Ajax (asynchronous JavaScript + XML) is a group of interrelated web development techniques used on the client-side to create interactive web applications. With Ajax, web applications can retrieve data from the server asynchronously in the background without interfering with the display and behavior of the existing page. The use of Ajax techniques has led to an increase in interactive or dynamic interfaces on web page and better quality of Web services due to the asynchronous mode. Data is usually retrieved using the XMLHttpRequest object.

I previously blogged about my setup for Spring Security in Google App Engine.

Recently, a reader has asked me to post more details on my configuration.  This post provides those details. Note that I simply cannot post my complete source, but hopefully everything relevant to security is available between the two posts.  The same Spring version numbers apply.

First, here is a relevant excerpt from my web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring/*-context.xml
		</param-value>
	</context-param>
	<!-- ... -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<filter>
		<filter-name>springSecurityFilterChain</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>springSecurityFilterChain</filter-name>
		<url-pattern>/*</url-pattern>
		<dispatcher>FORWARD</dispatcher>
		<dispatcher>REQUEST</dispatcher>
	</filter-mapping>
	<!-- ... -->
</web-app>

My security-context.xml looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security"
	xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.1.xsd">

	<beans:import resource="integration-context.xml" />

	<http>
		<intercept-url pattern="/register.*" filters="none" />
		<intercept-url pattern="/styles/**" filters="none" />
		<intercept-url pattern="/login.*" filters="none" />
		<intercept-url pattern="/**" access="ROLE_USER" />
		<form-login login-page="/login.f" login-processing-url="/j_spring_security_check"
			default-target-url="/index.f" authentication-failure-url="/login.f" />
		<logout logout-url="/logout" logout-success-url="/" />
	</http>

	<authentication-provider user-service-ref="userSecurityManagerService" />

	<beans:bean id="userSecurityManagerService"
		class="my.app.security.GaeUserDetailsService">
		<beans:property name="userSecurityDao" ref="userSecurityDao" />
		<beans:property name="userDao" ref="userDao" />
	</beans:bean>

	<beans:bean id="loggerListener"
		class="org.springframework.security.event.authentication.LoggerListener" />

	<authentication-manager alias="authenticationManager" />

</beans:beans>

That should be it.  If it helps, let me know and tell your friends.  If it doesn’t, tell me so and I’ll give it another shot.

App Engine has a number of security restrictions that it imposes on applications. One that is often cited as a major source of frustration is the inability to read/write to a local file system. It looks like the developer community may have developed a workaround.

Kyle Roche sent me a link to a GaeVFS, a distributed, writeable virtual file system for Google App Engine Java. It doesn’t actually use the local file system but simulates it using the datastore and memcache.

“GaeVFS is an Apache Commons VFS plug-in that implements a distributed, writeable virtual file system for Google App Engine (GAE) for Java. GaeVFS is implemented using the GAE datastore and memcache APIs. The primary goal of GaeVFS is to provide a portability layer that allows you to write application code to access the file system–both reads and writes–that runs unmodified in either GAE or non-GAE servlet environments.”

I’m not sure if we have enough time to get this added to our book but it may be interesting.