caterer 0.0.1

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tyler Flint
+
+MIT License
+
+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,29 @@
+# Caterer
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'caterer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install caterer
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/cater

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+# TODO: find a way to conditionally trigger this if dev only
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'log4r'
+require 'caterer'
+require 'vli'
+
+$stdout.sync = true
+$stderr.sync = true
+
+logger = Log4r::Logger.new "caterer::bin::cater"
+logger.info "`cater` invoked: #{ARGV.inspect}"
+
+opts = {}
+
+# Disable color if the proper argument was passed or if we're
+# on Windows since the default Windows terminal doesn't support
+# colors.
+if ARGV.include?("--no-color") || !$stdout.tty? || !Vli::Util::Platform.terminal_supports_colors?
+  # Delete the argument from the list so that it doesn't cause any
+  # invalid arguments down the road.
+  ARGV.delete("--no-color")
+  opts[:ui_class] = Vli::UI::Basic
+else
+  opts[:ui_class] = Vli::UI::Colored
+end
+
+env = Caterer::Environment.new(opts)
+
+env.load!
+
+exit env.cli(ARGV)

data/caterer.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'caterer/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "caterer"
+  gem.version       = Caterer::VERSION
+  gem.authors       = ["Tyler Flint"]
+  gem.email         = ["tylerflint@gmail.com"]
+  gem.description   = %q{Caterer is a server configuration tool that caters to your servers with a push model, with support for chef recipes}
+  gem.summary       = %q{A server configuration tool that caters to your servers with a push model, with support for chef recipes}
+  gem.homepage      = ""
+
+  gem.add_dependency 'log4r'
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'vli'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/config/default.rb

@@ -0,0 +1,3 @@
+Caterer.configure do |config|
+  # nothing to see here... yet
+end

data/example/Caterfile

@@ -0,0 +1,25 @@
+Caterer.configure do |config|
+
+  config.role :default do |node|
+
+    node.provision :chef_solo do |chef|
+      chef.add_recipe 'ruby'
+      chef.add_recipe 'mysql::server'
+      chef.add_recipe 'mysql::client'
+      chef.json = {
+        "ruby" => {
+          "gems" => ['args_parser', 'mysql2']
+        },
+        "mysql" => {
+          "server_root_password" => "root",
+          "bind_address" => '127.0.0.1',
+          "client" => {
+            "packages" => ["mysql-client", "libmysqlclient-dev"]
+          }
+        }
+      }
+    end
+
+  end
+
+end

data/lib/caterer.rb

@@ -0,0 +1,27 @@
+require 'vli'
+require 'caterer/version'
+require 'caterer/logger'
+
+module Caterer
+  autoload :Cli,          'caterer/cli'
+  autoload :Command,      'caterer/command'
+  autoload :Config,       'caterer/config'
+  autoload :Environment,  'caterer/environment'
+  
+  extend self
+
+  def commands
+    @commands ||= Vli::Registry.new
+  end
+
+  def config
+    @config ||= Config::Base.new
+  end
+
+  def configure
+    yield config if block_given?
+  end
+
+end
+
+require 'caterer/commands'

data/lib/caterer/cli.rb

@@ -0,0 +1,71 @@
+# Credit:
+# special thanks to Vagrant project: https://github.com/mitchellh/vagrant
+# where the source of this module was originally extracted.
+
+require 'optparse'
+
+module Caterer
+  class Cli < Vli::Command::Base
+    def initialize(argv, env)
+      super
+
+      @logger = Log4r::Logger.new("caterer::cli")
+      @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+      @logger.info("CLI: #{@main_args.inspect} #{@sub_command.inspect} #{@sub_args.inspect}")
+    end
+
+    def execute
+      if @main_args.include?("-v") || @main_args.include?("--version")
+        # Version short-circuits the whole thing. Just print
+        # the version and exit.
+        @env.ui.info "Caterer version #{Caterer::VERSION}", :prefix => false
+
+        return 0
+      elsif @main_args.include?("-h") || @main_args.include?("--help")
+        # Help is next in short-circuiting everything. Print
+        # the help and exit.
+        help
+        return 0
+      end
+
+      command_class = Caterer.commands.get(@sub_command.to_sym) if @sub_command
+      if !command_class || !@sub_command
+        help
+        return 0
+      end
+      @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+      # Initialize and execute the command class, returning the exit status.
+      result = command_class.new(@sub_args, @env).execute
+      result = 0 if !result.is_a?(Fixnum)
+      result
+    end
+
+    def help
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: cater [-v] [-h] command [<args>]"
+        opts.separator ""
+        opts.on("-v", "--version", "Print the version and exit.")
+        opts.on("-h", "--help", "Print this help.")
+        opts.separator ""
+        opts.separator "Available subcommands:"
+
+        # Add the available subcommands as separators in order to print them
+        # out as well.
+        keys = []
+        Caterer.commands.each { |key, value| keys << key.to_s }
+
+        keys.sort.each do |key|
+          opts.separator "     #{key}"
+        end
+
+        opts.separator ""
+        opts.separator "For help on any individual command run `cater COMMAND -h`"
+      end
+
+      @env.ui.info opts.help, :prefix => false
+    end
+
+  end
+end

data/lib/caterer/command.rb

@@ -0,0 +1,5 @@
+module Caterer
+  module Command
+    autoload :Test, 'caterer/command/test'
+  end
+end

data/lib/caterer/command/test.rb

@@ -0,0 +1,12 @@
+module Caterer
+  module Command
+    class Test < Vli::Command::Base
+      
+      def execute
+        puts "testy testy!"
+        0
+      end
+
+    end
+  end
+end

data/lib/caterer/commands.rb

@@ -0,0 +1 @@
+Caterer.commands.register(:test) { Caterer::Command::Test }

data/lib/caterer/config.rb

@@ -0,0 +1,7 @@
+module Caterer
+  module Config
+    autoload :Base,       'caterer/config/base'
+    autoload :Role,       'caterer/config/role'
+    autoload :Provision,  'caterer/config/provision'
+  end
+end

data/lib/caterer/config/base.rb

@@ -0,0 +1,17 @@
+module Caterer::Config
+
+  class Base
+    attr_accessor :roles
+
+    def initialize
+      @roles = []  
+    end
+
+    def role(name)
+      role = Caterer::Config::Role.new(name)
+      yield role if block_given?
+      @roles << role
+    end
+  end
+
+end

data/lib/caterer/config/provision.rb

@@ -0,0 +1,5 @@
+module Caterer::Config
+  module Provision
+    autoload :ChefSolo, 'caterer/config/provision/chef_solo'
+  end
+end

data/lib/caterer/config/provision/chef_solo.rb

@@ -0,0 +1,18 @@
+module Caterer::Config::Provision
+
+  class ChefSolo
+    
+    attr_accessor :recipes, :json
+
+    def initialize
+      @recipes = []
+      @json = {}
+    end
+
+    def add_recipe(recipe)
+      @recipes << recipe
+    end
+
+  end
+
+end

data/lib/caterer/config/role.rb

@@ -0,0 +1,21 @@
+require 'active_support/inflector'
+
+module Caterer::Config
+
+  class Role
+    
+    attr_reader   :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def provision(type=nil)
+      return @provision if not type
+      @provision = "Caterer::Config::Provision::#{type.to_s.classify}".constantize.new
+      yield @provision if block_given?
+    end
+
+  end
+
+end

data/lib/caterer/environment.rb

@@ -0,0 +1,53 @@
+require 'pathname'
+
+module Caterer
+  class Environment
+    
+    attr_reader :cwd, :caterfile_name, :ui
+
+    def initialize(opts={})
+      opts = {
+        :cwd => nil,
+        :caterfile_name => nil,
+        :ui_class => nil
+      }.merge(opts)
+
+      opts[:cwd] ||= ENV["CATERER_CWD"] if ENV.has_key?("CATERER_CWD")
+      opts[:cwd] ||= Dir.pwd
+      opts[:cwd]  = Pathname.new(opts[:cwd])
+
+      opts[:caterfile_name] ||= []
+      opts[:caterfile_name] = [opts[:caterfile_name]] if !opts[:vagrantfile_name].is_a?(Array)
+      opts[:caterfile_name] += ["Caterfile"]
+
+      @cwd            = opts[:cwd]
+      @caterfile_name = opts[:caterfile_name]
+
+      ui_class = opts[:ui_class] || Vli::UI::Silent
+      @ui      = ui_class.new("cater")
+
+    end
+
+    def load!
+      load_default_config
+      load_custom_config
+    end
+
+    def load_default_config
+      # doesn't work yet
+      # require 'config/default'
+    end
+
+    def load_custom_config
+      @caterfile_name.each do |config_file|
+        file = "#{@cwd}/#{config_file}"
+        load file if File.exists? file
+      end
+    end
+
+    def cli(*args)
+      Cli.new(args.flatten, self).execute
+    end
+
+  end
+end

data/lib/caterer/logger.rb

@@ -0,0 +1,43 @@
+require 'log4r'
+
+# Enable logging if it is requested. We do this before
+# anything else so that we can setup the output before
+# any logging occurs.
+if ENV["LOG_LEVEL"] && ENV["LOG_LEVEL"] != ""
+  # Require Log4r and define the levels we'll be using
+  require 'log4r/config'
+  Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
+
+  level = nil
+  begin
+    level = Log4r.const_get(ENV["LOG_LEVEL"].upcase)
+  rescue NameError
+    # This means that the logging constant wasn't found,
+    # which is fine. We just keep `level` as `nil`. But
+    # we tell the user.
+    level = nil
+  end
+
+  # Some constants, such as "true" resolve to booleans, so the
+  # above error checking doesn't catch it. This will check to make
+  # sure that the log level is an integer, as Log4r requires.
+  level = nil if !level.is_a?(Integer)
+
+  if !level
+    # We directly write to stderr here because the VagrantError system
+    # is not setup yet.
+    $stderr.puts "Invalid LOG_LEVEL: #{ENV["LOG_LEVEL"]}"
+    $stderr.puts ""
+    $stderr.puts "Please use one of the standard log levels: debug, info, warn, or error"
+    exit 1
+  end
+
+  # Set the logging level on all "caterer" namespaced
+  # logs as long as we have a valid level.
+  if level
+    logger = Log4r::Logger.new("caterer")
+    logger.outputters = Log4r::Outputter.stderr
+    logger.level = level
+    logger = nil
+  end
+end

data/lib/caterer/version.rb

@@ -0,0 +1,3 @@
+module Caterer
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: caterer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tyler Flint
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Caterer is a server configuration tool that caters to your servers with
+  a push model, with support for chef recipes
+email:
+- tylerflint@gmail.com
+executables:
+- cater
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cater
+- caterer.gemspec
+- config/default.rb
+- example/Caterfile
+- lib/caterer.rb
+- lib/caterer/cli.rb
+- lib/caterer/command.rb
+- lib/caterer/command/test.rb
+- lib/caterer/commands.rb
+- lib/caterer/config.rb
+- lib/caterer/config/base.rb
+- lib/caterer/config/provision.rb
+- lib/caterer/config/provision/chef_solo.rb
+- lib/caterer/config/role.rb
+- lib/caterer/environment.rb
+- lib/caterer/logger.rb
+- lib/caterer/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A server configuration tool that caters to your servers with a push model,
+  with support for chef recipes
+test_files: []
+has_rdoc: