visor-auth 0.0.1

data/lib/auth/backends/mysql_db.rb

@@ -0,0 +1,186 @@
+require 'mysql2'
+require 'json'
+require 'uri'
+
+module Visor
+  module Auth
+    module Backends
+
+      # The MySQL Backend for the VISoR Auth.
+      #
+      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]}`.`users` (
+          `_id` VARCHAR(45) NOT NULL ,
+          `access_key` VARCHAR(45) NOT NULL ,
+          `secret_key` VARCHAR(45) NOT NULL ,
+          `email` VARCHAR(45) NOT NULL ,
+          `created_at` DATETIME NULL ,
+          `updated_at` DATETIME 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 an array with the registered users.
+        #
+        # @option [Hash] filters Users attributes for filtering the returned results.
+        #   Besides common attributes filters, the following options can be passed to.
+        #
+        # @return [Array] The users information.
+        #
+        # @raise [NotFound] If there are no registered users.
+        #
+        def get_users(filters = {})
+          validate_query_filters filters unless filters.empty?
+          filter = filters.empty? ? 1 : to_sql_where(filters)
+          users = @conn.query("SELECT * FROM users WHERE #{filter}", symbolize_keys: true).to_a
+          raise NotFound, "No users found." if users.empty? && filters.empty?
+          raise NotFound, "No users found with given parameters." if users.empty?
+          users
+        end
+
+        # Returns an user information.
+        #
+        # @param [String] access_key The user access_key.
+        #
+        # @return [Hash] The requested user information.
+        #
+        # @raise [NotFound] If user was not found.
+        #
+        def get_user(access_key)
+          user = @conn.query("SELECT * FROM users WHERE access_key='#{access_key}'", symbolize_keys: true).first
+          raise NotFound, "No user found with access_key '#{access_key}'." unless user
+          user
+        end
+
+        # Delete a registered user.
+        #
+        # @param [String] access_key The user access_key.
+        #
+        # @return [hash] The deleted image metadata.
+        #
+        # @raise [NotFound] If user was not found.
+        #
+        def delete_user(access_key)
+          user = @conn.query("SELECT * FROM users WHERE access_key='#{access_key}'", symbolize_keys: true).first
+          raise NotFound, "No user found with access_key '#{access_key}'." unless user
+          @conn.query "DELETE FROM users WHERE access_key='#{access_key}'"
+          user
+        end
+
+        # Delete all images records.
+        #
+        def delete_all!
+          @conn.query "DELETE FROM users"
+        end
+
+        # Create a new user record for the given information.
+        #
+        # @param [Hash] user The user information.
+        #
+        # @return [Hash] The already added user information.
+        #
+        # @raise [Invalid] If user information validation fails.
+        # @raise [ConflictError] If an access_key was already taken.
+        #
+        def post_user(user)
+          validate_data_post user
+          exists = @conn.query("SELECT * FROM users WHERE access_key='#{user[:access_key]}'", symbolize_keys: true).first
+          raise ConflictError, "The access_key '#{user[:access_key]}' was already taken." if exists
+
+          set_protected_post user
+          keys_values = to_sql_insert(user)
+          @conn.query "INSERT INTO users #{keys_values[0]} VALUES #{keys_values[1]}"
+          self.get_user(user[:access_key])
+        end
+
+        # Update an user information.
+        #
+        # @param [String] access_key The user access_key.
+        # @param [Hash] update The user information update.
+        #
+        # @return [BSON::OrderedHash] The updated user information.
+        #
+        # @raise [Invalid] If user information validation fails.
+        # @raise [ConflictError] If an access_key was already taken.
+        # @raise [NotFound] If user was not found.
+        #
+        def put_user(access_key, update)
+          validate_data_put update
+          user = @conn.query("SELECT * FROM users WHERE access_key='#{access_key}'", symbolize_keys: true).first
+          raise NotFound, "No user found with access_key '#{access_key}'." unless user
+
+          if update[:access_key]
+            exists = @conn.query("SELECT * FROM users WHERE access_key='#{update[:access_key]}'", symbolize_keys: true).first
+            raise ConflictError, "The access_key '#{update[:access_key]}' was already taken." if exists
+          end
+
+          set_protected_put update
+          @conn.query "UPDATE users SET #{to_sql_update(update)} WHERE access_key='#{access_key}'"
+          self.get_user(update[:access_key] || access_key)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/auth/cli.rb

@@ -0,0 +1,333 @@
+require 'open-uri'
+require 'logger'
+require 'optparse'
+require 'fileutils'
+require 'rack'
+
+module Visor
+  module Auth
+    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 = 4566
+      # 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 Auth Server v#{Visor::Auth::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_auth)
+              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_auth, 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

data/lib/auth/client.rb

@@ -0,0 +1,149 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'json'
+
+module Visor
+  module Auth
+
+    # The Client API for the VISoR Auth.
+    #
+    # After Instantiate a Client object its possible to directly interact with the auth server and its
+    # database backend.
+    #
+    class Client
+
+      include Visor::Common::Exception
+
+      configs = Common::Config.load_config :visor_auth
+
+      DEFAULT_HOST = configs[:bind_host] || '0.0.0.0'
+      DEFAULT_PORT = configs[:bind_port] || 4566
+
+      attr_reader :host, :port, :ssl
+
+      def initialize(opts = {})
+        @host       = opts[:host] || DEFAULT_HOST
+        @port       = opts[:port] || DEFAULT_PORT
+        @ssl        = opts[:ssl] || false
+      end
+
+      def get_users(query={})
+        str     = build_query(query)
+        request = Net::HTTP::Get.new("/users#{str}")
+        do_request(request)
+      end
+
+      def get_user(access_key)
+        request = Net::HTTP::Get.new("/users/#{access_key}")
+        do_request(request)
+      end
+
+      def post_user(info)
+        request      = Net::HTTP::Post.new('/users')
+        request.body = prepare_body(info)
+        do_request(request)
+      end
+
+      def put_user(access_key, info)
+        request      = Net::HTTP::Put.new("/users/#{access_key}")
+        request.body = prepare_body(info)
+        do_request(request)
+      end
+
+      def delete_user(access_key)
+        request = Net::HTTP::Delete.new("/users/#{access_key}")
+        do_request(request)
+      end
+
+      private
+
+      # Parses a response body with the JSON parser and extracts and returns a single
+      # key value from it if defined, otherwise returns all the body.
+      #
+      # @param key (nil) [Symbol] The hash key to extract the wanted value.
+      # @param response [Net::HTTPResponse] The response which contains the body to parse.
+      #
+      # @return [String, Hash] If key is provided and exists on the response body, them return
+      #   its value, otherwise return all the body hash.
+      #
+      def parse(key=nil, response)
+        parsed = JSON.parse(response.body, symbolize_names: true)
+        key ? parsed[key] : parsed
+      end
+
+      # Generate a valid URI query string from key/value pairs of the given hash.
+      #
+      # @param opts [Hash] The hash with the key/value pairs to generate query from.
+      #
+      # @return [String] The generated query in the form of "?k=v&k1=v1".
+      #
+      def build_query(h)
+        (h.nil? or h.empty?) ? '' : '?' + URI.encode_www_form(h)
+      end
+
+      # Fill common header keys before each request. This sets the 'User-Agent' and 'Accept'
+      # headers for every request and additionally sets the 'content-type' header
+      # for POST and PUT requests.
+      #
+      # @param request [Net::HTTPResponse] The request which will be modified in its headers.
+      #
+      def prepare_headers(request)
+        request['User-Agent'] = 'VISoR image server'
+        request['Accept']     = 'application/json'
+        request['content-type'] = 'application/json' if ['POST', 'PUT'].include?(request.method)
+      end
+
+      # Generate a valid JSON request body for POST and PUT requests.
+      # It generates a JSON object encapsulated inside a :image key and then returns it.
+      #
+      # @param hash [Hash] The hash with the key/value pairs to generate a JSON object from.
+      #
+      # @return [Hash] If an :image key is already present in the hash, it just returns the plain
+      #   JSON object, otherwise, encapsulate the hash inside a :image key and returns it.
+      #
+      def prepare_body(hash)
+        hash.has_key?(:user) ? hash.to_json : {user: hash}.to_json
+      end
+
+      # Process requests by preparing its headers, launch them and assert or raise their response.
+      #
+      # @param request [Net::HTTPResponse] The request which will be launched.
+      #
+      # @return [String, Hash] If an error is raised, then it parses and returns its message,
+      #   otherwise it properly parse and return the response body.
+      #
+      # @raise [NotFound] If required image was not found (on a GET, PUT or DELETE request).
+      # @raise [Invalid] If image meta validation fails (on a POST or PUT request).
+      #
+      def do_request(request)
+        prepare_headers(request)
+        response = http_or_https.request(request)
+        case response
+        when Net::HTTPNotFound then
+          raise NotFound, parse(:message, response)
+        when Net::HTTPBadRequest then
+          raise Invalid, parse(:message, response)
+        when Net::HTTPConflict then
+          raise ConflictError, parse(:message, response)
+        else
+          parse(:user, response) or parse(:users, response)
+        end
+      end
+
+      # Generate a new HTTP or HTTPS connection based on initialization parameters.
+      #
+      # @return [Net::HTTP] A HTTP or HTTPS (not done yet) connection ready to use.
+      #
+      def http_or_https
+        if @ssl
+          #TODO: ssl connection
+          #https://github.com/augustl/net-http-cheat-sheet/blob/master/ssl_and_https.rb
+        else
+          Net::HTTP.new(@host, @port)
+        end
+      end
+
+    end
+  end
+end