zeroc-ice 3.7.10 → 3.8.0

data/dist/ice/slice/Glacier2/Metrics.ice

@@ -0,0 +1,47 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:GLACIER2_API"]]
+[["cpp:doxygen:include:Glacier2/Glacier2.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:Glacier2/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/Metrics.ice"
+
+["java:identifier:com.zeroc.IceMX"]
+["swift:identifier:Glacier2"]
+module IceMX
+{
+    /// Provides information about Glacier2 sessions.
+    class SessionMetrics extends Metrics
+    {
+        /// The number of client requests forwarded.
+        int forwardedClient = 0;
+
+        /// The number of server requests forwarded.
+        int forwardedServer = 0;
+
+        /// The size of the routing table.
+        int routingTableSize = 0;
+
+        /// The number of client requests queued.
+        ["deprecated:As of Ice 3.8, the Glacier2 router no longer queues requests."]
+        int queuedClient = 0;
+
+        /// The number of server requests queued.
+        ["deprecated:As of Ice 3.8, the Glacier2 router no longer queues requests."]
+        int queuedServer = 0;
+
+        /// The number of client requests overridden.
+        ["deprecated:As of Ice 3.8, the Glacier2 router no longer queues requests."]
+        int overriddenClient = 0;
+
+        /// The number of server requests overridden.
+        ["deprecated:As of Ice 3.8, the Glacier2 router no longer queues requests."]
+        int overriddenServer = 0;
+    }
+}

data/dist/ice/slice/Glacier2/PermissionsVerifier.ice

@@ -0,0 +1,55 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:GLACIER2_API"]]
+[["cpp:doxygen:include:Glacier2/Glacier2.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:Glacier2/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "SSLInfo.ice"
+
+["java:identifier:com.zeroc.Glacier2"]
+module Glacier2
+{
+    /// The exception that is thrown when a client is not allowed to create a session.
+    exception PermissionDeniedException
+    {
+        /// The reason why permission was denied.
+        string reason;
+    }
+
+    /// Represents an object that checks user permissions. The Glacier2 router and other services use a
+    /// {@link PermissionsVerifier} proxy when the user is authenticated using a user ID and password.
+    interface PermissionsVerifier
+    {
+        /// Checks if a user is authorized to establish a session.
+        /// @param userId The user ID.
+        /// @param password The user's password.
+        /// @param reason The reason why access was denied.
+        /// @return `true` if access is granted, `false` otherwise.
+        /// @throws PermissionDeniedException Thrown when the user's access is denied. This exception can be thrown
+        /// instead of returning `false` with a reason set in the reason out parameter.
+        ["cpp:const"]
+        idempotent bool checkPermissions(string userId, string password, out string reason)
+            throws PermissionDeniedException;
+    }
+
+    /// Represents an object that checks user permissions. The Glacier2 router and other services use an
+    /// {@link SSLPermissionsVerifier} proxy when the user is authenticated through an SSL certificate.
+    interface SSLPermissionsVerifier
+    {
+        /// Checks if a user is authorized to establish a session.
+        /// @param info The SSL information.
+        /// @param reason The reason why access was denied.
+        /// @return `true` if access is granted, `false` otherwise.
+        /// @throws PermissionDeniedException Thrown when the user's access is denied. This exception can be thrown
+        /// instead of returning `false` with a reason set in the reason out parameter.
+        ["cpp:const"]
+        idempotent bool authorize(SSLInfo info, out string reason)
+            throws PermissionDeniedException;
+    }
+}

data/dist/ice/slice/Glacier2/Router.ice

@@ -0,0 +1,93 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:GLACIER2_API"]]
+[["cpp:doxygen:include:Glacier2/Glacier2.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:Glacier2/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/Router.ice"
+#include "PermissionsVerifier.ice"
+#include "Session.ice"
+
+/// Communicate through firewalls and across NATs.
+["java:identifier:com.zeroc.Glacier2"]
+module Glacier2
+{
+    /// The exception that is thrown when a client tries to destroy a session with a router, but no session exists for
+    /// this client.
+    /// @see Router#destroySession
+    exception SessionNotExistException
+    {
+    }
+
+    /// The Glacier2 specialization of the {@link Ice::Router} interface.
+    interface Router extends Ice::Router
+    {
+        /// Gets a unique category that identifies the client (caller) in the router. This category must be used in the
+        /// identities of all the client's callback objects.
+        /// @return The category. It's an empty string when `Glacier2.Server.Endpoints` is not configured.
+        ["cpp:const"]
+        idempotent string getCategoryForClient();
+
+        /// Creates a session for the client (caller) with the router. If a {@link SessionManager} is configured,
+        /// a proxy to a {@link Session} object is returned to the client. Otherwise, null is returned and only an
+        /// internal session (i.e., not visible to the client) is created.
+        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
+        /// This occurs automatically when the router is configured as the client's default router at the time the
+        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
+        /// explicitly.
+        /// @param userId The user ID.
+        /// @param password The password.
+        /// @return A proxy for the newly created session, or null if no {@link SessionManager} is configured.
+        /// @throws PermissionDeniedException Thrown when an authentication or authorization failure occurs.
+        /// @throws CannotCreateSessionException Thrown when the session cannot be created.
+        /// @see Session
+        /// @see SessionManager
+        /// @see PermissionsVerifier
+        Session* createSession(string userId, string password)
+            throws PermissionDeniedException, CannotCreateSessionException;
+
+        /// Creates a per-client session with the router. The user is authenticated through the SSL certificate(s)
+        /// associated with the connection. If an {@link SSLSessionManager} is configured, a proxy to a {@link Session}
+        /// object is returned to the client. Otherwise, null is returned and only an internal session (i.e., not
+        /// visible to the client) is created.
+        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
+        /// This occurs automatically when the router is configured as the client's default router at the time the
+        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
+        /// explicitly.
+        /// @return A proxy for the newly created session, or null if no {@link SSLSessionManager} is configured.
+        /// @throws PermissionDeniedException Thrown when an authentication or authorization failure occurs.
+        /// @throws CannotCreateSessionException Thrown when the session cannot be created.
+        /// @see Session
+        /// @see SessionManager
+        /// @see PermissionsVerifier
+        Session* createSessionFromSecureConnection()
+            throws PermissionDeniedException, CannotCreateSessionException;
+
+        /// Keeps the session with this router alive.
+        /// @throws SessionNotExistException Thrown when no session exists for the caller (client).
+        ["deprecated:As of Ice 3.8, this operation does nothing."]
+        void refreshSession()
+            throws SessionNotExistException;
+
+        /// Destroys the session of the caller with this router.
+        /// @throws SessionNotExistException Thrown when no session exists for the caller (client).
+        void destroySession()
+            throws SessionNotExistException;
+
+        /// Gets the idle timeout used by the server-side of the connection.
+        /// @return The idle timeout (in seconds).
+        ["cpp:const"]
+        idempotent long getSessionTimeout();
+
+        /// Gets the idle timeout used by the server-side of the connection.
+        /// @return The idle timeout (in seconds).
+        ["cpp:const"]
+        idempotent int getACMTimeout();
+    }
+}

data/dist/ice/slice/Glacier2/SSLInfo.ice

@@ -0,0 +1,42 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:GLACIER2_API"]]
+[["cpp:doxygen:include:Glacier2/Glacier2.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:Glacier2/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/BuiltinSequences.ice"
+
+["java:identifier:com.zeroc.Glacier2"]
+module Glacier2
+{
+    interface SSLPermissionsVerifier; // So that doc-comments can link to `SSLPermissionsVerifier`.
+
+    /// Represents information gathered from an incoming SSL connection and used for authentication and authorization.
+    /// @see SSLPermissionsVerifier
+    struct SSLInfo
+    {
+        /// The remote host.
+        string remoteHost;
+
+        /// The remote port.
+        int remotePort;
+
+        /// The router's host.
+        string localHost;
+
+        /// The router's port.
+        int localPort;
+
+        /// The negotiated cipher suite.
+        string cipher;
+
+        /// The certificate chain.
+        Ice::StringSeq certs;
+    }
+}

data/dist/ice/slice/Glacier2/Session.ice

@@ -0,0 +1,133 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:GLACIER2_API"]]
+[["cpp:doxygen:include:Glacier2/Glacier2.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:Glacier2/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/BuiltinSequences.ice"
+#include "Ice/Identity.ice"
+#include "SSLInfo.ice"
+
+["java:identifier:com.zeroc.Glacier2"]
+module Glacier2
+{
+    interface Router; // So that doc-comments can link to `Glacier2::Router`.
+
+    /// The exception that is thrown when an attempt to create a new session fails.
+    exception CannotCreateSessionException
+    {
+        /// The reason why the session creation failed.
+        string reason;
+    }
+
+    /// Represents a session between a client application and the Glacier2 router. With Glacier2, the lifetime of a
+    /// session is tied to the Ice connection between the client and the router: the session is destroyed when the
+    /// connection is closed.
+    /// @see Router
+    /// @see SessionManager
+    interface Session
+    {
+        /// Destroys this session.
+        void destroy();
+    }
+
+    /// Manages a set of constraints on a {@link Session}.
+    /// @see SessionControl
+    interface StringSet
+    {
+        /// Adds a sequence of strings to this set of constraints. Order is not preserved and duplicates are implicitly
+        /// removed.
+        /// @param additions The sequence of strings to add.
+        idempotent void add(Ice::StringSeq additions);
+
+        /// Removes a sequence of strings from this set of constraints. No errors are returned if an entry is not found.
+        /// @param deletions The sequence of strings to remove.
+        idempotent void remove(Ice::StringSeq deletions);
+
+        /// Gets a sequence of strings describing the constraints in this set.
+        /// @return The sequence of strings for this set.
+        ["swift:identifier:`get`"]
+        idempotent Ice::StringSeq get();
+    }
+
+    /// Manages a set of object identity constraints on a {@link Session}.
+    /// @see SessionControl
+    interface IdentitySet
+    {
+        /// Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
+        /// implicitly removed.
+        /// @param additions The sequence of Ice identities to add.
+        idempotent void add(Ice::IdentitySeq additions);
+
+        /// Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
+        /// found.
+        /// @param deletions The sequence of Ice identities to remove.
+        idempotent void remove(Ice::IdentitySeq deletions);
+
+        /// Gets a sequence of identities describing the constraints in this set.
+        /// @return The sequence of Ice identities for this set.
+        ["swift:identifier:`get`"]
+        idempotent Ice::IdentitySeq get();
+    }
+
+    /// Represents a router-provided object that allows an application-provided session manager to configure the
+    /// routing constraints for a session.
+    /// @see SessionManager
+    interface SessionControl
+    {
+        /// Gets a proxy to the object that manages the allowable categories for object identities for this session.
+        /// @return A proxy to a {@link StringSet} object. This proxy is never null.
+        StringSet* categories();
+
+        /// Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
+        /// @return A proxy to a {@link StringSet} object. This proxy is never null.
+        StringSet* adapterIds();
+
+        /// Gets a proxy to the object that manages the allowable object identities for this session.
+        /// @return A proxy to an {@link IdentitySet} object. This proxy is never null.
+        IdentitySet* identities();
+
+        /// Gets the session timeout.
+        /// @return The timeout.
+        idempotent int getSessionTimeout();
+
+        /// Destroys the associated session.
+        void destroy();
+    }
+
+    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
+    /// own SessionManager implementation; this router will then return the sessions created by this session manager to
+    /// its clients.
+    interface SessionManager
+    {
+        /// Creates a new session object.
+        /// @param userId The user ID for the session.
+        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
+        /// is not configured.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws CannotCreateSessionException Thrown when the session cannot be created.
+        Session* create(string userId, SessionControl* control)
+            throws CannotCreateSessionException;
+    }
+
+    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
+    /// own SSLSessionManager implementation; this router will then return the sessions created by this session manager
+    /// to its clients.
+    interface SSLSessionManager
+    {
+        /// Creates a new session object.
+        /// @param info The SSL info.
+        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
+        /// is not configured.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws CannotCreateSessionException Thrown when the session cannot be created.
+        Session* create(SSLInfo info, SessionControl* control)
+            throws CannotCreateSessionException;
+    }
+}

data/dist/ice/slice/Ice/BuiltinSequences.ice

@@ -0,0 +1,54 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:no-default-include"]]
+[["cpp:include:Ice/Config.h"]]
+[["cpp:include:Ice/ObjectF.h"]]
+[["cpp:include:Ice/ProxyF.h"]]
+[["cpp:include:Ice/ValueF.h"]]
+[["cpp:include:cstdint"]]
+[["cpp:include:optional"]]
+[["cpp:include:string"]]
+[["cpp:include:vector"]]
+
+[["js:module:@zeroc/ice"]]
+
+["java:identifier:com.zeroc.Ice"]
+module Ice
+{
+    /// A sequence of bools.
+    sequence<bool> BoolSeq;
+
+    /// A sequence of bytes.
+    sequence<byte> ByteSeq;
+
+    /// A sequence of shorts.
+    sequence<short> ShortSeq;
+
+    /// A sequence of ints.
+    sequence<int> IntSeq;
+
+    /// A sequence of longs.
+    sequence<long> LongSeq;
+
+    /// A sequence of floats.
+    sequence<float> FloatSeq;
+
+    /// A sequence of doubles.
+    sequence<double> DoubleSeq;
+
+    /// A sequence of strings.
+    sequence<string> StringSeq;
+
+    /// A sequence of class instances.
+    ["deprecated:Define your own sequence instead and avoid using the term `object` to designate a class instance."]
+    sequence<Value> ObjectSeq;
+
+    /// A sequence of object proxies.
+    sequence<Object*> ObjectProxySeq;
+}

data/dist/ice/slice/Ice/Context.ice

@@ -0,0 +1,24 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:no-default-include"]]
+[["cpp:include:Ice/Config.h"]]
+[["cpp:include:map"]]
+[["cpp:include:string"]]
+
+[["js:module:@zeroc/ice"]]
+
+["java:identifier:com.zeroc.Ice"]
+module Ice
+{
+    /// Represents additional information carried by an Ice request. This information is filled in by the application
+    /// and transmitted by Ice as-is, from the client to the server.
+    /// @remark The Ice protocol provides request contexts but does not provide response contexts.
+    ["cpp:type:std::map<std::string, std::string, std::less<>>"]
+    dictionary<string, string> Context;
+}

data/dist/ice/slice/Ice/EndpointTypes.ice

@@ -0,0 +1,50 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:no-default-include"]]
+[["cpp:include:Ice/Config.h"]]
+[["cpp:include:cstdint"]]
+
+[["js:module:@zeroc/ice"]]
+
+// The endpoint types are called transport codes in IceRPC. They are used to marshal endpoints (as part of proxies) with
+// the Slice 1.x encoding.
+
+["java:identifier:com.zeroc.Ice"]
+module Ice
+{
+    /// Identifies endpoints marshaled as URI strings.
+    const short URIEndpointType = 0;
+
+    /// Identifies TCP endpoints.
+    const short TCPEndpointType = 1;
+
+    /// Identifies SSL endpoints.
+    const short SSLEndpointType = 2;
+
+    /// Identifies UDP endpoints.
+    const short UDPEndpointType = 3;
+
+    /// Identifies TCP-based WebSocket endpoints.
+    const short WSEndpointType = 4;
+
+    /// Identifies SSL-based WebSocket endpoints.
+    const short WSSEndpointType = 5;
+
+    /// Identifies Bluetooth endpoints.
+    const short BTEndpointType = 6;
+
+    /// Identifies SSL Bluetooth endpoints.
+    const short BTSEndpointType = 7;
+
+    /// Identifies iAP-based endpoints.
+    const short iAPEndpointType = 8;
+
+    /// Identifies SSL iAP-based endpoints.
+    const short iAPSEndpointType = 9;
+}

data/dist/ice/slice/Ice/Identity.ice

@@ -0,0 +1,36 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:no-default-include"]]
+[["cpp:include:Ice/Config.h"]]
+[["cpp:include:Ice/StreamHelpers.h"]]
+[["cpp:include:Ice/TupleCompare.h"]]
+[["cpp:include:string"]]
+[["cpp:include:vector"]]
+
+[["js:module:@zeroc/ice"]]
+
+/// The Ice RPC framework.
+["java:identifier:com.zeroc.Ice"]
+module Ice
+{
+    /// Represents the identity of an Ice object. It is comparable to the path of a URI. Its string representation is
+    /// `name` when the category is empty, and `category/name` when the category is not empty.
+    ["cpp:custom-print"]
+    struct Identity
+    {
+        /// The name of the Ice object. An empty name is not valid.
+        string name;
+
+        /// The category of the object.
+        string category = "";
+    }
+
+    /// A sequence of identities.
+    sequence<Identity> IdentitySeq;
+}

data/dist/ice/slice/Ice/Locator.ice

@@ -0,0 +1,74 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:source-include:Ice/LocatorRegistry.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Identity.ice"
+
+["java:identifier:com.zeroc.Ice"]
+module Ice
+{
+    /// The exception that is thrown by a {@link Locator} implementation when it cannot find an object adapter with the
+    /// provided adapter ID.
+    exception AdapterNotFoundException
+    {
+    }
+
+    /// The exception that is thrown by a {@link Locator} implementation when it cannot find an object with the provided
+    /// identity.
+    exception ObjectNotFoundException
+    {
+    }
+
+    interface LocatorRegistry;
+
+    /// Client applications use the Locator object to resolve Ice indirect proxies. This object also allows
+    /// server applications to retrieve a proxy to the associated {@link LocatorRegistry} object where they can register
+    /// their object adapters.
+    interface Locator
+    {
+        /// Finds an object by identity and returns a dummy proxy with the endpoint(s) that can be used to reach this
+        /// object. This dummy proxy may be an indirect proxy that requires further resolution using
+        /// {@link findAdapterById}.
+        /// @param id The identity.
+        /// @return A dummy proxy, or null if an object with the requested identity was not found.
+        /// @throws ObjectNotFoundException Thrown when an object with the requested identity was not found. The caller
+        /// should treat this exception like a null return value.
+        ["cpp:const"]
+        idempotent Object* findObjectById(Identity id)
+            throws ObjectNotFoundException;
+
+        /// Finds an object adapter by adapter ID and returns a dummy proxy with the object adapter's endpoint(s).
+        /// @param id The adapter ID.
+        /// @return A dummy proxy with the adapter's endpoints, or null if an object adapter with @p id was not found.
+        /// @throws AdapterNotFoundException Thrown when an object adapter with this adapter ID was not found. The
+        /// caller should treat this exception like a null return value.
+        ["cpp:const"]
+        idempotent Object* findAdapterById(string id)
+            throws AdapterNotFoundException;
+
+        /// Gets a proxy to the locator registry.
+        /// @return A proxy to the locator registry, or null if this locator has no associated registry.
+        ["cpp:const"]
+        idempotent LocatorRegistry* getRegistry();
+    }
+
+    /// Provides access to a {@link Locator} object via a fixed identity.
+    /// A LocatorFinder is always registered with identity `Ice/LocatorFinder`. This allows clients to obtain the
+    /// associated Locator proxy with just the endpoint information of the object. For example, you can use the
+    /// LocatorFinder proxy `Ice/LocatorFinder:tcp -h somehost -p 4061` to get the Locator proxy
+    /// `MyIceGrid/Locator:tcp -h somehost -p 4061`.
+    interface LocatorFinder
+    {
+        /// Gets a proxy to the associated {@link Locator}. The proxy might point to several replicas.
+        /// @return The locator proxy. This proxy is never null.
+        Locator* getLocator();
+    }
+}