wakame-vdc-agents 10.11.0

data/lib/dcmgr/node_modules/sta_collector.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+require 'isono'
+
+module Dcmgr
+  module NodeModules
+    class StaCollector < Isono::NodeModules::Base
+      
+      initialize_hook do
+        app = Isono::Rack::ObjectMethod.new(myinstance)
+        rpc = Isono::NodeModules::RpcChannel.new(node)
+        rpc.register_endpoint('sta-collector', Isono::Rack.build do
+                                use Isono::Rack::DataStore
+                                run proc { |req, res|
+                                  Thread.current[Models::BaseNew::LOCK_TABLES_KEY] = {}
+                                  app.call(req, res)
+                                }
+                              end)
+      end
+
+      terminate_hook do
+      end
+
+      def get_volume(volume_id)
+        Models::Volume.lock!
+        v = Dcmgr::Models::Volume[volume_id]
+        v.merge_pool_data
+      end
+
+      def get_snapshot(snapshot_id)
+        Models::VolumeSnapshot.lock!
+        vs = Dcmgr::Models::VolumeSnapshot[snapshot_id]
+        vs.to_hash_document
+      end
+
+      def update_volume(data)
+        Models::Volume.lock!
+        v = Dcmgr::Models::Volume[data[:volume_id]]
+
+        column = case data[:state]
+                 when :creating
+                   [:state, :export_path]
+                 when :available
+                   if !data[:transport_information].nil?
+                     [:state, :transport_information]
+                   else
+                     [:state, :host_device_name, :instance_id, :detached_at]
+                   end
+                 when :attaching
+                   [:state, :host_device_name]
+                 when :attached
+                   [:state, :guest_device_name, :attached_at]
+                 when :detaching
+                   [:state, :guest_device_name]
+                 else
+                   [:state]
+                 end
+
+        v.set_fields(data, column).save
+        # do not respond model object.
+        nil
+      end
+
+      def update_snapshot(data)
+        Models::VolumeSnapshot.lock!
+        vs = Dcmgr::Models::VolumeSnapshot[data[:snapshot_id]]
+        vs.set_fields(data, [:state]).save
+        # do not respond model object.
+        nil
+      end
+    end
+  end
+end

data/lib/dcmgr/scheduler.rb

@@ -0,0 +1,12 @@
+
+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'
+  end
+end

data/lib/dcmgr/scheduler/find_last.rb

@@ -0,0 +1,16 @@
+
+module Dcmgr
+  module PhysicalHostScheduler
+    # This is a simple host scheduler which gets back a host found
+    # at the top of hosts list.
+    class FindLast
+      def assign_to_instance(hosts, instance)
+        Dcmgr::logger.debug "assign to instance (%d hosts)" % hosts.length
+p 'hosts'
+p hosts
+        return hosts.last
+        raise NoPhysicalHostError.new("can't assign physical host")
+      end
+    end
+  end
+end

data/lib/dcmgr/scheduler/find_random.rb

@@ -0,0 +1,16 @@
+
+module Dcmgr
+  module PhysicalHostScheduler
+    # This is a simple host scheduler which gets back a host found
+    # at the top of hosts list.
+    class FindRandom
+      def assign_to_instance(hosts, instance)
+        Dcmgr::logger.debug "assign to instance (%d hosts)" % hosts.length
+        hvc_host = hosts[ rand(hosts.length) ]
+p 'hvc_host'
+p hvc_host
+        raise NoPhysicalHostError.new("can't assign physical host")
+      end
+    end
+  end
+end

data/lib/dcmgr/stm/instance.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+require 'statemachine'
+
+module Dcmgr::Stm
+  class Instance
+    STM = Statemachine.build {
+      startstate :pending
+      superstate :instance_condition do
+        trans :pending, :on_create, :starting
+        trans :starting, :on_started, :running
+        trans :running, :on_shutdown, :shuttingdown
+        trans :shuttingdown, :on_terminated, :terminated
+        
+        event :on_fail, :failed
+      end
+      
+      trans :failed, :on_fail, :failed
+    }
+    
+    def initialize
+    end
+    
+  end
+end

data/lib/dcmgr/stm/snapshot_context.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+require 'statemachine'
+
+module Dcmgr::Stm
+  class SnapshotContext < OpenStruct
+
+    attr_reader :stm
+
+    def initialize(snapshot_id=nil)
+      super({:snapshot_id=>snapshot_id})
+      @stm = Statemachine.build {
+        trans :registering, :on_create, :creating
+        trans :creating, :on_create, :available
+        trans :available, :on_delete, :deleting
+        trans :deleting, :on_delete, :deleted
+
+        trans :registering, :on_fail, :failed
+        trans :creating, :on_fail, :failed
+        trans :available, :on_fail, :failed
+        trans :deleting, :on_fail, :failed
+      }
+      @stm.context = self
+    end
+
+    def state
+      @stm.state
+    end
+
+    def to_hash
+      @table.dup.merge({:state=>@stm.state})
+    end
+  end
+end

data/lib/dcmgr/stm/volume_context.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+require 'statemachine'
+
+module Dcmgr::Stm
+  class VolumeContext < OpenStruct
+    attr_reader :stm
+
+    def initialize(volume_id=nil)
+      super({:volume_id => volume_id,
+              :export_path => nil,
+              :transport_information => nil,
+              :instance_id => nil,
+              :host_device_name => nil,
+              :guest_device_name => nil,
+              :deleted_at => nil,
+              :attached_at => nil,
+              :detached_at => nil,
+            })
+      @stm = Statemachine.build {
+        startstate :registering
+        superstate :volume_condition do
+          trans :registering, :on_create, :creating
+          trans :creating, :on_register, :available
+          trans :available, :on_attach, :attaching
+          trans :attaching, :on_attach, :attached
+          trans :attached, :on_detach, :detaching
+          trans :detaching, :on_detach, :available
+
+          event :on_fail, :failed
+          event :on_deregister, :deregistering
+        end
+
+        trans :failed, :on_create, :creating
+        trans :failed, :on_register, :available
+        trans :failed, :on_fail, :failed
+        trans :failed, :on_deregister, :deleting
+        trans :failed, :on_delete, :deleted
+        trans :deregistering, :on_delete, :deleting
+        trans :deleting, :on_delete, :deleted
+        trans :deleted, :on_delete, :deleted
+      }
+      @stm.context = self
+    end
+
+    def state
+      @stm.state
+    end
+    
+    def to_hash(hash={})
+      @table.dup.merge({:state=>@stm.state}).merge(hash)
+    end
+
+    def on_delete
+      self.deleted_at = Time.now
+    end
+
+    def on_attach
+      self.attached_at = Time.now
+    end
+
+    def on_detach
+      self.detached_at = Time.now
+    end
+  end
+end

data/lib/dcmgr/web/base.rb

@@ -0,0 +1,21 @@
+require 'sinatra'
+require 'sequel'
+
+module Dcmgr::Web
+  class Base < Sinatra::Base
+    set :logger, false
+    helpers { include Dcmgr::Helpers }
+    
+    def self.public_crud model
+      model.actions {|action, pattern, proc|
+        Dcmgr::logger.debug "REGISTER: %s %s" % [action, pattern]
+        self.send action, pattern, &proc
+      }
+    end
+
+    not_found do
+      logger.debug "not found: #{request.request_method} #{request.path}"
+      "not found"
+    end
+  end
+end

data/lib/sinatra/accept_media_types.rb

@@ -0,0 +1,128 @@
+module Rack
+  class Request
+    # The media types of the HTTP_ACCEPT header ordered according to their
+    # "quality" (preference level), without any media type parameters.
+    #
+    # ===== Examples
+    #
+    #   env['HTTP_ACCEPT']  #=> 'application/xml;q=0.8,text/html,text/plain;q=0.9'
+    #
+    #   req = Rack::Request.new(env)
+    #   req.accept_media_types          #=> ['text/html', 'text/plain', 'application/xml']
+    #   req.accept_media_types.prefered #=>  'text/html'
+    #
+    # For more information, see:
+    # * Acept header:   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+    # * Quality values: http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.9
+    #
+    # ===== Returns
+    # AcceptMediaTypes:: ordered list of accept header's media types
+    #
+    def accept_media_types
+       @accept_media_types ||= Rack::AcceptMediaTypes.new(@env['HTTP_ACCEPT'])
+    end
+  end
+
+  # AcceptMediaTypes is intended for wrapping env['HTTP_ACCEPT'].
+  #
+  # It allows ordering of its values (accepted media types) according to their
+  # "quality" (preference level).
+  #
+  # This wrapper is typically used to determine the request's prefered media
+  # type (see example below).
+  #
+  # ===== Examples
+  #
+  #   env['HTTP_ACCEPT']  #=> 'application/xml;q=0.8,text/html,text/plain;q=0.9'
+  #
+  #   types = Rack::AcceptMediaTypes.new(env['HTTP_ACCEPT'])
+  #   types               #=> ['text/html', 'text/plain', 'application/xml']
+  #   types.prefered      #=>  'text/html'
+  #
+  # ===== Notes
+  #
+  # For simplicity, media type parameters are striped, as they are seldom used
+  # in practice. Users who need them are excepted to parse the Accept header
+  # manually.
+  #
+  # ===== References
+  #
+  # HTTP 1.1 Specs:
+  # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+  # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.9
+  #
+  class AcceptMediaTypes < Array
+
+    #--
+    # NOTE
+    # Reason for special handling of nil accept header:
+    #
+    # "If no Accept header field is present, then it is assumed that the client
+    # accepts all media types."
+    #
+    def initialize(header)
+      if header.nil?
+        replace(['*/*'])
+      else
+        replace(order(header.gsub(/ /, '').split(/,/)))
+      end
+    end
+
+    # The client's prefered media type.
+    def prefered
+      first
+    end
+
+    private
+
+    # Order media types by quality values, remove invalid types, and return media ranges.
+    #
+    def order(types) #:nodoc:
+      types.map {|type| AcceptMediaType.new(type) }.reverse.sort.reverse.select {|type| type.valid? }.map {|type| type.range }
+    end
+
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+    #
+    class AcceptMediaType #:nodoc:
+      include Comparable
+
+      # media-range = ( "*/*"
+      #               | ( type "/" "*" )
+      #               | ( type "/" subtype )
+      #               ) *( ";" parameter )
+      attr_accessor :range
+
+      # qvalue = ( "0" [ "." 0*3DIGIT ] )
+      #        | ( "1" [ "." 0*3("0") ] )
+      attr_accessor :quality
+
+      def initialize(type)
+        self.range, *params = type.split(';')
+        self.quality = extract_quality(params)
+      end
+
+      def <=>(type)
+        self.quality <=> type.quality
+      end
+
+      # "A weight is normalized to a real number in the range 0 through 1,
+      # where 0 is the minimum and 1 the maximum value. If a parameter has a
+      # quality value of 0, then content with this parameter is `not
+      # acceptable' for the client."
+      #
+      def valid?
+        self.quality.between?(0.1, 1)
+      end
+
+      private
+        # Extract value from 'q=FLOAT' parameter if present, otherwise assume 1
+        #
+        # "The default value is q=1."
+        #
+        def extract_quality(params)
+          q = params.detect {|p| p.match(/q=\d\.?\d{0,3}/) }
+          q ? q.split('=').last.to_f : 1.0
+        end
+    end
+  end
+end

data/lib/sinatra/lazy_auth.rb

@@ -0,0 +1,56 @@
+require 'sinatra/base'
+
+# Lazy Basic HTTP authentication. Authentication is only forced when the
+# credentials are actually needed.
+module Sinatra
+  module LazyAuth
+    class LazyCredentials
+      def initialize(app)
+        @app = app
+        @provided = false
+      end
+
+      def user
+        credentials!
+        @user
+      end
+
+      def password
+        credentials!
+        @password
+      end
+
+      def provided?
+        @provided
+      end
+
+      private
+      def credentials!
+        unless provided?
+          auth = Rack::Auth::Basic::Request.new(@app.request.env)
+          unless auth.provided? && auth.basic? && auth.credentials
+            @app.authorize!
+          end
+          @user = auth.credentials[0]
+          @password = auth.credentials[1]
+          @provided = true
+        end
+      end
+
+    end
+
+    def authorize!
+      r = "#{DRIVER}-deltacloud@#{HOSTNAME}"
+      response['WWW-Authenticate'] = %(Basic realm="#{r}")
+      throw(:halt, [401, "Not authorized\n"])
+    end
+
+    # Request the current user's credentials. Actual credentials are only
+    # requested when an attempt is made to get the user name or password
+    def credentials
+      LazyCredentials.new(self)
+    end
+  end
+
+  helpers LazyAuth
+end