focuslight 0.1.1

data/lib/focuslight/config.rb

@@ -0,0 +1,27 @@
+require "focuslight"
+
+module Focuslight::Config
+  DEFAULT_DATADIR = File.expand_path('data', "#{__dir__}/../..")
+  DEFAULT_LOG_PATH = File.expand_path('log/application.log', "#{__dir__}/../..")
+
+  def self.get(name)
+    case name
+    when :datadir
+      ENV.fetch('DATADIR', DEFAULT_DATADIR)
+    when :float_support
+      ENV.fetch('FLOAT_SUPPORT', false)
+    when :dburl
+      ENV.fetch('DBURL', 'sqlite://data/gforecast.db')
+    when :log_path
+      ENV.fetch('LOG_PATH', DEFAULT_LOG_PATH)
+    when :log_level
+      ENV.fetch('LOG_LEVEL', 'info')
+    when :log_shift_age
+      ENV.fetch('LOG_SHIFT_AGE', '0')
+    when :log_shift_size
+      ENV.fetch('LOG_SHIFT_SIZE', '1048576')
+    else
+      raise ArgumentError, 'unknown configuration keyword'
+    end
+  end
+end

data/lib/focuslight/data.rb

@@ -0,0 +1,258 @@
+require "focuslight"
+require "focuslight/config"
+require "focuslight/logger"
+require "focuslight/graph"
+require "sequel"
+
+DB = Sequel.connect(Focuslight::Config.get(:dburl), logger: Focuslight.logger)
+
+class Focuslight::Data
+  include Focuslight::Logger
+
+  def initialize
+    @datadir = Focuslight::Config.get(:datadir)
+    @floatings = Focuslight::Config.get(:float_support) == "y"
+
+    if DB.database_type == :sqlite
+      DB.run 'PRAGMA journal_mode = WAL'
+      DB.run 'PRAGMA synchronous = NORMAL'
+    end
+    @graphs = DB.from(:graphs)
+    @complex_graphs = DB.from(:complex_graphs)
+  end
+
+  def number_type
+    @floatings ? Float : Bignum
+  end
+
+  def create_tables
+    ntype = number_type
+    DB.transaction do
+
+      DB.create_table :graphs do
+        primary_key :id, Bignum # Notice that SQLite actually creates integer primary key
+        column :service_name, String, null: false
+        column :section_name, String, null: false
+        column :graph_name, String, null: false
+        column :number, ntype, default: 0
+        column :mode, String, default: "gauge", null: false
+        column :description, String, default: "", null: false
+        column :sort, Bignum, default: 0, null: false
+        column :color, String, default: "#00CC00", null: false
+        column :ulimit, ntype, default: 1000000000000000, null: false
+        column :llimit, ntype, default: 0, null: false
+        column :type, String, default: "AREA", null: false
+        String :meta, text: true
+        column :created_at, Bignum, null: false
+        column :updated_at, Bignum, null: false
+        unique [:service_name, :section_name, :graph_name]
+      end
+
+      DB.create_table :complex_graphs do
+        primary_key :id, Bignum # Notice that SQLite actually creates integer primary key
+        column :service_name, String, null: false
+        column :section_name, String, null: false
+        column :graph_name, String, null: false
+        column :number, ntype, default: 0
+        column :description, String, default: "", null: false
+        column :sort, Bignum, default: 0, null: false
+        String :meta, text: true
+        column :created_at, Bignum, null: false
+        column :updated_at, Bignum, null: false
+        unique [:service_name, :section_name, :graph_name]
+      end
+    end
+  end
+
+  def execute(*args)
+    DB.run(*args)
+  end
+
+  def transaction
+    DB.transaction do
+      yield DB
+    end
+  end
+
+  def get(service, section, graph)
+    data = @graphs.where(service_name: service, section_name: section, graph_name: graph).first
+    data && Focuslight::Graph.concrete(data)
+  end
+
+  def get_by_id(id)
+    data = @graphs[id: id]
+    data && Focuslight::Graph.concrete(data)
+  end
+
+  def get_by_id_for_rrdupdate(id, target=:normal) # get_by_id_for_rrdupdate_short == get_by_id_for_rrdupdate(id, :short)
+    data = @graphs[id: id]
+    return nil unless data
+    graph = Focuslight::Graph.concrete(data)
+  end
+
+  def update(service_name, section_name, graph_name, number, mode, color)
+    data = nil
+    DB.transaction do
+      data = @graphs.where(service_name: service_name, section_name: section_name, graph_name: graph_name).first
+      if data
+        graph = Focuslight::Graph.concrete(data)
+        if mode == 'count'
+          number += graph.number
+        end
+        if mode != 'modified' || (mode == 'modified' && graph.number != number)
+          color = graph.color if color.empty?
+          @graphs.where(id: graph.id).update(number: number, mode: mode, color: color, updated_at: Time.now.to_i)
+        end
+      else
+        color = '#' + ['33', '66', '99', 'cc'].shuffle.slice(0,3).join if color.empty?
+        # COLUMNS = %w(service_name section_name graph_name number mode color llimit created_at updated_at)
+        columns = Focuslight::SimpleGraph::COLUMNS.join(',')
+        # PLACEHOLDERS = COLUMNS.map{|c| '?'}
+        placeholders = Focuslight::SimpleGraph::PLACEHOLDERS.join(',')
+        current_time = Time.now.to_i
+        @graphs.insert(
+                       service_name: service_name,
+                       section_name: section_name,
+                       graph_name: graph_name,
+                       number: number,
+                       mode: mode,
+                       color: color,
+                       llimit: -1000000000,
+                       created_at: current_time,
+                       updated_at: current_time)
+      end
+
+      data = @graphs.where(service_name: service_name, section_name: section_name, graph_name: graph_name).first
+    end # transaction
+
+    Focuslight::Graph.concrete(data)
+  end
+
+  def update_graph(id, args)
+    graph = get_by_id(id)
+    return nil unless graph
+
+    graph.update(args)
+    @graphs.where(id: graph.id)
+      .update(
+              service_name: graph.service,
+              section_name: graph.section,
+              graph_name: graph.graph,
+              description: graph.description,
+              sort: graph.sort,
+              color: graph.color,
+              type: graph.type,
+              llimit: graph.llimit,
+              ulimit: graph.ulimit,
+              meta: graph.meta
+              )
+    true
+  end
+
+  def update_graph_description(id, description)
+    @graphs.where(id: id).update(description: description)
+    true
+  end
+
+  def get_services
+    rows1 = @graphs.order(:service_name).all
+    rows2 = @complex_graphs.order(:service_name).all
+    (rows1 + rows2).map{|row| row[:service_name]}.uniq.sort
+  end
+
+  def get_sections(service)
+    rows1 = @graphs.select(:section_name).order(:section_name).where(service_name: service).all
+    rows2 = @complex_graphs.select(:section_name).order(:section_name).where(service_name: service).all
+    (rows1 + rows2).map{|row| row[:section_name]}.uniq.sort
+  end
+
+  def get_graphs(service, section)
+    rows1 = @graphs.order(Sequel.desc(:sort)).where(service_name: service, section_name: section).all
+    rows2 = @complex_graphs.order(Sequel.desc(:sort)).where(service_name: service, section_name: section).all
+    (rows1 + rows2).map{|row| Focuslight::Graph.concrete(row)}.sort{|a,b| b.sort <=> a.sort}
+  end
+
+  def get_all_graph_id
+    @graphs.select(:id).all
+  end
+
+  def get_all_graph_name
+    @graphs.select(:id, :service_name, :section_name, :graph_name).reverse_order(:service_name, :section_name, :graph_name).all
+  end
+
+  def get_all_graph_all
+    rows = @graphs.reverse_order(:service_name, :section_name, :graph_name).all
+    rows.map{|row| Focuslight::Graph.concrete(row)}
+  end
+
+  def remove(id)
+    DB.transaction do
+      @graphs.where(id: id).delete
+    end
+  end
+
+  def get_complex(service, section, graph)
+    data = @complex_graphs.where(service_name: service, section_name: section, graph_name: graph).first
+    data && Focuslight::Graph.concrete(data)
+  end
+
+  def get_complex_by_id(id)
+    data = @complex_graphs.where(id: id).first
+    data && Focuslight::Graph.concrete(data)
+  end
+
+  def create_complex(service, section, graph, args)
+    description = args[:description]
+    sort = args[:sort]
+    meta = Focuslight::ComplexGraph.meta_clean(args).to_json
+    now = Time.now.to_i
+    @complex_graphs.insert(
+                           service_name: service,
+                           section_name: section,
+                           graph_name: graph,
+                           description: description,
+                           sort: sort.to_i,
+                           meta: meta,
+                           created_at: now,
+                           updated_at: now,
+                           )
+    get_complex(service, section, graph)
+  end
+
+  def update_complex(id, args)
+    graph = get_complex_by_id(id)
+    return nil unless graph
+
+    graph.update(args)
+    @complex_graphs.where(id: graph.id)
+      .update(
+              service_name: graph.service,
+              section_name: graph.section,
+              graph_name: graph.graph,
+              description: graph.description,
+              sort: graph.sort,
+              meta: graph.meta,
+              updated_at: Time.now.to_i,
+              )
+
+    get_complex_by_id(id)
+  end
+
+  def remove_complex(id)
+    @complex_graphs.where(id: id).delete
+  end
+
+  def get_all_complex_graph_id
+    @complex_graphs.select(:id).all
+  end
+
+  def get_all_complex_graph_name
+    @complex_graphs.select(:id, :service_name, :section_name, :graph_name).reverse_order(:service_name, :section_name, :graph_name).all
+  end
+
+  def get_all_complex_graph_all
+    rows = @complex_graphs.reverse_order(:service_name, :section_name, :graph_name)
+    return [] unless rows
+    rows.map{|row| Focuslight::Graph.concrete(row)}
+  end
+end

data/lib/focuslight/graph.rb

@@ -0,0 +1,240 @@
+require "focuslight"
+require "focuslight/logger"
+
+require "digest"
+require "json"
+
+module Focuslight
+  class Graph
+    include Focuslight::Logger
+
+    def self.concrete(row)
+      if row.has_key?(:mode) && row.has_key?(:type)
+        Focuslight::SimpleGraph.new(row)
+      else
+        Focuslight::ComplexGraph.new(row)
+      end
+    end
+
+    attr_accessor :id, :service, :section, :graph, :number, :description, :sort
+    attr_accessor :meta
+    attr_accessor :created_at_time, :updated_at_time
+
+    attr_accessor :c_type, :stack # for complex graph construction
+
+    def initialize(row)
+      @row_hash = row
+
+      @id = row[:id]
+      @service = row[:service_name]
+      @section = row[:section_name]
+      @graph = row[:graph_name]
+      @number = row[:number].to_i # NOT NULL DEFAULT 0
+      @description = row[:description] || ''
+      @sort = row[:sort].to_i # NOT NULL DEFAULT 0
+
+      @meta = row[:meta]
+      @parsed_meta = JSON.parse(@meta || '{}', :symbolize_names => true)
+
+      @created_at_time = Time.at(row[:created_at].to_i)
+      @updated_at_time = Time.at(row[:updated_at].to_i)
+    end
+
+    def path
+      [@service, @section, @graph]
+    end
+
+    def created_at
+      @created_at_time.strftime('%Y/%m/%d %T')
+    end
+
+    def updated_at
+      @updated_at_time.strftime('%Y/%m/%d %T')
+    end
+
+    def to_hash
+      {
+        id: @id, service_name: @service, section_name: @section, graph_name: @graph,
+        number: @number, description: @description, sort: @sort,
+        created_at: self.created_at(), updated_at: self.updated_at(),
+      }
+    end
+
+    def self.hash2request(hash)
+      hash = hash.dup
+      is_complex = hash.delete(:complex)
+
+      hash.delete(:id)
+      hash.delete(:created_at)
+      hash.delete(:updated_at)
+
+      return hash unless is_complex ##TODO concrete?
+
+      hash.delete(:number)
+      hash[:sumup] = (hash[:sumup] ? '1' : '0')
+
+      data_rows = hash.delete(:data)
+
+      first = data_rows.shift
+      hash['path-1'.to_sym] = first[:graph_id]
+      hash['type-1'.to_sym] = first[:type]
+
+      p2 = 'path-2'.to_sym
+      t2 = 'type-2'.to_sym
+      s2 = 'stack-2'.to_sym
+      hash[p2] = []
+      hash[t2] = []
+      hash[s2] = []
+      data_rows.each do |row|
+        hash[p2] << row[:graph_id]
+        hash[t2] << row[:type]
+        hash[s2] << (row[:stack] ? '1' : '0')
+      end
+
+      hash ##TODO concrete?
+    end
+  end
+
+  class SimpleGraph < Graph
+    COLUMNS = %w(service_name section_name graph_name number mode color llimit created_at updated_at)
+    PLACEHOLDERS = COLUMNS.map{|c| '?'}
+
+    attr_accessor :mode, :color, :ulimit, :llimit, :type
+
+    attr_reader :md5
+    attr_accessor :adjust, :adjustval, :unit
+
+    def initialize(row)
+      super
+
+      @mode = row[:mode] || 'gauge' # NOT NULL DEFAULT 'gauge'
+      @color = row[:color] || '#00CC00' # NOT NULL DEFAULT '#00CC00'
+      @ulimit = row[:ulimit] || 1000000000000000 # NOT NULL DEFAULT 1000000000000000
+      @llimit = row[:llimit] || 0
+      @type = row[:type] || 'AREA'
+
+      @md5 = Digest::MD5.hexdigest(@id.to_s)
+
+      @adjust = @parsed_meta.fetch(:adjust, '*')
+      @adjustval = @parsed_meta.fetch(:adjustval, '1')
+      @unit = @parsed_meta.fetch(:unit, '')
+    end
+
+    def to_hash
+      simple = {
+        mode: @mode, color: @color,
+        ulimit: @ulimit, llimit: @llimit,
+        type: @type,
+        adjust: @adjust, adjustval: @adjustval, unit: @unit,
+        complex: false,
+        md5: @md5, meta: @meta,
+      }
+      hash = super
+      hash.merge(simple)
+    end
+
+    def complex?
+      false
+    end
+
+    def update(args={})
+      meta = @parsed_meta.dup
+      args.each do |k, v|
+        case k.to_sym
+        when :number then @number = v
+        when :description then @description = v
+        when :sort then @sort = v
+        when :mode then @mode = v
+        when :color then @color = v
+        when :ulimit then @ulimit = v
+        when :llimit then @llimit = v
+        when :type then @type = v
+        else
+          meta[k.to_sym] = v
+        end
+      end
+      @parsed_meta = self.class.meta_clean(@parsed_meta.merge(meta))
+      @meta = @parsed_meta.to_json
+    end
+
+    def self.meta_clean(args={})
+      args.delete_if do |k,v|
+        %w(id service_name section_name graph_name number
+           description sort mode color ulimit llimit type).include?(k.to_s)
+      end
+    end
+  end
+
+  class ComplexGraph < Graph
+    attr_accessor :sumup, :data_rows
+    attr_reader :complex_graph
+
+    def initialize(row)
+      super
+
+      uri = [:'type-1', :'path-1'].map{|k| @parsed_meta[k]}.join(':') + ':0' # stack
+
+      data_rows = []
+
+      first_row = {
+        type: @parsed_meta[:'type-1'],
+        path: @parsed_meta[:'path-1'].to_i,
+        stack: false,
+        graph_id: @parsed_meta[:'path-1'].to_i,
+      }
+      data_rows << first_row
+
+      unless @parsed_meta[:'type-2'].is_a?(Array)
+        [:'type-2', :'path-2', :'stack-2'].each do |key|
+          @parsed_meta[key] = [@parsed_meta[key]].flatten
+        end
+      end
+
+      @parsed_meta[:'type-2'].each_with_index do |type, i|
+        t = @parsed_meta[:'type-2'][i]
+        p = @parsed_meta[:'path-2'][i].to_i
+        s = @parsed_meta[:'stack-2'][i].is_a?(String) ? !!(@parsed_meta[:'stack-2'][i] =~ /^(1|true)$/i) : !!@parsed_meta[:'stack-2'][i]
+        uri += ':' + [t, p, (s ? '1' : '0')].join(':')
+        data_rows << {type: t, path: p, stack: s, graph_id: p}
+      end
+
+      @sumup = @parsed_meta.fetch(:sumup, '0') != '0' # '0' is false
+      @data_rows = data_rows
+      @complex_graph = uri
+    end
+
+    def to_hash
+      complex = {
+        sumup: @sumup, data: @data_rows,
+        complex: true
+      }
+      hash = super
+      hash.merge(complex)
+    end
+
+    def complex?
+      true
+    end
+
+    def update(args={})
+      meta = @parsed_meta.dup
+      args.each do |k, v|
+        case k.to_sym
+        when :number then @number = v
+        when :description then @description = v
+        when :sort then @sort = v
+        else
+          meta[k.to_sym] = v
+        end
+      end
+      @parsed_meta = self.class.meta_clean(@parsed_meta.merge(meta))
+      @meta = @parsed_meta.to_json
+    end
+
+    def self.meta_clean(args={})
+      args.delete_if do |k,v|
+        %w(id service_name section_name graph_name number description sort).include?(k.to_s)
+      end
+    end
+  end
+end