Friday Jun 17, 2016

Updated Best Practices Whitepaper

An updated Best Practices Whitepaper has been posted to the "Lean More" tab of the Oracle Technology Network Coherence page.  This white paper is a major revision of an older whitepaper developed for earlier versions of Coherence.  

The paper includes sections on

  • Design and Development
  • All Aspects of Testing (production, soak, load/stress, software and hardware failure, recovery...)
  • Capacity Planning
  • Setting up a Production Environment 

All new features of Coherence 12.2.1 are discussed, including

  • Persistence
  • Federated Caching
  • Distributed Java 8 Lambdas and Streams  
Happy reading!  Please send me any comments or requests for future updates.

 

 

Wednesday Jun 08, 2016

Docker support for Oracle Coherence

I’m very glad to announce the availability of Coherence on Docker.  While it has been possible to run Coherence within Docker for some time, those deployments were limited by lack of multihost networking in Docker. Since Coherence is multihost in almost all real deployments, this was quite limiting.  

Docker support is provided as a Coherence Community Project at https://coherence.java.net/.  This will take you to a github repository where all Oracle Docker projects live.  There you will find instructions on building Docker images, documentation for setting up a Coherence cluster with Docker, and special topics around enabling Coherence Extend, Federated Caching, Persistence, Elastic Data, and JMX.  

Docker is supported with Coherence 12.2.1+ and Docker 1.9+, and is, of course, limited to platforms supported by those technologies.  

A list of issues is also provided.  

We welcome all feedback.  

Tuesday May 10, 2016

CoherenceRx: Reactive Extensions for Oracle Coherence

We are pleased to announce the release of a new Oracle Coherence Community open source project.  The CoherenceRx project provides a reactive API for the Oracle Coherence in-memory data grid, based on the popular RxJava library.

It is implemented as a thin wrapper around the Oracle Coherence Asynchronous API, which implies that it requires Coherence 12.2.1 or a newer release.

Why CoherenceRx?

Reactive Programming is somewhat of an all-or-nothing proposition, or as Andre Staltz pointed out in his excellent tutorial:

Everything is a Stream

When you are writing a reactive application and need to access a data source that doesn't provide a reactive API, life can get complicated. In order to simplify our users' lives we decided to implement CoherenceRx and release it as an open source add-on for Coherence.

Using CoherenceRx

The easiest way to include CoherenceRx into your own project is to add it as a Maven dependency (along with Coherence itself and RxJava):

<dependency>
  <groupId>com.oracle.coherence</groupId>
  <artifactId>coherence</artifactId>
  <version>${coherence.version}</version>
</dependency>

<dependency>
  <groupId>com.oracle.coherence</groupId>
  <artifactId>coherence-rx</artifactId>
  <version>${coherence-rx.version}</version>
</dependency>

<dependency>
  <groupId>io.reactivex</groupId>
  <artifactId>rxjava</artifactId>
  <version>${rxjava.version}</version>
</dependency>

and configure versions within Maven properties section:

<coherence.version>12.2.1-0-0</coherence.version>
<coherence-rx.version>1.0.0</coherence-rx.version>
<rxjava.version>1.1.0</rxjava.version>

Once you have the necessary dependencies properly configured, you can use the static RxNamedCache.rx method to create an instance of RxNamedCache:

NamedCache<Long, Product>   cache   = CacheFactory.getTypedCache("trades", withTypes(Long.class, Product.class));
RxNamedCache<Long, Product> rxCache = RxNamedCache.rx(cache);

Of course, you can also use static import for the RxNamedCache.rx method, which would make the code even simpler.

The RxNamedCache interface will be familiar to anyone who has used Coherence NamedCache API before, with one major difference: all the methods return an Observable.

For example, RxNamedCache.get will return an Observable<V> which will eventually emit the value of the cache entry for the given key and complete:

rxCache.get(5L).subscribe(product -> System.out.println("Got: " + product));

Another important difference is that the bulk read operations, such as getAll, keySet, entrySet and values do not return a single container value like their NamedCache counterparts, but an Observable stream of individual values:

rxCache.values().subscribe(product -> System.out.println("Got: " + product));

This is both more efficient, as it doesn't realize full result set on the client, and simpler, as it allows you to process each individual value as it is emitted by the underlying Observable.

For example, if you wanted to process batches of 10 products at a time, you could trivially accomplish that using bufferoperation:

rxCache.values()
       .buffer(10)
       .subscribe(productList -> System.out.println("Got: " + productList));

Observing Event Streams

Oracle Coherence provides rich event notification functionality, so it only made sense to provide an adapter that allows you to use RxJava to process stream of event notifications.

CoherenceRx introduces ObservableMapListener, which extends RxJava Observable and implements CoherenceMapListener interface. The ObservableMapListener simply propagates each received event to all of its subscribers:

ObservableMapListener<Long, Product> listener = ObservableMapListener.create();
listener.subscribe(System.out::println);

cache.addMapListener(listener);

The above is not very interesting, and could be easily achieved using standard SimpleMapListener. But it becomes a lot more interesting when you start applying various RxJava operators to transform, filter and even combine event streams:

ObservableMapListener<Long, Trade> listener = ObservableMapListener.create();
listener.filter(evt -> evt.getId() == MapEvent.ENTRY_INSERTED)
        .map(MapEvent::getNewValue)
        .buffer(10, TimeUnit.SECONDS)
        .subscribe(trades -> System.out.println("Trades placed in the last 10 seconds: " + trades));

cache.addMapListener(listener);

It is important to note that unlike Observables returned by the RxNamedCache methods, which are 'cold', the ObservableMapListener is a 'hot' Observable and will start receiving and processing the events as soon as it is registered with the cache using NamedCache.addMapListener method.

Because of that, it is important that you add Subscribers to it before calling NamedCache.addMapListener, or you could miss some events.

Feedback

CoherenceRx is the latest example of how Oracle Coherence continues to improve the developer experience when working with In-Memory Data Grid platforms.  In the past several months, we have provided groundbreaking support for Distributed Java 8 Lambdas and Streams, a new Async API based on CompletableFutures, and, now, support for Reactive Programming.  We welcome feedback on the CoherenceRx project in the comments section below, or, as you use it, you can file issues on the GitHub project page.

Thursday Nov 19, 2015

Coherence Forums and Support

Do you know that you have ways of getting Coherence support beyond the standard Service Request process? We currently have multiple online forums where you can submit questions about Coherence. In an effort to encourage more open communication, the Coherence team is consolidating these forums.

  • The Coherence My Oracle Support Community (MOSC) has been available to customers with a paid Oracle support contract, and is lightly trafficked. This site will be retired.
  • The Oracle Technology Network (OTN) support forums on https://community.oracle.com/community/fusion_middleware/coherence allow anyone to post and answer questions about Coherence. This is a more heavily used community forum, and we are encouraging increased usage of this resource.

We hope that this consolidation will provide a more active and open discussion around use cases, design questions, and issues.

The Coherence MOS Community also provided convenient links to other resources, and we would like to ensure that you know how to access these resources once the site is retired.

As an Oracle customer with a current Support Contract has access to MyOracleSupport , have access to Support Notes, Knowledge Documents, and the ability to log a Service Request. You can access all this through MOS:

1. Log onto MyOracleSupport (https://support.oracle.com)

2. To access Knowledge Documents enter the product name and some search terms:

3.  This is the screen you see after clicking on Search:

4.  Click on the title of the Knowledge Document you would like to view

5. For the most timely and official resolution of issues, please log a Service Request with from the Dashboard (Bottom right) or the Service Request tab. This requires more detailed information about the product, version etc. We always encourage you to upload a description of the use case, deployment information, configuration files, and log files. For some Service Requests, we may ask you for stack traces, memory dumps, GC logs or other information. The faster you can provide us with this information, the faster we will be able to resolve any issue you may be having.

6.  The News and Getting started sections on the left are very useful for general information about Oracle support.

7.  Access to Coherence Information and Documentation.

8.  As mentioned above, you can access the Coherence OTN Community to ask questions to a wide audience including partners and customers.

9.  We highly recommend that you look at the following knowledge documents:

  • Oracle Support Accreditation - Series Index (Doc ID 1583898.1)
  • Oracle Support Accreditation Series for Level 1 My Oracle Support (Doc ID 1579751.1)
  • Oracle Support Accreditation Series - Oracle Fusion Middleware (Doc ID 1584011.1)

Tuesday Oct 27, 2015

Oracle Coherence 12cR2 Offers Major New Innovations

We are very happy to announce major new innovations with the release of Oracle Coherence 12.2.1 This release is one of the largest we have done and delivers several major features aimed at both developers and operations that improve developer productivity, support infrastructure consolidation, provide better security, and simplify multi-datacenter solutions. We are also announcing a new licensing option for low-cost deployment of small-to-medium sized deployments.

New Features

Coherence 12.2.1 is packed with major new features and capabilities:

  • The new Persistence feature enables Coherence to be a system-of-record and improves time-to-recovery from planned or unplanned, partial or total, cluster outage. Persistence can be configured to work in an on-line mode persisting changes as they are made to the cluster, or to take a snapshot of a data grid. Local disk configuration maximizes scalability, while network-attached storage maximizes availability.   Both data and metadata (indexes, listeners, expiry, locks, etc.) are stored, and recovery is completely automatic.
  • Federated Caching provides support for Active-Active, Active-Passive, Hub and Spoke, and custom multi-datacenter topologies. Implemented at the lowest level of Coherence, Federated Caching takes advantage of Message Bus, Elastic Data, and our new Persistence feature to improve scalability, durability, latency, and configurability of data replication over prior solutions.  
  • Coherence Multitenancy allows WebLogic Server Multitenant applications to share a cluster across a set of tenants and applications, consolidating infrastructure requirements. Multitenancy provides tenant-specific caches as well as shared caches for hosting reference data.  It is fully integrated with Oracle Traffic Director, WebLogic Server, and the Oracle Database to provide an end-to-end multitenant solution.
  • One of our most exciting new features is the integration we have done with Java 8 to provide Distributed Lambdas and Streams. We now provide the ability to execute Lambdas and Streams remotely, using standard Java 8, distributed across cluster members, without the need to deploy code on cluster servers. This provides the ability to do distributed, parallelized stream-based functional programming.  By reducing the need to deploy classes to servers, we have also greatly simplified application upgrade.
  • New Security Features include the ability to do fine-grained Authorization and Auditing of all cache access and updates.   We have also improved our SSL support.
  • For developers, we have also added support for Asynchronous Cache operations via Java 8 CompletableFutures for quicker, parallel execution of multiple tasks as well as a Streaming Async API to improve performance and reduce memory pressure on bulk reads. We also offer improved Generics Support.
  • Customers will notice increased performance from near cache optimizations and automatic, dynamic thread pool tuning. 
  • We have improved cluster and port management, and switched data communications to run over TCP via the TCP Message Bus. We also provide Dynamic Coherence Management Node for Management HA.
  • We also have a number of other goodies, including support for Sliding Expiry, a new cache truncate operation, REST Server-Sent Events, and JSON Passthrough that improve the developer experience and offer new functionality.

New Packaging and Licensing Options

We also offer new (and sometimes free!) options for deploying Coherence in production.

  • Coherence Standard Edition One replaces Standard Edition.   SE One is a low-priced ($800 / socket) dual-server Active/Standby solution that provides all Coherence APIs from Java, REST, JCache, and Memcached clients. It is perfect for smaller deployments where you data fits into a single node, e.g. anywhere up to around 20GB or larger depending on your tolerance for larger GC pauses and need for scale-out. SE One also includes the new Persistence features.
    • The good news around SE One does not end there.  SE One is included in Java SE Advanced (with the limitation that it is a single-server deployment with no standby).
    • Since WebLogic Server Enterprise Edition includes Java SE Advanced, WebLogic customers can now deploy Coherence for free in configurations not needing scale-out or advanced features of Enterprise and Grid Edition.
    • Customers needing the scale-out or other features of Coherence Enterprise Edition or Grid Edition can upgrade without code change since SE One provides the full Coherence API.
  • Real-Time Extend Data Clients are now included for free in every Coherence edition to provide deployment flexibility.  No longer do you need to decide whether you will use near cache or whether you will use an Extend proxy before you choose the appropriate Coherence edition.
  • Persistence is part of every Coherence edition. 
  • WebLogic Server Multitenant and WebLogic Server Continuous Availability  both provide the right to upgrade from Enterprise Edition to Grid Edition. If you own Coherence Enterprise Edition or WebLogic Suite and by WLS MT or CA, you will be able to deploy Coherence GE to take advantage of multitenant and continuous availability features of Coherence in your WLS applications.
  • Finally, we have improved our Free Developer’s License on OTN to allow developers to use Coherence for free in development even after Coherence has been deployed in production. 

I hope this has whet your appetite for Coherence 12.2.1. As you can tell, I am quite excited about it. Please check Coherence 12.2.1 Documentation for more information on the features above and watch as deep-dive videos from our engineering team are added to the YouTube OracleCoherence Channel over the next few days. 

Wednesday Oct 14, 2015

Oracle Coherence recognized as a leader in new Forrester Wave report

Oracle Coherence has been cited as leader and top ranked across several categories in a new Forrester Research report.  The Forrester Wave™: In Memory Data Grids, Q3 2015.  The report, which is subtitled “There Is No Better Way To Achieve Blazing Fast Performance At Scale” analyzes features, market presence, and roadmap of eleven vendors in the In-Memory Data Grid space.

[Read More]

Tuesday Jun 16, 2015

Coming Up, the next London Coherence SIG on 2nd July 2015

The next London Coherence Special Interest Group (SIG) meeting will be on Thursday 2nd July at the Oracle London City Office. This is a unique Oracle Coherence event, where customers, engineers, architects and product managers will provide an overview of innovative features, the Coherence Cloud Service, integrations with complimentary technologies and a preview of what's coming up in the next release.

[Read More]

Tuesday Mar 17, 2015

Coherence Patches and Releases

If you encounter a problem with Coherence and want to see if its fixed in the latest patch, you can find all the information you need on the Coherence Community home page. It provides links to all the latest releases for both Java, .NET and C++. It's also available from this RSS feed, if you want to be notifications as new releases become available.[Read More]

Wednesday Mar 04, 2015

Coherence is in the Cloud as Part of Java Cloud Service

This entry is reposted from the new cloud-focused blog at Oracle, "The Cloud Front."

 

Today we are excited to announce a major product innovation - Oracle Coherence is now available as a feature of the Java Cloud Service (JCS). Effective immediately, users of JCS can use our cloud tooling to optionally set up Coherence within JCS.

Flexibility is a key part of the solution. You can either select an initial capacity for the Coherence data tier:

Or use the "Advanced" option to have full control over the number of virtual machines you want for Coherence, the number of managed Coherence servers per virtual machine, and the heap size of each managed server: 

The WebLogic Management Framework is used under the covers allowing you, the user to develop, deploy, manage and monitor your applications via Managed Coherence Servers.

Because the same cloud tooling creates both WebLogic and Coherence, the experience of using the two together in our cloud is a fully integrated and seamless service. As is standard with JCS, you can patch Coherence as you please in an automated rolling fashion. Backups and restores are fully coordinated with the rest of the stack.

Common reasons for using Coherence with JCS:

  • Offload and protect shared cloud services and databases
  • Deliver real-time data to cloud applications
  • Provide transparency and high availability in the cloud's data grid tier

When running a WebLogic 12.1.3+ environment in the Java Cloud Service you have access to all the Coherence cloud tooling. For Java Cloud Service Enterprise Edition 11g with Coherence, you can manually create your own Coherence cluster.

Over the coming year, we plan to release a number of Coherence-related data grid and caching services. Stay tuned for more details. 

For more information:

Sunday Feb 08, 2015

Coming Up, the Los Angeles Coherence SIG on March 5th

This is a unique Oracle Coherence event in Los Angeles, where engineers, architects and product managers will provide a detailed overview of its innovative features and a preview of what's coming up in the next release.

A full agenda for the event and details about how to register are available on-line here. Some of the topics covered include: 
  • Strategic Direction and Roadmap for Coherence 
  • Coherence Data Management - from disk to data-centre 
  • Coherence in the Oracle Cloud 
  • Coherence and Java 8, "made for each other"
[Read More]

Coming Up, the London Coherence SIG on March 19th

The next London Coherence SIG will be on March 19th 2015. This is a great opportunity to hear from engineers, architects and product managers about innovative features, integrations with complimentary technologies and a preview of what's coming up in the next release and the Oracle Cloud.

A full agenda for the event and details about how to register are available on-line here. Some of the topics that will be covered include: 
  • Scalable real-time event processing with Coherence and Oracle Event Processor 
  • Coherence and Java 8 - seamless and asynchronous 
  • Coherence in the Oracle Cloud 
  • Coherence and Big Data, where do they fit?
[Read More]

Tuesday Jan 27, 2015

Spinning-up a Coherence Cluster with Weblogic Scripting (WLST)

The WebLogic scripting and management features available with Coherence 12c Managed Servers make it easy to create Coherence clusters and manage applications. Using the Weblogic Scripting Tool (WLST),  the whole lifecycle of Managed Coherence Servers can be controlled, from creating and starting a Coherence cluster to deploying Coherence applications.

WLST scripts are written in Jython and can manipulate Weblogic JMX MBean's to manage Weblogic and Coherence. The flexibility and power they provide make it easy to create, configure and startup up a complete Coherence environment - in just a few minutes.  This post will outline how to do just this, using some sample WLST scripts.

Read more here.


Tuesday Dec 02, 2014

Coherence Special Interest Groups [SIGs] Coming to Asia-Pacific!



The Coherence Special Interest Groups [SIGs] are coming to APAC!
Quick jump to Shenzen Dec 8 Beijing Dec 10 Seoul Dec 12 Melbourne Dec 15

We've invested a lot of energy over the years to be sure that you have local or semi-local access to Coherence product management and technical staff. Coming up in this round of APAC SIGs, we have myriad topics that you'll find valuable, including showcasing some customer use patterns, advances in database connectivity, real-time data processing and much more.

You'll also hear a lot about our next major release (12.2.1) and get a sneak peek at some of the new technologies we're including for developers, including utilizing Java 8 (yes, Java 8 - you heard right), and support for maximum-availability architecture [MAA] across multiple data centers.

If you're in China, Korea or Australia, these are can't-miss events! We look forward to seeing you there!

Shenzen, China, December 8
10 a.m. - 4 pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, Best Practices, Real-Time Persistence and Snapshotting, and more.
Full agenda

Beijing, China, December 10
10 a.m. - 4:00 pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, Best Practices, Real-Time Persistence and Snapshotting, and more.
Full agenda

Seoul, Korea, December 12
9 a.m. - 4:00 pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, customer use cases, Database Synchronization, Real-Time Persistence and Snapshotting, and more.
Full agenda

Melbourne, Australia, December 15
10 a.m. - 4:45 pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, Coherence + Java 8, Real-Time Cache Persistence and more.
Full agenda

Thursday Oct 30, 2014

What's the Difference Between In-Memory Database and In-Memory Data Grids?

We've gotten a lot of questions recently about the differences between Oracle's announced in-memory database and in-memory data grid technologies like Coherence. Let's clear that up, with a dusted-off excerpt from our "State of the Union" blog a couple of months ago. Just in case you missed it.

The In-Memory Database option has led to confusion in the In-Memory Data Grid market
Let us try to clarify some of the confusion.
Oracle Coherence is not embedded in the In-Memory Option for the Oracle Database. Although we have seen rumors of this to the contrary, this would make absolutely no sense. Coherence is a distributed key-value store; the in-memory option is a columnar store. The In-Memory option is purpose built and optimized to work as one with the database with its primary access method being SQL. (Of course, Coherence is part of many other Oracle solutions, such as Oracle Service Bus which offers web services results caching via a check box, or the Elastic Charging Engine, which is architected on top of Coherence’s fault-tolerant distributed processing.  As you can see, Coherence has become strategic within Oracle.)

The In-Memory Option focuses on different use cases than Coherence. In-Memory focuses on ad-hoc full-table scans of unindexed data.  In the words of Maria Colgan "The main use case for the In-Memory column store is fast analytics, which has very different access patterns to OLTP. Typically analytic queries access a few columns from a table but they examine all of the entries in those columns. You need to scan the whole table or segment, not just a small part of the table to answer these queries.” Storing these columns in-memory, in columnar format, speeds full-table scans orders of magnitude.

By contrast, Coherence focuses on providing scale-out data management and processing to middleware applications thereby reducing load on shared services such as databases, mainframes, and web services.  By caching data in domain object format close the application, Coherence also increases responsiveness and availability of applications. 

Hopefully, this helps you understand some key differences and benefits. 

Monday Oct 27, 2014

Coherence SIGs Coming to Europe in November!



The Coherence Special Interest Groups [SIGs] are coming to a town near you!
Quick jump to Munich Nov 4 Stockholm Nov 5 London Nov 7 Madrid Nov 12

We've invested a lot of energy over the years to be sure that you have local or semi-local access to Coherence product management and technical staff. Coming up in this round of SIGs, we have myriad topics that you'll find valuable, including showcasing the innovative usage of some of our recent 12c release features like HotCache (to keep your cache always-fresh) and Live Events for in-grid data processing.

You'll also hear a lot about our next major release (12.2.1) and get a sneak peek at some of the advances we're making for developers utilizing Java 8 (yes, Java 8 - you heard right), and support for maximum-availability architecture [MAA] across multiple data centers.

Finally, for customers of multiple Oracle products, we're participating in several Cloud Application Foundation SIGs that will incorporate WebLogic and Java at a holistic level. We look forward to seeing you there!

Munich, November 4 [with WebLogic & Java]
9 a.m. - 2:45pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, WebLogic for Java EE Multitenancy, Java 8, Cache and Database Synchronization and more.
Full agenda

Stockholm, November 5 [with WebLogic & Java]
9 a.m. - 2:15pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, WebLogic for Java EE Multitenancy, Java 8, Cache and Database Synchronization and more.
Full agenda

London, November 7
10 a.m. - 4:45pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, Coherence + Java 8, Managing Mission-Critical Large Clusters and more.
Full agenda

Madrid, November 12
9 a.m. - 1:00pm
REGISTER | DIRECTIONS
Agenda topics include Coherence road maps, Coherence + Java 8, Real-Time Cache Persistence and more.
Full agenda

About

Oracle Coherence, the market leading in-memory datagrid product.
Stay Connected...

Search

Archives
« June 2016
SunMonTueWedThuFriSat
   
1
2
3
4
5
6
7
9
10
11
12
13
14
15
16
18
19
20
21
22
23
24
25
26
27
28
29
30
  
       
Today