lbrt 0.1.0

data/lib/lbrt/ext/string_ext.rb

@@ -0,0 +1,25 @@
+class String
+  @@colorize = false
+
+  class << self
+    def colorize=(value)
+      @@colorize = value
+    end
+
+    def colorize
+      @@colorize
+    end
+  end # of class methods
+
+  Term::ANSIColor::Attribute.named_attributes.map do |attribute|
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{attribute.name}
+        if @@colorize
+          Term::ANSIColor.send(#{attribute.name.inspect}, self)
+        else
+          self
+        end
+      end
+    EOS
+  end
+end

data/lib/lbrt/logger.rb

@@ -0,0 +1,32 @@
+class Lbrt::Logger < ::Logger
+  include Singleton
+
+  def initialize
+    super($stdout)
+
+    self.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    self.level = INFO
+  end
+
+  def set_debug(value)
+    self.level = value ? DEBUG : INFO
+  end
+
+  module Helper
+    def log(level, message, opts = {})
+      global_options = (@options || {}).dup
+      global_options.delete(:color)
+      opts = global_options.merge(opts)
+
+      message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+      message << ' (dry-run)' if opts[:dry_run]
+      message = message.send(opts[:color]) if opts[:color]
+
+      logger = opts[:logger] || Lbrt::Logger.instance
+      logger.send(level, message)
+    end
+  end
+end

data/lib/lbrt/service.rb

@@ -0,0 +1,73 @@
+class Lbrt::Service
+  include Lbrt::Logger::Helper
+
+  def initialize(client, options = {})
+    @client = client
+    @options = options
+    @driver = Lbrt::Driver.new(@client, @options)
+  end
+
+  def export(export_options = {})
+    exported = Lbrt::Service::Exporter.export(@client, @options)
+    Lbrt::Service::DSL.convert(exported, @options)
+  end
+
+  def apply(file)
+    walk(file)
+  end
+
+  private
+
+  def walk(file)
+    expected = load_file(file)
+    actual = Lbrt::Service::Exporter.export(@client, @options)
+    walk_services(expected, actual)
+  end
+
+  def walk_services(expected, actual)
+    updated = false
+
+    expected.each do |key, expected_service|
+      next unless key.any? {|i| Lbrt::Utils.matched?(i, @options[:target]) }
+      actual_service = actual.delete(key)
+
+      if actual_service
+        updated = walk_service(key, expected_service, actual_service) || updated
+      else
+        updated = @driver.create_service(key, expected_service) || updated
+      end
+    end
+
+    actual.each do |key, actual_service|
+      next unless key.any? {|i| Lbrt::Utils.matched?(i, @options[:target]) }
+      updated = @driver.delete_service(key, actual_service) || updated
+    end
+
+    updated
+  end
+
+  def walk_service(key, expected, actual)
+    updated = false
+
+    actual_without_id = actual.dup
+    service_id = actual_without_id.delete('id')
+
+    if expected != actual_without_id
+      updated = @driver.update_service(key, expected.merge('id' => service_id), actual) || updated
+    end
+
+    updated
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        Lbrt::Service::DSL.parse(f.read, file)
+      end
+    elsif [File, Tempfile].any? {|i| file.kind_of?(i) }
+      Lbrt::Service::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+end

data/lib/lbrt/service/dsl.rb

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

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

@@ -0,0 +1,33 @@
+class Lbrt::Service::DSL::Context
+  include Lbrt::Utils::ContextHelper
+
+  def self.eval(dsl, path, options = {})
+    self.new(path, options) {
+      eval(dsl, binding, path)
+    }
+  end
+
+  attr_reader :result
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = {}
+    instance_eval(&block)
+  end
+
+  private
+
+  def service(type, title, &block)
+    type = type.to_s
+    title = title.to_s
+    key = [type, title]
+
+    if @result[key]
+      raise "Service `#{type}/#{title}` is already defined"
+    end
+
+    srvc = Lbrt::Service::DSL::Context::Service.new(type, title, &block).result
+    @result[key] = srvc
+  end
+end

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

@@ -0,0 +1,32 @@
+class Lbrt::Service::DSL::Context::Service
+  REQUIRED_ATTRIBUTES = %w(
+    settings
+  )
+
+  def initialize(type, title, &block)
+    @type = type
+    @title = title
+    @result = {}
+    instance_eval(&block)
+  end
+
+  def result
+    REQUIRED_ATTRIBUTES.each do |name|
+      unless @result.has_key?(name)
+        raise "Service `#{@type}/#{@title}`: #{name} is not defined"
+      end
+    end
+
+    @result
+  end
+
+  private
+
+  def settings(value)
+    unless value.is_a?(Hash)
+      raise TypeError, "wrong argument type #{value.class}: #{value.inspect} (expected Hash)"
+    end
+
+    @result['settings'] = value
+  end
+end

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

@@ -0,0 +1,38 @@
+class Lbrt::Service::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_services(@exported)
+  end
+
+  private
+
+  def output_services(service_by_key)
+    services = []
+
+    service_by_key.sort_by(&:first).map do |key, attrs|
+      next unless key.any? {|i| Lbrt::Utils.matched?(i, @options[:target]) }
+      services << output_service(key, attrs)
+    end
+
+    services.join("\n")
+  end
+
+  def output_service(key, attrs)
+    type, title = key
+    settings = attrs.fetch('settings')
+
+    <<-EOS
+service #{type.inspect}, #{title.inspect} do
+  settings #{Lbrt::Utils.unbrace(settings.inspect)}
+end
+    EOS
+  end
+end

data/lib/lbrt/service/exporter.rb

@@ -0,0 +1,37 @@
+class Lbrt::Service::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
+    services = @client.services.get
+    normalize(services)
+  end
+
+  private
+
+  def normalize(services)
+    service_by_key = {}
+
+    services.each do |srvc|
+      type = srvc.delete('type')
+      title = srvc.delete('title')
+      service_key = [type, title]
+
+      if service_by_key[service_key]
+        raise "Duplicate service type/title exists: #{type}/#{title}"
+      end
+
+      service_by_key[service_key] = srvc
+    end
+
+    service_by_key
+  end
+end

data/lib/lbrt/space.rb

@@ -0,0 +1,126 @@
+class Lbrt::Space
+  include Lbrt::Logger::Helper
+
+  def initialize(client, options = {})
+    @client = client
+    @options = options
+    @driver = Lbrt::Driver.new(@client, @options)
+  end
+
+  def export(export_options = {})
+    exported = Lbrt::Space::Exporter.export(@client, @options)
+    Lbrt::Space::DSL.convert(exported, @options)
+  end
+
+  def apply(file)
+    walk(file)
+  end
+
+  private
+
+  def walk(file)
+    expected = load_file(file)
+    actual = Lbrt::Space::Exporter.export(@client, @options)
+    walk_spaces(expected, actual)
+  end
+
+  def walk_spaces(expected, actual)
+    updated = false
+
+    expected.each do |name_or_id, expected_space|
+      actual_space = actual.delete(name_or_id)
+
+      if not actual_space and name_or_id.is_a?(Integer)
+        actual_space = actual.values.find {|i| i['id'] == name_or_id }
+      end
+
+      unless actual_space
+        updated = @driver.create_space(name_or_id, expected_space) || updated
+        actual_space = expected_space.merge('charts' => {})
+
+        # Set dummy id for dry-run
+        actual_space['id'] ||= -1
+      end
+
+      updated = walk_space(name_or_id, expected_space, actual_space) || updated
+    end
+
+    actual.each do |name_or_id, actual_space|
+      updated = @driver.delete_space(name_or_id, actual_space) || updated
+    end
+
+    updated
+  end
+
+  def walk_space(name_or_id, expected, actual)
+    updated = false
+    space_id = actual.fetch('id')
+    expected_charts = expected.fetch('charts')
+    actual_charts = actual.fetch('charts')
+    updated = walk_charts(name_or_id, space_id, expected_charts, actual_charts) || updated
+    updated
+  end
+
+  def walk_charts(space_name_or_id, space_id, expected, actual)
+    updated = false
+
+    expected.each do |name_or_id, expected_chart|
+      actual_chart = actual.delete(name_or_id)
+
+      if not actual_chart and name_or_id.is_a?(Integer)
+        actual_chart = actual.values.find {|i| i['id'] == name_or_id }
+      end
+
+      if actual_chart
+        updated = walk_chart(space_name_or_id, space_id, name_or_id, expected_chart, actual_chart) || updated
+      else
+        updated = @driver.create_chart(space_name_or_id, space_id, name_or_id, expected_chart) || updated
+      end
+    end
+
+    actual.each do |name_or_id, actual_chart|
+      updated = @driver.delete_chart(space_name_or_id, space_id, name_or_id, actual_chart) || updated
+    end
+
+    updated
+  end
+
+  def walk_chart(space_name_or_id, space_id, name_or_id, expected, actual)
+    updated = false
+
+    actual_without_id = actual.dup
+    alert_id = actual_without_id.delete('id')
+
+    if differ_chart?(expected, actual_without_id)
+      updated = @driver.update_chart(space_name_or_id, space_id, name_or_id, expected.merge('id' => alert_id), actual) || updated
+    end
+
+    updated
+  end
+
+  def differ_chart?(chart1, chart2)
+    chart1 = normalize_chart(chart1)
+    chart2 = normalize_chart(chart2)
+    chart1 != chart2
+  end
+
+  def normalize_chart(chart)
+    chart = chart.dup
+    chart_streams = chart['streams'].dup
+    chart_streams.each {|i| i.delete('id') }
+    chart['streams'] = chart_streams
+    chart
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        Lbrt::Space::DSL.parse(f.read, file)
+      end
+    elsif [File, Tempfile].any? {|i| file.kind_of?(i) }
+      Lbrt::Space::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+end

data/lib/lbrt/space/dsl.rb

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

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

@@ -0,0 +1,29 @@
+class Lbrt::Space::DSL::Context
+  include Lbrt::Utils::ContextHelper
+
+  def self.eval(dsl, path, options = {})
+    self.new(path, options) {
+      eval(dsl, binding, path)
+    }
+  end
+
+  attr_reader :result
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = {}
+    instance_eval(&block)
+  end
+
+  private
+
+  def space(name_or_id, &block)
+    if @result[name_or_id]
+      raise "Space `#{name_or_id}` is already defined"
+    end
+
+    spc = Lbrt::Space::DSL::Context::Space.new(name_or_id, &block).result
+    @result[name_or_id] = spc
+  end
+end