Changes since version 1.1.1 --------------------------- - Manual retry in the exception() callback of asynchronous requests didn't work. This has been fixed. - Fixed a crash that could happen during shutdown. - Fixed a deadlock that could happen during connection establishment. - Fixed deadlock during shutdown that can happen if a thread pool with only one thread is used. - Moved UserExceptionFactory from Ice package to IceInternal package because UserExceptionFactory is no longer an interface for use by applications. - Bi-directional connections are now handled by the client-side thread pool instead of the server-side thread pool. - Fixed a bug in the generated code that caused "at-most-once" semantics to be ignored for collocated invocations. - Fixed ant tasks to use ICE_HOME (if defined) in the pathname of a translator executable. - Implemented TwowayOnlyException. That exception is raised if an attempt is made to invoke an operation that has a return value, out parameters, or an exception specification via a oneway or datagram proxy. - Removed ice_flush() on the proxy base class. Batch requests are now flushed by calling Communicator::flushBatchRequests(). This flushes all requests that are currently batched in the communicator, (for all connections). - Added back the connection closure timeout, but only for misbehaving peers. If a timeout is set, and a peer doesn't react to a close connection message, the connection is forcefully closed after the timeout. However, it is never forcefully closed if requests are still outstanding. Doing so would violate ordering guarantees for finished() and deactivate() on servant locators. - Fixed a bug in the slice2java code generator: if a parameter was named "current", illegal code was generated. - Fixed a bug in the slice2java code generator: tie classes were not generated correctly for operations with an "amd" metadata directive. - Fixed a bug where Ice would print a dispatch warning for Ice::RequestFailedException even if the Ice.Warn.Dispatch property was set to 1. - Added per-proxy contexts. The change is source-code compatible with the previous approach, that is, it is still possible to pass an explicit Ice::Context to an operation call as an additional, trailing parameter. However, Ice.ObjectPrx now contains two new operations: - ice_getContext() This returns the context currently associated with a particular proxy. (By default, the context associated with proxies is empty.) - ice_newContext(java.util.Map context) This creates a new proxy that is associated with the passed context. Thereafter, calls via the new proxy always pass the context that was passed to ice_newContext() when that proxy was created. The net effect of this is that it is now possible to establish the context for a proxy once and, thereafter, have that same context sent automatically whenever an operation is invoked via the proxy (instead of having to pass an explicit context parameter on every call). - Added Ice::Properties::parseIceCommandLineOptions(). This operation converts to properties all options that start with one of the following prefixes: --Ice, --IceBox, --IcePack, --IcePatch, --IceSSL, --IceStorm, --Freeze, and --Glacier. - Added menu with several options to throughput demo. - Major Freeze update. See corresponding entry in the Ice for C++ CHANGES file. - Added Ice.UDP.RcvSize and Ice.UDP.SndSize properties. These properties control the size of the UDP receive and send buffers as well as controlling the maximum size of a datagram invocation. If a datagram exceeds the configured size, the Ice run time throws a DatagramLimitException. (Note that, on the receiving size, detection of this condition is dependent on the local UDP implementation -- some UDP implementations silently drop datagrams that are too large to fit into the receive buffer instead of reporting the error or delivering a truncated datagram.) - Added Ice.Warn.Datagrams. This property prints a warning on the server side if a DatagramLimitException is thrown. - Added Ice.MessageSizeMax property. This property controls the maximum message size accepted by the Ice protocol in kiloBytes. The default value is 1024 (1 MB). - Fixed a number of incorrect property settings in the config files for the demos. - Changed the return type of the ice_invoke_async method in Ice.BlobjectAsync to void instead of boolean. - Added new property: Ice.Trace.Slicing. When set to a value > 0, unknown exception and class types that are sliced emit a warning. - Added destroyOnInterrupt() to the Application class. destroyOnInterrupt() is now the default behavior, because shutdownOnInterrupt() only shuts down the server side of an application, and therefore doesn't work with pure clients. - ObjectAdapter::removeServantLocator() no longer exists. The life cycle of servant locators that are registered with an object adapter ends when the adapter is destroyed. - Changed Ice::ServantLocator::deactivate to be passed the category for which a servant locator is being deactivated. - Added saveObject() operation on Evictor, and savedObject() operation on PersistenceStrategy. saveObject() saves a persistent object immediately. Once an operation has called saveObject(), the object is considered "clean": other updates by the same operation can only be reliably saved by another call to saveObject(). - Added a test to the property parsing code to print a warning on System.err if a property is not recognized. This prevents silly typos, such as "Ice.config=MyFile" (instead of "Ice.Config=MyFile") from slipping through undetected. - Changed the python code for printing output from test clients, so that you get each line as it comes. Changes since version 1.1.0 --------------------------- - Added support for a default object factory, similar to the semantics of servant locators. Specifically, a factory registered with an empty type id is invoked when a type-specific factory cannot be found. - Fixed a bug where the locator cache wasn't correctly updated upon a connection failure to a server. This was causing IceJ to try to re-establish the connection to the same server endpoints without asking the locator if eventually the endpoints had changed. - Fixed server side bug with batch oneways or batch datagrams. - Fixed a bug where the operation mode argument wasn't used in the implementation of the Ice.ObjectPrx ice_invoke method. - Added missing declaration for ice_invoke_async to Ice.ObjectPrx. - Fixed a bug in the generated code for custom sequences so that it now checks whether the sequence value is null. - Added DB_PRIVATE flag to DBEnv->open(), to be able to use the Berkeley DB that ships with RedHat 9. Changes since version 1.0.1 --------------------------- - Ice now implements slicing for exceptions and classes: if a process receives an exception or class that is of a more derived type than the receiver understands, the exception or class is automatically sliced. (Previously, this situation resulted in an exception.) - User exception factories and user exception factory managers no longer exist. The factories for user exceptions are now automatically installed by the Ice run time. If you have existing code that implements user exception factories, you can simply delete it. - Fixed a bug in the Slice parser: the semantic check to see whether an identifier introduced into a scope has changed meaning was too stringent. - Fixed a bug with connections being closed even though they have outstanding batch requests. - The "unknown" field in UnknownLocalException and UnknownException now contains the whole exception stack trace instead of just the exception name. - Replaced the Freeze::EvictorPersistenceMode enumeration with the interface Freeze::PersistenceStrategy. - Instead of aborting the caller thread, Ice for Java now catches assertions in servant methods, prints the assertion, closes the connection, and continues. - Added dynamic thread pools, i.e., thread pools that grow and shrink based on a calculated load factor. Please see the section about thread pools in the manual for further details. - Structs and sequences which hold other structs or sequences are now legal dictionary key types, as long as such nested structs or sequences are (recursively) legal. - The connection timeout is now also used when connections are closed. This avoids hanging processes if the peer misbehaves, or if asynchronous method invocations do not return. - In some cases, communicator destruction could result in a java.lang.NullPointerException. This has been fixed. Now a CommunicatorDestroyedException is raised. - Fixed a bug with AMD methods using a servant locator, such as the Freeze evictor. - Changed the generated equals() method to use the helper java.util.Arrays.equals() when comparing sequences, rather than the native array equals() method. This means the equals() method for a type containing a sequence member will perform a deep comparison of the sequence. - Added timestamps to the default Ice logger. You can enable timestamps by setting the `Ice.Logger.Timestamp' property to a value larger than zero. By default timestamps are disabled. - Improved IceBox service deactivation. Instead of successively stoping a service and destroying its communicator, services are now all stopped first and then their communicators are destroyed. - Modified the Ice protocol to marshal sizes more efficiently. Sizes less than 255 now require a single byte whereas previously, sizes between 127 and 254 required five bytes. - Modified the Ice protocol to fix a problem with compression. The compressed message types have been removed, and a field has been added to the message header indicating compression status. - Added version negotiation to the Ice protocol. This permits future protocol extensions to be added without breaking interoperability with older deployed clients and servers. Unfortunately, doing this broke compatibility with the existing protocol so, when upgrading to this version, you must make sure that clients and servers use the same version of Ice.jar. - Added a magic number to the Ice protocol. All Ice protocol messages have 'I', 'c', 'e', 'P' (encoded as ASCII) in the first four bytes. This is useful to allow protocol analyzers to recognize Ice messages. - Changed the encoding of encapsulations. An encapsulation now looks like: size (4 bytes) major version number (1 byte) minor version number (1 byte) data (n bytes) The size includes the count of bytes for the size and versions, so the value of size is n + 6. - Added -v and -e options to stringified UDP endpoints. -v sets the protocol version and -e sets the encoding version. (The current version for both protocol and encoding is 1.0.) Changes since version 1.0.0 --------------------------- - Fixed a bug in the ObjectAdapter which caused it to ignore all but the first endpoint. - Fixed a bug with throwing exceptions in AMD calls after invoking ice_response(). - Fixed a bug with throwing exceptions in AMI from within ice_response().