percyclient.h

// Percy++ Copyright 2007,2012,2013,2014
// Ian Goldberg <iang@cs.uwaterloo.ca>,
// Casey Devet <cjdevet@uwaterloo.ca>,
// Paul Hendry <pshendry@uwaterloo.ca>,
// Ann Yang <y242yang@uwaterloo.ca>,
// Ryan Henry <rhenry@cs.uwaterloo.ca>
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of version 2 of the GNU General Public License as
// published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// There is a copy of the GNU General Public License in the COPYING file
// packaged with this plugin; if you cannot find it, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA

#ifndef __PERCYCLIENT_H__
#define __PERCYCLIENT_H__

#include <vector>
#include <set>
#include <iostream>
#include <string.h>
#include "percyresult.h"
#include "percyparams.h"
#include "percystats.h"
#include "percyio.h"

class PercyClient {
public:
    virtual ~PercyClient ();

    static PercyClient * make_client (const PercyClientParams * clientparams, 
        nservers_t num_servers, nservers_t t, sid_t * sids = NULL,
        PercyStats * stats = NULL);

    nqueries_t encode_request (vector<dbsize_t> block_numbers, 
        nqueries_t querybsize = 1);

    dbsize_t send_request(nqueries_t request_identifier, 
        std::vector<ostream*> &osvec, bool send_num_queries = true);

    dbsize_t receive_replies(nqueries_t request_identifier,
        std::vector<istream*> &isvec);

    nqueries_t process_replies(nservers_t h);

    // If the request is finished (fully and successfully processed by
    // process_replies), return true and put results in the results vector.
    // The results are then removed from the server (no longer stored in this
    // class).  Otherwise, return false and nothing is done to results.
    bool get_result (nqueries_t request_identifier,
        vector<PercyBlockResults> & results);

    bool fetch_blocks(nqueries_t& request_identifier, 
        vector<dbsize_t> block_numbers, vector<ostream*> &osvec, 
        vector<istream*> &isvec, vector<PercyBlockResults> &results, 
        nqueries_t querybsize = 1);

protected:
    friend class RecursiveClient;

    const vector<dbsize_t>& get_block_numbers (nqueries_t request_identifier) {
    return requested_blocks[request_identifier];
    }

    nqueries_t get_qbs (nqueries_t request_identifier) {
    return blocks_per_query[request_identifier];
    }

    virtual void encode_request_impl (nqueries_t request_identifier) = 0;

    virtual dbsize_t send_request_impl (nqueries_t request_identifier,
        vector<ostream*> &osvec, bool send_num_queries = true) = 0;

    virtual dbsize_t receive_replies_impl (nqueries_t request_identifier,
        vector<istream*> &isvec) = 0;

    virtual nqueries_t process_replies_impl (nservers_t h, 
        vector<vector<PercyResult> >& results) = 0;

    PercyClient (const PercyClientParams * clientparams, nservers_t num_servers,
        nservers_t t, PercyStats * stats = NULL);

    const PercyClientParams * clientparams;
    nservers_t num_servers;
    nservers_t t;
    vector<nservers_t> goodservers;
    static const bool randomize = true;

private:
    typedef map<nqueries_t, vector<dbsize_t> > BlockNumbers;
    typedef map<nqueries_t, vector<PercyBlockResults> > BlockResults;
    enum RequestStatus { ENCODE, SEND, RECEIVE, DECODE, INCOMPLETE, DONE };
    typedef map<nqueries_t, RequestStatus> RequestStatuses;

    nqueries_t next_request_identifier;
    BlockNumbers requested_blocks;
    std::map<nqueries_t, nqueries_t> blocks_per_query;
    RequestStatuses statuses;
    BlockNumbers undecoded_blocks;
    BlockResults decoded_blocks;

    PercyStats * stats;
    map<nqueries_t, nqueries_t> request_id_to_stats_batch_number;
};

inline ostream& operator<<(ostream &out, vector<dbsize_t> v) {
    out << "<";
    for (vector<dbsize_t>::const_iterator i=v.begin();
        i != v.end(); ++i) {
    out << " " << *i;
    }
    out << " >";
    return out;
}

#endif