wakame-vdc-webui 10.11.0

data/app/controllers/storage_pools_controller.rb

@@ -0,0 +1,27 @@
+class StoragePoolsController < ApplicationController
+  respond_to :json
+  
+  def index
+  end
+  
+  def list
+    data = {
+      :start => params[:start].to_i - 1,
+      :limit => params[:limit]
+    }
+    strage_pools = DcmgrResource::StoragePool.list(data)
+    respond_with(strage_pools[0], :to => [:json])
+  end
+  
+  def show
+    storage_pool_id = params[:id]
+    detail = DcmgrResource::StoragePool.show(storage_pool_id)
+    respond_with(detail,:to => [:json])
+  end
+  
+  def show_storage_pools
+    storage_pools = DcmgrResource::StoragePool.list
+    respond_with(storage_pools[0],:to => [:json])
+  end
+  
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,3 @@
+class UsersController < ApplicationController
+  skip_before_filter :login_required
+end

data/app/controllers/volumes_controller.rb

@@ -0,0 +1,86 @@
+class VolumesController < ApplicationController
+  respond_to :json
+  include Util
+  
+  def index
+  end
+  
+  def create
+    snapshot_ids = params[:ids]
+    if snapshot_ids
+      response = []
+      snapshot_ids.each do |snapshot_id|
+        data = {
+          :snapshot_id => snapshot_id
+        }
+        response << DcmgrResource::Volume.create(data)
+      end
+      render :json => response
+    else
+      # Convert to MB
+      size = case params[:unit]
+             when 'gb'
+               params[:size].to_i * 1024
+             when 'tb'
+               params[:size].to_i * 1024 * 1024
+             end
+      
+      storage_pool_id = params[:storage_pool_id] #option
+      
+      data = {
+        :volume_size => size,
+        :storage_pool_id => storage_pool_id
+      }
+      
+      @volume = DcmgrResource::Volume.create(data)
+
+      render :json => @volume
+    end
+  end
+  
+  def destroy
+    volume_ids = params[:ids]
+    response = []
+    volume_ids.each do |volume_id|
+      response << DcmgrResource::Volume.destroy(volume_id)
+    end
+    render :json => response
+  end
+  
+  def list
+    data = {
+      :start => params[:start].to_i - 1,
+      :limit => params[:limit]
+    }
+    volumes = DcmgrResource::Volume.list(data)
+    respond_with(volumes[0],:to => [:json])
+  end
+  
+  # GET volumes/vol-24f1af4d.json
+  def show
+    volume_id = params[:id]
+    detail = DcmgrResource::Volume.show(volume_id)
+    respond_with(detail,:to => [:json])
+  end
+
+  def attach
+    volume_id = params[:volume_id]
+    instance_id = params[:instance_id]
+    response = DcmgrResource::Volume.attach(volume_id, instance_id)
+    render :json => response
+  end
+
+  def detach
+    volume_ids = params[:ids]
+    response = []
+    volume_ids.each do |volume_id|
+      response << DcmgrResource::Volume.detach(volume_id)
+    end
+    render :json => response
+  end
+  
+  def total
+    total_resource = DcmgrResource::Volume.total_resource
+    render :json => total_resource
+  end
+end

data/app/helpers/accounts_helper.rb

@@ -0,0 +1,2 @@
+module AccountsHelper
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,23 @@
+module ApplicationHelper
+  
+  def li_link_to_current(name, controller)
+    if current_page?(:controller => controller)
+      str = '<li class="current">' + link_to(name,controller) + '</li>'
+    else
+      str = '<li>' + link_to(name,controller) + '</li>'
+    end
+    str.html_safe
+  end
+  
+  def show_accounts
+    User.account_name_with_uuid(@current_user.uuid)
+  end
+  
+  def primary_account_id
+    User.primary_account_id(@current_user.uuid)
+  end
+
+  def nl2br(text)
+    text.gsub(/(<.*?>)/, '').gsub(/\n/, '<br />').html_safe
+  end
+end

data/app/helpers/dialog_helper.rb

@@ -0,0 +1,2 @@
+module DialogHelper
+end

data/app/helpers/home_helper.rb

@@ -0,0 +1,2 @@
+module HomeHelper
+end

data/app/helpers/host_pools_helper.rb

@@ -0,0 +1,2 @@
+module HostPoolsHelper
+end

data/app/helpers/images_helper.rb

@@ -0,0 +1,2 @@
+module ImagesHelper
+end

data/app/helpers/information_helper.rb

@@ -0,0 +1,2 @@
+module InformationHelper
+end

data/app/helpers/instances_helper.rb

@@ -0,0 +1,2 @@
+module InstancesHelper
+end

data/app/helpers/keypairs_helper.rb

@@ -0,0 +1,2 @@
+module KeypairsHelper
+end

data/app/helpers/security_groups_helper.rb

@@ -0,0 +1,2 @@
+module SecurityGroupsHelper
+end

data/app/helpers/sessions_helper.rb

@@ -0,0 +1,2 @@
+module SessionsHelper
+end

data/app/helpers/snapshots_helper.rb

@@ -0,0 +1,2 @@
+module SnapshotsHelper
+end

data/app/helpers/storage_pools_helper.rb

@@ -0,0 +1,2 @@
+module StoragePoolsHelper
+end

data/app/helpers/users_helper.rb

@@ -0,0 +1,2 @@
+module UsersHelper
+end

data/app/helpers/volumes_helper.rb

@@ -0,0 +1,2 @@
+module VolumesHelper
+end

data/app/models/account.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+class Account < BaseNew
+  taggable 'a'
+  with_timestamps
+  plugin :single_table_inheritance, :uuid, :model_map=>{}
+  plugin :subclasses
+
+  # pk has to be overwritten by the STI subclasses.
+  unrestrict_primary_key
+
+  DISABLED=0
+  ENABLED=1
+  
+  inheritable_schema do
+    primary_key :id, :type=>Integer
+    String :name
+    Boolean :enable, :default=>true
+    DateTime :deleted_at, :null=>true
+    Boolean :is_deleted, :default=>false
+  end
+
+  one_to_many  :tags
+  many_to_many :users,:join_table => :users_accounts
+  
+  def disable?
+    self.enabled == DISABLED
+  end
+
+  def enable?
+    self.enabled == ENABLED
+  end
+
+  def to_hash_document
+    h = self.values.dup
+    h[:id] = h[:uuid] = self.canonical_uuid
+    h
+  end
+
+
+  # STI class variable setter, getter methods.
+  class << self
+    def default_values
+      @default_values ||= {}
+    end
+
+    def pk(pk=nil)
+      if pk
+        default_values[:id] = pk
+      end
+      default_values[:id]
+    end
+    
+    def uuid(uuid=nil)
+      if uuid.is_a?(String)
+        uuid = uuid.downcase
+        if uuid !~ /^[a-z0-9]{8}$/
+          raise "Invalid syntax of uuid: #{uuid}"
+        end
+        default_values[:uuid] = uuid
+      end
+      default_values[:uuid] || raise("#{self}.uuid is unset. Set the unique number")
+    end
+
+    def description(description=nil)
+      if description
+        default_values[:description] = description
+      end
+      default_values[:description]
+    end
+  end
+
+  module SystemAccount
+    def self.define_account(class_name, &blk)
+      unless class_name.is_a?(Symbol) || class_name.is_a?(String)
+        raise ArgumentError
+      end
+
+      c = Class.new(Account, &blk)
+      self.const_set(class_name.to_sym, c)
+      Account.sti_model_map[c.uuid] = c
+      Account.sti_key_map[c.to_s] = c.uuid
+      c
+    end
+  end
+
+  install_data_hooks do
+    Account.subclasses.each { |m|
+      Account.create(m.default_values.dup)
+    }
+  end
+
+  SystemAccount.define_account(:DatacenterAccount) do
+    pk 100
+    uuid '00000000'
+    description 'datacenter system account'
+
+    # DatacenterAccount never be disabled
+    def before_save
+      super
+      self.enabled = Account::ENABLED
+    end
+  end
+  
+end

data/app/models/authz.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+class Authz < BaseNew
+  with_timestamps
+
+  inheritable_schema do
+    primary_key :id, :type=>Integer
+    Fixnum :user_id, :null => false
+    Fixnum :account_id, :null => false
+    Fixnum :type_id, :null => false
+  end
+  
+  class << self
+    def get_my_authz(user_id,account_id)
+      self.dataset.where(:user_id => user_id,:account_id => account_id).all
+    end
+  end
+end
+
+module Tags
+  class Authz < Tag
+    def self.define_authz(klass_name, &blk)
+      c = Class.new(Authz, &blk)
+      @authz_collections ||= {}
+      @authz_collections.store(c.type_id,klass_name)
+      self.const_set(klass_name.to_sym, c)
+    end
+    
+    def self.authz_collections
+      @authz_collections
+    end
+
+    def accept_mapping?(taggable_obj)
+      taggable_obj.is_a?(Models::User) && !taggable_obj.accounts_dataset.filter(:account_id=>self.account_id).empty?
+    end
+
+    def self.authz_evaluate?(authz_class)
+      unless authz_class < Authz
+        raise ArgumentError, "Can't compare the class does not have the root with #{self}"
+      end
+      authz_class == self
+    end
+
+    def after_initialize
+      super
+      # Set default name for the :name column.
+      self[:name] = self.class.to_s.sub(/^Tags::/, '')
+    end
+  end
+  
+  Authz.define_authz(:ModifyAccount) do
+    type_id 90001
+    description ' modify priviledg'
+    
+    def self.authz_evaluate?(authz_class)
+      super || [Authz::CreateAccount,Authz::DeleteAccount].any?{|klass| klass == authz_class}
+    end
+  end
+
+  Authz.define_authz(:CreateAccount) do
+    type_id 90002
+    description ''
+  end
+
+  Authz.define_authz(:DeleteAccount) do
+    type_id 90003
+    description ''
+  end
+
+  Authz.define_authz(:AccountAdministrator) do
+    type_id 90004
+    description ''
+  end
+
+  Authz.define_authz(:ModifyUser) do
+    type_id 90005
+    description ''
+  end
+
+  Authz.define_authz(:ViewUser) do
+    type_id 90006
+    description ''
+  end
+
+  Authz.define_authz(:UserAdministrator) do
+    type_id 90007
+    description ''
+  end
+  
+  Authz.define_authz(:AdminInstance) do
+    type_id 90008
+    description ''
+
+    def self.authz_evaluate?(authz_class)
+      super || [Authz::RunInstance].any?{|klass| klass == authz_class}
+    end
+  end
+  
+  Authz.define_authz(:RunInstance) do
+    type_id 90009
+    description ''
+  end
+end

data/app/models/base_new.rb

@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+require 'sequel/model'
+
+# Sequal::Model plugin to inject the Taggable feature to the model
+# class.
+#
+# Taggable model supports the features below:
+# - Taggable.uuid_prefix to both set and get uuid_prefix for the model.
+# - Collision detection for specified uuid_prefix.
+# - Generate unique value for :uuid column at initialization.
+# - Add column :uuid if the model is capable of :schema plugin methods.
+module Taggable
+  UUID_TABLE='abcdefghijklmnopqrstuvwxyz0123456789'.split('').freeze
+  UUID_REGEX=%r/^(\w+)-([#{UUID_TABLE.join}]+)/
+
+  class UUIDPrefixDuplication < StandardError; end
+
+  def self.uuid_prefix_collection
+    @uuid_prefix_collection ||= {}
+  end
+
+  # Find a taggable model object from the
+  # given canonical uuid.
+  #
+  # # Find an account.
+  # Taggble.find('a-xxxxxxxx')
+  #
+  # # Find a user.
+  # Taggble.find('u-xxxxxxxx')
+  def self.find(uuid)
+    raise ArgumentError, "Invalid uuid syntax: #{uuid}" unless uuid =~ UUID_REGEX
+    upc = uuid_prefix_collection[$1.downcase]
+    raise "Unknown uuid prefix: #{$1.downcase}" if upc.nil?
+    upc[:class].find(:uuid=>$2)
+  end
+
+  # Checks if the uuid object stored in the database.
+  def self.exists?(uuid)
+    !find(uuid).nil?
+  end
+
+  def self.configure(model)
+    model.schema_builders << proc {
+      unless has_column?(:uuid)
+        # add :uuid column with unique index constraint.
+        column(:uuid, String, :size=>8, :null=>false, :fixed=>true, :unique=>true)
+      end
+    }
+  end
+
+  module InstanceMethods
+    # read-only instance method to retrieve @uuid_prefix class
+    # variable.
+    def uuid_prefix
+      self.class.uuid_prefix
+    end
+  
+    def after_initialize
+      super
+      # set random generated uuid value
+      self[:uuid] ||= Array.new(8) do UUID_TABLE[rand(UUID_TABLE.size)]; end.join
+    end
+
+    # Returns canonicalized uuid which has the form of
+    # "{uuid_prefix}-{uuid}".
+    def canonical_uuid
+      "#{self.uuid_prefix}-#{self[:uuid]}"
+    end
+    alias_method :cuuid, :canonical_uuid
+
+    # Put the tag on the object.
+    #
+    # This method just delegates the method call of Tag#label().
+    # @params [Models::Tag,String] tag_or_tag_uuid 'tag-xxxx' is expected when the type is string
+    def label_tag(tag_or_tag_uuid)
+      tag = case tag_or_tag_uuid
+            when String
+              Tag[tag_or_tag_uuid]
+            when Tag
+              tag_or_tag_uuid
+            else
+              raise ArgumentError, "Invalid type: #{tag_or_tag_uuid.class}"
+            end
+    
+      tag.label(self.uuid)
+    end
+
+    # Remove the labeled tag from the object
+    #
+    # This method just delegates the method call of Tag#unlabel().
+    # @params [Models::Tag,String] tag_or_tag_uuid 'tag-xxxx' is expected when the type is string
+    def unlabel_tag(tag_or_tag_uuid)
+      tag = case tag_or_tag_uuid
+            when String
+              Tag[tag_or_tag_uuid]
+            when Tag
+              tag_or_tag_uuid
+            else
+              raise ArgumentError, "Invalid type: #{tag_or_tag_uuid.class}"
+            end
+
+      tag.unlabel(self.uuid)
+    end
+
+  end
+
+  module ClassMethods
+    # Getter and setter for uuid_prefix of the class.
+    #
+    # @example
+    #   class Model1 < Sequel::Model
+    #     plugin Taggable
+    #     uuid_prefix('m')
+    #   end
+    #   
+    #   Model1.uuid_prefix # == 'm'
+    #   Model1.new.canonical_uuid # == 'm-abcd1234'
+    def uuid_prefix(prefix=nil)
+      if prefix
+        raise UUIDPrefixDuplication, "Found collision for uuid_prefix key: #{prefix}" if Taggable.uuid_prefix_collection.has_key?(prefix)
+      
+        Taggable.uuid_prefix_collection[prefix]={:class=>self}
+        @uuid_prefix = prefix
+      end
+      @uuid_prefix || raise("uuid prefix is unset for:#{self}")
+    end
+
+
+    # Override Model.[] to add lookup by uuid.
+    #
+    # @example
+    #   Account['a-xxxxxx']
+    def [](*args)
+      if args.size == 1 and args[0].is_a? String
+        super(:uuid=>trim_uuid(args[0]))
+      else
+        super(*args)
+      end
+    end
+
+    # Returns the uuid string which is removed prefix part: /^(:?\w+)-/.
+    #
+    # @example
+    #   Account.trim_uuid('a-abcd1234') # = 'abcd1234'
+    # @example Will get InvalidUUIDError as the uuid with invalid prefix has been tried.
+    #   Account.trim_uuid('u-abcd1234') # 'u-' prefix is for User model.
+    def trim_uuid(p_uuid)
+      regex = %r/^#{self.uuid_prefix}-/
+      if p_uuid and p_uuid =~ regex
+        return p_uuid.sub(regex, '')
+      end
+      raise InvalidUUIDError, "Invalid uuid or unsupported uuid: #{p_uuid} in #{self}"
+    end
+
+    # Checks the uuid syntax if it is for the Taggable class.
+    def check_uuid_format(uuid)
+      uuid =~ /^#{self.uuid_prefix}-/
+    end
+  end
+    
+end
+
+# Sequel::Model plugin extends :schema plugin to merge the column
+# definitions in its parent class.
+#
+# class Model1 < Sequel::Model
+#   plugin InheritableSchema
+#
+#   inheritable_schema do
+#     String :col1
+#   end
+# end
+#
+# class Model2 < Model1
+#   inheritable_schema do
+#     String :col2
+#   end
+# end
+#
+# Model2.create_table!
+# 
+# Then the schema for Model2 becomes as follows:
+#   primary_key :id, :type=>Integer, :unsigned=>true
+#   String :col1
+#   String :col2
+module InheritableSchema
+  def self.apply(model)
+    model.plugin :schema
+  end
+
+  module ClassMethods
+    def schema_builders
+      @schema_builders ||= []
+    end
+  
+    def inheritable_schema(&blk)
+      if blk
+        self.schema_builders << blk
+      
+        if @schema.nil?
+          # set_dataset(:tablename) in set_schema() force to overwrite
+          # dataset.row_proc to the standard one even if the
+          # dataset.row_proc is set something another. This becomes problem when
+          # another plugin needed to set its own row_proc.
+
+          # This is workaround to prevent from above.
+          row_proc = dataset.row_proc
+          set_schema(implicit_table_name) do
+            primary_key :id, :type=>Integer, :unsigned=>true
+          end
+          dataset.row_proc = row_proc if row_proc.is_a?(Proc)
+        end
+
+        builders = []
+        c = self
+        begin
+          builders << c.schema_builders if c.respond_to?(:schema_builders)
+        end while (c = c.superclass) < InheritableSchema
+
+        builders = builders.reverse.flatten
+        builders.delete(nil)
+        builders.each { |blk|
+          @schema.instance_eval(&blk)
+        }
+      end
+    end
+  end
+
+end
+
+class BaseNew < Sequel::Model
+
+  def self.Proxy(klass)
+    colnames = klass.schema.columns.map {|i| i[:name] }
+    colnames.delete_if(klass.primary_key) if klass.restrict_primary_key?
+    s = ::Struct.new(*colnames) do
+      def to_hash
+        n = {}
+        self.each_pair { |k,v|
+          n[k.to_sym]=v
+        }
+        n
+      end
+    end
+    s
+  end
+
+
+  # Callback when the initial data is setup to the database.
+  def self.install_data
+    install_data_hooks.each{|h| h.call }
+  end
+
+  # Add callbacks to setup the initial data. The hooks will be
+  # called when Model1.install_data() is called.
+  # 
+  # class Model1 < Base
+  #   install_data_hooks do
+  #     Model1.create({:col1=>1, :col2=>2})
+  #   end
+  # end
+  def self.install_data_hooks(&blk)
+    @install_data_hooks ||= []
+    if blk
+      @install_data_hooks << blk
+    end
+    @install_data_hooks
+  end
+
+
+  private
+  def self.inherited(klass)
+    super
+
+    klass.plugin InheritableSchema
+    klass.class_eval {
+
+      # Add timestamp columns and set callbacks using Timestamps
+      # plugin.
+      #
+      # class Model1 < Base
+      #   with_timestamps
+      # end
+      def self.with_timestamps
+        self.schema_builders << proc {
+          unless has_column?(:created_at)
+            column(:created_at, Time, :null=>false)
+          end
+          unless has_column?(:updated_at)
+            column(:updated_at, Time, :null=>false)
+          end
+        }
+      
+        self.plugin :timestamps, :update_on_create=>true
+      end
+
+      # Install Taggable module as Sequel plugin and set uuid_prefix.
+      # 
+      # class Model1 < Base
+      #   taggable 'm'
+      # end
+      def self.taggable(uuid_prefix)
+        return if self == BaseNew
+        self.plugin Taggable
+        self.uuid_prefix(uuid_prefix)
+      end
+
+    }
+  
+  end
+end