Distributor.h

Go to the documentation of this file.

/* 
 * File:   Distributor.h
 * Author: fermat
 *
 * Created on 20. Januar 2010, 10:34
 */

#ifndef _DISTRIBUTOR_H
#define _DISTRIBUTOR_H

#include <vector>
#include <list>
#include <string>
#include "Disk.h"
#include <ostream>
#include <cstring>
#include <gcrypt.h>


namespace VDRIVE {

    class Distributor {
    private:
        uint8_t *baseMessage;

        uint16_t numThreads;

        bool internelHash;

        int internalHashAlgorithm;

        int gcryptHashAlgorithm;

    public:
        const static int32_t SHARE = 1;
        const static int32_t NEAREST_NEIGHBOUR = 2;
        const static int32_t REDUNDANT_SHARE = 3;
        const static int32_t REDUNDANT_SHARE_K = 4;
        const static int32_t ROUND_ROBIN = 5;
        const static int32_t RUSH_P = 6;
        const static int32_t CRUSH = 7;

        const static int HASH_SHA1 = 1;

        const static int HASH_XOR = 2;

        const static int HASH_RAND = 3;

        const static int HASH_MT = 4;

        uint64_t a;

        uint64_t b;

        virtual ~Distributor();

        virtual std::list<Disk*>* placeExtent(int64_t virtualVolumeId, int64_t position) = 0;

        virtual void setConfiguration(std::list<Disk*>* disks, int64_t extentsize, int32_t copies) = 0;
        
        virtual void setClusters(std::list<std::list<Disk*>*>* clusters, std::list<uint32_t>* weights)  {};
        virtual void setDisks(std::list<Disk*>* disks) = 0;

        virtual uint8_t* getBaseMessage() const;

        virtual void setBaseMessage(uint8_t* baseMessage);

        uint64_t myMTRand(std::string* data) const;

        uint64_t myRand(std::string* data) const;

        uint64_t myLC(std::string* data) const;

        uint64_t mySHA1(std::string* data) const;

        uint64_t gcrypt(std::string* data) const;

        double hashFunction(std::string *data) const;

        uint64_t hashFunctionInt64(std::string *data) const;

        virtual std::list<Disk*>* getDisks() const = 0;

        virtual int64_t getExtentsize() const = 0;

        virtual int32_t getCopies() const = 0;

        static Distributor* createDistributor(int32_t distributor, int argc, char** argv);

        static Distributor* loadDistributor(std::string filename);

        virtual xercesc::DOMElement* toXML(xercesc::DOMDocument* doc) const = 0;

        void save(std::string filename) const;

        uint16_t getNumThreads() const {
            return numThreads;
        }

        void setNumThreads(uint16_t numThreads) {
            if (numThreads > 0)
                this->numThreads = numThreads;
        }

        void useInternalHashAlgorithm(int algorithm) {
            internelHash = true;
            internalHashAlgorithm = algorithm;
        }

        bool useGCryptHashAlgorithm(int algorithm) {
            if (gcry_md_test_algo(algorithm) != 0) {
                return false;
            }
            internelHash = false;
            gcryptHashAlgorithm = algorithm;
            return true;
        }

        void usedHashAlgorithm(bool* internal, int* gcryptalgorithm, int* intalgorithm) const {
            *internal = internelHash;
            *gcryptalgorithm = gcryptHashAlgorithm;
            *intalgorithm = internalHashAlgorithm;
        }

    protected:
        Distributor();
    };
}
#endif  /* _DISTRIBUTOR_H */