hosties 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0ddfeda2e90489df21afb44cb70c5560fd24b12
+  data.tar.gz: 7307934a3183c4fcb74d1a4fe3e4c6401ecf7ba0
+SHA512:
+  metadata.gz: e8c90640a12836827bc7c0df71a7496389833b5fafcfb495b35355efc650215032ae6e39b8b10870c40b9e36c9f62ed45025347f1d8d051175fe50c04813b7d4
+  data.tar.gz: e17ba1f3cb0e4bfa34740edf9491124a97ef467cdd993dd4e478e257cfcf4d556dcdc2e34270962239b05a3114e604a6a8c45d59635bf4e532d55ed743360c1b

data/lib/hosties.rb

@@ -0,0 +1,14 @@
+require 'hosties/definitions'
+require 'hosties/reification'
+
+# A library to provide easily readable environment definitions.
+module Hosties
+  # Environment definitions, keyed by type
+  EnvironmentDefinitions = {}
+  # Host definitions, keyed by type
+  HostDefinitions = {}
+  # Environment instances, definition type => array of instances
+  Environments = Hash.new{|h,k| h[k] = []}
+  # Maps type => hash of specified 'grouped_by' value to array of matches
+  GroupedEnvironments = {}
+end

data/lib/hosties/Definitions.rb

@@ -0,0 +1,137 @@
+#######################################################################
+# Provide some classes to give us friendly, easy on the eyes syntax   #
+# for defining what different types of hosts and environments should  #
+# have in order to be valid.                                          #
+#######################################################################
+
+# Constrains a named attribute to a provided set of values. This is good
+# for things like describing environments that a set of hosts can be in,
+# for instance Dev, QA, etc
+class AttributeConstraint
+  attr_reader :name, :possible_vals
+
+  def initialize(name)
+    @name = name
+    @possible_vals = []
+  end
+
+  def can_be(val, *more)
+    @possible_vals += (more << val)
+  end
+end
+
+# Superclass for the host and environment requirement types. This 
+# class handles the plumbing of tracking, constraining, and eventually
+# reifying attributes.
+class HasAttributes
+  attr_accessor :constraints
+  attr_accessor :attributes
+  def initialize
+    @constraints = {}
+    @attributes = []
+  end
+
+  # Specify symbols that will later be reified into attributes
+  def have_attributes(attr, *more)
+   @attributes += (more << attr)
+  end
+
+  alias_method :have_attribute, :have_attributes
+
+  # Helpful method to define constraints
+  def where(name)
+    # Must define the attributes before constraining them
+    raise ArgumentError, "Unknown attribute: #{name}" unless @attributes.include? name
+    @constraints[name] = AttributeConstraint.new(name)
+  end
+
+  # Check if a given name-value pair is valid given the constraints
+  def valid?(name, value)
+    if @constraints.include? name then
+      constraints[name].possible_vals.include? value
+    else true end
+  end
+end
+
+# Defines what a host of a certain type looks like
+class HostRequirement < HasAttributes
+  attr_reader :type, :services
+  def initialize(type)
+    super()
+    @type = type
+    @services = []
+  end
+
+  # Services will be provided with a host definition. In order for
+  # a host definition to be valid, it must provide service details 
+  # for all of the services specified by its matching 
+  # HostRequirement
+  def have_services(service, *more)
+   @services += (more << service)
+  end
+
+  alias_method :have_service, :have_services
+
+  def finished
+    Hosties::HostDefinitions[@type] = self
+  end
+end
+
+# Builder method
+def host_type(symbol, &block)
+  builder = HostRequirement.new(symbol)
+  begin
+    builder.instance_eval(&block)
+    builder.finished
+  rescue ArgumentError => ex
+    # TODO: There must be a better way!
+    # I'd like to provide some feedback in this case, but I don't 
+    # like having this show up in test output. 
+    #puts "Problem defining host \"#{symbol}\": #{ex}"
+  end
+end
+
+# Used to describe an environment.
+class EnvironmentRequirement < HasAttributes
+  attr_reader :type, :hosts, :grouping
+  def initialize(type)
+    super()
+    @type = type
+    @hosts = []
+  end
+
+  # Define the hosts that an environment needs to be valid,
+  # for instance, maybe you need a :logger host and a 
+  # :service host at a minimum.
+  def need(host1, *more)
+    sum = more << host1
+    # Array doesn't have an 'exists' method, so behold - map reduce wankery!
+    unless sum.map { |x| Hosties::HostDefinitions.include? x }.reduce(true) { |xs, x| x & xs }
+      raise ArgumentError, "Unrecognized host type"
+    end
+    @hosts += sum
+  end
+
+  # Optionally specify an attribute to group by when registering 
+  # environments of this type.
+  def grouped_by(attr) 
+    raise ArgumentError, "Unknown attribute #{attr}" unless @attributes.include?(attr)
+    @grouping = attr
+  end
+
+  def finished
+    Hosties::EnvironmentDefinitions[@type] = self
+  end
+end
+
+# Builder method
+def environment_type(symbol, &block)
+  builder = EnvironmentRequirement.new(symbol)
+  begin
+    builder.instance_eval(&block)
+    builder.finished
+  rescue ArgumentError => ex
+    # TODO: Same as above, find a better way to get this information out
+    #puts "Problem describing environment \"#{builder.type}\": #{ex}"
+  end
+end

data/lib/hosties/Reification.rb

@@ -0,0 +1,127 @@
+# Fancy words, fancy words.
+# Provide some classes to turn a declarative host definition into something 
+# more useful in code, applying rules from the definition files to ensure we
+# only get valid stuff.
+class UsesAttributes
+  # Oh this old thing...
+  def metaclass 
+    class << self
+      self
+    end
+  end
+  def initialize(has_attributes)
+    @attributes = has_attributes.attributes
+    # Magic.
+    has_attributes.attributes.each do |attr|
+      # Add in the attribute
+      self.metaclass.send(:attr_accessor, attr)
+      # Define a constrained setter
+      self.metaclass.send(:define_method, attr) do |val|
+        raise ArgumentError, "Invalid value" unless has_attributes.valid?(attr, val)
+        instance_variable_set "@#{attr}", val
+      end
+    end
+  end
+
+  # Return a hash after verifying everything was set correctly
+  def finish
+    retval = {}
+    # Ensure all required attributes have been set
+    @attributes.each do |attr|
+      val = instance_variable_get "@#{attr}"
+      raise ArgumentError, "Missing attribute #{attr}" if val.nil?
+      retval[attr] = val
+    end
+    retval
+  end
+end
+
+class HostBuilder < UsesAttributes
+  def initialize(type, hostname)
+    if Hosties::HostDefinitions[type].nil? then
+      raise ArgumentError, "Unrecognized host type"
+    end
+    @type = type
+    @definition = Hosties::HostDefinitions[@type]
+    @hostname = hostname
+    @service_ports = {} # Map of service type to port
+    super(@definition) # Creates attribute code
+    # Services are really just a special kind of attribute, but for now I'll
+    # keep them separate. I'm thinking maybe I could add a new type of attribute
+    # constraint that let's a user specify that an attribute must be numeric, or
+    # a string for instance.
+    @definition.services.each do |service_type|
+      self.metaclass.send(:attr_accessor, service_type)
+      self.metaclass.send(:define_method, service_type) do |port|
+        raise ArgumentError, "Port number required" unless port.is_a? Integer
+        @service_ports[service_type] = port
+      end
+    end
+  end
+
+  def finish
+    # Ensure all services have been set
+    @definition.services.each do |svc|
+      raise ArgumentError, "Missing service #{svc}" if @service_ports[svc].nil?
+    end
+    # TODO: More clever data repackaging
+    super.merge({ :hostname => @hostname }).merge(@service_ports)
+  end
+end
+
+# Turn a description into a useful data structure - and it's validated!
+class EnvironmentBuilder < UsesAttributes
+  def initialize(type)
+    if Hosties::EnvironmentDefinitions[type].nil? then
+      raise ArgumentError, "Unrecognized environment type"
+    end
+    @hosts = {} # host type => array of hosts' data
+    @type = type
+    @definition = Hosties::EnvironmentDefinitions[@type]
+    super(@definition) # Creates attribute code
+    # More magic, this time create a parameterized host builder based 
+    # on the type of hosts this environment wants. Poor man's currying
+    @definition.hosts.each do |host_type|
+      self.metaclass.send(:define_method, host_type) do |hostname, &block|
+        begin
+          builder = HostBuilder.new(host_type, hostname)
+          builder.instance_eval(&block)
+          if @hosts[host_type].nil? then @hosts[host_type] = [] end
+          @hosts[host_type] << builder.finish
+        rescue ArgumentError => ex
+          #puts "Problem declaring host: #{ex}"
+          raise ex
+        end
+      end
+    end
+  end
+
+  def finish
+    # Verify all of the required hosts were set
+    @definition.hosts.each do |host_type| 
+      raise ArgumentError, "Missing #{host_type} host" unless @hosts.include? host_type
+    end
+    retval = super.merge({ :hosts => @hosts })
+    Hosties::Environments[@type] << retval
+    # Add ourselves into the grouped listing if necessary
+    attr = @definition.grouping
+    unless attr.nil? then # TODO: This is really ugly
+      if Hosties::GroupedEnvironments[@type].nil? then
+        Hosties::GroupedEnvironments[@type] = Hash.new{|h,k| h[k] = []}
+      end
+      Hosties::GroupedEnvironments[@type][retval[attr]] << retval
+    end
+    retval
+  end
+end
+
+def environment_for(type, &block)
+  begin
+    builder = EnvironmentBuilder.new(type)
+    builder.instance_eval(&block)
+    data = builder.finish
+  rescue ArgumentError => ex
+    puts "Problem declaring environment: #{ex}"
+    raise ex
+  end
+end

data/spec/definitions_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe HasAttributes do
+  it 'rejects definitions with constraints on nonexistent attributes' do
+    instance = HasAttributes.new
+    instance.have_attributes :foo, :bar
+    expect { instance.where(:baz).can_be("anything") }.to raise_error(ArgumentError)
+  end
+end
+
+describe HostRequirement do
+  it 'defines host types' do
+    # Declare a host type
+    host_type :logger do
+      have_services :jmx, :rest, :http, :https
+      have_attributes :control_mbean, :default_user
+    end
+  end
+end
+
+describe EnvironmentRequirement do
+  it 'defines environments with host and attribute requirements' do
+    host_type :mutant_maker do end
+    host_type :turkey_blaster do end
+    environment_type :weird_thanksgiving do
+      need :mutant_maker, :turkey_blaster
+      have_attribute :weirdness_factor
+    end
+  end
+
+  it 'rejects environment definitions that need undefined host types' do
+    builder = EnvironmentRequirement.new(:failure)
+    expect { builder.need(:nonexistent) }.to raise_error(ArgumentError)
+  end
+
+  it 'rejects groupings for unknown attributes' do
+    builder = EnvironmentRequirement.new(:failure)
+    expect { builder.grouped_by(:nonexistent) }.to raise_error(ArgumentError)
+  end
+end

data/spec/hosties_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Hosties do
+  it 'can declare a host' do
+    host_type :special_host do
+    end
+    instance = HostBuilder.new(:special_host, "0.0.0.0")
+    expect(instance.finish).to eq({ :hostname => "0.0.0.0"})
+  end
+
+  it 'catches missing services' do
+    host_type :web_host do
+      have_service :http
+    end
+    instance = HostBuilder.new(:web_host, "0.0.0.0")
+    expect { instance.finish }.to raise_error(ArgumentError)
+  end
+
+  it 'catches missing attributes' do
+    host_type :mud_server do
+      have_attribute :version
+    end
+    instance = HostBuilder.new(:mud_server, "0.0.0.0")
+    expect { instance.finish }.to raise_error(ArgumentError)
+  end
+
+  it 'catches non-integral service ports' do
+    host_type :web_host do
+      have_service :http
+    end
+    instance = HostBuilder.new(:web_host, "0.0.0.0")
+    expect { instance.http 10.4 }.to raise_error(ArgumentError)
+  end
+
+  it 'catches missing host requirements' do
+    host_type :type_a do
+    end
+    host_type :type_b do
+    end
+    environment_type :needy_environment do
+      need :type_a, :type_b
+    end
+    builder = EnvironmentBuilder.new(:needy_environment)
+    builder.type_a "0.0.0.0" do end
+    # No type_b specified
+    expect { builder.finish }.to raise_error(ArgumentError)
+  end
+
+  it 'can fully declare an environment' do
+    # Declare the host types
+    host_type :monitoring do
+      have_services :logging, :http
+    end
+    host_type :service_host do
+      have_services :service_port, :rest, :jmx
+      have_attribute :uuid
+    end
+    # Declare this product's environment makeup
+    environment_type :typical_product do
+      need :service_host, :monitoring
+      have_attribute :environment
+      where(:environment).can_be(:dev, :qa, :live)
+    end
+    # make one!
+    environment_for :typical_product do
+      environment :qa
+      monitoring "192.168.0.1" do
+        logging 8888
+        http 80
+      end
+      monitoring "192.168.0.2" do
+        logging 8888
+        http 80
+      end
+      service_host "192.168.0.3" do
+        service_port 1234
+        rest 8080
+        jmx 9876
+        uuid "81E3C1D4-C040-4D59-A56F-4273384D576B"
+      end
+    end
+    expect(Hosties::Environments[:typical_product].nil?).to eq(false)
+    data = Hosties::Environments[:typical_product].first
+    expect(data[:environment]).to eq(:qa)
+    expect(data[:hosts][:monitoring].size).to eq(2) # Two monitoring hosts
+    expect(data[:hosts][:service_host].size).to eq(1)
+    service_host = data[:hosts][:service_host].first
+    expect(service_host[:service_port]).to eq(1234)
+    expect(service_host[:uuid]).to eq("81E3C1D4-C040-4D59-A56F-4273384D576B")
+  end
+
+  it 'can group environments by attribute' do
+    host_type :foo do end
+    host_type :bar do end
+    environment_type :foobar do
+      need :foo, :bar
+      have_attribute :env_type
+      where(:env_type).can_be :dev, :qa, :live
+      grouped_by :env_type
+    end
+    environment_for :foobar do
+      foo "0.0.0.0" do end
+      bar "0.0.0.0" do end
+      env_type :dev
+    end
+    environment_for :foobar do
+      foo "0.0.0.0" do end
+      bar "0.0.0.0" do end
+      env_type :qa
+    end
+    expect(Hosties::GroupedEnvironments[:foobar][:dev].size).to eq(1)
+    expect(Hosties::GroupedEnvironments[:foobar][:qa].size).to eq(1)
+  end
+end

data/spec/reification_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe UsesAttributes do
+  it 'can enforce attribute constraints' do
+    definition = HasAttributes.new
+    definition.have_attributes(:x)
+    definition.where(:x).can_be("hello")
+    instance = UsesAttributes.new(definition)
+    instance.x "hello"
+    expect { instance.x 31 }.to raise_error(ArgumentError)
+  end
+  it 'catches missing attributes' do
+    definition = HasAttributes.new
+    definition.have_attributes(:x)
+    instance = UsesAttributes.new(definition)
+    expect { instance.finish }.to raise_error(ArgumentError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'hosties'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter = 'documentation'
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: hosties
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ron Dahlgren
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: |2
+      Hosties provides an expressive way to define environments, which are in turn
+      comprised of lists of roles and the hosts that fill those roles.
+email: ronald.dahlgren@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hosties/Definitions.rb
+- lib/hosties/Reification.rb
+- lib/hosties.rb
+- spec/definitions_spec.rb
+- spec/hosties_spec.rb
+- spec/reification_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/influenza/hosties
+licenses:
+- BSD-new
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Easy environment description
+test_files:
+- spec/definitions_spec.rb
+- spec/hosties_spec.rb
+- spec/reification_spec.rb
+- spec/spec_helper.rb