Release Notes NCache 4.1

Tuesday, August 23, 2011

Introduction

NCache 4.1 has introduced very important new features and enhancements that are critical for enterprise level applications. This new release gives a whole new package for run time data sharing between multiple platforms (java & .Net). Java has been made 100% compatible with .NET and now you can even plug-in your Java code with NCache process. NCache request-response model has also been enhanced to handle large responses where GBs of data can be retrieved from the clustered cache in a single request. All the bugs that were reported in earlier release have been fixed in this release.

Enhancements and New Additions

For a comprehensive list of ALL FEATURES in 4.1, please read NCache Features:

  1. Runtime Data Sharing between .NET & Java:
  2. NCache now allows you to store either .NET objects in the cache and read them as Java objects from your Java applications, or vice versa. And, instead of doing .NET to Java transformation through XML, NCache uses binary-level transformation. As a result, the performance is super fast. NCache automatically resolves type conflicts between Java and .NET.

    You can also utilize multiple versions in Runtime Data Sharing between .NET and Java. See details below.

  3. Multiple Objects Version Support (.NET & Java):
  4. You can now share multiple versions of the same .NET or Java classes across multiple applications. One application may be using version 1.0 of a class while another application may have a later version 2.0 of this same class. When version 2.0 of this class is stored in the cache, the earlier application can still fetch this class as version 1.0, and vice versa. NCache lets you configure version mappings through XML configuration files.

    You can utilize version also in Runtime Data Sharing between .NET and Java.

  5. Continuous Query (.NET & Java):
  6. NCache lets you specify a data-set based on an SQL-like query. It then maintains this data-set in the cache cluster for you and monitors any runtime changes in it, including Additions, updates, or deletes. And, NCache notifies your application whenever any of these changes occur in the dataset. This allows your applications to more intelligently monitor for either data changes or addition of data matching a certain criteria and be notified by NCache.

    This is a powerful feature if you want to share data at runtime between multiple applications.

  7. Much Enhanced Bridge Topology:
  8. Bridge Topology allows you to intelligently and asynchronously replicate the entire cache across the WAN. NCache 4.1 now offer four different configurations in Bridge Topology. They are:

    1. Active/Passive: In this configuration, one cache is active and the other passive. Whatever updates you make to the active cache are asynchronously applied to the passive cache by the Bridge.Since the connection between active and passive is across the WAN, it is likely to be unstable. But, the Bridge is ware of it and if the connection breaks, it automatically reestablishes it.
    2. Active/Active:In this configuration, both caches are active and the Bridge receives update requests from both sides. Both caches are also maintaining an identical “clock” for time-stamping. This clock is synchronized through the Bridge. Whenever there is a conflict, meaning the same cache item is being updated in both caches, it is resolved by default on a last-update-wins strategy. But, if you want, you can provide a custom resolution handler which is invoked in case of a conflict. You can then determine which update should stay and which one should be discarded.
    3. Hub-Spoke: Star: This configuration looks identical to a Hub-Spoke except that all the Spokes are also active. In this configuration, there is one centralized cache and multiple satellite active caches. All updates are synchronized through the centralized cache to ensure consistency.
  9. Named Tags (.NET & Java):
  10. Previously, you could only assign tags as values. Now, you can assign tags with names. This allows you to index data based on attribute name and attribute value concept. Previously, you could index objects but all string data could not be indexed. Now, even string data (e.g. XML) could be indexed with named tags. Then, you could either use NCache API to fetch data belonging to one or more named tags or you could issue SQL-like query (through LINQ or OQL) for it.

  11. Java Features Now 100% Equivalent to .NET:
  12. NCache 4.1 brings support for Java at the same level as .NET. Here are the new Java based features intended to catch up to .NET feature-set:

    • Java Client API 100% equivalent to .NET
    • Java Client Cache (InProc):
    • You can now use Client Cache feature in Java applications on Windows or Unix. There is no code change required in your applications to enable Client Cache.

    • Java Client Cache (InProc):
    • You can now use Client Cache feature in Java applications on Windows or Unix. There is no code change required in your applications to enable Client Cache.

    • Cache Loader in Java:
    • Write your cache loading code in Java and register it with NCache. Your native Java code will run on cache servers just like the .NET code.

    • Dynamic Compact Serialization for Java:
    • Now, you can register your Java classes with NCache and NCache generates their serialization code at initialization time, compiles it in-memory, and sends it to NCache clients. This compiled Java code is then run to serialize/de-serialize your Java classes. This obviously speeds up your performance because compiled serialization code runs much faster than Reflection based serialization that is otherwise done in Java.

    • Spring/Hibernate Support:
    • NCache now provides an L2 Cache for Hibernate. This allows you to start using NCache without making any code changes in your Java application.

    • Multi-Response Model:
    • NCache now allows the cache servers to return larger response in smaller chunks for a given request. This improves the overall cache performance because the serialization cost reduces with the size and also helps applications to fetch larger data sets in a single call. It also eliminates the .NET serialization limitation where it fails to serialize data size larger than 1.9 GB. Response threshold and chunk size both are configurable and can be modified from NCache service config file “NCache\bin\service\ Alachisoft.NCache.Service.exe.config”
      <add key="NCacheServer.ResponseDataSize" value="1024"/>

List of Bugs Fixed:

  • 741001 FIX: When using Client-Cache GetCacheItem returns incorrect Group name.
  • 741002 FIX: Object Query does not work if the IN operator has just one parameter e.g Select Northwind.Customers where this.City In(?).
  • 741003 FIX: Alachisoft.NCache.Web.dll is missing in “4.0 GAC” folder in 64 bit remote client installation of NCache.
  • 741004 FIX: Alachisoft.NCache.Security.dll (32 bit) missing in Developer installation.
  • 741005 FIX: When a node joins the cluster the State transfer throws an object reference not set exception in cache server log file. This happens if one write through provider is configured with write behind enabled.
  • 741006 FIX: In a two or three node partitioned replica cluster, if a node goes down and immediately comes back before the state transfer is completed, items are lost.
  • 741007 FIX: If the indexed items are also associated with tags, the LINQ query without any where clause may return an exception that the key is already added in the dictionary. This was happening because of duplicate keys were added in the result.
  • 741008 FIX: Cannot increase the cache size at runtime from NCache Manager.
  • 741009 FIX: Cache server sends multiple status inquiry requests to the other cache server if it does not receive a response in a certain time for a given request. In case of network failures or cache node unresponsiveness the request queue becomes full and timeout errors are thrown to the user. This status inquiry mechanism is now disabled by default and can be turned on through NCache service config file.
  • 741010 FIX: If there are two or more caches running on the same machines and both are using TAG feature then you may get object reference not set errors in the cache server log files. This may also slow down the cache response in some situations. This has been fixed.
  • 741011 FIX: If the response size is larger than 1.9 GB the cache will hang and clients will timeout. This happens because of the .NET serialization limitation. This happens usually with bulk operations like Queries, Tags, Groups, and bulk operations.

Signup for monthly email newsletter to get latest updates.

Contact Us

PHONE

+1 (214) 764-6933 (US)

+44 20 7993 8327 (UK)

© Copyright Alachisoft 2002 - . All rights reserved.