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;
 
}
 
}