gce-host 0.1.0

data/lib/gce/host/gce_client.rb

@@ -0,0 +1,69 @@
+require_relative 'version'
+require 'google/apis/compute_v1'
+
+class GCE
+  class Host
+    class GCEClient
+      class Error < ::StandardError; end
+      class NotFound < Error; end
+
+      def instances(condition = {})
+        filter = build_filter(condition)
+        instances = []
+        res = client.list_aggregated_instances(Config.project, filter: filter)
+        instances.concat(res.items.values.map(&:instances).compact.flatten(1))
+        while res.next_page_token
+          res = client.list_aggregated_instances(Config.project, filter: filter, page_token: res.next_page_token)
+          instances.concat(res.items.values.map(&:instances).compact.flatten(1))
+        end
+        instances
+      end
+
+      private
+
+      def client
+        return @client if @client && @client_expiration > Time.now
+
+        scope = "https://www.googleapis.com/auth/compute.readonly"
+        client = Google::Apis::ComputeV1::ComputeService.new
+        client.client_options.application_name = 'gce-host'
+        client.client_options.application_name = GCE::Host::VERSION
+        client.request_options.retries = Config.retries
+        client.request_options.timeout_sec = Config.timeout_sec
+        client.request_options.open_timeout_sec = Config.open_timeout_sec
+
+        case Config.auth_method
+        when 'compute_engine'
+          auth = Google::Auth::GCECredentials.new
+
+        when 'json_key'
+          credential_file = Config.credential_file
+          auth = File.open(credential_file) do |f|
+            Google::Auth::ServiceAccountCredentials.make_creds(json_key_io: f, scope: scope)
+          end
+
+        when 'application_default'
+          auth = Google::Auth.get_application_default([scope])
+
+        else
+          raise ConfigError, "Unknown auth method: #{Config.auth_method}"
+        end
+
+        client.authorization = auth
+
+        @client_expiration = Time.now + 1800
+        @client = client
+      end
+
+      # MEMO: OR did not work
+      # MEMO: filter for metadata and tags did not work (metadata.items[0].value eq role)
+      def build_filter(condition)
+        if names = (condition[:name] || condition[:hostname]) and Array(names).size == 1
+          "name eq #{Array(names).first}"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/gce/host/hash_util.rb

@@ -0,0 +1,11 @@
+class GCE
+  class Host
+    module HashUtil
+      def self.except(hash, *keys)
+        hash = hash.dup
+        keys.each {|key| hash.delete(key) }
+        hash
+      end
+    end
+  end
+end

data/lib/gce/host/host_data.rb

@@ -0,0 +1,227 @@
+require 'json'
+
+class GCE
+  class Host
+    # Represents each host
+    class HostData
+      attr_reader :instance
+
+      # :hostname, # hostname
+      # :roles,    # roles.split(',') such as web:app1,db:app1
+      # :instance, # Aws::GCE::Types::Instance itself
+      #
+      # and OPTIONAL_ARRAY_KEYS, OPTIONAL_STRING_KEYS
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def hostname
+        instance.name
+      end
+
+      def roles
+        return @roles if @roles
+        roles = find_array_key(Config.roles_key)
+        @roles = roles.map {|role| GCE::Host::RoleData.build(role) }
+      end
+
+      Config.optional_string_keys.each do |key|
+        field = StringUtil.underscore(key)
+        define_method(field) do
+          instance_variable_get("@#{field}") || instance_variable_set("@#{field}", find_string_key(key))
+        end
+      end
+
+      Config.optional_array_keys.each do |key|
+        field = StringUtil.underscore(key)
+        define_method(field) do
+          instance_variable_get("@#{field}") || instance_variable_set("@#{field}", find_array_key(key))
+        end
+      end
+
+      define_method(Config.status) do
+        instance.status
+      end
+
+      def instance_id
+        instance.id
+      end
+
+      def zone
+        instance.zone.split('/').last
+      end
+
+      def private_ip_address
+        instance.network_interfaces.first.network_ip
+      end
+
+      def private_ip_addresses
+        instance.network_interfaces.map(&:network_ip)
+      end
+
+      def public_ip_address
+        instance.network_interfaces.first.access_configs.first.nat_ip
+      end
+
+      def public_ip_addresses
+        instance.network_interfaces.map {|i| i.access_configs.map(&:nat_ip) }.flatten(1)
+      end
+
+      def creation_timestamp
+        instance.creation_timestamp
+      end
+
+      # compatibility with dino-host
+      def ip
+        private_ip_address
+      end
+
+      # compatibility with dino-host
+      def start_date
+        creation_timestamp
+      end
+
+      # compatibility with dino-host
+      def usages
+        roles
+      end
+
+      def terminated?
+        instance.status == "TERMINATED"
+      end
+
+      def stopping?
+        instance.status == "STOPPING"
+      end
+
+      def running?
+        instance.status == "RUNNING"
+      end
+
+      def staging?
+        instance.status == "STAGING"
+      end
+
+      def provisioning?
+        instance.status == "PROVISIONING"
+      end
+
+      # match with condition or not
+      #
+      # @param [Hash] condition search parameters
+      def match?(condition)
+        return false if !condition[Config.status.to_sym] and (terminated? or stopping?)
+        return false unless role_match?(condition)
+        return false unless status_match?(condition)
+        return false unless instance_match?(condition)
+        true
+      end
+
+      def to_hash
+        params = {
+          "hostname" => hostname,
+          "roles" => roles,
+          "zone" => zone,
+        }
+        Config.optional_string_keys.each do |key|
+          field = StringUtil.underscore(key)
+          params[field] = send(field)
+        end
+        Config.optional_array_keys.each do |key|
+          field = StringUtil.underscore(key)
+          params[field] = send(field)
+        end
+        params.merge!(
+          "instance_id" => instance_id,
+          "private_ip_address" => private_ip_address,
+          "public_ip_address" => public_ip_address,
+          "creation_timestamp" => creation_timestamp,
+          Config.status => send(Config.status),
+        )
+      end
+
+      def info
+        if self.class.display_short_info?
+          info = "#{hostname}:#{status}"
+          info << "(#{roles.join(',')})" unless roles.empty?
+          info << "[#{tags.join(',')}]" unless tags.empty?
+          info << "{#{service}}" unless service.empty?
+          info
+        else
+          to_hash.to_s
+        end
+      end
+
+      def inspect
+        sprintf "#<GCE::Host::HostData %s>", info
+      end
+
+      private
+
+      def find_string_key(key)
+        item = instance.metadata.items.find {|item| item.key == key } if instance.metadata.items
+        item ? item.value : ''
+      end
+
+      def find_array_key(key)
+        item = instance.metadata.items.find {|item| item.key == key } if instance.metadata.items
+        item ? item.value.split(Config.array_value_delimiter) : []
+      end
+
+      def role_match?(condition)
+        # usage is an alias of role
+        if role = (condition[:role] || condition[:usage])
+          role1, role2, role3 = role.first.split(':')
+        else
+          role1 = (condition[:role1] || condition[:usage1] || []).first
+          role2 = (condition[:role2] || condition[:usage2] || []).first
+          role3 = (condition[:role3] || condition[:usage3] || []).first
+        end
+        if role1
+          return false unless roles.find {|role| role.match?(role1, role2, role3) }
+        end
+        true
+      end
+
+      def status_match?(condition)
+        if values = condition[Config.status.to_sym]
+          return false unless values.map(&:downcase).include?(send(Config.status).downcase)
+        end
+        true
+      end
+
+      def instance_match?(condition)
+        condition = HashUtil.except(condition, :role, :role1, :role2, :role3, :usage, :usage1, :usage2, :usage3, Config.status.to_sym)
+        condition.each do |key, values|
+          v = instance_variable_recursive_get(key)
+          if v.is_a?(Array)
+            return false unless v.find {|_| values.include?(_) }
+          else
+            return false unless values.include?(v)
+          end
+        end
+        true
+      end
+
+      # "instance.instance_id" => self.instance.instance_id
+      def instance_variable_recursive_get(key)
+        v = self
+        key.to_s.split('.').each {|k| v = v.send(k) }
+        v
+      end
+
+      # compatibility with dono-host
+      #
+      # If service,status,tags keys are defined
+      #
+      #     OPTIONAL_STRING_KEYS=service,status
+      #     OPTIONAL_ARRAY_KEYS=tags
+      #
+      # show in short format, otherwise, same with to_hash.to_s
+      def self.display_short_info?
+        return @display_short_info unless @display_short_info.nil?
+        @display_short_info = method_defined?(:service) and method_defined?(:status) and method_defined?(:tags)
+      end
+    end
+  end
+end

data/lib/gce/host/role_data.rb

@@ -0,0 +1,64 @@
+class GCE
+  class Host
+    # Represents each role
+    class RoleData
+      attr_reader :role1, :role2, :role3
+
+      def initialize(role1, role2 = nil, role3 = nil)
+        @role1 = role1
+        @role2 = role2
+        @role3 = role3
+      end
+
+      def self.build(role)
+        role1, role2, role3 = role.split(Config.role_value_delimiter, 3)
+        new(role1, role2, role3)
+      end
+
+      # @return [String] something like "admin:jenkins:slave"
+      def role
+        @role ||= [role1, role2, role3].compact.reject(&:empty?).join(Config.role_value_delimiter)
+      end
+      alias :to_s :role
+
+      # @return [Array] something like ["admin", "admin:jenkins", "admin:jenkins:slave"]
+      def uppers
+        uppers = [RoleData.new(role1)]
+        uppers << RoleData.new(role1, role2) if role2 and !role2.empty?
+        uppers << RoleData.new(role1, role2, role3) if role3 and !role3.empty?
+        uppers
+      end
+
+      def match?(role1, role2 = nil, role3 = nil)
+        if role3
+          role1 == self.role1 and role2 == self.role2 and role3 == self.role3
+        elsif role2
+          role1 == self.role1 and role2 == self.role2
+        else
+          role1 == self.role1
+        end
+      end
+
+      # Equality
+      #
+      #     Role::Data.new('admin') == Role::Data.new('admin') #=> true
+      #     Role::Data.new('admin', 'jenkin') == "admin:jenkins" #=> true
+      #
+      # @param [Object] other
+      def ==(other)
+        case other
+        when String
+          self.role == other
+        when GCE::Host::RoleData
+          super(other)
+        else
+          false
+        end
+      end
+
+      def inspect
+        "\"#{to_s}\""
+      end
+    end
+  end
+end

data/lib/gce/host/string_util.rb

@@ -0,0 +1,31 @@
+class GCE
+  class Host
+    # If want sophisticated utility, better to use ActiveSupport
+    module StringUtil
+      def self.camelize(string)
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+        string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { $2.capitalize }
+        string.gsub!(/\//, '::')
+        string
+      end
+
+      def self.underscore(camel_cased_word)
+        return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+        word = camel_cased_word.to_s.gsub(/::/, '/')
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      def self.pluralize(string)
+        "#{string.chomp('s')}s"
+      end
+
+      def self.singularize(string)
+        string.chomp('s')
+      end
+    end
+  end
+end

data/lib/gce/host/version.rb

@@ -0,0 +1,5 @@
+class GCE
+  class Host
+    VERSION = '0.1.0'
+  end
+end

data/spec/gce_client_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe GCE::Host::GCEClient do
+  let(:client) { GCE::Host::GCEClient.new }
+  let(:instances) { client.instances }
+  let(:instance) { instances.first }
+  let(:name) { instance.name }
+
+  describe '#instances' do
+    it do
+      expect(instances).not_to be_empty
+    end
+
+    it 'filter with name' do
+      instances = client.instances(name: name)
+      expect(instances).not_to be_empty
+      expect(instances.first.name).to eq(name)
+
+      instances = client.instances(name: 'something_not_exist')
+      expect(instances).to be_empty
+    end
+
+    it 'filter with hostname (alias of name)' do
+      instances = client.instances(hostname: name)
+      expect(instances).not_to be_empty
+      expect(instances.first.name).to eq(name)
+    end
+  end
+end

data/spec/host_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+shared_examples_for 'host' do
+  it 'should respond_to' do
+    [ :hostname,
+      :roles,
+      :zone,
+      GCE::Host::Config.status.to_sym,
+      :service,
+      :status,
+      :tags,
+      :instance,
+      :instance_id,
+      :private_ip_address,
+      :private_ip_addresses,
+      :public_ip_address,
+      :public_ip_addresses,
+      :creation_timestamp,
+      :ip,
+      :start_date,
+      :usages,
+    ].each do |k|
+      expect(subject.respond_to?(k)).to be_truthy
+    end
+  end
+end
+
+describe GCE::Host do
+  describe 'options' do
+    context do
+      let(:subject) { GCE::Host.new(hostname: 'gce-host-web', options: {foo:'bar'}) }
+      it { expect(subject.options).to eq({foo:'bar'}) }
+      it { expect(subject.conditions).to eq([{hostname: ['gce-host-web']}]) }
+    end
+
+    context do
+      let(:subject) { GCE::Host.new({hostname: 'gce-host-web'}, {hostname: 'gce-host-db'}, options: {foo:'bar'}) }
+      it { expect(subject.options).to eq({foo:'bar'}) }
+      it { expect(subject.conditions).to eq([{hostname: ['gce-host-web']}, {hostname: ['gce-host-db']}]) }
+    end
+  end
+
+  context '#to_hash' do
+    let(:subject) { GCE::Host.new(service: 'gce-host').first.to_hash }
+
+    it 'keys' do
+      expect(subject.keys).to eq([
+        'hostname',
+        'roles',
+        'zone',
+        'service',
+        'status',
+        'tags',
+        'instance_id',
+        'private_ip_address',
+        'public_ip_address',
+        'creation_timestamp',
+        GCE::Host::Config.status,
+      ])
+    end
+
+    it 'values are not empty' do
+      expect(subject.values.any? {|v| v.nil? or (v.respond_to?(:empty?) and v.empty?) }).to be_falsey
+    end
+  end
+
+  context 'by hostname' do
+    let(:hosts) { GCE::Host.new(hostname: 'gce-host-web').to_a }
+    let(:subject)  { hosts.first }
+    it_should_behave_like 'host'
+    it { expect(hosts.size).to eq(1) }
+    it { expect(subject.hostname).to eq('gce-host-web') }
+  end
+
+  context 'by instance_id' do
+    let(:instance_id) { GCE::Host.new(service: 'gce-host').first.instance_id }
+
+    context 'by instance_id' do
+      let(:hosts)   { GCE::Host.new(instance_id: instance_id).to_a }
+      let(:subject) { hosts.first }
+      it_should_behave_like 'host'
+      it { expect(hosts.size).to eq(1) }
+      it { expect(subject.instance_id).to eq(instance_id) }
+    end
+  end
+
+  context 'by role' do
+    context 'by a role' do
+      let(:subject) { GCE::Host.new(role: 'web:test').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by a role1' do
+      let(:subject) { GCE::Host.new(role1: 'web').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by multiple roles (or)' do
+      let(:hosts) {
+        GCE::Host.new(
+          {
+            role1: 'web',
+            role2: 'test',
+          },
+          {
+            role1: 'db',
+            role2: 'test',
+          },
+        ).to_a
+      }
+      let(:subject) { hosts.first }
+      it { expect(hosts.size).to be >= 2 }
+      it_should_behave_like 'host'
+    end
+  end
+
+  # for compatibility with dino-host
+  context 'by usage' do
+    context 'by a usage' do
+      let(:subject) { GCE::Host.new(usage: 'web:test').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by a usage1' do
+      let(:subject) { GCE::Host.new(usage1: 'web').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by multiple usages (or)' do
+      let(:hosts) {
+        GCE::Host.new(
+          {
+            usage1: 'web',
+            usage2: 'test',
+          },
+          {
+            usage1: 'db',
+            usage2: 'test',
+          },
+        ).to_a
+      }
+      let(:subject) { hosts.first }
+      it { expect(hosts.size).to be >= 2 }
+      it_should_behave_like 'host'
+    end
+  end
+
+  context 'by status (optional array tags)' do
+    context 'by a status' do
+      let(:subject) { GCE::Host.new(status: :active).first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by multiple status (or)' do
+      let(:hosts) { GCE::Host.new(status: [:reserve, :active]).to_a }
+      let(:subject) { hosts.first }
+      it_should_behave_like 'host'
+      it { expect(hosts.size).to be >= 2 }
+    end
+
+    context 'by a string status' do
+      let(:subject) { GCE::Host.new(status: 'active').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by multiple string status (or)' do
+      let(:hosts) { GCE::Host.new(status: ['reserve', 'active']).to_a }
+      let(:subject) { hosts.first }
+      it_should_behave_like 'host'
+      it { expect(hosts.size).to be >= 2 }
+    end
+  end
+
+  context 'by service (optional string tags)' do
+    context 'by a service' do
+      let(:subject) { GCE::Host.new(service: 'gce-host').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by multiple services (or)' do
+      let(:hosts) { GCE::Host.new(service: ['test', 'gce-host']) }
+      let(:subject) { hosts.first }
+      it_should_behave_like 'host'
+    end
+  end
+
+  context 'by tags (optional array tags)' do
+    context 'by a tag' do
+      let(:subject) { GCE::Host.new(tags: 'master').first }
+      it_should_behave_like 'host'
+    end
+
+    context 'by multiple tags (or)' do
+      let(:hosts) { GCE::Host.new(tags: ['standby', 'master']) }
+      let(:subject) { hosts.first }
+      it_should_behave_like 'host'
+    end
+  end
+end