zeroc-ice 3.7.9.1 → 3.8.0

data/dist/ice/slice/IceGrid/Registry.ice

@@ -0,0 +1,130 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICEGRID_API"]]
+[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceGrid/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Admin.ice"
+#include "Exception.ice"
+#include "Ice/Locator.ice"
+#include "Session.ice"
+
+/// Deploy and manage Ice servers.
+["java:identifier:com.zeroc.IceGrid"]
+module IceGrid
+{
+    /// Determines which load sampling interval to use.
+    enum LoadSample
+    {
+        /// Sample every minute.
+        ["swift:identifier:loadSample1"]
+        LoadSample1,
+
+        /// Sample every five minutes.
+        ["swift:identifier:loadSample5"]
+        LoadSample5,
+
+        /// Sample every fifteen minutes.
+        ["swift:identifier:loadSample15"]
+        LoadSample15
+    }
+
+    /// Finds well-known Ice objects registered with the IceGrid registry.
+    interface Query
+    {
+        /// Finds a well-known object by identity.
+        /// @param id The identity.
+        /// @return A proxy to the well-known object, or null if no such object is registered.
+        ["cpp:const"]
+        idempotent Object* findObjectById(Ice::Identity id);
+
+        /// Finds a well-known object by type. If there are several objects registered for the given type, the object is
+        /// randomly selected.
+        /// @param type The object type.
+        /// @return A proxy to a well-known object with the specified type, or null if no such object is registered.
+        ["cpp:const"]
+        idempotent Object* findObjectByType(string type);
+
+        /// Finds a well-known object by type on the least-loaded node. If the registry does not know which node hosts
+        /// the object (for example, because the object was registered with a direct proxy), the registry assumes the
+        /// object is hosted on a node that has a load average of 1.0.
+        /// @param type The object type.
+        /// @param sample The sampling interval.
+        /// @return A proxy to the well-known object, or null if no such object is registered.
+        ["cpp:const"]
+        idempotent Object* findObjectByTypeOnLeastLoadedNode(string type, LoadSample sample);
+
+        /// Finds all the well-known objects with the given type.
+        /// @param type The object type.
+        /// @return A list of proxies to the well-known objects with the specified type. Can be empty.
+        ["cpp:const"]
+        idempotent Ice::ObjectProxySeq findAllObjectsByType(string type);
+
+        /// Finds all the replicas of a well-known object.
+        /// @param proxy A proxy that identifies the well-known object.
+        /// @return A list of proxies to the replicas of the well-known object specified by @p proxy. Can be empty.
+        ["cpp:const"]
+        idempotent Ice::ObjectProxySeq findAllReplicas(Object* proxy);
+    }
+
+    /// Represents the main entry point into the IceGrid registry service. It provides operations to create sessions
+    /// with the registry.
+    interface Registry
+    {
+        /// Creates a client session.
+        /// @param userId The user ID.
+        /// @param password The password for the given user.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        Session* createSession(string userId, string password)
+            throws PermissionDeniedException;
+
+        /// Creates an administrative session.
+        /// @param userId The user ID.
+        /// @param password The password for the given user.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        AdminSession* createAdminSession(string userId, string password)
+            throws PermissionDeniedException;
+
+        /// Creates a client session from a secure connection.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        Session* createSessionFromSecureConnection()
+            throws PermissionDeniedException;
+
+        /// Creates an administrative session from a secure connection.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        AdminSession* createAdminSessionFromSecureConnection()
+            throws PermissionDeniedException;
+
+        /// Gets the session timeout. An Ice 3.7 or earlier client can use this value to determine how often it needs to
+        /// send heartbeats (using ACM) or call {@link Session#keepAlive} (resp. {@link AdminSession#keepAlive}) to keep
+        /// a session alive in the IceGrid registry.
+        /// @return The session timeout (in seconds).
+        ["cpp:const"]
+        ["deprecated"]
+        idempotent int getSessionTimeout();
+    }
+
+    /// Provides access to the {@link Query} and {@link Registry} objects implemented by the IceGrid registry.
+    interface Locator extends Ice::Locator
+    {
+        /// Gets a proxy to the registry object hosted by this IceGrid registry.
+        /// @return A proxy to the registry object. This proxy is never null.
+        ["cpp:const"]
+        idempotent Registry* getLocalRegistry();
+
+        /// Gets a proxy to the query object hosted by this IceGrid registry.
+        /// @return A proxy to the query object. This proxy is never null.
+        ["cpp:const"]
+        idempotent Query* getLocalQuery();
+    }
+}

data/dist/ice/slice/IceGrid/Session.ice

@@ -0,0 +1,64 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICEGRID_API"]]
+[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceGrid/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Exception.ice"
+#include "Glacier2/Session.ice"
+
+["java:identifier:com.zeroc.IceGrid"]
+module IceGrid
+{
+    interface Registry; // For doc-comments.
+
+    /// Represents a session object used by IceGrid clients to allocate and release objects. Client sessions are created
+    /// either via the {@link Registry} object or via the registry client {@link Glacier2::SessionManager} object.
+    interface Session extends Glacier2::Session
+    {
+        /// Keeps the session alive.
+        ["deprecated:As of Ice 3.8, there is no need to call this operation, and its implementation does nothing."]
+        idempotent void keepAlive();
+
+        /// Allocates an object.
+        /// @param id The identity of the object to allocate.
+        /// @return A proxy to the allocated object. This proxy is never null.
+        /// @throws ObjectNotRegisteredException Thrown when an object with the given identity is not registered with
+        /// the registry.
+        /// @throws AllocationException Thrown when the allocation fails.
+        /// @see #setAllocationTimeout
+        /// @see #releaseObject
+        Object* allocateObjectById(Ice::Identity id)
+            throws ObjectNotRegisteredException, AllocationException;
+
+        /// Allocates an object with the given type.
+        /// @param type The type of the object.
+        /// @return A proxy to the allocated object. This proxy is never null.
+        /// @throws AllocationException Thrown when the allocation fails.
+        /// @see #setAllocationTimeout
+        /// @see #releaseObject
+        Object* allocateObjectByType(string type)
+            throws AllocationException;
+
+        /// Releases an object that was allocated using {@link allocateObjectById} or {@link allocateObjectByType}.
+        /// @param id The identity of the object to release.
+        /// @throws ObjectNotRegisteredException Thrown when an object with the given identity is not registered with
+        /// the registry.
+        /// @throws AllocationException Thrown when the object can't be released. This can happen when the object is not
+        /// allocatable or is not allocated by this session.
+        void releaseObject(Ice::Identity id)
+            throws ObjectNotRegisteredException, AllocationException;
+
+        /// Sets the allocation timeout. When no object is immediately available for an allocation request, the
+        /// implementation of {@link allocateObjectById} and {@link allocateObjectByType} waits for the duration of
+        /// this @p timeout.
+        /// @param timeout The timeout in milliseconds.
+        idempotent void setAllocationTimeout(int timeout);
+    }
+}

data/dist/ice/slice/IceGrid/UserAccountMapper.ice

@@ -0,0 +1,34 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICEGRID_API"]]
+[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceGrid/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+["java:identifier:com.zeroc.IceGrid"]
+module IceGrid
+{
+    /// The exception that is thrown when a user account for a given session identifier can't be found.
+    exception UserAccountNotFoundException
+    {
+    }
+
+    /// Maps user strings in server descriptors to actual user account names. You can configure the user account mapper
+    /// of an IceGrid node with the property `IceGrid.Node.UserAccountMapper`.
+    interface UserAccountMapper
+    {
+        /// Gets the name of the user account for the given user. This is used by IceGrid nodes to figure out the user
+        /// account to use to run servers.
+        /// @param user The value of the server descriptor's `user` attribute. When this attribute is not defined, and
+        /// the server's activation mode is `session`, the default value for `user` is the session identifier.
+        /// @return The user account name.
+        /// @throws UserAccountNotFoundException Thrown when no user account is found for the given user.
+        string getUserAccount(string user)
+            throws UserAccountNotFoundException;
+    }
+}

data/dist/ice/slice/IceStorm/IceStorm.ice

@@ -0,0 +1,186 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICESTORM_API"]]
+[["cpp:doxygen:include:IceStorm/IceStorm.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceStorm/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/Identity.ice"
+#include "Metrics.ice"
+
+/// Lightweight publish/subscribe framework, available for all Ice language mappings.
+["java:identifier:com.zeroc.IceStorm"]
+module IceStorm
+{
+    interface Topic;
+
+    /// Information about a topic link.
+    struct LinkInfo
+    {
+        /// The linked topic proxy. This proxy is never null.
+        Topic* theTopic;
+
+        /// The name of the linked topic.
+        string name;
+
+        /// The cost of traversing this link.
+        int cost;
+    }
+
+    /// A sequence of {@link LinkInfo} objects.
+    sequence<LinkInfo> LinkInfoSeq;
+
+    /// Quality of service parameters.
+    /// @see Topic#subscribeAndGetPublisher
+    dictionary<string, string> QoS;
+
+    /// The exception that is thrown when attempting to create a link that already exists.
+    exception LinkExists
+    {
+        /// The name of the linked topic.
+        string name;
+    }
+
+    /// The exception that is thrown when attempting to remove a link that does not exist.
+    exception NoSuchLink
+    {
+        /// The name of the link that does not exist.
+        string name;
+    }
+
+    /// The exception that is thrown when attempting to subscribe a proxy for which a subscription already exists.
+    exception AlreadySubscribed
+    {
+    }
+
+    /// The exception that is thrown when attempting to subscribe with an invalid {@link QoS}.
+    exception BadQoS
+    {
+        /// The reason for the failure.
+        string reason;
+    }
+
+    /// Represents an IceStorm topic. Publishers publish data to a topic (via the topic's publisher object), and
+    /// subscribers subscribe to a topic.
+    /// @see TopicManager
+    interface Topic
+    {
+        /// Gets the name of this topic.
+        /// @return The name of the topic.
+        /// @see TopicManager#create
+        ["cpp:const"]
+        idempotent string getName();
+
+        /// Gets a proxy to a publisher object for this topic. To publish data to a topic, a publisher calls this
+        /// operation and then creates a proxy with the publisher type from this proxy. If a replicated IceStorm
+        /// deployment is used, this call may return a replicated proxy.
+        /// @return A proxy to publish data on this topic. This proxy is never null.
+        ["cpp:const"]
+        idempotent Object* getPublisher();
+
+        /// Gets a non-replicated proxy to a publisher object for this topic. To publish data to a topic, a publisher
+        /// calls this operation and then creates a proxy with the publisher type from this proxy.
+        /// @return A proxy to publish data on this topic. This proxy is never null.
+        ["cpp:const"]
+        idempotent Object* getNonReplicatedPublisher();
+
+        /// Subscribes to this topic.
+        /// @param theQoS The quality of service parameters for this subscription.
+        /// @param subscriber The subscriber's proxy. This proxy cannot be null.
+        /// @return The per-subscriber publisher proxy. This proxy is never null.
+        /// @throws AlreadySubscribed Thrown when @p subscriber is already subscribed.
+        /// @throws BadQoS Thrown when @p theQoS is unavailable or invalid.
+        /// @see #unsubscribe
+        Object* subscribeAndGetPublisher(QoS theQoS, Object* subscriber)
+            throws AlreadySubscribed, BadQoS;
+
+        /// Unsubscribes the provided @p subscriber from this topic.
+        /// @param subscriber A proxy to an existing subscriber. This proxy is never null.
+        /// @see #subscribeAndGetPublisher
+        idempotent void unsubscribe(Object* subscriber);
+
+        /// Creates a link to another topic. All events originating on this topic will also be sent to the other topic.
+        /// @param linkTo The topic to link to. This proxy cannot be null.
+        /// @param cost The cost of the link.
+        /// @throws LinkExists Thrown when a link to @p linkTo already exists.
+        void link(Topic* linkTo, int cost) throws LinkExists;
+
+        /// Destroys a link from this topic to the provided topic.
+        /// @param linkTo The topic to destroy the link to. This proxy cannot be null.
+        /// @throws NoSuchLink Thrown when a link to @p linkTo does not exist.
+        void unlink(Topic* linkTo) throws NoSuchLink;
+
+        /// Gets information on the current links.
+        /// @return A sequence of LinkInfo objects.
+        ["cpp:const"]
+        idempotent LinkInfoSeq getLinkInfoSeq();
+
+        /// Gets the list of subscribers for this topic.
+        /// @return The sequence of Ice identities for the subscriber objects.
+        ["cpp:const"] Ice::IdentitySeq getSubscribers();
+
+        /// Destroys this topic.
+        void destroy();
+    }
+
+    /// A dictionary of topic name to topic proxy.
+    dictionary<string, Topic*> TopicDict;
+
+    /// The exception that is thrown when attempting to create a topic that already exists.
+    exception TopicExists
+    {
+        /// The name of the topic that already exists.
+        string name;
+    }
+
+    /// The exception that is thrown when attempting to retrieve a topic that does not exist.
+    exception NoSuchTopic
+    {
+        /// The name of the topic that does not exist.
+        string name;
+    }
+
+    /// Represents an object that manages topics.
+    /// @see Topic
+    interface TopicManager
+    {
+        /// Creates a new topic.
+        /// @param name The name of the topic.
+        /// @return A proxy to the new topic object. The returned proxy is never null.
+        /// @throws TopicExists Thrown when a topic with the same @p name already exists.
+        Topic* create(string name) throws TopicExists;
+
+        /// Retrieves a topic by name.
+        /// @param name The name of the topic.
+        /// @return A proxy to the topic object. The returned proxy is never null.
+        /// @throws NoSuchTopic Thrown when there is no topic named @p name.
+        idempotent Topic* retrieve(string name) throws NoSuchTopic;
+
+        /// Creates a new topic with the given name, or retrieves the existing topic with this name if it already
+        /// exists.
+        /// @param name The name of the topic.
+        /// @return A proxy to the topic object. The returned proxy is never null.
+        Topic* createOrRetrieve(string name);
+
+        /// Retrieves all topics managed by this topic manager.
+        /// @return A dictionary of string, topic proxy pairs.
+        idempotent TopicDict retrieveAll();
+    }
+
+    /// Provides access to a {@link TopicManager} object via a fixed identity.
+    /// An IceStorm Finder is always registered with identity `IceStorm/Finder`. This allows clients to obtain the
+    /// associated TopicManager proxy with just the endpoint information of the object. For example, you can use the
+    /// Finder proxy `IceStorm/Finder:tcp -h somehost -p 4061` to get the TopicManager proxy
+    /// `MyIceStorm/TopicManager:tcp -h somehost -p 4061`.
+    interface Finder
+    {
+        /// Gets a proxy to the associated {@link TopicManager}. The proxy might point to several replicas.
+        /// @return The topic manager proxy. This proxy is never null.
+        TopicManager* getTopicManager();
+    }
+}

data/dist/ice/slice/IceStorm/Metrics.ice

@@ -0,0 +1,41 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICESTORM_API"]]
+[["cpp:doxygen:include:IceStorm/IceStorm.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceStorm/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/Metrics.ice"
+
+["java:identifier:com.zeroc.IceMX"]
+["swift:identifier:IceStorm"]
+module IceMX
+{
+    /// Provides information about one or more IceStorm topics.
+    class TopicMetrics extends Metrics
+    {
+        /// The number of events published on the topic(s) by publishers.
+        long published = 0;
+
+        /// The number of events forwarded on the topic(s) by IceStorm topic links.
+        long forwarded = 0;
+    }
+
+    /// Provides information about IceStorm subscribers.
+    class SubscriberMetrics extends Metrics
+    {
+        /// The number of queued events.
+        int queued = 0;
+
+        /// The number of outstanding events.
+        int outstanding = 0;
+
+        /// The number of forwarded events.
+        long delivered = 0;
+    }
+}

data/dist/lib/Glacier2/Metrics.rb

@@ -0,0 +1,41 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2rb version 3.8.0
+# <auto-generated>Generated from Slice file 'Metrics.ice'.</auto-generated>
+
+require 'Ice'
+require 'Ice/Metrics.rb'
+
+module ::IceMX
+    if not defined?(::IceMX::T_SessionMetrics)
+        T_SessionMetrics = Ice::__declareClass('::IceMX::SessionMetrics')
+    end
+
+    if not defined?(::IceMX::SessionMetrics)
+        class SessionMetrics < ::IceMX::Metrics
+
+            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, forwardedClient=0, forwardedServer=0, routingTableSize=0, queuedClient=0, queuedServer=0, overriddenClient=0, overriddenServer=0)
+                super(id, total, current, totalLifetime, failures)
+                @forwardedClient = forwardedClient
+                @forwardedServer = forwardedServer
+                @routingTableSize = routingTableSize
+                @queuedClient = queuedClient
+                @queuedServer = queuedServer
+                @overriddenClient = overriddenClient
+                @overriddenServer = overriddenServer
+            end
+
+            attr_accessor :forwardedClient, :forwardedServer, :routingTableSize, :queuedClient, :queuedServer, :overriddenClient, :overriddenServer
+        end
+
+        T_SessionMetrics.defineClass(SessionMetrics, -1, false, ::IceMX::T_Metrics, [
+            ['forwardedClient', Ice::T_int, false, 0],
+            ['forwardedServer', Ice::T_int, false, 0],
+            ['routingTableSize', Ice::T_int, false, 0],
+            ['queuedClient', Ice::T_int, false, 0],
+            ['queuedServer', Ice::T_int, false, 0],
+            ['overriddenClient', Ice::T_int, false, 0],
+            ['overriddenServer', Ice::T_int, false, 0]
+        ])
+    end
+end

data/dist/lib/Glacier2/PermissionsVerifier.rb

@@ -0,0 +1,61 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2rb version 3.8.0
+# <auto-generated>Generated from Slice file 'PermissionsVerifier.ice'.</auto-generated>
+
+require 'Ice'
+require_relative 'SSLInfo.rb'
+
+module ::Glacier2
+    if not defined?(::Glacier2::PermissionDeniedException)
+        class PermissionDeniedException < Ice::UserException
+            def to_s
+                '::Glacier2::PermissionDeniedException'
+            end
+
+            attr_accessor :reason
+        end
+
+        T_PermissionDeniedException = Ice::__defineException('::Glacier2::PermissionDeniedException', PermissionDeniedException, nil, [["reason", Ice::T_string, false, 0]])
+    end
+
+    if not defined?(::Glacier2::T_PermissionsVerifierPrx)
+        T_PermissionsVerifierPrx = Ice::__declareProxy('::Glacier2::PermissionsVerifier')
+    end
+
+    if not defined?(::Glacier2::PermissionsVerifierPrx)
+        module PermissionsVerifierPrx_mixin
+            def checkPermissions(userId, password, context=nil)
+                PermissionsVerifierPrx_mixin::OP_checkPermissions.invoke(self, [userId, password], context)
+            end
+        end
+
+        class PermissionsVerifierPrx < Ice::ObjectPrx
+            include PermissionsVerifierPrx_mixin
+        end
+
+        T_PermissionsVerifierPrx.defineProxy(PermissionsVerifierPrx, nil, [])
+
+        PermissionsVerifierPrx_mixin::OP_checkPermissions = Ice::__defineOperation('checkPermissions', 'checkPermissions', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0], [Ice::T_string, false, 0]], [[Ice::T_string, false, 0]], [Ice::T_bool, false, 0], [::Glacier2::T_PermissionDeniedException])
+    end
+
+    if not defined?(::Glacier2::T_SSLPermissionsVerifierPrx)
+        T_SSLPermissionsVerifierPrx = Ice::__declareProxy('::Glacier2::SSLPermissionsVerifier')
+    end
+
+    if not defined?(::Glacier2::SSLPermissionsVerifierPrx)
+        module SSLPermissionsVerifierPrx_mixin
+            def authorize(info, context=nil)
+                SSLPermissionsVerifierPrx_mixin::OP_authorize.invoke(self, [info], context)
+            end
+        end
+
+        class SSLPermissionsVerifierPrx < Ice::ObjectPrx
+            include SSLPermissionsVerifierPrx_mixin
+        end
+
+        T_SSLPermissionsVerifierPrx.defineProxy(SSLPermissionsVerifierPrx, nil, [])
+
+        SSLPermissionsVerifierPrx_mixin::OP_authorize = Ice::__defineOperation('authorize', 'authorize', Ice::OperationMode::Idempotent, nil, [[::Glacier2::T_SSLInfo, false, 0]], [[Ice::T_string, false, 0]], [Ice::T_bool, false, 0], [::Glacier2::T_PermissionDeniedException])
+    end
+end

data/dist/lib/Glacier2/Router.rb

@@ -0,0 +1,73 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2rb version 3.8.0
+# <auto-generated>Generated from Slice file 'Router.ice'.</auto-generated>
+
+require 'Ice'
+require 'Ice/Router.rb'
+require_relative 'PermissionsVerifier.rb'
+require_relative 'Session.rb'
+
+module ::Glacier2
+    if not defined?(::Glacier2::SessionNotExistException)
+        class SessionNotExistException < Ice::UserException
+            def to_s
+                '::Glacier2::SessionNotExistException'
+            end
+        end
+
+        T_SessionNotExistException = Ice::__defineException('::Glacier2::SessionNotExistException', SessionNotExistException, nil, [])
+    end
+
+    if not defined?(::Glacier2::T_RouterPrx)
+        T_RouterPrx = Ice::__declareProxy('::Glacier2::Router')
+    end
+
+    if not defined?(::Glacier2::RouterPrx)
+        module RouterPrx_mixin
+            include ::Ice::RouterPrx_mixin
+            def getCategoryForClient(context=nil)
+                RouterPrx_mixin::OP_getCategoryForClient.invoke(self, [], context)
+            end
+
+            def createSession(userId, password, context=nil)
+                RouterPrx_mixin::OP_createSession.invoke(self, [userId, password], context)
+            end
+
+            def createSessionFromSecureConnection(context=nil)
+                RouterPrx_mixin::OP_createSessionFromSecureConnection.invoke(self, [], context)
+            end
+
+            def refreshSession(context=nil)
+                RouterPrx_mixin::OP_refreshSession.invoke(self, [], context)
+            end
+
+            def destroySession(context=nil)
+                RouterPrx_mixin::OP_destroySession.invoke(self, [], context)
+            end
+
+            def getSessionTimeout(context=nil)
+                RouterPrx_mixin::OP_getSessionTimeout.invoke(self, [], context)
+            end
+
+            def getACMTimeout(context=nil)
+                RouterPrx_mixin::OP_getACMTimeout.invoke(self, [], context)
+            end
+        end
+
+        class RouterPrx < Ice::ObjectPrx
+            include RouterPrx_mixin
+        end
+
+        T_RouterPrx.defineProxy(RouterPrx, nil, [::Ice::T_RouterPrx])
+
+        RouterPrx_mixin::OP_getCategoryForClient = Ice::__defineOperation('getCategoryForClient', 'getCategoryForClient', Ice::OperationMode::Idempotent, nil, [], [], [Ice::T_string, false, 0], [])
+        RouterPrx_mixin::OP_createSession = Ice::__defineOperation('createSession', 'createSession', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0], [Ice::T_string, false, 0]], [], [::Glacier2::T_SessionPrx, false, 0], [::Glacier2::T_PermissionDeniedException, ::Glacier2::T_CannotCreateSessionException])
+        RouterPrx_mixin::OP_createSessionFromSecureConnection = Ice::__defineOperation('createSessionFromSecureConnection', 'createSessionFromSecureConnection', Ice::OperationMode::Normal, nil, [], [], [::Glacier2::T_SessionPrx, false, 0], [::Glacier2::T_PermissionDeniedException, ::Glacier2::T_CannotCreateSessionException])
+        RouterPrx_mixin::OP_refreshSession = Ice::__defineOperation('refreshSession', 'refreshSession', Ice::OperationMode::Normal, nil, [], [], nil, [::Glacier2::T_SessionNotExistException])
+        RouterPrx_mixin::OP_refreshSession.deprecate("As of Ice 3.8, this operation does nothing.")
+        RouterPrx_mixin::OP_destroySession = Ice::__defineOperation('destroySession', 'destroySession', Ice::OperationMode::Normal, nil, [], [], nil, [::Glacier2::T_SessionNotExistException])
+        RouterPrx_mixin::OP_getSessionTimeout = Ice::__defineOperation('getSessionTimeout', 'getSessionTimeout', Ice::OperationMode::Idempotent, nil, [], [], [Ice::T_long, false, 0], [])
+        RouterPrx_mixin::OP_getACMTimeout = Ice::__defineOperation('getACMTimeout', 'getACMTimeout', Ice::OperationMode::Idempotent, nil, [], [], [Ice::T_int, false, 0], [])
+    end
+end