MaintenanceScheduler.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 3 of the
 * License, or any later version.
 *
 * Hypertable 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */


#ifndef Hypertable_RangeServer_MaintenanceScheduler_h
#define Hypertable_RangeServer_MaintenanceScheduler_h

#include <Hypertable/RangeServer/MaintenancePrioritizerLogCleanup.h>
#include <Hypertable/RangeServer/MaintenancePrioritizerLowMemory.h>
#include <Hypertable/RangeServer/LoadStatistics.h>
#include <Hypertable/RangeServer/TableInfoMap.h>

#include <chrono>
#include <memory>
#include <mutex>
#include <set>

namespace Hypertable {


  class MaintenanceScheduler {
  public:

    MaintenanceScheduler(MaintenanceQueuePtr &queue,
                         TableInfoMapPtr &live_map);

    void schedule();

    void include(const TableIdentifier &table);

    void exclude(const TableIdentifier &table);

    void set_low_memory_mode(bool on) {
      if (on) {
        if (!m_low_memory_mode && m_low_memory_prioritization)
          m_prioritizer = &m_prioritizer_low_memory;
      }
      else {
        if (m_low_memory_mode) {
          m_prioritizer = &m_prioritizer_log_cleanup;
          m_last_low_memory = chrono::steady_clock::now();
        }
      }
      m_low_memory_mode = on;
    }

  private:

    int get_level(RangeData &rd);

    bool low_memory_mode() { return m_low_memory_mode; }

    bool debug_signal_file_exists(std::chrono::steady_clock::time_point now);

    void write_debug_output(std::chrono::steady_clock::time_point now, Ranges &ranges,
                            const String &header_str);

    std::mutex m_mutex;

    std::set<std::string> m_table_blacklist;

    MaintenanceQueuePtr m_queue;
    TableInfoMapPtr m_live_map;
    MaintenancePrioritizer *m_prioritizer;
    MaintenancePrioritizerLogCleanup m_prioritizer_log_cleanup;
    MaintenancePrioritizerLowMemory  m_prioritizer_low_memory;
    std::chrono::steady_clock::time_point m_last_low_memory;
    std::chrono::steady_clock::time_point m_last_check;
    int64_t m_query_cache_memory;
    int32_t m_maintenance_interval;
    int32_t m_low_memory_limit_percentage;
    int32_t m_merging_delay;
    int32_t m_merges_per_interval;
    int32_t m_move_compactions_per_interval;
    int32_t m_initialization_per_interval;
    int32_t m_maintenance_queue_worker_count;
    int32_t m_start_offset {};
    bool m_initialized {};
    bool m_low_memory_prioritization;
    bool m_low_memory_mode {};
  };

  typedef std::shared_ptr<MaintenanceScheduler> MaintenanceSchedulerPtr;


}

#endif // Hypertable_RangeServer_MaintenanceScheduler_h