puter 0.0.1

data/lib/puter/cli/vm.rb

@@ -0,0 +1,167 @@
+require 'puter/providers/vm'
+require 'puter/backend/ssh'
+
+module Puter
+  module CLI
+    class Vm < Thor
+      images_option =    [:images,    {:type => :string, :default => '/Puter/Images',    :banner => '/path/to/Puter/Images',    :desc => 'Override the default Images vSphere folder.'    }]
+      instances_option = [:instances, {:type => :string, :default => '/Puter/Instances', :banner => '/path/to/Puter/Instances', :desc => 'Override the default Instances vSphere folder.' }]
+      build_option =     [:build,     {:type => :string, :default => '/Puter/Build',     :banner => '/path/to/Puter/Build',     :desc => 'Override the default Build vSphere folder.'     }]
+
+      desc 'images', 'Lists available Puter images.'
+      method_option *images_option
+      def images()
+        CLI.run_cli do
+          vm.images(options[:images]).each { |i| Puter.ui.info i }
+        end
+      end
+
+      desc "apply INSTANCE CONTEXT", "Applies Puterfile to an existing & running VM"
+      method_option *instances_option
+      def apply(instance_name, context)
+        CLI.run_cli do
+          instance_path = "#{options[:instances]}/#{instance_name}"
+          puterfile_path = File.expand_path 'Puterfile', context
+          puterfile = Puter::Puterfile.from_path puterfile_path
+
+          vm.host(instance_path) do |host|
+            Puter.ui.info "Applying '#{puterfile_path}' to '#{instance_path}' at #{host}"
+            backend = Puter::Backend::Ssh.new(host, Puter::CLI::SSH_OPTS)
+            ret = puterfile.apply(context, backend, Puter.ui)
+          end
+          Puter.ui.info "Successfully applied '#{puterfile_path}' to '#{instance_name}'"
+        end
+      end
+
+      desc "build IMAGE CONTEXT", "Builds a new Puter image"
+      method_option *images_option
+      method_option *build_option
+      option :force,  :type => :boolean,  :default => false, :description => "Replaces Image specified by NAME if it exists"
+      def build(image_name, context)
+        CLI.run_cli do
+          build_path = "#{options[:build]}/#{image_name}"
+          images_path = "#{options[:images]}/#{image_name}"
+
+          puterfile_path = File.expand_path 'Puterfile', context
+          puterfile = Puter::Puterfile.from_path puterfile_path
+
+          Puter.ui.info "Building '#{images_path}' FROM '#{options[:images]}/#{puterfile.from}'"
+          Puter.ui.info "Waiting for SSH"
+          vm.build(build_path, images_path, "#{options[:images]}/#{puterfile.from}", options) do |host|
+            Puter.ui.info "Applying '#{puterfile_path}' to '#{build_path}' at #{host}"
+            backend = Puter::Backend::Ssh.new(host, Puter::CLI::SSH_OPTS)
+            ret = puterfile.apply(context, backend, Puter.ui)
+            Puter.ui.info "Stopping '#{build_path}' and moving to '#{images_path}'"
+          end
+          Puter.ui.info "Successfully built '#{image_name}'"
+        end
+      end
+
+      desc "rmi IMAGE", "Removes (deletes) a Puter image"
+      method_option *images_option
+      def rmi(image_name)
+        image_path = "#{options[:images]}/#{image_name}"
+        CLI.run_cli do
+          vm.rmi image_path
+          Puter.ui.info "Removed image '#{image_path}'"
+        end
+      end
+
+      desc "create IMAGE INSTANCE", "Creates (clones) a Puter instance from IMAGE as NAME"
+      method_option *images_option
+      method_option *instances_option
+      option :force,  :type => :boolean,  :default => false, :description => "Replaces Instance specified by NAME if it exists"
+      def create(image_name, instance_name)
+        CLI.run_cli do
+          image_path = "#{options[:images]}/#{image_name}"
+          instance_path = "#{options[:instances]}/#{instance_name}"
+
+          vm.create image_path, instance_path, options
+          Puter.ui.info "Created instance '#{instance_path}' from '#{image_path}'"
+        end
+      end
+
+      desc "ps", "Lists Puter instances"
+      method_option *instances_option
+      option :all, :type => :boolean, :default => false, :description => 'Includes non-running instances.'
+      def ps()
+        CLI.run_cli do
+          vm.ps(options[:instances], options[:all]).each { |i| Puter.ui.info i }
+        end
+      end
+
+      desc "start INSTANCE", "Starts a Puter instance"
+      method_option *instances_option
+      def start(instance_name)
+        CLI.run_cli do
+          instance_path = "#{options[:instances]}/#{instance_name}"
+
+          Puter.ui.info "Starting instance '#{instance_path}', waiting for SSH..."
+          vm.start instance_path do |host|
+            Puter.ui.info "Started '#{instance_path}' at #{host}."
+          end
+        end
+      end
+
+      desc "stop INSTANCE", "Stops a Puter instance"
+      method_option *instances_option
+      def stop(instance_name)
+        CLI.run_cli do
+          instance_path = "#{options[:instances]}/#{instance_name}"
+
+          Puter.ui.info "Stopping instance '#{instance_path}', waiting for shutdown..."
+          vm.stop instance_path
+          Puter.ui.info "Stopped '#{instance_path}'."
+        end
+      end
+
+      desc "kill INSTANCE", "Kills a Puter instance"
+      method_option *instances_option
+      def kill(instance_name)
+        CLI.run_cli do
+          instance_path = "#{options[:instances]}/#{instance_name}"
+
+          Puter.ui.info "Killing instance '#{instance_path}'"
+          vm.kill instance_path
+          Puter.ui.info "Killed '#{instance_path}'."
+        end
+      end
+
+      desc "rm INSTANCE", "Removes (deletes) a Puter instance"
+      method_option *instances_option
+      def rm(instance_name)
+        CLI.run_cli do
+          instance_path = "#{options[:instances]}/#{instance_name}"
+          vm.rm instance_path
+          Puter.ui.info "Removed instance '#{instance_path}'"
+        end
+      end
+
+      desc "init PATH", "Initializes Puter VM folders in VMware"
+      long_desc <<-LONGDESC
+        Initializes Puter VM folders in VMware.
+
+        Creates the following folder hierarchy:
+
+        PATH/        - default: /Puter
+          Build/     - working folder for building Puter images
+          Images/    - Puter images (VM Templates)
+          Instances/ - Putere instances (VMs)
+
+        PATH must be the full vSphere folder path name, e.g. '/Puter'.
+      LONGDESC
+      def init(path = '/Puter')
+        CLI.run_cli do
+          vm.init(path)
+          Puter.ui.info "Create Puter folders under #{path}"
+        end
+      end
+
+      private
+
+      def vm
+        @vm ||= Puter::Provider::Vm.new
+      end
+    end
+  end
+end

data/lib/puter/providers/vm.rb

@@ -0,0 +1,107 @@
+require 'vmonkey'
+require 'puter/puterfile'
+
+module Puter
+  module Provider
+    class Vm
+
+      def images(path, sub="")
+        folder = vmonkey.folder!(path)
+        imgs = folder.templates.collect { |t| "#{sub}#{t.name}" }
+        folder.folders.each do |sub_folder|
+          imgs += images("#{path}/#{sub_folder.name}", "#{sub}#{sub_folder.name}/")
+        end
+        imgs
+      end
+
+      def host(name, &block)
+        target = vmonkey.vm! name
+        block.call(target.guest_ip)
+      end
+
+      def build(build_path, image_path, template_name, opts, &block)
+        vmonkey.folder('/').mk_parent_folder build_path
+
+        template = vmonkey.vm! template_name
+        if opts[:force]
+          build = template.clone_to! build_path
+        else
+          build = template.clone_to build_path
+        end
+
+        build.start
+        build.wait_for_port 22
+        block.call(build.guest_ip) if block
+        build.stop
+        build.MarkAsTemplate()
+
+        vmonkey.folder('/').mk_parent_folder image_path
+
+        if opts[:force]
+          build.move_to! image_path
+        else
+          build.move_to image_path
+        end
+      end
+
+      def rmi(path)
+        vmonkey.template!(path).destroy
+      end
+
+      def create(image_path, instance_path, opts)
+        vmonkey.folder('/').mk_parent_folder instance_path
+
+        if opts[:force]
+          vmonkey.vm!(image_path).clone_to! instance_path
+        else
+          vmonkey.vm!(image_path).clone_to instance_path
+        end
+      end
+
+      def start(instance_name, &block)
+        instance = vmonkey.vm! instance_name
+        instance.start
+        instance.wait_for_port 22
+        block.call(instance.guest_ip) if block
+      end
+
+      def stop(instance_name)
+        instance = vmonkey.vm! instance_name
+        instance.stop
+      end
+
+      def kill(instance_name)
+        instance = vmonkey.vm! instance_name
+        instance.kill
+      end
+
+      def ps(instances_path, all, sub="")
+        folder = vmonkey.folder! instances_path
+        instances = folder.vms
+        instances.select! { |vm| vm.runtime.powerState == 'poweredOn' } unless all
+
+        ret = instances.collect { |i| "#{sub}#{i.name}" }
+        folder.folders.each do |sub_folder|
+          ret += ps("#{instances_path}/#{sub_folder.name}", all, "#{sub}#{sub_folder.name}/")
+        end
+        ret
+      end
+
+      def rm(path)
+        vmonkey.vm!(path).destroy
+      end
+
+      def init(path)
+        root = vmonkey.folder '/'
+        root.mk_folder "#{path}/Build"
+        root.mk_folder "#{path}/Images"
+        root.mk_folder "#{path}/Instances"
+      end
+
+      def vmonkey
+        @vmonkey ||= VMonkey.connect
+      end
+
+    end
+  end
+end

data/lib/puter/puterfile.rb

@@ -0,0 +1,198 @@
+module Puter
+  class SyntaxError < Exception
+  end
+
+  class RunError < Exception
+    {:cmd=>"sudo -u root -s -- sh -c 'exit 3'", :stdout=>"", :stderr=>"", :exit_status=>3, :exit_signal=>nil}
+
+    attr_accessor :result
+    attr_accessor :cmd
+    attr_accessor :exit_status
+    attr_accessor :exit_signal
+
+    def initialize(message, result)
+      super(message)
+      @result = result
+      @cmd = result[:cmd]
+      @exit_status = result[:exit_status]
+      @exit_signal = result[:exit_signal]
+    end
+  end
+
+  class Puterfile
+
+    attr_accessor :raw
+    attr_accessor :lines
+    attr_accessor :from
+    attr_accessor :operations
+    attr_accessor :executable_ops
+
+    BACKSLASH = "\\"
+
+    FROM     = :from
+    RUN      = :run
+    COPY     = :copy
+    BLANK    = :blank
+    CONTINUE = :continue
+    COMMENT  = :comment
+
+    COMMANDS = [ FROM, RUN, COPY ]
+
+    class << self
+      def from_path(path)
+        parse File.open(path, 'rb') { |f| f.read }
+      end
+
+      def parse(raw)
+        p = Puterfile.new
+        p.raw = raw
+        p.lines = raw.to_s.split "\n"
+        p.operations = parse_operations(p.lines)
+        p.executable_ops = executable_operations(p.operations)
+        p.from = p.operations[0][:data]
+        p
+      end
+
+      def parse_operations(lines)
+        raise Puter::SyntaxError.new "File is empty.  First line must be a FROM command" if lines.length == 0
+
+        ops = []
+        previous_line = ""
+        lines.each_with_index do | line, i |
+          begin
+            ops << parse_operation(line, previous_line)
+            if i == 0
+              raise Puter::SyntaxError.new "First line must be a FROM command" unless ops[i][:operation] == FROM
+            end
+          rescue Puter::SyntaxError => se
+            raise Puter::SyntaxError.new "On line #{i+1}: #{se.message}"
+          end
+          previous_line = line
+        end
+        ops
+      end
+
+      def parse_operation(line, previous_line="")
+        op = {}
+        line = line.rstrip unless line.nil?
+
+        case
+        when line.nil?
+          raise SyntaxError.new 'cannot parse nil lines'
+
+        # blank line
+        when line.strip.empty?
+          op[:operation] = BLANK
+          op[:data]      = line
+          op[:continue]  = false
+
+        # commented line
+        when line =~ /\s*\#/
+          op[:operation] = COMMENT
+          op[:data]      = line
+          op[:continue]  = line[-1] == BACKSLASH
+
+        # continuation of a previous line
+        when line =~ /\s/ && previous_line.rstrip[-1] == BACKSLASH
+          op[:operation] = CONTINUE
+          op[:data]      = line.lstrip
+          op[:continue]  = line[-1] == BACKSLASH
+
+        # must be an operation (FROM, COPY, RUN, ...)
+        else
+          parts = line.split(/\s+/, 2)
+          cmd = parts[0].downcase.to_sym
+          data = parts[1]
+
+          raise SyntaxError.new "Unknown operation [#{cmd.to_s.upcase}]" unless COMMANDS.include? cmd
+          raise SyntaxError.new "Operation [#{cmd.to_s.upcase}] has no data" if data.nil?
+          op[:operation] = cmd
+          op[:data]      = data
+          op[:continue]  = line[-1] == BACKSLASH
+
+        end
+        op[:data][-1] = " " if op[:continue]
+
+        op
+      end
+
+      def executable_operations(operations)
+        execs = []
+        operations.each_with_index do |op, i|
+          case op[:operation]
+          when COPY, RUN, FROM
+            exec = {
+              :operation => op[:operation],
+              :data      => op[:data].dup
+            }
+            exec[:start_line] = exec[:end_line] = i
+            execs << exec
+          when CONTINUE
+            execs.last[:data] << op[:data]
+            execs.last[:end_line] = i
+          end
+        end
+
+        execs.select { |e| e[:operation] == COPY }.each do |e|
+          e[:from], e[:to] = e[:data].strip.split /\s+/, 2
+          raise SyntaxError.new "COPY operation requires two parameters #{e.inspect}" if e[:from].nil? || e[:to].nil?
+        end
+
+        execs
+      end
+
+    end
+
+    def apply(context, backend, ui)
+      dependency_check(context)
+      ret = { :exit_status => 0, :exit_signal => nil }
+
+      executable_ops.each_with_index do |op, step|
+        ui.info "Step #{step} : #{op[:operation].to_s.upcase} #{op[:data]}"
+
+        case op[:operation]
+        when COPY
+          backend.copy path_in_context(op[:from], context), op[:to]
+        when RUN
+          ret = backend.run op[:data] do | type, data |
+            case type
+            when :stderr
+              ui.remote_stderr data
+            when :stdout
+              ui.remote_stdout data
+            end
+          end
+
+          if ret[:exit_status] != 0
+            line = "#{op[:start_line]+1}"
+            plural = ""
+            if op[:start_line] != op[:end_line]
+              line << "..#{op[:end_line]+1}"
+              plural = "s"
+            end
+
+            raise RunError.new "On line#{plural} #{line}: RUN command exited non-zero.", ret
+          end
+        end
+      end
+
+      ret
+    end
+
+    private
+    def path_in_context(path, context)
+      File.expand_path(path, context)
+    end
+
+    def dependency_check(context)
+      executable_ops.each do |op|
+        case op[:operation]
+        when COPY
+          File.open(path_in_context(op[:from], context), 'r') {}
+        end
+      end
+    end
+
+  end
+
+end