veewee-atlassian 0.3.11

data/doc/vagrant.md

@@ -0,0 +1,48 @@
+# Vagrant
+
+A typical workflow with Vagrant would be:
+
+    $ vagrant basebox define 'mybuntubox' 'ubuntu-10.12-amd64'
+    $ vagrant basebox build 'mybuntubox'
+    $ vagrant basebox export 'mybuntubox'
+
+Now you can import the generated '.box' file to the vagrant box repository:
+
+    $ vagrant basebox add 'mybuntubox' 'mybuntubox.box'
+
+
+## Export the vm to a .box file
+
+In order to use the box in Vagrant we need to export the VM as a [Basebox](http://vagrantup.com/v1/docs/base_boxes.html):
+
+    $ vagrant basebox export 'myubuntubox'
+
+This is actually calling `vagrant package --base 'myubuntubox' --output 'boxes/myubuntubox.box'`.
+
+The machine gets shut down, exported and will be packed in a `myubuntubox.box` file inside the current directory.
+
+
+## Add the new box as one of your Vagrant boxes
+
+To import it into Vagrant's box repository simply type:
+
+    $ vagrant box add 'myubuntubox' 'myubuntubox.box'
+
+The parameter 'myubuntubox' sets the name of the box that is used by Vagrant to reference the box e.g. in the `Vagrantfile`.
+
+See http://docs.vagrantup.com/v1/docs/boxes.html for more details.
+
+
+## Use it in vagrant
+
+To use your newly generated box in a fresh project execute these commands:
+
+    $ vagrant init 'myubuntubox'
+
+If you already have a project running with Vagrant, open the `Vagrantfile` and change the value of `config.vm.box`
+to the new boxname:
+
+    Vagrant::Config.run do |config|
+      config.vm.box = "myubuntubox"
+
+Now start the new environment with `vagrant up` and log in with `vagrant ssh` to enjoy the joys of your new environment.

data/doc/vbox.md

@@ -0,0 +1,2 @@
+# Coming Soon
+

data/lib/fission.rb

@@ -0,0 +1,39 @@
+require 'fileutils'
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+#require 'fission/error'
+require 'fission/cli'
+require 'fission/command'
+require 'fission/command_helpers'
+require 'fission/command/clone'
+require 'fission/command/snapshot_create'
+require 'fission/command/snapshot_list'
+require 'fission/command/snapshot_revert'
+require 'fission/command/start'
+require 'fission/command/status'
+require 'fission/command/stop'
+require 'fission/command/suspend'
+require 'fission/config'
+require 'fission/core_ext/class'
+require 'fission/core_ext/file'
+require 'fission/core_ext/object'
+require 'fission/fusion'
+require 'fission/lease'
+require 'fission/metadata'
+require 'fission/response'
+require 'fission/ui'
+require 'fission/vm'
+require 'fission/version'
+
+module Fission
+  extend self
+
+  def config
+    @config ||= Fission::Config.new
+  end
+
+end

data/lib/fission/config.rb

@@ -0,0 +1,76 @@
+module Fission
+  class Config
+
+    # Public: Gets/Sets the Hash of attributes.
+    attr_accessor :attributes
+
+    # Public: Path to the Fission conf file (default: ~/.fissionrc).
+    CONF_FILE = File.expand_path '~/.fissionrc'
+
+    # Public: Initializes a Config object.  This also sets the default config
+    # attributes for 'vmrun_bin', 'vmrun_cmd', 'vm_dir', 'plist_file', and
+    # 'gui_bin'.
+    #
+    # Examples
+    #
+    #   Fission::Config.new
+    #
+    # Returns a new Config instance.
+    def initialize
+      @attributes = {}
+
+      @attributes['vm_dir'] = File.expand_path('~/Documents/Virtual Machines.localized/')
+      @attributes['lease_file'] = '/var/db/vmware/vmnet-dhcpd-vmnet8.leases'
+
+      fusion_version = :unknown
+
+      if File.exists?("/Library/Application Support/VMware Fusion/vmrun")
+        @attributes['vmrun_bin'] = '/Library/Application Support/VMware Fusion/vmrun'
+      end
+
+      if File.exists?("/Applications/VMware Fusion.app/Contents/Library/vmrun")  
+        @attributes['vmrun_bin'] = "/Applications/VMware Fusion.app/Contents/Library/vmrun"
+      end
+
+      if fusion_version == :unknown
+      end
+
+      @attributes['plist_file'] = File.expand_path('~/Library/Preferences/com.vmware.fusion.plist')
+      @attributes['gui_bin'] = File.expand_path('/Applications/VMware Fusion.app/Contents/MacOS/vmware')
+
+      load_from_file
+
+      @attributes['vmrun_cmd'] = "#{@attributes['vmrun_bin'].gsub(' ', '\ ')} -T fusion"
+    end
+
+    # Public: Helper method to access config atributes.  This is a shortcut for
+    # querying the config attributes.
+    #
+    # item - The config item to query.
+    #
+    # Examples
+    #
+    #   Fission.config['vmrun_bin']
+    #   # => '/foo/bar/vmrun'
+    #
+    # Returns the value of the specified config item.
+    def [](item)
+      @attributes[item]
+    end
+
+    private
+    # Internal: Loads config values from the Fission conf file into attributes.
+    #
+    # Examples
+    #
+    #   load_from_file
+    #
+    # Returns nothing.
+    def load_from_file
+      if File.file?(CONF_FILE)
+        @attributes.merge!(YAML.load_file(CONF_FILE))
+      end
+    end
+
+  end
+end

data/lib/java/README.txt

@@ -0,0 +1,5 @@
+$ java -jar dir2floppy.jar 
+Usage: java -jar dir2floppy.jar <sourcedir> <floppyfile>
+
+This uses the http://code.google.com/p/fat32-lib library 
+http://code.google.com/p/fat32-lib/wiki/Tutorial

data/lib/java/dir2floppy.java

@@ -0,0 +1,137 @@
+package be.jedi.dir2floppy;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+
+import de.waldheinz.fs.FileSystem;
+import de.waldheinz.fs.FsDirectoryEntry;
+import de.waldheinz.fs.FsFile;
+import de.waldheinz.fs.fat.SuperFloppyFormatter;
+import de.waldheinz.fs.util.FileDisk;
+
+/**
+ * Hello world!
+ *
+ */
+public class Dir2Floppy 
+{
+    public static void main( String[] args )
+    {
+    	if (args.length < 2) {
+    		System.out.println("Usage: java -jar dir2floppy.jar <sourcedir> <floppyfile>");
+    		System.exit(-1);
+    	}
+ 
+    	FileDisk device = null;
+
+    	//Create the floppy
+    	try {
+            device = FileDisk.create(new File(args[1]),(long)1440 * 1024);
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            System.exit(-1);
+        }
+
+        //Format the floppy
+        FileSystem fs=null;
+        try {
+            fs = SuperFloppyFormatter.get(device).format();
+ 
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            System.exit(-1);
+
+        }
+
+        //Iterate of directories
+        File dir = new File(args[0]);
+
+        String[] children = dir.list();
+        if (children == null) {
+            // Either dir does not exist or is not a directory
+        	System.out.println("Error. does the directory exist?");
+        	System.exit(-1);        	
+        } else {
+            for (int i=0; i<children.length; i++) {
+                // Get filename of file or directory
+            	File aFile=new File(dir.getAbsolutePath()+System.getProperty("file.separator")+children[i]);
+            	
+        	    try {        	
+            	// Create the entry on the floppy
+                FsDirectoryEntry floppyEntry = fs.getRoot().addFile(children[i]);
+                //floppyEntry.setName(children[i]);
+                System.out.print("- Processing file: "+children[i]+" ");
+                
+                FsFile floppyfile = floppyEntry.getFile();
+            	
+            	// Copy the file over                
+            	if (aFile.isFile()) {
+            		FileInputStream fis= new FileInputStream(aFile);
+            		
+            		FileChannel fci = fis.getChannel();
+            		ByteBuffer buffer = ByteBuffer.allocate(1024);
+            		
+            		long counter=0;
+            	    int len;
+            	    
+            	 //   http://www.kodejava.org/examples/49.html
+            	 // Here we start to read the source file and write it
+                    // to the destination file. We repeat this process
+                    // until the read method of input stream channel return
+                    // nothing (-1).
+                    while(true)
+                    {
+                        // read a block of data and put it in the buffer
+                        int read = fci.read(buffer);
+
+                        // did we reach the end of the channel? if yes
+                        // jump out the while-loop
+                        if (read == -1)
+                            break;
+
+                        // flip the buffer
+                        buffer.flip();
+
+                        // write to the destination channel
+          	    	  System.out.print(".");
+                      floppyfile.write(counter*1024, buffer);
+                      counter++;
+
+                        
+                        // clear the buffer and user it for the next read
+                        // process
+                        buffer.clear();
+                    }
+                    System.out.println();
+                    
+            	      floppyfile.flush();
+
+						fis.close();
+            	}
+				} catch (IOException e) {
+						// TODO Auto-generated catch block
+						e.printStackTrace();
+				
+            	}
+ 
+            }
+        }
+
+
+        try {
+			fs.close();
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+        
+        System.out.println( "Done" );
+    }
+    
+}
+

data/lib/net/vnc/vnc.rb

@@ -0,0 +1,341 @@
+require 'socket'
+require 'yaml'
+require 'thread'
+require 'cipher/des'
+require 'net/vnc/version'
+
+module Net
+  #
+  # The VNC class provides for simple rfb-protocol based control of
+  # a VNC server. This can be used, eg, to automate applications.
+  #
+  # Sample usage:
+  #
+  #   # launch xclock on localhost. note that there is an xterm in the top-left
+  #   Net::VNC.open 'localhost:0', :shared => true, :password => 'mypass' do |vnc|
+  #		vnc.pointer_move 10, 10
+  #		vnc.type 'xclock'
+  #		vnc.key_press :return
+  #   end
+  #
+  # = TODO
+  #
+  # * The server read loop seems a bit iffy. Not sure how best to do it.
+  # * Should probably be changed to be more of a lower-level protocol wrapping thing, with the
+  #   actual VNCClient sitting on top of that. all it should do is read/write the packets over
+  #   the socket.
+  #
+  class VNC
+    class PointerState
+      attr_reader :x, :y, :button
+
+      def initialize vnc
+        @x = @y = @button = 0
+        @vnc = vnc
+      end
+
+      # could have the same for x=, and y=
+      def button= button
+        @button = button
+        refresh
+      end
+
+      def update x, y, button=@button
+        @x, @y, @button = x, y, button
+        refresh
+      end
+
+      def refresh
+        packet = 0.chr * 6
+        packet[0] = 5.chr
+        packet[1] = button.chr
+        packet[2, 2] = [x].pack 'n'
+        packet[4, 2] = [y].pack 'n'
+        @vnc.socket.write packet
+      end
+    end
+
+    BASE_PORT = 5900 if BASE_PORT.nil?
+    CHALLENGE_SIZE = 16 if CHALLENGE_SIZE.nil?
+    DEFAULT_OPTIONS = {
+      :shared => false,
+      :wait => 0.1
+    } if DEFAULT_OPTIONS.nil?
+
+    if KEY_MAP.nil?
+      keys_file = File.dirname(__FILE__) + '/../../data/keys.yaml'
+      KEY_MAP = YAML.load_file(keys_file).inject({}) { |h, (k, v)| h.update k.to_sym => v }
+      def KEY_MAP.[] key
+        super or raise ArgumentError.new('Invalid key name - %s' % key)
+      end
+    end
+
+    attr_reader :server, :display, :options, :socket, :pointer
+
+    def initialize display=':0', options={}
+      @server = '127.0.0.1'
+      if display =~ /^(.*)(:\d+)$/
+        @server, display = $1, $2
+      end
+      @display = display[1..-1].to_i
+      @options = DEFAULT_OPTIONS.merge options
+      @clipboard = nil
+      @pointer = PointerState.new self
+      @mutex = Mutex.new
+      connect
+      @packet_reading_state = nil
+      @packet_reading_thread = Thread.new { packet_reading_thread }
+    end
+
+    def self.open display=':0', options={}
+      vnc = new display, options
+      if block_given?
+        begin
+          yield vnc
+        ensure
+          vnc.close
+        end
+      else
+        vnc
+      end
+    end
+
+    def port
+      BASE_PORT + @display
+    end
+
+    def connect
+      @socket = TCPSocket.open server, port
+      unless socket.read(12) =~ /^RFB (\d{3}.\d{3})\n$/
+        raise 'invalid server response'
+      end
+      @server_version = $1
+      socket.write "RFB 003.003\n"
+      data = socket.read(4)
+      auth = data.to_s.unpack('N')[0]
+      case auth
+      when 0, nil
+        raise 'connection failed'
+      when 1
+        # ok...
+      when 2
+        password = @options[:password] or raise 'Need to authenticate but no password given'
+        challenge = socket.read CHALLENGE_SIZE
+        response = Cipher::DES.encrypt password, challenge
+        socket.write response
+        ok = socket.read(4).to_s.unpack('N')[0]
+        raise 'Unable to authenticate - %p' % ok unless ok == 0
+      else
+        raise 'Unknown authentication scheme - %d' % auth
+      end
+
+      # ClientInitialisation
+      socket.write((options[:shared] ? 1 : 0).chr)
+
+      # ServerInitialisation
+      # TODO: parse this.
+      socket.read(20)
+      data = socket.read(4)
+      # read this many bytes in chunks of 20
+      size = data.to_s.unpack('N')[0]
+      while size > 0
+        len = [20, size].min
+        # this is the hostname, and other stuff i think...
+        socket.read(len)
+        size -= len
+      end
+    end
+
+    # this types +text+ on the server
+    def type text, options={}
+      packet = 0.chr * 8
+      packet[0] = 4.chr
+      text.split(//).each do |char|
+        packet[7] = char[0]
+        packet[1] = 1.chr
+        socket.write packet
+        packet[1] = 0.chr
+        socket.write packet
+      end
+      wait options
+    end
+
+    SHIFTED_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ~!@#$%^&*()_+{}|:"<>?'
+    KEY_PRESS_CHARS = {
+      "\n" => :return,
+      "\t" => :tab
+    }
+
+    # This types +text+ on the server, but it holds the shift key down when necessary.
+    # It will also execute key_press for tabs and returns.
+    def type_string text, options={}
+      shift_key_down = nil
+
+      text.each_char do |char|
+        key_to_press = KEY_PRESS_CHARS[char]
+        unless key_to_press.nil?
+          key_press key_to_press
+        else
+          key_needs_shift = SHIFTED_CHARS.include? char
+
+          if shift_key_down.nil? || shift_key_down != key_needs_shift
+            if key_needs_shift
+              key_down :shift
+            else
+              key_up :shift
+            end
+          end
+
+          type char
+          shift_key_down = key_needs_shift
+        end
+      end
+      wait options
+    end
+
+    # this takes an array of keys, and successively holds each down then lifts them up in
+    # reverse order.
+    # FIXME: should wait. can't recurse in that case.
+    def key_press(*args)
+      options = Hash === args.last ? args.pop : {}
+      keys = args
+      raise ArgumentError, 'Must have at least one key argument' if keys.empty?
+      begin
+        key_down keys.first
+        if keys.length == 1
+          yield if block_given?
+        else
+          key_press(*(keys[1..-1] + [options]))
+        end
+      ensure
+        key_up keys.first
+      end
+    end
+
+    def get_key_code which
+      if String === which
+        if which.length != 1
+          raise ArgumentError, 'can only get key_code of single character strings'
+        end
+        which[0]
+      else
+        KEY_MAP[which]
+      end
+    end
+    private :get_key_code
+
+    def key_down which, options={}
+      packet = 0.chr * 8
+      packet[0] = 4.chr
+      key_code = get_key_code which
+      packet[4, 4] = [key_code].pack('N')
+      packet[1] = 1.chr
+      socket.write packet
+      wait options
+    end
+
+    def key_up which, options={}
+      packet = 0.chr * 8
+      packet[0] = 4.chr
+      key_code = get_key_code which
+      packet[4, 4] = [key_code].pack('N')
+      packet[1] = 0.chr
+      socket.write packet
+      wait options
+    end
+
+    def pointer_move x, y, options={}
+      # options[:relative]
+      pointer.update x, y
+      wait options
+    end
+
+    BUTTON_MAP = {
+      :left => 0
+    } if BUTTON_MAP.nil?
+
+    def button_press button=:left, options={}
+      begin
+        button_down button, options
+        yield if block_given?
+      ensure
+        button_up button, options
+      end
+    end
+
+    def button_down which=:left, options={}
+      button = BUTTON_MAP[which] || which
+      raise ArgumentError, 'Invalid button - %p' % which unless (0..2) === button
+      pointer.button |= 1 << button
+      wait options
+    end
+
+    def button_up which=:left, options={}
+      button = BUTTON_MAP[which] || which
+      raise ArgumentError, 'Invalid button - %p' % which unless (0..2) === button
+      pointer.button &= ~(1 << button)
+      wait options
+    end
+
+    def wait options={}
+      sleep options[:wait] || @options[:wait]
+    end
+
+    def close
+      # destroy packet reading thread
+      if @packet_reading_state == :loop
+        @packet_reading_state = :stop
+        while @packet_reading_state
+          # do nothing
+        end
+      end
+      socket.close
+    end
+
+    def clipboard
+      if block_given?
+        @clipboard = nil
+        yield
+        60.times do
+          clipboard = @mutex.synchronize { @clipboard }
+          return clipboard if clipboard
+          sleep 0.5
+        end
+        warn 'clipboard still empty after 30s'
+        nil
+      else
+        @mutex.synchronize { @clipboard }
+      end
+    end
+
+    private
+
+    def read_packet type
+      case type
+      when 3 # ServerCutText
+        socket.read 3 # discard padding bytes
+        len = socket.read(4).unpack('N')[0]
+        @mutex.synchronize { @clipboard = socket.read len }
+      else
+        raise NotImplementedError, 'unhandled server packet type - %d' % type
+      end
+    end
+
+    def packet_reading_thread
+      @packet_reading_state = :loop
+      loop do
+        begin
+          break if @packet_reading_state != :loop
+          next unless IO.select [socket], nil, nil, 2
+          type = socket.read(1)[0]
+          read_packet type
+        rescue
+          warn "exception in packet_reading_thread: #{$!.class}:#{$!}"
+          break
+        end
+      end
+      @packet_reading_state = nil
+    end
+  end
+end
+