wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/lib/dcmgr/rpc/sta_handler.rb

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+require 'isono'
+require 'fileutils'
+
+module Dcmgr
+  module Rpc
+
+    class StaHandler < EndpointBuilder
+      include Dcmgr::Logger
+      include Dcmgr::Helpers::CliHelper
+
+      def select_backing_store
+        backing_store = @node.manifest.config.backing_store 
+        @backing_store = Dcmgr::Drivers::BackingStore.select_backing_store(backing_store)
+      end
+
+      def select_iscsi_target
+        iscsi_target = @node.manifest.config.iscsi_target
+        @iscsi_target = Dcmgr::Drivers::IscsiTarget.select_iscsi_target(iscsi_target, @node)
+      end
+
+      # Setup volume file from snapshot storage and register to
+      # sotrage target.
+      def setup_and_export_volume
+        snapshot_file = nil 
+        unless @volume[:snapshot_id].nil?
+          @snapshot = rpc.request('sta-collector', 'get_snapshot', @volume[:snapshot_id])
+          raise "Invalid snapshot state: #{@snapshot[:state]}" unless @snapshot[:state].to_s == 'available'
+          snap_filename = @destination[:filename] 
+          
+          begin
+            storage_service = Dcmgr::StorageService.new(@destination[:driver], {
+              :account_id => @snapshot[:account_id],
+              :access_key => @destination[:access_key], 
+              :secret_key => @destination[:secret_key],
+            })
+            snapshot_storage = storage_service.snapshot_storage(@destination[:bucket], @destination[:path]) 
+            snapshot_storage.download(snap_filename)
+            snapshot_file = snapshot_storage.snapshot(snap_filename)
+            logger.info("download to #{@destination[:driver]}: #{snap_filename}")
+          rescue => e
+            logger.error(e)
+            raise "snapshot not downloaded"
+          end
+        end
+
+        logger.info("creating new volume #{@volume_id}")
+
+        rpc.request('sta-collector', 'update_volume', @volume_id, {:state=>:creating, :export_path=>@volume[:uuid]})
+
+        select_backing_store
+        @backing_store.create_volume(StaContext.new(self), snapshot_file)
+        
+        unless @volume[:snapshot_id].nil?
+          snapshot_storage.clear
+        end
+
+        select_iscsi_target
+        opt = @iscsi_target.create(StaContext.new(self))
+        rpc.request('sta-collector', 'update_volume', @volume_id, {:state=>:available, :transport_information=>opt})
+        logger.info("registered iscsi target: #{@volume_id}")
+      end
+
+      job :create_volume, proc {
+        @volume_id = request.args[0]
+        @destination = Dcmgr::StorageService.repository(request.args[1])
+        @volume = rpc.request('sta-collector', 'get_volume', @volume_id)
+        raise "Invalid volume state: #{@volume[:state]}" unless @volume[:state].to_s == 'pending'
+
+        setup_and_export_volume
+      }, proc {
+        # TODO: need to clear generated temp files or remote files in remote snapshot repository.
+        rpc.request('sta-collector', 'update_volume', @volume_id, {:state=>:deleted, :deleted_at=>Time.now.utc})
+        logger.error("Failed to run create_volume: #{@volume_id}")
+      }
+
+      # create volume and chain to run instance.
+      job :create_volume_and_run_instance, proc {
+        @volume_id = request.args[0]
+        @instance_id = request.args[1]
+        @destination = Dcmgr::StorageService.repository(request.args[2])
+
+        @volume = rpc.request('sta-collector', 'get_volume', @volume_id)
+        raise "Invalid volume state: #{@volume[:state]}" unless @volume[:state].to_s == 'pending'
+
+        setup_and_export_volume
+
+        @instance = rpc.request('hva-collector', 'get_instance', @instance_id)
+        jobreq.submit("hva-handle.#{@instance[:host_node][:node_id]}", 'run_vol_store', @instance_id, @volume_id)
+      }, proc {
+        # TODO: need to clear generated temp files or remote files in remote snapshot repository.
+        rpc.request('sta-collector', 'update_volume', @volume_id, {:state=>:deleted, :deleted_at=>Time.now.utc})
+        rpc.request('hva-collector', 'update_instance', @instance_id, {:state=>:terminated, :terminated_at=>Time.now.utc})
+        logger.error("Failed to run create_volume_and_run_instance: #{@instance_id}, #{@volume_id}")
+      }
+      
+      job :delete_volume do
+        @volume_id = request.args[0]
+        @volume = rpc.request('sta-collector', 'get_volume', @volume_id)
+        logger.info("#{@volume_id}: start deleting volume.")
+        errcount = 0
+        if @volume[:state].to_s == 'deleted'
+          raise "#{@volume_id}: Invalid volume state: deleted"
+        end
+        if @volume[:state].to_s != 'deregistering'
+          logger.warn("#{@volume_id}: Unexpected volume state but try destroy resource: #{@volume[:state]}")
+        end
+
+        # deregisterd iscsi target
+        select_iscsi_target
+        begin
+          @iscsi_target.delete(StaContext.new(self))
+        rescue => e
+          logger.error("#{@volume_id}: Failed to delete ISCSI target entry.")
+          errcount += 1
+        end
+
+        rpc.request('sta-collector', 'update_volume', @volume_id, {:state=>:deleting})
+
+        # delete volume
+        select_backing_store
+        begin
+          @backing_store.delete_volume(StaContext.new(self))
+        rescue => e
+          logger.error("#{@volume_id}: Failed to delete zfs volume: #{@volume[:storage_node][:export_path]}/#{@volume[:uuid]}")
+          errcount += 1
+        end
+
+        rpc.request('sta-collector', 'update_volume', @volume_id, {:state=>:deleted, :deleted_at=>Time.now.utc})
+        if errcount > 0
+          logger.info("#{@volume_id}: Encountered one or more errors during deleting.")
+        else
+          logger.info("#{@volume_id}: Deleted volume successfully.")
+        end
+      end
+
+      job :create_snapshot, proc {
+        @snapshot_id = request.args[0]
+        @destination = Dcmgr::StorageService.repository(request.args[1])
+        @snapshot = rpc.request('sta-collector', 'get_snapshot', @snapshot_id) unless @snapshot_id.nil?
+        @volume = rpc.request('sta-collector', 'get_volume', @snapshot[:origin_volume_id])
+
+        logger.info("create new snapshot: #{@snapshot_id}")
+        raise "Invalid volume state: #{@volume[:state]}" unless %w(available attached).member?(@volume[:state].to_s)
+        
+        begin 
+          storage_service = Dcmgr::StorageService.new(@destination[:driver], {
+            :account_id => @snapshot[:account_id],
+            :access_key => @destination[:access_key], 
+            :secret_key => @destination[:secret_key],
+          })
+          snapshot_storage = storage_service.snapshot_storage(@destination[:bucket], @destination[:path])
+          select_backing_store
+          
+          snap_filename = @destination[:filename] 
+          @backing_store.create_snapshot(StaContext.new(self), snapshot_storage.snapshot(snap_filename))
+       
+          snapshot_storage.upload(snap_filename)
+          snapshot_storage.clear
+          logger.info("upload to #{@destination[:driver]}: #{snap_filename}")
+        rescue => e
+          logger.error(e)
+          raise "snapshot has not be uploaded"
+        end
+        
+        rpc.request('sta-collector', 'update_snapshot', @snapshot_id, {:state=>:available})
+        logger.info("created new snapshot: #{@snapshot_id}")
+      }, proc {
+        # TODO: need to clear generated temp files or remote files in remote snapshot repository.
+        rpc.request('sta-collector', 'update_snapshot', @snapshot_id, {:state=>:deleted, :deleted_at=>Time.now.utc})
+        logger.error("Failed to run create_snapshot: #{@snapshot_id}")
+      }
+
+      job :delete_snapshot do
+        @snapshot_id = request.args[0]
+        @destination = Dcmgr::StorageService.repository(request.args[1])
+        @snapshot = rpc.request('sta-collector', 'get_snapshot', @snapshot_id)
+        @volume = rpc.request('sta-collector', 'get_volume', @snapshot[:origin_volume_id])
+        logger.info("deleting snapshot: #{@snapshot_id}")
+        raise "Invalid snapshot state: #{@snapshot[:state]}" unless @snapshot[:state].to_s == 'deleting'
+        begin 
+          storage_service = Dcmgr::StorageService.new(@destination[:driver], {
+            :account_id => @snapshot[:account_id],
+            :access_key => @destination[:access_key], 
+            :secret_key => @destination[:secret_key],
+          })
+          snapshot_storage = storage_service.snapshot_storage(@destination[:bucket], @destination[:path])
+          snapshot_storage.delete(@destination[:filename])
+        rescue => e
+           logger.error(e)
+           raise "snapshot has not be deleted"
+        end
+ 
+        rpc.request('sta-collector', 'update_snapshot', @snapshot_id, {:state=>:deleted, :deleted_at=>Time.now.utc})
+        logger.info("deleted snapshot: #{@snapshot_id}")
+      end
+
+      def rpc
+        @rpc ||= Isono::NodeModules::RpcChannel.new(@node)
+      end
+
+      def jobreq
+        @jobreq ||= Isono::NodeModules::JobChannel.new(@node)
+      end
+
+      def event
+        @event ||= Isono::NodeModules::EventChannel.new(@node)
+      end
+    end
+
+    class StaContext
+
+      def initialize(stahandler)
+        raise "Invalid Class: #{stahandler}" unless stahandler.instance_of?(StaHandler)
+        @sta = stahandler
+      end
+
+      def volume_id
+        @sta.instance_variable_get(:@volume_id)
+      end
+
+      def snapshot_id
+        @sta.instance_variable_get(:@snapshot_id)
+      end
+
+      def destination
+        @sta.instance_variable_get(:@destination)
+      end
+
+      def volume
+        @sta.instance_variable_get(:@volume)
+      end
+
+      def snapshot
+        @sta.instance_variable_get(:@snapshot)
+      end
+      
+      def node
+        @sta.instance_variable_get(:@node)
+      end
+    end
+
+  end
+end

data/lib/dcmgr/scheduler.rb

@@ -1,12 +1,126 @@
+# -*- coding: utf-8 -*-
+
+require 'extlib/module'
+require 'configuration'
 
 module Dcmgr
-  module PhysicalHostScheduler
-    class NoPhysicalHostError < StandardError; end
-
-    autoload :Algorithm1, 'dcmgr/scheduler/algorithm1'
-    autoload :Algorithm2, 'dcmgr/scheduler/algorithm2'
-    autoload :FindFirst, 'dcmgr/scheduler/find_first'
-    autoload :FindLast, 'dcmgr/scheduler/find_last'
-    autoload :FindRandom, 'dcmgr/scheduler/find_random'
+  module Scheduler
+    class SchedulerError < StandardError; end
+    class HostNodeSchedulingError < SchedulerError; end
+    class StorageNodeSchedulingError < SchedulerError; end
+    class NetworkSchedulingError < SchedulerError; end
+
+    # Factory method for HostNode scheduler
+    def self.host_node()
+      c = scheduler_class(Dcmgr.conf.host_node_scheduler, ::Dcmgr::Scheduler::HostNode)
+      if Dcmgr.conf.host_node_scheduler.respond_to?(:options)
+        c.new(Dcmgr.conf.host_node_scheduler.options)
+      else
+        c.new
+      end
+    end
+
+    # Factory method for HostNode scheduler for HA
+    def self.host_node_ha()
+      c = scheduler_class(Dcmgr.conf.host_node_ha_scheduler, ::Dcmgr::Scheduler::HostNode)
+      if Dcmgr.conf.host_node_ha_scheduler.respond_to?(:options)
+        c.new(Dcmgr.conf.host_node_ha_scheduler.options)
+      else
+        c.new
+      end
+    end
+
+    # Factory method for StorageNode scheduler
+    def self.storage_node()
+      c = scheduler_class(Dcmgr.conf.storage_node_scheduler, ::Dcmgr::Scheduler::StorageNode)
+      if Dcmgr.conf.storage_node_scheduler.respond_to?(:options)
+        c.new(Dcmgr.conf.storage_node_scheduler.options)
+      else
+        c.new
+      end
+    end
+
+    # Factory method for Network scheduler
+    def self.network()
+      c = scheduler_class(Dcmgr.conf.network_scheduler, ::Dcmgr::Scheduler::Network)
+      if Dcmgr.conf.network_scheduler.respond_to?(:options)
+        c.new(Dcmgr.conf.network_scheduler.options)
+      else
+        c.new
+      end
+    end
+
+    # common scheduler class finder
+    def self.scheduler_class(input, namespace)
+      c = case input
+          when Symbol
+            namespace.const_get(input)
+          when ::Configuration
+            if input.respond_to?(:scheduler)
+              namespace.const_get(input.scheduler)
+            else
+              raise "Missing configuration key: scheduler"
+            end
+          else
+            raise "Unknown #{namespace.to_s} scheduler: #{input}"
+          end
+      raise TypeError unless c < Module.find_const("#{namespace.to_s}Scheduler")
+      c
+    end
+
+    # Allocate HostNode to Instance object.
+    class HostNodeScheduler
+      def initialize(options=nil)
+        @options = options
+      end
+
+      # @param Models::Instance instance
+      # @return Models::HostNode
+      def schedule(instance)
+        raise NotImplementedError
+      end
+    end
+
+    # Allocate StorageNode to Volume object.
+    class StorageNodeScheduler
+      def initialize(options=nil)
+        @options = options
+      end
+      
+      # @param Models::Volume volume
+      # @return nil
+      def schedule(volume)
+        if volume.snapshot_id
+          # use same same storage node if it is local snapshot.
+          if volume.snapshot.destination == 'local'
+            volume.storage_node = Models::StorageNode[volume.snapshot.storage_node_id]
+          else
+            schedule_node(volume)
+          end
+        else
+          schedule_node(volume)
+        end
+        raise StorageNodeSchedulingError if volume.storage_node.nil?
+      end
+
+      protected
+      def schedule_node(volume)
+        raise NotImplementedError
+      end
+    end
+
+    # Manage vnic for instances and assign network object.
+    class NetworkScheduler
+      def initialize(options=nil)
+        @options = options
+      end
+
+      # @param Models::HostNode host_node
+      # @return Models::Network
+      def schedule(instance)
+        raise NotImplementedError
+      end
+    end
+
   end
 end

data/lib/dcmgr/scheduler/host_node/exclude_same.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Scheduler
+    module HostNode
+
+      class ExcludeSame < HostNodeScheduler
+        include Dcmgr::Logger
+
+        def schedule(instance)
+          ds = Models::HostNode.online_nodes.filter(:arch=>instance.spec.arch,
+                                                    :hypervisor=>instance.spec.hypervisor)
+
+          host_node = ds.all.find_all { |hn|
+            hn.node_id != instance.host_node.node_id
+          }.first
+
+          raise HostNodeSchedulingError if host_node.nil?
+          instance.host_node = host_node
+        end
+      end
+    end
+  end
+end

data/lib/dcmgr/scheduler/host_node/find_first.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr; module Scheduler; module HostNode
+  class FindFirst < HostNodeScheduler
+
+    def schedule(instance)
+      host_node = Models::HostNode.first
+      raise HostNodeScheduleError if host_node.nil?
+      instance.host_node = host_node
+    end
+  end
+end; end; end

data/lib/dcmgr/scheduler/host_node/least_usage.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Scheduler
+    module HostNode
+
+      # Find host node which has the largest available capacity.
+      class LeastUsage < HostNodeScheduler
+        include Dcmgr::Logger
+
+        def schedule(instance)
+          ds = Models::HostNode.online_nodes.filter(:arch=>instance.spec.arch,
+                                                    :hypervisor=>instance.spec.hypervisor)
+
+          host_node = ds.all.find_all { |hn|
+            hn.available_cpu_cores >= instance.cpu_cores && \
+              hn.available_memory_size >= instance.memory_size
+          }.sort_by { |hn|
+            hn.available_memory_size
+          }.reverse.first
+
+          raise HostNodeSchedulingError if host_node.nil?
+          instance.host_node = host_node
+        end
+      end
+    end
+  end
+end

data/lib/dcmgr/scheduler/host_node/per_instance.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Scheduler
+    module HostNode
+      # Meta scheduler calls another scheduler specified by API.
+      class PerInstance < HostNodeScheduler
+        
+        def schedule(instance)
+          sched_name = instance.request_params[:host_node_scheduler]
+          
+          sched = Scheduler.scheduler_class(sched_name, ::Dcmgr::Scheduler::HostNode)
+          sched.schedule(instance)
+        end
+      end
+    end
+  end
+end