vanagon 0.6.1 → 0.6.2

data/lib/vanagon/engine/ec2.rb

@@ -0,0 +1,75 @@
+require 'aws-sdk'
+require 'erb'
+require 'base64'
+require 'vanagon/engine/base'
+
+class Vanagon
+  class Engine
+    class Ec2 < Base
+      attr_accessor :ami, :key_name, :userdata, :key, :key_name, :shutdown_behavior
+      attr_accessor :subnet_id, :instance_type
+
+      def initialize(platform, target = nil)
+        super
+
+        @ami = @platform.aws_ami
+        @target_user = @platform.target_user
+        @subnet_id = @platform.aws_subnet_id
+        @userdata = @platform.aws_user_data
+        @region = @platform.aws_region || 'us-east-1'
+        @key_name = @platform.aws_key_name
+        @key = @platform.aws_key
+        @instance_type = @platform.aws_instance_type || "t1.micro"
+        @required_attributes = ["ssh_port", "aws_ami", "aws_key_name"]
+        @shutdown_behavior = @platform.aws_shutdown_behavior
+
+        @ec2 = ::Aws::EC2::Client.new(region: @region)
+        @resource = ::Aws::EC2::Resource.new(client: @ec2)
+      end
+
+      def name
+        'ec2'
+      end
+
+      def get_userdata
+        unless @userdata.nil?
+          Base64.encode64(ERB.new(@userdata).result(binding))
+        end
+      end
+
+      def instances
+        @instances ||= @resource.create_instances({
+          image_id: ami,
+          min_count: 1,
+          max_count: 1,
+          key_name: key_name,
+          instance_type: instance_type,
+          subnet_id: subnet_id,
+          user_data: get_userdata,
+          monitoring: {
+            enabled: false,
+          }
+        })
+      end
+
+      def instance
+        @instance ||= instances.first
+      end
+
+      def select_target
+        puts "Instance created id: #{instance.id}"
+        puts "Created instance waiting for status ok"
+        @ec2.wait_until(:instance_status_ok, instance_ids: [instance.id])
+        puts "Instance running"
+        @target = instance.private_ip_address
+      rescue ::Aws::Waiters::Errors::WaiterFailed => error
+        fail "Failed to wait for ec2 instance to start got error #{error}"
+      end
+
+      def teardown
+        puts "Destroying instance on AWS id: #{instance.id}"
+        instances.batch_terminate!
+      end
+    end
+  end
+end

data/lib/vanagon/engine/hardware.rb

@@ -51,15 +51,32 @@ class Vanagon
       end
 
       def initialize(platform, target)
+        super
+
         Vanagon::Driver.logger.debug "Hardware engine invoked."
-        @name = 'hardware'
-        @platform = platform
         @build_hosts = platform.build_hosts
         # Redis is the only backend supported in lock_manager currently
         @lockman = LockManager.new(type: 'redis', server: LOCK_MANAGER_HOST)
-        super
         @required_attributes << "build_hosts"
       end
+
+      # Get the engine name
+      def name
+        'hardware'
+      end
+
+      # Get the first build host name to build on
+      def build_host_name
+        if @build_host_name.nil?
+          validate_platform
+          # For now, get the first build host. In the future, lock management
+          # will be pushed into the pooler (or something that wraps it), and
+          # the hardware engine can go away.
+          @build_host_name = @build_hosts.first
+        end
+
+        @build_host_name
+      end
     end
   end
 end

data/lib/vanagon/engine/local.rb

@@ -7,9 +7,8 @@ class Vanagon
     class Local < Base
 
       def initialize(platform, target = nil)
-        @target = target || "local machine"
-        @name = 'local'
-        super
+        # local engine can't be used with a target
+        super(platform, 'local machine')
 
         # We inherit a set of required attributes from Base,
         # and rather than instantiate a new empty array for
@@ -18,6 +17,21 @@ class Vanagon
         @required_attributes.clear
       end
 
+      # Get the engine name
+      def name
+        'local'
+      end
+
+      # Return the target name to build on
+      def build_host_name
+        if @build_host_name.nil?
+          validate_platform
+          @build_host_name = @target
+        end
+
+        @build_host_name
+      end
+
       # Dispatches the command for execution
       def dispatch(command, return_output = false)
         Vanagon::Utilities.local_command(command, return_command_output: return_output)
@@ -31,6 +45,7 @@ class Vanagon
         FileUtils.mkdir_p("output")
         FileUtils.cp_r(Dir.glob("#{@remote_workdir}/output/*"), "output/")
       end
+
     end
   end
 end

data/lib/vanagon/engine/pooler.rb

@@ -7,11 +7,26 @@ class Vanagon
 
       # The vmpooler_template is required to use the pooler engine
       def initialize(platform, target = nil)
+        super
+
         @pooler = "http://vmpooler.delivery.puppetlabs.net"
         @token = load_token
-        super
         @required_attributes << "vmpooler_template"
-        @name = 'pooler'
+      end
+
+      # Get the engine name
+      def name
+        'pooler'
+      end
+
+      # Return the vmpooler template name to build on
+      def build_host_name
+        if @build_host_template_name.nil?
+          validate_platform
+          @build_host_template_name = @platform.vmpooler_template
+        end
+
+        @build_host_template_name
       end
 
       # This method loads the pooler token from one of two locations
@@ -35,12 +50,12 @@ class Vanagon
         response = Vanagon::Utilities.http_request(
           "#{@pooler}/vm",
           'POST',
-          '{"' + @platform.vmpooler_template + '":"1"}',
+          '{"' + build_host_name + '":"1"}',
           { 'X-AUTH-TOKEN' => @token }
         )
         if response["ok"]
-          @target = response[@platform.vmpooler_template]['hostname'] + '.' + response['domain']
-          Vanagon::Driver.logger.info "Reserving #{@target} (#{@platform.vmpooler_template}) [#{@token ? 'token used' : 'no token used'}]"
+          @target = response[build_host_name]['hostname'] + '.' + response['domain']
+          Vanagon::Driver.logger.info "Reserving #{@target} (#{build_host_name}) [#{@token ? 'token used' : 'no token used'}]"
 
           tags = {
             'tags' => {
@@ -51,13 +66,13 @@ class Vanagon
           }
 
           Vanagon::Utilities.http_request(
-            "#{@pooler}/vm/#{response[@platform.vmpooler_template]['hostname']}",
+            "#{@pooler}/vm/#{response[build_host_name]['hostname']}",
             'PUT',
             tags.to_json,
             { 'X-AUTH-TOKEN' => @token }
           )
         else
-          raise Vanagon::Error, "Something went wrong getting a target vm to build on, maybe the pool for #{@platform.vmpooler_template} is empty?"
+          raise Vanagon::Error, "Something went wrong getting a target vm to build on, maybe the pool for #{build_host_name} is empty?"
         end
       end
 

data/lib/vanagon/extensions/hashable.rb

@@ -0,0 +1,41 @@
+# This is bad, and I feel bad. This will let you append
+# broadly useful Hash and JSON casting on any class that
+# includes it. But it's pretty naive, in that it just turns
+# attributes names into keys while retaining their
+# associated values.
+module HashableAttributes
+  # @return [Hash] Converts an object to a hash with keys representing
+  #   each attribute (as symbols) and their corresponding values
+  def to_hash
+    instance_variables.each_with_object({}) do |var, hash|
+      hash[var.to_s.delete("@")] = instance_variable_get(var)
+    end
+  end
+  alias_method :to_h, :to_hash
+
+  def to_json(*options)
+    to_hash.to_json options
+  end
+end
+
+# Vanagon classes generally don't implement JSON or Hash functionality
+# so those need to be monkey-patched for useful inspection.
+class Vanagon
+  class Platform
+    include HashableAttributes
+  end
+
+  class Common
+    class Pathname
+      include HashableAttributes
+    end
+  end
+
+  class Component
+    include HashableAttributes
+  end
+
+  class Patch
+    include HashableAttributes
+  end
+end

data/lib/vanagon/extensions/ostruct/json.rb

@@ -0,0 +1,12 @@
+require 'ostruct'
+require 'json'
+
+module OpenStructJson
+  def to_json(*options)
+    to_h.to_json options
+  end
+end
+
+class OpenStruct
+  prepend OpenStructJson
+end

data/lib/vanagon/extensions/set/json.rb

@@ -0,0 +1,12 @@
+require 'set'
+require 'json'
+
+module SetJson
+  def to_json(*options)
+    to_a.to_json *options
+  end
+end
+
+class Set
+  prepend SetJson
+end

data/lib/vanagon/extensions/string.rb

@@ -6,6 +6,6 @@
 class String
   # @return [String]
   def undent
-    gsub(/^.{#{slice(/^ +/).length}}/, '')
+    gsub(/^.{#{slice(/^\s+/).length}}/, '')
   end
 end

data/lib/vanagon/platform.rb

@@ -7,6 +7,8 @@ class Vanagon
     attr_accessor :servicetype, :patch, :architecture, :codename, :os_name, :os_version
     attr_accessor :docker_image, :ssh_port, :rpmbuild, :install, :platform_triple
     attr_accessor :target_user, :package_type, :find, :sort, :build_hosts, :copy, :cross_compiled
+    attr_accessor :aws_ami, :aws_user_data, :aws_shutdown_behavior, :aws_key_name, :aws_region, :aws_key
+    attr_accessor :aws_instance_type, :aws_vpc_id, :aws_subnet_id
 
     # Platform names currently contain some information about the platform. Fields
     # within the name are delimited by the '-' character, and this regex can be used to

data/lib/vanagon/platform/dsl.rb

@@ -228,6 +228,55 @@ class Vanagon
         @platform.docker_image = name
       end
 
+      # Set the ami for the platform to use
+      #
+      # @param ami [String] the ami id used.
+      def aws_ami(ami)
+        @platform.aws_ami = ami
+      end
+
+      # Set the user data used in AWS to do setup. Like cloud-config
+      #
+      # @param userdata [String] a string used to send to the node to do the intial setup
+      def aws_user_data(userdata)
+        @platform.aws_user_data = userdata
+      end
+
+      # Set the region, this defaults to us-east-1
+      #
+      # @param region [String] a string used to setup the region
+      def aws_region(region = 'us-east-1')
+        @platform.aws_region = region
+      end
+
+      # Set the shutdown behavior for aws. This will default to terminate the instance on shutdown
+      #
+      # @param shutdown_behavior [String] a string used to set the shutdown behavior
+      def aws_shutdown_behavior(shutdown_behavior = 'terminate')
+        @platform.aws_shutdown_behavior = shutdown_behavior
+      end
+
+      # Set the key_name used. This should already exist on AWS.
+      #
+      # @param key_name [String] this defaults to the keyname vanagon. Can be set to any
+      def aws_key_name(key_name = 'vanagon')
+        @platform.aws_key_name = key_name
+      end
+
+      # Set the instaince type. This defaults to t1.micro which is the free instance
+      #
+      # @param instance_type [String] a string to define the instaince type
+      def aws_instance_type(instance_type = 't1.micro')
+        @platform.aws_instance_type = instance_type
+      end
+
+      # Set the subnet_id. Use this to setup a subnet for your VPC to use.
+      #
+      # @param subnet_id[String] a string to define the subnet_id in AWS
+      def aws_subnet_id(subnet_id)
+        @platform.aws_subnet_id = subnet_id
+      end
+
       # Set the port for ssh to use if it's not 22
       #
       # @param port [Integer] port number for ssh
@@ -235,6 +284,20 @@ class Vanagon
         @platform.ssh_port = port
       end
 
+      # Set the target user to login with. Defaults to root.
+      #
+      # @param user[String] a user string to login with.
+      def target_user(user = "root")
+        @platform.target_user = user
+      end
+
+      # Set the target ip address or hostname to start build
+      #
+      # @param target_host[String] a host string to login with.
+      def target_host(target_host)
+        @platform.target_host = target_host
+      end
+
       # Set the platform_triple for the platform
       #
       # @param triple[String] platform_triple for use in building out compiled

data/lib/vanagon/platform/osx.rb

@@ -25,8 +25,11 @@ class Vanagon
          # Setup build directories
         ["bash -c 'mkdir -p $(tempdir)/osx/build/{dmg,pkg,scripts,resources,root,payload,plugins}'",
          "mkdir -p $(tempdir)/osx/build/root/#{project.name}-#{project.version}",
+         "mkdir -p $(tempdir)/osx/build/pkg",
          # Grab distribution xml, scripts and other external resources
          "cp #{project.name}-installer.xml $(tempdir)/osx/build/",
+         #copy the uninstaller to the pkg dir, where eventually the installer will go too
+         "cp #{project.name}-uninstaller.tool $(tempdir)/osx/build/pkg/",
          "cp scripts/* $(tempdir)/osx/build/scripts/",
          "if [ -d resources/osx/productbuild ] ; then cp -r resources/osx/productbuild/* $(tempdir)/osx/build/; fi",
          # Unpack the project
@@ -73,6 +76,9 @@ class Vanagon
           FileUtils.chmod 0755, File.join(script_dir, script_file)
         end
 
+        erb_file(File.join(VANAGON_ROOT, 'resources', 'osx', 'uninstaller.tool.erb'), File.join(workdir, "#{name}-uninstaller.tool"), false, { :binding => binding })
+        FileUtils.chmod 0755, File.join(workdir, "#{name}-uninstaller.tool")
+
         # Probably a better way to do this, but OSX tends to need some extra stuff
         FileUtils.cp_r("resources/osx/.", resources_dir) if File.exist?("resources/osx/")
       end

data/lib/vanagon/project/dsl.rb

@@ -194,7 +194,7 @@ class Vanagon
       #
       # @param name [String] name of component to add. must be present in configdir/components and named $name.rb currently
       def component(name)
-        puts "Loading #{name}"
+        puts "Loading #{name}" if @project.settings[:verbose]
         if @include_components.empty? or @include_components.include?(name)
           component = Vanagon::Component.load_component(name, File.join(Vanagon::Driver.configdir, "components"), @project.settings, @project.platform)
           @project.components << component

data/lib/vanagon/utilities.rb

@@ -129,18 +129,24 @@ class Vanagon
     # @return [true] If the block succeeds, true is returned
     # @raise [Vanagon::Error] if the block fails after the retries are exhausted, an error is raised
     def retry_with_timeout(tries = 5, timeout = 1, &blk)
-      tries.times do
-        Timeout::timeout(timeout) do
+      error = nil
+      tries.to_i.times do
+        Timeout::timeout(timeout.to_i) do
           begin
             blk.call
             return true
-          rescue
+          rescue => e
             warn 'An error was encountered evaluating block. Retrying..'
+            error = e
           end
         end
       end
 
-      raise Vanagon::Error, "Block failed maximum of #{tries} tries. Exiting.."
+      message = "Block failed maximum number of #{tries} tries"
+      message += "\n with error #{error.message}" unless error.nil?
+      message += "\nExiting..."
+      raise error, message unless error.nil?
+      raise Vanagon::Error, "Block failed maximum number of #{tries} tries"
     end
 
     # Simple wrapper around git command line executes the given commands and

data/resources/osx/uninstaller.tool.erb

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+<%- if has_services? -%>
+<%- get_services.each do |service| -%>
+echo "Unloading service <%= service.name %>..."
+/bin/launchctl unload <%= service.service_file %>
+echo "OK"
+echo "Removing service file <%= service.service_file %>..."
+/bin/rm <%= service.service_file %>
+echo "OK"
+<%- end -%>
+<%- end -%>
+
+echo "Removing identifier: <%= @identifier-%>.<%= @name -%>..."
+if /usr/sbin/pkgutil --files <%= @identifier-%>.<%= @name -%> >/dev/null 2>&1 ; then
+  /usr/sbin/pkgutil --forget <%= @identifier-%>.<%= @name -%>
+
+fi
+echo "OK"
+
+echo "Removing Files"
+/bin/rm -Rf <%= get_directories.map {|d| d.path}.join(" ").to_s -%>
+
+echo "OK"