ibrdtn/ibrdtn/api/APIClient.h

Go to the documentation of this file.

/*
 * APIClient.h
 *
 *  Created on: 01.07.2011
 *      Author: morgenro
 */

#ifndef APICLIENT_H_
#define APICLIENT_H_

#include "ibrdtn/api/Bundle.h"
#include "ibrdtn/data/BundleID.h"
#include <ibrcommon/net/tcpstream.h>
#include <ibrcommon/Exceptions.h>

namespace dtn
{
        namespace api
        {
                class APIClient
                {
                public:
                        enum STATUS_CODES
                        {
                                API_STATUS_CONTINUE = 100,
                                API_STATUS_OK = 200,
                                API_STATUS_CREATED = 201,
                                API_STATUS_ACCEPTED = 202,
                                API_STATUS_FOUND = 302,
                                API_STATUS_BAD_REQUEST = 400,
                                API_STATUS_UNAUTHORIZED = 401,
                                API_STATUS_FORBIDDEN = 403,
                                API_STATUS_NOT_FOUND = 404,
                                API_STATUS_NOT_ALLOWED = 405,
                                API_STATUS_NOT_ACCEPTABLE = 406,
                                API_STATUS_CONFLICT = 409,
                                API_STATUS_INTERNAL_ERROR = 500,
                                API_STATUS_NOT_IMPLEMENTED = 501,
                                API_STATUS_SERVICE_UNAVAILABLE = 503,
                                API_STATUS_VERSION_NOT_SUPPORTED = 505,
                                API_STATUS_NOTIFY_COMMON = 600,
                                API_STATUS_NOTIFY_NEIGHBOR = 601,
                                API_STATUS_NOTIFY_BUNDLE = 602,
                        };

                        class Message
                        {
                        public:
                                Message(STATUS_CODES code, const std::string &msg);
                                virtual ~Message();

                                const STATUS_CODES code;
                                const std::string msg;
                        };

                        APIClient(ibrcommon::tcpstream &stream);

                        virtual ~APIClient();

                        void connect();

                        void setEndpoint(const std::string &endpoint);

                        void subscribe(const dtn::data::EID &eid);

                        void unsubscribe(const dtn::data::EID &eid);

                        std::list<dtn::data::EID> getSubscriptions();

                        virtual dtn::api::Bundle get(dtn::data::BundleID &id);

                        virtual dtn::api::Bundle get();

                        virtual void send(const dtn::api::Bundle &bundle);

                        Message wait();

                        void unblock_wait();

                        void notify_delivered(const dtn::api::Bundle &b);
                        void notify_delivered(const dtn::data::BundleID &id);

                protected:
                        virtual void register_put(const dtn::data::Bundle &bundle);

                        virtual void register_clear();

                        virtual void register_free();

                        virtual void register_store();

                        virtual void register_send();

                        virtual dtn::data::Bundle register_get();

                        // receive the response (queue notifies into the queue)
                        virtual int __get_return();

                        // receive the next notify
                        Message __get_message();

                        static dtn::data::BundleID readBundleID(const std::string &data);

                        // tcp stream reference to send/receive data to the daemon
                        ibrcommon::tcpstream &_stream;

                        // notify queue
                        ibrcommon::Conditional _queue_cond;
                        bool _get_busy;
                        std::queue<Message> _notify_queue;
                        std::queue<Message> _status_queue;
                };
        }
}

#endif /* APICLIENT_H_ */