Changes since version 3.2b
--------------------------
- The icegridadmin command line utility now tries to connect to a
slave registry if the master is not available.
Changes since version 3.1.1
---------------------------
- Deprecated Ice.UseEventLog. Windows services should no longer use
this property! Also fixed a bug with the windows event logger which
would cause hangs if the event log became full.
- Under Windows Ice Services (Ice::Service) always use the windows
event logger unless initData is otherwise configured. Installing the
service will now create the appropriate registry keys, and uninstalling
the service will remove them.
- createObjectAdapter() and propertyToProxy() print warnings if
unknown properties are found during creation of the adapter or
proxy. These warnings can be disabled by setting the property
Ice.Warn.UnknownProperties=0.
- Fixed a race condition that could cause an assertion failure when
using thread-per-connection.
- Added the property Ice.Default.EndpointSelection. If not defined,
the default value is "Random".
- Proxies and object adapters can now be configured to use
thread-per-connection.
- IceBox services no longer inherit the properties of the container
by default. If this is the desired behavior set the property
IceBox.InheritProperties to 1.
- Fixed a bug where new connections are being accepted but not
serviced correctly when using the thread pool concurrency model if
the number of file descriptors registered with the thread pool
exceeds FD_SETSIZE.
- Added Communicator::isShutdown() and ObjectAdapter::isDeactivated()
to allow applications to determine whether a communicator has been
shutdown or an object adapter has been deactivated, respectively.
- The Glacier2 SessionControl object is now registered with the Server
adapter rather than the Admin adapter.
- Added "null" permissions verifier objects to Glacier2.
- Renamed the property Glacier2.AddUserToAllowCategories to
Glacier2.Filter.Category.AcceptUser. The old property name has been
deprecated and will be removed in a future release.
- Added destroy() operation to the ObjectAdapter interface. This
operation must be called in order to reclaim the adapter's resources
and be able to recreate a new adapter with the same name. Destroying
a communicator automatically calls destroy on all of its adapters.
- Added a per-process logger and two methods to get/set the logger,
Ice::getProcessLogger() and Ice::setProcessLogger(). Calling
getProcessLogger() creates a default logger if setProcessLogger()
has not been called. The process logger is also used as the default
logger for all communicators that do not have a logger explicitly
set.
- Added the property Glacier2.ReturnClientProxy to control whether
Glacier2's implementation of the Router::getClientProxy() operation
returns a proxy or just null. By default this property is set to 0.
For backward compatibility with clients that use Ice versions older
than 3.2, this property must be set to 1.
- Added support for a user-defined signal handler in Ice::Application.
A subclass must override the interruptCallback method and invoke
callbackOnInterrupt to activate it.
- Message batches are now automatically flushed when the total size of
the batch reaches the message size maximum. This feature can be
controlled using the Ice.BatchAutoFlush property, which is on by
default.
- It is now possible to identify log files for IceGrid servers using
the `log' XML element of a server descriptor. Server logs can be
viewed remotely by the IceGrid GUI or the icegridadmin command-
line utility.
- Added support to the IceGrid GUI and icegridadmin command-line
utility for viewing the standard error and standard output files
of an IceGrid node, registry, and server.
- Added new `property' attribute to IceGrid object descriptors. If
this attribute is specified, the registry generates a property
that supplies the object's identity. For example:
generates the property "Identity=hello".
- Patching a distribution with IceGrid should no longer result in an
Ice::TimeoutException exception if the patching takes a long time.
- Fixed IceGrid to no longer return Ice::NoEndpointException to a
client if the object adapter of a server managed by an IceGrid node
is being deactivated. IceGrid will now queue the locate request from
the client, reactivate the server and send the response of the
locate request when the object adapter is active again.
- Replaced the IceGrid `wait-for-activation' attribute of an adapter
descriptor with a new `server-lifetime' attribute. An adapter with
the `server-lifetime' attribute set to true is expected to be active
for the duration of the server execution. IceGrid considers a server
active when all the adapters with this attribute set to true are
active and considers that a server is being deactivated as soon as
at least one such adapter is deactivated.
- Added findAllReplicas() method to the IceGrid::Query interface. This
operation allows you to retrieve all the replicas associated with a
given proxy.
- Added support for service property sets in server instances. These
property sets allow you to specify additional properties for IceBox
services hosted by IceBox server template instances. For example:
- Added new IceGrid `Ordered' load balancing policy. The endpoints of
a replica group configured with this load balancing policy are
ordered by the priority of each replica. A replica's priority is set
with the new object adapter `priority' attribute.
- Removed the `None' load balancing policy from IceGrid. This load
balancing policy is equivalent to the `Random' policy configured to
return the endpoints of all the replicas (i.e., with the
`n-replicas' attribute set to 0).
- Setting the n-replicas attribute of an IceGrid replica group load
balancing policy to 0 is no longer equivalent to 1. It now causes
the locator to return the endpoints of all the replicas that are
members of the replica group.
- The IceGrid registry now supports replication in a master/slave
scheme. See the Ice manual for information on the configuration
of replicated IceGrid registries.
- During the creation of an object adapter, the communicator now
raises InitializationException if the adapter has no configuration.
It is possible to create an adapter with no configuration, which
is useful for bidirectional connections, by passing an empty string
as the argument to createObjectAdapter.
- It is now possible to start and stop individual IceBox services
using the IceBox admin utility.
- Added Communicator::propertyToProxy() which creates a proxy from
a set of properties. This operation allows you to set various local
proxy settings, such as the locator cache timeout, which cannot be
set using stringToProxy().
- Added ["cpp:class"] C++ metadata to map a slice struct to a
reference counted class.
- Glacier2.AllowCategories is now deprecated and superseded by
Glacier2.Filter.Category.Accept.
- The Ice.Logger.Timestamp property has been removed. Timestamps are
now always printed.
- Added the property Ice.Default.PreferSecure, which if set to 1
causes secure endpoints to be preferred over non-secure endpoints.
By default this property is set to 0. Also added functions to
control this behavior on a per-proxy rather than global basis:
ice_isPreferSecure() and ice_preferSecure().
- Added a demo to illustrate the use of AMI/AMD.
- IceBox services are now stopped in the reverse order from which they
were started.
- If a proxy does not specify a hostname (via -h HOST), the client
only attempts to connect to the loopback interface (127.0.0.1).
- All Ice exceptions now derive from std::exception.
- Attempts to change the attributes of a fixed proxy now result in a
FixedProxyException rather than just ignoring the change request and
returning the same proxy. Also, attempts to marshal a fixed proxy
now result in a FixedProxyException rather than a MarshalException.
- Fixed a bug in the IceGrid locator implementation that could cause
a memory corruption when using replica groups.
- Added support for implicit request contexts. When you invoke an
operation on a proxy and don't pass an explicit context, Ice uses
the "implicit context" combined with the per-proxy context (if any).
You can obtain the implicit context using the new communicator
operation getImplicitContext(). Three implementations of implicit
context are available; you select one by setting the property
Ice.ImplicitContext to one of the following values:
* None: No implicit context at all (default).
* PerThread: The implementation maintains a context per thread.
* Shared: The implementation maintains a single thread-safe context
that is shared by all threads.
- Removed defaultContext from InitializationData.
- Communicator::setDefaultContext(), Communicator::getDefaultContext()
and Proxy::ice_defaultContext() have been deprecated.
- Ice now uses the epoll() system call on Linux and the poll() system
call on other Unix platforms instead of select().
- Setting the IceGrid.Node.Name property is now required; this
property no longer uses the hostname as its default value.
- For object adapters without endpoints, Ice.Trace.Network >= 2 now
prints a trace message.
- Added new overload of Ice::initialize() that accepts a StringSeq as
the first argument.
- IceStorm changes:
Changed IceStorm federation such that IceStorm now detects when
a downstream topic is unavailable. Once a link is diagnosed as
non-functional, events are thrown out until a timer expires
(specified using the property IceStorm.Discard.Interval in seconds,
default value is 1 minute). At that point, delivery of the link
is attempted once again.
Added a new property IceStorm.Send.Timeout. This specifies a timeout
in milliseconds that is used for all link and subscriber proxies.
The default value is 1 minute.
All message sending is now faster. In particular, oneway QoS is now
significantly faster.
All message propagation is now fully buffered through a dynamic
thread pool. Tracing for the thread pool can be enabled using the
property IceStorm.Trace.SubscriberPool. The thread pool size is
controlled by the following properties.
* IceStorm.SubscriberPool.Size: The initial size of the thread
pool. The default value is 1.
* IceStorm.SubscriberPool.SizeMax: The maximum size of the thread
pool. The default value is 0, which means unlimited.
* IceStorm.SubscriberPool.SizeWarn: A warning is issued if the size
of the thread pool exceeds this value. The default is 0, which
means never warn.
* IceStorm.SubscriberPool.Timeout: Specifies a timeout in
milliseconds. IceStorm spawns a new thread, up to the maximum
size of the thread pool, if a stall is detected for longer than
this timeout value. The default value is one second.
It is now possible to call unlink with a topic proxy that refers
to an IceStorm topic that is not currently reachable.
Added per-subscriber publisher objects to IceStorm. The new
operation Topic::subscribeAndGetPublisher returns a proxy that is
used to send an event to only that particular subscriber. See
demo/IceStorm/counter for an example of this feature.
The legal values for the reliability QoS passed to the operation
subscribeAndGetPublisher() are different than that of subscribe().
The new operation accepts only "ordered" or an empty string and
derives the desired QoS from the mode of the subscriber's proxy.
For example, passing a subscriber proxy configured for oneway
invocations enables oneway delivery in IceStorm. The "ordered" QoS
requires a twoway proxy otherwise a BadQoS exception is raised.
Topic::subscribe has been deprecated and retains the old QoS
semantics.
The property IceStorm.InstanceName is now used to produce unique
identities for each IceStorm topic. The identities used are now:
/topic./publisher./link.
IceStorm is still fully compatible with prior releases.
The IceStorm database format was changed to accommodate the new
identity semantics. The script config/upgradeicestorm.py can be
used to upgrade existing IceStorm databases to the new format.
- Changes in icestormadmin:
Removed support for the "graph" command.
The various icestormadmin commands take the topic manager as an
optional part of the arguments. For example, the command
"create MyTopicManager/foo" creates the topic "foo" on the topic
manager using the instance name MyTopicManager. See the Ice manual
for more information.
The program obtains the proxy for a topic manager using a property
of the form IceStormAdmin.TopicManager.NAME. If an icestormadmin
command does not specify a topic manager, the program uses the
proxy in the property IceStormAdmin.TopicManager.Default. For
backward compatibility, the property IceStorm.TopicManager.Proxy
also sets the default topic manager.
Added a new command "current" to set the default topic manager.
The list command now takes the topic manager as the first argument,
and the topics are the remaining arguments.
- Added Ice.Override.Secure which forces a client to only use
secure connections.
- IceGrid registry now cleans up any existing administrative and
regular client sessions that do not correctly time out. This could
occur if the Glacier2 router terminates unexpectedly.
- Added Glacier2::SessionControl::getSessionTimeout.
- Fixed a bug in slice2cpp so that the #include statements in a
generated header file are correctly modified by -I options.
- The icegridadmin command tool now must establish an administrative
session with the IceGrid registry -- anonymous administration is no
longer permitted. As with the IceGrid GUI, authentication occurs
through the IceGrid Client endpoints either using a username and
password or through SSL. See the Ice manual for full details.
- The IceGrid registry Admin endpoints have been removed. A new set of
endpoints has been added for the Glacier2 session manager. These
should only be enabled if Glacier2 integration is desired since it
presents a security threat. The endpoints are defined by the
property IceGrid.Registry.SessionManager.Endpoints.
- The ice_name() member function of exceptions derived from
Ice::Exception (and, hence, IceUtil::Exception) now returns a
non-const string instead of a const string:
const ::std::string ice_name() const; // Old signature
::std::string ice_name() const; // New signature
- Changed IceUtil::Options to allow testing for synonyms without
having to check both the short and long options. For example:
IceUtil::Options opts;
opts.addOpt("v", "version");
opts.parse();
Previously, to test whether the -v or --version option was set, you
had to write:
if(opts.isSet("v" || opts.isSet("version"))
// show version...
With the new behavior, you can test for either "v" or "version",
and the test returns true if either the long or short option
was set:
if(opts.isSet("version"))
// show version...
or:
if(opts.isSet("v"))
// show version...
Either test works correctly, regardless of whether the actual option
passed to the executable was -v or --version.
Note that, for this to work, you must add both long and short option
in a single call to addOpt():
opts.addOpt("v", "version"); // -v and --version are synonyms
If you add the options in separate calls, they are not recognized
as synonyms:
opts.addOpt("v"); // --version is considered a separate
// option from --version
opts.addOpt("", "version"); // --version is considered a separate
// option from -v
- The exceptions raised by IceUtil::Options have changed:
- IceUtil::Options::APIError is now IceUtil::APIException
- IceUtil::Options::BadOpt is now IceUtil::BadOptException
- IceUtil::Options::BadQuote has been removed.
APIException and BadOptException are now derived from
IceUtil::Exception. IceUtil::Options::parse() and
IceUtil::Options::split() now raise BadOptException (instead of
BadQuote) if a closing quote is missing from a command-line
argument.
- Added zero-copy functions to the stream classes.
- Added the NullSSLPermissionsVerifier to the IceGrid registry.
- Added more tracing to the IceSSL plug-in to aid in using the
TrustOnly properties.
- Added --ip and --dns command line options to the iceca sign command.
This adds support for subjectAltName in certificates.
- Merged the simple CA scripts into a single iceca script.
- Removed support for the following configuration properties that were
deprecated in Ice 3.0:
IceBox.ServiceManager.Identity
IcePatch2.AdminIdentity
IcePatch2.Identity
Glacier2.AdminIdentity
Glacier2.RouterIdentity
Each of these services supports an InstanceName property that should
be used instead.
- Added UnexpectedObjectException. This exception is raised if you
use Slice classes and client and server are compiled with mismatched
Slice definitions. Alternatively, this exception is raised if you
use dynamic invocation and pass a class of the wrong type as an
operation parameter.
- The Slice keyword 'nonmutating' is now deprecated; 'idempotent'
should be used instead. A new metadata directive is supported for
backward-compatibility (see below).
- Added the Freeze property Freeze.Evictor.UseNonmutating.
When set to a non-zero value, the Freeze Evictor behaves like it did
in previous Ice releases in that it assumes nonmutating operations
do not update the target object, while all other operations do
update the target.
As of this release, the recommended mechanism is to use the
"freeze:read" and "freeze:write" metadata (see below).
If not defined, the default value of this property is 0.
- New Slice metadata for operations:
- ["cpp:const"] generates a const member function on the
corresponding servant base class.
- ["freeze:read"] or ["freeze:write"] marks the operation as "read"
or "write" for the Freeze evictor. The default is the Freeze mode
of the enclosing interface/class.
- ["nonmutating"] provides backward compatibility for idempotent
operations that were previously declared using the deprecated
'nonmutating' keyword. You can replace the 'nonmutating' keyword
with '["nonmutating"] idempotent' to maintain compatibility with
objects implemented using Ice 3.0 or 3.1.
- New Slice metadata for interfaces/classes:
- ["freeze:read"] or ["freeze:write"] defines the default Freeze
mode for operations on the interface/class. The default is read.
This metadata has no effect on derived types.
- For non-abstract Slice classes, the C++ code generator now adds a
protected destructor. This prevents accidental allocation of
class instances on the stack or as static variables. For the
implementation of abstract Slice classes, and for servant classes,
applications can do the same thing and add a protected destructor
to prevent non-heap allocation.
- Fixed a bug in slice2cpp that caused incorrect code to be generated
if a class had a member that was an interface (not class) by value:
interface I
{
void op();
};
class C
{
void op();
};
class MyClass
{
I myI; // Note: I, not I*. Bad code generated for this in 3.1.0.
I* myIstar; // OK, no problem with 3.1.0.
C myC; // OK, no problem with 3.1.0.
C myCstar; // OK, no problem with 3.1.0.
};
Changes since version 3.1.0
---------------------------
- Fixed a bug in slice2docbook that could cause the "Used By" section of a
symbol to list the same operation more than once.
- slice2doc book now adds a "Used By" section for exceptions. (Previously,
exceptions did not have this section, only other types.)
- Fixed IceGrid allocation bug which could cause allocation failures
when allocating multiple objects by type from allocatable servers
and with the same session.
- Fixed the Slice translators to support spaces in paths of the
-I option.
- Fixed a bug where proxy operator< could return an incorrect result
for proxies of different types (e.g., direct vs. indirect proxies).
- Removed obsolete --no-globals option from slice2docbook.
- Fixed a bug in IceStorm where IceStorm stops sending events to
linked topics if the linked topic becomes unavailable for any
reason.
- Fixed a bug where the number of endpoints returned for a replica
group with no load balancing policy was random.
- It's now possible to invoke on the IceGrid::Query object from an
IceGrid admin session created through Glacier2.
- Fixed a Glacier2 shutdown bug where active sessions would not be
destroyed properly.
- A bug was fixed where the glacier2router would throw a
NullHandleException if a permission verifier was used that was not
configured.
- Fixed a bug with the IceGrid allocate and sessionAllocation demos
where the session would not be destroyed in the event of an
allocation failure.
- Fixed a bug with config/ca/import.py script when importing
certificates without an encrypted private key into a java keystore.
- Added support for Borland C++Builder 2006.
- Fixed a bug where variables from distribution descriptors were not
substituted.
- Fixed an assert in the IceGrid locator implementation that could
occur when using dynamic adapter registration. The assert was
triggered when an adapter was removed and a client was requesting
at the same time the adapter endpoints through the locator
interface.
- Fixed a bug in the IceGrid replication code that would cause clients
to get an Ice::NoEndpointException if the node of a replica was
inactive.
- Fixed a bug in the IceGrid XML parser that could cause a crash if
the adapter element for the IceBox.ServiceManager adapter was
specified in the icebox element.
- Restored Communicator::setDefaultContext.
- Fixed a bug in Ice::initialize() that raised a NullHandleException
when the function was called without arguments or when the
properties member of InitializationData was null.
Changes since version 3.0.1
---------------------------
- Fixed a bug in slice2cpp that could cause incorrect code to
be generated if a class contained a member to another class,
but that class was only forward declared.
- Unsupported port to Solaris 10 on Intel/AMD contributed by
Markus Bernhardt.
- Removed removeObjectFactory() from the communicator interface.
- Added a new object and server allocation mechanism to IceGrid. See
the Ice manual for more information.
- The IceGrid XML descriptor can only be used to specify
indirect adapters. It's no longer possible to specify an adapter
with an empty id. You can use properties to configure direct
adapters.
- Fixed a bug where IceGrid would fail to register well-known objects
with an identity containing reserved characters for proxies.
- Added "always" and "session" activation modes to IceGrid. See the
Ice manual for more information.
- Changed the entry point of the IceSSL plugin to be
IceSSL:createIceSSL.
- Changed the entry point of the IceStorm service to be
IceStormService,31:createIceStorm.
- ObjectAdapter::deactivate() now notifies the locator registry when
the adapter is deactivated.
- Fixed ObjectAdapter::activate() to activate the object adapter
only if it is able to register its endpoints and process proxy with
the locator. Calling activate() again retries a failed registration.
- Glacier2.AllowCategories is now deprecated and superseded by
Glacier2.Filter.Category.Accept.
- A new address filtering mechanism has been added to the Glacier2
router. See the description of the Glacier2.Filter.Address.Accept
and Glacier2.Filter.Address.Reject properties in the Ice manual
for details.
- The Glacier2 router's identity-based filtering is now modifiable at
runtime through the Glacier2::SessionControl interface.
- Generating new streaming functions for a Slice structure. The
ice_write and ice_read member functions replace their internal
equivalents (__write and __read).
- Removed getDefaultProperties() functions, and the global default
properties. If you need global properties, you can easily create
your own global variable.
- In Ice::Service, main(), run() and initializeCommunicator() now take
a third parameter, const InitializationData&. It's defaulted for
main() and run().
- The signature of createProperties(argc, argv) is now:
PropertiesPtr createProperties(int* argc, char* argv[],
const PropertiesPtr& defaults = 0,
const StringConverterPtr& conv = 0);
where "defaults" represents an optional set of default properties
used to initialize the new Properties object. Ice properties
defined on the command line and properties defined in a
configuration file override these default properties.
- Fixed a bug in dumpdb so that it handles object graphs correctly.
- Fixed a bug where the proxy timeout, compress flag and connection
id attributes would be ignored for direct proxies using a router.
- Added ability to configure Ice thread start/stop hooks through
InitializationData.
- Added SSL authorization as an alternative to username/password
for Glacier2. To authorize with SSL, use the new operation
Glacier2::Router::createSessionFromSecureConnection(). On the
server side, the new interfaces Glacier2::SSLPermissionsVerifier and
Glacier2::SSLSessionManager must be implemented.
- The Glacier2.CryptPasswords property no longer has a default value.
To reproduce the router's behavior from previous releases, define
Glacier2.CryptPasswords=passwords
- Added identityToString and stringToIdentity to the Communicator
interface. If a string converter is configured, these functions
must be used instead of the current static functions.
- Added ability to configure user-defined string and wstring
converters that are used during marshalling/unmarshalling to
convert between UTF8 (as required by the Ice protocol) and the
user's character set.
- Added operators <=, > and >= for Slice classes, proxies and
structures.
- Added operation that allows a Glacier2 session to be destroyed from
a backend server.
- It is now possible to recreate a new object adapter with the same
name as an old adapter once waitForDeactivate() has completed on the
old adapter.
- Added new operation Communicator::createObjectAdapterWithRouter(),
which creates a routed object adapter. An object adapter may now
be associated with at most one router, which is defined using this
operation or by setting the .Router property. Also
as a result of this change, the ObjectAdapter::addRouter() and
ObjectAdapter::removeRouter() operations have been removed.
- Added property sets to IceGrid descriptors. Property sets allow you
to define a set of properties in application, node and template
descriptors. These property sets can then be referenced from the
server, service and instance descriptors. See the IceGrid chapter in
the Ice manual for more information.
- Changed the IceGrid::Admin::getApplicationDescriptor operation to
return the application descriptor without performing any variable
substitutions.
- Fixed a bug in the adaptive load policy implementation that could
cause the IceGrid registry to crash.
- Fixed a deadlock in the IceGrid registry that could occur when
using the adaptive load balancing policy or the IceGrid::Query
findObjectByTypeOnLeastLoadedNode operation.
- Added communicator initialize functions that takes an argument of
type Ice::InitializationData. This structure contains communicator
members that may only be set during communicator initialization.
Currently included are Properties, Logger, Stats, default context,
string converters and the thread hooks. The initializeWithXXX
functions have been deprecated and the setLogger(), setStats() and
setDefaultContext() operations have been removed.
- Added the new Slice metadata "deprecate" that can be used to
qualify operations. On most platforms this will cause a compiler
warning to be issued if user code uses the deprecated operation.
- Integrated contributed updates for Tru64.
- Added a new operation addProxies() to Ice::Router, which can return
evicted proxies. The old operation addProxy() is now deprecated.
Note that this is an internal interface for communications between
clients and routers (such as Glacier2).
- Added a new property Glacier2.RoutingTable.MaxSize. If more proxies
are added than permitted by this property, proxies are evicted from
Glacier2's internal routing table on a least recently used basis.
Ice clients from version 3.1 on will automatically retry operation
calls on such evicted proxies, thereby re-adding them to Glacier2's
routing table. Ice clients older than version 3.0 will receive an
ObjectNotExistException. To continue to support such old clients,
you must set the maximum high enough so that Glacier2 will not evict
proxies. Upgrading your clients to 3.1 is highly recommended to avoid
large routing table sizes in Glacier2.
- Replaced the IceSSL plugin. The new plugin no longer uses an XML
configuration file but rather relies solely on properties. A Python
script is provided in config/convertssl.py to convert old XML files
to the new properties. See the Ice manual for more information on
the plugin.
- Added support for new Slice metadata ("cpp:type:wstring") that
generates code to use std::wstring instead of std::string. See the
Ice manual for more details.
- The ice_timeout and ice_compress proxy methods now correctly
override the timeout and compress flag of indirect proxy endpoints.
- Added proxy methods ice_isSecure, ice_getLocator, ice_getRouter,
ice_isCollocationOptimized.
- Deprecated the following proxy methods:
ice_hash
ice_communicator
ice_collocationOptimization
ice_connection
ice_newIdentity
ice_newFacet
ice_newContext
ice_newAdapterId
ice_newEndpoints
These methods will be removed in the next major release. You should
use the new methods shown below:
ice_getHash
ice_getCommunicator
ice_collocationOptimized
ice_getConnection
ice_identity
ice_facet
ice_context
ice_adapterId
ice_endpoints
- Changed the Ice core and services to use the random generator from
IceUtil. The initialization of the communicator doesn't call srand
or srand48 anymore. Your application should call it if necessary.
- Added random generator to IceUtil (in include/IceUtil/Random.h). The
random generator is using /dev/urandom on Unix platforms and the
cryptography API on Windows (CryptGenRandom).
- Added requestId to Current, which allows a servant to determine
whether an operation was invoked with collocated, oneway or twoway
semantics. The requestId member is 0 for oneway invocations and
-1 for collocated invocations.
- Added typedefs for ProxyType and PointerType to the generated class
for Slice classes and interfaces to allow for easier templating.
- Fixed a bug in the Glacier2 router that could cause the router
to leak resources when a session is destroyed and hang on shutdown.
- Fixed a buffered mode bug in the Glacier2 router that could cause
hangs in the router if a client misbehaved.
- AMI invocations will now reuse the connection cached with the
proxy instead of always looking up an existing connection for
each invocation. As a side effect of this change, AMI invocations
on a proxy with collocation optimization enabled will now raise
Ice::CollocationOptimizationException.
- Added the property Ice.Default.LocatorCacheTimeout and the proxy
method ice_locatorCacheTimeout(). If a cached endpoint is older
than the configured cache timeout, the Ice runtime won't use
the cached endpoint. Instead, the Ice runtime will query the
Ice locator service to retrieve up-to-date endpoints and then update
the locator cache. Please see the Ice manual for more information.
- Added the proxy method ice_endpointSelection, which allows an
application to control how endpoints are selected at connection
establishment. Two endpoint selection types are currently supported:
Random and Ordered.
- Added the proxy method ice_connectionCached. This method allows you
to enable or disable the caching of the connection by the proxy. By
default, the proxy will cache the connection to avoid looking it up
for each request. Disabling the connection caching is useful to do
per-request load balancing: the proxy will select a connection for
each request and the request will eventually be sent to different
servers.
- Removed the Ice.Warn.Leaks property.
- Performance improvements if an AMI callback object is reused with
the same proxy.
- If several proxies share the same connection, and an operation call
on one of the proxies causes a failure and the shared connection to
be closed, then subsequent calls on the other proxies will try to
establish a new connection instead of throwing an exception, even if
retries are disabled.
- IcePatch2 now performs incremental reads of files during compression
and checksum calculation. Previously the entire file being processed
was read into memory.
- If a proxy is not configured with the -h parameter, Ice will now
attempt to connect using all local interfaces. The loopback
interface (127.0.0.1) will only be tried if it is the only local
interface present.
- Added the ability to specify alternate mappings for Slice sequences
other than std::vector. Please see the Ice manual for more details.
- Fixed a bug in slice2cpp that caused one-shot constructors for
classes to incorrectly initialize base classes for class hierarchies
three or more levels deep.
- Fixed a bug in slice2cpp that caused a compiler warning about an
unused parameter in the generated code for operations on classes
with void return type, no parameters, and no exception
specification.
- Fixed a bug in the IceGrid deployment mechanism that would prevent
the use of a variable in an object identity's category.
- Added Glacier2::Router::getCategoryForClient that should be used to
get the category for Glacier2 client callback objects. This
operation is a convenience that replaces the equivalent code
getServerProxy()->ice_getIdentity().category.
- The Glacier2 router now forwards the context set by the client when
calling PermissionsVerifier::checkPermissions and
SessionManager::create.
- Fixed a bug in IceBox and IceGrid that would prevent running IceBox
servers from a directory containing spaces.
- Fixed a bug in the class garbage collector that could result in
double deallocation of class instances.
Changes since version 3.0.0
---------------------------
- Fixed an assert that could occur during connection establishment if
the communicator was shutdown or destroyed concurrently.
- IceUtil::Time::toString() has been deprecated and should no longer
be used. Instead, use IceUtil::Time::toDateTime() to get a date
and time string. (toString() will continue to work as a synonym for
two more releases and will then be removed.)
IceUtil::Time::toDuration() is a new function that returns a
duration string of the form "days hh:mm:ss.usec". (The number of
days and micro seconds is printed only if they are non-zero.)
- Fixed a bug in the Slice parser that caused problems if an included
file contained white space in the file name.
- Fixed a bug where the IceGrid node would fail to retrieve the CPU
utilization on localized Windows versions.
- The Glacier2 router now logs a warning if a request arrives on an
unknown connection if Glacier2.Client.Trace.Reject >= 1.
- Fixed a bug in IceGrid on Windows where environment variables set
in server descriptors would not override those already set in the
node's environment.
- Fixed a bug in slice2freeze in which using the --output-dir option
was causing include paths to be modified in generated files.
- Fixed a bug where the IceGrid node, if installed as a Windows
service, wouldn't correctly start on boot.
- Fixed a bug where the IceGrid node could incorrectly remove
configuration files or database environment directories if they were
not specified in alphabetical order (sorted by name) in the
descriptor.
- Added --enable-new-dtags to Linux linker options.
- Added support for Apple Xcode 2.2.
- Windows x64 port; INSTALL.WINDOWS now shows how to target the x64
platform.
Changes since version 2.1.2
---------------------------
- Added support for custom comparison in Freeze Maps. You can now
provide your own compare functors for keys and indices. See the
slice2freeze usage for the new options. The default behavior is
backward compatible, comparing binary strings in the Ice encoding.
Map have 4 new functions:
- lower_bound (const and non-const)
- upper_bound (const and non-const)
In addition, the implementation of equal_range is now correct.
Generated index classes have 6 new functions:
- lowerBoundFor (const and non-const)
- upperBoundFor (const and non-const)
- equalRangeFor (const and non-const)
The findBy also takes a new bool parameter, "onlyDups"; its
default value is true for compatibility with previous releases.
When onlyDups is true, findBy returns only the elements that
match the given index value; when false, the iterator returns first
these elements and then lets you iterate over the remainder of the
database (according to the order defined by the index).
- Fixed a deadlock during shutdown that could happen with
bi-directional connections.
- Removed ice_default() method from proxies.
- Added downgrade() to IceUtil::RWRecMutex and fixed a bug in
upgrade(). Previously, upgrade() was equivalent to calling unlock()
followed by writeLock(), which could allow a thread to acquire a
write lock while another thread was in the middle of an upgrade.
upgrade() is now atomic, so whatever state is protected by a read
lock is guaranteed to remain unchanged when upgrade() completes.
- Connection::close(false) (i.e., graceful connection shutdown) now
waits until all outstanding requests have completed.
- Added a new object adapter property, .ReplicaGroupId, which
allows adapters to be replicated. See the IceGrid chapter in the
manual for more information.
- Added the following properties:
IceBox.InstanceName
IcePatch2.InstanceName
IceStorm.InstanceName
Glacier2.InstanceName
These properties make it more convenient to configure multiple
instances of these services by modifying the identity category of
their well-known objects. The properties listed below are now
deprecated and will be removed in a future release:
IceBox.ServiceManager.Identity
IcePatch2.Identity
IcePatch2.AdminIdentity
IceStorm.TopicManagerIdentity
Glacier2.AdminIdentity
Glacier2.RouterIdentity
- Added the proxy method ice_connectionId, which allows an application
to control connection reuse.
- Added the new methods Ice::initializeWithLogger() and
Ice::initializeWithPropertiesAndLogger(), which ensure that a custom
logger is used to record any errors during communicator
initialization.
- Ice will now listen on all local interfaces if no -h parameter is
present in the endpoint configuration and no default host has been
set. It will also listen to all interfaces if the -h parameter is
set to 0.0.0.0. In such configurations the endpoints published in
proxies will not contain the loopback interface (127.0.0.1) unless
it is the only local interface present.
- Fixed a race condition with the object adapter holding state.
- Changed the way servant locators work if a server has a servant
locator registered for a specific category, in addition to a default
servant locator. Previously, if the locator for the specific
category failed to locate the servant, the run time would then call
the default locator. With the new behavior, if the locator for the
specific category does not return a servant, the default locator is
not called.
- Added proxy methods to retrieve the proxy adapter id and endpoints
(ice_getAdapterId() and ice_getEndpoints()) and to create a new
proxy with a new adapter id or new endpoints (ice_newAdapterId() and
ice_newEndpoints()).
- Added Slice Ice::Endpoint local interface in slice/Ice/Endpoint.ice.
- Fixed a bug that would cause UDP server connections to be closed on
transient errors, thus preventing the reception of any more UDP
messages until a server restart.
- Communicator::setDefaultContext() no longer changes the context
information set on existing proxies.
- slice2cpp and slice2freeze now provide the --add-header option. It
adds a #include directive for the specified header at the beginning
of the generated source file. For example:
slice2cpp --add-header=precompiled.h x.ice
adds "#include to the beginning of x.cpp (before any
other include directives).
You can specify an optional guard, for example:
slice2cpp --add-header=precompiled.h,__PRECOMPILED_H__ x.ice
With this, the beginning of x.cpp contains:
#ifndef __PRECOMPILED_H__
#define __PRECOMPILED_H__
#include
#endif
You can repeat the --add-header option to include several headers in
the generated source.
- Ice::Communicator::createObjectAdapter() throws
Ice::AlreadyRegisteredException if it is called with the name of an
object adapter that already exists.
- Fixed a bug in the slice2java code generator, which would cause
incorrect code to be generated when metadata was used to modify
dictionary types used as class or struct members.
- Fixed a bug in the slice2java code generator, which could cause
incorrect code to be generated for certain custom sequence types.
- Fixed a bug in the slice2cs code generator: if an operation had a
parameter named i or szx, incorrect code was generated in some
cases.
- Fixed a bug in the slice2vb code generator: if an operation had a
parameter named ix or spx, incorrect code was generated in some
cases.
- Added unsupported and untested "support" for Tru64 (with gcc).
- Renamed CompressionNotSupportException to a more general
FeatureNotSupportedException.
- Fixed a bug in proxyToString() for bidirectional proxies.
- Added ice_communicator() to proxies. This function returns the
communicator that was used to create the proxy.
- Added ice_toString() to proxies. This function returns the
stringified proxy. This function can be more convenient to use than
communicator->stringToProxy() because you do not need the
communicator to stringify a proxy that way.
operator<< is overloaded for proxies and proxy handles, so you can
write:
Ice::ObjectPrx o = ...;
cout << o << endl; // Print stringified proxy, empty
// string if o is null
cout << *o << endl; // Print stringified proxy
- IceUtil/Config.h no longer includes winsock.h under WIN32. Ice can
now build with WIN32_LEAN_AND_MEAN.
- Removed operator timeval() from IceUtil::Time for WIN32.
- Parsing a stringified proxy no longer completely fails if the proxy
contains an endpoint type that is unknown to the Ice runtime as long
as the proxy contains other endpoints that are known. A warning is
printed for the unknown types that are encountered.
- Ice::Object is now an abstract class that cannot be instantiated.
This change should be transparent to application code.
- For abstract classes, ice_clone() now throws a
CloneNotImplementedException if the concrete implementation class
does not override ice_clone(). (Previously, ice_clone() incorrectly
sliced the cloned abstract class to the most derived- concrete class
or Ice::Object.)
- Added new features to the C++ mapping:
- Classes and exceptions now have one-shot constructors. For
example, for a class
class Example {
int i;
string s;
};
the following constructors are generated:
class Example {
Example();
Example(::Ice::Int, const ::std::string&);
// ...
};
This allows you to construct a class or exception and supply
values for the data members in a single statement, instead of
having to assign to the members of a default-constructed instance.
For derived exceptions and classes, the constructor expects values
for all data members, including those of base exceptions or
classes, in base-to-derived order of declaration.
- Classes are now copyable and assignable. For example, using the
previous Example class, the following statements are now valid
(whereas, previously, they would have caused compile-time errors):
Example e1;
Example e2(1, "hello");
e1 = e2;
ExamplePtr ep1 = new Example();
*ep1 = e2;
- Removed IceSSL's internal handshake retry loop, along with the
related property IceSSL.Client.Handshake.Retries.
- Added support for OpenSSL 0.98.
Changes since version 2.1.1
---------------------------
- Fixed a bug in proxyToString() for bidirectional proxies.
- Fixed a bug with dynamic thread pools, where new threads were
destroyed immediately after dispatch if .Size=1 and
.SizeMax > 1.
- Fixed a few Windows bugs in the Ice::Service class.
- Fixed a bug in the Ice core involving command-line arguments that
could result in an array access violation.
- Changed the Ice::Service class on Windows so that service failures
do not cause the obscure message "Error1: Incorrect function".
- Removed the 64KB packet size limitation for TCP in Windows.
- Changed the C++ translator so that generated code no longer uses
static function data.
- Fixed a bug in IcePack where stopping a server could hang if the
server didn't answer the Ice::Process::shutdown() call.
- Changed IceStorm subscriber reaping to release dead subscribers
more quickly from memory.
- Fixed a bug in IceStorm where the mode (idempotent or nonmutating)
of the request wasn't correctly forwarded to the subscribers.
- Added IcePack.Registry.AdminIdentity, IcePack.Registry.QueryIdentity
and IcePack.Registry.LocatorIdentity properties to allow configuring
the identities of well-known IcePack registry interfaces.
- Added the configuration property Ice.Compression.Level to provide
more control over the bzip2 algorithm used to compress Ice protocol
messages.
- Fixed a bug in the Glacier2 router where buffered mode serialized
twoway requests when it should not.
Changes since version 2.1.0
---------------------------
- Fixed bug with the random selection of an endpoint for a proxy with
multiple endpoints configured. The random number generator used
by GCC was not being seeded, causing the selection order to always
be the same.
- Fixed Slice compilers to allow file names containing whitespace.
- Fixed a thread pool bug on Win32 in which the file descriptors for
the pipe were not closed.
- Fixed a bug in Freeze Maps: you can now add an index to an existing
Freeze Map.
- Added sequences of fixed-length elements to throughput demo.
- Added RTLD_GLOBAL when calling dlopen on Unix platforms.
- Fixed a bug that could cause an assert if connections could not be
established in thread-per-connection mode.
- Added two new properties for controlling Active Connection
Management (ACM). In prior releases ACM was governed by the property
Ice.ConnectionIdleTime, which affected client- and server-side
behavior. The new properties, Ice.ACM.Client and Ice.ACM.Server,
now allow independent timeouts to be specified for client- and
server-side ACM. Ice.ConnectionIdleTime is now deprecated.
- Reverted a change introduced in 2.1.0 in which retries were not
attempted for oneway and batch oneway requests. Ice now behaves
as it did in prior releases: if the connection associated with a
oneway or batch oneway proxy is closed, an invocation on the proxy
will transparently reestablish the connection. Please see the Ice
manual for more information on the reliability of oneway and batch
oneway reliability.
- A race condition with Glacier2 detaching the request handler thread
has been fixed.
- Added -E option to the various Slice compilers to print preprocessor
output on stdout.
- Ice::ObjectNotExistException is now retried for invocations made on
indirect proxies. This allows the transparent migration of objects
or objects adapters.
- As announced with version 1.5, slice2cpp and slice2freeze now
require all Slice definitions to be nested inside a module;
definitions at global scope (other than module definitions) now
cause a hard error (whereas, previously, they only caused a
warning).
- Fixed a bug in the option parsing for Ice tools such as slice2cpp,
slice2java, slice2cs, etc. The option parser used to incorrectly
complain about repeated options when in fact no option was
repeated. Also changed the parser to permit options to follow an
argument, so
slice2cpp -I. x.ice
and
slice2cpp x.ice -I.
are now equivalent.
- Fixed bug where the IcePack node with a collocated registry wouldn't
terminate after the admin "shutdown" command.
- The Windows demo/IcePatch2/MFC example displays an error dialog when
the patch client is run without the --IcePatch2.Endpoints option.
- Fixed bug where data transfer statistics were not being reported on
outgoing datagram requests.
Changes since version 2.0.0
---------------------------
- Fixed bug in the code generators for C# and VB: for sequences
of structs and sequences of Object*, incorrect code was generated
if a ["cs:collection"] or ["vb:collection"] metadata directive
was used.
- We do not retry oneway or batch oneway requests anymore, except if
there are problems during connection establishment. If we retry a
oneway or batch oneway, previous oneways from the same batch, or
previous oneways that are buffered by the IP stack implementation,
are silently thrown away. This can lead to a situation where the
latest oneway succeeds due to retry, but former oneways are
discarded.
- Fixed race between connection validation and activation for UDP
endpoints in thread-per-connection mode.
- Fixed a deadlock that could occur if a server cannot send data
during connection validation.
- Glacier2 could hang if a server is not running. This has been fixed.
- Added support for g++ builds on Solaris.
- Fixed IcePack node and registry database environment names. They
have been changed to be the name of the node for IcePack nodes and
'Registry' for the IcePack registry. This means that you can now
configure the database environment using the properties prefixed
with Freeze.DbEnv. or Freeze.DbEnv.Registry.
- Fixed a bug where the endpoint cache for indirect proxies wasn't
always cleared upon a communication failure with an object.
- Fixed a race condition in the IcePack on-demand server activation
code which could cause clients to hang under rare conditions if the
server couldn't be activated.
- Fixed a small memory leak in the IcePack node that would occur each
time a process is forked (Unix only).
- Added 'object list' and 'object describe' IcePack admin commands.
- Changed the signature of IcePack::Admin::removeObject() to take the
identity of the object instead of its proxy.
- Connection validation now checks for the timeout specified by the
property Ice.Override.ConnectTimeout and will raise
Ice::ConnectTimeoutException if the connection validation times out.
- Fixed an assert that could occur during connection establishment if
no more file descriptors are available.
- Improved support for on-demand server activation in IcePack.
- Improved the IcePack registry to prevent potential deadlocks caused
by thread starvation.
- The Ice manual stated that the IcePack configuration property
IcePack.Registry.Internal.Endpoints was only necessary when nodes
were being used, but in fact the property is required regardless
of whether nodes are used. The manual has been updated accordingly.
- Fixed a bug where Ice::ObjectAdapter::activate() could throw
Ice::ObjectAdapterDeactivatedException if the object adapter was
deactivated concurrently.
- Fixed a bug where setting the locator proxy on an indirect proxy
could cause an assert.
- Fixed a bug in IceSSL when multiple communicators are used.
- Added an optimization to the Freeze evictor for the ice_ping
operation. The object is no longer loaded into the cache by this
operation; Freeze simply checks if the object is in the cache or
the database.
- Fixed a slice2cpp failure when the --output-dir option specified a
directory containing backslashes.
- Changed the signature of Ice::Service::main() and
Ice::Service::run() to accept a reference to argc (int & argc)
rather than passing argc by value (int argc). This is to ensure
that, if Ice::initialize() or Ice::Service::initializeCommunicator()
rewrites argv, argc reflects the number of elements of the rewritten
argument vector.
- Fixed an encoding bug in IceSSL.
- Fixed incorrect logging message if no more endpoints are available
for retry.
- Added setDefaultContext() and getDefaultContext() to the
Ice::Communicator interface. This allows a default context to be
established on a communicator-wide basis. See section 29.9.3 in the
doc.
Added ice_defaultContext to Ice::ObjectProxy. This creates a new
proxy that uses the default context established on the communicator.
- Fixed a rare proxy marshaling bug that could cause the receiver to
encounter an UnmarshalOutOfBoundsException.
- Overloaded the checkedCast member function of the generated Prx
classes to allow a trailing argument of type Ice::Context. This
makes it possible to do stateful things that require a context in a
servant locator's activate() method.
- Added catalogs for Freeze: each database environment used by Freeze
now contains a special dictionary (named __catalog) that keeps track
of all evictor and dictionary databases in this environment.
- Fixed a bug in slice2cs and slice2vb: incorrect code was generated
if an interface was derived from a base interface in a different
module and if the base interface contained an AMD operation.
Changes since version 1.5.1
---------------------------
- Fixed a bug in IcePack which could cause a core dump of the IcePack
registry or node when updating an application deployment.
- The proxy returned by the object adapter operations addFacet and
addFacetWithUUID did not contain the facet. This required the
application to make an extra call to ice_newFacet in order to
obtain the correct proxy. This has been fixed.
- Added the object adapter property .PublishedEndpoints, which
specifies endpoints to advertise in proxies created by the adapter.
- For WIN32, Thread::getThreadControl() set the thread id of the
ThreadControl object to the current thread instead of the thread the
control object belongs to. This has been fixed.
- Changed Ice::Service to use _exit() in the daemon parent.
- Fixed a bug with AMD exception handling, where it was possible that
certain exceptions propagate out of ice_response() or
ice_exception(), and therefore such exceptions were not handled
properly.
- Exceptions raised while marshaling data for batch requests resulted
in a connection deadlock. This has been fixed.
- Fixed a bug in slice2cs: the generated code was incorrect for
dictionaries with sequence value types, if that sequence value type
was mapped to an array.
- Fixed bug in IcePack that would prevent dynamically added adapters
from being used again after the IcePack registry was restarted.
- Fixed tracing of operation mode.
- Fixed bug in slice2cpp: for statically linked binaries under
Windows, exceptions and classes could cause an
UnmarshalOutOfBoundsException.
- Fixed bug in slice2java: with the --impl-tie option, incorrect code
was generated for local interfaces and classes.
- Tightened semantic check for all Slice compilers: previously, a
local interface or class could be derived from a non-local interface
or class. This is now correctly diagnosed as an error.
- Changed code generation in slice2java: for local interfaces, only an
OperationsNC (but no Operations) interface is generated
now. (Previously, both interfaces were generated, with one of them
being empty.)
- The IceSSL plug-in was using regular mutexes in some places where
static mutexes are necessary. This has been fixed.
- Fixed a bug in the garbage collector that caused a crash in rare
circumstances.
- Freeze dictionaries now support indices. You can index on the full
value of the dictionary, or on a member (when the value is a struct
or a class). When you index on a member, you can define several
indices (for different members). See the Freeze bench demo and the
Freeze dbmap test for examples.
- The Ice::Service class no longer resets the umask to 0, but rather
uses the inherited umask.
- Fixed a code generation problem in slice2cpp. This problem showed up
only for the --impl option.
- Changed the way C++ keywords are escaped. Previously, a Slice
identifier that is a C++ keyword was escaped everywhere. For
example, Slice "while" was mapped to "_cpp_while" and
"_cpp_whilePrx". With the change, Slice "while" is mapped to
"_cpp_while" and "whilePrx".
- Fixed the slice2java and slice2cs compilers for operations with
multiple exceptions in an exception specification: if an exception
was a base of one or more other exceptions in the same exception
specification, the code generator sometimes emitted the catch blocks
in the marshaling and dispatch code in the wrong order. (This
applied only to interfaces with an ["amd"] metadata directive.)
- Fixed a bug in the slice2cs code generator:
["cs:collection"] sequence