lbrt 0.1.0

data/lib/lbrt/alert/dsl.rb

@@ -0,0 +1,9 @@
+class Lbrt::Alert::DSL
+  def self.convert(exported, options = {})
+    Lbrt::Alert::DSL::Converter.convert(exported, options)
+  end
+
+  def self.parse(client, dsl, path, options = {})
+    Lbrt::Alert::DSL::Context.eval(client, dsl, path, options).result
+  end
+end

data/lib/lbrt/alert/dsl/context.rb

@@ -0,0 +1,32 @@
+class Lbrt::Alert::DSL::Context
+  include Lbrt::Utils::ContextHelper
+
+  def self.eval(client, dsl, path, options = {})
+    self.new(client, path, options) {
+      eval(dsl, binding, path)
+    }
+  end
+
+  attr_reader :result
+
+  def initialize(client, path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = {}
+    @services = Lbrt::Service::Exporter.export(client, options)
+    instance_eval(&block)
+  end
+
+  private
+
+  def alert(name, &block)
+    name = name.to_s
+
+    if @result[name]
+      raise "Alert `#{name}` is already defined"
+    end
+
+    alrt = Lbrt::Alert::DSL::Context::Alert.new(name, @services, &block).result
+    @result[name] = alrt
+  end
+end

data/lib/lbrt/alert/dsl/context/alert.rb

@@ -0,0 +1,75 @@
+class Lbrt::Alert::DSL::Context::Alert
+  REQUIRED_ATTRIBUTES = %w(
+    description
+    attributes
+    active
+    rearm_seconds
+    rearm_per_signal
+  )
+
+  def initialize(name, services, &block)
+    @name = name
+    @services = services
+
+    @result = {
+      'attributes' => {},
+      'conditions' => [],
+      'services' => [],
+    }
+
+    instance_eval(&block)
+  end
+
+  def result
+    REQUIRED_ATTRIBUTES.each do |name|
+      unless @result.has_key?(name)
+        raise "Alert `#{@name}`: #{name} is not defined"
+      end
+    end
+
+    @result
+  end
+
+  private
+
+  def description(value)
+    @result['description'] = value.to_s
+  end
+
+  def attributes(value)
+    unless value.is_a?(Hash)
+      raise TypeError, "wrong argument type #{value.class}: #{value.inspect} (expected Hash)"
+    end
+
+    @result['attributes'] = value
+  end
+
+  def active(value)
+    @result['active'] = !!value
+  end
+
+  def rearm_seconds(value)
+    @result['rearm_seconds'] = value.to_i
+  end
+
+  def rearm_per_signal(value)
+    @result['rearm_per_signal'] = !!value
+  end
+
+  def condition(&block)
+    @result['conditions'] << Lbrt::Alert::DSL::Context::Alert::Condition.new(@name, &block).result
+  end
+
+  def service(type, title)
+    service_key = [type, title]
+    service = @services[service_key]
+
+    unless service
+      raise "Service `#{type}/#{title}` is not found"
+    end
+
+    service['title'] = title
+    service['type'] = type
+    @result['services'] << service
+  end
+end

data/lib/lbrt/alert/dsl/context/alert/condition.rb

@@ -0,0 +1,61 @@
+class Lbrt::Alert::DSL::Context::Alert::Condition
+  REQUIRED_ATTRIBUTES = %w(
+    type
+    metric_name
+    source
+  )
+
+  REQUIRED_ATTRIBUTES_BY_TYPE = {
+    'above' => %W(threshold summary_function),
+    'below' => %W(threshold summary_function),
+    'active' => %W(duration),
+  }
+
+  def initialize(alert_name, &block)
+    @alert_name = alert_name
+    @result = {}
+    instance_eval(&block)
+  end
+
+  def result
+    REQUIRED_ATTRIBUTES.each do |name|
+      unless @result.has_key?(name)
+        raise "Alert `#{@alert_name}` > Condition > `#{name}` is not defined"
+      end
+    end
+
+    REQUIRED_ATTRIBUTES_BY_TYPE.fetch(@result['type'], {}).each do |name|
+      unless @result.has_key?(name)
+        raise "Alert `#{@alert_name}` > Condition > `#{name}` is not defined"
+      end
+    end
+
+    @result
+  end
+
+  private
+
+  def type(value)
+    @result['type'] = value.to_s
+  end
+
+  def metric_name(value)
+    @result['metric_name'] = value.to_s
+  end
+
+  def source(value)
+    @result['source'] = value.nil? ? nil : value.to_s
+  end
+
+  def threshold(value)
+    @result['threshold'] = value.to_f
+  end
+
+  def summary_function(value)
+    @result['summary_function'] = value.to_s
+  end
+
+  def duration(value)
+    @result['duration'] = value.to_i
+  end
+end

data/lib/lbrt/alert/dsl/converter.rb

@@ -0,0 +1,113 @@
+class Lbrt::Alert::DSL::Converter
+  def self.convert(exported, options = {})
+    self.new(exported, options).convert
+  end
+
+  def initialize(exported, options = {})
+    @exported = exported
+    @options = options
+  end
+
+  def convert
+    output_alerts(@exported)
+  end
+
+  private
+
+  def output_alerts(alert_by_name)
+    alerts = []
+
+    alert_by_name.sort_by(&:first).map do |name, attrs|
+      next unless Lbrt::Utils.matched?(name, @options[:target])
+      alerts << output_alert(name, attrs)
+    end
+
+    alerts.join("\n")
+  end
+
+  def output_alert(name, attrs)
+    description = attrs.fetch('description')
+    attributes = attrs.fetch('attributes')
+    active = attrs.fetch('active')
+    rearm_seconds = attrs.fetch('rearm_seconds')
+    rearm_per_signal = attrs.fetch('rearm_per_signal')
+
+    conditions = attrs.fetch('conditions')
+    services = attrs.fetch('services')
+
+    if attributes.empty?
+      attributes = "\n" + <<-EOS.chomp
+  #attributes "runbook_url"=>"http://example.com"
+      EOS
+    else
+      attributes = "\n" + <<-EOS.chomp
+  attributes #{Lbrt::Utils.unbrace(attributes.inspect)}
+      EOS
+    end
+
+    <<-EOS
+alert #{name.inspect} do
+  description #{description.inspect}#{
+  attributes}
+  active #{active.inspect}
+  rearm_seconds #{rearm_seconds.inspect}
+  rearm_per_signal #{rearm_per_signal.inspect}
+
+  #{output_conditions(conditions)}
+
+  #{output_services(services)}
+end
+    EOS
+  end
+
+  def output_conditions(conditions)
+    if conditions.empty?
+      '# no condition'
+    else
+      conditions.map {|i| output_condition(i) }.join("\n").strip
+    end
+  end
+
+  def output_condition(condition)
+    type = condition.fetch('type')
+    metric_name = condition.fetch('metric_name')
+    source = condition.fetch('source')
+
+    out = <<-EOS
+  condition do
+    type #{type.inspect}
+    metric_name #{metric_name.inspect}
+    source #{source.inspect}
+    EOS
+
+    %w(threshold summary_function duration).each do |key|
+      next unless condition.has_key?(key)
+      value = condition[key]
+
+      out << <<-EOS
+    #{key} #{value.inspect}
+      EOS
+    end
+
+    out << <<-EOS
+  end
+    EOS
+  end
+
+  def output_services(services)
+    if services.empty?
+      '# no service'
+    else
+      services.map {|i| output_service(i) }.join.strip
+    end
+  end
+
+  def output_service(service)
+    type = service.fetch('type')
+    title = service.fetch('title')
+
+    <<-EOS
+  service #{type.inspect}, #{title.inspect}
+    EOS
+  end
+end

data/lib/lbrt/alert/exporter.rb

@@ -0,0 +1,38 @@
+class Lbrt::Alert::Exporter
+  class << self
+    def export(client, options = {})
+      self.new(client, options).export
+    end
+  end # of class methods
+
+  def initialize(client, options = {})
+    @client = client
+    @options = options
+  end
+
+  def export
+    alerts = @client.alerts.get
+    normalize(alerts)
+  end
+
+  def normalize(alerts)
+    alert_by_name = {}
+
+    alerts.each do |alrt|
+      name = alrt.delete('name')
+
+      if alert_by_name[name]
+        raise "Duplicate alert name exists: #{name}"
+      end
+
+      %w(created_at updated_at version).each do |key|
+        alrt.delete(key)
+      end
+
+      alrt['attributes'] ||= {}
+      alert_by_name[name] = alrt
+    end
+
+    alert_by_name
+  end
+end

data/lib/lbrt/cli.rb

@@ -0,0 +1,2 @@
+module Lbrt::CLI
+end

data/lib/lbrt/cli/alert.rb

@@ -0,0 +1,26 @@
+class Lbrt::CLI::Alert < Thor
+  include Lbrt::Utils::CLIHelper
+
+  class_option :target
+
+  desc 'apply FILE', 'Apply alerts'
+  option :'dry-run', :type => :boolean, :default => false
+  def apply(file)
+    updated = client(Lbrt::Alert).apply(file)
+
+    unless updated
+      Lbrt::Logger.instance.info('No change'.intense_blue)
+    end
+  end
+
+  desc 'export [FILE]', 'Export alerts'
+  def export(file = nil)
+    dsl = client(Lbrt::Alert).export
+
+    if file.nil? or file == '-'
+      puts dsl
+    else
+      open(file, 'wb') {|f| f.puts dsl }
+    end
+  end
+end

data/lib/lbrt/cli/app.rb

@@ -0,0 +1,15 @@
+class Lbrt::CLI::App < Thor
+  class_option :user,  :default => ENV['LIBRATO_USER']
+  class_option :token, :default => ENV['LIBRATO_TOKEN']
+  class_option :color, :type => :boolean, :default => true
+  class_option :debug, :type => :boolean, :default => false
+
+  desc 'alert SUBCOMMAND', 'Manage alerts'
+  subcommand :alert, Lbrt::CLI::Alert
+
+  desc 'service SUBCOMMAND', 'Manage services'
+  subcommand :service, Lbrt::CLI::Service
+
+  desc 'space SUBCOMMAND', 'Manage spaces'
+  subcommand :space, Lbrt::CLI::Space
+end

data/lib/lbrt/cli/service.rb

@@ -0,0 +1,26 @@
+class Lbrt::CLI::Service < Thor
+  include Lbrt::Utils::CLIHelper
+
+  class_option :target
+
+  desc 'apply FILE', 'Apply services'
+  option :'dry-run', :type => :boolean, :default => false
+  def apply(file)
+    updated = client(Lbrt::Service).apply(file)
+
+    unless updated
+      Lbrt::Logger.instance.info('No change'.intense_blue)
+    end
+  end
+
+  desc 'export [FILE]', 'Export services'
+  def export(file = nil)
+    dsl = client(Lbrt::Service).export
+
+    if file.nil? or file == '-'
+      puts dsl
+    else
+      open(file, 'wb') {|f| f.puts dsl }
+    end
+  end
+end

data/lib/lbrt/cli/space.rb

@@ -0,0 +1,27 @@
+class Lbrt::CLI::Space < Thor
+  include Lbrt::Utils::CLIHelper
+
+  class_option :target
+  class_option :'export-concurrency', :type => :numeric, :default => 32
+
+  desc 'apply FILE', 'Apply spaces'
+  option :'dry-run', :type => :boolean, :default => false
+  def apply(file)
+    updated = client(Lbrt::Space).apply(file)
+
+    unless updated
+      Lbrt::Logger.instance.info('No change'.intense_blue)
+    end
+  end
+
+  desc 'export [FILE]', 'Export spaces'
+  def export(file = nil)
+    dsl = client(Lbrt::Space).export
+
+    if file.nil? or file == '-'
+      puts dsl
+    else
+      open(file, 'wb') {|f| f.puts dsl }
+    end
+  end
+end

data/lib/lbrt/driver.rb

@@ -0,0 +1,240 @@
+class Lbrt::Driver
+  include Lbrt::Logger::Helper
+
+  def initialize(client, options = {})
+    @client = client
+    @options = options
+  end
+
+  # Space
+
+  def create_space(name, expected)
+    updated = false
+
+    log(:info, "Create Space `#{name}`", :color => :cyan)
+
+    unless name.is_a?(String)
+      raise TypeError, "wrong argument type #{name.class}: #{name.inspect} (expected String)"
+    end
+
+    unless @options[:dry_run]
+      response = @client.spaces.post('name' => name)
+      expected['id'] = response.fetch('id')
+      updated = true
+    end
+
+    updated
+  end
+
+  def delete_space(name_or_id, actual)
+    updated = false
+
+    log(:info, "Delete Space `#{name_or_id}`", :color => :red)
+
+    space_id = actual.fetch('id')
+
+    unless @options[:dry_run]
+      @client.spaces(space_id).delete
+      updated = true
+    end
+
+    updated
+  end
+
+  # Chart
+
+  def create_chart(space_name_or_id, space_id, name, expected)
+    updated = false
+
+    log(:info, "Create Space `#{space_name_or_id}` > Chart `#{name}`", :color => :cyan)
+
+    unless name.is_a?(String)
+      raise TypeError, "wrong argument type #{name.class}: #{name.inspect} (expected String)"
+    end
+
+    unless @options[:dry_run]
+      response = @client.spaces(space_id).charts.post(expected.merge('name' => name))
+      expected['id'] = response.fetch('id')
+      updated = true
+    end
+
+    updated
+  end
+
+  def delete_chart(space_name_or_id, space_id, name_or_id, actual)
+    updated = false
+
+    log(:info, "Delete Space `#{space_name_or_id}` > `#{name_or_id}`", :color => :red)
+
+    chart_id = actual.fetch('id')
+
+    unless @options[:dry_run]
+      @client.spaces(space_id).charts(chart_id).delete
+      updated = true
+    end
+
+    updated
+  end
+
+  def update_chart(space_name_or_id, space_id, name_or_id, expected, actual)
+    updated = false
+
+    log(:info, "Update Space `#{space_name_or_id}` > Chart: #{name_or_id}", :color => :green)
+
+    delta = diff(Lbrt::Space::DSL::Converter,
+      {space_name_or_id => {'charts' => {name_or_id => actual}}},
+      {space_name_or_id => {'charts' => {name_or_id => expected}}}
+    )
+
+    log(:info, delta)
+
+    chart_id = actual.fetch('id')
+
+    unless @options[:dry_run]
+      params = chart_to_update_params(expected)
+      @client.spaces(space_id).charts(chart_id).put(params)
+      updated = true
+    end
+
+    updated
+  end
+
+  # Alert
+
+  def create_alert(name, expected)
+    updated = false
+
+    log(:info, "Create Alert `#{name}`", :color => :cyan)
+
+    unless @options[:dry_run]
+      params = alert_to_params(name, expected)
+      response = @client.alerts.post(params)
+      expected['id'] = response.fetch('id')
+      updated = true
+    end
+
+    updated
+  end
+
+  def delete_alert(name, actual)
+    updated = false
+
+    log(:info, "Delete Alert `#{name}`", :color => :red)
+
+    alert_id = actual.fetch('id')
+
+    unless @options[:dry_run]
+      @client.alerts(alert_id).delete
+      updated = true
+    end
+
+    updated
+  end
+
+  def update_alert(name, expected, actual)
+    updated = false
+
+    log(:info, "Update Alert `#{name}`", :color => :green)
+    log(:info, diff(Lbrt::Alert::DSL::Converter, {name => actual}, {name => expected}))
+
+    alert_id = actual.fetch('id')
+
+    unless @options[:dry_run]
+      params = alert_to_params(name, expected)
+      @client.alerts(alert_id).put(params)
+      updated = true
+    end
+
+    updated
+  end
+
+  # Service
+
+  def create_service(key, expected)
+    updated = false
+    type, title = key
+
+    log(:info, "Create Service `#{type}/#{title}`", :color => :cyan)
+
+    settings = expected.fetch('settings')
+
+    unless @options[:dry_run]
+      response = @client.services.post(
+        'title'    => title,
+        'type'     => type,
+        'settings' => settings
+      )
+
+      expected['id'] = response.fetch('id')
+      updated = true
+    end
+
+    updated
+  end
+
+  def delete_service(key, actual)
+    updated = false
+    type, title = key
+
+    log(:info, "Delete Service `#{type}/#{title}`", :color => :red)
+
+    service_id = actual.fetch('id')
+
+    unless @options[:dry_run]
+      @client.services(service_id).delete
+      updated = true
+    end
+
+    updated
+  end
+
+  def update_service(key, expected, actual)
+    updated = false
+    type, title = key
+
+    log(:info, "Update Service `#{type}/#{title}`", :color => :green)
+    log(:info, diff(Lbrt::Service::DSL::Converter, {key => actual}, {key => expected}))
+
+    service_id = actual.fetch('id')
+    settings = expected.fetch('settings')
+
+    unless @options[:dry_run]
+      @client.services(service_id).put(
+        'settings' => settings
+      )
+
+      updated = true
+    end
+
+    updated
+  end
+
+  private
+
+  def diff(converter, obj1, obj2)
+    diffy = Diffy::Diff.new(
+      converter.convert(obj1),
+      converter.convert(obj2),
+      :diff => '-u'
+    )
+
+    diffy.to_s(@options[:color] ? :color : :text).gsub(/\s+\z/m, '')
+  end
+
+  def alert_to_params(name, alert)
+    params = alert.dup
+    params['name'] = name
+    params['services'] = params.fetch('services').map {|i| i.fetch('id') }
+    params
+  end
+
+  def chart_to_update_params(chat)
+    params = chat.dup
+    # XXX: Correct?
+    params['chart_type'] = params.delete('type')
+    params['max'] ||= nil
+    params['min'] ||= nil
+    params['label'] ||= nil
+    params
+  end
+end