fog-opennebula 0.0.1

data/lib/fog/opennebula/models/compute/server.rb

@@ -0,0 +1,85 @@
+require 'fog/compute/models/server'
+
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Server < Fog::Compute::Server
+
+        identity :id
+        attribute :template_str
+        attribute :name
+        attribute :uuid
+        attribute :state
+        attribute :status
+        attribute :ip
+        attribute :mac
+        attribute :vcpu
+        attribute :cpu
+        attribute :memory
+        attribute :user
+        attribute :gid
+        attribute :group
+        attribute :onevm_object
+        attribute :flavor
+
+        def save
+          merge_attributes(service.vm_allocate(attributes))
+        end
+
+        def vm_ip_address
+          ip
+        end
+
+        def private_ip_address
+          ip
+        end
+
+        def public_ip_address
+          ip
+        end
+
+        def vm_mac_address
+          mac
+        end
+
+        def start
+          service.vm_resume(id) if status == 4
+          true
+        end
+
+        def stop
+          Fog::Logger.warning("stop VM: ID:#{id}")
+          service.vm_stop(id)
+        end
+
+        def suspend
+          service.vm_suspend(id)
+        end
+
+        def resume
+          service.vm_resume(id)
+        end
+
+        def destroy
+          service.vm_destroy(id)
+        end
+
+        def ready?
+          (status == 3)
+        end
+
+        def console_output
+          requires :id
+          service.get_vnc_console(id, 'vnc', onevm_object)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/models/compute/servers.rb

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/opennebula/models/compute/server'
+
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::OpenNebula::Server
+
+        def all(filter = {})
+          load(service.list_vms(filter))
+        end
+
+        def get(id)
+          data = service.list_vms(:id => id)
+          new data.first unless data.empty?
+        end
+
+        def shutdown(id)
+          service.vm_shutdown(id)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/requests/compute/OpenNebulaVNC.rb

@@ -0,0 +1,314 @@
+#
+# This class provides support for launching and stopping a websockify proxy
+#
+
+require 'rubygems'
+require 'json'
+require 'opennebula'
+
+# if !ONE_LOCATION
+NOVNC_LOCK_FILE = '/var/lock/.novnc.lock'.freeze
+# else
+#    NOVNC_LOCK_FILE= ONE_LOCATION + "/var/.novnc.lock"
+# end
+
+TOKEN_EXPIRE_SECONDS = 4
+
+VNC_STATES = [
+  # 0,  #LCM_INIT
+  # 1,  #PROLOG
+  # 2,  #BOOT
+  '3', # RUNNING
+  '4', # MIGRATE
+  # 5,  #SAVE_STOP
+  # 6,  #SAVE_SUSPEND
+  # 7,  #SAVE_MIGRATE
+  # 8,  #PROLOG_MIGRATE
+  # 9,  #PROLOG_RESUME
+  # 10, #EPILOG_STOP
+  # 11, #EPILOG
+  '12', # SHUTDOWN
+  '13', # CANCEL
+  # 14, #FAILURE
+  # 15, #CLEANUP_RESUBMIT
+  '16', # UNKNOWN
+  '17', # HOTPLUG
+  '18', # SHUTDOWN_POWEROFF
+  # 19, #BOOT_UNKNOWN
+  # 20, #BOOT_POWEROFF
+  # 21, #BOOT_SUSPENDED
+  # 22, #BOOT_STOPPED
+  # 23, #CLEANUP_DELETE
+  '24', # HOTPLUG_SNAPSHOT
+  '25', # HOTPLUG_NIC
+  '26', # HOTPLUG_SAVEAS
+  '27', # HOTPLUG_SAVEAS_POWEROFF
+  '28', # HOTPLUG_SAVEAS_SUSPENDED
+  '29'  # SHUTDOWN_UNDEPLOY
+  # 30, #EPILOG_UNDEPLOY
+  # 31, #PROLOG_UNDEPLOY
+  # 32  #BOOT_UNDEPLOY
+].freeze
+
+VAR_LOCATION = Dir.pwd + '/extras/noVNC'
+SHARE_LOCATION = Dir.pwd + '/extras/noVNC'
+class OpenNebulaVNC
+
+  attr_reader :proxy_port
+
+  def initialize(config, logger, options = {})
+    opts = { :json_errors => true,
+             :token_folder_name => 'sunstone_vnc_tokens' }.merge(options)
+
+    @pipe = nil
+    @token_folder = File.join(VAR_LOCATION, opts[:token_folder_name])
+    @proxy_path   = File.join(SHARE_LOCATION, 'websockify/websocketproxy.py')
+    @proxy_port   = config[:vnc_proxy_port]
+
+    @proxy_ipv6   = config[:vnc_proxy_ipv6]
+
+    @wss = config[:vnc_proxy_support_wss]
+
+    @lock_file = NOVNC_LOCK_FILE
+
+    if (@wss == 'yes') || (@wss == 'only') || (@wss == true)
+      @enable_wss = true
+      @cert       = config[:vnc_proxy_cert]
+      @key        = config[:vnc_proxy_key]
+    else
+      @enable_wss = false
+    end
+    @options = opts
+    @logger = logger
+  end
+
+  def start
+    if is_running?
+      message = 'VNC server already running'
+      STDERR.puts message
+      @logger.info message
+      return false
+    end
+
+    create_token_dir
+
+    proxy_options = "--target-config=#{@token_folder} "
+
+    if @enable_wss
+      proxy_options << " --cert #{@cert}"
+      proxy_options << " --key #{@key}" if @key && !@key.empty?
+      proxy_options << ' --ssl-only' if @wss == 'only'
+    end
+
+    proxy_options << ' -6' if @proxy_ipv6
+
+    cmd = "python #{@proxy_path} #{proxy_options} #{@proxy_port}"
+
+    begin
+      @logger.info { "Starting VNC proxy: #{cmd}" }
+      pid = start_daemon(cmd, VNC_LOG)
+    rescue Exception => e
+      @logger.error e.message
+      return false
+    end
+
+    File.open(@lock_file, 'w') do |f|
+      f.write(pid.to_s)
+    end
+
+    sleep 1
+
+    unless is_running?
+      message = 'Error starting VNC proxy'
+      STDERR.puts message
+      @logger.error message
+      File.delete(@lock_file) if File.exist?(@lock_file)
+
+      return false
+    end
+
+    STDOUT.puts 'VNC proxy started'
+
+    true
+  end
+
+  def proxy(vm_resource)
+    # Check configurations and VM attributes
+    # if !is_running?
+    #    return error(400, "VNC Proxy is not running")
+    # end
+
+    unless VNC_STATES.include?(vm_resource['LCM_STATE'])
+      return error(400, "Wrong state (#{vm_resource['LCM_STATE']}) to open a VNC session")
+    end
+
+    if vm_resource['TEMPLATE/GRAPHICS/TYPE'].nil? ||
+       !vm_resource['TEMPLATE/GRAPHICS/TYPE'].casecmp('vnc').zero?
+      return error(400, 'VM has no VNC configured')
+    end
+
+    # Proxy data
+    host     = vm_resource['HISTORY_RECORDS/HISTORY[last()]/HOSTNAME']
+    vnc_port = vm_resource['TEMPLATE/GRAPHICS/PORT']
+    vnc_pw = vm_resource['TEMPLATE/GRAPHICS/PASSWD']
+
+    # Generate token random_str: host:port
+    random_str = rand(36**20).to_s(36) # random string a-z0-9 length 20
+    token = "#{random_str}: #{host}:#{vnc_port}"
+    token_file = 'one-' + vm_resource['ID']
+
+    # Create token file
+
+    begin
+            f = File.open(File.join(@token_folder, token_file), 'w')
+            f.write(token)
+            f.close
+    rescue Exception => e
+      #            @logger.error e.message
+      return error(500, 'Cannot create VNC proxy token')
+          end
+
+    info = {
+      :proxy_port => '29876',
+      :password => vnc_pw,
+      :token => random_str,
+      :vm_name => vm_resource['NAME']
+    }
+
+    [200, info]
+  end
+
+  # Delete proxy token file
+  def delete_token(filename)
+    File.delete(File.join(@token_folder, filename))
+  rescue StandardError => e
+    @logger.error "Error deleting token file for VM #{vm_id}"
+    @logger.error e.message
+  end
+
+  def stop(force = false)
+    pid = get_pid
+
+    if pid
+      @logger.info 'Killing VNC proxy'
+
+      force ? signal = 'KILL' : signal = 'TERM'
+      Process.kill(signal, pid)
+
+      sleep 1
+
+      begin
+        Process.getpgid(pid)
+
+        Process.kill('KILL', pid)
+      rescue StandardError
+      end
+
+      if is_running?
+        message = 'VNC server is still running'
+        STDERR.puts message
+        logger.error message
+        return false
+      end
+
+      delete_token_dir
+    else
+      message = 'VNC server is not running'
+      @logger.info message
+      STDERR.puts message
+    end
+    true
+  end
+
+  def status
+    if is_running?
+      STDOUT.puts 'VNC is running'
+      true
+    else
+      STDOUT.puts 'VNC is NOT running'
+      false
+    end
+  end
+
+  private
+
+  def error(code, msg)
+    if @options[:json_errors]
+      [code, OpenNebula::Error.new(msg).to_json]
+    else
+      [code, msg]
+    end
+  end
+
+  def create_token_dir
+    delete_token_dir
+    begin
+      Dir.mkdir(@token_folder) unless File.exist?(@token_folder)
+    rescue Exception => e
+      @logger.error 'Cannot create token folder'
+      @logger.error e.message
+    end
+  end
+
+  def delete_token_dir
+    if File.exist?(@token_folder)
+      begin
+          Dir.glob("#{@token_folder}/*").each do |file|
+            File.delete(file)
+          end
+      rescue StandardError => e
+        @logger.error 'Error deleting token folder'
+        @logger.error e.message
+        end
+    end
+  end
+
+  def is_running?
+    if File.exist?(@lock_file)
+      pid = File.read(@lock_file).strip
+
+      return pid.to_i if system("ps #{pid} 1> /dev/null")
+
+      @logger.info 'Deleting stale lock file'
+      File.delete(@lock_file)
+    end
+
+    false
+  end
+  alias get_pid is_running?
+
+  if RUBY_VERSION < '1.9'
+    def spawn(*args)
+      fork do
+        command = args[0..-2]
+
+        # Close stdin and point out and err to log file
+        $stdin.close
+        $stdout.reopen(VNC_LOG, 'a')
+        $stderr.reopen(VNC_LOG, 'a')
+
+        # Detach process from the parent
+        Process.setsid
+
+        exec(*command)
+      end
+    end
+  end
+
+  def start_daemon(cmd, log)
+    options = {
+      :pgroup => true,
+      :in => :close,
+      [:out, :err] => [log, 'a'],
+      :close_others => true
+    }
+
+    params = cmd.split(' ') + [options]
+    pid = spawn(*params)
+
+    Process.detach(pid)
+
+    pid
+  end
+
+end

data/lib/fog/opennebula/requests/compute/get_vnc_console.rb

@@ -0,0 +1,58 @@
+require File.expand_path('OpenNebulaVNC', __dir__)
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Mock
+
+        # Get a vnc console for an instance.
+        #
+        # === Parameters
+        # * server_id <~String> - The ID of the server.
+        # * console_type <~String> - Type of vnc console to get ('novnc' or 'xvpvnc').
+        # === Returns
+        # * response <~Excon::Response>:
+        #   * body <~Hash>:
+        #     * url <~String>
+        #     * type <~String>
+        def get_vnc_console(_server_id, _console_type)
+          body = {
+            :type => 'novnc',
+            :proxy_port => '29876',
+            :password => 'null',
+            :token => '3n32dtwpsdj5jkug3b4w',
+            :proxy_host => 'example.com'
+          }
+        end
+
+      end
+
+      class Real
+
+        def get_vnc_console(_server_id, _console_type, onevm_object)
+          logger = Fog::Logger.new
+          $conf = { 'vnc_proxy_port' => '29876', 'vnc_proxy_ipv6' => '',
+                    'vnc_proxy_support_wss' => '', 'vnc_proxy_cert' => '',
+                    'vnc_proxy_key' => '' }
+          $vnc = OpenNebulaVNC.new($conf, logger)
+          ret = startvnc(onevm_object, $vnc)
+
+          response = Excon::Response.new
+          response.status = ret[0]
+          response.body = ret[1]
+          response
+        end
+
+        def startvnc(onevm_object, vnc)
+          vnc.proxy(onevm_object)
+        end
+
+      end
+
+    end
+
+  end
+
+end