Admin.ice

Go to the documentation of this file.

// **********************************************************************
//
// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

#pragma once

[["cpp:header-ext:h", "objc:header-dir:objc", "js:ice-build"]]
[["cpp:include:IceGrid/Config.h"]]

#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>

["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();
};

interface RegistryObserver;
interface NodeObserver;
interface ApplicationObserver;
interface AdapterObserver;
interface ObjectObserver;

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;

};

};