BundleCore.h

Go to the documentation of this file.

/*
 * BundleCore.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 BUNDLECORE_H_
#define BUNDLECORE_H_

#include "Component.h"
#include "Configuration.h"

#include "core/EventReceiver.h"
#include "core/StatusReportGenerator.h"
#include "storage/BundleStorage.h"
#include "core/WallClock.h"
#include "routing/BaseRouter.h"
#include "core/BundleFilter.h"

#include "net/ConnectionManager.h"
#include "net/ConvergenceLayer.h"
#include "net/DiscoveryAgent.h"

#include "routing/QueueBundleEvent.h"
#include "core/BundlePurgeEvent.h"
#include "net/TransferCompletedEvent.h"
#include "net/TransferAbortedEvent.h"

#include <ibrdtn/data/Serializer.h>
#include <ibrdtn/data/EID.h>

#include <ibrcommon/thread/RWMutex.h>
#include <ibrcommon/link/LinkManager.h>

#include <vector>
#include <set>
#include <map>
#include "BundleFilterTable.h"

using namespace dtn::data;

namespace dtn
{
        namespace core
        {
                class P2PDialupException : public ibrcommon::Exception
                {
                        public:
                                P2PDialupException(string what = "No path known except of dial-up connections.") throw() : Exception(what)
                                {
                                };
                };

                class BundleCore
                  : public dtn::daemon::IntegratedComponent, public dtn::data::Validator, public ibrcommon::LinkManager::EventCallback, public dtn::daemon::Configuration::OnChangeListener,
                    public dtn::core::EventReceiver<dtn::routing::QueueBundleEvent>, public dtn::core::EventReceiver<dtn::core::BundlePurgeEvent>, public dtn::core::EventReceiver<dtn::net::TransferCompletedEvent>, public dtn::core::EventReceiver<dtn::net::TransferAbortedEvent>
                {
                        static const std::string TAG;

                public:
                        static dtn::data::EID local;

                        static BundleCore& getInstance();

                        WallClock& getClock();

                        virtual void onConfigurationChanged(const dtn::daemon::Configuration &conf) throw ();

                        void setStorage(dtn::storage::BundleStorage *storage);
                        dtn::storage::BundleStorage& getStorage();

                        void setSeeker(dtn::storage::BundleSeeker *seeker);
                        dtn::storage::BundleSeeker& getSeeker();

                        void setRouter(dtn::routing::BaseRouter *router);
                        dtn::routing::BaseRouter& getRouter() const;

                        dtn::net::ConnectionManager& getConnectionManager();

                        dtn::net::DiscoveryAgent& getDiscoveryAgent();

                        void addRoute(const dtn::data::EID &destination, const dtn::data::EID &nexthop, const dtn::data::Timeout timeout = 0);

                        void removeRoute(const dtn::data::EID &destination, const dtn::data::EID &nexthop);

                        bool isGloballyConnected() const;

                        void raiseEvent(const dtn::routing::QueueBundleEvent &evt) throw ();
                        void raiseEvent(const dtn::core::BundlePurgeEvent &evt) throw ();
                        void raiseEvent(const dtn::net::TransferCompletedEvent &evt) throw ();
                        void raiseEvent(const dtn::net::TransferAbortedEvent &evt) throw ();

                        virtual void validate(const dtn::data::PrimaryBlock &obj) const throw (RejectedException);
                        virtual void validate(const dtn::data::Block &obj, const dtn::data::Number&) const throw (RejectedException);
                        virtual void validate(const dtn::data::PrimaryBlock &bundle, const dtn::data::Block &obj, const dtn::data::Number&) const throw (RejectedException);
                        virtual void validate(const dtn::data::Bundle &obj) const throw (RejectedException);
                        virtual void validate(const dtn::data::MetaBundle &obj) const throw (RejectedException);

                        BundleFilter::ACTION filter(BundleFilter::TABLE table, const FilterContext &context, dtn::data::Bundle &bundle) const;

                        BundleFilter::ACTION evaluate(BundleFilter::TABLE table, const FilterContext &context) const;

                        static dtn::data::Length blocksizelimit;

                        static dtn::data::Length foreign_blocksizelimit;

                        static dtn::data::Length max_lifetime;

                        static dtn::data::Length max_timestamp_future;

                        static bool forwarding;

                        static dtn::data::Size max_bundles_in_transit;

                        virtual const std::string getName() const;

                        static void processBlocks(dtn::data::Bundle &b);

                        void setGloballyConnected(bool val);

                        void eventNotify(const ibrcommon::LinkEvent &evt);

                        static void inject(const dtn::data::EID &source, dtn::data::Bundle &bundle);

                protected:
                        virtual void componentUp() throw ();
                        virtual void componentDown() throw ();

                private:
                        BundleCore();

                        virtual ~BundleCore();

                        void check_connection_state() throw ();

                        void reload_filter_tables() throw ();

                        BundleCore operator=(const BundleCore &k)
                        { return k; };

                        WallClock _clock;

                        dtn::storage::BundleStorage *_storage;
                        dtn::storage::BundleSeeker *_seeker;
                        dtn::routing::BaseRouter *_router;

                        // generator for statusreports
                        StatusReportGenerator _statusreportgen;

                        // manager class for connections
                        dtn::net::ConnectionManager _connectionmanager;

                        // discovery agent handling all the discovery stuff
                        dtn::net::DiscoveryAgent _disco_agent;

                        bool _globally_connected;

                        BundleFilterTable _table_validation;
                        BundleFilterTable _table_input;
                        BundleFilterTable _table_output;
                        BundleFilterTable _table_routing;

                        mutable ibrcommon::RWMutex _filter_mutex;
                };
        }
}

#endif /*BUNDLECORE_H_*/