database.h 8.41 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// Copyright (C) 2011  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#ifndef __DATABASE_DATASRC_H
#define __DATABASE_DATASRC_H

#include <datasrc/client.h>

namespace isc {
namespace datasrc {

23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
/**
 * \brief Abstract connection to database with DNS data
 *
 * This class is defines interface to databases. Each supported database
 * will provide methods for accessing the data stored there in a generic
 * manner. The methods are meant to be low-level, without much or any knowledge
 * about DNS and should be possible to translate directly to queries.
 *
 * On the other hand, how the communication with database is done and in what
 * schema (in case of relational/SQL database) is up to the concrete classes.
 *
 * This class is non-copyable, as copying connections to database makes little
 * sense and will not be needed.
 *
 * \todo Is it true this does not need to be copied? For example the zone
 *     iterator might need it's own copy. But a virtual clone() method might
 *     be better for that than copy constructor.
 *
 * \note The same application may create multiple connections to the same
 *     database. If the database allows having multiple open queries at one
 *     connection, the connection class may share it.
 */
45 46
class DatabaseConnection : boost::noncopyable {
public:
47 48 49 50 51 52
    /**
     * \brief Destructor
     *
     * It is empty, but needs a virtual one, since we will use the derived
     * classes in polymorphic way.
     */
53
    virtual ~DatabaseConnection() { }
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
    /**
     * \brief Retrieve a zone identifier
     *
     * This method looks up a zone for the given name in the database. It
     * should match only exact zone name (eg. name is equal to the zone's
     * apex), as the DatabaseClient will loop trough the labels itself and
     * find the most suitable zone.
     *
     * It is not specified if and what implementation of this method may throw,
     * so code should expect anything.
     *
     * \param name The name of the zone's apex to be looked up.
     * \return The first part of the result indicates if a matching zone
     *     was found. In case it was, the second part is internal zone ID.
     *     This one will be passed to methods finding data in the zone.
     *     It is not required to keep them, in which case whatever might
     *     be returned - the ID is only passed back to the connection as
     *     an opaque handle.
     */
73
    virtual std::pair<bool, int> getZone(const isc::dns::Name& name) const = 0;
74 75 76 77 78 79 80

    /**
     * \brief Starts a new search for records of the given name in the given zone
     *
     * \param zone_id The zone to search in, as returned by getZone()
     * \param name The name of the records to find
     */
81
    virtual void searchForRecords(int zone_id, const std::string& name) = 0;
82 83 84 85 86 87 88 89 90 91 92 93 94 95

    /**
     * \brief Retrieves the next record from the search started with searchForRecords()
     *
     * Returns a boolean specifying whether or not there was more data to read.
     * In the case of a database error, a DatasourceError is thrown.
     *
     * \exception DatasourceError if there was an error reading from the database
     *
     * \param columns This vector will be cleared, and the fields of the record will
     *                be appended here as strings (in the order rdtype, ttl, sigtype,
     *                and rdata). If there was no data, the vector is untouched.
     * \return true if there was a next record, false if there was not
     */
96
    virtual bool getNextRecord(std::vector<std::string>& columns) = 0;
97 98
};

99 100 101 102 103 104 105 106 107 108 109 110 111 112
/**
 * \brief Concrete data source client oriented at database backends.
 *
 * This class (together with corresponding versions of ZoneFinder,
 * ZoneIterator, etc.) translates high-level data source queries to
 * low-level calls on DatabaseConnection. It calls multiple queries
 * if necessary and validates data from the database, allowing the
 * DatabaseConnection to be just simple translation to SQL/other
 * queries to database.
 *
 * While it is possible to subclass it for specific database in case
 * of special needs, it is not expected to be needed. This should just
 * work as it is with whatever DatabaseConnection.
 */
113 114
class DatabaseClient : public DataSourceClient {
public:
115 116 117 118 119
    /**
     * \brief Constructor
     *
     * It initializes the client with a connection.
     *
120
     * \exception isc::InvalidParameter if connection is NULL. It might throw
121 122 123 124 125 126
     * standard allocation exception as well, but doesn't throw anything else.
     *
     * \param connection The connection to use to get data. As the parameter
     *     suggests, the client takes ownership of the connection and will
     *     delete it when itself deleted.
     */
127
    DatabaseClient(boost::shared_ptr<DatabaseConnection> connection);
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
    /**
     * \brief Corresponding ZoneFinder implementation
     *
     * The zone finder implementation for database data sources. Similarly
     * to the DatabaseClient, it translates the queries to methods of the
     * connection.
     *
     * Application should not come directly in contact with this class
     * (it should handle it trough generic ZoneFinder pointer), therefore
     * it could be completely hidden in the .cc file. But it is provided
     * to allow testing and for rare cases when a database needs slightly
     * different handling, so it can be subclassed.
     *
     * Methods directly corresponds to the ones in ZoneFinder.
     */
    class Finder : public ZoneFinder {
    public:
        /**
         * \brief Constructor
         *
         * \param connection The connection (shared with DatabaseClient) to
         *     be used for queries (the one asked for ID before).
         * \param zone_id The zone ID which was returned from
         *     DatabaseConnection::getZone and which will be passed to further
         *     calls to the connection.
         */
154
        Finder(boost::shared_ptr<DatabaseConnection> connection, int zone_id);
155 156
        virtual isc::dns::Name getOrigin() const;
        virtual isc::dns::RRClass getClass() const;
157 158 159 160

        /**
         * \brief Find an RRset in the datasource
         */
161 162 163 164
        virtual FindResult find(const isc::dns::Name& name,
                                const isc::dns::RRType& type,
                                isc::dns::RRsetList* target = NULL,
                                const FindOptions options = FIND_DEFAULT)
165
            const;
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
        /**
         * \brief The zone ID
         *
         * This function provides the stored zone ID as passed to the
         * constructor. This is meant for testing purposes and normal
         * applications shouldn't need it.
         */
        int zone_id() const { return (zone_id_); }
        /**
         * \brief The database connection.
         *
         * This function provides the database connection stored inside as
         * passed to the constructor. This is meant for testing purposes and
         * normal applications shouldn't need it.
         */
        const DatabaseConnection& connection() const {
182
            return (*connection_);
183
        }
184
    private:
185
        boost::shared_ptr<DatabaseConnection> connection_;
186 187 188 189 190 191 192 193 194 195 196 197 198 199
        const int zone_id_;
    };
    /**
     * \brief Find a zone in the database
     *
     * This queries connection's getZone to find the best matching zone.
     * It will propagate whatever exceptions are thrown from that method
     * (which is not restricted in any way).
     *
     * \param name Name of the zone or data contained there.
     * \return Result containing the code and instance of Finder, if anything
     *     is found. Applications should not rely on the specific class being
     *     returned, though.
     */
200 201
    virtual FindResult findZone(const isc::dns::Name& name) const;
private:
202
    /// \brief Our connection.
203
    const boost::shared_ptr<DatabaseConnection> connection_;
204 205 206 207 208 209
};

}
}

#endif