veewee-atlassian 0.3.11

data/lib/python/parallels_sdk_check.py

@@ -0,0 +1,19 @@
+import sys
+import prlsdkapi
+
+prlsdk = prlsdkapi.prlsdk
+consts = prlsdkapi.prlsdk.consts
+
+# Initialize the Parallels API Library
+prlsdk.InitializeSDK(consts.PAM_DESKTOP_MAC)
+
+# Obtain a server object identifying the Parallels Service.
+server = prlsdkapi.Server()
+
+# Log in. (local as we do Parallels Desktop
+login_job=server.login_local()
+login_job.wait()
+
+# Logoff and deinitialize the library
+server.logoff()
+prlsdkapi.deinit_sdk

data/lib/python/parallels_send_key.py

@@ -0,0 +1,73 @@
+import sys
+import prlsdkapi
+
+if len(sys.argv) != 4:
+    print "Usage: parallels_send_keycode '<VM_NAME>' '<keyname>' '<press|release>'"
+    exit()
+
+# Parse arguments
+vm_name=sys.argv[1]
+# Keycode to use
+keyname=sys.argv[2]
+# Release or press
+state=sys.argv[3]
+
+print "Sending keyname '%(keyname)s' to VM '%(vm_name)s'" % {"keyname": keyname, "vm_name":vm_name}
+
+prlsdk = prlsdkapi.prlsdk
+consts = prlsdkapi.prlsdk.consts
+
+# Initialize the Parallels API Library
+prlsdk.InitializeSDK(consts.PAM_DESKTOP_MAC)
+
+# Obtain a server object identifying the Parallels Service.
+server = prlsdkapi.Server()
+
+# Log in. (local as we do Parallels Desktop
+login_job=server.login_local()
+login_job.wait()
+
+# Get a list of virtual machines.
+# Find the specified virtual machine and
+# obtain an object identifying it.
+vm_list = server.get_vm_list()
+result= vm_list.wait()
+
+print prlsdkapi.prlsdk.consts.ScanCodesList
+
+# Look for the VM with the name speficied on the CLI
+found = False
+for i in range(result.get_params_count()):
+  VM = result.get_param_by_index(i)
+  print VM.get_name()
+  if VM.get_name() == vm_name:
+    found = True
+    break
+
+press = consts.PKE_PRESS
+release = consts.PKE_RELEASE
+
+# Access the Remote Desktop Access session
+vm_io = prlsdkapi.VmIO()
+try:
+  vm_io.connect_to_vm(VM).wait()
+except prlsdkapi.PrlSDKError, e:
+  print "Error: %s" % e
+  exit()
+
+scan_code = consts.ScanCodesList[keyname]
+
+if state == 'press':
+  vm_io.send_key_event(VM,scan_code,press)
+elif  state == 'release':
+  vm_io.send_key_event(VM,scan_code,release)
+else:
+  print "invalid state: %s" % state
+  exit()
+
+# End the Remote Deskop Access session
+vm_io.disconnect_from_vm(VM)
+
+# Logoff and deinitialize the library
+server.logoff()
+prlsdkapi.deinit_sdk

data/lib/python/parallels_send_string.py

@@ -0,0 +1,76 @@
+import sys
+import prlsdkapi
+import string
+
+if len(sys.argv) != 3:
+    print "Usage: parallels_send_string '<VM_NAME>' '<string>'"
+    exit()
+
+# Parse arguments
+vm_name=sys.argv[1]
+# String to use
+keynames = sys.argv[2].split(' ');
+
+prlsdk = prlsdkapi.prlsdk
+consts = prlsdkapi.prlsdk.consts
+
+# Initialize the Parallels API Library
+prlsdk.InitializeSDK(consts.PAM_DESKTOP_MAC)
+
+# Obtain a server object identifying the Parallels Service.
+server = prlsdkapi.Server()
+
+# Log in. (local as we do Parallels Desktop
+login_job=server.login_local()
+login_job.wait()
+
+# Get a list of virtual machines.
+# Find the specified virtual machine and
+# obtain an object identifying it.
+vm_list = server.get_vm_list()
+result= vm_list.wait()
+
+print prlsdkapi.prlsdk.consts.ScanCodesList
+
+# Look for the VM with the name speficied on the CLI
+found = False
+for i in range(result.get_params_count()):
+  VM = result.get_param_by_index(i)
+  print VM.get_name()
+  if VM.get_name() == vm_name:
+    found = True
+    break
+
+press = consts.PKE_PRESS
+release = consts.PKE_RELEASE
+
+# Access the Remote Desktop Access session
+vm_io = prlsdkapi.VmIO()
+try:
+  vm_io.connect_to_vm(VM).wait()
+except prlsdkapi.PrlSDKError, e:
+  print "Error: %s" % e
+  exit()
+
+for keyname in keynames:
+    if(keyname != ''): 
+	# Keys can also contain special keys like shift, that has to be pressed before and release after
+	# eg. SHIFT-C (Press shift, then press C)
+	keys = keyname.split('#');
+
+	for keypress in keys: 
+    		scan_code = consts.ScanCodesList[keypress]
+    		vm_io.send_key_event(VM,scan_code,press,50)
+
+	# And now the reversed order
+	# eg. Now release C then SHIFT
+	for keypress in reversed(keys):
+    		scan_code = consts.ScanCodesList[keypress]
+    		vm_io.send_key_event(VM,scan_code,release,50)
+
+# End the Remote Deskop Access session
+vm_io.disconnect_from_vm(VM)
+
+# Logoff and deinitialize the library
+server.logoff()
+prlsdkapi.deinit_sdk

data/lib/vagrant_init.rb

@@ -0,0 +1,8 @@
+begin
+  require 'vagrant'
+  require 'veewee/command/vagrant'
+rescue LoadError
+  require 'rubygems'
+  require 'veewee/command/vagrant'
+  require 'veewee/command/kvm'
+end

data/lib/veewee.rb

@@ -0,0 +1,23 @@
+require 'json'
+require 'i18n'
+require 'yaml'
+require 'pathname'
+
+module Veewee
+  # The source root is the path to the root directory of
+  # the Veewee gem.
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+  end
+end
+
+# # Default I18n to load the en locale
+I18n.load_path << File.expand_path("lib/veewee/templates/locales/en.yml", Veewee.source_root)
+
+# Load the things which must be loaded before anything else
+require 'veewee/error'
+require 'veewee/cli'
+require 'veewee/ui'
+require 'veewee/command'
+require 'veewee/environment'
+require 'veewee/version'

data/lib/veewee/cli.rb

@@ -0,0 +1,55 @@
+require 'thor'
+
+module Veewee
+  # Entrypoint for the Veewee CLI. This class should never be
+  # initialized directly (like a typical Thor class). Instead,
+  # use {Environment#cli} to invoke the CLI.
+  #
+  # # Defining Custom CLI Commands
+  #
+  # If you're looking to define custom CLI commands, then look at
+  # one of the two following classes:
+  #
+  # * {Command::Base} - Implementing a single command such as `mccloud up`, e.g.
+  #   one without subcommands. Also take a look at {Command::NamedBase}.
+  # * {Command::GroupBase} - Implementing a command with subcommands, such as
+  #   `mccloud box`, which has the `list`, `add`, etc. subcommands.
+  #
+  # The above linked classes contain the main documentation for each
+  # type of command.
+  class CLI < Thor
+    # Registers the given class with the CLI so it can be accessed.
+    # The class must be a subclass of either {Command::Base} or {Command::GroupBase}.
+    # Don't call this method directly, instead call the {Command::Base.register}
+    # or {Command::GroupBase.register} methods.
+    #
+    # @param [Class] klass Command class
+    # @param [String] name Command name, accessed at `mccloud NAME`
+    # @param [String] usage Command usage, such as "mccloud NAME [--option]"
+    # @param [String] description Description of the command shown during the
+    #   command listing.
+    # @param [Hash] opts Other options (not gone into detail here, look at
+    #   the source instead).
+    def self.register(klass, name, usage, description, opts = nil)
+      opts ||= {}
+
+      if klass <= Command::GroupBase
+        # A subclass of GroupBase is a subcommand, since it contains
+        # many smaller commands within it.
+        desc usage, description, opts
+        subcommand name, klass
+      elsif klass <= Command::Base
+        # A subclass of Base is a single command, since it
+        # is invoked as a whole (as Thor::Group)
+        desc usage, description, opts
+        define_method(name) { |*args| invoke klass, args }
+      end
+
+      if opts[:alias]
+        # Alises are defined for this command, so properly alias the
+        # newly defined method/subcommand:
+        map opts[:alias] => name
+      end
+    end
+  end
+end #Veewee

data/lib/veewee/command.rb

@@ -0,0 +1,15 @@
+module Veewee
+  module Command
+    autoload :Base, 'veewee/command/base'
+    autoload :GroupBase, 'veewee/command/group_base'
+    autoload :Helpers, 'veewee/command/helpers'
+    autoload :NamedBase, 'veewee/command/named_base'
+  end
+end
+
+# The built-in commands must always be loaded
+require 'veewee/command/version'
+require 'veewee/command/kvm'
+require 'veewee/command/vbox'
+require 'veewee/command/fusion'
+require 'veewee/command/parallels'

data/lib/veewee/command/base.rb

@@ -0,0 +1,106 @@
+require 'thor/group'
+require 'thor/actions'
+
+module Veewee
+  module Command
+    # A {Base} is the superclass for all commands which are single
+    # commands, e.g. `veewee init`, `veewee up`. Not commands like
+    # `veewee box add`. For commands which have more subcommands, use
+    # a {GroupBase}.
+    #
+    # A {Base} is a subclass of `Thor::Group`, so view the documentation
+    # there on how to add arguments, descriptions etc. The important note
+    # about this is that when invoked, _all public methods_ will be called
+    # in the order they are defined. If you don't want a method called when
+    # the command is invoked, it must be made `protected` or `private`.
+    #
+    # The best way to get examples of how to create your own command is to
+    # view the various Veewee commands, which are relatively simple, and
+    # can be found in the Veewee source tree at `lib/veewee/command/`.
+    #
+    # # Defining a New Command
+    #
+    # To define a new single command, create a new class which inherits
+    # from this class, then call {register} to register the command. That's
+    # it! When the command is invoked, _all public methods_ will be called.
+    # Below is an example `SayHello` class:
+    #
+    #     class SayHello < Veewee::Command::Base
+    #       register "hello", "Says hello"
+    #
+    #       def hello
+    #         env.ui.info "Hello"
+    #       end
+    #     end
+    #
+    # In this case, the above class is invokable via `veewee hello`. To give
+    # this a try, just copy and paste the above into a Veeweefile somewhere.
+    # The command will be available for that project!
+    #
+    # Also note that the above example uses `env.ui` to output. It is recommended
+    # you use this instead of raw "env.ui.info" since it is configurable and provides
+    # additional functionality, such as colors and asking for user input. See
+    # the {UI} class for more information.
+    #
+    # ## Defining Command-line Options
+    #
+    # Most command line actions won't be as simple as `veewee hello`, and will
+    # probably require parameters or switches. Luckily, Thor makes adding these
+    # easy:
+    #
+    #     class SayHello < Veewee::Command::Base
+    #       register "hello", "Says hello"
+    #       argument :name, :type => :string
+    #
+    #       def hello
+    #         env.ui.info "Hello, #{name}"
+    #       end
+    #     end
+    #
+    # Then, the above can be invoked with `veewee hello Mitchell` which would
+    # output "Hello, Mitchell." If instead you're looking for switches, such as
+    # "--name Mitchell", then take a look at `class_option`, an example of which
+    # can be found in the {PackageCommand}.
+    class Base < Thor::Group
+      include Thor::Actions
+      include Helpers
+
+      attr_reader :env
+
+      # Register the command with the main Veewee CLI under the
+      # given name. The name will be used for accessing it from the CLI,
+      # so if you name it "lamp", then the command to invoke this
+      # will be `veewee lamp`.
+      #
+      # The description is used when the help is listed, and is meant to be
+      # a brief (one sentence) description of what the command does.
+      #
+      # Some additional options may be passed in as the last parameter:
+      #
+      # * `:alias` - If given as an array or string, these will be aliases
+      #  for the same command. For example, `veewee version` is also
+      #  `veewee --version` and `veewee -v`
+      #
+      # @param [String] usage
+      # @param [String] description
+      # @param [Hash] opts
+      def self.register(usage, description, opts=nil)
+        desc description
+        ::Veewee::CLI.register(self, extract_name_from_usage(usage), usage, desc, opts)
+      end
+
+      def initialize(*args)
+        super
+        initialize_environment(*args)
+      end
+
+      protected
+
+      # Extracts the name of the command from a usage string. Example:
+      # `init [box_name] [box_url]` becomes just `init`.
+      def self.extract_name_from_usage(usage)
+        /^([-_a-zA-Z0-9]+)(\s+(.+?))?$/.match(usage).to_a[1]
+      end
+    end
+  end
+end

data/lib/veewee/command/fusion.rb

@@ -0,0 +1,170 @@
+
+
+module Veewee
+  module Command
+
+    class Fusion< Veewee::Command::GroupBase
+
+      register "fusion", "Subcommand for Vmware fusion"
+      desc "build [BOX_NAME]", "Build box"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the build"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      method_option :auto,:type => :boolean , :default => false, :aliases => "-a", :desc => "auto answers"
+      method_option :checksum , :type => :boolean , :default => false, :desc => "verify checksum"
+      method_option :postinstall_include, :type => :array, :default => [], :aliases => "-i", :desc => "ruby regexp of postinstall filenames to additionally include"
+      method_option :postinstall_exclude, :type => :array, :default => [], :aliases => "-e", :desc => "ruby regexp of postinstall filenames to exclude"
+      def build(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).build(options)
+      end
+
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the destroy"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "destroy [BOXNAME]", "Destroys the virtualmachine that was built"
+      def destroy(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).destroy(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the shutdown"
+      desc "halt [BOXNAME]", "Activates a shutdown the virtualmachine"
+      def halt(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).halt(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "up [BOXNAME]", "Starts a Box"
+      def up(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).up(options)
+      end
+
+      desc "ssh [BOXNAME] [COMMAND]", "SSH to box"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ssh(box_name,command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).issh(command)
+      end
+
+
+      desc "winrm [BOXNAME] [COMMAND]", "Execute command via winrm"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def winrm(box_name,command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).winrm(command,{:exitcode => "*"})
+      end
+
+      desc "copy [BOXNAME] [SRC] [DST]", "Copy a file to the VM"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def copy(box_name,src,dst)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).copy_to_box(src,dst)
+      end
+
+
+
+      desc "define [BOXNAME] [TEMPLATE]", "Define a new basebox starting from a template"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite the definition"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def define(definition_name, template_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.definitions.define(definition_name,template_name,options)
+        env.ui.info "The basebox '#{definition_name}' has been successfully created from the template '#{template_name}'"
+        env.ui.info "You can now edit the definition files stored in definitions/#{definition_name} or build the box with:"
+        env.ui.info "veewee fusion build '#{definition_name}'"
+      end
+
+      desc "undefine [BOXNAME]", "Removes the definition of a basebox "
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def undefine(definition_name)
+        env.ui.info "Removing definition #{definition_name}" , :prefix => false
+        begin
+          venv=Veewee::Environment.new(options)
+          venv.ui=env.ui
+          venv.definitions.undefine(definition_name,options)
+          env.ui.info "Definition #{definition_name} successfully removed",:prefix => false
+        rescue Error => ex
+          env.ui.error "#{ex}" , :prefix => false
+          exit -1
+        end
+      end
+
+      desc "validate [NAME]", "Validates a box against vmfusion compliancy rules"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :tags, :type => :array , :default => %w{vmfusion puppet chef}, :aliases => "-t", :desc => "tags to validate"
+      def validate(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).validate_vmfusion(options)
+      end
+
+      desc "ostypes", "List the available Operating System types"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ostypes
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.ostypes.each do |name|
+          env.ui.info "- #{name}"
+        end
+      end
+
+      desc "export [NAME]", "Exports the basebox to the ova format"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite existing file"
+      def export(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["vmfusion"].get_box(box_name).export_ova(options)
+      end
+
+
+      desc "templates", "List the currently available templates"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def templates
+        env.ui.info "The following templates are available:",:prefix => false
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.templates.each do |name,template|
+          env.ui.info "veewee fusion define '<box_name>' '#{name}'",:prefix => false
+        end
+      end
+
+      desc "list", "Lists all defined boxes"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def list
+        env.ui.info "The following local definitions are available:",:prefix => false
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.definitions.each do |name,definition|
+          env.ui.info "- #{name}"
+        end
+      end
+
+      desc "add_share [BOX_NAME] [SHARE_NAME] [SHARE_PATH]", "Adds a share to the guest"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def add_share(box_name, share_name, share_path)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+#          command="#{File.dirname().shellescape}/vmware-vdiskmanager -c -s #{definition.disk_size}M -a lsilogic -t #{disk_type} #{name}.vmdk"
+#          shell_results=shell_exec("#{command}",{:mute => true})
+        venv.providers["vmfusion"].get_box(box_name).add_share(share_name, share_path)
+
+      end
+
+    end
+
+  end
+end