worker.cpp

#include "worker.h"
#include "helpers/string_to_hex.h"

class multiple_string_matcher : public header_matcher
{
public:
    static const char delimiter = '|';

    multiple_string_matcher(std::string my_value) : header_matcher(my_value)
    {
    }

    virtual ~multiple_string_matcher()
    {
    }

    virtual bool match(const std::string &value)
    {
        size_t offset = 0;

        while (offset < value.size()) {
            size_t end = value.find(delimiter, offset);

            if (end == std::string::npos) {
                end = value.size();
            }

            if (value.compare(offset, end - offset, my_value_) == 0) {
                return true;
            }

            offset = end + 1;
        }

        return false;
    }
};

class count_matcher : public header_matcher
{
private:
    size_t my_count_;

public:
    count_matcher(std::string my_value) : my_count_(std::stoul(my_value)), header_matcher(my_value)
    {
    }

    virtual ~count_matcher()
    {
    }

    virtual bool match(const std::string &value)
    {
        return my_count_ >= std::stoul(value);
    }
};


worker::worker(
    const std::string &id, const std::string &hwgroup, const std::multimap<std::string, std::string> &headers)
    : identity(id), hwgroup(hwgroup), free_(true), current_request_(nullptr), headers_copy_(headers)
{
    headers_.emplace("hwgroup", std::unique_ptr<header_matcher>(new multiple_string_matcher(hwgroup)));

    for (auto it : headers) {
        auto matcher = std::unique_ptr<header_matcher>(new header_matcher(it.second));

        if (it.first == "threads") {
            matcher = std::unique_ptr<header_matcher>(new count_matcher(it.second));
        }

        headers_.emplace(it.first, std::move(matcher));
    }
}

worker::~worker()
{
}

void worker::enqueue_request(request_ptr request)
{
    request_queue_.push(request);
}

void worker::complete_request()
{
    free_ = true;
    current_request_ = nullptr;
}

worker::request_ptr worker::cancel_request()
{
    auto request = current_request_;

    if (request != nullptr) {
        request->failure_count += 1;
    }

    complete_request();
    return request;
}

bool worker::next_request()
{
    if (free_ && !request_queue_.empty()) {
        current_request_ = request_queue_.front();
        request_queue_.pop();
        free_ = false;

        return true;
    }

    return false;
}

std::shared_ptr<const request> worker::get_current_request() const
{
    return current_request_;
}

std::shared_ptr<std::vector<worker::request_ptr>> worker::terminate()
{
    auto result = std::make_shared<std::vector<worker::request_ptr>>();

    if (current_request_ != nullptr) {
        current_request_->failure_count += 1;
        result->push_back(current_request_);
    }

    current_request_ = nullptr;

    while (!request_queue_.empty()) {
        result->push_back(request_queue_.front());
        request_queue_.pop();
    }

    return result;
}

bool worker::check_header(const std::string &header, const std::string &value)
{
    // Find all worker headers with the right name
    auto range = headers_.equal_range(header);
    for (auto &worker_header = range.first; worker_header != range.second; ++worker_header) {
        // If any of these headers has a matching value, return true
        if (worker_header->second->match(value)) {
            return true;
        }
    }

    // If we found nothing, return false
    return false;
}


bool worker::headers_equal(const std::multimap<std::string, std::string> &other)
{
    return other == headers_copy_;
}

std::string worker::get_description() const
{
    if (description == "") {
        return helpers::string_to_hex(identity);
    } else {
        return helpers::string_to_hex(identity) + " (" + description + ")";
    }
}