ocp_registry 0.0.1.alpha

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

@@ -0,0 +1,57 @@
+module Ocp::Registry
+
+	class CloudManager
+
+		class Openstack
+
+			module KeystoneHelper
+		 		#{ 
+	      #  "name": "ACME corp",
+	      #  "description": "A description ...",
+	      #  "enabled": true
+	      #}
+	      def create_tenant(name, description, enabled = true)
+	      	with_openstack do 
+	        	keystone.tenants.create( :name => name ,
+	        														:description => description ,
+	        														:enabled => enabled )
+	      	end
+	      end
+
+	      #{
+	      #  "username": "jqsmith",
+	      #  "email": "john.smith@example.org",
+	      #  "enabled": true,
+	      #  "OS-KSADM:password": "secrete"
+	      #}
+	      def create_user(name, tenant_id, password, email = '')
+	      	with_openstack do 
+		        keystone.users.create( :name => name,
+		        												:tenant_id => tenant_id,
+		        												:password => password,
+		        												:email => email)
+	      	end
+	      end
+
+	      def get_tenant_by_name(name)
+	      	with_openstack { keystone.tenants.find {|tenant| tenant.name == name} }
+	      end
+
+	      def tenant_add_user_with_role(tenant, user_id, role_id)
+	        with_openstack { tenant.grant_user_role(user_id, role_id) }
+	      end
+
+	      def get_role_by_name(name)
+	      	with_openstack { keystone.roles.find {|role| role.name == name} }
+	      end
+
+	      def find_user_by_name(name)
+	      	with_openstack { keystone.users.find {|user| user.name == name} }
+	      end
+			end
+
+		end
+
+	end
+
+end

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

@@ -0,0 +1,37 @@
+module Ocp::Registry
+
+	class CloudManager
+
+		class Openstack
+
+			module NovaHelper
+
+				NOVA_QUOTA_FIELDS = ["metadata_items",
+				                     "cores",
+				                     "instances",
+				                     "injected_files",
+				                     "injected_file_content_bytes",
+				                     "ram",
+				                     "floating_ips",
+				                     "fixed_ips",
+				                     "security_groups",
+				                     "security_group_rules"]
+
+				def default_compute_quota
+					with_openstack { compute.get_quota_defaults(nil).body["quota_set"] }
+				end
+
+				def set_compute_quota(tenant_id, hash)
+					with_openstack do 
+						settings = Ocp::Registry::Common.hash_filter(hash, NOVA_QUOTA_FIELDS)
+						compute.update_quota(tenant_id,settings).body["quota_set"]
+					end
+				end
+
+			end
+
+		end
+
+	end
+
+end

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

@@ -0,0 +1,126 @@
+
+module Ocp::Registry
+
+  class CloudManager
+
+    class Openstack < CloudManager
+
+      require 'openstack/cinder_helper'
+      require 'openstack/nova_helper'
+      require 'openstack/keystone_helper'
+
+      include KeystoneHelper
+      include NovaHelper
+      include CinderHelper
+
+      def initialize(cloud_config)
+        validate_options(cloud_config)
+
+        @logger = Ocp::Registry.logger
+
+        @openstack_properties = cloud_config["openstack"]
+
+        unless @openstack_properties["auth_url"].match(/\/tokens$/)
+          @openstack_properties["auth_url"] = @openstack_properties["auth_url"] + "/tokens"
+        end
+
+        @openstack_options = {
+          :provider => "OpenStack",
+          :openstack_auth_url => @openstack_properties["auth_url"],
+          :openstack_username => @openstack_properties["username"],
+          :openstack_api_key => @openstack_properties["api_key"],
+          :openstack_tenant => @openstack_properties["tenant"],
+          :openstack_endpoint_type => @openstack_properties["endpoint_type"]
+        }
+        @default_role_name =  cloud_config["default_role"]
+      end
+
+      def logger
+        @logger
+      end
+
+      def compute
+        @compute ||= Fog::Compute.new(@openstack_options)
+      end
+
+      def keystone
+        @keystone ||= Fog::Identity.new(@openstack_options)
+      end
+      
+      def volume
+        @volume ||= Fog::Volume.new(@openstack_options)
+      end
+
+      def validate_options(cloud_config)
+        unless cloud_config.has_key?("openstack") &&
+            cloud_config["openstack"].is_a?(Hash) &&
+            cloud_config["openstack"]["auth_url"] &&
+            cloud_config["openstack"]["username"] &&
+            cloud_config["openstack"]["api_key"] &&
+            cloud_config["openstack"]["tenant"] &&
+            cloud_config["default_role"]
+          raise ConfigError, "Invalid OpenStack configuration parameters"
+        end
+      end
+
+      def set_tenant_quota(tenant_id, settings={})
+        result = nil
+        with_openstack do
+          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)
+        end
+        cloud_error "Quota for #{tenant_id} has not been set" unless result
+        result
+      end
+
+      def default_quota
+        return @default_quota if @default_quota
+        with_openstack do
+          compute_quota = default_compute_quota
+          volume_quota = default_volume_quota
+          @default_quota = compute_quota.merge (volume_quota)
+        end
+        cloud_error "Default Quota is not found" unless @default_quota
+        @default_quota
+      end
+
+      def default_role
+        return @default_role if @default_role
+        with_openstack do 
+          @default_role ||= get_role_by_name(@default_role_name)
+        end
+        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 with_openstack
+        retried = false
+        begin
+          yield
+        rescue Excon::Errors::Unauthorized => e
+          unless retried
+            retried = true
+            @compute = nil
+            @volume = nil
+            @keystone = nil
+            retry
+          end
+          cloud_error "Unable to connect to OpenStack API: #{e.message}", e
+        rescue Excon::Errors::InternalServerError => e
+          cloud_error "OpenStack API Internal Server error. Check debug log for details.", e
+        end
+      end
+
+      def cloud_error(message, exception = nil)
+        @logger.error(message) if @logger
+        @logger.error(exception) if @logger && exception
+        raise Ocp::Registry::CloudError, message
+      end
+
+    end
+
+  end
+
+end

data/lib/ocp_registry/common.rb

@@ -0,0 +1,54 @@
+module Ocp::Registry::Common
+
+	class << self
+
+		def uuid
+      SecureRandom.uuid
+    end
+
+    def gen_password
+			SecureRandom.base64
+		end
+
+		def parse_email(email)
+			return unless email =~ /[a-z0-9_.-]+@[a-z0-9-]+\.[a-z.]+/
+				email =~ /([a-z0-9_.-]+)@([a-z0-9-]+\.[a-z.]+)/
+				{
+					:name => $1 ,
+					:domain => $2
+				}
+		end
+
+		def hash_filter(hash, fields = [])
+			copy = deep_copy(hash)
+			do_hash_filter(copy, fields)
+		end
+
+		def deep_copy(o)
+  		Marshal.load(Marshal.dump(o))
+		end
+
+		def json_merge(a,b,reverse = false)
+			hash_a = Yajl::load a 
+			hash_b = Yajl::load b
+			if reverse
+				b.merge a
+			else
+				a.merge b
+			end
+		end
+
+		private 
+
+		def do_hash_filter(hash, fields = [])
+			hash.keep_if do |k,v|
+				if v.is_a? Hash
+					do_hash_filter(v, fields)
+					!v.empty?
+				else
+					fields.include? k
+				end
+			end
+		end
+	end
+end

data/lib/ocp_registry/config.rb

@@ -0,0 +1,96 @@
+
+module Ocp::Registry
+
+  class << self
+
+    attr_accessor :logger
+    attr_accessor :base_url
+    attr_accessor :http_port
+    attr_accessor :http_user
+    attr_accessor :http_password
+    attr_accessor :db
+    attr_accessor :application_manager
+    attr_accessor :cloud_login_url
+
+    def configure(config)
+      validate_config(config)
+
+      @logger ||= Logger.new(config["logfile"] || STDOUT)
+      if config["loglevel"].kind_of?(String)
+        @logger.level = Logger.const_get(config["loglevel"].upcase)
+      end
+
+      @base_url = config["http"]["base_url"] || "127.0.0.1"
+      @http_port = config["http"]["port"]
+      @http_user = config["http"]["user"]
+      @http_password = config["http"]["password"]
+
+      @db = connect_db(config["db"])
+
+      migrate_db if @db
+
+      @cloud_login_url = config["cloud"]["login_url"]
+      
+      plugin = config["cloud"]["plugin"]
+      begin
+        require "ocp_registry/cloud_manager/#{plugin}"
+      rescue LoadError
+        raise ConfigError, "Could not find Provider Plugin: #{plugin}"
+      end
+      @cloud_manager = Ocp::Registry::CloudManager.const_get(plugin.capitalize).new(config["cloud"])
+      
+      @mail_client = init_mail_client(config["mail"]) if config["mail"]
+      
+      @application_manager = Ocp::Registry::ApplicationManager.new(@cloud_manager,@mail_client)
+    end
+
+    def init_mail_client(mail_config)
+      require "ocp_registry/mail_client"
+      MailClient.new(mail_config)
+    end
+
+    def migrate_db
+      Sequel.extension :migration
+      Sequel::Migrator.apply(@db,File.expand_path('./lib/ocp_registry/db'))
+    end
+
+    def connect_db(db_config)
+      connection_options = db_config.delete('connection_options') {{}}
+      db_config.delete_if { |_, v| v.to_s.empty? }
+      db_config = db_config.merge(connection_options)
+
+      db = Sequel.connect(db_config)
+      if logger
+        db.logger = @logger
+        db.sql_log_level = :debug
+      end
+
+      db
+    end
+
+    def validate_config(config)
+      unless config.is_a?(Hash)
+        raise ConfigError, "Invalid config format, Hash expected, " \
+                           "#{config.class} given"
+      end
+
+      unless config.has_key?("http") && config["http"].is_a?(Hash)
+        raise ConfigError, "HTTP configuration is missing from config file"
+      end
+
+      unless config.has_key?("db") && config["db"].is_a?(Hash)
+        raise ConfigError, "Database configuration is missing from config file"
+      end
+
+      unless config.has_key?("cloud") && config["cloud"].is_a?(Hash)
+        raise ConfigError, "Cloud configuration is missing from config file"
+      end
+
+      if config["cloud"]["plugin"].nil?
+        raise ConfigError, "Cloud plugin is missing from config file"
+      end
+    end
+
+  end
+
+end

data/lib/ocp_registry/db/001_db_initialize.rb

@@ -0,0 +1,16 @@
+
+Sequel.migration do
+  change do
+    create_table(:registry_applications) do
+      primary_key :id ,:auto_increment => false, :type => String
+      String :email , :null => false
+      String :project , :null => false
+      String :description , :text => true
+      String :state  , :null => false , :default => 'PENDING'
+      String :created_at , :null => false 
+      String :updated_at
+      String :comments , :text => true
+      String :settings , :null => false , :text => true
+    end
+  end
+end

data/lib/ocp_registry/error.rb

@@ -0,0 +1,16 @@
+module Ocp::Registry
+
+  class Error < StandardError
+    def self.code(code = 500)
+      define_method(:code) { code }
+    end
+  end
+
+  class FatalError < Error; end
+
+  class ConfigError < Error; end
+  class ConnectionError < Error; end
+
+  class CloudError < Error ; end
+
+end

data/lib/ocp_registry/mail_client.rb

@@ -0,0 +1,141 @@
+module Ocp::Registry
+	class MailClient
+
+		require "net/smtp"
+		require "thread"
+
+		DEFAULT_WORKER = 1
+		DEFAULT_PORT = '25' 
+		DEFAULT_HELO = 'ocp.com'
+		TEMPLATES_PATH = 'mail_template'
+		DEFAULT_FROM = 'registry@ocp.com'
+		DEFAULT_TLS = false
+		DEFAULT_ADMIN_EMAIL = 'admin@ocp.com'
+
+		def initialize(mail_config)
+			validate_opinions(mail_config)
+
+			@logger = Ocp::Registry.logger
+
+			@worker = mail_config["worker"] || DEFAULT_WORKER
+			@enable_tls = mail_config["enable_tls"] || DEFAULT_TLS
+
+			@mail_opinions = {
+				:address => mail_config["smtp_server"] ,
+				:port => mail_config["port"] || DEFAULT_PORT ,
+				:helo => mail_config["helo"] || DEFAULT_HELO ,
+				:user => mail_config["username"] || nil ,
+				:secret  => mail_config["password"] || nil ,
+				:authtype  => mail_config["authentication"] || nil
+			}
+
+			@admin_emails = mail_config["admin_emails"] || DEFAULT_ADMIN_EMAIL
+
+			@mail_queue = Queue.new
+
+			setup_senders
+
+		end
+
+		def admin_emails
+			@admin_emails
+		end
+
+		def send_mail(mail_info)
+			mail_info.merge!({ :from => DEFAULT_FROM }) 
+			@mail_queue << mail_info if mail_validated?(mail_info)
+		end
+
+		def validate_opinions(mail_config)
+			unless mail_config["smtp_server"] && mail_config["admin_emails"]
+				raise ConfigError, "Invalid Mail configuration"
+			end
+		end
+
+		def mail_validated?(mail_info)
+			unless mail_info[:from] && mail_info[:to] && mail_info[:template] && has_template?(mail_info[:template])
+				@logger.waring "Mail is ignored because less of necessary fields "
+				return false
+			end
+				true
+		end
+
+		def has_template?(template)
+			File.exists? File.expand_path("#{TEMPLATES_PATH}/#{template}.erb")
+		end
+
+		def prepare_message(mail)
+			template = mail.delete(:template)
+			template = File.read(File.expand_path("#{TEMPLATES_PATH}/#{template}.erb"))
+			@logger.debug "Starting prepare message for mail - #{mail.to_s}"
+			begin
+				info = mail[:msg]
+				message = ERB.new(template).result binding
+			rescue Exception => e
+				@logger.error "Load email template failed - #{e.message}"
+				@logger.debug(e.backtrace.join("\n"))
+			end
+			return message ,  mail[:from] , mail[:to] 
+		end
+
+		private 
+
+		# Here we use multi-thread to realize a provider-consumer mode with a block-queue
+		# TODO: Realize with Fiber 
+		def setup_senders
+			@worker.times do |index|
+
+				thread = Thread.new { create_sender }
+				thread.run
+
+				@logger.info("Mail sender thread #{index} is running ")
+
+			end
+
+		end
+
+
+		def create_sender
+			loop do
+				mail = @mail_queue.pop
+				begin
+					if @enable_tls
+						require "tlsmail"
+						Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
+					end
+					@logger.info("Starting SMTP with opinions #{@mail_opinions}")
+					Net::SMTP.start(@mail_opinions[:address] ,
+													@mail_opinions[:port] ,
+													@mail_opinions[:helo] ,
+													@mail_opinions[:user] ,
+													@mail_opinions[:secret] ,
+													@mail_opinions[:authtype]) do |smtp|
+						until mail.nil? do 
+							msg, from, to  = prepare_message(mail)
+							smtp.send_message(msg, from, to)
+							@logger.debug("Mail is sent with message \n#{msg}")
+							begin
+								mail = @mail_queue.pop(:non_block => true )
+							rescue ThreadError => e
+								mail = nil 
+							end
+						end
+					end
+				rescue Net::SMTPAuthenticationError => e
+					@logger.error("Mail server authentication failed - #{e.message}", e)
+					@logger.debug(e.backtrace.join("\n"))
+				rescue Net::SMTPError => e
+					@logger.error("Mail is not sent because of SMTP error - #{e.message}")
+					@logger.debug(e.backtrace.join("\n"))
+				rescue Exception => e
+					@logger.error(e.message)
+					@logger.debug(e.backtrace.join("\n"))
+				end
+			end
+		end
+
+
+
+
+	end
+end