toast/log/rotation_policies.hpp

Go to the documentation of this file.

#ifndef toast_log_rotation_policies_hpp_INCLUDED
#define toast_log_rotation_policies_hpp_INCLUDED

#include <iostream>
#include <boost/lexical_cast.hpp>
#include <boost/filesystem.hpp>
#include <toast/concept_check.hpp>
#include <toast/contracts.hpp>

#include <cstdio>

namespace toast {
namespace log {

namespace size {
        const unsigned int KB = 1024;
        const unsigned int MB = KB * KB;
        const unsigned int GB = KB * KB * KB;
        const unsigned int TB = KB * KB * KB * KB;
}
    
template <typename Policy>
struct RotationCheckPolicyConcept
{
        void constraints() {
                bool a = p.test(100);
                Policy_Sub p_sub;
        }

private:
        class Policy_Sub : public Policy
        {
                public:
                Policy_Sub()
                {
                        const char f[10] = "blah";
                        Policy::test(f);
                        Policy::reset();
                }
        };
        Policy p;
};

struct never_rotate {
        static bool test(unsigned int) { return (false); }
protected:
        static bool test(const char*) { return (false); }
        static void reset() { return; }
        ~never_rotate() {}
};

struct message_limit {
        message_limit() : max_messages_(0), messages_(0) {}
        void max_messages(unsigned int messages) { max_messages_ = messages; }
        bool test(unsigned int)
        {
                ++messages_;

                if (max_messages_ && messages_ >= max_messages_) {
                        messages_ = 0;
                        return (true);
                }

                return (false);
        }
protected:
        static bool test(const char*) { return (false); }
        void reset() { messages_ = 0; }
        unsigned int max_messages_;
        unsigned int messages_;
        ~message_limit() {}
};

struct max_file_size {
        max_file_size() : max_size_(0), aggregate_(0) {}
        void max_size(unsigned int size) { max_size_ = size; }
        bool test(unsigned int size)
        {
                aggregate_ += size;

                if (max_size_ && aggregate_ >= max_size_) {
                        aggregate_ = 0;
                        return (true);
                }

                return (false);
        }

protected:
        bool test(const char* f)
        {
                FILE* pf = 0;
                pf = std::fopen(f, "rb");

                if (!pf) return (false);

                std::fseek(pf, 0, SEEK_END);
                long size = std::ftell(pf);
                std::fclose(pf);

                return (test(size));
        }
        void reset() { aggregate_ = 0; }
        unsigned int max_size_;
        unsigned int aggregate_;
        ~max_file_size() {}
};

template <typename Policy>
struct RotationImplPolicyConcept
{
        void constraints() {
                Policy_Sub p;
        }
private:
        class Policy_Sub : public Policy 
        {
                public:
                Policy_Sub() 
                { 
                        const char f[10] = "blah";
                        Policy::rotate(f);                              
                }
        };
};

struct roll_rotation 
{
        roll_rotation() : max_rotated_(2) {}
        void max_rotated(unsigned int logs) 
        { 
                TOAST_IN(logs >= 2);
                max_rotated_ = logs; 
        }
protected:
        const char* rotate(const char* f)
        {
                using boost::lexical_cast;
                using boost::filesystem::exists;
                using boost::filesystem::remove;

                std::string basename(f);

                unsigned int test_suffix = max_rotated_ - 1;
                unsigned int top_suffix = max_rotated_ - 1;
                unsigned int bottom_suffix = 0;
                unsigned int range = 0;

                if (exists(basename + "." + lexical_cast<std::string>(bottom_suffix))) {

                        for (;;) {

                                if (exists(basename + "." + lexical_cast<std::string>(test_suffix))) {

                                        if (test_suffix == max_rotated_ - 1) break;
                                        if (test_suffix == top_suffix - 1) break;

                                        bottom_suffix = test_suffix;
                                        range = top_suffix - bottom_suffix;
                                        test_suffix += (range / 2) + (range % 2);

                                } else {

                                        if (test_suffix == bottom_suffix + 1) {
                                                test_suffix = bottom_suffix;
                                                break;
                                        }

                                        top_suffix = test_suffix;
                                        range = top_suffix - bottom_suffix;
                                        test_suffix -= (range / 2) + (range % 2);

                                }

                        }

                        test_suffix += (test_suffix == max_rotated_ - 1 ? 0 : 1);
                        for (unsigned int log = test_suffix; log > 0; --log) {
                                rename((basename + "." + lexical_cast<std::string>(log - 1)).c_str(), 
                                        (basename + "." + lexical_cast<std::string>(log)).c_str());
                        }

                }

                rename(basename.c_str(), (basename + ".0").c_str());
                return (f);
        }

        unsigned int max_rotated_;
        ~roll_rotation() {}
};

template <typename Policy>
struct RotationPolicyConcept
{
        void constraints() {
                const char f[10] = "blah";
                bool a = p.test(100);
                Policy_Sub psub;
        }
private:
        class Policy_Sub : public Policy
        {
                public:
                Policy_Sub() 
                {
                        const char f[10] = "test";
                        Policy::rotate();
                        Policy::set_file(f);
                }
        };
        Policy p;
};

template <typename RotationCheckPolicy, typename RotationImplPolicy>
struct rotation_policy :
        public RotationCheckPolicy,
        public RotationImplPolicy
{
        TOAST_CLASS_REQUIRE(RotationCheckPolicy, toast::log, RotationCheckPolicyConcept);
        TOAST_CLASS_REQUIRE(RotationImplPolicy, toast::log, RotationImplPolicyConcept);

protected:
        const char* rotate()
        {
                base_filename_ = RotationImplPolicy::rotate(base_filename_.c_str());
                RotationCheckPolicy::reset();
                return (base_filename_.c_str());
        }
        void set_file(const char* f) 
        { 
                base_filename_ = f; 

                if (RotationCheckPolicy::test(f))
                        RotationImplPolicy::rotate(f);
        }

        std::string base_filename_;
        ~rotation_policy() {}
};

} // namespace log
} // namespace toast

#endif // toast_log_rotation_policies_hpp_INCLUDED

---