Google App Engine SDK 1.2.8 Released and they are finally supporting JAXB

Google has announced the new App Engine SDK 1.2.8 and they are finally providing support for JAXB.

The App Engine team has been hard at work tackling our the issues on our tracker, tweaking APIs and closing bugs. In addition to a ton of bug fixes, 1.2.8 also includes:

Enhanced Admin Console - Users will notice new tools for managing tasks and queues created with the Task Queue API, and more visibility into index processing.

Improved Java Compatibility - This release adds support for new filter operators and inheritance to JPA and JDO as well as support for JAXB, the single most requested feature for the Java SDK.

...

Apache PhotArk - Improved documentation and new website is now live !!!

Apache PhotArk will be a complete open source photo gallery application including a content repository for the images, a display piece, an access control layer, and upload capabilities. The idea is to have a rigid design for the content repository with a very flexible display piece. The images in the content repository will be protected with granular access control.

The new PhotArk website layout is live, and it has improved documentation with a improved developer guide and a new architecture guide.

Apache PhotArk welcomes your help. Any contribution, including code, testing, contributions to the documentation, or bug reporting is always appreciated. For more information on how to get involved in the Apache PhotArk project, visit the website at:

http://incubator.apache.org/photark/

Thank you for your interest in Apache PhotArk!

The Apache PhotArk Team.

Tuscany SVN structure has changed...

In order to simplify the Tuscany SVN structure and make it easier for users to find the active sub-projects the Tuscany community have changed the SVN structure as described below:

SCA 2.x

For SCA 2.x, which is based on the most recent drafts of OASIS SCA Specifications 1.1, you can find all the code (trunk, branches, tags, contrib) at [1], the SCA 1.x trunk is available at [2].

[1] https://svn.apache.org/repos/asf/tuscany/sca-java-2.x/
[2] https://svn.apache.org/repos/asf/tuscany/sca-java-2.x/trunk/

SCA 1.x

For SCA 1.x, which is based on the OSOA SCA Specifications 1.0, you can find all the code (trunk, branches, tags, contrib) at [3], the SCA 1.x trunk is available at [4].

[3] https://svn.apache.org/repos/asf/tuscany/sca-java-1.x/
[4] https://svn.apache.org/repos/asf/tuscany/sca-java-1.x/trunk

SDO

You can find all SDO code (trunk, branches, tags, contrib) at [5], the SDO trunk is available at [6] and the SDO Community Tests are now available at [7]

[5] https://svn.apache.org/repos/asf/tuscany/sdo-java/
[6] https://svn.apache.org/repos/asf/tuscany/sdo-java/trunk/
[7] https://svn.apache.org/repos/asf/tuscany/sdo-java/trunk-cts/

DAS

You can find all DAS code (trunk, branches, tags, contrib) at [8] and the das trunk is available at [9].

[8] https://svn.apache.org/repos/asf/tuscany/das-java/
[9] https://svn.apache.org/repos/asf/tuscany/das-java/trunk/

Migrating your local checkouts

If you want to point your local svn checkout to the new source location, you could use svn switch :

cd [your local checkout]
svn switch [your new code location in svn]

Please send us an e-mail on the Tuscany mailing lists if you have questions and/or comments.

ApacheCon 2009 Session: Applying OSGi after the fact

ApacheCon US 2009 is almost finished, and I'm done with my last Apache Tuscany/OSGi session.

Tuscany: Applying OSGi modularity after the fact
Fri, 06 November 2009 11:15 by Luciano Resende

Slides are now available

Subversion is being proposed as an Apache Incubator project

The CollabNet-sponsored Subversion project and The Apache Software Foundation (ASF) announced today that the award-winning Open Source project has formally submitted itself to the Apache Incubator in order to become part of the Foundation's efforts.

Read the Press Release....

ApacheCon 2009 Session : SCA, Java EE, Spring, Web 2.0 and Cloud Come Together - Service assembly with Apache Tuscany SCA

ApacheCon US 2009 has started and I'm done with my first Apache Tuscany session.

SCA, Java EE, Spring, Web 2.0 and Cloud Come Together - Service assembly with Apache Tuscany SCA
Wed, 04 November 2009 11:00, by Luciano Resende

Slides are now available

Tuscany cloud tutorial source code is available in Tuscany SVN at sca-cloud-tutorial sandbox.

The application integration sample (a.k.a Travel Sample) is available in Tuscany SVN at travel-sample sandbox.

Distributed online store scenario running on multiple cloud environments.

In my previous post, I described A variant of the Store scenario running on Google AppEngine. I have expanded the scenario to incorporate other catalogs hosted in different cloud environment, and have added a vegetables catalog hosted in the IBM cloud.



One of the problems that raises when you start thinking on multiple cloud environments, is that the is no current Cloud Standard, and trying to consume cloud infrastructure services will make your application dependent on a given cloud environment. To solve this problem, we have now started an abstraction layer for these cloud infrastructure services, similar to the idea proposed by simpleCloud.org. We have defined a userService which abstracts user related services, and a DocumentStore which is used to handle data store services and is based on the Tuscany Collection interface that easily maps to REST. We are still maturing this cloud api layer, and the current store scenario uses the userServices implementation based on Google AppEngine UserServices to provide authentication support for the application, as well as to provide individual shoppingCarts per user.

Note that this is all based on the new Tuscany 2.x runtime, which is based on the OASIS SCA 1.1 draft specifications.

If you got interested, the distributed online store scenario is available in the sca cloud tutorial sandbox.

Tuscany Sessions at ApacheCon US 2009

ApacheCon US 2009 is just around the corner, and we are going to have several Apache Tuscany related sessions.

SCA, Java EE, Spring and Web 2.0 Come Together - Service assembly with Apache Tuscany SCA
Wed, 04 November 2009 11:00, by Luciano Resende

Apache Tuscany provides an easy-to-use open source services infrastructure for building, assembling, deploying and running SOA solutions based on the Service Component Architecture (SCA) specifications from OASIS. The Apache Tuscany project goes beyond the SCA specification and is an environment for innovative ideas around SOA, for example it extends SCA to work with web2.0 and OSGI. Apache Tuscany is integrated with other Apache technologies such as Tomcat, Axis2, Geronimo, BSF, Ode, XMLBeans and Abdera.This talk will provide a short overview of SCA and the Apache Tuscany project and will mainly focus on an enterprise integration example to demonstrate how to take advantage of SCA and Tuscany to describe, assemble and deploy an end-to-end SOA solution.

This talk is directed at those who are building distributed solutions from connected services and want to understand how SCA can help.

The presenters will use their experience of working with the Apache Tuscany project and its users to illustrate:
• Partitioning of the application into components and services
• Exploitation of a variety technologies to implement components including Java EE, Spring and Web2.0
• Use of different communication technologies such as web services, JSON-RPC
• Configuration of policy to control consistent quality of service across the distributed application
• Deployment to distributed runtimes with varying capabilities including Java EE containers, web browsers and command line JSE nodes

Distributed OSGi with SCA using Apache Tuscany
Wed, 04 November 2009 13:30 by Raymond Feng

OSGi goes beyond service invocations in a single JVM with the introduction of RFC 119 - Distributed OSGi. It will enable an OSGi bundle deployed in a JVM to invoke a service (either OSGi or non-OSGi) in another JVM or process, potentially on a remote computer accessed via a network protocol. Meanwhile, an OSGi service deployed in another JVM or a non-OSGi program such as Web Service client, potentially on a remote computer, to find and access a service running in the "local" OSGi JVM (i.e. an OSGi deployment can accept service invocations from remote OSGi bundle or external environments). The distributed computing functionality is added to the OSGi programming model without additional APIs or concepts as the distribution layer will be mostly transparent to OSGi developers by configuration.

SCA (Service Component Architecture) provides a technology-neutral approach to abstract business logic into components and assemble them into composite applications. It greatly simplifies the component communications using declarative bindings. QoS requirements can be uniformly declared as SCA intents which can be mapped and realized using different stacks. SCA is a great fit to be a distribution provider for distributed OSGi.

Apache Tuscany is an open source project that implements the SCA specifications. It provides integrations of implementation types (such as Java, Scripting, BPEL, Spring, OSGi and JEE) and binding types (such as Web Service, JMS, EJB, CORBA, RMI, JSONRPC, and ATOM) as the infrastructure for SCA programming. The latest version of Tuscany runtime is fully built on top of OSGi as the foundation. We recently added the OSGi RFC 119 support.

In this session, we will teach you how to develop a distributed OSGi application to leverage the SCA capabilities using Apache Tuscany. A calculator scenario will be used to demonstrate the distributed OSGi service invocations using RMI and Web Service protocols. We will also explain how to model an OSGi bundle as an SCA component and configure the SCA composite to provide communications between services. The readers will understand the basic ideas behind distributed OSGi in the concrete example and the power of Tuscany SCA for service composition.

Tuscany: Applying OSGi modularity after the fact
Fri, 06 November 2009 15:00 by Luciano Resende

Apache Tuscany is an open source project that simplifies the development, deployment and management of distributed applications built as compositions of service components.It is based on the Service Component Architecture specifications being defined by the OASIS Open SCA Collaboration. Tuscany was built with a modular architecture, using a different approach from that of OSGi. In 2008 an effort was started to integrate Tuscany with OSGi. As part of this we undertook an investigation into how to apply OSGi modularity to the Tuscany runtime so that clean boundaries between modules are enforced and different versions of the same library can coexist.This involved analyzing the existing Tuscany modularity which turned up lots of interesting information about the linkages between the various sub-components. This understanding was then used to determine how to map Tuscany into a suitable form for use as OSGi bundles, including prototyping various levels of decomposition granularity. This presentation will share the experiences of analyzing and modularizing an existing project using OSGi. It will discuss what to expect when approaching modularizing existing projects, the tools (and it's caveats) for aiding analysis and also best practices for applying OSGi modularity. Beyond the OSGi enablement for the runtime, we are also going to cover how to integrate OSGi and SCA at the application level.