visor-image 0.0.1

data/lib/image/meta.rb

@@ -0,0 +1,219 @@
+require 'em-synchrony'
+require 'em-synchrony/em-http'
+require 'json'
+
+module Visor
+  module Image
+
+    # The API for the VISoR Meta Server. This class supports all image metadata manipulation operations.
+    #
+    # This is the entry-point for the VISoR Image Server to communicate with the VISoR Meta Server,
+    # here are processed and logged all the calls to the meta server coming from it.
+    #
+    class Meta
+      include Visor::Common::Exception
+
+      DEFAULT_HOST = '0.0.0.0'
+      DEFAULT_PORT = 4567
+
+      attr_reader :host, :port, :ssl
+
+      # Initializes a new new VISoR Meta Image.
+      #
+      # @option opts [String] :host (DEFAULT_HOST) The host address where VISoR meta server resides.
+      # @option opts [String] :port (DEFAULT_PORT) The host port where VISoR meta server resides.
+      # @option opts [String] :ssl (false) If the connection should be made through HTTPS (SSL).
+      #
+      def initialize(opts = {})
+        @host = opts[:host] || DEFAULT_HOST
+        @port = opts[:port] || DEFAULT_PORT
+        @ssl  = opts[:ssl] || false
+      end
+
+      # Retrieves brief metadata of all public images.
+      # Options for filtering the returned results can be passed in.
+      #
+      # @option query [String] :<attribute_name> The image attribute value to filter returned results.
+      # @param owner (nil) [String] The user's access key to look for its private images too.
+      # @option query [String] :sort ("_id") The image attribute to sort returned results.
+      # @option query [String] :dir ("asc") The direction to sort results ("asc"/"desc").
+      #
+      # @return [Array] All public images brief metadata.
+      #   Just {Visor::Meta::Backends::Base::BRIEF BRIEF} fields are returned.
+      #
+      # @raise [NotFound] If there are no public images registered on the server.
+      #
+      def get_images(query = {}, owner=nil)
+        http    = request.get path: '/images', query: query.merge({access: 'public'}), head: get_headers
+        pub = return_response(http)
+        priv = []
+        if owner
+          http = request.get path: '/images', query: query.merge({access: 'private', owner: owner}), head: get_headers
+          begin
+            priv = return_response(http)
+          rescue => e
+            nil
+          end
+        end
+        pub + priv
+      end
+
+      # Retrieves detailed metadata of all public images.
+      #
+      # Filtering and querying works the same as with {#get_images}. The only difference is the number
+      # of disclosed attributes.
+      #
+      # @option query [String] :attribute_name The image attribute value to filter returned results.
+      # @param owner (nil) [String] The user's access_key to look for its private images too.
+      # @option query [String] :sort ("_id") The image attribute to sort returned results.
+      # @option query [String] :dir ("asc") The direction to sort results ("asc"/"desc").
+      #
+      # @return [Array] All public images detailed metadata.
+      #   The {Visor::Meta::Backends::Base::DETAIL_EXC DETAIL_EXC} fields are excluded from results.
+      #
+      # @raise [NotFound] If there are no public images registered on the server.
+      #
+      def get_images_detail(query = {}, owner=nil)
+        http = request.get path: '/images/detail', query: query, head: get_headers
+        pub = return_response(http)
+        priv = []
+        if owner
+          http = request.get path: '/images/detail', query: query.merge({access: 'private', owner: owner}), head: get_headers
+          begin
+            priv = return_response(http)
+          rescue => e
+            nil
+          end
+        end
+        pub + priv
+      end
+
+      # Retrieves detailed image metadata of the image with the given id.
+      #
+      # @param id [String] The wanted image's _id.
+      #
+      # @return [Hash] The requested image metadata.
+      #
+      # @raise [NotFound] If image not found.
+      #
+      def get_image(id)
+        http = request.get path: "/images/#{id}", head: get_headers
+        return_response(http)
+      end
+
+      # Register a new image on the server with the given metadata and returns its metadata.
+      #
+      # @param meta [Hash] The image metadata.
+      #
+      # @return [Hash] The already inserted image metadata.
+      #
+      # @raise [Invalid] If image meta validation fails.
+      #
+      def post_image(meta)
+        body = prepare_body(meta)
+        http = request.post path: '/images', body: body, head: post_headers
+        return_response(http)
+      end
+
+      # Updates an image record with the given metadata and returns its metadata.
+      #
+      # @param id [String] The image's _id which will be updated.
+      # @param meta [Hash] The image metadata.
+      #
+      # @return [Hash] The already updated image metadata.
+      #
+      # @raise [Invalid] If image meta validation fails.
+      # @raise [NotFound] If required image was not found.
+      #
+      def put_image(id, meta)
+        body = prepare_body(meta)
+        http = request.put path: "/images/#{id}", body: body, head: put_headers
+        return_response(http)
+      end
+
+      # Removes an image record based on its _id and returns its metadata.
+      #
+      # @param id [String] The image's _id which will be deleted.
+      #
+      # @return [Hash] The already deleted image metadata. This is useful for recover on accidental delete.
+      #
+      # @raise [NotFound] If required image was not found.
+      #
+      def delete_image(id)
+        http = request.delete path: "/images/#{id}", head: delete_headers
+        return_response(http)
+      end
+
+      private
+
+      # 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?(:image) ? meta.to_json : {image: hash}.to_json
+      end
+
+      # Process requests by preparing its headers, launch them and assert or raise their response.
+      #
+      # @param request [EventMachine::HttpRequest] 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 return_response(http)
+        body   = http.response
+        status = http.response_header.status.to_i
+        parsed = JSON.parse(body, symbolize_names: true)
+
+        case status
+        when 404 then
+          raise NotFound, parsed[:message]
+        when 400 then
+          raise Invalid, parsed[:message]
+        when 500 then
+          raise InternalError, parsed[:message]
+        else
+          parsed[:image] || parsed[:images]
+        end
+      end
+
+      # Generate a new HTTP or HTTPS connection based on initialization parameters.
+      #
+      # @return [EventMachine::HttpRequest] A HTTP or HTTPS (not done yet) connection ready to use.
+      #
+      def request
+        if @ssl
+          #TODO: ssl connection
+        else
+          EventMachine::HttpRequest.new("http://#{@host}:#{@port}")
+        end
+      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.
+      #
+      def get_headers
+        {'User-Agent' => 'VISoR Image Server',
+         'Accept'     => 'application/json'}
+      end
+
+      def post_headers
+        {'User-Agent'   => 'VISoR Image Server',
+         'Accept'       => 'application/json',
+         'content-type' => 'application/json'}
+      end
+
+      alias :delete_headers :get_headers
+      alias :put_headers :post_headers
+    end
+  end
+end

data/lib/image/routes/delete_all_images.rb

@@ -0,0 +1,40 @@
+require 'goliath'
+
+module Visor
+  module Image
+
+    # Delete all images metadata
+    #
+    class DeleteAllImages < Goliath::API
+      include Visor::Common::Exception
+      use Goliath::Rack::Render, 'json'
+
+      # Pre-process headers as they arrive and load them into a environment variable.
+      #
+      # @param [Object] env The Goliath environment variables.
+      # @param [Object] headers The incoming request HTTP headers.
+      #
+      def on_headers(env, headers)
+        logger.debug "Received headers: #{headers.inspect}"
+        env['headers'] = headers
+      end
+
+      def response(env)
+        authorize(env, vas)
+        images = vms.get_images
+        images.each { |image| vms.delete_image(image[:_id]) }
+        [200, {}, nil]
+      rescue Forbidden => e
+        exit_error(403, e.message)
+      rescue NotFound => e
+        exit_error(404, e.message)
+      end
+
+      def exit_error(code, message)
+        logger.error message
+        [code, {}, {code: code, message: message}]
+      end
+    end
+
+  end
+end

data/lib/image/routes/delete_image.rb

@@ -0,0 +1,62 @@
+require 'goliath'
+
+module Visor
+  module Image
+
+    # Delete the metadata and data of the image with the given id.
+    #
+    class DeleteImage < Goliath::API
+      include Visor::Common::Exception
+      include Visor::Common::Util
+      use Goliath::Rack::Render, ['json', 'xml']
+
+      # Pre-process headers as they arrive and load them into a environment variable.
+      #
+      # @param [Object] env The Goliath environment variables.
+      # @param [Object] headers The incoming request HTTP headers.
+      #
+      def on_headers(env, headers)
+        logger.debug "Received headers: #{headers.inspect}"
+        env['headers'] = headers
+      end
+
+      # Query database to delete the wanted image based on its id.
+      #
+      # @param [Object] env The Goliath environment variables.
+      #
+      # @return [Array] The HTTP response containing the image
+      #   metadata or an error code and its messages if anything was raised.
+      #
+      def response(env)
+        authorize(env, vas)
+        meta = vms.delete_image(params[:id])
+        uri  = meta[:location]
+        name = meta[:store]
+
+        if uri && name
+          store = Visor::Image::Store.get_backend(uri, configs)
+          store.delete unless name == 'http'
+        end
+      rescue Forbidden => e
+        exit_error(403, e.message)
+      rescue NotFound => e
+        exit_error(404, e.message)
+      else
+        [200, {}, {image: meta}]
+      end
+
+      # Produce an HTTP response with an error code and message.
+      #
+      # @param [Fixnum] code The error code.
+      # @param [String] message The error message.
+      #
+      # @return [Array] The HTTP response containing an error code and its message.
+      #
+      def exit_error(code, message)
+        logger.error message
+        [code, {}, {code: code, message: message}]
+      end
+    end
+
+  end
+end

data/lib/image/routes/get_image.rb

@@ -0,0 +1,78 @@
+require 'goliath'
+
+module Visor
+  module Image
+
+    # Get image data and metadata for the given id.
+    #
+    class GetImage < Goliath::API
+      include Visor::Common::Exception
+      include Visor::Common::Util
+      use Goliath::Rack::Render, ['json', 'xml']
+
+      # Pre-process headers as they arrive and load them into a environment variable.
+      #
+      # @param [Object] env The Goliath environment variables.
+      # @param [Object] headers The incoming request HTTP headers.
+      #
+      def on_headers(env, headers)
+        logger.debug "Received headers: #{headers.inspect}"
+        env['headers'] = headers
+      end
+
+      # Query database to retrieve the wanted image meta and return it in
+      # headers, along with the image file, if any, streaming it in request body.
+      #
+      # @param [Object] env The Goliath environment variables.
+      #
+      def response(env)
+        begin
+          authorize(env, vas)
+          meta = vms.get_image(params[:id])
+          uri  = meta[:location]
+          if uri
+            store = Visor::Image::Store.get_backend(uri, configs)
+            store.file_exists?
+          end
+        rescue Forbidden => e
+          return exit_error(403, e.message)
+        rescue NotFound => e
+          return exit_error(404, e.message)
+        end
+
+        custom  = {'Content-Type' => 'application/octet-stream', 'X-Stream' => 'Goliath'}
+        headers = push_meta_into_headers(meta, custom)
+
+        if uri
+          EM.next_tick do
+            store.get { |chunk| chunk ? env.chunked_stream_send(chunk) : env.chunked_stream_close }
+          end
+          chunked_streaming_response(200, headers)
+        else
+          [200, headers, nil]
+        end
+      end
+
+      # On connection close log a message.
+      #
+      # @param [Object] env The Goliath environment variables.
+      #
+      def on_close(env)
+        logger.info 'Connection closed'
+      end
+
+      # Produce an HTTP response with an error code and message.
+      #
+      # @param [Fixnum] code The error code.
+      # @param [String] message The error message.
+      #
+      # @return [Array] The HTTP response containing an error code and its message.
+      #
+      def exit_error(code, message)
+        logger.error message
+        [code, {}, {code: code, message: message}]
+      end
+    end
+
+  end
+end

data/lib/image/routes/get_images.rb

@@ -0,0 +1,54 @@
+require 'goliath'
+
+module Visor
+  module Image
+
+    # Get brief information about all public images.
+    #
+    class GetImages < Goliath::API
+      include Visor::Common::Exception
+      include Visor::Common::Util
+      use Goliath::Rack::Render, ['json', 'xml']
+
+      # Pre-process headers as they arrive and load them into a environment variable.
+      #
+      # @param [Object] env The Goliath environment variables.
+      # @param [Object] headers The incoming request HTTP headers.
+      #
+      def on_headers(env, headers)
+        logger.debug "Received headers: #{headers.inspect}"
+        env['headers'] = headers
+      end
+
+      # Query database to retrieve public images brief meta and return it in request body.
+      #
+      # @param [Object] env The Goliath environment variables.
+      #
+      # @return [Array] The HTTP response containing the images
+      #   metadata or an error code and its message if anything was raised.
+      #
+      def response(env)
+        access_key = authorize(env, vas)
+        meta = vms.get_images(params, access_key)
+        [200, {}, {images: meta}]
+      rescue Forbidden => e
+        exit_error(403, e.message)
+      rescue NotFound => e
+        exit_error(404, e.message)
+      end
+
+      # Produce an HTTP response with an error code and message.
+      #
+      # @param [Fixnum] code The error code.
+      # @param [String] message The error message.
+      #
+      # @return [Array] The HTTP response containing an error code and its message.
+      #
+      def exit_error(code, message)
+        logger.error message
+        [code, {}, {code: code, message: message}]
+      end
+    end
+
+  end
+end