confer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e9bed58740690419da224ac3da8449b5ad24ec5e
+  data.tar.gz: 2a6c54c6a28b37259418a140383ec34817f37618
+SHA512:
+  metadata.gz: 11a984f70c62beeda250d6a037147057507219d0625ad18935b068e411ba2fe8a57e3ecc593e62c9b8bab5319f16c95913bb55c1ece375175fbe6ca31f333898
+  data.tar.gz: 568e89efcdd151db5c1d21c602b61c18147b259d673505df0e4c65c420f8bea25bfe34e06a6b41c0562049691bcc9f2a7d75c97a47a793a564378409fda83974

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## 0.0.1
+
+* Initial version

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Cliff Rowley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Confer - lightweight configuration management
+
+Inspired by tools such as [Ansible](http://www.ansibleworks.com), [Puppet](http://puppetlabs.com) and [Chef](http://opscode.com/chef), but at a much smaller scale.
+
+## Why smaller scale?
+
+Because sometimes these otherwise awesome tools take an inordinate amount of time and effort to configure and maintain if you only have a server or two to manage.  For example if (like me) you have your own dedicated server that you would like to configure by recipe but you don't need webscale™, then Confer is possibly for you.
+
+## Status
+
+Confer is very young and very much in heavy development at this stage so I can't vouch for its stability nor integrity, however I am experienced enough that my code won't blow up in your face.  I've intentionally kept the source simple with little in the way of magic so you should find it easy to read should you encounter any problems.  Failing that, please feel free to submit issues.
+
+**NOTE: Confer is not yet feature complete, let alone production ready.**
+
+## Upcoming features
+
+* **Flexible recipes**: A YAML recipe simply describes a list of configurators and their parameters, so if your requirements are a little more complex or dynamic you can construct recipes programmatically with a high level DSL.  Or if you need something a little closer to the metal (to integrate within your own code for example) you can simply import Confer as a library and interact directly with its classes.
+* **Easy to extend**: At the heart of Confer are its "configurators" which do all the heavy lifting to apply and verify the configuration defined in recipes.  Configurators are built around a simple lifecycle and can be written using a high level DSL or with plain old Ruby objects that implement the appropriate methods.
+* **Idempotency**: The configurator lifecycle includes querying and verification of existing configuration so changes are only applied if actually necessary.  Verification can be implicit or explicit, allowing for complex use cases.
+* **No client/server**: Confer performs all of its operations over SSH, and no server component is required.  In many cases a client-server model may be desirable, however this may be an indication that you need to consider a more comprehensive tool.
+* **Generators**: In order to speed up the Confer workflow, boilerplate recipes and configurators can be generated.
+
+## Caveats
+
+As with any software, there are always going to be some drawbacks and limitations.
+
+* **Weak cross platform support**: One of Confer's strengths is its simplicity, particularly in regards to writing custom configurators that are appropriate for _your_ setup.  However this simplicity means there is no platform abstraction layer, and a configurator that must support multiple platforms will need to contain a fair number of ifs and buts.  This _may_ be addressed in a future update.
+* **Ruby 1.9 untested**: At this stage no effort has been made to test Confer with anything less than Ruby 2.0.  Apologies for that, but at this point I'm more interested in actually getting a working version.  I almost certainly will put some effort into supporting Ruby 1.9 in the very near future.  Pull requests are also welcome.
+* **No tests**: I love TDD, but I've had to make an exception on this project because I need it yesterday.  Therefore please consider this version of Confer as a prototype until such a time as I can guarantee its behavior with comprehensive tests.
+
+## Requirements
+
+Currently the only requirement is that you must be able to connect to the host being configured via SSH, and that Ruby 2.0 is installed on your workstation.
+
+## Installing
+
+If you're using a Ruby version manager such as RVM or rbenv (which you should!), you can simply `gem install confer`, otherwise you'll probably need to `sudo gem install confer`.  This should be done client side.  There is no need to install Confer on the server.
+
+Alternatively you can install from the source by fetching it and running `rake install`.
+
+## License
+
+In the spirit of openness and freedom to use and abuse Confer is released under the MIT license, which basically means you are free do whatever you like with it.  But it'd be really nice if awesome changes and bug fixes made their way back to the source as pull requests ;-)

data/bin/confer

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../lib', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'bundler/setup'
+require 'confer/cli'

data/lib/confer.rb

@@ -0,0 +1,7 @@
+require 'confer/version'
+require 'confer/extensions/hash'
+require 'confer/extensions/array'
+require 'confer/inventory'
+require 'confer/recipe'
+require 'confer/connection'
+require 'confer/configurator'

data/lib/confer/builtins.rb

@@ -0,0 +1 @@
+require 'confer/configurators/tzdata'

data/lib/confer/cli.rb

@@ -0,0 +1,72 @@
+#
+# The command line interface, obviously ;-)
+#
+# Fair warning that the CLI interface will almost certainly change drastically
+# at some point in the not too distant future.  I've used GLI because frankly
+# it's the quickest thing to prototype with, but I don't intend to keep it
+# because I find the interface it generates to be unintuitive and often a tad
+# frustrating.
+#
+
+require 'gli'
+require 'confer'
+
+include GLI::App
+
+program_desc      'Lightweight configuration management'
+program_long_desc 'Inspired by tools such as Ansible, Puppet and Chef, but at a much smaller scale if you only have a server or two to manage.'
+version           Confer::VERSION
+
+flag 'host',      'h', default_value: 'default',       desc: 'Specify the host to configure'
+flag 'inventory', 'i', default_value: 'inventory.yml', desc: 'Specify the inventory to use'
+flag 'recipe',    'r', default_value: 'recipe.yml',    desc: 'Specify the recipe to use'
+
+inventory = nil
+recipe    = nil
+host      = nil
+
+pre do |global, command, opts, args|
+  inventory = Confer::Inventory.from_file global[:inventory]
+  recipe    = Confer::Recipe.from_file    global[:recipe]
+  host      = inventory.hosts[global[:host]]
+
+  true
+end
+
+on_error do |e|
+  $stdout.puts "#{e.class.name}: #{e.message}"
+  $stdout.puts e.backtrace.join "\n"
+  false
+end
+
+desc 'Queries configurator values'
+command :query do |c|
+  c.flag 'configurator', '-c', desc: 'The configurator to query'
+
+  c.action do |global, opts, args|
+    Confer::Connection.start(host.options['connection']) do |connection|
+      recipe.steps.each do |step|
+        $stdout.puts "===== #{step.configurator} => #{step.options}"
+        configurator = Confer::Configurator.get(step.configurator, step.options)
+        puts configurator.query(connection)
+        $stdout.puts
+      end
+    end
+  end
+end
+
+desc 'Verifies the recipe against configurator values'
+command :verify do |c|
+  c.action do |global, opts, args|
+
+  end
+end
+
+desc 'Applies the recipe to the remote host'
+command :apply do |c|
+  c.action do |global, opts, args|
+
+  end
+end
+
+exit run ARGV

data/lib/confer/configurator.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/string/inflections'
+
+module Confer
+
+  class ConfiguratorError         < StandardError; end
+  class ConfiguratorNotFoundError < ConfiguratorError; end
+
+  #
+  # Public: Encapsulates the actual interaction with the remote server.
+  #
+  class Configurator
+
+    #
+    # Public: Find and instantiate a Configurator with the given name.
+    #
+    # name    - A String containing the name of the configurator to get.
+    # options - A Hash of options to pass to the configurator.
+    #
+    # Raises
+    #
+    # ConfiguratorNotFoundError - If a configurator with the specified name can
+    #                             not be located.
+    # ConfiguratorError         - If the configurator was found byt cannot be
+    #                             instantiated for some reason.
+    #
+    # Returns a Configurator instance if found.
+    #
+    def self.get(name, options = {})
+      require "confer/configurators/#{name}"
+      Confer::Configurators.const_get(name.camelize).new(options)
+    rescue LoadError => e
+      raise ConfiguratorNotFoundError.new("Configurator #{name} not found")
+    rescue StandardError => e
+      raise ConfiguratorError.new(e)
+    end
+
+    #
+    # Public: Instantiates a new Configurator.  By itself this method doesn't
+    # really do very much for the base class, however for subclasses it will
+    # attempt to apply the options passed to attributes if they exist.
+    #
+    # options - A Hash of configurator specific options.
+    #
+    def initialize(options = {})
+      options.apply_to self
+    end
+
+    #
+    # Public: Query and return the remote configuration.
+    #
+    def query(connection); end
+
+    #
+    # Public: Verify the remote configuration against the Configurator attributes.
+    #
+    def verify(connection); end
+
+    #
+    # Public: Modify the remote configuration to match the Configurator attributes.
+    #
+    def apply(connection); end
+  end
+
+end

data/lib/confer/configurators/locale.rb

@@ -0,0 +1,25 @@
+module Confer
+  module Configurators
+
+    class Locale < Configurator
+
+      attr_accessor :name
+      attr_accessor :encoding
+
+      def query(connection)
+        connection.exec! 'locale -a'
+      end
+
+      # verify do
+      #   params[:locales].all? { |locale| sh "locale -a | grep '/^#{locale}$/'" == locale }
+      # end
+
+      # configure do
+      #   sh "echo '#{params[:locales].join('\\\n')}' > /etc/locale.gen"
+      #   sh "locale-gen"
+      # end
+
+    end
+
+  end
+end

data/lib/confer/configurators/tzdata.rb

@@ -0,0 +1,49 @@
+require 'diffy'
+
+module Confer
+  module Configurators
+
+    #
+    # Public: Configures the timezone on the remote host.
+    #
+    # Attributes
+    #
+    # timezone - The desired time zone in the format expected by the file
+    #            `/etc/timezone` on a Linux machine.  E.g. London, UK would
+    #            be `Europe/London`.
+    #
+    class Tzdata < Configurator
+
+      #
+      # Public: The desired time zone.
+      #
+      attr_accessor :timezone
+
+      #
+      # See `Confer::Configurator#query`
+      #
+      def query(connection)
+        connection.exec! 'cat /etc/timezone'
+      end
+
+      #
+      # See `Confer::Configurator#verify`
+      #
+      def verify(connection)
+        expected = query.strip
+        return true if expected == timezone
+        Diffy::Diff.new(expected, timezone).to_s(:color)
+      end
+
+      #
+      # See `Confer::Configurator#apply`
+      #
+      def apply(connection)
+        # sh "echo '#{params[:timezone]}' > /etc/timezone"
+        # sh "dpkg-reconfigure -f noninteractive tzdata"
+      end
+
+    end
+
+  end
+end

data/lib/confer/connection.rb

@@ -0,0 +1,75 @@
+require 'net/ssh'
+
+module Confer
+
+  #
+  # Public: Encapsulates a connection to a remote host.
+  #
+  class Connection
+
+    #
+    # Public: Creates a new instance and immediately connects to the remote
+    # host, yielding the instance to the given block.
+    #
+    # opts  - The options to pass to the new Connection instance.
+    # block - The block to receive the new instance.
+    #
+    def self.start(opts = {}, &block)
+      Connection.new(opts).start(&block)
+    end
+
+    #
+    # Public: A String containing the remote hostname.
+    #
+    attr_accessor :host
+
+    #
+    # Public: A String containing the remote username.
+    #
+    attr_accessor :user
+
+    #
+    # Public: A Hash containing the SSH configuration options.
+    #
+    attr_accessor :config
+
+    #
+    # Public: Initialies a Connection instance.
+    #
+    # host - The host to connect to.
+    #
+    def initialize(opts = {})
+      @config ||= {}
+      opts.apply_to self
+    end
+
+    #
+    # Public: Opens a connection to the remote host and yields self to the
+    # given block for further interaction.  The connection will be closed once
+    # the block has executed.
+    #
+    # block - The block to yield to.
+    #
+    def start(&block)
+      Net::SSH.start(self.host, self.user, self.config) do |ssh|
+        @ssh = ssh
+        yield(self)
+      end
+    end
+
+    #
+    # Public: Execute a command on the remote host.
+    #
+    # command - The command to execute.
+    # opts    - A hash of options:
+    #           :shell - True if the command should be run via the remote shell.
+    #
+    # Returns the raw response from the command.
+    #
+    def exec!(command, opts = {})
+      @ssh.exec! command
+    end
+
+  end
+
+end

data/lib/confer/extensions/array.rb

@@ -0,0 +1,22 @@
+class Array
+
+  #
+  # Public: Removes and returns the last element of the Array if it is a Hash.
+  #
+  # Examples
+  #
+  #   array = ["one", "two", {three: 'four'}]
+  #   opts  = array.extract_options!
+  #   # => {three: 'four'}
+  #   array
+  #   # => ["one", "two"]
+  #
+  # Returns the last element of the Array if it is a Hash, otherwise an empty
+  # hash is returned.
+  #
+  def extract_options!
+    return pop if last.is_a?(Hash)
+    {}
+  end
+
+end

data/lib/confer/extensions/hash.rb

@@ -0,0 +1,15 @@
+class Hash
+
+  #
+  # Public: Iterates through the keys of this hash and for each key sets the
+  # attribute of the same name on `object`.  If a property of the same does
+  # not exist, it is silently ignored.
+  #
+  # object - The object on which to apply the values of this Hash.
+  #
+  #
+  def apply_to(object)
+    self.each { |k, v| object.send("#{k}=", v) if object.respond_to? "#{k}=" }
+  end
+
+end

data/lib/confer/inventory.rb

@@ -0,0 +1,85 @@
+require 'yaml'
+
+module Confer
+
+  class InventoryError         < StandardError;  end
+  class InventoryNotFoundError < InventoryError; end
+  class InventorySyntaxError   < InventoryError; end
+
+  #
+  # Public: Encapsulates an inventory, which is simply a list of hosts and the
+  # credentials and transport mechanisms required to interact with them.
+  #
+  class Inventory
+
+    #
+    # Public: Loads an inventory from a YAML file.
+    #
+    # path - A String containing the path to the YAML file to load.
+    #
+    # Returns an Inventory instance.
+    #
+    def self.from_file(path)
+      self.from_hash YAML.load File.open(path, 'r').read
+    rescue Errno::ENOENT => e
+      raise InventoryNotFoundError.new(e)
+    rescue Psych::SyntaxError => e
+      raise InventorySyntaxError.new(e)
+    end
+
+    #
+    # Public: Loads an inventory from a Hash of hosts.
+    #
+    # array - A Hash of hosts and their options, indexed by name.
+    #
+    # Returns an Inventory instance.
+    #
+    def self.from_hash(hash)
+      Inventory.new Hash[hash.map { |k, v| [k, Host.new(k, v)] }]
+    end
+
+    #
+    # Public: A Hash of the hosts and their options in this Inventory, indexed
+    # by name.
+    #
+    attr_accessor :hosts
+
+    #
+    # Public: Creates a new Inventory instance.
+    #
+    # hosts - A Hash of hosts their options in the inventory, indexed by name.
+    #
+    def initialize(hosts = {})
+      @hosts = hosts
+    end
+
+    #
+    # Internal: Encapsulates a single host in an Inventory.
+    #
+    class Host
+
+      #
+      # Public: A String containing the name of the host.
+      #
+      attr_reader :name
+
+      #
+      # Public: A Hash containing the host options.
+      #
+      attr_reader :options
+
+      #
+      # Internal: Iniitalize a new Host with configuration.
+      #
+      # args - An array containing the name of the host and a Hash containing
+      #        the host options.
+      #
+      def initialize(*args)
+        @options = args.extract_options!
+        @name    = args.first
+      end
+
+    end
+  end
+
+end

data/lib/confer/recipe.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+
+module Confer
+
+  class RecipeError         < StandardError; end
+  class RecipeNotFoundError < RecipeError;   end
+  class RecipeSyntaxError   < RecipeError;   end
+
+  #
+  # Public: Encapsulates a recipe.  Usually instantiated by calling a method
+  # from a mixed in module such as `Confer::Recipe::Yaml`.
+  #
+  class Recipe
+
+    #
+    # Public: Loads a recipe from a YAML file.
+    #
+    # path - A String containing the path to the YAML file to load.
+    #
+    # Returns a Recipe instance.
+    #
+    def self.from_file(path)
+      self.from_array YAML.load File.open(path, 'r').read
+    rescue Errno::ENOENT => e
+      raise RecipeNotFoundError.new(e)
+    rescue Psych::SyntaxError => e
+      raise RecipeSyntaxError.new(e)
+    end
+
+    #
+    # Public: Loads a recipe from an array of steps.
+    #
+    # array - An Array containing a Hash of options indexed by name for each
+    #         step in the recipe.
+    #
+    # Returns a Recipe instance.
+    #
+    def self.from_array(array)
+      Recipe.new array.map { |e| Step.new(*e.first) }
+    end
+
+    #
+    # Public: An Array of steps this recipe contains.
+    #
+    attr_reader :steps
+
+    #
+    # Public: Instantiate a new instance with the given steps.
+    #
+    # array - An Array of Hash objects defining the steps for this recipe.
+    # opts  - A Hash of options.
+    #
+    def initialize(steps = [])
+      @steps = steps
+    end
+
+    #
+    # Internal: Encapsulates a single step in a recipe.
+    #
+    class Step
+
+      #
+      # Public: A String containing the name of the configurator.
+      #
+      attr_reader :configurator
+
+      #
+      # Public: A Hash containing the configurator options.
+      #
+      attr_reader :options
+
+      #
+      # Internal: Initialize a new Step with configuration.
+      #
+      # args - An array contaning the configurator name and a Hash containing
+      #        the configurator options.
+      #
+      def initialize(*args)
+        @options      = args.extract_options!
+        @configurator = args.first
+      end
+
+    end
+
+  end
+
+end

data/lib/confer/version.rb

@@ -0,0 +1,3 @@
+module Confer
+  VERSION = '0.0.1' # :nodoc:
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: confer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cliff Rowley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: syntax
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Inspired by tools such as Ansible, Puppet and Chef, but at a much smaller
+  scale if you only have a server or two to manage.
+email:
+- cliffrowley@gmail.com
+executables:
+- confer
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/confer
+- lib/confer/builtins.rb
+- lib/confer/cli.rb
+- lib/confer/configurator.rb
+- lib/confer/configurators/locale.rb
+- lib/confer/configurators/tzdata.rb
+- lib/confer/connection.rb
+- lib/confer/extensions/array.rb
+- lib/confer/extensions/hash.rb
+- lib/confer/inventory.rb
+- lib/confer/recipe.rb
+- lib/confer/version.rb
+- lib/confer.rb
+- LICENSE
+- README.md
+- CHANGELOG.md
+homepage: http://github.com/cliffrowley/confer
+licenses:
+- MIT
+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.1.11
+signing_key: 
+specification_version: 4
+summary: Lightweight configuration management
+test_files: []