konzertmeister 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5679713dea43f8aa152592f629a42b5a7ae79d89
+  data.tar.gz: 6bd78152ad09ed1ae8d9daf7f42c124c8b61ed2e
+SHA512:
+  metadata.gz: e5888c8b9b3277252faa67d3c259ff22640b4caf88437f250b26a5fdd606941eea6b032bb39f1bf64e4cc48220f8acbeabaa8d1d56bc2fdff232bb3a680809fd
+  data.tar.gz: 8d500622431f22d2625ab48e55add264d3841862803a3ea7412fd49b72d4b4a48a8de518f05a33e60f3a6dbbb1672348b940f61c42b49784a71ea04d3ea6166f

data/lib/konzertmeister.rb

@@ -0,0 +1,34 @@
+require 'rest-client'
+
+class Konzertmeister
+  autoload :Backend, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'backend.rb'))
+  autoload :Host, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'host.rb'))
+  autoload :Customer, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'customer.rb'))
+  autoload :MetaVersion, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'meta_version.rb'))
+  autoload :InfrastructureVersion, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'infrastructure_version.rb'))
+  autoload :ProductVersion, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'product_version.rb'))
+  autoload :Session, File.expand_path(File.join(File.dirname(__FILE__), 'konzertmeister', 'session.rb'))
+
+  def self.session
+    return @@session
+  end
+
+  def self.session=(new_session)
+    @@session = new_session
+    return @@session
+  end
+
+  def self.new_session(
+    hostname: 'konzertmeister',
+    port: 443,
+    ssl_client_cert: nil,
+    ssl_client_key: nil
+  )
+    @@session = Konzertmeister::Session.new(
+      hostname: hostname,
+      port: port,
+      ssl_client_cert: ssl_client_cert,
+      ssl_client_key: ssl_client_key
+    )
+  end
+end

data/lib/konzertmeister/backend.rb

@@ -0,0 +1,197 @@
+class Konzertmeister
+  class Backend
+    KINDS = %w[
+      production
+      sandbox
+      development
+      internal
+    ]
+
+    attr_accessor :name, :kind
+    attr_reader :id, :short_name, :puppet_master, :monthly_cost, :created_at, :updated_at
+
+    def self.all
+      response = Konzertmeister.session.get('/backends')
+      if response
+        response.map do |data|
+          Konzertmeister::Backend.new(data)
+        end.sort_by do |b|
+          "#{b.customer.short_name} #{b.short_name}"
+        end
+      end
+    end
+
+    def self.find_by(attr, value)
+      Backend.new(Konzertmeister.session.get("/backends/#{attr}/#{value}"))
+    end
+
+    def initialize(data = {})
+      @data = data
+      data.each do |k,value|
+        next if %w[hosts customer meta_version].include?(k)
+
+        if m = k.match(/^backend_(.*)$/)
+          key = m[1]
+        else
+          key = k
+        end
+
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def save
+      params = {
+        backend_platform: 'Rackspace',
+        backend_name: name,
+        backend_kind: kind,
+        customer: {customer_id: customer.id},
+        meta_version: {meta_version_id: meta_version.id},
+        coda_count: coda_count,
+        coda_flavor: coda_flavor,
+        postgres_flavor: postgres_flavor
+      }
+      puts "Creating with params: #{params}"
+
+      response = Konzertmeister.session.post("/backends", params)
+      if response 
+        response_object = Konzertmeister::Backend.new(response)
+        @id = response_object.id
+        @short_name = response_object.short_name
+        @puppet_master = response_object.puppet_master
+        @monthly_cost = response_object.monthly_cost
+        @created_at = response_object.created_at
+        @updated_at = response_object.updated_at
+        response_object
+      end
+    end
+
+    def hosts
+      @hosts ||= if @data.key?('hosts')
+          @data.fetch('hosts').map do |host_hash|
+            Konzertmeister::Host.new(host_hash)
+          end.sort_by(&:hostname)
+        else
+          Backend.find_by('id', self.id).hosts
+        end
+    end
+
+    def coda_count
+      @coda_count ||= self.hosts.size
+    end
+
+    def coda_count=(size)
+      @coda_count = size
+    end
+
+    def coda_flavor
+      @coda_flavor ||= self.hosts.find{|h| h.kind == Konzertmeister::Host::CODA_KIND}.flavor
+    end
+
+    def coda_flavor=(input_flavor)
+      if Konzertmeister::Host::FLAVORS.include?(input_flavor)
+        @coda_flavor = input_flavor
+      else
+        raise "Invalid flavor: #{input_flavor}. Choose one of: #{Konzertmeister::Host::Flavors.join(', ')}"
+      end
+    end
+
+    def postgres_flavor
+      @postgres_flavor ||= self.hosts.find{|h| h.kind == Konzertmeister::Host::POSTGRES_KIND}.flavor
+    end
+
+    def postgres_flavor=(input_flavor)
+      if Konzertmeister::Host::FLAVORS.include?(input_flavor)
+        @postgres_flavor = input_flavor
+      else
+        raise "Invalid flavor: #{input_flavor}. Choose one of: #{Konzertmeister::Host::Flavors.join(', ')}"
+      end
+    end
+
+    def meta_version
+      @meta_version ||= if @data.key?('meta_version')
+           Konzertmeister::MetaVersion.new(@data.fetch('meta_version'))
+         else
+           Backend.find_by('id', self.id).meta_version
+         end
+    end
+
+    def meta_version=(input_mv)
+      @meta_version = input_mv
+    end
+
+    def customer
+      @customer ||= if @data.key?('customer')
+          Konzertmeister::Customer.new(@data.fetch('customer'))
+        else
+          Backend.find_by('id', self.id).customer
+        end
+    end
+
+    def customer=(input_customer)
+      @customer = input_customer
+    end
+
+    def proxy_host
+      @proxy_host ||= @data.fetch('proxy').fetch('proxy_host')
+    end
+
+    def proxy_port
+      @proxy_port ||= @data.fetch('proxy').fetch('proxy_port')
+    end
+
+    def full_name
+      [
+        short_name,
+        customer.short_name
+      ].join("-")
+    end
+
+    def fqdn(scope = nil)
+      first = scope.nil? ? full_name : "#{full_name}-admin"
+      [
+        first,
+        "backend",
+        "tempoiq",
+        "com"
+      ].join(".")
+    end
+
+    def production?
+      @kind == 'production'
+    end
+
+    def ssh_prefix(user, port=1535, *args)
+      proxy = @data.fetch("proxy")
+      proxy_host = proxy.fetch("proxy_host")
+      proxy_port = proxy.fetch("proxy_port")
+
+      %Q{ssh -p #{port} -o "ProxyCommand ssh -p #{proxy_port} #{user}@#{proxy_host} nc %h %p" #{args.join(' ')}}
+    end
+
+    def proxy_command(host, user, port=1535, *args)
+      prefix = ssh_prefix(user, port, *args)
+      %Q{#{prefix} #{user}@#{host.management_ip}}
+    end
+
+    def rsync_up_command(host, user, file_local, file_remote="", port=1535, *args)
+      prefix = ssh_prefix(user, port, *args)
+      %Q{rsync -avzP -e '#{prefix}' #{file_local} #{user}@#{host.management_ip}:#{file_remote}}
+    end
+
+    def rsync_down_command(host, user, file_remote, file_local, port=1535, *args)
+      prefix = ssh_prefix(user, port, *args)
+      %Q{rsync -avzP -e '#{prefix}' #{user}@#{host.management_ip}:#{file_remote} #{file_local}}
+    end
+
+    def to_s
+      cost = "%1.2f" % monthly_cost
+
+      ([
+       "$#{cost}/month #{full_name} (#{kind})",
+       "MetaVersion: #{meta_version}",
+       "Hosts:"
+      ] + hosts.sort_by(&:name).map {|h| " #{h}"}).join("\n")
+    end
+  end
+end

data/lib/konzertmeister/customer.rb

@@ -0,0 +1,65 @@
+class Konzertmeister
+  class Customer
+    attr_accessor :name
+    attr_reader :id, :short_name, :created_at, :updated_at
+
+    def self.all
+      response = Konzertmeister.session.get('/customers')
+      if response
+        response.map do |data|
+          Konzertmeister::Customer.new(data)
+        end.sort_by(&:short_name)
+      end
+    end
+
+    def self.find_by(attr, value)
+      Customer.new(Konzertmeister.session.get("/customers/#{attr}/#{value}"))
+    end
+
+    def initialize(data = {})
+      @data = data
+      data.each do |k,value|
+        next if k == 'backends'
+
+        if m = k.match(/^customer_(.*)$/)
+          key = m[1]
+        else
+          key = k
+        end
+
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def save
+      params = {
+        customer_name: name
+      }
+      response = Konzertmeister.session.post("/customers", params)
+      if response
+        response_object = Konzertmeister::Customer.new(response)
+        @id = response_object.id
+        @short_name = response_object.short_name
+      end
+    end
+
+    def backends
+      @backends ||= if @data.key?('backends')
+          @data.fetch('backends').map do |be_hash|
+            Konzertmeister::Backend.new(be_hash)
+          end.sort_by(&:short_name)
+        else
+          Customer.find_by('id', self.id).backends
+        end
+    end
+
+    def to_s
+      monthly_cost = backends.inject(0) do |sum, backend|
+        sum + backend.monthly_cost
+      end
+
+      cost_string = "$%1.2f/month" % [monthly_cost]
+      "%-14s %s" % [cost_string, "#{name} (#{short_name})"]
+    end
+  end
+end

data/lib/konzertmeister/host.rb

@@ -0,0 +1,66 @@
+class Konzertmeister
+  class Host
+    FLAVORS = %w[
+      2x_small
+      extra_small
+      small
+      medium
+      large
+      extra_large
+      2x_large
+    ]
+    POSTGRES_KIND = 'postgres'
+    CODA_KIND = 'coda'
+    UTIL_KIND = 'util'
+
+    attr_reader :id, :hostname, :backend_ip, :management_ip, :kind, :token, :status, :monthly_cost, :created_at, :updated_at, :flavor
+
+    def self.all
+      response = Konzertmeister.session.get('/hosts')
+      if response
+        response.map do |data|
+          Konzertmeister::Host.new(data)
+        end.sort_by(&:hostname)
+      end
+    end
+
+    def self.find_by(attr, value)
+      Host.new(Konzertmeister.session.get("/hosts/#{attr}/#{value}"))
+    end
+
+    def initialize(data)
+      @data = data
+      data.each do |k,value|
+        next if %w[backend].include?(k)
+        if m = k.match(/^host_(.*)$/)
+          key = m[1]
+        else
+          key = k
+        end
+
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def backend
+      @backend ||= if @data.key?('backend')
+          Konzertmeister::Backend.new(@data.fetch('backend'))
+        else
+          Host.find_by('id', self.id).backend
+      end
+    end
+
+    def name
+      "#{kind}-#{token}"
+    end
+
+    def to_s
+      if status == "active"
+        cost_string = "$%1.2f/month" % [monthly_cost]
+        "%-14s %s" % [cost_string, name]
+      else
+        "%-14s %s" % ["(inactive)", name]
+      end
+    end
+  end
+end

data/lib/konzertmeister/infrastructure_version.rb

@@ -0,0 +1,65 @@
+class Konzertmeister
+  class InfrastructureVersion
+    attr_reader :id, :commit, :tag, :branch, :created_at, :updated_at
+
+    def initialize(data = {})
+      @data = data
+      data.each do |k,value|
+        if m = k.match(/^infrastructure_version_id$/)
+          key = "id"
+        else
+          key = k
+        end
+
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def save
+      if commit
+        params = { 'commit' => commit }
+      elsif tag
+        params = { 'tag' => tag }
+      elsif branch
+        params = { 'branch' => branch }
+      end
+
+      response = Konzertmeister.session.post('/infrastructure_versions', params)
+      if response
+        response_object = Konzertmeister::InfrastructureVersion.new(response)
+        @id = response_object.id
+        response_object
+      end
+    end
+
+    def commit=(input_commit)
+      remove_instance_variable(:@tag) if instance_variable_defined?(:@tag)
+      remove_instance_variable(:@branch) if instance_variable_defined?(:@branch)
+      @commit = input_commit
+    end
+
+    def tag=(input_tag)
+      remove_instance_variable(:@branch) if instance_variable_defined?(:@branch)
+      remove_instance_variable(:@commit) if instance_variable_defined?(:@commit)
+      @tag = input_tag
+    end
+
+    def branch=(input_branch)
+      remove_instance_variable(:@tag) if instance_variable_defined?(:@tag)
+      remove_instance_variable(:@commit) if instance_variable_defined?(:@commit)
+      @branch = input_branch
+    end
+
+    def to_s
+      if @data.has_key?("commit")
+        inf_version_string = "commit:#{@data["commit"]}"
+      elsif @data.has_key?("tag")
+        inf_version_string = "tag:#{@data["tag"]}"
+      else
+        inf_version_string = "branch:#{@data["branch"]}"
+      end
+
+      "Inf<#{inf_version_string}>"
+    end
+  end
+end

data/lib/konzertmeister/meta_version.rb

@@ -0,0 +1,109 @@
+class Konzertmeister
+  class MetaVersion
+    attr_reader :id, :created_at, :updated_at
+
+    def self.all
+      response = Konzertmeister.session.get('/meta_versions')
+      if response
+        response.map do |data|
+          Konzertmeister::MetaVersion.new(data)
+        end
+      end
+    end
+
+    def self.find_by(attr, value)
+      MetaVersion.new(Konzertmeister.session.get("/meta_versions/#{attr}/#{value}"))
+    end
+
+    def initialize(data = {})
+      @data = data
+      data.each do |k,value|
+        next if %w[
+          infrastructure_version
+          tapp_version
+          legato_version
+          forte_version
+          backends
+        ].include?(k)
+
+        if m = k.match(/^meta_version_(.*)$/)
+          key = m[1]
+        else
+          key = k
+        end
+
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def save
+      params = {
+        'infrastructure_version' => {'infrastructure_version_id' => infrastructure_version.id},
+        'tapp_version' => {'tapp_version_id' => tapp_version.id},
+        'legato_version' => {'legato_version_id' => legato_version.id},
+        'forte_version' => {'forte_version_id' => forte_version.id}
+      }
+      response = Konzertmeister.session.post('/meta_versions', params)
+      if response
+        response_object = Konzertmeister::MetaVersion.new(response)
+        @id = response_object.id
+        response_object
+      end
+    end
+
+    def infrastructure_version
+      @infrastructure_version ||= Konzertmeister::InfrastructureVersion.new(@data.fetch("infrastructure_version"))
+    end
+
+    def infrastructure_version=(input_iv)
+      @infrastructure_version = input_iv
+    end
+
+    def tapp_version
+      @tapp_version ||= Konzertmeister::ProductVersion.new("tapp", @data.fetch("tapp_version"))
+    end
+
+    def tapp_version=(input_tv)
+      @tapp_version = input_tv
+    end
+
+    def legato_version
+      @legato_version ||= Konzertmeister::ProductVersion.new("legato", @data.fetch("legato_version"))
+    end
+
+    def legato_version=(input_lv)
+      @legato_version = input_lv
+    end
+
+    def forte_version
+      @forte_version ||= Konzertmeister::ProductVersion.new("forte", @data.fetch("forte_version"))
+    end
+
+    def forte_version=(input_fv)
+      @forte_version = input_fv
+    end
+
+    def to_s(format = :short)
+      fields = [
+        id,
+        infrastructure_version,
+        tapp_version,
+        legato_version,
+        forte_version
+      ]
+      table_widths = "%-3s %-25s %-20s %-25s %-25s"
+
+      if @data.has_key?("backends")
+        fields << "Backends: #{@data.fetch("backends").size}"
+        table_widths += " %-11s"
+      end
+
+      case format
+      when :short
+        fields.join(" ")
+      when :table
+        table_widths % fields
+      end
+    end
+  end
+end

data/lib/konzertmeister/product_version.rb

@@ -0,0 +1,33 @@
+class Konzertmeister
+  class ProductVersion
+    attr_accessor :version
+    attr_reader :id, :product, :created_at, :updated_at
+
+    def initialize(product, data = {})
+      @product = product
+      @data = data
+      data.each do |k,value|
+        if m = k.match(/^(tapp|legato|forte)_version_id$/)
+          key = "id"
+        else
+          key = k
+        end
+
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def save
+      response = Konzertmeister.session.post("/#{product}_versions", {'version' => version})
+      if response
+        response_object = Konzertmeister::ProductVersion.new(product, response)
+        @id = response_object.id
+        response_object
+      end
+    end
+
+    def to_s
+      "#{@product.capitalize}<#{version}>"
+    end
+  end
+end

data/lib/konzertmeister/session.rb

@@ -0,0 +1,74 @@
+require 'rest-client'
+
+class Konzertmeister
+  class Session
+
+    def initialize(
+      hostname: 'konzertmeister',
+      port: 443,
+      ssl_client_cert: nil,
+      ssl_client_key: nil
+    )
+      @ssl_client_cert = OpenSSL::X509::Certificate.new(File.read(ssl_client_cert)) unless ssl_client_cert.nil?
+      @ssl_client_key = OpenSSL::PKey::RSA.new(File.read(ssl_client_key)) unless ssl_client_key.nil?
+      @hostname = hostname
+      @port = port
+    end
+
+    def get(path, headers = {}, &block)
+      url = _url(path)
+      params = _request_params(
+        :method => :get,
+        :url => url,
+        :headers => headers,
+        :timeout => nil
+      )
+      begin
+        json = RestClient::Request.execute(params, &block)
+        JSON.parse(json)
+      rescue => e
+        puts "ERROR"
+        p e
+        false
+      end
+    end
+
+    def post(path, params, headers = {}, &block)
+      json = JSON.generate(params)
+      url = _url(path)
+      request_params = _request_params({
+        :method => :post,
+        :url => url,
+        :payload => json,
+        :headers => headers,
+        :timeout => nil
+      })
+      begin
+        response = RestClient::Request.execute(request_params, &block)
+        JSON.parse(response)
+      rescue RestClient::Exception => e
+        puts
+        puts "ERROR making request to #{path}:"
+        p e
+        false
+      end
+    end
+
+    def _request_params(extra = {})
+      base = {}
+      base[:ssl_client_cert] = @ssl_client_cert if @ssl_client_cert
+      base[:ssl_client_key] = @ssl_client_key if @ssl_client_key
+
+      base.merge(extra)
+    end
+
+    def _url(path = nil)
+      scheme = (@port == 443 ? "https" : "http")
+      [
+        "#{scheme}://#{@hostname}:#{@port}",
+        path
+      ].compact.join("")
+    end
+
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: konzertmeister
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- TempoIQ Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: This is the client code for an internal book-keeping and cloud orchestration
+  service named Konzertmeister.
+email:
+- service@tempoiq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/konzertmeister.rb
+- lib/konzertmeister/backend.rb
+- lib/konzertmeister/customer.rb
+- lib/konzertmeister/host.rb
+- lib/konzertmeister/infrastructure_version.rb
+- lib/konzertmeister/meta_version.rb
+- lib/konzertmeister/product_version.rb
+- lib/konzertmeister/session.rb
+homepage: http://tempoiq.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Konzertmeister http client
+test_files: []