What is Ice?
With Ice, network interactions are operations called on remote objects. Familiar object-oriented idioms allow you to design elegant and powerful networked applications.
There is no need to worry about details such as opening network connections, serializing and deserializing data for network transmission, or retrying failed connection attempts (just to name a few things).
Language and Operating System Interoperability
Write your client in one language, your server in another, and run them on your favorite platforms. It's all seamless; your client and server are unaware of the language and platform the other is using.
Define the contract between your client and server using Ice's IDL, Slice.
Slice provides a rich set of data types that cleanly maps to all supported languages. User-defined types include enumerations, structures, sequences, and dictionaries, as well as classes and exceptions. Classes support pointer semantics, so complex graphs of objects can be passed over the wire.
Ice is Flexible
Make synchronous and asynchronous invocations using TCP, UDP, SSL/TLS, and WebSockets. Bidirectional connections allow a server to reuse a connection established by a client to make callbacks.
Synchronous and Asynchronous
Ice supports both synchronous (blocking) and asynchronous (non-blocking) invocations. With a synchronous invocation, the caller's thread blocks until the RPC has completed. An asynchronous invocation allows the caller to continue using the thread while the RPC is in progress and to be notified of the result.
On the server side, Ice supports both synchronous and asynchronous dispatch. The default is synchronous dispatch, where a server's thread reads the request, then locates and executes the implementation. With an asynchronous dispatch, the server's thread gives a callback to the implementation and is immediately available for additional requests. The implementation provides the result asynchronously through the callback.
An Ice connection normally allows requests to flow in only one direction. If your application requires the server to make callbacks to a client, the server usually establishes a new connection to that client in order to send a callback request. Network restrictions often prevent a server from being able to create a separate connection to the client, such as when the client resides behind a firewall.
A bidirectional connection offers a solution. Requests may flow in both directions over a bidirectional connection, allowing a server to send callback requests to a client over the client's existing connection to the server.
A Slice compiler will map each Slice type to a default type in the target language. You can also customize this mapping. For example, a Slice
sequence<string> becomes by default a
std::vector<string> in C++ and a
String in Java. Slice metadata allows you to generate another compatible type, such as
std::list<string> in C++ and
java.util.List<String> in Java.
Dynamic Invocation and Dispatch
Besides static invocation and dispatch, which rely on compiled Slice definitions, Ice supports dynamic invocation and dispatch, which delay the decision as to which types are used for communication until run time. This feature permits you to create applications (such as routers and protocol bridges) that must deal with Slice types that are unknown at compile time.
Ice is Secure
Ice offers powerful and easy to use security features. The IceSSL plug-in uses your operating system's SSL/TLS stack to encrypt your data and authenticate your connections.
// Stringified proxy for an object reachable through a wss endpoint
string strProxy = "hello:wss -h localhost -p 5064";
// Create a proxy from stringified representation
auto hello = Ice::checkedCast<HelloPrx>(communicator->stringToProxy(strProxy));
// sayHello over a secure websocket connection
Ice is Fast
Ice uses a compact, efficient binary protocol to minimize CPU and bandwidth consumption.
Efficient Binary Protocol
Ice was designed from the ground up for applications that require the utmost in performance and scalability. At the network level, Ice uses an efficient binary protocol that minimizes bandwidth consumption. Ice uses little CPU and memory, and its highly efficient internal data structures do not impose arbitrary size limitations. This allows applications to scale to tens of thousands of clients with ease.
For bandwidth-limited communication (such as over satellite channels), Ice provides protocol compression, which reduces the size of invocations to the absolute minimum. Compression can be enabled and disabled at run time and requires no code changes.
Ice applications can receive requests as opaque blobs of data and forward these requests to new destinations. This enables the creation of very efficient message routers, such as IceStorm or Glacier2, because messages can be forwarded without the need to unmarshal and remarshal their payloads.
Ice is Reliable
Create fault tolerant and load balanced deployments.
No Single Point of Failure
Ice allows you to create fault tolerant applications. Multiple instances of a server can be deployed on different machines, with transparent fail-over if a machine crashes or is disconnected from the network. This not only makes applications resilient against failures, but also increases performance because Ice allows you to balance the load of an application across multiple servers.
All Ice services can be replicated for fault tolerance, so they do not introduce a single point of failure.
Ice is Everywhere
Ice runs on a wide range of platforms, from mainstream servers to smart phones and embedded devices.
Ice is more than a RPC framework. It also provides a number of complementary services for your networked applications.