pencil 0.2.10 → 0.3.0

data/lib/helpers.rb

@@ -1,209 +0,0 @@
-module Dash::Helpers
-  include Dash::Models
-
-  @@prefs = [["Start Time", "start"],
-             ["Duration", "duration"],
-             ["Width", "width"],
-             ["Height", "height"]]
-
-  # convert keys to symbols before lookup
-  def param_lookup(name)
-    sym_hash = {}
-    session.each { |k,v| sym_hash[k.to_sym] = v unless v.empty? }
-    params.each { |k,v| sym_hash[k.to_sym] = v unless v.empty? }
-    settings.config.global_config[:url_opts].merge(sym_hash)[name.to_sym]
-  end
-
-  def cluster_graph(g, cluster, title="wtf")
-    image_url = \
-    @dash.render_cluster_graph(g, cluster,
-                               :title => title,
-                               :dynamic_url_opts => merge_opts)
-    zoom_url = cluster_graph_link(@dash, g, cluster)
-    return image_url, zoom_url
-  end
-
-  def cluster_graph_link(dash, g, cluster)
-    link = dash.graph_opts[g]["click"] ||
-      "/dash/#{cluster}/#{dash.name}/#{g.name}"
-    return append_query_string(link)
-  end
-
-  def cluster_zoom_graph(g, cluster, host, title)
-    image_url = g.render_url([host.name], [cluster], :title => title,
-                             :dynamic_url_opts => merge_opts)
-    zoom_url = cluster_zoom_link(cluster, host)
-    return image_url, zoom_url
-  end
-
-  def cluster_zoom_link(cluster, host)
-    return append_query_string("/host/#{cluster}/#{host}")
-  end
-
-  def suggest_cluster_links(clusters, g)
-    links = []
-    clusters.each do |c|
-      href = append_query_string("/dash/#{c}/#{params[:dashboard]}/#{g.name}")
-      links << "<a href=\"#{href}\">#{c}</a>"
-    end
-    return "zoom (" + links.join(", ") + ")"
-  end
-
-  def suggest_dashboards_links(host, graph)
-    suggested = suggest_dashboards(host, graph)
-    return "" if suggested.length == 0
-
-    links = []
-    suggested.each do |d|
-      links << "<a href=\"/dash/#{host.cluster}/#{append_query_string(d)}\">" +
-        "#{d}</a>"
-    end
-    return "(" + links.join(", ") + ")"
-  end
-
-  # it's mildly annoying that when this set is empty there're no uplinks
-  # consider adding a link up to the cluster (which is best we can do)
-  def suggest_dashboards(host, graph)
-    ret = Set.new
-
-    host.graphs.each do |g|
-      Dashboard.find_by_graph(g).each do |d|
-        valid, _ = d.get_valid_hosts(g, host['cluster'])
-        ret << d.name if valid.member?(host)
-      end
-    end
-
-    return ret
-  end
-
-  # generate the input box fields, filled in to current parameters if specified
-  def input_boxes
-    @prefs = @@prefs
-    erb :'partials/input_boxes', :layout => false
-  end
-
-  def dash_link(dash, cluster)
-    return append_query_string("/dash/#{cluster}/#{dash.name}")
-  end
-
-  def cluster_link(cluster)
-    return append_query_string("/dash/#{cluster}")
-  end
-
-  # fixme this isn't used anymore, but should
-  def css_url
-    style = File.join(settings.root, "public/style.css")
-    mtime = File.mtime(style).to_i.to_s
-    return \
-    %Q[<link href="/style.css?#{mtime}" rel="stylesheet" type="text/css">]
-  end
-
-  def refresh
-    if settings.config.global_config[:refresh_rate] != false && nowish
-      rate = settings.config.global_config[:refresh_rate] || 60
-      return %Q[<meta http-equiv="refresh" content="#{rate}">]
-    end
-  end
-
-  def hosts_selector(hosts, print_clusters=false)
-    @print_clusters = print_clusters
-    @hosts = hosts
-    erb :'partials/hosts_selector', :layout => false
-  end
-
-  def append_query_string(str)
-    v = str.dup
-    (v << "?#{request.query_string}") unless request.query_string.empty?
-    return v
-  end
-
-  def merge_opts
-    static_opts = ["cluster", "dashboard", "zoom", "host", "session_id"]
-    opts = params.dup
-    session.merge(opts).delete_if { |k,v| static_opts.member?(k) || v.empty? }
-  end
-
-  def shortcuts(str)
-    @str = str
-    erb :'partials/shortcuts', :layout => false
-  end
-  def cluster_switcher(clusters)
-    @clusters = clusters
-    erb :'partials/cluster_switcher', :layout => false
-  end
-
-  def dash_switcher
-    erb :'partials/dash_switcher', :layout => false
-  end
-
-  def graph_switcher
-    erb :'partials/graph_switcher', :layout => false
-  end
-
-  def cluster_selector
-    @clusters = settings.config.clusters.sort + ["global"]
-    erb :'partials/cluster_selector', :layout => false
-  end
-
-  def host_uplink
-    link = "/dash/#{append_query_string(@host.cluster)}"
-    "zoom out: <a href=\"#{link}\">#{@host.cluster}</a>"
-  end
-
-  def graph_uplink
-    link = append_query_string(request.path.split("/")[0..-2].join("/"))
-    "zoom out: <a href=\"#{link}\">#{@dash}</a>"
-  end
-
-  def dash_uplink
-    link = append_query_string(request.path.split("/")[0..-2].join("/"))
-    "zoom out: <a href=\"#{link}\">#{@params[:cluster]}</a>"
-  end
-
-  # fixme this is a hack
-  def header(str)
-    <<FOO
-<div class="path_container">
-              <h2>#{@title}</h2>
-                <span class="zoom">
-                #{str}
-                </span>
-            </div>
-            <div id="timeslice_container">
-              <h3 id="timeslice">#{range_string}</h3>
-              #{permalink unless @no_graphs}
-            </div>
-FOO
-  end
-
-  def nowish
-    if settings.config.global_config[:now_threshold] == false
-      return false
-    end
-    threshold = settings.config.global_config[:now_threshold] || 300
-    return @request_time.to_i - @etime.to_i < threshold
-  end
-
-  def range_string
-    format = settings.config.global_config[:date_format] || "%X %x"
-    if @stime && @etime
-      if nowish
-        "timeslice: from #{@stime.strftime(format)}"
-      else
-        "timeslice: #{@stime.strftime(format)} - #{@etime.strftime(format)}"
-      end
-    else
-      "invalid time range"
-    end
-
-  end
-
-  def permalink
-    return "" unless @stime && @duration
-    format = "%F %T" # chronic REALLY understands this
-    url = request.path + "?"
-    url << "&start=#{@stime.strftime(format)}"
-    url << "&duration=#{ChronicDuration.output(@duration)}"
-    "<a id=\"permalink\" href=\"#{url}\">permalink</a>"
-  end
-end

data/lib/models/base.rb

@@ -1,73 +0,0 @@
-module Dash::Models
-  class Base
-    @@objects = Hash.new { |h, k| h[k] = Hash.new }
-    attr_reader :name
-
-    def initialize(name, params={})
-      @name = name
-      @match_name = name
-      @params = params
-      @@objects[self.class.to_s][name] = self
-    end
-
-    def self.find(name)
-      return @@objects[self.name][name] rescue []
-    end
-
-    def self.each(&block)
-      h = @@objects[self.name] rescue {}
-      h.each { |k, v| yield(k, v) }
-    end
-
-    def self.all
-      return @@objects[self.name].values
-    end
-
-    def [](key)
-      return @params[key] rescue []
-    end
-
-    def match(glob)
-      return true if glob == '*'
-      # convert glob to a regular expression
-      glob_parts = glob.split('*').collect { |s| Regexp.escape(s) }
-      if glob[0].chr == '*'
-        glob_re = /^.*#{glob_parts.join('.*')}$/
-      elsif glob[-1].chr == '*'
-        glob_re = /^#{glob_parts.join('.*')}.*$/
-      else
-        glob_re = /^#{glob_parts.join('.*')}$/
-      end
-      return @match_name.match(glob_re)
-    end
-
-    def multi_match(globs)
-      ret = false
-
-      globs.each do |glob|
-        ret = match(glob)
-        break if ret
-      end
-
-      return ret
-    end
-
-    def to_s
-      return @name
-    end
-
-    def <=>(other)
-      return to_s <=> other.to_s
-    end
-
-    def update_params(hash)
-      @params.merge!(hash)
-    end
-
-    # compose a metric using a :metric_format
-    # format string with %c for metric, %c for cluster, and %h for host
-    def compose_metric (m, c, h)
-      @params[:metric_format].dup.gsub("%m", m).gsub("%c", c).gsub("%h", h)
-    end
-  end # Dash::Models::Base
-end # Dash::Models

data/lib/models/dashboard.rb

@@ -1,111 +0,0 @@
-require "models/base"
-require "models/graph"
-require "models/host"
-require "set"
-
-module Dash::Models
-  class Dashboard < Base
-    attr_accessor :graphs
-    attr_accessor :graph_opts
-
-    def initialize(name, params={})
-      super
-
-      @graphs = []
-      @graph_opts = {}
-      params["graphs"].each do |name|
-        # graphs map to option hashes
-        if name.instance_of?(Hash) # could be YAML::Omap
-          g = Graph.find(name.keys.first) # should only be one key
-          @graph_opts[g] = name[name.keys.first]||{}
-        else
-          raise "Bad format for graph (must be a hash)"
-        end
-
-        @graphs << g if g
-      end
-
-      @valid_hosts_table = {} # cache calls to get_valid_hosts
-    end
-
-    def clusters
-      clusters = Set.new
-      @graphs.each { |g| clusters += get_valid_hosts(g)[1] }
-      clusters.sort
-    end
-
-    def get_all_hosts(cluster=nil)
-      hosts = Set.new
-      clusters = Set.new
-      @graphs.each do |g|
-        h, c = get_valid_hosts(g, cluster)
-        hosts += h
-        clusters += c
-      end
-      return hosts, clusters
-    end
-
-    def get_valid_hosts(graph, cluster=nil)
-      if @valid_hosts_table[[graph, cluster]]
-        return @valid_hosts_table[[graph, cluster]]
-      end
-
-      clusters = Set.new
-      if cluster
-        hosts = Host.find_by_cluster(cluster)
-      else
-        hosts = Host.all
-      end
-
-      # filter by what matches the graph definition
-      hosts = hosts.select { |h| h.multi_match(graph["hosts"]) }
-
-      # filter if we have a dashboard-level 'hosts' filter
-      if @params["hosts"]
-        hosts = hosts.select { |h| h.multi_match(@params["hosts"]) }
-      end
-
-      hosts.each { |h| clusters << h.cluster }
-
-      @valid_hosts_table[[graph, cluster]] = [hosts, clusters]
-      return hosts, clusters
-    end
-
-    def render_cluster_graph(graph, clusters, opts={})
-      # FIXME: edge case where the dash filter does not filter to a subset of
-      # the hosts filter
-
-      hosts = get_host_wildcards(graph)
-      opts[:sum] = :cluster unless opts[:zoom]
-      graph_url = graph.render_url(hosts.to_a, clusters, opts)
-      return graph_url
-    end
-
-    def get_host_wildcards(graph)
-      return graph_opts[graph]["hosts"] || @params["hosts"] || graph["hosts"]
-    end
-
-    def render_global_graph(graph, opts={})
-      hosts = get_host_wildcards(graph)
-      _, clusters = get_valid_hosts(graph)
-
-      next_url = ""
-      type = opts[:zoom] ? :cluster : :global
-      options = opts.merge({:sum => type})
-      graph_url = graph.render_url(hosts, clusters, options)
-      return graph_url
-    end
-
-    def self.find_by_graph(graph)
-      ret = []
-      Dashboard.each do |name, dash|
-
-        if dash["graphs"].map { |x| x.keys.first }.member?(graph.name)
-          ret << dash
-        end
-      end
-
-      return ret
-    end
-  end # Dash::Models::Dashboard
-end # Dash::Models