tenderloin 0.2.0

data/lib/tenderloin/actions/vm/provision.rb

@@ -0,0 +1,71 @@
+module Tenderloin
+  module Actions
+    module VM
+      class Provision < Base
+        def execute!
+          chown_provisioning_folder
+          setup_json
+          setup_solo_config
+          run_chef_solo
+        end
+
+        def chown_provisioning_folder
+          logger.info "Setting permissions on provisioning folder..."
+          SSH.execute do |ssh|
+            ssh.exec!("sudo chown #{Tenderloin.config.ssh.username} #{Tenderloin.config.chef.provisioning_path}")
+          end
+        end
+
+        def setup_json
+          logger.info "Generating JSON and uploading..."
+
+          # Set up initial configuration
+          data = {
+            :config => Tenderloin.config,
+            :directory => Tenderloin.config.vm.project_directory,
+          }
+
+          # And wrap it under the "tenderloin" namespace
+          data = { :tenderloin => data }
+
+          # Merge with the "extra data" which isn't put under the
+          # tenderloin namespace by default
+          data.merge!(Tenderloin.config.chef.json)
+
+          json = data.to_json
+
+          SSH.upload!(StringIO.new(json), File.join(Tenderloin.config.chef.provisioning_path, "dna.json"))
+        end
+
+        def setup_solo_config
+          solo_file = <<-solo
+file_cache_path "#{Tenderloin.config.chef.provisioning_path}"
+cookbook_path "#{cookbooks_path}"
+solo
+
+          logger.info "Uploading chef-solo configuration script..."
+          SSH.upload!(StringIO.new(solo_file), File.join(Tenderloin.config.chef.provisioning_path, "solo.rb"))
+        end
+
+        def run_chef_solo
+          logger.info "Running chef recipes..."
+          SSH.execute do |ssh|
+            ssh.exec!("cd #{Tenderloin.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
+              # TODO: Very verbose. It would be easier to save the data and only show it during
+              # an error, or when verbosity level is set high
+              logger.info("#{stream}: #{data}")
+            end
+          end
+        end
+
+        def cookbooks_path
+          File.join(Tenderloin.config.chef.provisioning_path, "cookbooks")
+        end
+
+        def collect_shared_folders
+          ["tenderloin-provisioning", File.expand_path(Tenderloin.config.chef.cookbooks_path, Env.root_path), cookbooks_path]
+        end
+      end
+    end
+  end
+end

data/lib/tenderloin/actions/vm/reload.rb

@@ -0,0 +1,17 @@
+module Tenderloin
+  module Actions
+    module VM
+      class Reload < Base
+        def prepare
+          steps = [SharedFolders, Boot]
+          steps.unshift(Halt) if @runner.vm.running?
+          steps << Provision if Tenderloin.config.chef.enabled
+
+          steps.each do |action_klass|
+            @runner.add_action(action_klass)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tenderloin/actions/vm/shared_folders.rb

@@ -0,0 +1,47 @@
+module Tenderloin
+  module Actions
+    module VM
+      class SharedFolders < Base
+        def shared_folders
+          shared_folders = @runner.invoke_callback(:collect_shared_folders)
+
+          # Basic filtering of shared folders. Basically only verifies that
+          # the result is an array of 3 elements. In the future this should
+          # also verify that the host path exists, the name is valid,
+          # and that the guest path is valid.
+          shared_folders.collect do |folder|
+            if folder.is_a?(Array) && folder.length == 3
+              folder
+            else
+              nil
+            end
+          end.compact
+        end
+
+        def before_boot
+
+        end
+
+        def after_boot
+          logger.info "Creating shared folders metadata..."
+
+          shared_folders.each do |name, hostpath, guestpath|
+            @runner.fusion_vm.share_folder(name, hostpath)
+            @runner.fusion_vm.enable_shared_folders
+          end
+
+          logger.info "Linking shared folders..."
+
+          Tenderloin::SSH.execute(@runner.fusion_vm.ip) do |ssh|
+            shared_folders.each do |name, hostpath, guestpath|
+              logger.info "-- #{name}: #{guestpath}"
+              ssh.exec!("sudo ln -s /mnt/hgfs/#{name} #{guestpath}")
+              ssh.exec!("sudo chown #{Tenderloin.config.ssh.username} #{guestpath}")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/tenderloin/actions/vm/start.rb

@@ -0,0 +1,17 @@
+module Tenderloin
+  module Actions
+    module VM
+      class Start < Base
+        def prepare
+          # Start is a "meta-action" so it really just queues up a bunch
+          # of other actions in its place:
+          steps = [SharedFolders, Boot]
+
+          steps.each do |action_klass|
+            @runner.add_action(action_klass)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tenderloin/actions/vm/up.rb

@@ -0,0 +1,55 @@
+module Tenderloin
+  module Actions
+    module VM
+      class Up < Base
+        def prepare
+          # If the dotfile is not a file, raise error
+          if File.exist?(Env.dotfile_path) && !File.file?(Env.dotfile_path)
+            raise ActionException.new(<<-msg)
+The dotfile which Tenderloin uses to store the UUID of the project's
+virtual machine already exists and is not a file! The dotfile is
+currently configured to be `#{Env.dotfile_path}`
+
+To change this value, please see `config.tenderloin.dotfile_name`
+msg
+          end
+
+          # Up is a "meta-action" so it really just queues up a bunch
+          # of other actions in its place:
+          steps = [Import, SharedFolders, Boot]
+          steps << Provision if Tenderloin.config.chef.enabled
+          steps.insert(0, MoveHardDrive) if Tenderloin.config.vm.hd_location
+
+          steps.each do |action_klass|
+            @runner.add_action(action_klass)
+          end
+        end
+
+        def after_import
+          persist
+          setup_uuid_mac
+        end
+
+        def persist
+          logger.info "Persisting the VM UUID (#{@runner.vm_id})..."
+          Env.persist_vm(@runner.vm_id)
+        end
+
+        def setup_uuid_mac
+          logger.info "Resetting VMX UUID, MAC and Display Name..."
+
+          VMXFile.with_vmx_data(@runner.vmx_path) do |data|
+            data.delete "ethernet0.addressType"
+            data.delete "uuid.location"
+            data.delete "uuid.bios"
+            data.delete "ethernet0.generatedAddress"
+            data.delete "ethernet1.generatedAddress"
+            data.delete "ethernet0.generatedAddressOffset"
+            data.delete "ethernet1.generatedAddressOffset"
+            data['displayName'] = "tenderloin-" + @runner.vm_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tenderloin/box.rb

@@ -0,0 +1,143 @@
+module Tenderloin
+  # Represents a "box," which is simply a packaged tenderloin environment.
+  # Boxes are simply `tar` files which contain an exported VirtualBox
+  # virtual machine, at the least. They are created with `tenderloin package`
+  # and may contain additional files if specified by the creator. This
+  # class serves to help manage these boxes, although most of the logic
+  # is kicked out to actions.
+  #
+  # What can the {Box} class do?
+  #
+  # * Find boxes
+  # * Add existing boxes (from some URI)
+  # * Delete existing boxes
+  #
+  # # Finding Boxes
+  #
+  # Using the {Box.find} method, you can search for existing boxes. This
+  # method will return `nil` if none is found or an instance of {Box}
+  # otherwise.
+  #
+  #     box = Tenderloin::Box.find("base")
+  #     if box.nil?
+  #       puts "Box not found!"
+  #     else
+  #       puts "Box exists at #{box.directory}"
+  #     end
+  #
+  # # Adding a Box
+  #
+  # Boxes can be added from any URI. Some schemas aren't supported; if this
+  # is the case, the error will output to the logger.
+  #
+  #     Tenderloin::Box.add("foo", "http://myfiles.com/foo.box")
+  #
+  # # Destroying a box
+  #
+  # Boxes can be deleted as well. This method is _final_ and there is no way
+  # to undo this action once it is completed.
+  #
+  #     box = Tenderloin::Box.find("foo")
+  #     box.destroy
+  #
+  class Box < Actions::Runner
+    # The name of the box.
+    attr_accessor :name
+
+    # The URI for a new box. This is not available for existing boxes.
+    attr_accessor :uri
+
+    # The temporary path to the downloaded or copied box. This should
+    # only be used internally.
+    attr_accessor :temp_path
+
+    class <<self
+      # Returns an array of all created boxes, as strings.
+      #
+      # @return [Array<String>]
+      def all
+        results = []
+
+        Dir.open(Env.boxes_path) do |dir|
+          dir.each do |d|
+            next if d == "." || d == ".." || !File.directory?(File.join(Env.boxes_path, d))
+            results << d.to_s
+          end
+        end
+
+        results
+      end
+
+      # Finds a box with the given name. This method searches for a box
+      # with the given name, returning `nil` if none is found or returning
+      # a {Box} instance otherwise.
+      #
+      # @param [String] name The name of the box
+      # @return [Box] Instance of {Box} representing the box found
+      def find(name)
+        return nil unless File.directory?(directory(name))
+        new(name)
+      end
+
+      # Adds a new box with given name from the given URI. This method
+      # begins the process of adding a box from a given URI by setting up
+      # the {Box} instance and calling {#add}.
+      #
+      # @param [String] name The name of the box
+      # @param [String] uri URI to the box file
+      def add(name, uri)
+        box = new
+        box.name = name
+        box.uri = uri
+        box.add
+      end
+
+      # Returns the directory to a box of the given name. The name given
+      # as a parameter is not checked for existence; this method simply
+      # returns the directory which would be used if the box did exist.
+      #
+      # @param [String] name Name of the box whose directory you're interested in.
+      # @return [String] Full path to the box directory.
+      def directory(name)
+        File.join(Env.boxes_path, name)
+      end
+    end
+
+    # Creates a new box instance. Given an optional `name` parameter,
+    # newly created instance will have that name, otherwise it defaults
+    # to `nil`.
+    #
+    # **Note:** This method does not actually _create_ the box, but merely
+    # returns a new, abstract representation of it. To add a box, see {#add}.
+    def initialize(name=nil)
+      @name = name
+    end
+
+    # Returns path to the vmx file of the box. This contains the config
+    #
+    # @return [String]
+    def vmx_file
+      File.join(directory, Tenderloin.config.vm.box_vmx)
+    end
+
+    # Begins the process of adding a box to the tenderloin installation. This
+    # method requires that `name` and `uri` be set. The logic of this method
+    # is kicked out to the {Actions::Box::Add add box} action.
+    def add
+      execute!(Actions::Box::Add)
+    end
+
+    # Beings the process of destroying this box.
+    def destroy
+      execute!(Actions::Box::Destroy)
+    end
+
+    # Returns the directory to the location of this boxes content in the local
+    # filesystem.
+    #
+    # @return [String]
+    def directory
+      self.class.directory(self.name)
+    end
+  end
+end

data/lib/tenderloin/busy.rb

@@ -0,0 +1,73 @@
+module Tenderloin
+  def self.busy?
+    Busy.busy?
+  end
+
+  def self.busy(&block)
+    Busy.busy(&block)
+  end
+
+  class Busy
+    extend Tenderloin::Util
+
+    @@busy = false
+    @@mutex = Mutex.new
+    @@trap_thread = nil
+
+    class << self
+      def busy?
+        @@busy
+      end
+
+      def busy=(val)
+        @@busy = val
+      end
+
+      def busy(&block)
+        @@mutex.synchronize do
+          begin
+            Signal.trap("INT") { wait_for_not_busy }
+            Busy.busy = true
+            runner = Thread.new(block) { block.call }
+            runner.join
+          ensure
+            # In the case an exception is thrown, make sure we restore
+            # busy back to some sane state.
+            Busy.busy = false
+
+            # Make sure that the trap thread completes, if it is running
+            trap_thread.join if trap_thread
+
+            # And restore the INT trap to the default
+            Signal.trap("INT", "DEFAULT")
+          end
+        end
+      end
+
+      def wait_for_not_busy(sleeptime=5)
+        @@trap_thread ||= Thread.new do
+          # Wait while the app is busy
+          loop do
+            break unless busy?
+            logger.info "Waiting for tenderloin to clean itself up..."
+            sleep sleeptime
+          end
+
+          # Exit out of the entire script
+          logger.info "Exiting tenderloin..."
+          exit
+        end
+      end
+
+      # Used for testing
+      def reset_trap_thread!
+        @@trap_thread = nil
+      end
+
+      # Returns the trap thread
+      def trap_thread
+        @@trap_thread
+      end
+    end
+  end
+end

data/lib/tenderloin/cli.rb

@@ -0,0 +1,59 @@
+require 'thor'
+require 'tenderloin'
+
+module Tenderloin
+
+  class CLI < Thor
+    class_option :file, :aliases => :'-f', :default => "Tenderfile"
+
+    no_tasks do
+      def setup
+        $ROOTFILE_NAME = options[:file].dup.freeze
+      end
+    end
+
+    desc "up [--file <tenderfile>]", "Boots the VM"
+    def up()
+      setup
+      Tenderloin::Commands.up
+    end
+
+    desc "halt [--file <tenderfile>]", "Force shuts down the running VM"
+    def halt()
+      setup
+      Tenderloin::Commands.halt
+    end
+
+    desc "destroy [--file <tenderfile>]", "Shuts down and deletes the VM"
+    def destroy()
+      setup
+      Tenderloin::Commands.destroy
+    end
+
+    desc "box [--file <tenderfile>]", "Manages base boxes"
+    # TODO - make the box command use real args/a subcommand
+    def box(arg1=nil, arg2=nil, arg3=nil, arg4=nil)
+      setup
+      Tenderloin::Commands.box([arg1, arg2, arg3, arg4].compact)
+    end
+
+    desc "init [--file <tenderfile>]", "Creates a new Tenderfile"
+    def init()
+      setup
+      Tenderloin::Commands.init
+    end
+
+    desc "reload [--file <tenderfile>]", "Reboots & re-provisions the VM"
+    def reload()
+      setup
+      Tenderloin::Commands.reload
+    end
+
+    desc "ssh [--file <tenderfile>]", "SSH's in to the VM"
+    def ssh()
+      setup
+      Tenderloin::Commands.ssh
+    end
+
+  end
+end

data/lib/tenderloin/commands.rb

@@ -0,0 +1,154 @@
+module Tenderloin
+  # Contains all the command-line commands invoked by the
+  # binaries. Having them all in one location assists with
+  # documentation and also takes the commands out of some of
+  # the other classes.
+  class Commands
+    extend Tenderloin::Util
+
+    class << self
+      # Initializes a directory for use with tenderloin. This command copies an
+      # initial `Tenderfile` into the current working directory so you can
+      # begin using tenderloin. The configuration file contains some documentation
+      # to get you started.
+      def init
+        rootfile_path = File.join(Dir.pwd, $ROOTFILE_NAME)
+        if File.exist?(rootfile_path)
+          error_and_exit(<<-error)
+It looks like this directory is already setup for tenderloin! (A #{$ROOTFILE_NAME}
+already exists.)
+error
+        end
+
+        # Copy over the rootfile template into this directory
+        FileUtils.cp(File.join(PROJECT_ROOT, "templates", $ROOTFILE_NAME), rootfile_path)
+      end
+
+      # Bring up a tenderloin instance. This handles everything from importing
+      # the base VM, setting up shared folders, forwarded ports, etc to
+      # provisioning the instance with chef. {up} also starts the instance,
+      # running it in the background.
+      def up
+        Env.load!
+
+        if Env.persisted_vm
+          logger.info "VM already created. Starting VM if its not already running..."
+          Env.persisted_vm.start
+        else
+          Env.require_box
+          VM.execute!(Actions::VM::Up)
+        end
+      end
+
+      # Tear down a tenderloin instance. This not only shuts down the instance
+      # (if its running), but also deletes it from the system, including the
+      # hard disks associated with it.
+      #
+      # This command requires that an instance already be brought up with
+      # `tenderloin up`.
+      def destroy
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.destroy
+      end
+
+      # Reload the environment. This is almost equivalent to the {up} command
+      # except that it doesn't import the VM and do the initialize bootstrapping
+      # of the instance. Instead, it forces a shutdown (if its running) of the
+      # VM, updates the metadata (shared folders, forwarded ports), restarts
+      # the VM, and then reruns the provisioning if enabled.
+      def reload
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.execute!(Actions::VM::Reload)
+      end
+
+      # SSH into the tenderloin instance. This will setup an SSH connection into
+      # the tenderloin instance, replacing the running ruby process with the SSH
+      # connection.
+      #
+      # This command requires that an instance already be brought up with
+      # `tenderloin up`.
+      def ssh
+        Env.load!
+        Env.require_persisted_vm
+        SSH.connect :host => Env.persisted_vm.fusion_vm.ip
+      end
+
+      # Halts a running tenderloin instance. This forcibly halts the instance;
+      # it is the equivalent of pulling the power on a machine. The instance
+      # can be restarted again with {up}.
+      #
+      # This command requires than an instance already be brought up with
+      # `tenderloin up`.
+      def halt
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.execute!(Actions::VM::Halt)
+      end
+
+      # Manages the `tenderloin box` command, allowing the user to add
+      # and remove boxes. This single command, given an array, determines
+      # which action to take and calls the respective action method
+      # (see {box_add} and {box_remove})
+      def box(argv)
+        Env.load!
+
+        sub_commands = ["list", "add", "remove"]
+
+        if !sub_commands.include?(argv[0])
+          error_and_exit(<<-error)
+Please specify a valid action to take on the boxes, either
+`add` or `remove`. Examples:
+
+tenderloin box add name uri
+tenderloin box remove name
+error
+        end
+
+        send("box_#{argv[0]}", *argv[1..-1])
+      end
+
+      # Lists all added boxes
+      def box_list
+        boxes = Box.all.sort
+
+        wrap_output do
+          if !boxes.empty?
+            puts "Installed Tenderloin Boxes:\n\n"
+            boxes.each do |box|
+              puts box
+            end
+          else
+            puts "No Tenderloin Boxes Added!"
+          end
+        end
+      end
+
+      # Adds a box to the local filesystem, given a URI.
+      def box_add(name, path)
+        Box.add(name, path)
+      end
+
+      # Removes a box.
+      def box_remove(name)
+        box = Box.find(name)
+        if box.nil?
+          error_and_exit(<<-error)
+The box you're attempting to remove does not exist!
+error
+          return # for tests
+        end
+
+        box.destroy
+      end
+
+      private
+
+      def act_on_vm(&block)
+        yield Env.persisted_vm
+        Env.persisted_vm.execute!
+      end
+    end
+  end
+end