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 



452
453
454
 
# File 'ruby/IceGrid/Admin.rb', line 452

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

#addObject(obj, context = nil) ⇒ Object 



548
549
550
 
# File 'ruby/IceGrid/Admin.rb', line 548

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

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



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

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

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



512
513
514
 
# File 'ruby/IceGrid/Admin.rb', line 512

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

#getAdapterInfo(id, context = nil) ⇒ Object 



536
537
538
 
# File 'ruby/IceGrid/Admin.rb', line 536

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

#getAllAdapterIds(context = nil) ⇒ Object 



544
545
546
 
# File 'ruby/IceGrid/Admin.rb', line 544

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

#getAllApplicationNames(context = nil) ⇒ Object 



488
489
490
 
# File 'ruby/IceGrid/Admin.rb', line 488

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

#getAllNodeNames(context = nil) ⇒ Object 



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

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

#getAllObjectInfos(expr, context = nil) ⇒ Object 



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

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

#getAllRegistryNames(context = nil) ⇒ Object 



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

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

#getAllServerIds(context = nil) ⇒ Object 



532
533
534
 
# File 'ruby/IceGrid/Admin.rb', line 532

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

#getApplicationInfo(name, context = nil) ⇒ Object 



480
481
482
 
# File 'ruby/IceGrid/Admin.rb', line 480

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

#getDefaultApplicationDescriptor(context = nil) ⇒ Object 



484
485
486
 
# File 'ruby/IceGrid/Admin.rb', line 484

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

#getNodeAdmin(name, context = nil) ⇒ Object 



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

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

#getNodeHostname(name, context = nil) ⇒ Object 



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

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

#getNodeInfo(name, context = nil) ⇒ Object 



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

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

#getNodeLoad(name, context = nil) ⇒ Object 



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

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

#getNodeProcessorSocketCount(name, context = nil) ⇒ Object 



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

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

#getObjectInfo(id, context = nil) ⇒ Object 



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

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

#getObjectInfosByType(type, context = nil) ⇒ Object 



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

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

#getRegistryAdmin(name, context = nil) ⇒ Object 



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

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

#getRegistryInfo(name, context = nil) ⇒ Object 



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

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

#getServerAdmin(id, context = nil) ⇒ Object 



508
509
510
 
# File 'ruby/IceGrid/Admin.rb', line 508

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

#getServerAdminCategory(context = nil) ⇒ Object 



504
505
506
 
# File 'ruby/IceGrid/Admin.rb', line 504

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

#getServerInfo(id, context = nil) ⇒ Object 



492
493
494
 
# File 'ruby/IceGrid/Admin.rb', line 492

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

#getServerPid(id, context = nil) ⇒ Object 



500
501
502
 
# File 'ruby/IceGrid/Admin.rb', line 500

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

#getServerState(id, context = nil) ⇒ Object 



496
497
498
 
# File 'ruby/IceGrid/Admin.rb', line 496

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

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



476
477
478
 
# File 'ruby/IceGrid/Admin.rb', line 476

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

#isServerEnabled(id, context = nil) ⇒ Object 



516
517
518
 
# File 'ruby/IceGrid/Admin.rb', line 516

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

#pingNode(name, context = nil) ⇒ Object 



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

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

#pingRegistry(name, context = nil) ⇒ Object 



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

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

#removeAdapter(id, context = nil) ⇒ Object 



540
541
542
 
# File 'ruby/IceGrid/Admin.rb', line 540

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

#removeApplication(name, context = nil) ⇒ Object 



472
473
474
 
# File 'ruby/IceGrid/Admin.rb', line 472

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

#removeObject(id, context = nil) ⇒ Object 



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

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

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



528
529
530
 
# File 'ruby/IceGrid/Admin.rb', line 528

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

#shutdown(context = nil) ⇒ Object 



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

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

#shutdownNode(name, context = nil) ⇒ Object 



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

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

#shutdownRegistry(name, context = nil) ⇒ Object 



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

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

#startServer(id, context = nil) ⇒ Object 



520
521
522
 
# File 'ruby/IceGrid/Admin.rb', line 520

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

#stopServer(id, context = nil) ⇒ Object 



524
525
526
 
# File 'ruby/IceGrid/Admin.rb', line 524

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

#syncApplication(descriptor, context = nil) ⇒ Object 



456
457
458
 
# File 'ruby/IceGrid/Admin.rb', line 456

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

#syncApplicationWithoutRestart(descriptor, context = nil) ⇒ Object 



464
465
466
 
# File 'ruby/IceGrid/Admin.rb', line 464

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

#updateApplication(descriptor, context = nil) ⇒ Object 



460
461
462
 
# File 'ruby/IceGrid/Admin.rb', line 460

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

#updateApplicationWithoutRestart(descriptor, context = nil) ⇒ Object 



468
469
470
 
# File 'ruby/IceGrid/Admin.rb', line 468

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

#updateObject(obj, context = nil) ⇒ Object 



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

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