Admin.ice

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
 
#pragma once
 
[["cpp:dll-export:ICEGRID_API"]]
[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
[["cpp:header-ext:h"]]
[["cpp:include:IceGrid/Config.h"]]
 
[["ice-prefix"]]
 
[["js:module:ice"]]
[["js:cjs-module"]]
 
[["objc:dll-export:ICEGRID_API"]]
[["objc:header-dir:objc"]]
 
[["python:pkgdir:IceGrid"]]
 
#include <Ice/Identity.ice>
#include <Ice/BuiltinSequences.ice>
#include <Ice/Properties.ice>
#include <Ice/SliceChecksumDict.ice>
#include <Glacier2/Session.ice>
#include <IceGrid/Exception.ice>
#include <IceGrid/Descriptor.ice>
 
#ifndef __SLICE2JAVA_COMPAT__
[["java:package:com.zeroc"]]
#endif
 
["objc:prefix:ICEGRID"]
module IceGrid
{
 
enum ServerState
{
    Inactive,
 
    Activating,
 
    ActivationTimedOut,
 
    Active,
 
    Deactivating,
 
    Destroying,
 
    Destroyed
}
 
dictionary<string, Object*> StringObjectProxyDict;
 
["cpp:comparable"]
struct ObjectInfo
{
    Object* proxy;
 
    string type;
}
 
sequence<ObjectInfo> ObjectInfoSeq;
 
["cpp:comparable"]
struct AdapterInfo
{
    string id;
 
    Object* proxy;
 
    string replicaGroupId;
}
 
sequence<AdapterInfo> AdapterInfoSeq;
 
struct ServerInfo
{
    string application;
 
    string uuid;
 
    int revision;
 
    string node;
 
    ServerDescriptor descriptor;
 
    string sessionId;
}
 
struct NodeInfo
{
    string name;
 
    string os;
 
    string hostname;
 
    string release;
 
    string version;
 
    string machine;
 
    int nProcessors;
 
    string dataDir;
}
 
struct RegistryInfo
{
    string name;
 
    string hostname;
}
 
sequence<RegistryInfo> RegistryInfoSeq;
 
struct LoadInfo
{
    float avg1;
 
    float avg5;
 
    float avg15;
}
 
struct ApplicationInfo
{
    string uuid;
 
    long createTime;
 
    string createUser;
 
    long updateTime;
 
    string updateUser;
 
    int revision;
 
    ApplicationDescriptor descriptor;
}
 
["java:type:java.util.LinkedList<ApplicationInfo>"] sequence<ApplicationInfo> ApplicationInfoSeq;
 
struct ApplicationUpdateInfo
{
    long updateTime;
 
    string updateUser;
 
    int revision;
 
    ApplicationUpdateDescriptor descriptor;
}
 
interface Admin
{
    void addApplication(ApplicationDescriptor descriptor)
        throws AccessDeniedException, DeploymentException;
 
    void syncApplication(ApplicationDescriptor descriptor)
        throws AccessDeniedException, DeploymentException, ApplicationNotExistException;
 
    void updateApplication(ApplicationUpdateDescriptor descriptor)
        throws AccessDeniedException, DeploymentException, ApplicationNotExistException;
 
    void syncApplicationWithoutRestart(ApplicationDescriptor descriptor)
        throws AccessDeniedException, DeploymentException, ApplicationNotExistException;
 
    void updateApplicationWithoutRestart(ApplicationUpdateDescriptor descriptor)
        throws AccessDeniedException, DeploymentException, ApplicationNotExistException;
 
    void removeApplication(string name)
        throws AccessDeniedException, DeploymentException, ApplicationNotExistException;
 
    void instantiateServer(string application, string node, ServerInstanceDescriptor desc)
        throws AccessDeniedException, ApplicationNotExistException, DeploymentException;
 
    ["amd"] void patchApplication(string name, bool shutdown)
        throws ApplicationNotExistException, PatchException;
 
    ["nonmutating", "cpp:const"] idempotent ApplicationInfo getApplicationInfo(string name)
        throws ApplicationNotExistException;
 
    ["nonmutating", "cpp:const"] idempotent ApplicationDescriptor getDefaultApplicationDescriptor()
        throws DeploymentException;
 
    ["nonmutating", "cpp:const"] idempotent Ice::StringSeq getAllApplicationNames();
 
    ["nonmutating", "cpp:const"] idempotent ServerInfo getServerInfo(string id)
        throws ServerNotExistException;
 
    ["nonmutating", "cpp:const"] idempotent ServerState getServerState(string id)
        throws ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    ["nonmutating", "cpp:const"] idempotent int getServerPid(string id)
        throws ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    ["cpp:const"]
    idempotent string getServerAdminCategory();
 
    ["cpp:const"]
    idempotent Object* getServerAdmin(string id)
        throws ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    idempotent void enableServer(string id, bool enabled)
        throws ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    ["nonmutating", "cpp:const"] idempotent bool isServerEnabled(string id)
        throws ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    ["amd"] void startServer(string id)
        throws ServerNotExistException, ServerStartException, NodeUnreachableException, DeploymentException;
 
    ["amd"] void stopServer(string id)
        throws ServerNotExistException, ServerStopException, NodeUnreachableException, DeploymentException;
 
    ["amd"] void patchServer(string id, bool shutdown)
        throws ServerNotExistException, NodeUnreachableException, DeploymentException, PatchException;
 
    void sendSignal(string id, string signal)
       throws ServerNotExistException, NodeUnreachableException, DeploymentException, BadSignalException;
 
    ["nonmutating", "cpp:const"] idempotent Ice::StringSeq getAllServerIds();
 
    ["nonmutating", "cpp:const"] idempotent AdapterInfoSeq getAdapterInfo(string id)
        throws AdapterNotExistException;
 
    void removeAdapter(string id)
        throws AdapterNotExistException, DeploymentException;
 
    ["nonmutating", "cpp:const"] idempotent Ice::StringSeq getAllAdapterIds();
 
    void addObject(Object* obj)
        throws ObjectExistsException, DeploymentException;
 
    void updateObject(Object* obj)
        throws ObjectNotRegisteredException, DeploymentException;
 
    void addObjectWithType(Object* obj, string type)
        throws ObjectExistsException, DeploymentException;
 
    void removeObject(Ice::Identity id)
        throws ObjectNotRegisteredException, DeploymentException;
 
    ["nonmutating", "cpp:const"] idempotent ObjectInfo getObjectInfo(Ice::Identity id)
        throws ObjectNotRegisteredException;
 
    ["nonmutating", "cpp:const"] idempotent ObjectInfoSeq getObjectInfosByType(string type);
 
    ["nonmutating", "cpp:const"] idempotent ObjectInfoSeq getAllObjectInfos(string expr);
 
    ["nonmutating", "cpp:const"] idempotent bool pingNode(string name)
        throws NodeNotExistException;
 
    ["nonmutating", "cpp:const"] idempotent LoadInfo getNodeLoad(string name)
        throws NodeNotExistException, NodeUnreachableException;
 
    ["nonmutating", "cpp:const"] idempotent NodeInfo getNodeInfo(string name)
        throws NodeNotExistException, NodeUnreachableException;
 
    ["cpp:const"] idempotent Object* getNodeAdmin(string name)
         throws NodeNotExistException, NodeUnreachableException;
 
    ["nonmutating", "cpp:const"] idempotent int getNodeProcessorSocketCount(string name)
        throws NodeNotExistException, NodeUnreachableException;
 
    void shutdownNode(string name)
        throws NodeNotExistException, NodeUnreachableException;
 
    ["nonmutating", "cpp:const"] idempotent string getNodeHostname(string name)
        throws NodeNotExistException, NodeUnreachableException;
 
    ["nonmutating", "cpp:const"] idempotent Ice::StringSeq getAllNodeNames();
 
    ["cpp:const"] idempotent bool pingRegistry(string name)
        throws RegistryNotExistException;
 
    ["cpp:const"] idempotent RegistryInfo getRegistryInfo(string name)
        throws RegistryNotExistException, RegistryUnreachableException;
 
    ["cpp:const"] idempotent Object* getRegistryAdmin(string name)
        throws RegistryNotExistException;
 
    idempotent void shutdownRegistry(string name)
        throws RegistryNotExistException, RegistryUnreachableException;
 
    ["cpp:const"] idempotent Ice::StringSeq getAllRegistryNames();
 
    void shutdown();
 
    ["nonmutating", "cpp:const"] idempotent Ice::SliceChecksumDict getSliceChecksums();
}
 
interface FileIterator
{
    bool read(int size, out Ice::StringSeq lines)
        throws FileNotAvailableException;
 
    void destroy();
}
 
struct ServerDynamicInfo
{
    string id;
 
    ServerState state;
 
    int pid;
 
    bool enabled;
}
 
["java:type:java.util.LinkedList<ServerDynamicInfo>"] sequence<ServerDynamicInfo> ServerDynamicInfoSeq;
 
struct AdapterDynamicInfo
{
    string id;
 
    Object* proxy;
}
 
["java:type:java.util.LinkedList<AdapterDynamicInfo>"] sequence<AdapterDynamicInfo> AdapterDynamicInfoSeq;
 
struct NodeDynamicInfo
{
    NodeInfo info;
 
    ServerDynamicInfoSeq servers;
 
    AdapterDynamicInfoSeq adapters;
}
 
interface RegistryObserver
{
    void registryInit(RegistryInfoSeq registries);
 
    void registryUp(RegistryInfo node);
 
    void registryDown(string name);
}
 
sequence<NodeDynamicInfo> NodeDynamicInfoSeq;
 
interface NodeObserver
{
    void nodeInit(NodeDynamicInfoSeq nodes);
 
    void nodeUp(NodeDynamicInfo node);
 
    void nodeDown(string name);
 
    void updateServer(string node, ServerDynamicInfo updatedInfo);
 
     void updateAdapter(string node, AdapterDynamicInfo updatedInfo);
}
 
interface ApplicationObserver
{
    void applicationInit(int serial, ApplicationInfoSeq applications);
 
    void applicationAdded(int serial, ApplicationInfo desc);
 
    void applicationRemoved(int serial, string name);
 
    void applicationUpdated(int serial, ApplicationUpdateInfo desc);
}
 
interface AdapterObserver
{
    void adapterInit(AdapterInfoSeq adpts);
 
    void adapterAdded(AdapterInfo info);
 
    void adapterUpdated(AdapterInfo info);
 
    void adapterRemoved(string id);
}
 
interface ObjectObserver
{
    void objectInit(ObjectInfoSeq objects);
 
    void objectAdded(ObjectInfo info);
 
    void objectUpdated(ObjectInfo info);
 
    void objectRemoved(Ice::Identity id);
}
 
interface AdminSession extends Glacier2::Session
{
    idempotent void keepAlive();
 
    ["nonmutating", "cpp:const"] idempotent Admin* getAdmin();
 
    ["cpp:const"] idempotent Object* getAdminCallbackTemplate();
 
    idempotent void setObservers(RegistryObserver* registryObs, NodeObserver* nodeObs, ApplicationObserver* appObs,
                                 AdapterObserver* adptObs, ObjectObserver* objObs)
        throws ObserverAlreadyRegisteredException;
 
    idempotent void setObserversByIdentity(Ice::Identity registryObs, Ice::Identity nodeObs, Ice::Identity appObs,
                                           Ice::Identity adptObs, Ice::Identity objObs)
        throws ObserverAlreadyRegisteredException;
 
    int startUpdate()
        throws AccessDeniedException;
 
    void finishUpdate()
        throws AccessDeniedException;
 
    ["cpp:const"] idempotent string getReplicaName();
 
    FileIterator* openServerLog(string id, string path, int count)
        throws FileNotAvailableException, ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    FileIterator* openServerStdErr(string id, int count)
        throws FileNotAvailableException, ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    FileIterator* openServerStdOut(string id, int count)
        throws FileNotAvailableException, ServerNotExistException, NodeUnreachableException, DeploymentException;
 
    FileIterator* openNodeStdErr(string name, int count)
        throws FileNotAvailableException, NodeNotExistException, NodeUnreachableException;
 
    FileIterator* openNodeStdOut(string name, int count)
        throws FileNotAvailableException, NodeNotExistException, NodeUnreachableException;
 
    FileIterator* openRegistryStdErr(string name, int count)
        throws FileNotAvailableException, RegistryNotExistException, RegistryUnreachableException;
 
    FileIterator * openRegistryStdOut(string name, int count)
        throws FileNotAvailableException, RegistryNotExistException, RegistryUnreachableException;
 
}
 
}