foreman_docker 3.0.0 → 3.1.0

data/app/models/container.rb

@@ -6,20 +6,19 @@ class Container < ActiveRecord::Base
   belongs_to :registry, :class_name => "DockerRegistry", :foreign_key => :registry_id
   has_many :environment_variables, :dependent  => :destroy, :foreign_key => :reference_id,
                                    :inverse_of => :container,
-                                   :class_name => 'EnvironmentVariable',
-                                   :validate => false
+                                   :class_name => 'EnvironmentVariable'
+
   accepts_nested_attributes_for :environment_variables, :allow_destroy => true
-  include ForemanDocker::ParameterValidators
 
   has_many :exposed_ports,  :dependent  => :destroy, :foreign_key => :reference_id,
                             :inverse_of => :container,
-                            :class_name => 'ExposedPort',
-                            :validate => true
+                            :class_name => 'ExposedPort'
 
   has_many :dns,  :dependent  => :destroy, :foreign_key => :reference_id,
                   :inverse_of => :container,
-                  :class_name => 'ForemanDocker::Dns',
-                  :validate => true
+                  :class_name => 'ForemanDocker::Dns'
+
+  include ForemanDocker::ParameterValidators
 
   accepts_nested_attributes_for :exposed_ports, :allow_destroy => true
   scoped_search :on => :name
@@ -41,10 +40,10 @@ class Container < ActiveRecord::Base
       'AttachStdout' => attach_stdout,          'AttachStdin'  => attach_stdin,
       'AttachStderr' => attach_stderr,          'CpuShares'    => cpu_shares,
       'Cpuset'       => cpu_set,
-      'Env' => environment_variables.map { |env| "#{env.name}=#{env.value}" },
-      'ExposedPorts' => Hash[*exposed_ports.map { |v| [v.name + "/" + v.value, {}] }.flatten],
+      'Env' => environment_variables.map { |env| "#{env.key}=#{env.value}" },
+      'ExposedPorts' => Hash[*exposed_ports.map { |v| [v.key + "/" + v.value, {}] }.flatten],
       'HostConfig' => {
-        'Dns' => dns.map { |env| "#{env.name}" }
+        'Dns' => dns.map { |env| "#{env.key}" }
       } }
   end
 

data/app/models/docker_container_wizard_state.rb

@@ -9,6 +9,8 @@ class DockerContainerWizardState < ActiveRecord::Base
                         :dependent => :destroy, :validate => true, :autosave => true
 
   delegate :compute_resource_id,   :to => :preliminary
+  delegate :compute_resource, :to => :preliminary
+
   delegate :environment_variables, :to => :environment
   delegate :exposed_ports, :to => :environment
   delegate :dns, :to => :environment

data/app/models/docker_container_wizard_states/dns.rb

@@ -1,17 +1,11 @@
 require 'resolv'
 
 module DockerContainerWizardStates
-  class Dns < Parameter
-    # The Parameter class from which this Dns class inherits,validates for the
-    # presence of an associated domain,  operating system, host or host group.
-    # We will have to reset those validations for the Dns class as they do not
-    # make any sense for the context in which this class is being used here.
-    Dns.reset_callbacks(:validate)
-
+  class Dns < DockerParameter
     belongs_to :environment,  :foreign_key => :reference_id,
                               :inverse_of => :dns,
                               :class_name => 'DockerContainerWizardStates::Environment'
-    validates :name, :uniqueness => { :scope => :reference_id },
+    validates :key, :uniqueness => { :scope => :reference_id },
                      :format => {
                        :with => Regexp.union(Resolv::IPv4::Regex,
                                              Resolv::IPv6::Regex,

data/app/models/docker_container_wizard_states/environment.rb

@@ -3,32 +3,22 @@ module DockerContainerWizardStates
     self.table_name_prefix = 'docker_container_wizard_states_'
     belongs_to :wizard_state, :class_name => DockerContainerWizardState
 
-    # Fix me:
-    # Validations are off on this association as there's a bug in ::Parameter
-    # that forces validation of reference_id. This will fail on new records as
-    # validations are executed before parent and children records have been persisted.
     has_many :environment_variables, :dependent  => :destroy, :foreign_key => :reference_id,
                                      :inverse_of => :environment,
                                      :class_name =>
-                                       'DockerContainerWizardStates::EnvironmentVariable',
-                                     :validate => false
-    include ::ParameterValidators
+                                       'DockerContainerWizardStates::EnvironmentVariable'
 
     has_many :exposed_ports,  :dependent  => :destroy, :foreign_key => :reference_id,
                               :inverse_of => :environment,
-                              :class_name => 'DockerContainerWizardStates::ExposedPort',
-                              :validate => true
+                              :class_name => 'DockerContainerWizardStates::ExposedPort'
     has_many :dns,  :dependent  => :destroy, :foreign_key => :reference_id,
                     :inverse_of => :environment,
-                    :class_name => 'DockerContainerWizardStates::Dns',
-                    :validate => true
+                    :class_name => 'DockerContainerWizardStates::Dns'
 
+    include ForemanDocker::ParameterValidators
     accepts_nested_attributes_for :environment_variables, :allow_destroy => true
     accepts_nested_attributes_for :exposed_ports, :allow_destroy => true
     accepts_nested_attributes_for :dns, :allow_destroy => true
 
-    def parameters_symbol
-      :environment_variables
-    end
   end
 end

data/app/models/docker_container_wizard_states/environment_variable.rb

@@ -1,7 +1,7 @@
 module DockerContainerWizardStates
-  class EnvironmentVariable < Parameter
+  class EnvironmentVariable < DockerParameter
     belongs_to :environment, :foreign_key => :reference_id, :inverse_of => :environment_variables,
                              :class_name => 'DockerContainerWizardStates::Environment'
-    validates :name, :uniqueness => { :scope => :reference_id }
+    validates :key, :uniqueness => { :scope => :reference_id }
   end
 end

data/app/models/docker_container_wizard_states/exposed_port.rb

@@ -1,14 +1,8 @@
 module DockerContainerWizardStates
-  class ExposedPort < Parameter
-    # The Parameter class from which ExposedPort class inherits,validates for the
-    # presence of an  associated domain, operating system, host or host group. We
-    # will have to reset those validations for the  ExposedPort class as  they do
-    # not make any sense for the context in which this class is being used here.
-    ExposedPort.reset_callbacks(:validate)
-
+  class ExposedPort < DockerParameter
     belongs_to :environment,  :foreign_key => :reference_id, :inverse_of => :exposed_ports,
                               :class_name => 'DockerContainerWizardStates::Environment'
-    validates :name,  :uniqueness => { :scope => :reference_id },
+    validates :key,  :uniqueness => { :scope => :reference_id },
                       :numericality => { :only_integer => true,
                                          :greater_than => 0,
                                          :less_than_or_equal_to => 655_35 }

data/app/models/docker_container_wizard_states/image.rb

@@ -4,8 +4,38 @@ module DockerContainerWizardStates
     belongs_to :wizard_state, :class_name => DockerContainerWizardState,
                               :foreign_key => :docker_container_wizard_state_id
     delegate :compute_resource_id, :to => :wizard_state
+    delegate :compute_resource, :to => :wizard_state
 
     validates :tag,             :presence => true
     validates :repository_name, :presence => true
+    validate :image_exists
+
+    def name
+      "#{repository_name}:#{tag}"
+    end
+
+    def registry_api
+      if registry_id
+        DockerRegistry.find(registry_id).api
+      else
+        Service::RegistryApi.docker_hub
+      end
+    end
+
+    def sources
+      [compute_resource, registry_api]
+    end
+
+    def image_search_service
+      ForemanDocker::ImageSearch.new(*sources)
+    end
+
+    def image_exists
+      return true if image_search_service.available?(name)
+      error_msg = _("Container image %{image_name} is not available.") % {
+        image_name: "#{name}",
+      }
+      errors.add(:image, error_msg)
+    end
   end
 end

data/app/models/docker_container_wizard_states/preliminary.rb

@@ -6,7 +6,7 @@ module DockerContainerWizardStates
     belongs_to :wizard_state, :class_name => DockerContainerWizardState,
                               :foreign_key => :docker_container_wizard_state_id
 
-    validates :compute_resource_id, :presence => true
+    belongs_to :compute_resource, :required => true
 
     def used_location_ids
       Location.joins(:taxable_taxonomies).where(

data/app/models/docker_parameter.rb

@@ -0,0 +1,20 @@
+class DockerParameter < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :key
+  include Parameterizable::ByIdName
+
+  validates_lengths_from_database
+
+  include Authorizable
+  validates :key, :presence => true, :no_whitespace => true
+
+  scoped_search :on => :key, :complete_value => true
+
+  default_scope -> { order("docker_parameters.key") }
+
+  before_validation :strip_whitespaces
+
+  def strip_whitespaces
+    self.value.strip! unless value.blank?
+  end
+end

data/app/models/docker_registry.rb

@@ -42,13 +42,15 @@ class DockerRegistry < ActiveRecord::Base
     _("Docker/Registry")
   end
 
+  def api
+    @api ||= Service::RegistryApi.new(url: url, user: username,
+                                      password: password)
+  end
+
   private
 
   def attempt_login
-    login_endpoint = RestClient::Resource.new(url + '/v1/users',
-                                              :user => username,
-                                              :password => password)
-    login_endpoint.get == "\"OK\""
+    api.ok?
   rescue => e
     errors.add(:base, _('Unable to log in to this Docker Registry - %s') % e)
   end

data/app/models/environment_variable.rb

@@ -1,5 +1,5 @@
-class EnvironmentVariable < Parameter
+class EnvironmentVariable < DockerParameter
   belongs_to :container, :foreign_key => :reference_id, :inverse_of => :environment_variables
-  audited :except => [:priority], :associated_with => :container, :allow_mass_assignment => true
-  validates :name, :uniqueness => { :scope => :reference_id }
+  audited :associated_with => :container, :allow_mass_assignment => true
+  validates :key, :uniqueness => { :scope => :reference_id }
 end

data/app/models/exposed_port.rb

@@ -1,14 +1,8 @@
-class ExposedPort < Parameter
-  # The Parameter class from which ExposedPort class inherits,validates for the
-  # presence of an  associated domain, operating system, host or host group. We
-  # will have to reset those validations for the  ExposedPort class as  they do
-  # not make any sense for the context in which this class is being used here.
-  ExposedPort.reset_callbacks(:validate)
-
+class ExposedPort < DockerParameter
   belongs_to :container, :foreign_key => :reference_id, :inverse_of => :exposed_ports
-  audited :except => [:priority], :associated_with => :container, :allow_mass_assignment => true
-  validates :name,  :uniqueness => { :scope => :reference_id }
-  validates :name,  :numericality => { :only_integer => true,
+  audited :associated_with => :container, :allow_mass_assignment => true
+  validates :key,  :uniqueness => { :scope => :reference_id }
+  validates :key,  :numericality => { :only_integer => true,
                                        :greater_than => 0,
                                        :less_than_or_equal_to => 655_35,
                                        :message => "%{value} is not a valid port number" }

data/app/models/foreman_docker/compute_resource_extensions.rb

@@ -0,0 +1,11 @@
+module ForemanDocker
+  module ComputeResourceExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      def self.providers_requiring_url
+        _("Docker, Libvirt, oVirt, OpenStack and Rackspace")
+      end
+    end
+  end
+end

data/app/models/foreman_docker/dns.rb

@@ -1,19 +1,13 @@
 require 'resolv'
 
 module ForemanDocker
-  class Dns < Parameter
-    # The Parameter class from which this Dns class inherits,validates for the
-    # presence of an associated domain,  operating system, host or host group.
-    # We will have to reset those validations for the Dns class as they do not
-    # make any sense for the context in which this class is being used here.
-    ForemanDocker::Dns.reset_callbacks(:validate)
-
+  class Dns < DockerParameter
     belongs_to :container, :foreign_key => :reference_id,
                            :inverse_of => :dns,
                            :class_name => "Container"
 
-    audited :except => [:priority], :associated_with => :container, :allow_mass_assignment => true
-    validates :name, :uniqueness => { :scope => :reference_id },
+    audited :associated_with => :container, :allow_mass_assignment => true
+    validates :key, :uniqueness => { :scope => :reference_id },
                      :format => {
                        :with => Regexp.union(Resolv::IPv4::Regex,
                                              Resolv::IPv6::Regex,

data/app/models/foreman_docker/docker.rb

@@ -61,11 +61,7 @@ module ForemanDocker
       if exist?(image_name)
         tags_for_local_image(image(image_name))
       else
-        # If image is not found in the compute resource, get the tags from the Hub
-        hub_api_url = "https://index.docker.io/v1/repositories/#{image_name}/tags"
-        JSON.parse(URI.parse(hub_api_url).read).map do |tag|
-          tag['name']
-        end
+        Service::RegistryApi.docker_hub.tags(image_name).map { |tag| tag['name'] }
       end
     end
 

data/app/models/service/containers.rb

@@ -41,9 +41,14 @@ module Service
 
       pull_image(container)
       start_container(container)
-      errors << container.errors unless container.valid?
+      unless container.valid?
+        @errors = errors + container.errors.full_messages
+      end
 
-      fail ActiveRecord::Rollback if @errors.present?
+      if @errors.present?
+        @errors = @errors.flatten.uniq
+        fail ActiveRecord::Rollback
+      end
 
       container.name = container.in_fog.name[1..-1] unless container.name.present?
 
@@ -53,7 +58,8 @@ module Service
     def pull_image(container)
       success = container.compute_resource.
         create_image(:fromImage => container.repository_pull_url)
-      errors << container.compute_resource.errors[:base] unless success
+      return true if success
+      @errors = errors + container.compute_resource.errors.full_messages
     end
 
     def start_container(container)
@@ -61,7 +67,7 @@ module Service
       if started
         container.uuid = started.id
       else
-        errors << container.compute_resource.errors[:base]
+        @errors = errors + container.compute_resource.errors.full_messages
       end
       started
     end
@@ -74,31 +80,29 @@ module Service
     def load_environment_variables(state, r)
       state.environment_variables.each do |environment_variable|
         var = r.environment_variables.build
-        var.name = environment_variable.name
+        var.key = environment_variable.key
         var.value = environment_variable.value
-        var.priority = environment_variable.priority
       end
     end
 
     def load_exposed_ports(state, r)
       state.exposed_ports.each do |e|
         port = r.exposed_ports.build
-        port.name = e.name
+        port.key = e.key
         port.value = e.value
-        port.priority = e.priority
       end
     end
 
     def load_dns(state, r)
       state.dns.each do |e|
         dns = r.dns.build
-        dns.name = e.name
-        dns.priority = e.priority
+        dns.key = e.key
       end
     end
 
     def full_messages
-      errors.respond_to?(:full_messages) ? errors.full_messages : errors
+      return errors.full_messages if errors.respond_to?(:full_messages)
+      @errors
     end
 
     def run_container(container)

data/app/models/service/registry_api.rb

@@ -1,26 +1,98 @@
 module Service
   class RegistryApi
-    DEFAULTS = { :url => 'http://localhost:5000' }
-    attr_reader :config
+    DOCKER_HUB = 'https://registry.hub.docker.com/'.freeze
+    DEFAULTS = {
+      url: 'http://localhost:5000'.freeze,
+      connection: { omit_default_port: true }
+    }
+
+    attr_accessor :config, :url
+    delegate :logger, :to => Rails
 
     def initialize(params = {})
-      config = DEFAULTS.merge(params)
-      uri = URI(config.delete(:url))
-      uri.user = config.delete(:user) unless config[:user].blank?
-      uri.password = config.delete(:password) unless config[:password].blank?
-      @config = config.merge(:url => uri.to_s)
+      self.config = DEFAULTS.merge(params)
+      self.url = config[:url]
+      @user = config[:user] unless config[:user].blank?
+      @password = config[:password] unless config[:password].blank?
+
+      Docker.logger = logger if Rails.env.development? || Rails.env.test?
+    end
+
+    def connection
+      @connection ||= ::Docker::Connection.new(url, credentials)
+    end
+
+    def get(path, params = nil)
+      response = connection.get('/'.freeze, params,
+                                DEFAULTS[:connection].merge({ path: "#{path}" }))
+      response = parse_json(response)
+      response
+    end
+
+    # Since the Registry API v2 does not support a search the v1 endpoint is used
+    # Newer registries will fail, the v2 catalog endpoint is used
+    def search(query)
+      get('/v1/search'.freeze, { q: query })
+    rescue => e
+      logger.warn "API v1 - Search failed #{e.backtrace}"
+      { 'results' => catalog(query) }
+    end
+
+    # Some Registries might have this endpoint not implemented/enabled
+    def catalog(query)
+      get('/v2/_catalog'.freeze)['repositories'].select do |image|
+        image =~ /^#{query}/
+      end.map { |image_name| { 'name' => image_name } }
+    end
+
+    def tags(image_name, query = nil)
+      result = get_tags(image_name)
+      result = result.keys.map { |t| {'name' => t.to_s } } if result.is_a? Hash
+      result = filter_tags(result, query) if query
+      result
+    end
+
+    def ok?
+      get('/v1/'.freeze).match("Docker Registry API")
+    rescue => e
+      logger.warn "API v1 - Ping failed #{e.backtrace}"
+      get('/v2/'.freeze).is_a? Hash
+    end
+
+    def self.docker_hub
+      @@docker_hub ||= new(url: DOCKER_HUB)
+    end
+
+    private
+
+    def parse_json(string)
+      JSON.parse(string)
+    rescue => e
+      logger.warn "JSON parsing failed: #{e.backtrace}"
+      string
+    end
+
+    def get_tags(image_name)
+      get("/v1/repositories/#{image_name}/tags")
+    rescue => e
+      logger.warn "API v1 - Repository images request failed #{e.backtrace}"
+      tags_v2(image_name)
+    end
+
+    def tags_v2(image_name)
+      get("/v2/#{image_name}/tags/list")['tags'].map { |tag| { 'name' => tag } }
+    rescue Docker::Error::NotFoundError
+      []
     end
 
-    def search(aquery)
-      response = RestClient.get(config[:url] + '/v1/search',
-                                :params => { :q => aquery }, :accept => :json)
-      JSON.parse(response.body)
+    def credentials
+      { user: @user, password: @password }
     end
 
-    def list_repository_tags(arepository)
-      response = RestClient.get(config[:url] + "/v1/repositories/#{arepository}/tags",
-                                :accept => :json)
-      JSON.parse(response.body)
+    def filter_tags(result, query)
+      result.select do |tag_name|
+        tag_name['name'] =~ /^#{query}/
+      end
     end
   end
 end