Tuesday, October 27, 2009

Join Us for the New XAP Security Framework Webinar

You’re welcome to join our XAP security webinar on Wednesday, October 28.

In this webinar I’ll will explain the motivation behind our revamped security framework and overview its capabilities. The session will also include a live demo in which I’ll show how to secure the GigaSpaces runtime environment in a few simple steps, and how to enable security for a typical application without changing a single line of code or configuration.

The webinar will be held at 9am PDT, 12pm EST, 5pm CET. Please click here to register

Hoping to see you tomorrow,

Tuesday, September 15, 2009

GigaSpaces XAP 7.0.1 Is Out!

I’m happy to announce that today we’ve released our latest version, XAP 7.0.1. I would like to share with you a few details about it. Version 7.0.1 is a service pack release on top of version 7.0.0 and as such is backwards compatible with it. In addition to a number of bug fixes on top of 7.0.0, It includes some very interesting features and improvements around 3 main areas: Enterprise grade security, improved usability and APIs and better troubleshooting and monitoring capabilities. In addition to that, we’ve also worked on further optimizing the performance of our data grid implementation. Here’s a short description of the release highlights:

  • Security: 7.0.1 introduces a revamped security implementation for the best possible data grid security. This implementation was specifically designed to support enterprise and cloud data grid scenarios in which the data grid is accessed by multiple applications and serves as a central data repository. In terms of relevance to the cloud, it brings a new level of data security which enables you to safely store data in cloud environments without having to worry about security hazard related to storing your data off premises. In addition to transport level security for all data grid related communication (based on SSL), it includes support for users and roles, with a comprehensive permissions system to enforce authorization for every operation, starting from the management of the GigaSpaces infrastructure, processing units and space (data grid) instances and ending with content based authorization to access the data grid contents and operate on it. The new security implementation is fully supported by the various management interfaces (GUI, CLI and administration API) and also provides open APIs for integration with 3rd party user registries. For more details please refer to this page. We will also dedicate a separate blog post to this important aspect of the XAP 7.0.1.

  • API and Usability:
    • All new space based remoting implementation for XAP.NET. Space based remoting has been around since version 6.0 in XAP for Java and extends the Spring remoting stack to provide a wealth of benefits in comparison to traditional remoting implementations, such as: high availability of exposed services, transparent client side failover, location transparency, load balancing across services in the cluster, map/reduce support and asynchronous invocation (please refer to “The Service Virtualization Framework” white paper in our whitepapers section if you’d like to further learn about the benefits of space based remoting). As of version 7.0.1, it is also available for our XAP.NET users with all the goodies which are part of the Java implementation. The documentation of this feature can be found here.
    • XAP.NET built processing unit container. In order to further ease and simplify the processing unit development and deployment experience in XAP.NET, we've implemented the Basic Processing Unit Container, which is a smart built in implementation of the processing unit container interface. This container automatically starts and manages GigaSpaces related components for you (such as space instances, event containers and remote service endpoints), relieving you from the need to explicitly manage the life cycle of those components and allowing you to focus on your application’s business logic.
    • Easier cache eviction policy configuration. This is a nice little configuration improvement that makes our users’ life easier when configuring the cache eviction policy. In previous releases, the recommended way to control the eviction policy was by using space properties. In 7.0.1, this has been made much more elegant with native XML namespace and Java code configuration support. Here’s an example of how you would have configured LRU eviction in your pu.xml and in code in 7.0.0 and 7.0.1:
    • Extended Indexing at the property level: Extended indexing allows you to index properties of objects written to the space with a BTree index, thus allowing for range queries (based on the property type’s natural ordering). Prior to 7.0.1, extended indexing was only available at the class level, which means you had to either use the extended index for all the properties of a certain class or for none at all (and make do with basic indexing). In 7.0.1, we’ve enabled extended indexing at the property level, so you can now choose the right indexing scheme for each property. For example, the identifier property of a certain class would typically be indexed with a basic index, which does not have a sense of order between indexed values and is therefore more lightweight and faster than extended indexing. For another date/time or number property, you would use the extended indexing since if you would like to perform range queries (e.g. all the objects with date property before 1/1/2009). This can be configured via annotations, e.g. @SpaceProperty(index=IndexType.Extended) or via XML, e.g.
      <property name="lastName" index="EXTENDED"/>.

  • Performance improvements for embedded operations. As with every release, we have dedicated quite a lot of time to further optimize areas which we knew could be improved. In this release we have focused on performance of embedded space operations and by optimizing the concurrency of internal thread and object pools we have been able to present improvements of up to 200% for embedded space operations. The following graphs show across-the-board improvements in comparison to 7.0.1 (these were measured with 8 threads concurrently accessing the space). It is important to mention that these improvements were achieved without any sacrifice to the consistency and correctness of the space operations:

  • Better troubleshooting and monitoring:
    • More information in log files: We are continuing to improve the quality and amount of information exposed via our log files. 7.0.0 introduced some major logging improvements (per-pu log messages, improved file naming scheme, time-based rollover policies and more). In 7.0.1 we’ve added some more helpful information to help you tune and troubleshoot the system. The first one is GC awareness. You can define a GC pause upper threshold (10 seconds by default). In case the garbage collection process takes longer, the system will log this for future reference. In addition, we’ve added logging for the recovery process (which occurs when starting a backup space instance and recovering the data from the primary) so you can now tell exactly what happened during the process and how long it took
    • Replication statistics in administration API. This is an important addition to the administration API which enables you to monitor the rate at which objects are replicated and whether or not there’s an issue with the replication mechanism. For more details refer to the org.openspaces.admin.space.SpaceInstanceStatistics interface(specifically, the getReplicationStatistics() method).

As always, we would be happy to hear your feedback on the new release (you can send it directly to feedback7.0 at gigaspaces dot com). For the complete release content please consult to the official 7.0.x release notes (refer to the notes relevant for 7.0.1).

Wednesday, August 5, 2009

StockDemo and GigaSpaces Petclinic for XAP 7.0 Now Available

If you’ve been following our webinars and demos in the last year or so, in many of them we’ve used two applications to demonstrate the product. The first one is the stock demo, which is an AJAX enabled Spring MVC web application that communicates with the Space and displays real time stock quotes. The second one is the good old Spring PetClinic application with the data access layer accessing GigaSpaces instead of a relational database, and persisting asynchronously to a MySql database (via Hibernate).

I’ve been planning for quite some time now to port both application to XAP 7.0 due to the packaging and deployment improvements of this version.

I finally found the time to do this after finalizing the 7.0 release. You may now find the up to date version of both applications on our forge site, OpenSpaces.org.

Note that both applications are also available as one-click demos on our cloud framework. The 7.0 compatible-version will soon be made available on this framework as well.


Saturday, July 25, 2009

Join Us for the 7.0 Overview Webinar

You’re all welcome to join our 7.0 introduction webinar next Tuesday (July 28). In this technical update and live demo, I will go over the new and noteworthy in the 7.0 release.

Joining me in this webinar will be Shay Banon, our System Architect (who also runs the Compass project in his spare time).

I will explain how GigaSpaces XAP combines a robust in-memory data grid, the Jetty web container and a grid-based business logic execution framework to form a single, easy-to-use platform on which you can build and run extremely scalable enterprise applications.

Key release highlights which I’ll cover in this webinar include performance and scalability improvements, new monitoring and administration API, new data grid APIs and cloud integration. These will be illustrated through the use of live demos.

Shay will describe a real life use case in which XAP 7.0 was used to implement a distributed search functionality on a social network and drastically improve the performance of the application.

Please click here to register. Note that for your convenience the webinar will be held twice, on two separate schedules, to accommodate for different time zones.

Sunday, May 24, 2009

Building GigaSpaces Apps in Minutes with Giga Systems Builder

If you're into MDA, there are some great news for you. One of our partners, New Technology/enterprise (NT/e) has created a very impressive tool to build and deploy end-to-end GigaSpaces applications in minutes. The tool is called GigaSystemsBuilder (GSB).
GSB is an Eclipse plugin which makes it quick and easy for Java developers to model, code and deploy GigaSpaces applications.
Since it's based on well known and battle-proven patterns on top of the GigaSpaces XAP platform, it reduces learning time and on-going development effort, and also increases the likelihood of successful projects.
It covers the entire application life cycle, and enables you to model, code, build, run and even deploy the application on the cloud (using our cloud framework) in a few clicks from within your IDE.
The tool is free for development and deployment, and comes with optional paid support package from NT/e.
A good place to start exploring this tool is this 10-minute screen cast.


Sunday, May 10, 2009

UI & Manageability Improvements in XAP 7.0

As GigaSpaces XAP 7.0 release is getting closer, it's time to overview some of the important new features and enhancements of this version. In this post I will focus on the manageability aspects of this release. I'll review the general concepts behind the management interfaces, namely the GUI and the new Administration API, and will also touch on these two interfaces.
I will dedicate separate posts to each of them in future to keep things in a digestible size.

One of the main issues with previous releases was that the tooling behind the product provided a lot of information about the GigaSpaces runtime, but the data was not fully organized according the product's domain model, and the tools did not expose all of the capabilities that you would have expected. In this release we have gone a great to deal to make sure the management interfaces are comprehensive, coherent, easy to use and accurately reflect to product's domain model.

The GigaSpaces Domain Model
GigaSpaces is very simple to understand if you look at things hierarchically, starting from the physical infrastructure and ending at the application level.

The physical infrastructure level:
At the bottom level, you have the physical infrastructure, which includes the physical (or virtual, if you're running on the cloud) hosts. Information about this level includes CPU, memory and network utilization, and naturally machine level properties such as operating system, processor architecture, etc.

The process/JVM level:
The next level is the JVM level, which hosts three main components:
  • The GigaSpaces container (GSC) - this is a lightweight container, which hosts deployed application instances (e.g. a data grid instance, a Spring application or a web application instance). It's in fact a meta container, which exposes SLA and manageability capabilities on top of other lightweight containers such as Spring or Jetty.
  • The GigaSpaces manager (GSM) - this is the actual deployment manager. You deploy your application to the GSM, which takes care of provisioning application instances to the running GSCs and mobilizing the deployed application binaries to these GSCs. It is also responsible for monitoring the state of the deployed applications and using the GSCs to enforce the SLA requirements, e.g. take action if a certain application instance fails
  • The GigaSpaces agent (GSA) - New in 7.0. Think of it as a daemon or a background service which simply start and stops the other services (GSM, GSC) and receives remote commands from the management interface (GUI or admin API)
Information about this layer includes JVM systems properties, JVM stats (available heap size, number threads, GC stats, etc.) and information specific to the above components, such as the applications managed by a specific GSM or the application instances running on a certain GSC. This layer can also be actively managed, e.g. start, stop and restart components.

The processing unit (application) level: The next level is the processing unit level. A processing unit is, simply put, the deployment and packaging unit. A certain application can be composed of one or more processing units. A processing unit can take multiple forms, but in general we distinguish between 3 types of processing units:
  • Data only, which only contains a data grid
  • Business logic only, which contains application code which may or may not access a data grid, but does not host the actual data grid instance
  • Data and business logic, which contains both the data grid and business logic, which in most cases interacts with the embedded data grid in memory to achieve the lowest possible latency the highest level of scalability
Once deployed, the processing unit has one or more instances, e.g. a data only processing unit with 5 space partitions would have 5 instances. If we define a backup to each of the partitions then it would have 10 instances. Typically, the processing unit is configured via Spring, with custom GigaSpaces namespace bindings to reflect the SLA associated with it and the GigaSpaces components it may contain. Furthermore, in version 6.6, we have also implemented processing units which are plain JEE web applications, Mule applications or even .Net applications. This can be thought of as a mere extension to the basic processing unit model (after all, all of the above also run business logic and may or may not contain a space).
Information about this layer includes the processing unit's name, type, number of instances, its contents, e.g. space instances, web application instances, exposed remote service and so on.
It also includes runtime statistics like the throughput of space operations, web requests per second if it's a JEE web app, and many more runtime characteristics.
Operations that can be taken on this layer include deployment, undeployment, relocation from one GSC to another, restart of a certain instance, increment/decrement the number of instances, etc.

The following diagram depicts the above (click to enlarge):

The management interfaces
Let's start with the admin API. This is a completely new API, which gives you full control over the entire lifecycle of the GigaSpaces runtime components.
Using this API, you can start and stop any GigaSpaces component (literally, at the JVM process level!) or even your own custom components, deploy and undeploy your processing units, and monitor almost any aspect you can think of using either polling or event based notifications.
Monitorable entities are all the ones mentioned above, namely the physical hosts (CPU, memory, network utilization), JVMs (number of threads, available heap memory, object count, etc.), deployed processing units (transactions committed, space data, JEE requests stats) or even the underlying network layer.
The main benefit of this API, besides it's cleanliness and completeness, is that opens a variety of options to extend the core product functionality, e.g. implement sophisticated cluster-side bootstrapping, easily integrate with any 3rd party monitoring tools, implement automatic scaling for your web application (as shown in my latest webinar) and much more. But that's something I'll cover in detail in a separate post.

As for the GUI, it also caters for all of the above, but allows to view everything graphically (and as they say, a picture is worth a thousand words). We used the excellent Balsamiq Mockup tool to quickly create sketches of the way we want to see things, and from there the job went fairly smoothly. The user interface is now divided into 3 main tabs:
  • Hosts: which gives a physical view of things, but also shows the entire component hierarchy described above
  • Applications: which focuses on the logical side of things, namely deployed processing unit and the components they contain
  • Space browser: a pure data-grid only view to enable you to focus on data grid aspects
Naturally, besides viewing things you are also able to operate on the cluster and do all the above mentioned operations using the UI (.e.g. restart a certain JVM, relocate a running processing unit instance from on host to another, or even increase the number of processing unit instances).
The following image shows how we went from mockup to real implementation (in this case showing the "Hosts" view):

I encourage you to give it a try and let us know what you think. Naturally this milestone 8 and not the final release so there are a few more tweaks and improvements we will add, but this can give you the general sense of things.


Wednesday, March 25, 2009

My Session at the Banking and Finance Technology Forum in HK

You're welcome to view my session from the annual Banking and Finance Technology Forum held last week in Hong Kong. The session is 20 minutes long, and deals with the challenges in developing and deploying applications on the cloud as opposed to your local IT environment.
I want to take the opportunity and thank our partners at Cluster Technologies for setting up a very nice booth and making all the arrangements for the conference.
As always, HK was action packed. Besides the conference, I had some very good meetings with various customers and prospects that focused on our upcoming 7.0 release and the GigaSpaces-Mule integration package which seems to be gaining quite a nice momentum these days.


Sunday, February 22, 2009

Scalable SOA with Mule & GigaSpaces

If you missed the joint Webinar Ken Yagen of MuleSource and I did last week, you can find the recorded version here. The demo application shown during the webinar can be downloaded here.
The demo application requires the following to be installed on your machine: Please note that the Mule/GigaSpaces integration is also available in the latest GigaSpaces GA release (6.6.x), but XAP 6.6.x only supports the Mule 2.0 branch and not 2.1.
The documentation for the integration can be found here (6.6.3) and here (7.0 EA).
If you have any question please drop me a note here or use our online forums.

I would like to take the opportunity and thank Ken and the rest of the team at MuleSource for hosting this webinar and giving us the chance to present the joint solution to the community.


Tuesday, February 10, 2009

Scalable SOA - with Mule & GigaSpaces

You are welcome to join Ken Yagen, Sr. Director of Engineering at MuleSource, and myself for our joint webinar on scaling your SOA implementation with GigaSpaces and Mule. The webinar will take place on Wednesday, February 11th 2009, at 9am PT / noon ET / 6pm CET.
In this webinar we will introduce the Mule & GigaSpaces joint solution and discuss the underlying details around how this integration works. We will also discuss a real life use case and present a short demo that shows the benefits of this integration.

See you there!