vagrant-tiktalik 0.0.1

data/lib/vagrant-tiktalik/action/terminate_instance.rb

@@ -0,0 +1,36 @@
+require "log4r"
+require "time"
+
+require "tiktalik"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_tiktalik::action::terminate_instance")
+          @config = env[:machine].provider_config
+        end
+
+        def call(env)
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_tiktalik.terminating"))
+
+          t = Tiktalik
+          t.api_key = @config.api_key
+          t.api_secret_key = @config.api_secret
+
+          i = Tiktalik::Computing::Instance
+          instance = i.find env[:machine].id
+          instance.destroy
+
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-tiktalik/util/timer"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_tiktalik.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/config.rb

@@ -0,0 +1,45 @@
+require "vagrant"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :api_key
+      attr_accessor :image
+      attr_accessor :size
+      attr_accessor :ssh_key
+      attr_accessor :api_secret
+      #attr_accessor :network
+
+      def initialize
+        @api_key    = UNSET_VALUE
+        @image      = UNSET_VALUE
+        @size       = UNSET_VALUE
+        @ssh_key    = UNSET_VALUE
+        @api_secret = UNSET_VALUE
+        #@network    = UNSET_VALUE
+      end
+
+      def finalize!
+        @api_key    = ENV['TIKTALIK_API_KEY'] if @api_key == UNSET_VALUE
+        @image      = nil if @image == UNSET_VALUE
+        @size       = 0.5 if @size == UNSET_VALUE
+        @ssh_key    = nil if @ssh_key == UNSET_VALUE
+        @api_secret = ENV['TIKTALIK_API_SECRET'] if @api_secret == UNSET_VALUE
+        #@network    = nil if @network == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << I18n.t("vagrant_tiktalik.config.api_key_required") if config.api_key.nil?
+        errors << I18n.t("vagrant_tiktalik.config.api_secret_required") if config.api_secret.nil?
+        errors << I18n.t("vagrant_tiktalik.config.image_required") if config.image.nil?
+        errors << I18n.t("vagrant_tiktalik.config.ssh_key_required") if !@ssh_key
+
+        # TODO validate network
+
+        { "Tiktalik Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/errors.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Errors
+      class VagrantTiktalikError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_tiktalik.errors")
+      end
+
+      class FogError < VagrantTiktalikError
+        error_key(:fog_error)
+      end
+
+      class InstanceReadyTimeout < VagrantTiktalikError
+        error_key(:instance_ready_timeout)
+      end
+
+      class RsyncError < VagrantTiktalikError
+        error_key(:rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Tiktalik.com plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant Tiktalik.com plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module TiktalikVagrant
+    class Plugin < Vagrant.plugin("2")
+      name "Tiktalik.com"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in Tiktalik.com.
+      DESC
+
+      config(:"tiktalik.com", :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:"tiktalik.com", parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", TiktalikVagrant.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_tiktalik")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/provider.rb

@@ -0,0 +1,50 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_tiktalik.states.short_#{state_id}")
+        long  = I18n.t("vagrant_tiktalik.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "Tiktalik.com (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    VERSION = "0.0.1"
+  end
+end

data/locales/en.yml

@@ -0,0 +1,94 @@
+en:
+  vagrant_tiktalik:
+    already_created: |-
+      The machine is already created.
+    launching_instance: |-
+      Launching an instance with the following settings...
+    launch_no_keypair: |-
+      Warning! You didn't specify a keypair to launch your instance with.
+      This can sometimes result in not being able to access your instance.
+    launch_vpc_warning: |-
+      Warning! You're launching this instance into a VPC without an
+      elastic IP. Please verify you're properly connected to a VPN so
+      you can access this machine, otherwise Vagrant will not be able
+      to SSH into it.
+    not_created: |-
+      Instance is not created. Please run `vagrant up` first.
+    ready: |-
+      Machine is booted and ready for use!
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    terminating: |-
+      Terminating the instance...
+    powering_off: |-
+      Stopping the instance...
+    powering_on: |-
+      Starting the instance...
+    waiting_for_ready: |-
+      Waiting for instance to become "ready"...
+    waiting_for_ssh: |-
+      Waiting for SSH to become available...
+    active_instance: |-
+      Instance is already up and running
+    unknown_state: |-
+      Instance is in unknown state
+    warn_networks: |-
+      Warning! The Tiktalik.com provider doesn't support any of the Vagrant
+      high-level network configurations (`config.vm.network`). They
+      will be silently ignored.
+    will_not_destroy: |-
+      The instance '%{name}' will not be destroyed, since the confirmation
+      was declined.
+
+    config:
+      api_key_required: |-
+        An access key ID must be specified via "api_key"
+      image_required: |-
+        An instance image UUID must be configured via "image"
+      api_secret_required: |-
+        A secret access key is required via "api_secret"
+      ssh_key_required: |-
+        A SSH key is required via "ssh_key"
+
+    errors:
+      fog_error: |-
+        There was an error talking to Tiktalik.com API. The error message is shown
+        below:
+
+        %{message}
+      instance_ready_timeout: |-
+        The instance never became "ready" in Tiktalik.com. The timeout currently
+        set waiting for the instance to become ready is %{timeout} seconds.
+        Please verify that the machine properly boots. If you need more time
+        set the `instance_ready_timeout` configuration on the Tiktalik.com provider.
+      rsync_error: |-
+        There was an error when attemping to rsync a share folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The Tiktalik.com instance is not created. Run `vagrant up` to create it.
+
+      short_running: |-
+        running
+      long_running: |-
+        The Tiktalik.com instance is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.
+
+      short_pending: |-
+        pending
+      long_pending: |-
+        The Tiktalik.com instance is still being initialized. To destroy this machine,
+        you can run `vagrant destroy`.
+
+      short_stopped: |-
+        stopped
+      long_stopped: |-
+        The Tiktalik.com instance is stopped. To destroy this machine,
+        you can run `vagrant destroy`.

data/spec/vagrant-tiktalik/config_spec.rb

@@ -0,0 +1,200 @@
+require "vagrant-tiktalik/config"
+
+describe VagrantPlugins::Tiktalik::Config do
+  let(:instance) { described_class.new }
+
+  # Ensure tests are not affected by Tiktalik credential environment variables
+  before :each do
+    ENV.stub(:[] => nil)
+  end
+
+  puts "config_spec"
+
+  describe "defaults" do
+    subject do
+      instance.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("api_key")     { should be_nil }
+    its("image")               { should be_nil }
+    #its("availability_zone") { should be_nil }
+    #its("instance_ready_timeout") { should == 120 }
+    #its("instance_type")     { should == "m1.small" }
+    #its("keypair_name")      { should be_nil }
+    #its("private_ip_address") { should be_nil }
+    #its("region")            { should == "us-east-1" }
+    its("api_secret") { should be_nil }
+    #its("security_groups")   { should == [] }
+    #its("subnet_id")         { should be_nil }
+    #its("tags")              { should == {} }
+    #its("user_data")         { should be_nil }
+    #its("use_iam_profile")   { should be_false }
+    #its("block_device_mapping")  {should == {} }
+  end
+
+  describe "overriding defaults" do
+    # I typically don't meta-program in tests, but this is a very
+    # simple boilerplate test, so I cut corners here. It just sets
+    # each of these attributes to "foo" in isolation, and reads the value
+    # and asserts the proper result comes back out.
+    #[:api_key, :ami, :availability_zone, :instance_ready_timeout,
+    #  :instance_type, :keypair_name,
+    #  :region, :api_secret, :security_groups,
+    #  :subnet_id, :tags,
+    #  :use_iam_profile, :user_data, :block_device_mapping].each do |attribute|
+    [:api_key, :api_secret, :image].each do |attribute|
+      it "should not default #{attribute} if overridden" do
+        instance.send("#{attribute}=".to_sym, "foo")
+        instance.finalize!
+        instance.send(attribute).should == "foo"
+      end
+    end
+  end
+
+  #describe "getting credentials from environment" do
+  #  context "without EC2 credential environment variables" do
+  #    subject do
+  #      instance.tap do |o|
+  #        o.finalize!
+  #      end
+  #    end
+  #
+  #    its("api_key")     { should be_nil }
+  #    its("api_secret") { should be_nil }
+  #  end
+  #
+  #  context "with EC2 credential environment variables" do
+  #    before :each do
+  #      ENV.stub(:[]).with("AWS_ACCESS_KEY").and_return("access_key")
+  #      ENV.stub(:[]).with("AWS_SECRET_KEY").and_return("secret_key")
+  #    end
+  #
+  #    subject do
+  #      instance.tap do |o|
+  #        o.finalize!
+  #      end
+  #    end
+  #
+  #    its("api_key")     { should == "access_key" }
+  #    its("api_secret") { should == "secret_key" }
+  #  end
+  #end
+
+  describe "region config" do
+    let(:config_api_key)     { "foo" }
+    let(:config_ami)               { "foo" }
+    let(:config_instance_type)     { "foo" }
+    let(:config_keypair_name)      { "foo" }
+    let(:config_region)            { "foo" }
+    let(:config_api_secret) { "foo" }
+
+    def set_test_values(instance)
+      instance.api_key     = config_api_key
+      instance.ami               = config_ami
+      instance.instance_type     = config_instance_type
+      instance.keypair_name      = config_keypair_name
+      instance.region            = config_region
+      instance.api_secret = config_api_secret
+    end
+
+    it "should raise an exception if not finalized" do
+      expect { instance.get_region_config("us-east-1") }.
+        to raise_error
+    end
+
+    context "with no specific config set" do
+      subject do
+        # Set the values on the top-level object
+        set_test_values(instance)
+
+        # Finalize so we can get the region config
+        instance.finalize!
+
+        # Get a lower level region
+        instance.get_region_config("us-east-1")
+      end
+
+      its("api_key")     { should == config_api_key }
+      its("ami")               { should == config_ami }
+      its("instance_type")     { should == config_instance_type }
+      its("keypair_name")      { should == config_keypair_name }
+      its("region")            { should == config_region }
+      its("api_secret") { should == config_api_secret }
+    end
+
+    context "with a specific config set" do
+      let(:region_name) { "hashi-region" }
+
+      subject do
+        # Set the values on a specific region
+        instance.region_config region_name do |config|
+          set_test_values(config)
+        end
+
+        # Finalize so we can get the region config
+        instance.finalize!
+
+        # Get the region
+        instance.get_region_config(region_name)
+      end
+
+      its("api_key")     { should == config_api_key }
+      its("ami")               { should == config_ami }
+      its("instance_type")     { should == config_instance_type }
+      its("keypair_name")      { should == config_keypair_name }
+      its("region")            { should == region_name }
+      its("api_secret") { should == config_api_secret }
+    end
+
+    describe "inheritance of parent config" do
+      let(:region_name) { "hashi-region" }
+
+      subject do
+        # Set the values on a specific region
+        instance.region_config region_name do |config|
+          config.ami = "child"
+        end
+
+        # Set some top-level values
+        instance.api_key = "parent"
+        instance.ami = "parent"
+
+        # Finalize and get the region
+        instance.finalize!
+        instance.get_region_config(region_name)
+      end
+
+      its("api_key") { should == "parent" }
+      its("ami")           { should == "child" }
+    end
+
+    describe "shortcut configuration" do
+      subject do
+        # Use the shortcut configuration to set some values
+        instance.region_config "us-east-1", :ami => "child"
+        instance.finalize!
+        instance.get_region_config("us-east-1")
+      end
+
+      its("ami") { should == "child" }
+    end
+
+    describe "merging" do
+      let(:first)  { described_class.new }
+      let(:second) { described_class.new }
+
+      it "should merge the tags" do
+        first.tags["one"] = "one"
+        second.tags["two"] = "two"
+
+        third = first.merge(second)
+        third.tags.should == {
+          "one" => "one",
+          "two" => "two"
+        }
+      end
+    end
+  end
+end