zeroc-ice 3.6.5 → 3.7.4

data/lib/IceGrid.rb

@@ -1,17 +1,9 @@
-# **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) ZeroC, Inc. All rights reserved.
 #
-# This copy of Ice is licensed to you under the terms described in the
-# ICE_LICENSE file included in this distribution.
-#
-# **********************************************************************
 
 require 'IceGrid/Admin.rb'
 require 'IceGrid/Descriptor.rb'
 require 'IceGrid/FileParser.rb'
-require 'IceGrid/Locator.rb'
-require 'IceGrid/Observer.rb'
-require 'IceGrid/Query.rb'
 require 'IceGrid/Registry.rb'
 require 'IceGrid/UserAccountMapper.rb'

data/lib/IceGrid/Admin.rb

@@ -1,14 +1,9 @@
 # encoding: utf-8
-# **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) ZeroC, Inc. All rights reserved.
 #
-# This copy of Ice is licensed to you under the terms described in the
-# ICE_LICENSE file included in this distribution.
 #
-# **********************************************************************
-#
-# Ice version 3.6.5
+# Ice version 3.7.4
 #
 # <auto-generated>
 #
@@ -60,10 +55,6 @@ module ::IceGrid
                 @value.hash
             end
 
-            def inspect
-                @name + "(#{@value})"
-            end
-
             def ServerState.each(&block)
                 @@_enumerators.each_value(&block)
             end
@@ -94,6 +85,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ObjectInfo)
         class ObjectInfo
+            include ::Ice::Inspect_mixin
             def initialize(proxy=nil, type='')
                 @proxy = proxy
                 @type = type
@@ -117,10 +109,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ObjectInfo)
-            end
-
             attr_accessor :proxy, :type
         end
 
@@ -136,6 +124,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::AdapterInfo)
         class AdapterInfo
+            include ::Ice::Inspect_mixin
             def initialize(id='', proxy=nil, replicaGroupId='')
                 @id = id
                 @proxy = proxy
@@ -162,10 +151,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_AdapterInfo)
-            end
-
             attr_accessor :id, :proxy, :replicaGroupId
         end
 
@@ -182,6 +167,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ServerInfo)
         class ServerInfo
+            include ::Ice::Inspect_mixin
             def initialize(application='', uuid='', revision=0, node='', descriptor=nil, sessionId='')
                 @application = application
                 @uuid = uuid
@@ -217,10 +203,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ServerInfo)
-            end
-
             attr_accessor :application, :uuid, :revision, :node, :descriptor, :sessionId
         end
 
@@ -236,6 +218,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::NodeInfo)
         class NodeInfo
+            include ::Ice::Inspect_mixin
             def initialize(name='', os='', hostname='', release='', version='', machine='', nProcessors=0, dataDir='')
                 @name = name
                 @os = os
@@ -277,10 +260,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_NodeInfo)
-            end
-
             attr_accessor :name, :os, :hostname, :release, :version, :machine, :nProcessors, :dataDir
         end
 
@@ -298,6 +277,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::RegistryInfo)
         class RegistryInfo
+            include ::Ice::Inspect_mixin
             def initialize(name='', hostname='')
                 @name = name
                 @hostname = hostname
@@ -321,10 +301,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_RegistryInfo)
-            end
-
             attr_accessor :name, :hostname
         end
 
@@ -340,6 +316,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::LoadInfo)
         class LoadInfo
+            include ::Ice::Inspect_mixin
             def initialize(avg1=0.0, avg5=0.0, avg15=0.0)
                 @avg1 = avg1
                 @avg5 = avg5
@@ -366,10 +343,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_LoadInfo)
-            end
-
             attr_accessor :avg1, :avg5, :avg15
         end
 
@@ -382,6 +355,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ApplicationInfo)
         class ApplicationInfo
+            include ::Ice::Inspect_mixin
             def initialize(uuid='', createTime=0, createUser='', updateTime=0, updateUser='', revision=0, descriptor=::IceGrid::ApplicationDescriptor.new)
                 @uuid = uuid
                 @createTime = createTime
@@ -420,10 +394,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ApplicationInfo)
-            end
-
             attr_accessor :uuid, :createTime, :createUser, :updateTime, :updateUser, :revision, :descriptor
         end
 
@@ -444,6 +414,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ApplicationUpdateInfo)
         class ApplicationUpdateInfo
+            include ::Ice::Inspect_mixin
             def initialize(updateTime=0, updateUser='', revision=0, descriptor=::IceGrid::ApplicationUpdateDescriptor.new)
                 @updateTime = updateTime
                 @updateUser = updateUser
@@ -473,10 +444,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ApplicationUpdateInfo)
-            end
-
             attr_accessor :updateTime, :updateUser, :revision, :descriptor
         end
 
@@ -488,590 +455,742 @@ module ::IceGrid
         ])
     end
 
-    if not defined?(::IceGrid::Admin_mixin)
-        module Admin_mixin
-            include ::Ice::Object_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::Admin']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::Admin'
-            end
-
-            #
-            # Operation signatures.
-            #
-            # def addApplication(descriptor, current=nil)
-            # def syncApplication(descriptor, current=nil)
-            # def updateApplication(descriptor, current=nil)
-            # def syncApplicationWithoutRestart(descriptor, current=nil)
-            # def updateApplicationWithoutRestart(descriptor, current=nil)
-            # def removeApplication(name, current=nil)
-            # def instantiateServer(application, node, desc, current=nil)
-            # def patchApplication(name, shutdown, current=nil)
-            # def getApplicationInfo(name, current=nil)
-            # def getDefaultApplicationDescriptor(current=nil)
-            # def getAllApplicationNames(current=nil)
-            # def getServerInfo(id, current=nil)
-            # def getServerState(id, current=nil)
-            # def getServerPid(id, current=nil)
-            # def getServerAdminCategory(current=nil)
-            # def getServerAdmin(id, current=nil)
-            # def enableServer(id, enabled, current=nil)
-            # def isServerEnabled(id, current=nil)
-            # def startServer(id, current=nil)
-            # def stopServer(id, current=nil)
-            # def patchServer(id, shutdown, current=nil)
-            # def sendSignal(id, signal, current=nil)
-            # def getAllServerIds(current=nil)
-            # def getAdapterInfo(id, current=nil)
-            # def removeAdapter(id, current=nil)
-            # def getAllAdapterIds(current=nil)
-            # def addObject(obj, current=nil)
-            # def updateObject(obj, current=nil)
-            # def addObjectWithType(obj, type, current=nil)
-            # def removeObject(id, current=nil)
-            # def getObjectInfo(id, current=nil)
-            # def getObjectInfosByType(type, current=nil)
-            # def getAllObjectInfos(expr, current=nil)
-            # def pingNode(name, current=nil)
-            # def getNodeLoad(name, current=nil)
-            # def getNodeInfo(name, current=nil)
-            # def getNodeAdmin(name, current=nil)
-            # def getNodeProcessorSocketCount(name, current=nil)
-            # def shutdownNode(name, current=nil)
-            # def getNodeHostname(name, current=nil)
-            # def getAllNodeNames(current=nil)
-            # def pingRegistry(name, current=nil)
-            # def getRegistryInfo(name, current=nil)
-            # def getRegistryAdmin(name, current=nil)
-            # def shutdownRegistry(name, current=nil)
-            # def getAllRegistryNames(current=nil)
-            # def shutdown(current=nil)
-            # def getSliceChecksums(current=nil)
-
-            def inspect
-                ::Ice::__stringify(self, T_Admin)
-            end
-        end
-        class Admin
-            include Admin_mixin
-            
-            def Admin.ice_staticId()
-                '::IceGrid::Admin'
-            end
+    if not defined?(::IceGrid::Admin_Mixin)
+
+        module ::IceGrid::Admin_Mixin
         end
         module AdminPrx_mixin
 
-            def addApplication(descriptor, _ctx=nil)
-                Admin_mixin::OP_addApplication.invoke(self, [descriptor], _ctx)
+            def addApplication(descriptor, context=nil)
+                AdminPrx_mixin::OP_addApplication.invoke(self, [descriptor], context)
             end
 
-            def syncApplication(descriptor, _ctx=nil)
-                Admin_mixin::OP_syncApplication.invoke(self, [descriptor], _ctx)
+            def syncApplication(descriptor, context=nil)
+                AdminPrx_mixin::OP_syncApplication.invoke(self, [descriptor], context)
             end
 
-            def updateApplication(descriptor, _ctx=nil)
-                Admin_mixin::OP_updateApplication.invoke(self, [descriptor], _ctx)
+            def updateApplication(descriptor, context=nil)
+                AdminPrx_mixin::OP_updateApplication.invoke(self, [descriptor], context)
             end
 
-            def syncApplicationWithoutRestart(descriptor, _ctx=nil)
-                Admin_mixin::OP_syncApplicationWithoutRestart.invoke(self, [descriptor], _ctx)
+            def syncApplicationWithoutRestart(descriptor, context=nil)
+                AdminPrx_mixin::OP_syncApplicationWithoutRestart.invoke(self, [descriptor], context)
             end
 
-            def updateApplicationWithoutRestart(descriptor, _ctx=nil)
-                Admin_mixin::OP_updateApplicationWithoutRestart.invoke(self, [descriptor], _ctx)
+            def updateApplicationWithoutRestart(descriptor, context=nil)
+                AdminPrx_mixin::OP_updateApplicationWithoutRestart.invoke(self, [descriptor], context)
             end
 
-            def removeApplication(name, _ctx=nil)
-                Admin_mixin::OP_removeApplication.invoke(self, [name], _ctx)
+            def removeApplication(name, context=nil)
+                AdminPrx_mixin::OP_removeApplication.invoke(self, [name], context)
             end
 
-            def instantiateServer(application, node, desc, _ctx=nil)
-                Admin_mixin::OP_instantiateServer.invoke(self, [application, node, desc], _ctx)
+            def instantiateServer(application, node, desc, context=nil)
+                AdminPrx_mixin::OP_instantiateServer.invoke(self, [application, node, desc], context)
             end
 
-            def patchApplication(name, shutdown, _ctx=nil)
-                Admin_mixin::OP_patchApplication.invoke(self, [name, shutdown], _ctx)
+            def patchApplication(name, shutdown, context=nil)
+                AdminPrx_mixin::OP_patchApplication.invoke(self, [name, shutdown], context)
             end
 
-            def getApplicationInfo(name, _ctx=nil)
-                Admin_mixin::OP_getApplicationInfo.invoke(self, [name], _ctx)
+            def getApplicationInfo(name, context=nil)
+                AdminPrx_mixin::OP_getApplicationInfo.invoke(self, [name], context)
             end
 
-            def getDefaultApplicationDescriptor(_ctx=nil)
-                Admin_mixin::OP_getDefaultApplicationDescriptor.invoke(self, [], _ctx)
+            def getDefaultApplicationDescriptor(context=nil)
+                AdminPrx_mixin::OP_getDefaultApplicationDescriptor.invoke(self, [], context)
             end
 
-            def getAllApplicationNames(_ctx=nil)
-                Admin_mixin::OP_getAllApplicationNames.invoke(self, [], _ctx)
+            def getAllApplicationNames(context=nil)
+                AdminPrx_mixin::OP_getAllApplicationNames.invoke(self, [], context)
             end
 
-            def getServerInfo(id, _ctx=nil)
-                Admin_mixin::OP_getServerInfo.invoke(self, [id], _ctx)
+            def getServerInfo(id, context=nil)
+                AdminPrx_mixin::OP_getServerInfo.invoke(self, [id], context)
             end
 
-            def getServerState(id, _ctx=nil)
-                Admin_mixin::OP_getServerState.invoke(self, [id], _ctx)
+            def getServerState(id, context=nil)
+                AdminPrx_mixin::OP_getServerState.invoke(self, [id], context)
             end
 
-            def getServerPid(id, _ctx=nil)
-                Admin_mixin::OP_getServerPid.invoke(self, [id], _ctx)
+            def getServerPid(id, context=nil)
+                AdminPrx_mixin::OP_getServerPid.invoke(self, [id], context)
             end
 
-            def getServerAdminCategory(_ctx=nil)
-                Admin_mixin::OP_getServerAdminCategory.invoke(self, [], _ctx)
+            def getServerAdminCategory(context=nil)
+                AdminPrx_mixin::OP_getServerAdminCategory.invoke(self, [], context)
             end
 
-            def getServerAdmin(id, _ctx=nil)
-                Admin_mixin::OP_getServerAdmin.invoke(self, [id], _ctx)
+            def getServerAdmin(id, context=nil)
+                AdminPrx_mixin::OP_getServerAdmin.invoke(self, [id], context)
             end
 
-            def enableServer(id, enabled, _ctx=nil)
-                Admin_mixin::OP_enableServer.invoke(self, [id, enabled], _ctx)
+            def enableServer(id, enabled, context=nil)
+                AdminPrx_mixin::OP_enableServer.invoke(self, [id, enabled], context)
             end
 
-            def isServerEnabled(id, _ctx=nil)
-                Admin_mixin::OP_isServerEnabled.invoke(self, [id], _ctx)
+            def isServerEnabled(id, context=nil)
+                AdminPrx_mixin::OP_isServerEnabled.invoke(self, [id], context)
             end
 
-            def startServer(id, _ctx=nil)
-                Admin_mixin::OP_startServer.invoke(self, [id], _ctx)
+            def startServer(id, context=nil)
+                AdminPrx_mixin::OP_startServer.invoke(self, [id], context)
             end
 
-            def stopServer(id, _ctx=nil)
-                Admin_mixin::OP_stopServer.invoke(self, [id], _ctx)
+            def stopServer(id, context=nil)
+                AdminPrx_mixin::OP_stopServer.invoke(self, [id], context)
             end
 
-            def patchServer(id, shutdown, _ctx=nil)
-                Admin_mixin::OP_patchServer.invoke(self, [id, shutdown], _ctx)
+            def patchServer(id, shutdown, context=nil)
+                AdminPrx_mixin::OP_patchServer.invoke(self, [id, shutdown], context)
             end
 
-            def sendSignal(id, signal, _ctx=nil)
-                Admin_mixin::OP_sendSignal.invoke(self, [id, signal], _ctx)
+            def sendSignal(id, signal, context=nil)
+                AdminPrx_mixin::OP_sendSignal.invoke(self, [id, signal], context)
             end
 
-            def getAllServerIds(_ctx=nil)
-                Admin_mixin::OP_getAllServerIds.invoke(self, [], _ctx)
+            def getAllServerIds(context=nil)
+                AdminPrx_mixin::OP_getAllServerIds.invoke(self, [], context)
             end
 
-            def getAdapterInfo(id, _ctx=nil)
-                Admin_mixin::OP_getAdapterInfo.invoke(self, [id], _ctx)
+            def getAdapterInfo(id, context=nil)
+                AdminPrx_mixin::OP_getAdapterInfo.invoke(self, [id], context)
             end
 
-            def removeAdapter(id, _ctx=nil)
-                Admin_mixin::OP_removeAdapter.invoke(self, [id], _ctx)
+            def removeAdapter(id, context=nil)
+                AdminPrx_mixin::OP_removeAdapter.invoke(self, [id], context)
             end
 
-            def getAllAdapterIds(_ctx=nil)
-                Admin_mixin::OP_getAllAdapterIds.invoke(self, [], _ctx)
+            def getAllAdapterIds(context=nil)
+                AdminPrx_mixin::OP_getAllAdapterIds.invoke(self, [], context)
             end
 
-            def addObject(obj, _ctx=nil)
-                Admin_mixin::OP_addObject.invoke(self, [obj], _ctx)
+            def addObject(obj, context=nil)
+                AdminPrx_mixin::OP_addObject.invoke(self, [obj], context)
             end
 
-            def updateObject(obj, _ctx=nil)
-                Admin_mixin::OP_updateObject.invoke(self, [obj], _ctx)
+            def updateObject(obj, context=nil)
+                AdminPrx_mixin::OP_updateObject.invoke(self, [obj], context)
             end
 
-            def addObjectWithType(obj, type, _ctx=nil)
-                Admin_mixin::OP_addObjectWithType.invoke(self, [obj, type], _ctx)
+            def addObjectWithType(obj, type, context=nil)
+                AdminPrx_mixin::OP_addObjectWithType.invoke(self, [obj, type], context)
             end
 
-            def removeObject(id, _ctx=nil)
-                Admin_mixin::OP_removeObject.invoke(self, [id], _ctx)
+            def removeObject(id, context=nil)
+                AdminPrx_mixin::OP_removeObject.invoke(self, [id], context)
             end
 
-            def getObjectInfo(id, _ctx=nil)
-                Admin_mixin::OP_getObjectInfo.invoke(self, [id], _ctx)
+            def getObjectInfo(id, context=nil)
+                AdminPrx_mixin::OP_getObjectInfo.invoke(self, [id], context)
             end
 
-            def getObjectInfosByType(type, _ctx=nil)
-                Admin_mixin::OP_getObjectInfosByType.invoke(self, [type], _ctx)
+            def getObjectInfosByType(type, context=nil)
+                AdminPrx_mixin::OP_getObjectInfosByType.invoke(self, [type], context)
             end
 
-            def getAllObjectInfos(expr, _ctx=nil)
-                Admin_mixin::OP_getAllObjectInfos.invoke(self, [expr], _ctx)
+            def getAllObjectInfos(expr, context=nil)
+                AdminPrx_mixin::OP_getAllObjectInfos.invoke(self, [expr], context)
             end
 
-            def pingNode(name, _ctx=nil)
-                Admin_mixin::OP_pingNode.invoke(self, [name], _ctx)
+            def pingNode(name, context=nil)
+                AdminPrx_mixin::OP_pingNode.invoke(self, [name], context)
             end
 
-            def getNodeLoad(name, _ctx=nil)
-                Admin_mixin::OP_getNodeLoad.invoke(self, [name], _ctx)
+            def getNodeLoad(name, context=nil)
+                AdminPrx_mixin::OP_getNodeLoad.invoke(self, [name], context)
             end
 
-            def getNodeInfo(name, _ctx=nil)
-                Admin_mixin::OP_getNodeInfo.invoke(self, [name], _ctx)
+            def getNodeInfo(name, context=nil)
+                AdminPrx_mixin::OP_getNodeInfo.invoke(self, [name], context)
             end
 
-            def getNodeAdmin(name, _ctx=nil)
-                Admin_mixin::OP_getNodeAdmin.invoke(self, [name], _ctx)
+            def getNodeAdmin(name, context=nil)
+                AdminPrx_mixin::OP_getNodeAdmin.invoke(self, [name], context)
             end
 
-            def getNodeProcessorSocketCount(name, _ctx=nil)
-                Admin_mixin::OP_getNodeProcessorSocketCount.invoke(self, [name], _ctx)
+            def getNodeProcessorSocketCount(name, context=nil)
+                AdminPrx_mixin::OP_getNodeProcessorSocketCount.invoke(self, [name], context)
             end
 
-            def shutdownNode(name, _ctx=nil)
-                Admin_mixin::OP_shutdownNode.invoke(self, [name], _ctx)
+            def shutdownNode(name, context=nil)
+                AdminPrx_mixin::OP_shutdownNode.invoke(self, [name], context)
             end
 
-            def getNodeHostname(name, _ctx=nil)
-                Admin_mixin::OP_getNodeHostname.invoke(self, [name], _ctx)
+            def getNodeHostname(name, context=nil)
+                AdminPrx_mixin::OP_getNodeHostname.invoke(self, [name], context)
             end
 
-            def getAllNodeNames(_ctx=nil)
-                Admin_mixin::OP_getAllNodeNames.invoke(self, [], _ctx)
+            def getAllNodeNames(context=nil)
+                AdminPrx_mixin::OP_getAllNodeNames.invoke(self, [], context)
             end
 
-            def pingRegistry(name, _ctx=nil)
-                Admin_mixin::OP_pingRegistry.invoke(self, [name], _ctx)
+            def pingRegistry(name, context=nil)
+                AdminPrx_mixin::OP_pingRegistry.invoke(self, [name], context)
             end
 
-            def getRegistryInfo(name, _ctx=nil)
-                Admin_mixin::OP_getRegistryInfo.invoke(self, [name], _ctx)
+            def getRegistryInfo(name, context=nil)
+                AdminPrx_mixin::OP_getRegistryInfo.invoke(self, [name], context)
             end
 
-            def getRegistryAdmin(name, _ctx=nil)
-                Admin_mixin::OP_getRegistryAdmin.invoke(self, [name], _ctx)
+            def getRegistryAdmin(name, context=nil)
+                AdminPrx_mixin::OP_getRegistryAdmin.invoke(self, [name], context)
             end
 
-            def shutdownRegistry(name, _ctx=nil)
-                Admin_mixin::OP_shutdownRegistry.invoke(self, [name], _ctx)
+            def shutdownRegistry(name, context=nil)
+                AdminPrx_mixin::OP_shutdownRegistry.invoke(self, [name], context)
             end
 
-            def getAllRegistryNames(_ctx=nil)
-                Admin_mixin::OP_getAllRegistryNames.invoke(self, [], _ctx)
+            def getAllRegistryNames(context=nil)
+                AdminPrx_mixin::OP_getAllRegistryNames.invoke(self, [], context)
             end
 
-            def shutdown(_ctx=nil)
-                Admin_mixin::OP_shutdown.invoke(self, [], _ctx)
+            def shutdown(context=nil)
+                AdminPrx_mixin::OP_shutdown.invoke(self, [], context)
             end
 
-            def getSliceChecksums(_ctx=nil)
-                Admin_mixin::OP_getSliceChecksums.invoke(self, [], _ctx)
+            def getSliceChecksums(context=nil)
+                AdminPrx_mixin::OP_getSliceChecksums.invoke(self, [], context)
             end
         end
+
         class AdminPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
             include AdminPrx_mixin
+        end
 
-            def AdminPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::Admin', facetOrCtx, _ctx)
-            end
+        if not defined?(::IceGrid::T_AdminPrx)
+            T_Admin = ::Ice::__declareClass('::IceGrid::Admin')
+            T_AdminPrx = ::Ice::__declareProxy('::IceGrid::Admin')
+        end
+
+        T_Admin.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_AdminPrx.defineProxy(AdminPrx, nil, [])
+
+        AdminPrx_mixin::OP_addApplication = ::Ice::__defineOperation('addApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_syncApplication = ::Ice::__defineOperation('syncApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
+        AdminPrx_mixin::OP_updateApplication = ::Ice::__defineOperation('updateApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationUpdateDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
+        AdminPrx_mixin::OP_syncApplicationWithoutRestart = ::Ice::__defineOperation('syncApplicationWithoutRestart', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
+        AdminPrx_mixin::OP_updateApplicationWithoutRestart = ::Ice::__defineOperation('updateApplicationWithoutRestart', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationUpdateDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
+        AdminPrx_mixin::OP_removeApplication = ::Ice::__defineOperation('removeApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
+        AdminPrx_mixin::OP_instantiateServer = ::Ice::__defineOperation('instantiateServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::IceGrid::T_ServerInstanceDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_ApplicationNotExistException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_patchApplication = ::Ice::__defineOperation('patchApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0], [::Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ApplicationNotExistException, ::IceGrid::T_PatchException])
+        AdminPrx_mixin::OP_getApplicationInfo = ::Ice::__defineOperation('getApplicationInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ApplicationInfo, false, 0], [::IceGrid::T_ApplicationNotExistException])
+        AdminPrx_mixin::OP_getDefaultApplicationDescriptor = ::Ice::__defineOperation('getDefaultApplicationDescriptor', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::IceGrid::T_ApplicationDescriptor, false, 0], [::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_getAllApplicationNames = ::Ice::__defineOperation('getAllApplicationNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
+        AdminPrx_mixin::OP_getServerInfo = ::Ice::__defineOperation('getServerInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ServerInfo, false, 0], [::IceGrid::T_ServerNotExistException])
+        AdminPrx_mixin::OP_getServerState = ::Ice::__defineOperation('getServerState', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ServerState, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_getServerPid = ::Ice::__defineOperation('getServerPid', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_int, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_getServerAdminCategory = ::Ice::__defineOperation('getServerAdminCategory', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_string, false, 0], [])
+        AdminPrx_mixin::OP_getServerAdmin = ::Ice::__defineOperation('getServerAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_ObjectPrx, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_enableServer = ::Ice::__defineOperation('enableServer', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_isServerEnabled = ::Ice::__defineOperation('isServerEnabled', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_startServer = ::Ice::__defineOperation('startServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_ServerStartException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_stopServer = ::Ice::__defineOperation('stopServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_ServerStopException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_patchServer = ::Ice::__defineOperation('patchServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0], [::Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException, ::IceGrid::T_PatchException])
+        AdminPrx_mixin::OP_sendSignal = ::Ice::__defineOperation('sendSignal', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException, ::IceGrid::T_BadSignalException])
+        AdminPrx_mixin::OP_getAllServerIds = ::Ice::__defineOperation('getAllServerIds', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
+        AdminPrx_mixin::OP_getAdapterInfo = ::Ice::__defineOperation('getAdapterInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_AdapterInfoSeq, false, 0], [::IceGrid::T_AdapterNotExistException])
+        AdminPrx_mixin::OP_removeAdapter = ::Ice::__defineOperation('removeAdapter', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AdapterNotExistException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_getAllAdapterIds = ::Ice::__defineOperation('getAllAdapterIds', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
+        AdminPrx_mixin::OP_addObject = ::Ice::__defineOperation('addObject', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_updateObject = ::Ice::__defineOperation('updateObject', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_addObjectWithType = ::Ice::__defineOperation('addObjectWithType', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_ObjectPrx, false, 0], [::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_removeObject = ::Ice::__defineOperation('removeObject', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_Identity, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException])
+        AdminPrx_mixin::OP_getObjectInfo = ::Ice::__defineOperation('getObjectInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_Identity, false, 0]], [], [::IceGrid::T_ObjectInfo, false, 0], [::IceGrid::T_ObjectNotRegisteredException])
+        AdminPrx_mixin::OP_getObjectInfosByType = ::Ice::__defineOperation('getObjectInfosByType', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [])
+        AdminPrx_mixin::OP_getAllObjectInfos = ::Ice::__defineOperation('getAllObjectInfos', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [])
+        AdminPrx_mixin::OP_pingNode = ::Ice::__defineOperation('pingNode', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [::IceGrid::T_NodeNotExistException])
+        AdminPrx_mixin::OP_getNodeLoad = ::Ice::__defineOperation('getNodeLoad', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_LoadInfo, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminPrx_mixin::OP_getNodeInfo = ::Ice::__defineOperation('getNodeInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_NodeInfo, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminPrx_mixin::OP_getNodeAdmin = ::Ice::__defineOperation('getNodeAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_ObjectPrx, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminPrx_mixin::OP_getNodeProcessorSocketCount = ::Ice::__defineOperation('getNodeProcessorSocketCount', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_int, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminPrx_mixin::OP_shutdownNode = ::Ice::__defineOperation('shutdownNode', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminPrx_mixin::OP_getNodeHostname = ::Ice::__defineOperation('getNodeHostname', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_string, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminPrx_mixin::OP_getAllNodeNames = ::Ice::__defineOperation('getAllNodeNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
+        AdminPrx_mixin::OP_pingRegistry = ::Ice::__defineOperation('pingRegistry', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [::IceGrid::T_RegistryNotExistException])
+        AdminPrx_mixin::OP_getRegistryInfo = ::Ice::__defineOperation('getRegistryInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_RegistryInfo, false, 0], [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
+        AdminPrx_mixin::OP_getRegistryAdmin = ::Ice::__defineOperation('getRegistryAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_ObjectPrx, false, 0], [::IceGrid::T_RegistryNotExistException])
+        AdminPrx_mixin::OP_shutdownRegistry = ::Ice::__defineOperation('shutdownRegistry', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
+        AdminPrx_mixin::OP_getAllRegistryNames = ::Ice::__defineOperation('getAllRegistryNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
+        AdminPrx_mixin::OP_shutdown = ::Ice::__defineOperation('shutdown', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [])
+        AdminPrx_mixin::OP_getSliceChecksums = ::Ice::__defineOperation('getSliceChecksums', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_SliceChecksumDict, false, 0], [])
+    end
 
-            def AdminPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
+    if not defined?(::IceGrid::FileIterator_Mixin)
+
+        module ::IceGrid::FileIterator_Mixin
+        end
+        module FileIteratorPrx_mixin
+
+            def read(size, context=nil)
+                FileIteratorPrx_mixin::OP_read.invoke(self, [size], context)
             end
-            def AdminPrx.ice_staticId()
-                '::IceGrid::Admin'
+
+            def destroy(context=nil)
+                FileIteratorPrx_mixin::OP_destroy.invoke(self, [], context)
             end
         end
 
-        if not defined?(::IceGrid::T_Admin)
-            T_Admin = ::Ice::__declareClass('::IceGrid::Admin')
-            T_AdminPrx = ::Ice::__declareProxy('::IceGrid::Admin')
+        class FileIteratorPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
+            include FileIteratorPrx_mixin
         end
 
-        T_Admin.defineClass(Admin, -1, true, false, nil, [], [])
-        Admin_mixin::ICE_TYPE = T_Admin
-
-        T_AdminPrx.defineProxy(AdminPrx, T_Admin)
-        AdminPrx::ICE_TYPE = T_AdminPrx
-
-        Admin_mixin::OP_addApplication = ::Ice::__defineOperation('addApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_syncApplication = ::Ice::__defineOperation('syncApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
-        Admin_mixin::OP_updateApplication = ::Ice::__defineOperation('updateApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationUpdateDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
-        Admin_mixin::OP_syncApplicationWithoutRestart = ::Ice::__defineOperation('syncApplicationWithoutRestart', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
-        Admin_mixin::OP_updateApplicationWithoutRestart = ::Ice::__defineOperation('updateApplicationWithoutRestart', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ApplicationUpdateDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
-        Admin_mixin::OP_removeApplication = ::Ice::__defineOperation('removeApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException])
-        Admin_mixin::OP_instantiateServer = ::Ice::__defineOperation('instantiateServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::IceGrid::T_ServerInstanceDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_ApplicationNotExistException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_patchApplication = ::Ice::__defineOperation('patchApplication', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0], [::Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ApplicationNotExistException, ::IceGrid::T_PatchException])
-        Admin_mixin::OP_getApplicationInfo = ::Ice::__defineOperation('getApplicationInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ApplicationInfo, false, 0], [::IceGrid::T_ApplicationNotExistException])
-        Admin_mixin::OP_getDefaultApplicationDescriptor = ::Ice::__defineOperation('getDefaultApplicationDescriptor', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::IceGrid::T_ApplicationDescriptor, false, 0], [::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_getAllApplicationNames = ::Ice::__defineOperation('getAllApplicationNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
-        Admin_mixin::OP_getServerInfo = ::Ice::__defineOperation('getServerInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ServerInfo, false, 0], [::IceGrid::T_ServerNotExistException])
-        Admin_mixin::OP_getServerState = ::Ice::__defineOperation('getServerState', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ServerState, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_getServerPid = ::Ice::__defineOperation('getServerPid', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_int, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_getServerAdminCategory = ::Ice::__defineOperation('getServerAdminCategory', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_string, false, 0], [])
-        Admin_mixin::OP_getServerAdmin = ::Ice::__defineOperation('getServerAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_ObjectPrx, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_enableServer = ::Ice::__defineOperation('enableServer', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_isServerEnabled = ::Ice::__defineOperation('isServerEnabled', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_startServer = ::Ice::__defineOperation('startServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_ServerStartException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_stopServer = ::Ice::__defineOperation('stopServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_ServerStopException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_patchServer = ::Ice::__defineOperation('patchServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [[::Ice::T_string, false, 0], [::Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException, ::IceGrid::T_PatchException])
-        Admin_mixin::OP_sendSignal = ::Ice::__defineOperation('sendSignal', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException, ::IceGrid::T_BadSignalException])
-        Admin_mixin::OP_getAllServerIds = ::Ice::__defineOperation('getAllServerIds', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
-        Admin_mixin::OP_getAdapterInfo = ::Ice::__defineOperation('getAdapterInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_AdapterInfoSeq, false, 0], [::IceGrid::T_AdapterNotExistException])
-        Admin_mixin::OP_removeAdapter = ::Ice::__defineOperation('removeAdapter', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AdapterNotExistException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_getAllAdapterIds = ::Ice::__defineOperation('getAllAdapterIds', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
-        Admin_mixin::OP_addObject = ::Ice::__defineOperation('addObject', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_updateObject = ::Ice::__defineOperation('updateObject', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_addObjectWithType = ::Ice::__defineOperation('addObjectWithType', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_ObjectPrx, false, 0], [::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_removeObject = ::Ice::__defineOperation('removeObject', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_Identity, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException])
-        Admin_mixin::OP_getObjectInfo = ::Ice::__defineOperation('getObjectInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_Identity, false, 0]], [], [::IceGrid::T_ObjectInfo, false, 0], [::IceGrid::T_ObjectNotRegisteredException])
-        Admin_mixin::OP_getObjectInfosByType = ::Ice::__defineOperation('getObjectInfosByType', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [])
-        Admin_mixin::OP_getAllObjectInfos = ::Ice::__defineOperation('getAllObjectInfos', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [])
-        Admin_mixin::OP_pingNode = ::Ice::__defineOperation('pingNode', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [::IceGrid::T_NodeNotExistException])
-        Admin_mixin::OP_getNodeLoad = ::Ice::__defineOperation('getNodeLoad', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_LoadInfo, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        Admin_mixin::OP_getNodeInfo = ::Ice::__defineOperation('getNodeInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_NodeInfo, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        Admin_mixin::OP_getNodeAdmin = ::Ice::__defineOperation('getNodeAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_ObjectPrx, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        Admin_mixin::OP_getNodeProcessorSocketCount = ::Ice::__defineOperation('getNodeProcessorSocketCount', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_int, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        Admin_mixin::OP_shutdownNode = ::Ice::__defineOperation('shutdownNode', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        Admin_mixin::OP_getNodeHostname = ::Ice::__defineOperation('getNodeHostname', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_string, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        Admin_mixin::OP_getAllNodeNames = ::Ice::__defineOperation('getAllNodeNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
-        Admin_mixin::OP_pingRegistry = ::Ice::__defineOperation('pingRegistry', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [::IceGrid::T_RegistryNotExistException])
-        Admin_mixin::OP_getRegistryInfo = ::Ice::__defineOperation('getRegistryInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::IceGrid::T_RegistryInfo, false, 0], [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
-        Admin_mixin::OP_getRegistryAdmin = ::Ice::__defineOperation('getRegistryAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_ObjectPrx, false, 0], [::IceGrid::T_RegistryNotExistException])
-        Admin_mixin::OP_shutdownRegistry = ::Ice::__defineOperation('shutdownRegistry', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_string, false, 0]], [], nil, [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
-        Admin_mixin::OP_getAllRegistryNames = ::Ice::__defineOperation('getAllRegistryNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
-        Admin_mixin::OP_shutdown = ::Ice::__defineOperation('shutdown', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [])
-        Admin_mixin::OP_getSliceChecksums = ::Ice::__defineOperation('getSliceChecksums', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_SliceChecksumDict, false, 0], [])
-    end
+        if not defined?(::IceGrid::T_FileIteratorPrx)
+            T_FileIterator = ::Ice::__declareClass('::IceGrid::FileIterator')
+            T_FileIteratorPrx = ::Ice::__declareProxy('::IceGrid::FileIterator')
+        end
+
+        T_FileIterator.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_FileIteratorPrx.defineProxy(FileIteratorPrx, nil, [])
 
-    if not defined?(::IceGrid::FileIterator_mixin)
-        module FileIterator_mixin
-            include ::Ice::Object_mixin
+        FileIteratorPrx_mixin::OP_read = ::Ice::__defineOperation('read', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0]], [[::Ice::T_StringSeq, false, 0]], [::Ice::T_bool, false, 0], [::IceGrid::T_FileNotAvailableException])
+        FileIteratorPrx_mixin::OP_destroy = ::Ice::__defineOperation('destroy', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [])
+    end
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::FileIterator']
+    if not defined?(::IceGrid::ServerDynamicInfo)
+        class ServerDynamicInfo
+            include ::Ice::Inspect_mixin
+            def initialize(id='', state=::IceGrid::ServerState::Inactive, pid=0, enabled=false)
+                @id = id
+                @state = state
+                @pid = pid
+                @enabled = enabled
             end
 
-            def ice_id(current=nil)
-                '::IceGrid::FileIterator'
+            def hash
+                _h = 0
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @state.hash
+                _h = 5 * _h + @pid.hash
+                _h = 5 * _h + @enabled.hash
+                _h % 0x7fffffff
             end
 
-            #
-            # Operation signatures.
-            #
-            # def read(size, current=nil)
-            # def destroy(current=nil)
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ServerDynamicInfo or
+                    @id != other.id or
+                    @state != other.state or
+                    @pid != other.pid or
+                    @enabled != other.enabled
+                true
+            end
 
-            def inspect
-                ::Ice::__stringify(self, T_FileIterator)
+            def eql?(other)
+                return other.class == self.class && other == self
             end
+
+            attr_accessor :id, :state, :pid, :enabled
         end
-        class FileIterator
-            include FileIterator_mixin
-            
-            def FileIterator.ice_staticId()
-                '::IceGrid::FileIterator'
+
+        T_ServerDynamicInfo = ::Ice::__defineStruct('::IceGrid::ServerDynamicInfo', ServerDynamicInfo, [
+            ["id", ::Ice::T_string],
+            ["state", ::IceGrid::T_ServerState],
+            ["pid", ::Ice::T_int],
+            ["enabled", ::Ice::T_bool]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServerDynamicInfoSeq)
+        T_ServerDynamicInfoSeq = ::Ice::__defineSequence('::IceGrid::ServerDynamicInfoSeq', ::IceGrid::T_ServerDynamicInfo)
+    end
+
+    if not defined?(::IceGrid::AdapterDynamicInfo)
+        class AdapterDynamicInfo
+            include ::Ice::Inspect_mixin
+            def initialize(id='', proxy=nil)
+                @id = id
+                @proxy = proxy
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @proxy.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::AdapterDynamicInfo or
+                    @id != other.id or
+                    @proxy != other.proxy
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
             end
+
+            attr_accessor :id, :proxy
         end
-        module FileIteratorPrx_mixin
 
-            def read(size, _ctx=nil)
-                FileIterator_mixin::OP_read.invoke(self, [size], _ctx)
+        T_AdapterDynamicInfo = ::Ice::__defineStruct('::IceGrid::AdapterDynamicInfo', AdapterDynamicInfo, [
+            ["id", ::Ice::T_string],
+            ["proxy", ::Ice::T_ObjectPrx]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_AdapterDynamicInfoSeq)
+        T_AdapterDynamicInfoSeq = ::Ice::__defineSequence('::IceGrid::AdapterDynamicInfoSeq', ::IceGrid::T_AdapterDynamicInfo)
+    end
+
+    if not defined?(::IceGrid::NodeDynamicInfo)
+        class NodeDynamicInfo
+            include ::Ice::Inspect_mixin
+            def initialize(info=::IceGrid::NodeInfo.new, servers=nil, adapters=nil)
+                @info = info
+                @servers = servers
+                @adapters = adapters
             end
 
-            def destroy(_ctx=nil)
-                FileIterator_mixin::OP_destroy.invoke(self, [], _ctx)
+            def hash
+                _h = 0
+                _h = 5 * _h + @info.hash
+                _h = 5 * _h + @servers.hash
+                _h = 5 * _h + @adapters.hash
+                _h % 0x7fffffff
             end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::NodeDynamicInfo or
+                    @info != other.info or
+                    @servers != other.servers or
+                    @adapters != other.adapters
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :info, :servers, :adapters
         end
-        class FileIteratorPrx < ::Ice::ObjectPrx
-            include FileIteratorPrx_mixin
 
-            def FileIteratorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::FileIterator', facetOrCtx, _ctx)
+        T_NodeDynamicInfo = ::Ice::__defineStruct('::IceGrid::NodeDynamicInfo', NodeDynamicInfo, [
+            ["info", ::IceGrid::T_NodeInfo],
+            ["servers", ::IceGrid::T_ServerDynamicInfoSeq],
+            ["adapters", ::IceGrid::T_AdapterDynamicInfoSeq]
+        ])
+    end
+
+    if not defined?(::IceGrid::RegistryObserver_Mixin)
+
+        module ::IceGrid::RegistryObserver_Mixin
+        end
+        module RegistryObserverPrx_mixin
+
+            def registryInit(registries, context=nil)
+                RegistryObserverPrx_mixin::OP_registryInit.invoke(self, [registries], context)
             end
 
-            def FileIteratorPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
+            def registryUp(node, context=nil)
+                RegistryObserverPrx_mixin::OP_registryUp.invoke(self, [node], context)
             end
-            def FileIteratorPrx.ice_staticId()
-                '::IceGrid::FileIterator'
+
+            def registryDown(name, context=nil)
+                RegistryObserverPrx_mixin::OP_registryDown.invoke(self, [name], context)
             end
         end
 
-        if not defined?(::IceGrid::T_FileIterator)
-            T_FileIterator = ::Ice::__declareClass('::IceGrid::FileIterator')
-            T_FileIteratorPrx = ::Ice::__declareProxy('::IceGrid::FileIterator')
+        class RegistryObserverPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
+            include RegistryObserverPrx_mixin
         end
 
-        T_FileIterator.defineClass(FileIterator, -1, true, false, nil, [], [])
-        FileIterator_mixin::ICE_TYPE = T_FileIterator
+        if not defined?(::IceGrid::T_RegistryObserverPrx)
+            T_RegistryObserver = ::Ice::__declareClass('::IceGrid::RegistryObserver')
+            T_RegistryObserverPrx = ::Ice::__declareProxy('::IceGrid::RegistryObserver')
+        end
 
-        T_FileIteratorPrx.defineProxy(FileIteratorPrx, T_FileIterator)
-        FileIteratorPrx::ICE_TYPE = T_FileIteratorPrx
+        T_RegistryObserver.defineClass(::Ice::Value, -1, false, true, nil, [])
 
-        FileIterator_mixin::OP_read = ::Ice::__defineOperation('read', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0]], [[::Ice::T_StringSeq, false, 0]], [::Ice::T_bool, false, 0], [::IceGrid::T_FileNotAvailableException])
-        FileIterator_mixin::OP_destroy = ::Ice::__defineOperation('destroy', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [])
-    end
+        T_RegistryObserverPrx.defineProxy(RegistryObserverPrx, nil, [])
 
-    if not defined?(::IceGrid::T_RegistryObserver)
-        T_RegistryObserver = ::Ice::__declareClass('::IceGrid::RegistryObserver')
-        T_RegistryObserverPrx = ::Ice::__declareProxy('::IceGrid::RegistryObserver')
+        RegistryObserverPrx_mixin::OP_registryInit = ::Ice::__defineOperation('registryInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_RegistryInfoSeq, false, 0]], [], nil, [])
+        RegistryObserverPrx_mixin::OP_registryUp = ::Ice::__defineOperation('registryUp', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_RegistryInfo, false, 0]], [], nil, [])
+        RegistryObserverPrx_mixin::OP_registryDown = ::Ice::__defineOperation('registryDown', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [])
     end
 
-    if not defined?(::IceGrid::T_NodeObserver)
-        T_NodeObserver = ::Ice::__declareClass('::IceGrid::NodeObserver')
-        T_NodeObserverPrx = ::Ice::__declareProxy('::IceGrid::NodeObserver')
+    if not defined?(::IceGrid::T_NodeDynamicInfoSeq)
+        T_NodeDynamicInfoSeq = ::Ice::__defineSequence('::IceGrid::NodeDynamicInfoSeq', ::IceGrid::T_NodeDynamicInfo)
     end
 
-    if not defined?(::IceGrid::T_ApplicationObserver)
-        T_ApplicationObserver = ::Ice::__declareClass('::IceGrid::ApplicationObserver')
-        T_ApplicationObserverPrx = ::Ice::__declareProxy('::IceGrid::ApplicationObserver')
-    end
+    if not defined?(::IceGrid::NodeObserver_Mixin)
+
+        module ::IceGrid::NodeObserver_Mixin
+        end
+        module NodeObserverPrx_mixin
+
+            def nodeInit(nodes, context=nil)
+                NodeObserverPrx_mixin::OP_nodeInit.invoke(self, [nodes], context)
+            end
+
+            def nodeUp(node, context=nil)
+                NodeObserverPrx_mixin::OP_nodeUp.invoke(self, [node], context)
+            end
+
+            def nodeDown(name, context=nil)
+                NodeObserverPrx_mixin::OP_nodeDown.invoke(self, [name], context)
+            end
+
+            def updateServer(node, updatedInfo, context=nil)
+                NodeObserverPrx_mixin::OP_updateServer.invoke(self, [node, updatedInfo], context)
+            end
+
+            def updateAdapter(node, updatedInfo, context=nil)
+                NodeObserverPrx_mixin::OP_updateAdapter.invoke(self, [node, updatedInfo], context)
+            end
+        end
+
+        class NodeObserverPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
+            include NodeObserverPrx_mixin
+        end
 
-    if not defined?(::IceGrid::T_AdapterObserver)
-        T_AdapterObserver = ::Ice::__declareClass('::IceGrid::AdapterObserver')
-        T_AdapterObserverPrx = ::Ice::__declareProxy('::IceGrid::AdapterObserver')
+        if not defined?(::IceGrid::T_NodeObserverPrx)
+            T_NodeObserver = ::Ice::__declareClass('::IceGrid::NodeObserver')
+            T_NodeObserverPrx = ::Ice::__declareProxy('::IceGrid::NodeObserver')
+        end
+
+        T_NodeObserver.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_NodeObserverPrx.defineProxy(NodeObserverPrx, nil, [])
+
+        NodeObserverPrx_mixin::OP_nodeInit = ::Ice::__defineOperation('nodeInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_NodeDynamicInfoSeq, false, 0]], [], nil, [])
+        NodeObserverPrx_mixin::OP_nodeUp = ::Ice::__defineOperation('nodeUp', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_NodeDynamicInfo, false, 0]], [], nil, [])
+        NodeObserverPrx_mixin::OP_nodeDown = ::Ice::__defineOperation('nodeDown', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [])
+        NodeObserverPrx_mixin::OP_updateServer = ::Ice::__defineOperation('updateServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::IceGrid::T_ServerDynamicInfo, false, 0]], [], nil, [])
+        NodeObserverPrx_mixin::OP_updateAdapter = ::Ice::__defineOperation('updateAdapter', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::IceGrid::T_AdapterDynamicInfo, false, 0]], [], nil, [])
     end
 
-    if not defined?(::IceGrid::T_ObjectObserver)
-        T_ObjectObserver = ::Ice::__declareClass('::IceGrid::ObjectObserver')
-        T_ObjectObserverPrx = ::Ice::__declareProxy('::IceGrid::ObjectObserver')
+    if not defined?(::IceGrid::ApplicationObserver_Mixin)
+
+        module ::IceGrid::ApplicationObserver_Mixin
+        end
+        module ApplicationObserverPrx_mixin
+
+            def applicationInit(serial, applications, context=nil)
+                ApplicationObserverPrx_mixin::OP_applicationInit.invoke(self, [serial, applications], context)
+            end
+
+            def applicationAdded(serial, desc, context=nil)
+                ApplicationObserverPrx_mixin::OP_applicationAdded.invoke(self, [serial, desc], context)
+            end
+
+            def applicationRemoved(serial, name, context=nil)
+                ApplicationObserverPrx_mixin::OP_applicationRemoved.invoke(self, [serial, name], context)
+            end
+
+            def applicationUpdated(serial, desc, context=nil)
+                ApplicationObserverPrx_mixin::OP_applicationUpdated.invoke(self, [serial, desc], context)
+            end
+        end
+
+        class ApplicationObserverPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
+            include ApplicationObserverPrx_mixin
+        end
+
+        if not defined?(::IceGrid::T_ApplicationObserverPrx)
+            T_ApplicationObserver = ::Ice::__declareClass('::IceGrid::ApplicationObserver')
+            T_ApplicationObserverPrx = ::Ice::__declareProxy('::IceGrid::ApplicationObserver')
+        end
+
+        T_ApplicationObserver.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_ApplicationObserverPrx.defineProxy(ApplicationObserverPrx, nil, [])
+
+        ApplicationObserverPrx_mixin::OP_applicationInit = ::Ice::__defineOperation('applicationInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::IceGrid::T_ApplicationInfoSeq, false, 0]], [], nil, [])
+        ApplicationObserverPrx_mixin::OP_applicationAdded = ::Ice::__defineOperation('applicationAdded', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::IceGrid::T_ApplicationInfo, false, 0]], [], nil, [])
+        ApplicationObserverPrx_mixin::OP_applicationRemoved = ::Ice::__defineOperation('applicationRemoved', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::Ice::T_string, false, 0]], [], nil, [])
+        ApplicationObserverPrx_mixin::OP_applicationUpdated = ::Ice::__defineOperation('applicationUpdated', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::IceGrid::T_ApplicationUpdateInfo, false, 0]], [], nil, [])
     end
 
-    if not defined?(::IceGrid::AdminSession_mixin)
-        module AdminSession_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::IceGrid::AdapterObserver_Mixin)
+
+        module ::IceGrid::AdapterObserver_Mixin
+        end
+        module AdapterObserverPrx_mixin
 
-            def ice_ids(current=nil)
-                ['::Glacier2::Session', '::Ice::Object', '::IceGrid::AdminSession']
+            def adapterInit(adpts, context=nil)
+                AdapterObserverPrx_mixin::OP_adapterInit.invoke(self, [adpts], context)
             end
 
-            def ice_id(current=nil)
-                '::IceGrid::AdminSession'
+            def adapterAdded(info, context=nil)
+                AdapterObserverPrx_mixin::OP_adapterAdded.invoke(self, [info], context)
             end
 
-            #
-            # Operation signatures.
-            #
-            # def keepAlive(current=nil)
-            # def getAdmin(current=nil)
-            # def getAdminCallbackTemplate(current=nil)
-            # def setObservers(registryObs, nodeObs, appObs, adptObs, objObs, current=nil)
-            # def setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, current=nil)
-            # def startUpdate(current=nil)
-            # def finishUpdate(current=nil)
-            # def getReplicaName(current=nil)
-            # def openServerLog(id, path, count, current=nil)
-            # def openServerStdErr(id, count, current=nil)
-            # def openServerStdOut(id, count, current=nil)
-            # def openNodeStdErr(name, count, current=nil)
-            # def openNodeStdOut(name, count, current=nil)
-            # def openRegistryStdErr(name, count, current=nil)
-            # def openRegistryStdOut(name, count, current=nil)
+            def adapterUpdated(info, context=nil)
+                AdapterObserverPrx_mixin::OP_adapterUpdated.invoke(self, [info], context)
+            end
 
-            def inspect
-                ::Ice::__stringify(self, T_AdminSession)
+            def adapterRemoved(id, context=nil)
+                AdapterObserverPrx_mixin::OP_adapterRemoved.invoke(self, [id], context)
             end
         end
-        class AdminSession
-            include AdminSession_mixin
-            
-            def AdminSession.ice_staticId()
-                '::IceGrid::AdminSession'
+
+        class AdapterObserverPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
+            include AdapterObserverPrx_mixin
+        end
+
+        if not defined?(::IceGrid::T_AdapterObserverPrx)
+            T_AdapterObserver = ::Ice::__declareClass('::IceGrid::AdapterObserver')
+            T_AdapterObserverPrx = ::Ice::__declareProxy('::IceGrid::AdapterObserver')
+        end
+
+        T_AdapterObserver.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_AdapterObserverPrx.defineProxy(AdapterObserverPrx, nil, [])
+
+        AdapterObserverPrx_mixin::OP_adapterInit = ::Ice::__defineOperation('adapterInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_AdapterInfoSeq, false, 0]], [], nil, [])
+        AdapterObserverPrx_mixin::OP_adapterAdded = ::Ice::__defineOperation('adapterAdded', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_AdapterInfo, false, 0]], [], nil, [])
+        AdapterObserverPrx_mixin::OP_adapterUpdated = ::Ice::__defineOperation('adapterUpdated', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_AdapterInfo, false, 0]], [], nil, [])
+        AdapterObserverPrx_mixin::OP_adapterRemoved = ::Ice::__defineOperation('adapterRemoved', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [])
+    end
+
+    if not defined?(::IceGrid::ObjectObserver_Mixin)
+
+        module ::IceGrid::ObjectObserver_Mixin
+        end
+        module ObjectObserverPrx_mixin
+
+            def objectInit(objects, context=nil)
+                ObjectObserverPrx_mixin::OP_objectInit.invoke(self, [objects], context)
+            end
+
+            def objectAdded(info, context=nil)
+                ObjectObserverPrx_mixin::OP_objectAdded.invoke(self, [info], context)
+            end
+
+            def objectUpdated(info, context=nil)
+                ObjectObserverPrx_mixin::OP_objectUpdated.invoke(self, [info], context)
+            end
+
+            def objectRemoved(id, context=nil)
+                ObjectObserverPrx_mixin::OP_objectRemoved.invoke(self, [id], context)
             end
         end
+
+        class ObjectObserverPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
+            include ObjectObserverPrx_mixin
+        end
+
+        if not defined?(::IceGrid::T_ObjectObserverPrx)
+            T_ObjectObserver = ::Ice::__declareClass('::IceGrid::ObjectObserver')
+            T_ObjectObserverPrx = ::Ice::__declareProxy('::IceGrid::ObjectObserver')
+        end
+
+        T_ObjectObserver.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_ObjectObserverPrx.defineProxy(ObjectObserverPrx, nil, [])
+
+        ObjectObserverPrx_mixin::OP_objectInit = ::Ice::__defineOperation('objectInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ObjectInfoSeq, false, 0]], [], nil, [])
+        ObjectObserverPrx_mixin::OP_objectAdded = ::Ice::__defineOperation('objectAdded', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ObjectInfo, false, 0]], [], nil, [])
+        ObjectObserverPrx_mixin::OP_objectUpdated = ::Ice::__defineOperation('objectUpdated', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ObjectInfo, false, 0]], [], nil, [])
+        ObjectObserverPrx_mixin::OP_objectRemoved = ::Ice::__defineOperation('objectRemoved', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_Identity, false, 0]], [], nil, [])
+    end
+
+    if not defined?(::IceGrid::AdminSession_Mixin)
+
+        module ::IceGrid::AdminSession_Mixin
+        end
         module AdminSessionPrx_mixin
             include ::Glacier2::SessionPrx_mixin
 
-            def keepAlive(_ctx=nil)
-                AdminSession_mixin::OP_keepAlive.invoke(self, [], _ctx)
+            def keepAlive(context=nil)
+                AdminSessionPrx_mixin::OP_keepAlive.invoke(self, [], context)
             end
 
-            def getAdmin(_ctx=nil)
-                AdminSession_mixin::OP_getAdmin.invoke(self, [], _ctx)
+            def getAdmin(context=nil)
+                AdminSessionPrx_mixin::OP_getAdmin.invoke(self, [], context)
             end
 
-            def getAdminCallbackTemplate(_ctx=nil)
-                AdminSession_mixin::OP_getAdminCallbackTemplate.invoke(self, [], _ctx)
+            def getAdminCallbackTemplate(context=nil)
+                AdminSessionPrx_mixin::OP_getAdminCallbackTemplate.invoke(self, [], context)
             end
 
-            def setObservers(registryObs, nodeObs, appObs, adptObs, objObs, _ctx=nil)
-                AdminSession_mixin::OP_setObservers.invoke(self, [registryObs, nodeObs, appObs, adptObs, objObs], _ctx)
+            def setObservers(registryObs, nodeObs, appObs, adptObs, objObs, context=nil)
+                AdminSessionPrx_mixin::OP_setObservers.invoke(self, [registryObs, nodeObs, appObs, adptObs, objObs], context)
             end
 
-            def setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, _ctx=nil)
-                AdminSession_mixin::OP_setObserversByIdentity.invoke(self, [registryObs, nodeObs, appObs, adptObs, objObs], _ctx)
+            def setObserversByIdentity(registryObs, nodeObs, appObs, adptObs, objObs, context=nil)
+                AdminSessionPrx_mixin::OP_setObserversByIdentity.invoke(self, [registryObs, nodeObs, appObs, adptObs, objObs], context)
             end
 
-            def startUpdate(_ctx=nil)
-                AdminSession_mixin::OP_startUpdate.invoke(self, [], _ctx)
+            def startUpdate(context=nil)
+                AdminSessionPrx_mixin::OP_startUpdate.invoke(self, [], context)
             end
 
-            def finishUpdate(_ctx=nil)
-                AdminSession_mixin::OP_finishUpdate.invoke(self, [], _ctx)
+            def finishUpdate(context=nil)
+                AdminSessionPrx_mixin::OP_finishUpdate.invoke(self, [], context)
             end
 
-            def getReplicaName(_ctx=nil)
-                AdminSession_mixin::OP_getReplicaName.invoke(self, [], _ctx)
+            def getReplicaName(context=nil)
+                AdminSessionPrx_mixin::OP_getReplicaName.invoke(self, [], context)
             end
 
-            def openServerLog(id, path, count, _ctx=nil)
-                AdminSession_mixin::OP_openServerLog.invoke(self, [id, path, count], _ctx)
+            def openServerLog(id, path, count, context=nil)
+                AdminSessionPrx_mixin::OP_openServerLog.invoke(self, [id, path, count], context)
             end
 
-            def openServerStdErr(id, count, _ctx=nil)
-                AdminSession_mixin::OP_openServerStdErr.invoke(self, [id, count], _ctx)
+            def openServerStdErr(id, count, context=nil)
+                AdminSessionPrx_mixin::OP_openServerStdErr.invoke(self, [id, count], context)
             end
 
-            def openServerStdOut(id, count, _ctx=nil)
-                AdminSession_mixin::OP_openServerStdOut.invoke(self, [id, count], _ctx)
+            def openServerStdOut(id, count, context=nil)
+                AdminSessionPrx_mixin::OP_openServerStdOut.invoke(self, [id, count], context)
             end
 
-            def openNodeStdErr(name, count, _ctx=nil)
-                AdminSession_mixin::OP_openNodeStdErr.invoke(self, [name, count], _ctx)
+            def openNodeStdErr(name, count, context=nil)
+                AdminSessionPrx_mixin::OP_openNodeStdErr.invoke(self, [name, count], context)
             end
 
-            def openNodeStdOut(name, count, _ctx=nil)
-                AdminSession_mixin::OP_openNodeStdOut.invoke(self, [name, count], _ctx)
+            def openNodeStdOut(name, count, context=nil)
+                AdminSessionPrx_mixin::OP_openNodeStdOut.invoke(self, [name, count], context)
             end
 
-            def openRegistryStdErr(name, count, _ctx=nil)
-                AdminSession_mixin::OP_openRegistryStdErr.invoke(self, [name, count], _ctx)
+            def openRegistryStdErr(name, count, context=nil)
+                AdminSessionPrx_mixin::OP_openRegistryStdErr.invoke(self, [name, count], context)
             end
 
-            def openRegistryStdOut(name, count, _ctx=nil)
-                AdminSession_mixin::OP_openRegistryStdOut.invoke(self, [name, count], _ctx)
+            def openRegistryStdOut(name, count, context=nil)
+                AdminSessionPrx_mixin::OP_openRegistryStdOut.invoke(self, [name, count], context)
             end
         end
+
         class AdminSessionPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
             include AdminSessionPrx_mixin
-
-            def AdminSessionPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::AdminSession', facetOrCtx, _ctx)
-            end
-
-            def AdminSessionPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def AdminSessionPrx.ice_staticId()
-                '::IceGrid::AdminSession'
-            end
         end
 
-        if not defined?(::IceGrid::T_AdminSession)
+        if not defined?(::IceGrid::T_AdminSessionPrx)
             T_AdminSession = ::Ice::__declareClass('::IceGrid::AdminSession')
             T_AdminSessionPrx = ::Ice::__declareProxy('::IceGrid::AdminSession')
         end
 
-        T_AdminSession.defineClass(AdminSession, -1, true, false, nil, [::Glacier2::T_Session], [])
-        AdminSession_mixin::ICE_TYPE = T_AdminSession
-
-        T_AdminSessionPrx.defineProxy(AdminSessionPrx, T_AdminSession)
-        AdminSessionPrx::ICE_TYPE = T_AdminSessionPrx
-
-        AdminSession_mixin::OP_keepAlive = ::Ice::__defineOperation('keepAlive', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], nil, [])
-        AdminSession_mixin::OP_getAdmin = ::Ice::__defineOperation('getAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::IceGrid::T_AdminPrx, false, 0], [])
-        AdminSession_mixin::OP_getAdminCallbackTemplate = ::Ice::__defineOperation('getAdminCallbackTemplate', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_ObjectPrx, false, 0], [])
-        AdminSession_mixin::OP_setObservers = ::Ice::__defineOperation('setObservers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::IceGrid::T_RegistryObserverPrx, false, 0], [::IceGrid::T_NodeObserverPrx, false, 0], [::IceGrid::T_ApplicationObserverPrx, false, 0], [::IceGrid::T_AdapterObserverPrx, false, 0], [::IceGrid::T_ObjectObserverPrx, false, 0]], [], nil, [::IceGrid::T_ObserverAlreadyRegisteredException])
-        AdminSession_mixin::OP_setObserversByIdentity = ::Ice::__defineOperation('setObserversByIdentity', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0]], [], nil, [::IceGrid::T_ObserverAlreadyRegisteredException])
-        AdminSession_mixin::OP_startUpdate = ::Ice::__defineOperation('startUpdate', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], [::Ice::T_int, false, 0], [::IceGrid::T_AccessDeniedException])
-        AdminSession_mixin::OP_finishUpdate = ::Ice::__defineOperation('finishUpdate', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [::IceGrid::T_AccessDeniedException])
-        AdminSession_mixin::OP_getReplicaName = ::Ice::__defineOperation('getReplicaName', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_string, false, 0], [])
-        AdminSession_mixin::OP_openServerLog = ::Ice::__defineOperation('openServerLog', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        AdminSession_mixin::OP_openServerStdErr = ::Ice::__defineOperation('openServerStdErr', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        AdminSession_mixin::OP_openServerStdOut = ::Ice::__defineOperation('openServerStdOut', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
-        AdminSession_mixin::OP_openNodeStdErr = ::Ice::__defineOperation('openNodeStdErr', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        AdminSession_mixin::OP_openNodeStdOut = ::Ice::__defineOperation('openNodeStdOut', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
-        AdminSession_mixin::OP_openRegistryStdErr = ::Ice::__defineOperation('openRegistryStdErr', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
-        AdminSession_mixin::OP_openRegistryStdOut = ::Ice::__defineOperation('openRegistryStdOut', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
+        T_AdminSession.defineClass(::Ice::Value, -1, false, true, nil, [])
+
+        T_AdminSessionPrx.defineProxy(AdminSessionPrx, nil, [::Glacier2::T_SessionPrx])
+
+        AdminSessionPrx_mixin::OP_keepAlive = ::Ice::__defineOperation('keepAlive', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], nil, [])
+        AdminSessionPrx_mixin::OP_getAdmin = ::Ice::__defineOperation('getAdmin', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::IceGrid::T_AdminPrx, false, 0], [])
+        AdminSessionPrx_mixin::OP_getAdminCallbackTemplate = ::Ice::__defineOperation('getAdminCallbackTemplate', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_ObjectPrx, false, 0], [])
+        AdminSessionPrx_mixin::OP_setObservers = ::Ice::__defineOperation('setObservers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::IceGrid::T_RegistryObserverPrx, false, 0], [::IceGrid::T_NodeObserverPrx, false, 0], [::IceGrid::T_ApplicationObserverPrx, false, 0], [::IceGrid::T_AdapterObserverPrx, false, 0], [::IceGrid::T_ObjectObserverPrx, false, 0]], [], nil, [::IceGrid::T_ObserverAlreadyRegisteredException])
+        AdminSessionPrx_mixin::OP_setObserversByIdentity = ::Ice::__defineOperation('setObserversByIdentity', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [[::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0], [::Ice::T_Identity, false, 0]], [], nil, [::IceGrid::T_ObserverAlreadyRegisteredException])
+        AdminSessionPrx_mixin::OP_startUpdate = ::Ice::__defineOperation('startUpdate', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], [::Ice::T_int, false, 0], [::IceGrid::T_AccessDeniedException])
+        AdminSessionPrx_mixin::OP_finishUpdate = ::Ice::__defineOperation('finishUpdate', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [::IceGrid::T_AccessDeniedException])
+        AdminSessionPrx_mixin::OP_getReplicaName = ::Ice::__defineOperation('getReplicaName', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::Ice::T_string, false, 0], [])
+        AdminSessionPrx_mixin::OP_openServerLog = ::Ice::__defineOperation('openServerLog', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminSessionPrx_mixin::OP_openServerStdErr = ::Ice::__defineOperation('openServerStdErr', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminSessionPrx_mixin::OP_openServerStdOut = ::Ice::__defineOperation('openServerStdOut', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException])
+        AdminSessionPrx_mixin::OP_openNodeStdErr = ::Ice::__defineOperation('openNodeStdErr', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminSessionPrx_mixin::OP_openNodeStdOut = ::Ice::__defineOperation('openNodeStdOut', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
+        AdminSessionPrx_mixin::OP_openRegistryStdErr = ::Ice::__defineOperation('openRegistryStdErr', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
+        AdminSessionPrx_mixin::OP_openRegistryStdOut = ::Ice::__defineOperation('openRegistryStdOut', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::Ice::T_int, false, 0]], [], [::IceGrid::T_FileIteratorPrx, false, 0], [::IceGrid::T_FileNotAvailableException, ::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
     end
 end