vagrant-g5k 0.0.2

data/lib/vagrant-g5k/action/read_state.rb

@@ -0,0 +1,36 @@
+require "log4r"
+
+module VagrantPlugins
+  module G5K
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_g5k::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:machine], env[:g5k_connection])
+          @app.call(env)
+        end
+
+        def read_state(machine, conn)
+          return :not_created if machine.id.nil?
+          # is there a job running for this vm ?
+          subnet = conn.check_or_reserve_subnet()
+          if subnet.nil? 
+            return :missing_subnet
+          end
+          job = conn.check_job(machine.id)
+          if job.nil? # TODO or fraged
+            return :not_created
+          end
+
+          return job["state"].to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-g5k/action/run_instance.rb

@@ -0,0 +1,37 @@
+require "log4r"
+require 'json'
+require 'yaml'
+
+
+module VagrantPlugins
+  module G5K
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_g5k::action::run_instance")
+        end
+
+        def call(env)
+          conn = env[:g5k_connection]
+          conn.launch_vm(env)
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/vagrant-g5k/command.rb

@@ -0,0 +1,21 @@
+require 'net/ssh/multi'
+require 'vagrant-g5k/util/g5k_utils'
+
+module VagrantPlugins
+  module G5K
+    class Command < Vagrant.plugin('2', :command)
+
+      # Show description when `vagrant list-commands` is triggered
+      def self.synopsis
+        "plugin: vagrant-g5k: manage virtual machines on grid'5000"
+      end
+
+      def execute
+        conn = Connection.instance
+        # someday pretty print the output
+        puts conn.list_images
+      end
+    end
+  end
+end
+

data/lib/vagrant-g5k/config.rb

@@ -0,0 +1,58 @@
+require "vagrant"
+require "iniparse"
+
+module VagrantPlugins
+  module G5K
+    class Config < Vagrant.plugin("2", :config)
+      # G5K username
+      #
+      # @return [String]
+      attr_accessor :username
+
+      # G5K site
+      #
+      # @return [String]
+      attr_accessor :site
+      # G5K image location (path)
+      #
+      # @return [String]
+      attr_accessor :image_location
+
+      # G5K image location (path)
+      #
+      # @return [String]
+      attr_accessor :image_type
+
+      # G5K image strategy
+      # 
+      #
+      # @return [String]
+      attr_accessor :image_strategy
+
+
+      def initialize()
+        @username     = nil
+        @image_location = nil
+        @site = "rennes"
+        @image_type     = "local"
+        @image_strategy = "snapshot"
+      end
+
+      def finalize!()
+        # This is call by the plugin mecanism after initialize
+      end
+
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << "g5k username is required" if @username.nil?
+        errors << "g5k image_location is required" if @image_location.nil?
+
+        { "G5K Provider" => errors }
+      end
+
+    end
+  end
+end
+

data/lib/vagrant-g5k/errors.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module G5K
+    module Errors
+      class VagrantG5KError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_g5k.errors")
+      end
+
+      class TimeoutOnJobSubmissionError < VagrantG5KError
+        error_key("tired of waiting")
+      end
+
+      class JobNotRunning < VagrantG5KError
+        error_key("tired of waiting")
+      end
+    end
+  end
+end

data/lib/vagrant-g5k/plugin.rb

@@ -0,0 +1,78 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant G5K 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 G5K plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module G5K
+    class Plugin < Vagrant.plugin("2")
+
+      name "G5K"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in G5K.
+      DESC
+
+      config(:g5k, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:g5k, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      command(:vmlist) do
+        require_relative 'command'
+        Command
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", G5K.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_g5k")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-g5k/provider.rb

@@ -0,0 +1,49 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module G5K
+    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", lock: false)
+        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", lock: false)
+
+        state_id = env[:machine_state_id]
+
+        short = "#{state_id}"
+        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
+        "G5K (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-g5k/util/g5k_utils.rb

@@ -0,0 +1,177 @@
+require 'net/ssh/multi'
+require 'net/scp'
+require 'json'
+
+require 'vagrant/util/retryable'
+
+WORKING_DIR = ".vagrant-g5k"
+LAUNCHER_SCRIPT = "launch_vm.sh"
+JOB_SUBNET_NAME = "vagrant-g5k-subnet"
+WALLTIME="01:00:00"
+
+module VagrantPlugins
+  module G5K
+    class Connection
+      include Vagrant::Util::Retryable
+
+      attr_accessor :session
+
+      attr_accessor :username
+
+      attr_accessor :site
+
+      attr_accessor :image_location
+
+      attr_accessor :logger
+
+      attr_accessor :node
+      
+      attr_accessor :pool
+
+      attr_accessor :ip
+
+      attr_accessor :mac
+
+      @@locations = [
+        {
+          :path => "/grid5000/virt-images",
+          :type => "local"
+        }
+      ]
+
+      def initialize(args)
+        # initialize
+        args.each do |k,v|
+          instance_variable_set("@#{k}", v) unless v.nil?
+        end
+
+        gateway = Net::SSH::Gateway.new("access.grid5000.fr", "msimonin", :forward_agent => true)
+        @session = gateway.ssh(@site, "msimonin")
+      end
+
+      def list_images()
+        images = []
+        @@locations.each do |location|
+          if location[:type] == "local"
+            stdout = ""
+            @session.exec!("ls #{location[:path]}/*.qcow2") do |channel, stream, data| 
+              stdout << data
+            end
+            images += stdout.split("\n").map{ |i| {:path => i, :type => 'local'} }
+          #elsif location[:type] == "ceph"
+          #  stdout = ""
+          #  @session.exec!("rbd --pool #{location[:pool]} --conf $HOME/.ceph/config --id #{location[:id]} ls") do |channel, stream, data|
+          #    stdout << data
+          #  end
+          #  images += stdout.split("\n").map{ |i| {:path => i, :type => 'ceph'} }
+          end
+        end
+        images
+      end
+      
+      def create_local_working_dir(env)
+        @session.exec("mkdir -p #{WORKING_DIR}")
+      end
+
+
+      def check_job(job_id)
+        oarstat = exec("oarstat --json")
+        oarstat = JSON.load(oarstat)
+        r = oarstat.select!{ |k,v| k == job_id and v["owner"] == @username }.values.first
+        # update the assigned hostname
+        # this will be used to reach the vm 
+        if !r.nil?
+          @node = r["assigned_network_address"].first
+        end
+        return r
+      end
+
+      def check_or_reserve_subnet()
+        @logger.info("Checking if a subnet has been reserved")
+        oarstat = exec("oarstat --json")
+        oarstat = JSON.load(oarstat)
+        job = oarstat.select!{ |k,v| v["owner"] == @username && v["name"] == JOB_SUBNET_NAME }.values.first
+        if job.nil?
+          # we have to reserve a subnet
+          @logger.info("Reserving a subnet")
+          job_id = exec("oarsub -l \"slash_22=1, walltime=#{WALLTIME}\" --name #{JOB_SUBNET_NAME} \"sleep 3600\" | grep OAR_JOB_ID | cut -d '='  -f2").chomp
+          begin
+            retryable(:on => VagrantPlugins::G5K::Errors::JobNotRunning, :tries => 5, :sleep => 1) do
+              @logger.info("Waiting for the job to be running")
+              job = check_job(job_id)
+              if job.nil? or job["state"] != "Running"
+                raise VagrantPlugins::G5K::Errors::JobNotRunning 
+              end
+              break
+            end
+          rescue VagrantPlugins::G5K::Errors::JobNotRunning
+            @logger.error("Tired of waiting")
+            raise VagrantPlugins::G5K::Errors::JobNotRunning
+          end
+        end
+        # get the macs ips addresses pool
+        im = exec("g5k-subnets -j #{job["Job_Id"]} -im")
+        @pool = im.split("\n").map{|i| i.split("\t")}
+        @ip, @mac = @pool[0]
+        @logger.info("Get the mac #{mac} and the corresponding ip #{ip} from the subnet")
+      end
+
+
+      def launch_vm(env)
+        launcher_path = File.join(File.dirname(__FILE__), LAUNCHER_SCRIPT)
+        @logger.info("Launching the VM on Grid'5000")
+        # Checking the subnet job
+        subnet = check_or_reserve_subnet()
+        @logger.info("Uploading launcher")
+        # uploading the launcher
+        launcher_remote_path = File.join("/home", @username , WORKING_DIR, LAUNCHER_SCRIPT)
+        upload(launcher_path, launcher_remote_path)
+        # creating the params file
+        params_path = File.join("/home", @username, WORKING_DIR, 'params')
+        exec("echo #{@image_location} #{@mac} > #{params_path}")
+        # Submitting a new job
+        @logger.info("Starting a new job")
+        job_id = exec("oarsub -t allow_classic_ssh -l \"{virtual!=\'none\'}/nodes=1,walltime=#{WALLTIME}\" --name #{env[:machine].name} --checkpoint 60 --signal 12  --array-param-file #{params_path} #{launcher_remote_path} | grep OAR_JOB_ID | cut -d '='  -f2").chomp
+        
+
+        begin
+          retryable(:on => VagrantPlugins::G5K::Errors::JobNotRunning, :tries => 5, :sleep => 1) do
+            @logger.info("Waiting for the job to be running")
+            job = check_job(job_id)
+            if job.nil? or job["state"] != "Running"
+              raise VagrantPlugins::G5K::Errors::JobNotRunning 
+            end
+            # saving the id
+            env[:machine].id = job["Job_Id"]
+            break
+          end
+        rescue VagrantPlugins::G5K::Errors::JobNotRunning
+          @logger.error("Tired of waiting")
+          raise VagrantPlugins::G5K::Errors::JobNotRunning
+        end
+        @logger.info("VM booted on Grid'5000")
+
+      end
+
+
+      def exec(cmd)
+        @logger.info("Executing #{cmd}")
+        stdout = ""
+        @session.exec!(cmd) do |channel, stream, data| 
+          stdout << data
+        end
+        return stdout
+      end
+
+      def upload(src, dst)
+        @session.scp.upload!(src, dst)
+      end
+
+
+
+
+    end
+  end
+end
+
+