Module: IceGrid::AdminPrx_mixin

Included in:
AdminPrx
Defined in:
ruby/IceGrid/Admin.rb

Constant Summary collapse

OP_addApplication = 
Ice::__defineOperation('addApplication', 'addApplication', Ice::OperationMode::Normal, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException], false)
OP_syncApplication = 
Ice::__defineOperation('syncApplication', 'syncApplication', Ice::OperationMode::Normal, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException], false)
OP_updateApplication = 
Ice::__defineOperation('updateApplication', 'updateApplication', Ice::OperationMode::Normal, nil, [[::IceGrid::T_ApplicationUpdateDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException], false)
OP_syncApplicationWithoutRestart = 
Ice::__defineOperation('syncApplicationWithoutRestart', 'syncApplicationWithoutRestart', Ice::OperationMode::Normal, nil, [[::IceGrid::T_ApplicationDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException], false)
OP_updateApplicationWithoutRestart = 
Ice::__defineOperation('updateApplicationWithoutRestart', 'updateApplicationWithoutRestart', Ice::OperationMode::Normal, nil, [[::IceGrid::T_ApplicationUpdateDescriptor, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException], false)
OP_removeApplication = 
Ice::__defineOperation('removeApplication', 'removeApplication', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AccessDeniedException, ::IceGrid::T_DeploymentException, ::IceGrid::T_ApplicationNotExistException], false)
OP_instantiateServer = 
Ice::__defineOperation('instantiateServer', 'instantiateServer', Ice::OperationMode::Normal, 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], false)
OP_getApplicationInfo = 
Ice::__defineOperation('getApplicationInfo', 'getApplicationInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ApplicationInfo, false, 0], [::IceGrid::T_ApplicationNotExistException], false)
OP_getDefaultApplicationDescriptor = 
Ice::__defineOperation('getDefaultApplicationDescriptor', 'getDefaultApplicationDescriptor', Ice::OperationMode::Idempotent, nil, [], [], [::IceGrid::T_ApplicationDescriptor, false, 0], [::IceGrid::T_DeploymentException], false)
OP_getAllApplicationNames = 
Ice::__defineOperation('getAllApplicationNames', 'getAllApplicationNames', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [], false)
OP_getServerInfo = 
Ice::__defineOperation('getServerInfo', 'getServerInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ServerInfo, false, 0], [::IceGrid::T_ServerNotExistException], false)
OP_getServerState = 
Ice::__defineOperation('getServerState', 'getServerState', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ServerState, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_getServerPid = 
Ice::__defineOperation('getServerPid', 'getServerPid', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_int, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_getServerAdminCategory = 
Ice::__defineOperation('getServerAdminCategory', 'getServerAdminCategory', Ice::OperationMode::Idempotent, nil, [], [], [Ice::T_string, false, 0], [], false)
OP_getServerAdmin = 
Ice::__defineOperation('getServerAdmin', 'getServerAdmin', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_ObjectPrx, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_enableServer = 
Ice::__defineOperation('enableServer', 'enableServer', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0], [Ice::T_bool, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_isServerEnabled = 
Ice::__defineOperation('isServerEnabled', 'isServerEnabled', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_bool, false, 0], [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_startServer = 
Ice::__defineOperation('startServer', 'startServer', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_ServerStartException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_stopServer = 
Ice::__defineOperation('stopServer', 'stopServer', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_ServerStopException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException], false)
OP_sendSignal = 
Ice::__defineOperation('sendSignal', 'sendSignal', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0], [Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ServerNotExistException, ::IceGrid::T_NodeUnreachableException, ::IceGrid::T_DeploymentException, ::IceGrid::T_BadSignalException], false)
OP_getAllServerIds = 
Ice::__defineOperation('getAllServerIds', 'getAllServerIds', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [], false)
OP_getAdapterInfo = 
Ice::__defineOperation('getAdapterInfo', 'getAdapterInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_AdapterInfoSeq, false, 0], [::IceGrid::T_AdapterNotExistException], false)
OP_removeAdapter = 
Ice::__defineOperation('removeAdapter', 'removeAdapter', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AdapterNotExistException, ::IceGrid::T_DeploymentException], false)
OP_getAllAdapterIds = 
Ice::__defineOperation('getAllAdapterIds', 'getAllAdapterIds', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [], false)
OP_addObject = 
Ice::__defineOperation('addObject', 'addObject', Ice::OperationMode::Normal, nil, [[Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException], false)
OP_updateObject = 
Ice::__defineOperation('updateObject', 'updateObject', Ice::OperationMode::Normal, nil, [[Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException], false)
OP_addObjectWithType = 
Ice::__defineOperation('addObjectWithType', 'addObjectWithType', Ice::OperationMode::Normal, nil, [[Ice::T_ObjectPrx, false, 0], [Ice::T_string, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException], false)
OP_removeObject = 
Ice::__defineOperation('removeObject', 'removeObject', Ice::OperationMode::Normal, nil, [[::Ice::T_Identity, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException], false)
OP_getObjectInfo = 
Ice::__defineOperation('getObjectInfo', 'getObjectInfo', Ice::OperationMode::Idempotent, nil, [[::Ice::T_Identity, false, 0]], [], [::IceGrid::T_ObjectInfo, false, 0], [::IceGrid::T_ObjectNotRegisteredException], false)
OP_getObjectInfosByType = 
Ice::__defineOperation('getObjectInfosByType', 'getObjectInfosByType', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [], false)
OP_getAllObjectInfos = 
Ice::__defineOperation('getAllObjectInfos', 'getAllObjectInfos', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [], false)
OP_pingNode = 
Ice::__defineOperation('pingNode', 'pingNode', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_bool, false, 0], [::IceGrid::T_NodeNotExistException], false)
OP_getNodeLoad = 
Ice::__defineOperation('getNodeLoad', 'getNodeLoad', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_LoadInfo, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException], false)
OP_getNodeInfo = 
Ice::__defineOperation('getNodeInfo', 'getNodeInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_NodeInfo, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException], false)
OP_getNodeAdmin = 
Ice::__defineOperation('getNodeAdmin', 'getNodeAdmin', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_ObjectPrx, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException], false)
OP_getNodeProcessorSocketCount = 
Ice::__defineOperation('getNodeProcessorSocketCount', 'getNodeProcessorSocketCount', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_int, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException], false)
OP_shutdownNode = 
Ice::__defineOperation('shutdownNode', 'shutdownNode', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException], false)
OP_getNodeHostname = 
Ice::__defineOperation('getNodeHostname', 'getNodeHostname', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_string, false, 0], [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException], false)
OP_getAllNodeNames = 
Ice::__defineOperation('getAllNodeNames', 'getAllNodeNames', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [], false)
OP_pingRegistry = 
Ice::__defineOperation('pingRegistry', 'pingRegistry', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_bool, false, 0], [::IceGrid::T_RegistryNotExistException], false)
OP_getRegistryInfo = 
Ice::__defineOperation('getRegistryInfo', 'getRegistryInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_RegistryInfo, false, 0], [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException], false)
OP_getRegistryAdmin = 
Ice::__defineOperation('getRegistryAdmin', 'getRegistryAdmin', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_ObjectPrx, false, 0], [::IceGrid::T_RegistryNotExistException], false)
OP_shutdownRegistry = 
Ice::__defineOperation('shutdownRegistry', 'shutdownRegistry', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException], false)
OP_getAllRegistryNames = 
Ice::__defineOperation('getAllRegistryNames', 'getAllRegistryNames', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [], false)
OP_shutdown = 
Ice::__defineOperation('shutdown', 'shutdown', Ice::OperationMode::Normal, nil, [], [], nil, [], false)

Instance Method Summary collapse

Instance Method Details

#addApplication(descriptor, context = nil) ⇒ Object 



553
554
555
 
# File 'ruby/IceGrid/Admin.rb', line 553

def addApplication(descriptor, context=nil)
    AdminPrx_mixin::OP_addApplication.invoke(self, [descriptor], context)
end

#addObject(obj, context = nil) ⇒ Object 



649
650
651
 
# File 'ruby/IceGrid/Admin.rb', line 649

def addObject(obj, context=nil)
    AdminPrx_mixin::OP_addObject.invoke(self, [obj], context)
end

#addObjectWithType(obj, type, context = nil) ⇒ Object 



657
658
659
 
# File 'ruby/IceGrid/Admin.rb', line 657

def addObjectWithType(obj, type, context=nil)
    AdminPrx_mixin::OP_addObjectWithType.invoke(self, [obj, type], context)
end

#enableServer(id, enabled, context = nil) ⇒ Object 



613
614
615
 
# File 'ruby/IceGrid/Admin.rb', line 613

def enableServer(id, enabled, context=nil)
    AdminPrx_mixin::OP_enableServer.invoke(self, [id, enabled], context)
end

#getAdapterInfo(id, context = nil) ⇒ Object 



637
638
639
 
# File 'ruby/IceGrid/Admin.rb', line 637

def getAdapterInfo(id, context=nil)
    AdminPrx_mixin::OP_getAdapterInfo.invoke(self, [id], context)
end

#getAllAdapterIds(context = nil) ⇒ Object 



645
646
647
 
# File 'ruby/IceGrid/Admin.rb', line 645

def getAllAdapterIds(context=nil)
    AdminPrx_mixin::OP_getAllAdapterIds.invoke(self, [], context)
end

#getAllApplicationNames(context = nil) ⇒ Object 



589
590
591
 
# File 'ruby/IceGrid/Admin.rb', line 589

def getAllApplicationNames(context=nil)
    AdminPrx_mixin::OP_getAllApplicationNames.invoke(self, [], context)
end

#getAllNodeNames(context = nil) ⇒ Object 



705
706
707
 
# File 'ruby/IceGrid/Admin.rb', line 705

def getAllNodeNames(context=nil)
    AdminPrx_mixin::OP_getAllNodeNames.invoke(self, [], context)
end

#getAllObjectInfos(expr, context = nil) ⇒ Object 



673
674
675
 
# File 'ruby/IceGrid/Admin.rb', line 673

def getAllObjectInfos(expr, context=nil)
    AdminPrx_mixin::OP_getAllObjectInfos.invoke(self, [expr], context)
end

#getAllRegistryNames(context = nil) ⇒ Object 



725
726
727
 
# File 'ruby/IceGrid/Admin.rb', line 725

def getAllRegistryNames(context=nil)
    AdminPrx_mixin::OP_getAllRegistryNames.invoke(self, [], context)
end

#getAllServerIds(context = nil) ⇒ Object 



633
634
635
 
# File 'ruby/IceGrid/Admin.rb', line 633

def getAllServerIds(context=nil)
    AdminPrx_mixin::OP_getAllServerIds.invoke(self, [], context)
end

#getApplicationInfo(name, context = nil) ⇒ Object 



581
582
583
 
# File 'ruby/IceGrid/Admin.rb', line 581

def getApplicationInfo(name, context=nil)
    AdminPrx_mixin::OP_getApplicationInfo.invoke(self, [name], context)
end

#getDefaultApplicationDescriptor(context = nil) ⇒ Object 



585
586
587
 
# File 'ruby/IceGrid/Admin.rb', line 585

def getDefaultApplicationDescriptor(context=nil)
    AdminPrx_mixin::OP_getDefaultApplicationDescriptor.invoke(self, [], context)
end

#getNodeAdmin(name, context = nil) ⇒ Object 



689
690
691
 
# File 'ruby/IceGrid/Admin.rb', line 689

def getNodeAdmin(name, context=nil)
    AdminPrx_mixin::OP_getNodeAdmin.invoke(self, [name], context)
end

#getNodeHostname(name, context = nil) ⇒ Object 



701
702
703
 
# File 'ruby/IceGrid/Admin.rb', line 701

def getNodeHostname(name, context=nil)
    AdminPrx_mixin::OP_getNodeHostname.invoke(self, [name], context)
end

#getNodeInfo(name, context = nil) ⇒ Object 



685
686
687
 
# File 'ruby/IceGrid/Admin.rb', line 685

def getNodeInfo(name, context=nil)
    AdminPrx_mixin::OP_getNodeInfo.invoke(self, [name], context)
end

#getNodeLoad(name, context = nil) ⇒ Object 



681
682
683
 
# File 'ruby/IceGrid/Admin.rb', line 681

def getNodeLoad(name, context=nil)
    AdminPrx_mixin::OP_getNodeLoad.invoke(self, [name], context)
end

#getNodeProcessorSocketCount(name, context = nil) ⇒ Object 



693
694
695
 
# File 'ruby/IceGrid/Admin.rb', line 693

def getNodeProcessorSocketCount(name, context=nil)
    AdminPrx_mixin::OP_getNodeProcessorSocketCount.invoke(self, [name], context)
end

#getObjectInfo(id, context = nil) ⇒ Object 



665
666
667
 
# File 'ruby/IceGrid/Admin.rb', line 665

def getObjectInfo(id, context=nil)
    AdminPrx_mixin::OP_getObjectInfo.invoke(self, [id], context)
end

#getObjectInfosByType(type, context = nil) ⇒ Object 



669
670
671
 
# File 'ruby/IceGrid/Admin.rb', line 669

def getObjectInfosByType(type, context=nil)
    AdminPrx_mixin::OP_getObjectInfosByType.invoke(self, [type], context)
end

#getRegistryAdmin(name, context = nil) ⇒ Object 



717
718
719
 
# File 'ruby/IceGrid/Admin.rb', line 717

def getRegistryAdmin(name, context=nil)
    AdminPrx_mixin::OP_getRegistryAdmin.invoke(self, [name], context)
end

#getRegistryInfo(name, context = nil) ⇒ Object 



713
714
715
 
# File 'ruby/IceGrid/Admin.rb', line 713

def getRegistryInfo(name, context=nil)
    AdminPrx_mixin::OP_getRegistryInfo.invoke(self, [name], context)
end

#getServerAdmin(id, context = nil) ⇒ Object 



609
610
611
 
# File 'ruby/IceGrid/Admin.rb', line 609

def getServerAdmin(id, context=nil)
    AdminPrx_mixin::OP_getServerAdmin.invoke(self, [id], context)
end

#getServerAdminCategory(context = nil) ⇒ Object 



605
606
607
 
# File 'ruby/IceGrid/Admin.rb', line 605

def getServerAdminCategory(context=nil)
    AdminPrx_mixin::OP_getServerAdminCategory.invoke(self, [], context)
end

#getServerInfo(id, context = nil) ⇒ Object 



593
594
595
 
# File 'ruby/IceGrid/Admin.rb', line 593

def getServerInfo(id, context=nil)
    AdminPrx_mixin::OP_getServerInfo.invoke(self, [id], context)
end

#getServerPid(id, context = nil) ⇒ Object 



601
602
603
 
# File 'ruby/IceGrid/Admin.rb', line 601

def getServerPid(id, context=nil)
    AdminPrx_mixin::OP_getServerPid.invoke(self, [id], context)
end

#getServerState(id, context = nil) ⇒ Object 



597
598
599
 
# File 'ruby/IceGrid/Admin.rb', line 597

def getServerState(id, context=nil)
    AdminPrx_mixin::OP_getServerState.invoke(self, [id], context)
end

#instantiateServer(application, node, desc, context = nil) ⇒ Object 



577
578
579
 
# File 'ruby/IceGrid/Admin.rb', line 577

def instantiateServer(application, node, desc, context=nil)
    AdminPrx_mixin::OP_instantiateServer.invoke(self, [application, node, desc], context)
end

#isServerEnabled(id, context = nil) ⇒ Object 



617
618
619
 
# File 'ruby/IceGrid/Admin.rb', line 617

def isServerEnabled(id, context=nil)
    AdminPrx_mixin::OP_isServerEnabled.invoke(self, [id], context)
end

#pingNode(name, context = nil) ⇒ Object 



677
678
679
 
# File 'ruby/IceGrid/Admin.rb', line 677

def pingNode(name, context=nil)
    AdminPrx_mixin::OP_pingNode.invoke(self, [name], context)
end

#pingRegistry(name, context = nil) ⇒ Object 



709
710
711
 
# File 'ruby/IceGrid/Admin.rb', line 709

def pingRegistry(name, context=nil)
    AdminPrx_mixin::OP_pingRegistry.invoke(self, [name], context)
end

#removeAdapter(id, context = nil) ⇒ Object 



641
642
643
 
# File 'ruby/IceGrid/Admin.rb', line 641

def removeAdapter(id, context=nil)
    AdminPrx_mixin::OP_removeAdapter.invoke(self, [id], context)
end

#removeApplication(name, context = nil) ⇒ Object 



573
574
575
 
# File 'ruby/IceGrid/Admin.rb', line 573

def removeApplication(name, context=nil)
    AdminPrx_mixin::OP_removeApplication.invoke(self, [name], context)
end

#removeObject(id, context = nil) ⇒ Object 



661
662
663
 
# File 'ruby/IceGrid/Admin.rb', line 661

def removeObject(id, context=nil)
    AdminPrx_mixin::OP_removeObject.invoke(self, [id], context)
end

#sendSignal(id, signal, context = nil) ⇒ Object 



629
630
631
 
# File 'ruby/IceGrid/Admin.rb', line 629

def sendSignal(id, signal, context=nil)
    AdminPrx_mixin::OP_sendSignal.invoke(self, [id, signal], context)
end

#shutdown(context = nil) ⇒ Object 



729
730
731
 
# File 'ruby/IceGrid/Admin.rb', line 729

def shutdown(context=nil)
    AdminPrx_mixin::OP_shutdown.invoke(self, [], context)
end

#shutdownNode(name, context = nil) ⇒ Object 



697
698
699
 
# File 'ruby/IceGrid/Admin.rb', line 697

def shutdownNode(name, context=nil)
    AdminPrx_mixin::OP_shutdownNode.invoke(self, [name], context)
end

#shutdownRegistry(name, context = nil) ⇒ Object 



721
722
723
 
# File 'ruby/IceGrid/Admin.rb', line 721

def shutdownRegistry(name, context=nil)
    AdminPrx_mixin::OP_shutdownRegistry.invoke(self, [name], context)
end

#startServer(id, context = nil) ⇒ Object 



621
622
623
 
# File 'ruby/IceGrid/Admin.rb', line 621

def startServer(id, context=nil)
    AdminPrx_mixin::OP_startServer.invoke(self, [id], context)
end

#stopServer(id, context = nil) ⇒ Object 



625
626
627
 
# File 'ruby/IceGrid/Admin.rb', line 625

def stopServer(id, context=nil)
    AdminPrx_mixin::OP_stopServer.invoke(self, [id], context)
end

#syncApplication(descriptor, context = nil) ⇒ Object 



557
558
559
 
# File 'ruby/IceGrid/Admin.rb', line 557

def syncApplication(descriptor, context=nil)
    AdminPrx_mixin::OP_syncApplication.invoke(self, [descriptor], context)
end

#syncApplicationWithoutRestart(descriptor, context = nil) ⇒ Object 



565
566
567
 
# File 'ruby/IceGrid/Admin.rb', line 565

def syncApplicationWithoutRestart(descriptor, context=nil)
    AdminPrx_mixin::OP_syncApplicationWithoutRestart.invoke(self, [descriptor], context)
end

#updateApplication(descriptor, context = nil) ⇒ Object 



561
562
563
 
# File 'ruby/IceGrid/Admin.rb', line 561

def updateApplication(descriptor, context=nil)
    AdminPrx_mixin::OP_updateApplication.invoke(self, [descriptor], context)
end

#updateApplicationWithoutRestart(descriptor, context = nil) ⇒ Object 



569
570
571
 
# File 'ruby/IceGrid/Admin.rb', line 569

def updateApplicationWithoutRestart(descriptor, context=nil)
    AdminPrx_mixin::OP_updateApplicationWithoutRestart.invoke(self, [descriptor], context)
end

#updateObject(obj, context = nil) ⇒ Object 



653
654
655
 
# File 'ruby/IceGrid/Admin.rb', line 653

def updateObject(obj, context=nil)
    AdminPrx_mixin::OP_updateObject.invoke(self, [obj], context)
end