visor-meta 0.0.1

data/lib/meta/backends/mysql_db.rb

@@ -0,0 +1,235 @@
+require 'mysql2'
+require 'json'
+require 'uri'
+
+module Visor::Meta
+  module Backends
+
+    # The MySQL Backend for the VISoR Meta.
+    #
+    class MySQL < Base
+      include Visor::Common::Exception
+
+      # Connection constants
+      #
+      # Default MySQL database
+      DEFAULT_DB       = 'visor'
+      # Default MySQL host address
+      DEFAULT_HOST     = '127.0.0.1'
+      # Default MySQL host port
+      DEFAULT_PORT     = 3306
+      # Default MySQL user
+      DEFAULT_USER     = 'visor'
+      # Default MySQL password
+      DEFAULT_PASSWORD = 'passwd'
+
+      #CREATE DATABASE visor;
+      #CREATE USER 'visor'@'localhost' IDENTIFIED BY 'visor';
+      #SET PASSWORD FOR 'visor'@'localhost' = PASSWORD('passwd');
+      #GRANT ALL PRIVILEGES ON visor.* TO 'visor'@'localhost';
+
+      # Initializes a MongoDB Backend instance.
+      #
+      # @option [Hash] opts Any of the available options can be passed.
+      #
+      # @option opts [String] :uri The connection uri, if provided, no other option needs to be setted.
+      # @option opts [String] :db (DEFAULT_DB) The wanted database.
+      # @option opts [String] :host (DEFAULT_HOST) The host address.
+      # @option opts [Integer] :port (DEFAULT_PORT) The port to be used.
+      # @option opts [String] :user (DEFAULT_USER) The user to be used.
+      # @option opts [String] :password (DEFAULT_PASSWORD) The password to be used.
+      # @option opts [Object] :conn The connection pool to access database.
+      #
+      def self.connect(opts = {})
+        opts[:uri]      ||= ''
+        uri             = URI.parse(opts[:uri])
+        opts[:db]       = uri.path ? uri.path.gsub('/', '') : DEFAULT_DB
+        opts[:host]     = uri.host || DEFAULT_HOST
+        opts[:port]     = uri.port || DEFAULT_PORT
+        opts[:user]     = uri.user || DEFAULT_USER
+        opts[:password] = uri.password || DEFAULT_PASSWORD
+
+        self.new opts
+      end
+
+      def initialize(opts)
+        super opts
+        @conn = connection
+        @conn.query %[
+        CREATE TABLE IF NOT EXISTS `#{opts[:db]}`.`images` (
+          `_id` VARCHAR(45) NOT NULL ,
+          `uri` VARCHAR(255) NULL ,
+          `name` VARCHAR(45) NOT NULL ,
+          `architecture` VARCHAR(45) NOT NULL ,
+          `access` VARCHAR(45) NOT NULL ,
+          `type` VARCHAR(45) NULL ,
+          `format` VARCHAR(45) NULL ,
+          `store` VARCHAR(45) NULL ,
+          `location` VARCHAR(255) NULL ,
+          `kernel` VARCHAR(45) NULL ,
+          `ramdisk` VARCHAR(45) NULL ,
+          `owner` VARCHAR(45) NULL ,
+          `status` VARCHAR(45) NULL ,
+          `size` INT NULL ,
+          `created_at` DATETIME NULL ,
+          `uploaded_at` DATETIME NULL ,
+          `updated_at` DATETIME NULL ,
+          `accessed_at` DATETIME NULL ,
+          `access_count` INT NULL DEFAULT 0 ,
+          `checksum` VARCHAR(255) NULL ,
+          `others` VARCHAR(255) NULL,
+          PRIMARY KEY (`_id`) )
+          ENGINE = InnoDB;
+        ]
+      end
+
+      # Establishes and returns a MySQL database connection and
+      # creates Images table if it does not exists.
+      #
+      # @return [Mysql2::Client] It returns a database client object.
+      #
+      def connection
+        Mysql2::Client.new(host:     @host, port: @port, database: @db,
+                           username: @user, password: @password)
+      end
+
+      # Returns the requested image metadata.
+      #
+      # @param [String] id The requested image's _id.
+      #
+      # @return [Hash] The requested image metadata.
+      #
+      # @raise [NotFound] If image not found.
+      #
+      def get_image(id, pass_timestamps = false)
+        meta = @conn.query("SELECT * FROM images WHERE _id='#{id}'", symbolize_keys: true).first
+        raise NotFound, "No image found with id '#{id}'." if meta.nil?
+
+        set_protected_get(id) unless pass_timestamps
+
+        exclude(meta)
+        meta
+      end
+
+      # Returns an array with the public images metadata.
+      #
+      # @param [true, false] brief (false) If true, the returned images will
+      #   only contain BRIEF attributes.
+      #
+      # @option [Hash] filters Image attributes for filtering the returned results.
+      #   Besides common attributes filters, the following options can be passed to.
+      #
+      # @option opts [String] :sort (_id) The image attribute to sort returned results.
+      #
+      # @return [Array] The public images metadata.
+      #
+      # @raise [NotFound] If there is no public images.
+      #
+      def get_public_images(brief = false, filters = {})
+        validate_query_filters filters unless filters.empty?
+
+        sort   = [(filters.delete(:sort) || '_id'), (filters.delete(:dir) || 'asc')]
+        filter = {access: 'public'}.merge(filters)
+        fields = brief ? BRIEF.join(', ') : '*'
+
+        pub = @conn.query("SELECT #{fields} FROM images WHERE #{to_sql_where(filter)}
+                                ORDER BY #{sort[0]} #{sort[1]}", symbolize_keys: true).to_a
+
+        raise NotFound, "No public images found." if pub.empty? && filters.empty?
+        raise NotFound, "No public images found with given parameters." if pub.empty?
+        pub.each { |meta| exclude(meta) } if fields == '*'
+        pub
+      end
+
+      # Delete an image record.
+      #
+      # @param [String] id The image's _id to remove.
+      #
+      # @return [Hash] The deleted image metadata.
+      #
+      # @raise [NotFound] If image not found.
+      #
+      def delete_image(id)
+        meta = @conn.query("SELECT * FROM images WHERE _id='#{id}'", symbolize_keys: true).first
+        raise NotFound, "No image found with id '#{id}'." if meta.nil?
+
+        @conn.query "DELETE FROM images WHERE _id='#{id}'"
+        meta
+      end
+
+      # Delete all images records.
+      #
+      def delete_all!
+        @conn.query "DELETE FROM images"
+      end
+
+      # Create a new image record for the given metadata.
+      #
+      # @param [Hash] meta The metadata.
+      # @option [Hash] opts Any of the available options can be passed.
+      #
+      # @option opts [String] :owner (Nil) The owner of the image.
+      # @option opts [Integer] :size (Nil) The image file size.
+      #
+      # @return [Hash] The already inserted image metadata.
+      # @raise [Invalid] If image meta validation fails.
+      #
+      def post_image(meta, opts = {})
+        validate_data_post meta
+
+        set_protected_post meta, opts
+        serialize_others(meta)
+
+        keys_values = to_sql_insert(meta)
+        @conn.query "INSERT INTO images #{keys_values[0]} VALUES #{keys_values[1]}"
+        self.get_image(meta[:_id], true)
+      end
+
+      # Update an image's metadata.
+      #
+      # @param [String] id The image _id to update.
+      # @param [Hash] update The image metadata to update.
+      #
+      # @return [Hash] The updated image metadata.
+      # @raise [Invalid] If update metadata validation fails.
+      # @raise [NotFound] If image not found.
+      #
+      def put_image(id, update)
+        validate_data_put update
+        img  = @conn.query("SELECT * FROM images WHERE _id='#{id}'", symbolize_keys: true).first
+        raise NotFound, "No image found with id '#{id}'." if img.nil?
+
+        set_protected_put update
+        serialize_others(update)
+
+        @conn.query "UPDATE images SET #{to_sql_update(update)} WHERE _id='#{id}'"
+        self.get_image(id, true)
+      end
+
+
+      private
+
+      # Excludes details that should not be disclosed on get detailed image meta.
+      # Also deserialize others attributes from the others column.
+      #
+      # @return [Hash] The image parameters that should not be retrieved from database.
+      #
+      def exclude(meta)
+        deserialize_others(meta)
+        DETAIL_EXC.each { |key| meta.delete(key) }
+      end
+
+      # Atomically set protected fields value from a get operation.
+      # Being them the accessed_at and access_count.
+      #
+      # @param [String] id The _id of the image being retrieved.
+      # @param [Mysql2::Client] conn The connection to the database.
+      #
+      def set_protected_get(id)
+        @conn.query "UPDATE images SET accessed_at='#{Time.now}', access_count=access_count+1 WHERE _id='#{id}'"
+      end
+
+    end
+  end
+end
+

data/lib/meta/cli.rb

@@ -0,0 +1,333 @@
+require 'open-uri'
+require 'logger'
+require 'optparse'
+require 'fileutils'
+require 'rack'
+
+module Visor
+  module Meta
+    class CLI
+
+      attr_reader :app, :cli_name, :argv, :options,
+                  :port, :host, :env, :command, :parser
+
+      # Available commands
+      COMMANDS = %w[start stop restart status clean]
+      # Commands that wont load options from the config file
+      NO_CONF_COMMANDS = %w[stop status]
+      # Default config files directories to look at
+      DEFAULT_DIR = File.expand_path('~/.visor')
+      # Default host address
+      DEFAULT_HOST = '0.0.0.0'
+      # Default port
+      DEFAULT_PORT = 4567
+      # Default application environment
+      DEFAULT_ENV = :production
+
+      # Initialize a CLI
+      #
+      def initialize(app, cli_name, argv=ARGV)
+        @app = app
+        @cli_name = cli_name
+        @argv = argv
+        @options = default_opts
+        @parser = parser
+        @command = parse!
+      end
+
+      def default_opts
+        {debug: false,
+         foreground: false,
+         no_proxy: false,
+         environment: DEFAULT_ENV}
+      end
+
+      # OptionParser parser
+      #
+      def parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: #{cli_name} [OPTIONS] COMMAND"
+
+          opts.separator ""
+          opts.separator "Commands:"
+          opts.separator "     start        start the server"
+          opts.separator "     stop         stop the server"
+          opts.separator "     restart      restart the server"
+          opts.separator "     status       current server status"
+
+          opts.separator ""
+          opts.separator "Options:"
+
+          opts.on("-c", "--config FILE", "Load a custom configuration file") do |file|
+            options[:config] = File.expand_path(file)
+          end
+          opts.on("-o", "--host HOST", "listen on HOST (default: #{DEFAULT_HOST})") do |host|
+            options[:host] = host.to_s
+          end
+          opts.on("-p", "--port PORT", "use PORT (default: #{DEFAULT_PORT})") do |port|
+            options[:port] = port.to_i
+          end
+          opts.on("-x", "--no-proxy", "ignore proxy settings if any") do
+            options[:no_proxy] = true
+          end
+          opts.on("-e", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: #{DEFAULT_ENV})") do |env|
+            options[:environment] = env.to_sym
+          end
+          opts.on("-F", "--foreground", "don't daemonize, run in the foreground") do
+            options[:foreground] = true
+          end
+
+          opts.separator ""
+          opts.separator "Common options:"
+
+          opts.on_tail("-d", "--debug", "Set debugging on (with foreground only)") do
+            options[:debug] = true
+          end
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+          opts.on_tail('-v', '--version', "Show version") do
+            puts "VISoR Meta Server v#{Visor::Meta::VERSION}"
+            exit
+          end
+        end
+      end
+
+      # Parse the current shell arguments and run the command.
+      # Exits on error.
+      #
+      def run!
+        if command.nil?
+          abort @parser.to_s
+        elsif COMMANDS.include?(command)
+          run_command
+        else
+          abort "Unknown command: #{command}. Available commands: #{COMMANDS.join(', ')}"
+        end
+      end
+
+      # Execute the command
+      #
+      def run_command
+        unless NO_CONF_COMMANDS.include?(command)
+          @conf = load_conf_file
+          @host = options[:host] || @conf[:bind_host] || DEFAULT_HOST
+          @port = options[:port] || @conf[:bind_port] || DEFAULT_PORT
+          @env = options[:environment]
+        end
+
+        case command
+          when 'start' then start
+          when 'stop' then stop
+          when 'restart' then restart
+          when 'status' then status
+          else clean
+        end
+        exit 0
+      end
+
+      # Remove all files created by the daemon.
+      #
+      def clean
+        begin
+          FileUtils.rm(pid_file) rescue Errno::ENOENT
+        end
+        begin
+          FileUtils.rm(url_file) rescue Errno::ENOENT
+        end
+        put_and_log :warn, "Removed all files created by server start"
+      end
+
+      # Restart server
+      #
+      def restart
+        @restart = true
+        stop
+        sleep 0.1 while running?
+        start
+      end
+
+      # Display current server status
+      #
+      def status
+        if running?
+          STDERR.puts "#{cli_name} is running PID: #{fetch_pid} URL: #{fetch_url}"
+        else
+          STDERR.puts "#{cli_name} is not running."
+        end
+      end
+
+      # Stop the server
+      #
+      def stop
+        begin
+          pid = File.read(pid_file)
+          put_and_log :warn, "Stopping #{cli_name} with PID: #{pid.to_i} Signal: INT"
+          Process.kill(:INT, pid.to_i)
+          File.delete(url_file)
+        rescue
+          put_and_log :warn, "Cannot stop #{cli_name}, is it running?"
+          exit! 1
+        end
+      end
+
+      # Start the server
+      #
+      def start
+        FileUtils.mkpath(DEFAULT_DIR)
+        begin
+          is_it_running?
+          can_use_port?
+          write_url
+          launch!
+        rescue => e
+          put_and_log :warn, "ERROR starting #{cli_name}: #{e}"
+          exit! 1
+        end
+      end
+
+      # Launch the server
+      #
+      def launch!
+        put_and_log :info, "Starting #{cli_name} at #{host}:#{port}"
+        debug_settings
+
+        Rack::Server.start(app: app,
+                           Host: host,
+                           Port: port,
+                           environment: get_env,
+                           daemonize: daemonize?,
+                           pid: pid_file)
+      end
+
+      protected
+
+      def is_it_running?
+        if files_exist?(pid_file, url_file)
+          if running?
+            put_and_log :warn, "'#{cli_name}' is already running at #{fetch_url}"
+            exit! 1
+          else
+            clean
+          end
+        end
+      end
+
+      def running?
+        begin
+          Process.kill 0, fetch_pid
+          true
+        rescue Errno::ESRCH
+          false
+        rescue Errno::EPERM
+          true
+        rescue
+          false
+        end
+      end
+
+      def can_use_port?
+        unless port_open?
+          put_and_log :warn, "Port #{port} already in use. Please try other."
+          exit! 1
+        end
+      end
+
+      def port_open?
+        begin
+          options[:no_proxy] ? open(url, proxy: nil) : open(url)
+          false
+        rescue OpenURI::HTTPError #TODO: quick-fix, try solve this
+          false
+        rescue Errno::ECONNREFUSED
+          true
+        end
+      end
+
+      def daemonize?
+        !options[:foreground]
+      end
+
+      def get_env
+        env == 'development' ? env : 'deployment'
+      end
+
+      def logger
+        @conf ||= load_conf_file
+        @logger ||=
+            begin
+              log = options[:foreground] ? Logger.new(STDERR) : Visor::Common::Config.build_logger(:visor_meta)
+              conf_level = @conf[:log_level] == 'INFO' ? 1 : 0
+              log.level = options[:debug] ? 0 : conf_level
+              log.formatter = Proc.new {|s, t, n, msg| "[#{t.strftime("%Y-%m-%d %H:%M:%S")}] #{s} - #{msg}\n"}
+              log
+            end
+      end
+
+      def put_and_log(level, msg)
+        STDERR.puts msg
+        logger.send level, msg
+      end
+
+      def parse!
+        parser.parse! argv
+        argv.shift
+      end
+
+      def debug_settings
+        logger.debug "Configurations loaded from #{@conf[:file]}:"
+        logger.debug "***************************************************"
+        @conf.each { |k, v| logger.debug "#{k}: #{v}" }
+        logger.debug "***************************************************"
+
+        logger.debug "Configurations passed from #{cli_name} CLI:"
+        logger.debug "***************************************************"
+        options.each { |k, v| logger.debug "#{k}: #{v}" if options[k] != default_opts[k] }
+        logger.debug "***************************************************"
+      end
+
+      def files_exist?(*files)
+        files.each { |file| return false unless File.exists?(File.expand_path(file)) }
+        true
+      end
+
+      def write_url
+        File.open(url_file, 'w') { |f| f << url }
+      end
+
+      def load_conf_file
+        Visor::Common::Config.load_config(:visor_meta, options[:config])
+      end
+
+      def safe_cli_name
+        cli_name.gsub('-', '_')
+      end
+
+      def fetch_pid
+        IO.read(pid_file).to_i
+      rescue
+        nil
+      end
+
+      def fetch_url
+        IO.read(url_file).split('//').last
+      rescue
+        nil
+      end
+
+      def pid_file
+        File.join(DEFAULT_DIR, "#{safe_cli_name}.pid")
+      end
+
+      def url_file
+        File.join(DEFAULT_DIR, "#{safe_cli_name}.url")
+      end
+
+      def url
+        "http://#{host}:#{port}"
+      end
+
+    end
+  end
+end