veewee 0.3.7 → 0.3.9

data/doc/parallels.md

@@ -0,0 +1,3 @@
+# Parallels VM Provider
+
+Documentation related to [Parallels](parallels.md) hasn't been completed yet.

data/doc/providers.md

@@ -1,23 +1,8 @@
-# Providers in Veewee
+# Veewee Virtual Machine Providers
 
-Initially veewee started as provider for virtualbox. From v0.3 Vmware fusion and KVM support are introduced.
+Veewee now has multiple virtual machine (VM) providers. Initially Veewee started with only VirtualBox as a provider. VMware Fusion and KVM were introduced in v0.3.  Parallels support is the newest addition.
 
-## Virtualbox
-
-To interact with virtualbox, veewee executes shell-commands through the 'VboxManage' command. The virtualbox gem library proved to be less stable.
-
-To simulate the typing, veewee uses the 'VBoxManage controlvm 'myubuntu' keyboardputscancode <keycode>'.
-Scancode are injected directly the keyboard buffer with this. And as this buffer is small, we can't type fast.
-This is why you have the delay while veewee types the commands. Speeding it up, will make the keyboard buffer loose keystrokes.
-
-## Vmware fusion
-
-To interact with Vmware fusion, we leverage (a currently patched) version of [Fission gem](https://github.com/thbishop/fission). This takes care of the heavy lifting.
-
-To interact with the screen , veewee enables VNC on the created vmware fusion machines and use the [Ruby-VNC gem](http://code.google.com/p/ruby-vnc/) to send the keystrokes. Here too , sending keystrokes too fast is a problem.
-
-## KVM
-
-To interact  with KVM veewee, uses [libvirt support](http://libvirt.org/ruby/) provided through [Fog gem](http://fog.io).
-
-To interact with the screen , veewee enables VNC on the created kvm machines and use the [Ruby-VNC gem](http://code.google.com/p/ruby-vnc/) to send the keystrokes. Here too , sending keystrokes too fast is a problem.
+* [Guide for VirtualBox](vbox.md)
+* [Guide for VMware Fusion](fusion.md)
+* [Guide for KVM](kvm.md)
+* [Guide for Parallels](parallels.md)

data/doc/requirements.md

@@ -1,7 +1,71 @@
-More Coming Soon
+# Requirements
 
-Development Libraries:
+Veewee has a few requirements that must be met before you're able to use Veewee.
 
-libxslt1-dev
-libxml2-dev
-zlib1g-dev
+
+## Virtualization Providers
+
+You'll need to install at least one of the supported VM providers (see [Providers](providers.md) doc for details). If you're not sure which provider to use, a common choice is [VirtualBox](http://www.virtualbox.org/) since it's free, portable, and supported by Vagrant.
+
+
+## Development Libraries
+
+Veewee is written in Ruby. In order to use Veewee you need Ruby installed as well as some header files
+in order to compile native extensions that come as dependencies. If you already have experiences with Ruby this should be very straightforward. 
+
+
+### For Linux
+
+On Linux, you may need these packages in order to build native rubygems:
+
+    libxslt1-dev
+    libxml2-dev
+    zlib1g-dev # or build-essential
+
+
+### For Mac OS X
+
+On Macs, either install `Xcode` or use [homebrew](http://mxcl.github.io/homebrew/) to install `apple-gcc42` or `build-essential`.
+
+
+### For Windows
+
+On Windows, you will need to install:
+
+* Ruby devkit
+* msysgit
+* PowerShell (if on XP or Vista)
+* PowerShell Community Extensions
+* And you may need to add VirtualBox to your `PATH`, usually installed to `C:\Program Files\Oracle\VirtualBox`.
+
+
+## Ruby Environment
+
+It is highly recommended that you use either `rvm` or `rbenv` to manage your ruby versions.
+
+
+### Option 1: RVM
+
+[RVM](https://rvm.io/) is Veewee's prefered ruby version manager. 
+
+RVM will allow Veewee to install it's own [gemset](https://rvm.io/gemsets/basics/) and configure it's own ruby version - which keeps Veewee and it's dependancies completely separate from your other projects. Please see https://rvm.io/gemsets/basics/ for details if you are new to the concept of 'gemsets'.
+
+
+##### Installing RVM
+
+Please see the [RVM install documentation](https://rvm.io/rvm/install) for up-to-date installation instructions.
+
+
+### Option 2: rbenv
+
+[rbenv](https://github.com/sstephenson/rbenv) is another popular ruby version manager that you can use as an alternative to RVM.
+
+
+##### Installing rbenv
+
+Please see the [rbenv README]( https://github.com/sstephenson/rbenv/#installation) for up-to-date installation instructions.
+
+
+## Up Next
+
+Ok, now that we have cover all the requirements, you can move on with [installing Veewee](installation.md).

data/doc/vagrant.md

@@ -1,119 +1,52 @@
-## Define a new box
-Let's define a  Ubuntu 10.10 server i386 basebox called myunbuntubox
-this is essentially making a copy based on the  templates provided above.
+# Vagrant
 
-    $ veewee vbox define 'myubuntubox' 'ubuntu-10.10-server-i386'
-    The basebox 'myubuntubox' has been successfully created from the template ''ubuntu-10.10-server-i386'
-    You can now edit the definition files stored in definitions/myubuntubox
-    or build the box with:
-    veewee vbox build 'myubuntubox'
+If you don't find what you're looking for here, please see the official [Vagrant docs](http://docs.vagrantup.com/v2/) for more information.
 
--> This copies over the templates/ubuntu-10.10-server-i386 to definition/myubuntubox
 
-    $ ls definitions/myubuntubox
-    definition.rb	postinstall.sh	postinstall2.sh	preseed.cfg
+## Typical workflow to build a Vagrant VM image
 
-## Optionally modify the definition.rb , postinstall.sh or preseed.cfg
+A simple workflow to build a VirtualBox VM for Vagrant would be:
 
-    Veewee::Definition.declare( {
-    :cpu_count => '1', :memory_size=> '256', 
-    :disk_size => '10140', :disk_format => 'VDI', :disk_variant => 'Standard',
-    :os_type_id => 'Ubuntu',
-    :iso_file => "ubuntu-10.10-server-i386.iso", 
-    :iso_src => "http://releases.ubuntu.com/maverick/ubuntu-10.10-server-i386.iso",
-    :iso_md5 => "ce1cee108de737d7492e37069eed538e",
-    :iso_download_timeout => "1000",
-    :boot_wait => "10",
-    :boot_cmd_sequence => [ 
-        '<Esc><Esc><Enter>',
-        '/install/vmlinuz noapic preseed/url=http://%IP%:%PORT%/preseed.cfg ',
-        'debian-installer=en_US auto locale=en_US kbd-chooser/method=us ',
-        'hostname=%NAME% ',
-        'fb=false debconf/frontend=noninteractive ',
-        'console-setup/ask_detect=false console-setup/modelcode=pc105 console-setup/layoutcode=us ',
-        'initrd=/install/initrd.gz -- <Enter>' 
-      ],
-    :kickstart_port => "7122", :kickstart_timeout => "10000",:kickstart_file => "preseed.cfg",
-    :ssh_login_timeout => "10000",:ssh_user => "vagrant", :ssh_password => "vagrant",:ssh_key => "",
-    :ssh_host_port => "2222", :ssh_guest_port => "22",
-    :sudo_cmd => "echo '%p'|sudo -S sh '%f'",
-    :shutdown_cmd => "shutdown -H",
-    :postinstall_files => [ "postinstall.sh"],:postinstall_timeout => "10000"
-     }
-    )
+    $ bundle exec veewee vbox templates | grep -i ubuntu
+    $ bundle exec veewee vbox define 'mybuntubox' 'ubuntu-12.10-server-amd64'
+    $ bundle exec veewee vbox build 'mybuntubox'
 
-If you need to change values in the templates, be sure to run the rake undefine, the rake define again to copy the changes across.
+For additional box building instructions, see the [Veewee Basics](basics.md) and [Definition Customization](customize.md) docs.
 
-## Getting the cdrom file in place
-Put your isofile inside the 'currentdir'/iso directory or if you don't run
+To build a VM for another provider, such as VMware Fusion, you'd use "fusion" instead of "vbox" in the above.
 
-    $ veewee vbox build 'myubuntubox'
+## Export the VM image to a .box file
 
-- the build assumes your iso files are in 'currentdir'/iso
-- if it can not find it will suggest to download the iso for you
-- use '--force' to overwrite an existing install
+In order to use the box in Vagrant, we need to export the VM as a [base box](http://docs.vagrantup.com/v2/boxes.html) (e.g. export to the .box filetype):
 
-## Build the new box:
+    $ bundle exec veewee vbox export 'myubuntubox'
 
-    $ veewee vbox build 'myubuntubox'
+This is actually calling `vagrant package --base 'myubuntubox' --output 'boxes/myubuntubox.box'`.
 
-- This will create a machine + disk according to the definition.rb
-- Note: :os_type_id = The internal Name Virtualbox uses for that Distribution
-- Mount the ISO File :iso_file
-- Boot up the machine and wait for :boot_time
-- Send the keystrokes in :boot_cmd_sequence
-- Startup a webserver on :kickstart_port to wait for a request for the :kickstart_file (don't navigate to the file in your browser or the server will stop and the installer will not be able to find your preseed)
-- Wait for ssh login to work with :ssh_user , :ssh_password
-- Sudo execute the :postinstall_files
+The machine gets shut down, exported and will be packed in a `myubuntubox.box` file inside the current directory.
 
-## Validate the vm 
 
-    $ veewee vbox validate 'myubuntubox'
+## Add the exported .box to Vagrant
 
-this will run some cucumber test against the box to see if it has the necessary bits and pieces for vagrant to work
-
-## Export the vm to a .box file
-
-    $ vagrant basebox export 'myubuntubox'
-
-this is actually calling - vagrant package --base 'myubuntubox' --output 'boxes/myubuntubox.box'
-
-this will result in a myubuntubox.box
-
-## Add the box as one of your boxes
-To import it into vagrant type:
+To import it into Vagrant's box repository simply type:
 
     $ vagrant box add 'myubuntubox' 'myubuntubox.box'
 
-## Use it in vagrant
+The parameter 'myubuntubox' sets the name that Vagrant will use to reference the box (i.e. in the `Vagrantfile`).
 
-To use it:
 
-    $ vagrant init 'myubuntubox'
-    $ vagrant up
-    $ vagrant ssh
-
-## How to add a new OS/installation (needs some love)
-
-I suggest the easiest way is to get an account on github and fork of the veewee repository
+## Use the added box in Vagrant
 
-    $ git clone https://github.com/*your account*/veewee.git
-    $ cd veewee
-    $ gem install bundler
-    $ bundle install
+To use your newly generated box in a fresh project execute these commands:
 
-If you don't use rvm, be sure to execute vagrant through bundle exec
-
-    $ alias veewee="bundle exec veewee"
+    $ vagrant init 'myubuntubox'
 
-Start of an existing one
+If you already have a project running with Vagrant, open the `Vagrantfile` and change the value of `config.vm.box` to the new box name:
 
-    $ veewee vbox define 'mynewos' 'ubuntu...'
+    Vagrant.configure("2") do |config|
+      config.vm.box = "myubuntubox"
+    end
 
-- Do changes in the currentdir/definitions/mynewos
-- When it builds ok, move the definition/mynewos to a sensible directory under templates
-- commit the changes (git commit -a)
-- push the changes to github (git push)
-- go to the github gui and issue a pull request for it
+See the [Vagrantfile machine settings](http://docs.vagrantup.com/v2/vagrantfile/machine_settings.html) for more details on setting up your `Vagrantfile` configuration.
 
-## If you have a setup working, share your 'definition' with me. That would be fun! 
+Now start the new environment with `vagrant up` and log in with `vagrant ssh` to enjoy your new environment.

data/doc/vbox.md

@@ -1,2 +1,79 @@
-Coming Soon
+# VirtualBox VM Provider
 
+To interact with [VirtualBox](http://www.virtualbox.org/), Veewee
+executes shell-commands through the 'VboxManage' command. The
+`virtualbox` gem library proved to be less stable.
+
+## Interacting with Guest Machine
+To simulate the typing, Veewee uses the `VBoxManage` command:
+
+`$ VBoxManage controlvm 'myubuntu' keyboardputscancode <keycode>`
+
+[Scancodes](http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html) are
+injected directly
+from the keyboard buffer with this command.  Because this buffer is
+small, Veewee can't type fast(er). This is why you'll notice a delay
+before Veewee types the commands. Speeding it up would make the keyboard
+buffer lose keystrokes.
+
+## VirtualBox OS_Types
+VirtualBox supports a wide variety of Guest Operating Systems.  The
+table below is a partial list of a few of the popular `os_types`.  *For
+a complete list* run the `virtualbox` command: `VBoxManage list ostypes`
+
+OS_TYPE_ID     | DESCRIPTION
+-------------- | -------------------
+ArchLinux_64   | Arch Linux (64 bit)
+ArchLinux      | Arch Linux
+Debian_64      | Debian (64 bit)
+Debian         | Debian
+Fedora_64      | Fedora (64 bit)
+Fedora         | Fedora
+FreeBSD_64     | FreeBSD (64 bit)
+FreeBSD        | FreeBSD
+Gentoo_64      | Gentoo (64 bit)
+Gentoo         | Gentoo
+MacOS_64       | Mac OS X (64 bit)
+MacOS          | Mac OS X
+OpenSUSE_64    | openSUSE (64 bit)
+Other          | Other/Unknown (32bit)
+RedHat_64      | CentOS (64 bit)
+RedHat         | CentOS
+RedHat_64      | Red Hat (64 bit)
+RedHat         | Red Hat
+Ubuntu_64      | Ubuntu (64 bit)
+Ubuntu         | Ubuntu
+Windows2012_64 | Windows 2012 (64 bit)
+Windows81_64   | Windows 8.1 (64 bit)
+Windows81      | Windows 8.1
+Windows8       | Windows 8
+
+
+## Guest Machine Settings
+`Virtualbox` creates *default VM settings* for a new Guest Machine
+based on the internal `os_type`.  For example, 64bit machines are setup
+with IO_APIC on so that guest machines can utilize multiple CPU's. 32bit
+Machines have IO_APIC off by default, even though modern 32-bit systems
+have [good support for SMP](http://en.wikipedia.org/wiki/Intel_APIC_Architecture#Problems).
+Therefore this, and other settings can be overridden within
+the `definion.rb` file, by using an array similar to:
+
+    :virtualbox => {
+      :vm_options => [
+        # Some example settings
+        'audio' => 'null',              # Enable Audio by setting host to null driver
+        'audiocontroller' => 'hda',     # Use simulated Intel HD audio
+        'ioapic' => 'on',               # APIC is necessary for symmetric multiprocessor (SMP) support
+        'rtcuseutc' => 'on',            # UTC internal time
+        'usb' => 'on',
+        'mouse' => 'usbtablet',         # Enable absolute pointing device
+        'usbwebcam' => 'on',
+        'accelerate3d' => 'on',         # Necessary for X to start the Unity desktop in Ubuntu 12.10+ -- Useful for 12.04, although can slow the VM if host hardware lacks good 3D support
+        'clipboard' => 'bidirectional'  # Useful for clipboard sharing between host & guest
+        'nonrotational' => 'on'         # Useful for guest OS's like Windows, so disk utilities aren't run
+
+        # A Full list of settings can be found here: http://virtualbox.org/manual/ch08.html#idp51057568
+        # Or generated based on the current settings of a virtualbox guest, such a machine named: myubuntu
+        # VBoxManage showvminfo --machinereadable 'myubuntu'
+        ]
+      }

data/doc/veeweefile.md

@@ -0,0 +1,25 @@
+# Veeweefile
+
+In cases were you'd like to set your own paths, feel free to create a `Veeweefile` in the project root:
+
+    Veewee::Config.run do |config|
+      
+      # Initialize convenience vars
+      cwd = File.dirname(__FILE__)
+      env = config.veewee.env
+      
+      # These env settings will override default settings
+      #env.cwd              = cwd
+      #env.definition_dir   = File.join(cwd, 'definitions')
+      #env.template_path    = [File.join(cwd, 'templates')]
+      #env.iso_dir          = File.join(cwd, 'iso')
+      #env.validation_dir   = File.join(cwd, 'validation')
+      #env.tmp_dir          = "/tmp"
+
+    end
+
+An example where this may be useful is if you'd like create your own barebones project, include the `veewee` gem in that project's Gemfile, and then make sure your local `templates` directory is referenced rather than the templates found inside the veewee gem.
+
+## Up Next
+
+Either check out the [guide for Vagrant](vagrant.md) or review one of the various [guides for Providers](providers.md).

data/lib/fission.old/cli.rb

@@ -0,0 +1,76 @@
+module Fission
+  class CLI
+    def self.execute(args=ARGV)
+      optparse = OptionParser.new do |opts|
+        opts.banner = "\nUsage: fission [options] COMMAND [arguments]"
+
+        opts.on_head('-v', '--version', 'Output the version of fission') do
+          Fission.ui.output Fission::VERSION
+          exit(0)
+        end
+
+        opts.on_head('-h', '--help', 'Displays this message') do
+          show_all_help(optparse)
+          exit(0)
+        end
+
+        opts.define_tail do
+          commands_banner
+        end
+
+      end
+
+      begin
+        optparse.order! args
+      rescue OptionParser::InvalidOption => e
+        Fission.ui.output e
+        show_all_help(optparse)
+        exit(1)
+      end
+
+      if commands.include?(args.first)
+        @cmd = Fission::Command.const_get(args.first.capitalize).new args.drop 1
+      elsif is_snapshot_command?(args)
+        klass = args.take(2).map {|c| c.capitalize}.join('')
+        @cmd = Fission::Command.const_get(klass).new args.drop 2
+      else
+        show_all_help(optparse)
+        exit(1)
+      end
+
+      begin
+        @cmd.execute
+      rescue Error => e
+         puts "Error: #{e}"
+      end
+    end
+
+    def self.commands
+      cmds = Dir.entries(File.join(File.dirname(__FILE__), 'command')).select do |file|
+        !File.directory? file
+      end
+
+      cmds.map { |cmd| File.basename(cmd, '.rb').gsub '_', ' ' }
+    end
+
+    private
+    def self.is_snapshot_command?(args)
+      args.first == 'snapshot' && args.count > 1 && commands.include?(args.take(2).join(' '))
+    end
+
+    def self.commands_banner
+      text = "\nCommands:\n"
+      Fission::Command.descendants.each do |command_klass|
+        text << (command_klass.send :help)
+      end
+
+      text
+    end
+
+    def self.show_all_help(options)
+      Fission.ui.output options
+      Fission.ui.output commands_banner
+    end
+
+  end
+end

data/lib/fission.old/command.rb

@@ -0,0 +1,15 @@
+module Fission
+  class Command
+    attr_reader :options, :args
+
+    def initialize(args=[])
+      @options = OpenStruct.new
+      @args = args
+    end
+
+    def self.help
+      self.new.option_parser.to_s
+    end
+
+  end
+end