ocp_registry 0.0.1.alpha

data/lib/ocp_registry/application_manager.rb

@@ -0,0 +1,213 @@
+
+module Ocp::Registry
+
+	class ApplicationManager
+
+		def initialize(cloud_manager,mail_manager)
+			@cloud_manager = cloud_manager
+			@mail_manager = mail_manager
+			@logger = Ocp::Registry.logger
+		end
+
+		def list(email=nil)
+			if email
+				results = Ocp::Registry::Models::RegistryApplication.reverse_order(:created_at).where(:email => email)
+			else
+				results = Ocp::Registry::Models::RegistryApplication.reverse_order(:created_at).all
+			end
+		
+			results
+		end
+
+		def show(app_id)
+			app_info = get_application(app_id)
+			return {:status => "error", :message => "Application with id - [#{app_id}] is not existed"} if app_info.nil?
+			app_info
+		end
+
+		def default 
+			@default ||= {
+				:email => "" ,
+				:project => "" ,
+				:description => "" ,
+				:settings => Yajl::Encoder.encode(@cloud_manager.default_quota)
+			}
+		end
+
+		def approve(app_id)
+			app_info = get_application(app_id)
+
+			return {:status => "error", :message => "Application with id - [#{app_id}] is not existed"} if app_info.nil?
+
+			return {:status => "error", :message => "Application [#{app_info.project}] - [#{app_id}] has been #{app_info.state}"} unless app_info.state == 'PENDING'
+
+			unless existed_tenant?(app_info.project, :find_local => false) then
+				# create project tenant and user
+				tenant = @cloud_manager.create_tenant(app_info.project, app_info.description)
+
+				@logger.info("Project [#{tenant.name}] - [#{tenant.id}] has been created with detailed json - #{tenant.to_json}")
+
+				username = Ocp::Registry::Common.parse_email(app_info.email)[:name]
+
+				user = @cloud_manager.find_user_by_name(username)
+
+				if user.nil?
+					password = Ocp::Registry::Common.gen_password
+					user = @cloud_manager.create_user(username, tenant.id, password, app_info.email)
+					@logger.info("User [#{user.name}] - [#{user.id}] has been created with detailed json - #{user.to_json}")
+				else
+					password = "<your-password-in-other-project>"
+					@logger.info("Using existed User [#{user.name}] - [#{user.id}] with detailed json - #{user.to_json}")
+				end
+
+				role = @cloud_manager.default_role
+
+				@cloud_manager.tenant_add_user_with_role(tenant, user.id, role.id)
+
+				@logger.info("User [#{user.name}] - [#{user.id}] has been added into project [#{tenant.name}] - [#{tenant.id}] as [#{role.name}] - [#{role.id}]")
+
+				#assign quota to project
+
+				settings = @cloud_manager.set_tenant_quota(tenant.id, Yajl.load(app_info.settings))
+
+				Ocp::Registry::Models::RegistryApplication.where(:id => app_id)
+																									.update(:state => 'APPROVED',
+					                                                :updated_at => Time.now.utc.to_s,
+					                                                :settings => Yajl::Encoder.encode(settings) )
+				app_info = get_application(app_id)
+				if @mail_manager
+					admin_msg = {
+						:app_info => app_info , 
+						:application_link => gen_app_uri(app_id, :review => true) ,
+						:applications_link => gen_app_uri
+					}
+					mail = prepare_mail_properties(:approve_admin, @mail_manager.admin_emails, admin_msg)
+					@mail_manager.send_mail(mail)
+					user_msg = {
+						:app_info => app_info ,
+						:application_link => gen_app_uri(app_id) ,
+						:applications_link => gen_app_uri(nil, :email => app_info.email) ,
+						:login => Ocp::Registry.cloud_login_url ,
+						:username => username ,
+						:password => password
+					}
+					mail = prepare_mail_properties(:approve_user, app_info.email, user_msg)
+					@mail_manager.send_mail(mail)
+				end
+				app_info
+			else
+				@logger.info("Project [#{app_info.project}] name has been used during request time")
+				refuse(app_info.id,"Project Name [#{app_info.project}] has been used during request time")
+			end
+
+		end
+
+		def refuse(app_id,comments)
+			app_info = get_application(app_id)
+			return {:status => "error", :message => "Application with id - [#{app_id}] is not existed"} if app_info.nil?
+			return {:status => "error", :message => "Application [#{app_info.project}] - #{app_id} has been #{app_info.state}"} unless app_info.state == 'PENDING'
+
+			comments ||= "no comments"
+			Ocp::Registry::Models::RegistryApplication.where(:id => app_id)
+																								.update(:state => 'REFUSED',
+																												:updated_at => Time.now.utc.to_s,
+																												:comments => comments)
+			app_info = get_application(app_id)
+
+			if @mail_manager
+				admin_msg = {
+					:app_info => app_info , 
+					:application_link => gen_app_uri(app_id, :review => true) ,
+					:applications_link => gen_app_uri
+				}
+				mail = prepare_mail_properties(:refuse_admin, @mail_manager.admin_emails, admin_msg)
+				@mail_manager.send_mail(mail)
+				user_msg = {
+					:app_info => app_info , 
+					:application_link => gen_app_uri(app_id) ,
+					:applications_link => gen_app_uri(nil, :email => app_info.email) 
+				}
+				mail = prepare_mail_properties(:refuse_user, app_info.email, user_msg)
+				@mail_manager.send_mail(mail)
+			end
+			app_info
+		end
+
+		def create(app_info)
+			if existed_tenant?(app_info['project'])
+				{:status => "error", :message => "Project name [#{app_info['project']}] has been used"}
+			else
+		 		result = Ocp::Registry::Models::RegistryApplication.create(app_info)
+				if @mail_manager
+					admin_msg = {
+						:app_info => result , 
+						:application_link => gen_app_uri(result.id, :review => true) ,
+						:applications_link => gen_app_uri 
+					}
+					mail = prepare_mail_properties(:request_admin, @mail_manager.admin_emails, admin_msg)
+					@mail_manager.send_mail(mail)
+					user_msg = {
+						:app_info => result ,
+						:application_link => gen_app_uri(result.id) ,
+						:applications_link => gen_app_uri(nil, :email => result.email) 
+					}
+					mail = prepare_mail_properties(:request_user, result.email, user_msg)
+					@mail_manager.send_mail(mail)
+				end
+				result
+			end
+		end
+
+		def existed_tenant?(tenant, find_local = true)
+			if find_local
+				local_existed = Ocp::Registry::Models::RegistryApplication.where(:project => tenant, :state => 'APPROVED')
+																																	.count == 0? false : true
+				return true if local_existed
+			end
+		  remote_existed = @cloud_manager.get_tenant_by_name(tenant)? true : false
+		  if remote_existed
+		  	return true
+		  else
+		  	return false
+		  end
+		end
+
+		private 
+
+		def get_application(app_id)
+			Ocp::Registry::Models::RegistryApplication[:id => app_id]
+		end
+
+		def prepare_mail_properties(template, to, msg = {})
+			{
+				:to => to ,
+				:template => template.to_s ,
+				:msg => msg
+			}
+		end
+
+		def gen_app_uri(app_id = nil, querys = nil)
+			host = URI::escape(Ocp::Registry.base_url)
+			port = Ocp::Registry.http_port
+			path = "/v1/applications"
+			if app_id
+				path += URI::escape("/#{app_id}")
+			end
+			query = nil
+			if(querys && querys.is_a?(Hash))
+				querys.each do |key, value|
+					if query.nil?
+						query = "#{key.to_s}=#{value}"
+					else
+						query += "&" 
+						query += "#{key.to_s}=#{value}"
+					end
+				end
+			end
+
+			uri = URI::HTTP.build(:host => host, :port => port, :path => path, :query => query).to_s
+		end
+
+	end
+
+end

data/lib/ocp_registry/cloud_manager/mock.rb

@@ -0,0 +1,5 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+$:.unshift(File.dirname(__FILE__))
+
+require "mock/model"
+require 'mock/mock'

data/lib/ocp_registry/cloud_manager/mock/mock.rb

@@ -0,0 +1,191 @@
+module Ocp::Registry
+	  class CloudManager
+
+    class Mock < CloudManager 
+    	def initialize(cloud_config)
+        validate_options(cloud_config)
+
+        @logger = Ocp::Registry.logger
+
+        @mock_properties = cloud_config["mock"]
+
+        unless @mock_properties["auth_url"].match(/\/tokens$/)
+          @mock_properties["auth_url"] = @mock_properties["auth_url"] + "/tokens"
+        end
+
+        @mock_options = {
+          :provider => "mock",
+          :mock_auth_url => @mock_properties["auth_url"],
+          :mock_username => @mock_properties["username"],
+          :mock_api_key => @mock_properties["api_key"],
+          :mock_tenant => @mock_properties["tenant"],
+          :mock_endpoint_type => @mock_properties["endpoint_type"]
+        }
+        @default_role_name =  cloud_config["default_role"]
+      end
+
+      def validate_options(cloud_config)
+        unless cloud_config.has_key?("mock") &&
+            cloud_config["mock"].is_a?(Hash) &&
+            cloud_config["mock"]["auth_url"] &&
+            cloud_config["mock"]["username"] &&
+            cloud_config["mock"]["api_key"] &&
+            cloud_config["mock"]["tenant"] &&
+            cloud_config["default_role"]
+          raise ConfigError, "Invalid mock configuration parameters"
+        end
+      end
+
+      def default_compute_quota
+      	{
+          "injected_file_content_bytes"=>10240, 
+          "metadata_items"=>128, 
+          "ram"=>51200, 
+          "floating_ips"=>10, 
+          "key_pairs"=>100, 
+          "id"=>"defaults", 
+          "instances"=>10, 
+          "security_group_rules"=>20, 
+          "injected_files"=>5, 
+          "cores"=>20, 
+          "fixed_ips"=>-1, 
+          "injected_file_path_bytes"=>255, 
+          "security_groups"=>10
+        }
+      end
+
+      def default_volume_quota
+      	{
+          "gigabytes"=>1000, 
+          "volumes"=>10, 
+          "id"=>"defaults", 
+          "snapshots"=>10
+        }
+      end
+
+      def default_quota
+        return @default_quota if @default_quota
+        compute_quota = default_compute_quota
+        volume_quota = default_volume_quota
+        @default_quota = compute_quota.merge (volume_quota)
+        cloud_error "Default Quota is not found" unless @default_quota
+        @default_quota
+      end
+
+      def get_role_by_name(name)
+      	role = {
+                  :id => "08bc68483a804ee59f4290256a8003c6",
+                  :name => name
+              	}
+        Model.new role
+      end
+
+      def default_role
+        return @default_role if @default_role
+        @default_role ||= get_role_by_name(@default_role_name)
+        cloud_error "Default Role [#{cloud_config["default_role"]}] is not found" unless @default_role
+        @logger.info("Default Role #{@default_role.name} - #{@default_role.id}")
+        @default_role
+      end 
+
+      def set_tenant_quota(tenant_id, settings={})
+        result = nil
+        compute_quota = set_compute_quota(tenant_id, settings)
+        volume_quota = set_volume_quota(tenant_id, settings)
+        result =  compute_quota.merge (volume_quota) if (compute_quota && volume_quota)
+        cloud_error "Quota for #{tenant_id} has not been set" unless result
+        result
+      end
+
+
+      def cloud_error(message, exception = nil)
+        @logger.error(message) if @logger
+        @logger.error(exception) if @logger && exception
+        raise Ocp::Registry::CloudError, message
+      end
+
+			CINDER_QUOTA_FIELDS = ["volumes", "snapshots", "gigabytes"]
+
+
+			def set_volume_quota(tenant_id, hash)
+				settings = Ocp::Registry::Common.hash_filter(hash, CINDER_QUOTA_FIELDS)
+        {
+          "gigabytes"=>1000, 
+          "volumes"=>10, 
+          "id"=>"defaults", 
+          "snapshots"=>10
+        }.merge settings
+			end
+
+			def create_tenant(name, description, enabled = true)
+      tenant = {
+        :name => "your project name",
+        :description => "your project description",
+        :enabled => true,
+        :id => "1bb0fed1c2df4b5faa19e7700c049e35"
+      }
+      Model.new tenant
+      end
+
+      def create_user(name, tenant_id, password, email = '')
+      user = {
+        :email => email,
+        :enabled => true,
+        :name => name,
+        :tenant_id => tenant_id, 
+        :password => password
+      }
+      Model.new user
+      end
+
+      def get_tenant_by_name(name)
+    	nil
+      end
+
+      def tenant_add_user_with_role(tenant, user_id, role_id)
+        true
+      end
+
+      def find_user_by_name(name)
+    	user = {
+        :email => "#{name}@email.com",
+        :enabled => true,
+        :name => name,
+        :tenant_id => "1bb0fed1c2df4b5faa19e7700c049e35",
+        :password => "passwordxxxxx"
+    	}
+      Model.new user
+      end
+
+			NOVA_QUOTA_FIELDS = ["metadata_items",
+			                     "cores",
+			                     "instances",
+			                     "injected_files",
+			                     "injected_file_content_bytes",
+			                     "ram",
+			                     "floating_ips",
+			                     "fixed_ips",
+			                     "security_groups",
+			                     "security_group_rules"]
+
+			def set_compute_quota(tenant_id, hash)
+				settings = Ocp::Registry::Common.hash_filter(hash, NOVA_QUOTA_FIELDS)
+        {
+          "injected_file_content_bytes"=>10240, 
+          "metadata_items"=>128, "ram"=>51200, 
+          "floating_ips"=>10, 
+          "key_pairs"=>100, 
+          "id"=>"defaults", 
+          "instances"=>10, 
+          "security_group_rules"=>20, 
+          "injected_files"=>5, 
+          "cores"=>20, 
+          "fixed_ips"=>-1, 
+          "injected_file_path_bytes"=>255, 
+          "security_groups"=>10
+        }.merge settings
+			end
+
+    end
+  end
+end

data/lib/ocp_registry/cloud_manager/mock/model.rb

@@ -0,0 +1,22 @@
+module Ocp::Registry
+	class CloudManager
+
+    class Mock < CloudManager 
+    	class Model
+	    	def initialize(properties)
+	    		if properties.is_a? (Hash)
+	    			@properties = properties
+	    		end
+	    	end
+
+	    	def method_missing(method, *args)
+	    		return @properties[method.to_sym]
+	    	end
+
+	    	def to_json
+	    		Yajl::Encoder.encode(@properties)
+	    	end
+    	end
+    end
+  end
+end

data/lib/ocp_registry/cloud_manager/openstack.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+$:.unshift(File.dirname(__FILE__))
+
+require 'openstack/openstack'

data/lib/ocp_registry/cloud_manager/openstack/cinder_helper.rb

@@ -0,0 +1,27 @@
+module Ocp::Registry
+
+	class CloudManager
+
+		class Openstack 
+
+			module CinderHelper
+				CINDER_QUOTA_FIELDS = ["volumes", "snapshots", "gigabytes"]
+
+				def default_volume_quota
+					with_openstack { volume.get_quota_defaults(nil).body["quota_set"] }
+				end
+
+				def set_volume_quota(tenant_id, hash)
+					with_openstack do 
+						settings = Ocp::Registry::Common.hash_filter(hash, CINDER_QUOTA_FIELDS)
+						volume.update_quota(tenant_id, settings).body["quota_set"]
+					end
+				end
+
+			end
+
+		end
+
+	end
+
+end