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])
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])
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])
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])
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])
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])
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])
OP_getApplicationInfo = 
Ice::__defineOperation('getApplicationInfo', 'getApplicationInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ApplicationInfo, false, 0], [::IceGrid::T_ApplicationNotExistException])
OP_getDefaultApplicationDescriptor = 
Ice::__defineOperation('getDefaultApplicationDescriptor', 'getDefaultApplicationDescriptor', Ice::OperationMode::Idempotent, nil, [], [], [::IceGrid::T_ApplicationDescriptor, false, 0], [::IceGrid::T_DeploymentException])
OP_getAllApplicationNames = 
Ice::__defineOperation('getAllApplicationNames', 'getAllApplicationNames', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
OP_getServerInfo = 
Ice::__defineOperation('getServerInfo', 'getServerInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ServerInfo, false, 0], [::IceGrid::T_ServerNotExistException])
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])
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])
OP_getServerAdminCategory = 
Ice::__defineOperation('getServerAdminCategory', 'getServerAdminCategory', Ice::OperationMode::Idempotent, nil, [], [], [Ice::T_string, false, 0], [])
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])
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])
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])
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])
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])
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])
OP_getAllServerIds = 
Ice::__defineOperation('getAllServerIds', 'getAllServerIds', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
OP_getAdapterInfo = 
Ice::__defineOperation('getAdapterInfo', 'getAdapterInfo', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_AdapterInfoSeq, false, 0], [::IceGrid::T_AdapterNotExistException])
OP_removeAdapter = 
Ice::__defineOperation('removeAdapter', 'removeAdapter', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_AdapterNotExistException, ::IceGrid::T_DeploymentException])
OP_getAllAdapterIds = 
Ice::__defineOperation('getAllAdapterIds', 'getAllAdapterIds', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
OP_addObject = 
Ice::__defineOperation('addObject', 'addObject', Ice::OperationMode::Normal, nil, [[Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectExistsException, ::IceGrid::T_DeploymentException])
OP_updateObject = 
Ice::__defineOperation('updateObject', 'updateObject', Ice::OperationMode::Normal, nil, [[Ice::T_ObjectPrx, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException])
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])
OP_removeObject = 
Ice::__defineOperation('removeObject', 'removeObject', Ice::OperationMode::Normal, nil, [[::Ice::T_Identity, false, 0]], [], nil, [::IceGrid::T_ObjectNotRegisteredException, ::IceGrid::T_DeploymentException])
OP_getObjectInfo = 
Ice::__defineOperation('getObjectInfo', 'getObjectInfo', Ice::OperationMode::Idempotent, nil, [[::Ice::T_Identity, false, 0]], [], [::IceGrid::T_ObjectInfo, false, 0], [::IceGrid::T_ObjectNotRegisteredException])
OP_getObjectInfosByType = 
Ice::__defineOperation('getObjectInfosByType', 'getObjectInfosByType', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [])
OP_getAllObjectInfos = 
Ice::__defineOperation('getAllObjectInfos', 'getAllObjectInfos', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [::IceGrid::T_ObjectInfoSeq, false, 0], [])
OP_pingNode = 
Ice::__defineOperation('pingNode', 'pingNode', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_bool, false, 0], [::IceGrid::T_NodeNotExistException])
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])
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])
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])
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])
OP_shutdownNode = 
Ice::__defineOperation('shutdownNode', 'shutdownNode', Ice::OperationMode::Normal, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_NodeNotExistException, ::IceGrid::T_NodeUnreachableException])
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])
OP_getAllNodeNames = 
Ice::__defineOperation('getAllNodeNames', 'getAllNodeNames', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
OP_pingRegistry = 
Ice::__defineOperation('pingRegistry', 'pingRegistry', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_bool, false, 0], [::IceGrid::T_RegistryNotExistException])
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])
OP_getRegistryAdmin = 
Ice::__defineOperation('getRegistryAdmin', 'getRegistryAdmin', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], [Ice::T_ObjectPrx, false, 0], [::IceGrid::T_RegistryNotExistException])
OP_shutdownRegistry = 
Ice::__defineOperation('shutdownRegistry', 'shutdownRegistry', Ice::OperationMode::Idempotent, nil, [[Ice::T_string, false, 0]], [], nil, [::IceGrid::T_RegistryNotExistException, ::IceGrid::T_RegistryUnreachableException])
OP_getAllRegistryNames = 
Ice::__defineOperation('getAllRegistryNames', 'getAllRegistryNames', Ice::OperationMode::Idempotent, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
OP_shutdown = 
Ice::__defineOperation('shutdown', 'shutdown', Ice::OperationMode::Normal, nil, [], [], nil, [])

Instance Method Summary collapse

Instance Method Details

#addApplication(descriptor, context = nil) ⇒ Object 



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

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

#addObject(obj, context = nil) ⇒ Object 



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

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

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



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

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

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



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

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

#getAdapterInfo(id, context = nil) ⇒ Object 



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

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

#getAllAdapterIds(context = nil) ⇒ Object 



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

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

#getAllApplicationNames(context = nil) ⇒ Object 



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

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

#getAllNodeNames(context = nil) ⇒ Object 



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

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

#getAllObjectInfos(expr, context = nil) ⇒ Object 



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

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

#getAllRegistryNames(context = nil) ⇒ Object 



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

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

#getAllServerIds(context = nil) ⇒ Object 



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

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

#getApplicationInfo(name, context = nil) ⇒ Object 



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

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

#getDefaultApplicationDescriptor(context = nil) ⇒ Object 



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

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

#getNodeAdmin(name, context = nil) ⇒ Object 



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

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

#getNodeHostname(name, context = nil) ⇒ Object 



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

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

#getNodeInfo(name, context = nil) ⇒ Object 



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

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

#getNodeLoad(name, context = nil) ⇒ Object 



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

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

#getNodeProcessorSocketCount(name, context = nil) ⇒ Object 



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

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

#getObjectInfo(id, context = nil) ⇒ Object 



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

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

#getObjectInfosByType(type, context = nil) ⇒ Object 



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

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

#getRegistryAdmin(name, context = nil) ⇒ Object 



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

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

#getRegistryInfo(name, context = nil) ⇒ Object 



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

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

#getServerAdmin(id, context = nil) ⇒ Object 



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

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

#getServerAdminCategory(context = nil) ⇒ Object 



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

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

#getServerInfo(id, context = nil) ⇒ Object 



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

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

#getServerPid(id, context = nil) ⇒ Object 



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

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

#getServerState(id, context = nil) ⇒ Object 



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

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

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



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

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

#isServerEnabled(id, context = nil) ⇒ Object 



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

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

#pingNode(name, context = nil) ⇒ Object 



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

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

#pingRegistry(name, context = nil) ⇒ Object 



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

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

#removeAdapter(id, context = nil) ⇒ Object 



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

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

#removeApplication(name, context = nil) ⇒ Object 



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

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

#removeObject(id, context = nil) ⇒ Object 



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

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

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



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

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

#shutdown(context = nil) ⇒ Object 



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

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

#shutdownNode(name, context = nil) ⇒ Object 



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

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

#shutdownRegistry(name, context = nil) ⇒ Object 



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

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

#startServer(id, context = nil) ⇒ Object 



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

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

#stopServer(id, context = nil) ⇒ Object 



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

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

#syncApplication(descriptor, context = nil) ⇒ Object 



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

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

#syncApplicationWithoutRestart(descriptor, context = nil) ⇒ Object 



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

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

#updateApplication(descriptor, context = nil) ⇒ Object 



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

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

#updateApplicationWithoutRestart(descriptor, context = nil) ⇒ Object 



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

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

#updateObject(obj, context = nil) ⇒ Object 



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

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