DobbyProxy.h

/*
* If not stated otherwise in this file or this component's LICENSE file the
* following copyright and licenses apply:
*
* Copyright 2016 Sky UK
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
 * DobbyProxy.h
 * Author:
 *
 */
#ifndef DOBBYPROXY_H
#define DOBBYPROXY_H
 
 
#if defined(DOBBY_BUILD)
#include <Dobby/IDobbyProxy.h>
#include <IIpcService.h>
#include <IDGenerator.h>
#else
#include <Dobby/Public/Dobby/IDobbyProxy.h>
#include <Dobby/IpcService/IIpcService.h>
#include <Dobby/IDGenerator.h>
#endif
 
#include <string>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <deque>
 
 
// -----------------------------------------------------------------------------
class DobbyProxy : public IDobbyProxy
{
public:
    DobbyProxy(const std::shared_ptr<AI_IPC::IIpcService>& ipcService,
               const std::string& serviceName,
               const std::string& objectName);
    ~DobbyProxy() final;
 
public:
    // Admin interface
    bool shutdown() const override;
 
    bool ping() const override;
 
    bool isAlive(const std::chrono::milliseconds& timeout) const override;
 
    bool setLogMethod(uint32_t method, int pipeFd) const override;
 
    bool setLogLevel(int level) const override;
 
    bool setAIDbusAddress(bool privateBus,
                          const std::string& address) const override;
 
public:
    // Control interface
    int32_t startContainerFromSpec(const std::string& id,
                                   const std::string& jsonSpec,
                                   const std::list<int>& files,
                                   const std::string& command = "",
                                   const std::string& displaySocket = "",
                                   const std::vector<std::string>& envVars = std::vector<std::string>()) const override;
 
 
    int32_t startContainerFromBundle(const std::string& id,
                                     const std::string& bundlePath,
                                     const std::list<int>& files,
                                     const std::string& command = "",
                                     const std::string& displaySocket = "",
                                     const std::vector<std::string>& envVars = std::vector<std::string>()) const override;
 
    bool stopContainer(int32_t cd, bool withPrejudice) const override;
 
    bool pauseContainer(int32_t cd) const override;
 
    bool resumeContainer(int32_t cd) const override;
 
    bool hibernateContainer(int32_t descriptor, const std::string& options) const override;
 
    bool wakeupContainer(int32_t descriptor) const override;
    
    bool addContainerMount(int32_t descriptor, 
                           const std::string& source, 
                           const std::string& destination,  
                           const std::vector<std::string>& mountFlags, 
                           const std::string& mountData) const override;
    
    bool addAnnotation(int32_t cd,
                       const std::string& key,
                       const std::string& value) const override;
 
    bool removeAnnotation(int32_t cd,
                       const std::string& key) const override;
 
    bool removeContainerMount(int32_t descriptor, const std::string& source) const override;
 
    bool execInContainer(int32_t cd,
                         const std::string& options,
                         const std::string& command) const override;
 
    int getContainerState(int32_t cd) const override;
 
    int registerListener(const StateChangeListener &listener, const void* cbParams) override;
 
    void unregisterListener(int tag) override;
 
    std::string getContainerInfo(int32_t descriptor) const override;
 
    std::list<std::pair<int32_t, std::string>> listContainers() const override;
 
#if (AI_BUILD_TYPE == AI_DEBUG)
 
public:
    // Debug interface
    bool createBundle(const std::string& id,
                      const std::string& jsonSpec) const override;
 
    std::string getSpec(int32_t descriptor) const override;
 
    std::string getOCIConfig(int32_t descriptor) const override;
 
#if (AI_ENABLE_TRACING)
    bool startInProcessTracing(int traceFileFd,
                               const std::string &categoryFilter) const override;
 
    bool stopInProcessTracing() const override;
#endif // (AI_ENABLE_TRACING)
 
#endif // (AI_BUILD_TYPE == AI_DEBUG)
 
private:
    void onContainerStartedEvent(const AI_IPC::VariantList& args);
    void onContainerStoppedEvent(const AI_IPC::VariantList& args);
    void onContainerHibernatedEvent(const AI_IPC::VariantList& args);
    void onContainerAwokenEvent(const AI_IPC::VariantList& args);
 
private:
    bool invokeMethod(const char *interface_, const char *method_,
                      const AI_IPC::VariantList& params_,
                      AI_IPC::VariantList& returns_) const;
 
    void containerStateChangeThread();
 
private:
    const std::shared_ptr<AI_IPC::IIpcService> mIpcService;
    const std::string mServiceName;
    const std::string mObjectName;
 
private:
    std::string mContainerStartedSignal;
    std::string mContainerStoppedSignal;
 
private:
    std::thread mStateChangeThread;
    std::mutex mStateChangeLock;
    std::condition_variable mStateChangeCond;
 
    struct StateChangeEvent
    {
        enum Type { Terminate, ContainerStarted, ContainerStopped, ContainerHibernated, ContainerAwoken };
 
        explicit StateChangeEvent(Type type_)
            : type(type_), descriptor(-1)
        { }
 
        StateChangeEvent(Type type_, int32_t descriptor_, const std::string& name_)
            : type(type_), descriptor(descriptor_), name(name_)
        { }
 
        Type type;
        int32_t descriptor;
        std::string name;
    };
 
    std::deque<StateChangeEvent> mStateChangeQueue;
 
    std::mutex mListenersLock;
    AICommon::IDGenerator<8> mListenerIdGen;
    std::map<int, std::pair<StateChangeListener, const void*>> mListeners;
 
};
 
 
 
#endif // !defined(DOBBYPROXY_H)