fry-cook 0.2.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6bb59c77a0a41152f10c174fafcd5af5b0e2ecc2
+  data.tar.gz: 999b3e34abaaa77b593da933634dae1b28ac6008
+SHA512:
+  metadata.gz: 63627e5591cda4bb4646b2267fa979378bd41600ac2d4bc90bb7123b12495dbdc1732fa2ee70b4605ddaa0e466c6f549f26265e89fa4b24aabf9dbb14c6c5aff
+  data.tar.gz: ef31001c347c70f867827d59b6b62e24d4d5cbcbecc82c30403a55acfa96968c8b6c0459ef65ddee302d7920be2e4025005059a3d1bb43cb94b3246af8a6262e

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2013, Graham Batty
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the Project.

data/README.md

@@ -0,0 +1,135 @@
+# Fry Cook
+
+*Not quite a chef yet, the fry cook knows only one menu.* 
+
+Fry Cook is a chef server that is designed to be used with a
+git repository (or working directory) that is to be treated as
+a definitive source of truth. It is based on chef zero with
+the Chef local filesystem data source, but has some modifications
+on top of that.
+
+## Standalone Usage
+
+Fry Cook can be used as a standalone server just like a normal
+chef server. All the caveats of using this as a chef server apply
+as using [https://github.com/opscode/chef-zero](Chef-Zero). It
+doesn't authenticate anything. This is because it uses chef-zero
+to do most of the work.
+
+However, it can be useful in ways that chef-zero is not. Namely,
+it can seed your cookbooks from a git repository and even build
+those cookbooks from a Berksfile. It will also convert all .rb files
+to .json files as expected by the chef server. This is all a much
+faster option than setting up a chef server and uploading everything
+to it.
+
+If you run fry-cook --help you will see this:
+
+```bash
+    Usage: fry-cook [ARGS]
+        -H, --host HOST                  Host to bind to (default: 127.0.0.1)
+        -p, --port PORT                  Port to listen on (default: 8889)
+            --socket PATH                Unix socket path to listen on
+        -d, --daemon                     Run as a daemon process
+            --path PATH                  A working copy of the chef-repo to build from (default: .)
+            --remote GIT_REMOTE          A git remote to build from
+            --track GIT_REF              The branch (or other ref) to track in the git remote (default: master)
+            --storage-path PATH          Where to store the files the server works from (default: {working_path}/.fry-cook
+        -l, --log-level LEVEL            Set the output log level
+        -h, --help                       Show this message
+            --version                    Show version
+```
+
+The arguments that differ from chef-zero are the path, remote,
+track, and storage-path options. Fry-cook effectively has two modes,
+depending on where you want to build your working chef server from:
+
+### From a Local Path
+
+You can build from a local path, like a working copy of a git repository. This
+is great for development or using as a vagrant plugin (below). To use this mode you
+can simply pass nothing special and it will assume the current working directory
+is the local path you want to work from. To explicitly specify a path, you can
+pass the --path option.
+
+You should not pass the remote or track arguments for this mode. They put it
+into the git mode, described in the next section.
+
+Examples:
+
+```bash
+    fry-cook -d # The current working directory should be a chef repo.
+```
+
+```bash
+    fry-cook -d --path /var/lib/chef # Build from /var/lib/chef.
+```
+
+### From a Git Repository or Remote
+
+If you want to build your chef server configuration from a remote git repository,
+say on github or some other central repository, you can use the remote and track
+arguments. Remote is a git remote, such as ```git@github.com:stormbrew/fry-cook.git```.
+Track is the reference within the repository, which could be a branch or tag. It
+defaults to the master branch.
+
+Examples:
+
+```bash
+    fry-cook -d --remote git@github.com:stormbrew/mything.git # Master branch of mything on github.
+```
+
+```bash
+    fry-cook -d --remote git@github.com:stormbew/mything.git --track production # Production branch of mything on github.
+```
+
+### Storage Path
+
+The storage path is where fry-cook builds into. Every time it builds from
+the source it builds into a fresh directory. It also keeps the uploaded node
+json files in here in a way that persists across rebuilds.
+
+This setup is designed to allow rebuilding from the repository on a live
+server without turning it off. This feature will be added later.
+
+Most of the time you'll want to leave this as the default, which will
+put it in a .fry-cook directory in the current working directory.
+
+## Using With Vagrant
+
+If you install Fry Cook as a vagrant plugin you can use it in much the same
+way as the vagrant-chef-zero plugin. You don't need to install a separate
+plugin to do this, just ```vagrant plugin install fry-cook```. From there
+you can add it to your Vagrantfile as follows:
+
+```ruby
+    Vagrant.configure("2") do |config|
+        config.vm.box_url = "http://files.vagrantup.com/precise64.box"
+        config.omnibus.chef_version = "11.8.0"
+
+        ## For a local repository
+        config.fry_cook.repo_path = "."
+
+        ## For a remote repository
+        # config.fry_cook.repo_git_remote = "git@github.com:stormbrew/stuff.git"
+        # config.fry_cook.repo_git_ref = "master" # optional
+
+        ## If you have multiple vms in your vagrantfile and you
+        ## want them to use a different chef server, you can set
+        ## them up to use different 'prefixes' and different server
+        ## ports (default is 18999) to keep them separate:
+        # config.fry_cook.prefix = "config1"
+        # config.fry_cook.server_port = 9432
+
+        config.vm.provision :chef_client do |chef_client|
+            chef_client.add_recipe "apt"
+            chef_client.add_recipe "nginx"
+        end
+    end
+```
+
+## Future Work
+
+This really needs more testing infrastructure (or any at all). It also needs
+a command to rebuild the repo without restarting the server, which is not
+terribly difficult.

data/bin/fry-cook

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require "fry_cook/version"
+require "chef_zero/version"
+require "fry_cook/server"
+require "optparse"
+
+options = {}
+fry_options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: fry-cook [ARGS]"
+
+  opts.on("-H", "--host HOST", "Host to bind to (default: 127.0.0.1)") do |value|
+    options[:host] = value
+  end
+  opts.on("-p", "--port PORT", Integer, "Port to listen on (default: 8889)") do |value|
+    options[:port] = value
+  end
+  opts.on("--socket PATH", String, "Unix socket path to listen on") do |value|
+    options[:socket] = value
+  end
+  opts.on("-d", "--daemon", "Run as a daemon process") do |value|
+    options[:daemon] = value
+  end
+
+  opts.on("--path PATH", String, "A working copy of the chef-repo to build from (default: .)") do |value|
+    fry_options[:working_path] = value
+  end
+
+  opts.on("--remote GIT_REMOTE", String, "A git remote to build from") do |value|
+    fry_options[:git_repo_remote] = value
+  end
+
+  opts.on("--track GIT_REF", String, "The branch (or other ref) to track in the git remote (default: master)") do |value|
+    fry_options[:git_ref] = value
+  end
+
+  opts.on("--storage-path PATH", String, "Where to store the files the server works from (default: {working_path}/.fry-cook") do |value|
+    fry_options[:storage_path] = value
+  end
+
+  opts.on("-l", "--log-level LEVEL", "Set the output log level") do |value|
+    options[:log_level] = value
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "Show version") do
+    puts "fry-cook-#{FryCook::VERSION}, chef-zero-#{ChefZero::VERSION}"
+    exit
+  end
+end.parse!
+
+server = FryCook::Server.new(options, fry_options)
+
+if options[:daemon]
+  unless Process.respond_to?('daemon')
+    abort 'Process.deamon requires Ruby >= 1.9'
+  else
+    Process.daemon(true)
+    server.start(:publish => true)
+  end
+else
+  server.start(:publish => true)
+end

data/lib/fry-cook.rb

@@ -0,0 +1,3 @@
+if defined? Vagrant
+  require 'fry_cook/vagrant_plugin'
+end

data/lib/fry_cook/server.rb

@@ -0,0 +1,24 @@
+require 'chef_zero/server'
+require 'fry_cook/work_tree'
+
+module FryCook
+  class Server < ChefZero::Server
+    def initialize(chef_options, fry_options)
+      @work_tree = WorkTree.new(fry_options)
+      @work_tree.build
+
+      Chef::Config.node_path = @work_tree.node_path
+      Chef::Config.cookbook_path = @work_tree.cookbook_path
+      Chef::Config.role_path = @work_tree.role_path
+      Chef::Config.data_bag_path = @work_tree.data_bag_path
+      Chef::Config.environment_path = @work_tree.environment_path
+
+      data_store = Chef::ChefFS::ChefFSDataStore.new(
+        Chef::ChefFS::Config.new(Chef::Config).local_fs
+      )
+      chef_options[:data_store] = data_store
+
+      super(chef_options)
+    end
+  end
+end

data/lib/fry_cook/vagrant_plugin.rb

@@ -0,0 +1,32 @@
+module FryCook
+  module VagrantPlugin
+    class Plugin < ::Vagrant.plugin("2")
+      name "fry-cook"
+      description <<-DESC
+      Auto-configurator for fry cook for the chef_client provisioner.
+      DESC
+
+      config(:fry_cook) do
+        require File.expand_path("../vagrant_plugin/config", __FILE__)
+        Config
+      end
+
+      action_hook(:fry_cook_reconfig) do |hook|
+        chain = Vagrant::Action::Builder.new.tap do |b|
+          require File.expand_path("../vagrant_plugin/hooks", __FILE__)
+          b.use Hooks::ConfigureServerUrl
+        end
+        hook.before(::Vagrant::Action::Builtin::ConfigValidate, chain)
+      end
+      %w{up reload provision}.each do |action|
+        action_hook(:"fry_cook_#{action}", :"machine_action_#{action}") do |hook|
+          chain = Vagrant::Action::Builder.new.tap do |b|
+            require File.expand_path("../vagrant_plugin/hooks", __FILE__)
+            b.use Hooks::StartServer
+          end
+          hook.before(::Vagrant::Action::Builtin::Provision, chain)
+        end
+      end
+    end
+  end
+end

data/lib/fry_cook/vagrant_plugin/config.rb

@@ -0,0 +1,38 @@
+module FryCook
+  module VagrantPlugin
+    class Config < Vagrant.plugin("2", :config)
+      def self.config_attr(name, default = nil, &block)
+        @config_attrs ||= {}
+        @config_attrs[name] = block || default
+        attr_accessor name
+      end
+      def self.config_attrs
+        @config_attrs || {}
+      end
+
+      config_attr :repo_path
+      config_attr :repo_git_remote
+      config_attr :repo_git_track, "master"
+      config_attr :prefix, "default"
+      config_attr :server_port, 18998
+
+      def initialize()
+        self.class.config_attrs.each do |config_attr, default|
+          instance_variable_set(:"@#{config_attr}", UNSET_VALUE)
+        end
+      end
+
+      def finalize!
+        self.class.config_attrs.each do |config_attr, default|
+          if instance_variable_get(:"@#{config_attr}") == UNSET_VALUE
+            if default.respond_to? :call
+              default = default.call
+            end
+            instance_variable_set(:"@#{config_attr}", default)
+          end
+        end
+        {}
+      end
+    end
+  end
+end

data/lib/fry_cook/vagrant_plugin/hooks.rb

@@ -0,0 +1,99 @@
+require 'socket'
+require 'openssl'
+require 'tmpdir'
+require 'fry_cook/server'
+
+module FryCook::VagrantPlugin::Hooks
+  class Base
+    def initialize(app, env)
+      @app = app
+      @env = env
+    end
+
+    def config
+      @env[:machine].config.fry_cook
+    end
+
+    def client_config
+      @env[:machine].config.vm.provisioners.select {|prov| prov.name == :chef_client }
+    end
+
+    def active?
+      client_config.any? && config.repo_path || config.repo_git_remote
+    end
+
+    def host_ip_address
+      # This gets the first ip address in a private range. With virtualbox,
+      # at least, things seem to be routed so that the vm can connect to this
+      # IP even if it has nothing to do with vagrant or virtualbox. This may not
+      # be an entirely safe assumption, but vagrant doesn't provide any kind of
+      # better way to obtain a canonical reachable address as far as I can tell.
+      Socket.ip_address_list.detect{|intf| intf.ipv4_private?}.ip_address
+    end
+
+    def call(env)
+      @env = env
+      if active?
+        do_action(env)
+      end
+      @app.call(env)
+    end
+  end
+
+  class ConfigureServerUrl < Base
+    def get_fake_key_path
+      fake_directory = File.join(Dir.tmpdir, "fake_key")
+      fake_key_path = File.join(fake_directory, "fake.pem")
+
+      if !File.exists?(fake_key_path)
+        fake_key = OpenSSL::PKey::RSA.new(2048)
+        Dir.mkdir(fake_directory) unless File.exists?(fake_directory)
+        File.open(fake_key_path,"w") {|f| f.puts fake_key } 
+      end
+
+      fake_key_path
+    end
+
+    def do_action(env)
+      client_config.each do |client|
+        fake_key = get_fake_key_path
+
+        if !client.config.instance_variable_get(:"@chef_server_url")
+          client.config.instance_variable_set(:"@chef_server_url", "http://#{host_ip_address}:#{config.server_port}/")
+        end
+        if !client.config.instance_variable_get(:@validation_key_path)
+          client.config.instance_variable_set(:@validation_key_path, fake_key)
+        end
+      end
+    end
+  end
+
+  class StartServer < Base
+    def do_action(env)
+      # Note: This is not thread safe, but it may not entirely
+      # be able to be. I don't think vagrant would run these in
+      # parallel at the moment at any rate.
+      if !defined? @@running
+        server_options = {
+          host: host_ip_address,
+          port: config.server_port,
+          daemon: false,
+        }
+        fry_options = {
+          storage_path: ".vagrant/fry-cook/#{config.prefix}",
+        }
+        case
+        when config.repo_path
+          fry_options[:working_path] = config.repo_path
+        when config.repo_git_remote
+          fry_options[:git_repo_remote] = config.repo_git_remote
+          fry_options[:git_ref] = config.repo_git_track
+        end
+
+        server = FryCook::Server.new(server_options, fry_options)
+        server.start_background
+        @@running = true
+      end
+    end
+  end
+end

data/lib/fry_cook/version.rb

@@ -0,0 +1,3 @@
+module FryCook
+  VERSION = "0.2.0.beta1"
+end

data/lib/fry_cook/work_tree.rb

@@ -0,0 +1,184 @@
+require 'chef/chef_fs/chef_fs_data_store'
+require 'chef/chef_fs/config'
+require 'chef/role'
+require 'chef/environment'
+require 'fileutils'
+require 'json'
+require 'berkshelf'
+
+module FryCook
+  class WorkTree
+    attr_reader :storage_path
+
+    def initialize(options)
+      if options[:storage_path] && File.file?("#{options[:storage_path]}/config.json")
+        existing_config = JSON.load(File.read("#{options[:storage_path]}/config.json"), nil, symbolize_names: true)
+        options = existing_config.merge(options)
+      end
+
+      if options[:git_repo_remote]
+        @mode = :git
+        @git_remote = options[:git_repo_remote]
+        @git_ref = options[:git_ref] || 'master'
+        @storage_path = options[:storage_path] || raise("Must specify storage path for git mode.")
+        @git_repo = "#{@storage_path}/git-repo"
+      else
+        @mode = :path
+        @working_path = options[:working_path] || '.'
+        @storage_path = options[:storage_path] || "#{@working_path}/.fry-cook"
+      end
+
+      FileUtils.mkdir_p(@storage_path)
+      FileUtils.mkdir_p("#{@storage_path}/nodes")
+
+      File.write("#{@storage_path}/config.json", JSON.dump(options))
+    end
+
+    def node_path
+      "#{storage_path}/nodes"
+    end
+    def cookbook_path
+      "#{storage_path}/current/cookbooks"
+    end
+    def role_path
+      "#{storage_path}/current/roles"
+    end
+    def data_bag_path
+      "#{storage_path}/current/data_bags"
+    end
+    def environment_path
+      "#{storage_path}/current/environments"
+    end
+
+    def cmd(cmd)
+      res = IO.popen(cmd, :err=>[:child, :out]) do |p|
+        p.readlines.collect {|line| line.chomp }
+      end
+      if !$?.success?
+        raise("Command #{cmd.join(' ')} failed:\n#{res.join("\n")}")
+      end
+      res
+    end
+    def git(*cmd)
+      cmd(["git", "--git-dir", @git_repo, *cmd])
+    end
+    def git_in(work_path, *cmd)
+      FileUtils.mkdir_p(work_path)
+      git("--work-tree", work_path, *cmd)
+    end
+
+    def git_refresh
+      if !File.directory? @git_repo
+        git("clone", "--bare", @git_remote, @git_repo)
+      end
+      git("fetch", '-f', @git_remote, 'refs/heads/*:refs/heads/*')
+    end
+
+    def pull_source
+      case @mode
+      when :git
+        git_refresh
+        new_ref = git("rev-parse", @git_ref)
+        if new_ref.length == 0
+          raise("Didn't get a valid ref for #{@git_ref}")
+        end
+        new_version = "build-" + new_ref[0]
+        source_path = "#{@storage_path}/#{new_version}/chef_repo"
+        if !File.directory? source_path
+          git_in(source_path, "checkout", "-f", @git_ref)
+        end
+      when :path
+        new_version = "build-#{Time.now.to_i}"
+        source_path = @working_path
+      end
+      return new_version, source_path
+    end
+
+    def install_cookbooks(new_version, source_path, install_path)
+      case
+      when File.file?("#{source_path}/Berksfile")
+        # Note: Doesn't work properly without being in the directory of the berksfile.
+        Dir.chdir(source_path) do
+          berksfile = Berkshelf::Berksfile.from_file("Berksfile")
+          berksfile.vendor("#{install_path}/cookbooks")
+        end
+      when File.directory?("#{source_path}/cookbooks")
+        FileUtils.cp_r("#{source_path}/cookbooks", "#{install_path}/cookbooks")
+      else
+        raise("No cookbooks found.")
+      end
+    end
+
+    def install_environments(new_version, source_path, install_path)
+      FileUtils.mkdir_p("#{install_path}/environments")
+      environments = Dir.glob("#{source_path}/environments/*.json")
+      if !environments.empty?
+        FileUtils.cp(environments, "#{install_path}/environments")
+      end
+      Dir.glob("#{source_path}/environments/*.rb").each do |environment|
+        environment_obj = Chef::Environment.new
+        environment_obj.name File.basename(environment, ".rb")
+        environment_obj.from_file(environment)
+        File.write("#{install_path}/environments/#{File.basename(environment, ".rb")}.json", environment_obj.to_json)
+      end
+    end
+
+    def install_roles(new_version, source_path, install_path)
+      FileUtils.mkdir_p("#{install_path}/roles")
+      roles = Dir.glob("#{source_path}/roles/*.json")
+      if !roles.empty?
+        FileUtils.cp(roles, "#{install_path}/roles")
+      end
+      Dir.glob("#{source_path}/roles/*.rb").each do |role|
+        role_obj = Chef::Role.new
+        role_obj.name File.basename(role, ".rb")
+        role_obj.from_file(role)
+        File.write("#{install_path}/roles/#{File.basename(role, ".rb")}.json", role_obj.to_json)
+      end
+    end
+
+    def install_data_bags(new_version, source_path, install_path)
+      FileUtils.mkdir_p("#{install_path}/data_bags")
+      Dir.glob("#{source_path}/data_bags/*").each do |data_bag|
+        next if !File.directory? data_bag
+
+        data_bag_name = File.basename(data_bag)
+        FileUtils.mkdir_p("#{install_path}/data_bags/#{data_bag_name}")
+        items = Dir.glob("#{data_bag}/*.json")
+        if !items.empty?
+          FileUtils.cp(items, "#{install_path}/data_bags/#{data_bag_name}")
+        end
+      end
+    end
+
+    def build(force = false)
+      current_link = "#{@storage_path}/current"
+      old_version = File.symlink?(current_link) && File.readlink(current_link)
+
+      new_version, source_path = pull_source()
+      install_path = File.expand_path("#{@storage_path}/#{new_version}")
+
+      if force || new_version != old_version
+        begin
+          install_cookbooks(new_version, source_path, install_path)
+          install_environments(new_version, source_path, install_path)
+          install_roles(new_version, source_path, install_path)
+          install_data_bags(new_version, source_path, install_path)
+        rescue
+          # Clean up the probably broken deploy install path if it got created.
+          # We don't care why it failed, so we pass the buck up.
+          FileUtils.rmdir(install_path) if File.directory?(install_path)
+          raise
+        end
+
+        tmplink = current_link + ".#{Process.pid}.lnk"
+        FileUtils.ln_s(new_version, tmplink)
+        File.rename(tmplink, current_link)
+
+        if old_version && File.directory?("#{@storage_path}/#{old_version}")
+          FileUtils.rm_rf("#{@storage_path}/#{old_version}")
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: fry-cook
+version: !ruby/object:Gem::Version
+  version: 0.2.0.beta1
+platform: ruby
+authors:
+- Graham Batty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: chef-zero
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta7
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: Not quite a chef yet, the fry cook knows only one menu.
+email: graham@stormbrew.ca
+executables:
+- fry-cook
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/fry-cook
+- lib/fry_cook/version.rb
+- lib/fry_cook/vagrant_plugin/hooks.rb
+- lib/fry_cook/vagrant_plugin/config.rb
+- lib/fry_cook/work_tree.rb
+- lib/fry_cook/server.rb
+- lib/fry_cook/vagrant_plugin.rb
+- lib/fry_cook/.version.rb.swp
+- lib/fry-cook.rb
+- LICENSE
+- README.md
+homepage: https://www.github.com/stormbrew/fry-cook
+licenses: []
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Not quite a chef yet, the fry cook knows only one menu.
+test_files: []