hibachi 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93d51833915516bde538031d378a015bcac41b0d
+  data.tar.gz: ca5f2c393ab648c57a620a2f74b2f30fbecb64d7
+SHA512:
+  metadata.gz: 6cfc2e1dec973836c824094c604d5c338274eb9883f59ef5fb2e2feedc67056b7e743e0a24770f2f11ccd8629d9b7c9ac5fc66966a8d81e677f6d718d8095d1b
+  data.tar.gz: 19c4b64c853cbe399769e6a8759e7c8c4aca6263da7d53258918711cee39784e4c7c1d274d33f86c015926ee077795c65ac9cb866138631cab298015f84bdd08

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/dummy/db
+spec/dummy/log/*.log

data/.rspec

@@ -0,0 +1 @@
+--color --format=documentation

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+cache: bundle
+deploy:
+  provider: rubygems
+  api_key: $RUBYGEMS_API_KEY
+  on:
+    tags: true

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hibachi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2014 Tom Scott
+All rights reserved.
+
+Developed by:
+
+    Tom Scott
+    TelVue Corporation
+
+    http://www.telvue.com/
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal with 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:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.
+Neither the names of Tom Scott, TelVue Corporation, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.
+
+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 CONTRIBUTORS 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 WITH THE SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+# Hibachi
+
+Hibachi is a bridge between your Rails application and your Chef
+configuration. It provides a framework for building Rails models
+that persist to a central JSON file rather than a database, as well as
+automatically running Chef in an `ActiveJob` in the background.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem 'hibachi'
+```
+
+Run the following command to install:
+
+```bash
+$ bundle
+```
+
+Now, you can run the generator to set up Hibachi's configuration
+(optional):
+
+```bash
+$ rails generate hibachi:install
+```
+
+This will generate the following Rails initializer:
+
+```ruby
+require 'hibachi'
+
+Hibachi.configure do |config|
+  config.chef_json_path = "#{Rails.root}/config/chef.json"
+  config.chef_dir = "#{Rails.root}/config/chef"
+  config.run_in_background = false # NOTE: will be `true` by default when ActiveJob hits 1.0
+end
+```
+
+## Configuration
+
+Configuration is stored in the `Rails.application.config.hibachi`
+object, which is set up by our Railtie and required upon requiring the
+gem. The default settings are specified above, but you can override them
+either in the generated initializer or in the Rails environment config,
+just use the `config.hibachi` namespace.
+
+- **chef_json_path** defines an absolute path to the JSON file that
+  dictates user-specified configuration.
+- **chef_dir** defines an absolute path to the Chef repo that has been
+  installed on this machine.
+- **run_in_background** is a flag that dictates whether to queue Chef
+  runs in a background job or run them directly. The default is false,
+  but *will* be true whenever ActiveJob is merged in, as this method has
+  the best performance.
+
+## Usage
+
+When you want to manipulate settings, generate a new Hibachi model:
+
+```bash
+$ rails generate hibachi:model NetworkInterface name dhcp address netmask gateway
+```
+
+You'll get a file that looks like this:
+
+```ruby
+class NetworkInterface < Hibachi::Model
+  recipe :network_interfaces
+
+  attr_accessor :name, :dhcp, :address, :netmask, :gateway
+
+end
+```
+
+`Hibachi::Model` is really just an `ActiveModel::Model` with some added
+sugar. So you can use all the validation and callbacks you'd expect from
+an ActiveModel:
+
+```ruby
+class NetworkInterface < Hibachi::Model
+  recipe :network_interfaces
+
+  attr_accessor :name, :dhcp, :address, :netmask, :gateway
+
+  validates :name, presence: true
+  validates :dhcp, presence: true
+
+  validates :address, presence: true, :if => :dhcp?
+  validates :netmask, presence: true, :if => :dhcp?
+  validates :gateway, presence: true, :if => :dhcp?
+
+  def dhcp?
+    !!dhcp
+  end
+end
+```
+
+When you want to add a new interface, you can do it as if it were a
+regular ActiveRecord model:
+
+```ruby
+NetworkInterface.create name: 'eth2', dhcp: true
+```
+
+Running `create()` will not only persist this new setting to the JSON,
+but will also run Chef on the box for the recipe provided in the class
+definition.
+
+Other AR-like methods such as `update()` and `destroy()` are also
+available. They pretty much take the same parameters.
+
+### Singletons
+
+Another concept in configuration is the idea of a "singleton", that is,
+a model that exists without the need for enumeration. For example, say
+you have a recipe that configures Nginx like so:
+
+```ruby
+  template "install site configuration" do
+    source "site.conf.erb"
+    action :create
+  end
+
+  nginx_site node[:app_cookbook][:nginx_site][:server_name] do
+    action :enable
+  end
+```
+
+You can configure that attribute with your front-end app by generating a
+`Hibachi::Model` like this:
+
+```ruby
+class NginxSite < Hibachi::Model
+  recipe :nginx_site, :type => :singleton
+  attr_accessor :server_name
+end
+```
+
+This affects the way attributes are both looked up and persisted by
+Hibachi. Instead of treating the attribute as if it was an Array of
+Hashes, Hibachi will write to the attribute directly as a Hash. So when
+doing this:
+
+```ruby
+site = NginxSite.fetch
+site.update :server_name => 'www.example.org'
+```
+
+You'll get **chef.json** that looks like this (using the `:app_cookbook`
+namespace from before):
+
+```json
+{
+  "app_cookbook": {
+    "nginx_site": {
+      "server_name": "www.example.org"
+    }
+  }
+}
+```
+
+
+## Contributing
+
+1. Fork it ( http://github.com/tubbo/hibachi/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Commit your tests (`git commit -am 'Tests for my feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+7. ![ship it](https://assets-cdn.github.com/images/icons/emoji/shipit.png)
+
+## License
+
+This software is licensed under [The University of Illinois/NCSA Open
+Source License](http://opensource.org/licenses/NCSA)...
+
+    Copyright (c) 2014 Tom Scott
+    All rights reserved.
+
+    Developed by:
+
+        Tom Scott
+        TelVue Corporation
+
+        http://www.telvue.com/
+
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal with 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:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.
+    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.
+    Neither the names of Tom Scott, TelVue Corporation, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.
+
+    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 CONTRIBUTORS 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 WITH THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new :test
+
+YARD::Rake::YardocTask.new :doc do |t|
+  t.options = %w(--markup=markdown)
+end

data/hibachi.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hibachi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hibachi"
+  spec.version       = Hibachi::VERSION
+  spec.authors       = ["Tom Scott"]
+  spec.email         = ["tscott@telvue.com"]
+  spec.summary       = %q{A Rails model layer for your Chef configuration.}
+  spec.description   = "#{spec.summary} Control your Chef configs with Rails."
+  spec.homepage      = "http://github.com/tubbo/hibachi"
+  spec.license       = "NCSA"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rails'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'redcarpet' # for docs in markdown
+  spec.add_development_dependency 'sqlite3' # for the dummy app
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+end

data/lib/generators/hibachi/install_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/base'
+
+module Hibachi
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Installs Hibachi to this Rails app"
+      source_root File.expand_path("../../templates", __FILE__)
+
+      def copy_initializer
+        template 'hibachi.rb', 'config/initializers/hibachi.rb'
+      end
+    end
+  end
+end

data/lib/generators/hibachi/model_generator.rb

@@ -0,0 +1,41 @@
+require 'rails/generators/named_base'
+
+module Hibachi
+  module Generators
+    class ModelGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      desc "Generates a model for interacting with the Chef config"
+      source_root File.expand_path("../../templates", __FILE__)
+
+      argument :model_attributes, :type => :array
+      class_option :recipe, :type => :string, :description => "Specify recipe"
+
+      def copy_model_definition
+        template 'model.rb.erb', "app/models/#{file_path}.rb"
+      end
+
+      protected
+      def model_class
+        file_path.classify
+      end
+
+      def symbolized_model_attributes
+        ARGV[1..-1].reject { |arg|
+          arg =~ /\A--/
+        }.map { |arg|
+          ":#{arg}"
+        }.join ', '
+      end
+
+      def recipe_name
+        return "'#{derived_recipe_name}'" if derived_recipe_name =~ /\:/
+        ":#{derived_recipe_name}" # prefer symbols
+      end
+
+      def derived_recipe_name
+        options[:recipe] || file_path.tableize
+      end
+    end
+  end
+end

data/lib/generators/templates/hibachi.rb

@@ -0,0 +1,11 @@
+require 'hibachi'
+
+# Configure global Hibachi settings here, such as the location of the log file
+# and Chef JSON file. You my also use the Rails config to manipulate
+# these settings, as all configuration data is stored in the
+# `Rails.application.config.hibachi` namespace.
+
+Hibachi.configure do |config|
+  #config.chef_json_path = "#{Rails.root}/config/chef.json"
+  #config.log_path = "#{Rails.root}/log/hibachi.log"
+end

data/lib/generators/templates/model.rb.erb

@@ -0,0 +1,4 @@
+class <%= model_class %> < Hibachi::Model
+  recipe <%= recipe_name %>
+  attr_accessor <%= symbolized_model_attributes %>
+end

data/lib/hibachi/chef_runner.rb

@@ -0,0 +1,54 @@
+require 'hibachi/install_active_job_error'
+
+module Hibachi
+  module ChefRunner
+    # Runs the local Chef::Solo client for the given recipe. Loads the
+    # configuration specified at `Hibachi.config.chef_json_path` as
+    # Chef JSON, running only the given recipe name as specified in the
+    # method call. Used by the model backend to run Chef when they are
+    # updated, so configuration stays up to date with the JSON
+    # configuration.
+    def run_chef recipe, options={}
+      return true unless config.run_chef
+
+      if options[:background]
+        run_chef_in_bg(recipe) and return true
+      else
+        run "touch #{config.log_path}" and
+        log "Running Chef for '#{recipe}' at '#{Time.now}'..." and
+        chef "-r '#{recipe_name(recipe)}' -J #{config.chef_json_path}"
+      end
+    end
+
+    private
+    def run_chef_in_bg recipe
+      raise InstallActiveJobError unless using_active_job?
+      require 'hibachi/job' # we must require it here "conditionally"
+      Hibachi::Job.enqueue self
+    end
+
+    def using_active_job?
+      defined? ActiveJob::Base
+    end
+
+    def chef options
+      run %(cd #{config.chef_dir} && chef-solo -l debug #{options})
+    end
+
+    def log message
+      run %(echo "#{message}" >> #{config.chef_json_path})
+    end
+
+    def run command
+      `#{command}` and $?.success?
+    end
+
+    def recipe_name name
+      if name =~ /\:\:/
+        "recipe[#{cookbook}::#{name}]"
+      else
+        "recipe[#{cookbook}::#{name}::default]"
+      end
+    end
+  end
+end

data/lib/hibachi/configuration.rb

@@ -0,0 +1,18 @@
+require 'hibachi/railtie'
+
+module Hibachi
+  # Methods for manipulating Hibachi's configuration settings, which are
+  # actually stored in the Rails config. This module is meant to be
+  # extend'ed onto the Hibachi main module.
+  module Configuration
+    # Manipulate the Hibachi configuration.
+    def configure
+      yield config
+    end
+
+    # Shorthand access to the entire Hibachi configuration.
+    def config
+      Rails.application.config.hibachi
+    end
+  end
+end

data/lib/hibachi/install_active_job_error.rb

@@ -0,0 +1,13 @@
+module Hibachi
+  # Thrown when `Hibachi::Job` is called, but `ActiveJob::Base` was not
+  # defined. Prevents a possibly harder-to-diagnose error.
+  class InstallActiveJobError < StandardError
+    def initialize
+      @message = %{
+        You must install ActiveJob to run Hibachi in the background..
+
+        <https://github.com/rails/activejob>
+      }
+    end
+  end
+end

data/lib/hibachi/job.rb

@@ -0,0 +1,7 @@
+module Hibachi
+  class Job < ActiveJob::Base
+    def perform(model)
+      Hibachi.run_chef model.recipe
+    end
+  end
+end

data/lib/hibachi/model.rb

@@ -0,0 +1,42 @@
+require 'active_model'
+
+require 'hibachi/recipe'
+require 'hibachi/persistence'
+require 'hibachi/provisioning'
+require 'hibachi/querying'
+
+module Hibachi
+  # A Rails model backend for describing machine configuration and
+  # exposing such configuration to manipulation by the end user.
+  # Hibachi::Model is subclassed like an ActiveRecord::Base, you define
+  # attributes on the class that map to attributes in each model's JSON
+  # representation.
+  class Model
+    include ActiveModel::Model
+    include Recipe
+    include Persistence
+    include Provisioning
+    extend Querying
+
+    # Store all attributes in this Hash.
+    attr_reader :attributes
+
+    # Set attributes to the main collector before assigning them to
+    # methods.
+    def initialize(from_attrs={})
+      @attributes = from_attrs
+      super
+    end
+
+    # The JSON representation of each Model object is simply its
+    # attributes exposed as JSON.
+    def to_json(*arguments)
+      @json ||= attributes.to_json
+    end
+
+    protected
+    def config
+      Hibachi.config
+    end
+  end
+end

data/lib/hibachi/node.rb

@@ -0,0 +1,112 @@
+module Hibachi
+  # Interaction object with the Chef JSON. This class is used to write
+  # to and read from the configuration on disk, which is also used by
+  # Chef to manage machine configuration. It's called "Node" because
+  # that's what Chef Server calls each of the servers it's deploying
+  # your code to.
+  #
+  # All operations on this class are "hard", that is, they will actually
+  # write data out to the config file.
+  class Node
+    include ActiveModel::Model
+    include Enumerable
+
+    attr_accessor :attributes, :file_path
+
+    validates :file_path, presence: true
+
+    validate :file_exists
+    validate :has_cookbook_attributes
+
+    # Derive config from file at given path.
+    def self.find at_path=""
+      node = new file_path: at_path
+      node.valid?
+      node
+    end
+
+    # Test if the specified file we're supposed to manipulate does in
+    # fact exist.
+    def exists?
+      @exists ||= File.exists? file_path
+    end
+    alias present? exists?
+
+    # Iterate through all attributes.
+    def each
+      attributes.each { |attr| yield attr }
+    end
+
+    delegate :empty?, :to => :attributes
+    delegate :any?, :to => :attributes
+
+    # Find the attribute at a given key.
+    def [] key
+      attributes[key]
+    end
+
+    # Set the attribute at a given key.
+    def []= key, value
+      merge! key => value
+    end
+
+    # Merge incoming Hash with the Chef JSON.
+    def merge! with_new_attributes={}
+      attributes.merge! with_new_attributes
+      update!
+    end
+
+    # Delete an attribute from the Hash and write JSON.
+    def delete id
+      attributes.delete id
+      update!
+    end
+
+    # Delete all attributes from this recipe.
+    def delete!
+      @attributes = {}
+      update!
+    end
+
+    # Attributes as initially populated by the parsed JSON file. Scoped
+    # by the global cookbook.
+    def attributes
+      @attributes ||= parsed_json_attributes[Hibachi.config.cookbook] || {}
+    end
+
+    delegate :any?, :to => :attributes
+    delegate :empty?, :to => :attributes
+
+    protected
+    # All attributes as parsed from the Chef JSON.
+    def parsed_json_attributes
+      JSON.parse(chef_json).with_indifferent_access
+    end
+
+    private
+    def chef_json
+      @raw_json ||= File.read file_path
+    end
+
+    def update!
+      File.write file_path, pretty_formatted_json
+      true
+    rescue StandardError => exception
+      logger.error exception.message
+      exception.backtrace.each { |line| logger.error line }
+      false
+    end
+
+    def pretty_formatted_json
+      JSON.pretty_generate Hibachi.config.cookbook => attributes
+    end
+
+    def file_exists
+      errors.add :file, "'#{file_path}' does not exist" unless exists?
+    end
+
+    def has_cookbook_attributes
+      errors.add :cookbook, "could not be parsed from JSON" unless any?
+    end
+  end
+end