imagemaster3000 0.1.0

data/lib/imagemaster3000/definitions/parser.rb

@@ -0,0 +1,45 @@
+require 'json'
+require 'json-schema'
+
+module Imagemaster3000
+  module Definitions
+    class Parser
+      SCHEMA = File.join File.dirname(__FILE__), 'schemas', 'imagemaster3000-definition-schema.json'
+
+      class << self
+        def parse_image_definitions
+          definition_files = Dir.glob(File.join(Imagemaster3000::Settings[:'definitions-dir'], '*.json')).sort
+          logger.debug "Found definition files: #{definition_files.inspect}"
+          definition_files.map { |file| parse file }.compact
+        end
+
+        private
+
+        def parse(file)
+          logger.debug "Parsing file #{file.inspect}"
+          json = File.read file
+          validate json
+
+          hash = JSON.parse json, symbolize_names: true
+          Imagemaster3000::Entities::Image.new hash
+        rescue Imagemaster3000::Errors::ArgumentError, Imagemaster3000::Errors::ParsingError => ex
+          logger.error "Parsing error occured while reading definition #{file.inspect}: #{ex.message}. Skipping."
+          nil
+        end
+
+        def validate(json)
+          logger.debug "Validating json\n#{json}"
+          JSON::Validator.schema_reader = JSON::Schema::Reader.new(accept_uri: false, accept_file: true)
+          JSON::Validator.validate!(SCHEMA, json, json: true)
+        rescue JSON::Schema::JsonParseError => ex
+          raise Imagemaster3000::Errors::ParsingError, ex
+        rescue JSON::Schema::ValidationError => ex
+          raise Imagemaster3000::Errors::ParsingError, "JSON is not valid according to JSON schema: #{ex.message}"
+        end
+      end
+
+      private_class_method :parse
+      private_class_method :validate
+    end
+  end
+end

data/lib/imagemaster3000/definitions/schemas/imagemaster3000-definition-schema.json

@@ -0,0 +1,238 @@
+{
+  "$schema":"http://json-schema.org/draft-04/schema#",
+  "additionalProperties":false,
+  "definitions":{
+    "source":{
+      "description":"Source file",
+      "id":"#source",
+      "title":"Source",
+      "type":"string"
+    },
+    "target":{
+      "description":"Target directory",
+      "id":"#target",
+      "title":"Target",
+      "type":"string"
+    },
+    "name":{
+      "description":"New name of the copied file",
+      "id":"#name",
+      "title":"Name",
+      "type":"string"
+    },
+    "copy":{
+      "additionalItems":false,
+      "id":"#copy",
+      "items":{
+        "additionalProperties":false,
+        "properties":{
+          "source":{
+            "$ref":"#/definitions/source"
+          },
+          "target":{
+            "$ref":"#/definitions/target"
+          },
+          "name":{
+            "$ref":"#/definitions/name"
+          }
+        },
+        "required":[
+          "source",
+          "target"
+        ],
+        "type":"object"
+      },
+      "type":"array"
+    },
+    "remove":{
+      "additionalItems":false,
+      "id":"#remove",
+      "items":{
+        "description":"File to remove",
+        "title":"File",
+        "type":"string"
+      },
+      "type":"array"
+    },
+    "actions":{
+      "additionalProperties":false,
+      "id":"#actions",
+      "properties":{
+        "copy":{
+          "$ref":"#/definitions/copy"
+        },
+        "remove":{
+          "$ref":"#/definitions/remove"
+        }
+      },
+      "type":"object"
+    },
+    "cpu":{
+      "description":"Minimum required CPU",
+      "id":"#cpu",
+      "title":"CPU",
+      "type":"integer"
+    },
+    "distribution":{
+      "description":"Distribution name",
+      "id":"#distribution",
+      "title":"Distribution",
+      "type":"string"
+    },
+    "name":{
+      "description":"Image name",
+      "id":"#name",
+      "title":"Name",
+      "type":"string"
+    },
+    "ram":{
+      "description":"Minimum required RAM",
+      "id":"#ram",
+      "title":"RAM",
+      "type":"integer"
+    },
+    "url":{
+      "description":"Image URL",
+      "id":"#url",
+      "title":"URL",
+      "type":"string"
+    },
+    "function":{
+      "description":"Hash function",
+      "id":"#function",
+      "title":"Function",
+      "type":"string"
+    },
+    "hash":{
+      "additionalProperties":false,
+      "id":"#hash",
+      "properties":{
+        "function":{
+          "$ref":"#/definitions/function"
+        }
+      },
+      "required":[
+        "function"
+      ],
+      "type":"object"
+    },
+    "file":{
+      "description":"URL to file with both signature and data",
+      "id":"#file",
+      "title":"File",
+      "type":"string"
+    },
+    "clearsign":{
+      "additionalProperties":false,
+      "id":"#clearsign",
+      "properties":{
+        "file":{
+          "$ref":"#/definitions/file"
+        }
+      },
+      "required":[
+        "file"
+      ],
+      "type":"object"
+    },
+    "data":{
+      "description":"URL to file with signed data",
+      "id":"#data",
+      "title":"Data",
+      "type":"string"
+    },
+    "signature_file":{
+      "description":"URL to file with signature",
+      "id":"#signature_file",
+      "title":"Signature",
+      "type":"string"
+    },
+    "detached":{
+      "additionalProperties":false,
+      "id":"#detached",
+      "properties":{
+        "data":{
+          "$ref":"#/definitions/data"
+        },
+        "signature":{
+          "$ref":"#/definitions/signature_file"
+        }
+      },
+      "required":[
+        "data",
+        "signature"
+      ],
+      "type":"object"
+    },
+    "signature":{
+      "additionalProperties":false,
+      "id":"#signature",
+      "properties":{
+        "clearsign":{
+          "$ref":"#/definitions/clearsign"
+        },
+        "detached":{
+          "$ref":"#/definitions/detached"
+        }
+      },
+      "type":"object"
+    },
+    "verification":{
+      "additionalProperties":false,
+      "id":"#verification",
+      "properties":{
+        "hash":{
+          "$ref":"#/definitions/hash"
+        },
+        "signature":{
+          "$ref":"#/definitions/signature"
+        }
+      },
+      "required":[
+        "hash",
+        "signature"
+      ],
+      "type":"object"
+    },
+    "version":{
+      "description":"Image version",
+      "id":"#version",
+      "title":"Version",
+      "type":"string"
+    }
+  },
+  "id":"imagemaster3000-definition-schema.json",
+  "properties":{
+    "actions":{
+      "$ref":"#/definitions/actions"
+    },
+    "cpu":{
+      "$ref":"#/definitions/cpu"
+    },
+    "distribution":{
+      "$ref":"#/definitions/distribution"
+    },
+    "name":{
+      "$ref":"#/definitions/name"
+    },
+    "ram":{
+      "$ref":"#/definitions/ram"
+    },
+    "url":{
+      "$ref":"#/definitions/url"
+    },
+    "verification":{
+      "$ref":"#/definitions/verification"
+    },
+    "version":{
+      "$ref":"#/definitions/version"
+    }
+  },
+  "required":[
+    "name",
+    "url",
+    "version",
+    "distribution"
+  ],
+  "type":"object"
+}

data/lib/imagemaster3000/definitions.rb

@@ -0,0 +1,5 @@
+module Imagemaster3000
+  module Definitions
+    autoload :Parser, 'imagemaster3000/definitions/parser'
+  end
+end

data/lib/imagemaster3000/entities/downloadable.rb

@@ -0,0 +1,47 @@
+require 'net/https'
+
+module Imagemaster3000
+  module Entities
+    module Downloadable
+      def download
+        logger.debug "Downloading image from #{url.inspect}"
+
+        uri = URI.parse url
+        filename = generate_filename(uri)
+        retrieve_image(uri, filename)
+
+        logger.debug "Image from #{url.inspect} was saved as #{filename.inspect}"
+        @file = filename
+        @size = File.size filename
+      rescue ::URI::InvalidURIError, ::IOError => ex
+        raise Imagemaster3000::Errors::DownloadError, ex
+      end
+
+      private
+
+      def retrieve_image(uri, filename)
+        use_ssl = uri.scheme == 'https'
+        Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
+          request = Net::HTTP::Get.new(uri)
+
+          http.request(request) do |response|
+            if response.is_a? Net::HTTPRedirection
+              retrieve_image URI.join(uri, response.header['location']), filename
+              break
+            end
+
+            response.value
+            open(filename, 'w') { |file| response.read_body { |chunk| file.write(chunk) } }
+          end
+        end
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, Net::HTTPBadResponse,
+             Net::HTTPHeaderSyntaxError, EOFError, Net::HTTPServerException, Net::HTTPRetriableError => ex
+        raise Imagemaster3000::Errors::DownloadError, ex
+      end
+
+      def generate_filename(uri)
+        File.join(Imagemaster3000::Settings[:'image-dir'], File.basename(uri.path))
+      end
+    end
+  end
+end

data/lib/imagemaster3000/entities/image.rb

@@ -0,0 +1,92 @@
+module Imagemaster3000
+  module Entities
+    class Image
+      include Downloadable
+
+      attr_accessor :name, :url, :distribution, :version, :ram, :cpu, :actions, :verification, :file, :size
+
+      def initialize(name: nil, url: nil, distribution: nil, version: nil, ram: nil, cpu: nil, actions: nil, verification: nil)
+        raise Imagemaster3000::Errors::ArgumentError, 'name, url, distribution or version cannot be nil' \
+          if name.blank? || url.blank? || distribution.blank? || version.blank?
+
+        @name = name
+        @url = url
+        @distribution = distribution
+        @version = version
+        @ram = ram
+        @cpu = cpu
+        @actions = prepare_actions actions
+        @verification = prepare_verification verification
+
+        logger.debug "Created image #{inspect}"
+      end
+
+      private
+
+      def prepare_actions(actions_hash)
+        return nil if actions_hash.blank?
+        logger.debug 'Preparing actions'
+
+        namespace = Imagemaster3000::Actions
+        prepared_actions = []
+
+        actions_hash.each_pair do |action_name, array|
+          action_const_name = action_name.capitalize.to_sym
+          raise Imagemaster3000::Errors::ActionError, "No such action #{action_name.inspect}" \
+            unless namespace.constants.include? action_const_name
+
+          logger.debug "Recognized action #{action_name.inspect}"
+          action_const = namespace.const_get action_const_name
+          prepared_actions += array.map { |object| action_const.new(object) }
+        end
+
+        prepared_actions
+      end
+
+      def prepare_verification(verification_hash)
+        return nil if verification_hash.blank?
+        logger.debug 'Preparing verification'
+
+        extend Imagemaster3000::Verification::Verifiable
+        prepared_verification = {}
+
+        prepared_verification[:signature] = prepare_signature_verification verification_hash[:signature]
+        prepared_verification[:hash] = prepare_hash_verification verification_hash[:hash]
+
+        prepared_verification
+      end
+
+      def prepare_signature_verification(signature_hash)
+        logger.debug 'Preparing signature verification'
+        namespace = Imagemaster3000::Verification::Signatures
+        signature_name = signature_hash.keys.first
+        signature_const_name = signature_name.capitalize.to_sym
+
+        raise Imagemaster3000::Errors::VerificationError, "No such signature type #{signature_name}" \
+          unless namespace.constants.include? signature_const_name
+
+        logger.debug "Recognized signature #{signature_name}"
+        extend namespace.const_get(signature_const_name)
+
+        signature_hash[signature_name]
+      end
+
+      def prepare_hash_verification(hash_hash)
+        logger.debug 'Preparing hash verification'
+        extend Imagemaster3000::Verification::Hash
+
+        hash_function_name = hash_hash[:function]
+        hash_function_const_name = hash_function_name.upcase.to_sym
+
+        begin
+          Digest(hash_function_const_name)
+        rescue LoadError
+          raise Imagemaster3000::Errors::VerificationError, "No such hash function #{hash_function_name}"
+        end
+
+        logger.debug "Recognized hash function #{hash_function_name}"
+        { function: Digest.const_get(hash_function_const_name) }
+      end
+    end
+  end
+end

data/lib/imagemaster3000/entities.rb

@@ -0,0 +1,6 @@
+module Imagemaster3000
+  module Entities
+    autoload :Image, 'imagemaster3000/entities/image'
+    autoload :Downloadable, 'imagemaster3000/entities/downloadable'
+  end
+end

data/lib/imagemaster3000/errors/action_error.rb

@@ -0,0 +1,5 @@
+module Imagemaster3000
+  module Errors
+    class ActionError < StandardError; end
+  end
+end