Client.h

Go to the documentation of this file.

/*
 * Client.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
 *
 * 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.
 *
 */

#ifndef CLIENT_H_
#define CLIENT_H_

#include "ibrdtn/data/Number.h"
#include "ibrdtn/data/Bundle.h"
#include "ibrdtn/streams/StreamConnection.h"
#include <ibrcommon/net/socketstream.h>
#include <ibrcommon/thread/Mutex.h>
#include <ibrcommon/thread/MutexLock.h>
#include <ibrcommon/Exceptions.h>
#include <ibrcommon/thread/Queue.h>

namespace dtn
{
        namespace api
        {
                class ConnectionException : public ibrcommon::Exception
                {
                public:
                        ConnectionException(string what = "A connection error occurred.") throw() : ibrcommon::Exception(what)
                        {
                        };
                };

                class ConnectionTimeoutException : public ConnectionException
                {
                public:
                        ConnectionTimeoutException(string what = "Timeout.") throw() : ConnectionException(what)
                        {
                        };
                };

                class ConnectionAbortedException : public ConnectionException
                {
                public:
                        ConnectionAbortedException(string what = "Aborted.") throw() : ConnectionException(what)
                        {
                        };
                };

                class Client : public dtn::streams::StreamConnection, public dtn::streams::StreamConnection::Callback
                {
                private:
                        class AsyncReceiver : public ibrcommon::JoinableThread
                        {
                        public:
                                AsyncReceiver(Client &client);

                                virtual ~AsyncReceiver();

                        protected:
                                void run() throw ();

                                void __cancellation() throw ();

                        private:
                                // member variable for the reference to the client object
                                Client &_client;

                                bool _running;
                        };

                public:
                        enum COMMUNICATION_MODE
                        {
                                MODE_BIDIRECTIONAL = 0,         
                                MODE_SENDONLY = 1                       
                        };

                        Client(const std::string &app, ibrcommon::socketstream &stream, const COMMUNICATION_MODE mode = MODE_BIDIRECTIONAL);
                        Client(const std::string &app, const dtn::data::EID &group, ibrcommon::socketstream &stream, const COMMUNICATION_MODE mode = MODE_BIDIRECTIONAL);

                        virtual ~Client();

                        void connect();

                        void close();

                        void abort();

                        virtual void eventConnectionDown() throw ();

                        virtual void eventBundleAck(const dtn::data::Length &ack) throw ();

                        virtual void eventShutdown(StreamConnection::ConnectionShutdownCases) throw () {};

                        virtual void eventTimeout() throw () {};

                        virtual void eventError() throw () {};

                        virtual void eventConnectionUp(const dtn::streams::StreamContactHeader&) throw () {};

                        virtual void eventBundleRefused() throw () {};

                        virtual void eventBundleForwarded() throw () {};

                        void operator<<(const dtn::data::Bundle &b);

                        dtn::data::Bundle getBundle(const dtn::data::Timeout timeout = 0) throw (ConnectionException);

                        // public variable
                        dtn::data::Length lastack;

                protected:
                        virtual void received(const dtn::streams::StreamContactHeader&) {};

                        virtual void received(const dtn::data::Bundle &b);

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

                        // communication mode flags
                        COMMUNICATION_MODE _mode;

                        // own application suffix
                        std::string _app;

                        // group to join
                        dtn::data::EID _group;

                        // The asynchronous receiver thread which receives incoming bundles
                        Client::AsyncReceiver _receiver;

                        // the queue for incoming bundles, when used in synchronous mode
                        ibrcommon::Queue<dtn::data::Bundle> _inqueue;
                };
        }
}

#endif /* CLIENT_H_ */