Plugins » Docker

      $('#wizard_states_image_registry_id').val('');

    data: { search: item.val(), registry_id: $('#wizard_states_image_registry_id').val() },

  $.getJSON( tag.data("url"), { search: $('#search').val(), registry_id: $('#wizard_states_image_registry_id').val() },

    data: { search: $('#search').val(), registry_id: $('#wizard_states_image_registry_id').val() },

    before_filter :find_state

    # rubocop:disable Metrics/CyclomaticComplexity

        @container_resources = allowed_resources.select { |cr| cr.provider == 'Docker' }

        @preliminary = @state.preliminary || @state.build_preliminary

      when :image

        @image = @state.image || @state.build_image

      when :configuration

        @configuration = @state.configuration || @state.build_configuration

      when :environment

        @environment = @state.environment || @state.build_environment

        @state.create_preliminary!(params[:docker_container_wizard_states_preliminary])

        @state.create_image!(params[:docker_container_wizard_states_image])

        @state.create_configuration!(params[:docker_container_wizard_states_configuration])

        @state.create_environment!(params[:docker_container_wizard_states_environment])

        container = Service::Containers.start_container!(@state)

        if container

          return redirect_to container_path(container)

          @environment = @state.environment

          process_error(:object => @state.environment, :render => 'environment')

      render_wizard @state

    def find_state

      @state = DockerContainerWizardState.find(params[:wizard_state_id])

  before_filter :find_container, :only => [:show, :commit]

    redirect_to wizard_state_step_path(

                    :wizard_state_id => DockerContainerWizardState.create!.id,

                    :id => :preliminary)

class ImageSearchController < ::ApplicationController

  before_filter :find_resource

  def auto_complete_repository_name

    render :text => (use_hub? ? hub_image_exists?(params[:search]) :

        registry_image_exists?(params[:search])).to_s

  end

  def auto_complete_image_tag

    # This is the format jQuery UI autocomplete expects

    tags = use_hub? ? hub_auto_complete_image_tags(params[:search]) :

        registry_auto_complete_image_tags(params[:search])

    respond_to do |format|

      format.js do

        tags.map! { |tag| { :label => CGI.escapeHTML(tag), :value => CGI.escapeHTML(tag) } }

        render :json => tags

      end

    end

  end

  def search_repository

    images = use_hub? ? hub_search_image(params[:search]) : registry_search_image(params[:search])

    respond_to do |format|

      format.js { render :partial => 'repository_search_results', :locals => { :images => images } }

    end

  end

  def use_hub?

    @registry.nil?

  end

  def hub_image_exists?(terms)

    @cr.exist?(terms)

  end

  def hub_auto_complete_image_tags(terms)

    @cr.tags(terms)

  end

  def hub_search_image(terms)

    @cr.search(terms)

  end

  def registry_image_exists?(term)

    result = ::Service::RegistryApi.new(:url => @registry.url).search(term)

    registry_name = term.split('/').size > 1 ? term :

        'library/' + term

    result['results'].any? { |r| r['name'] == registry_name }

  end

  def registry_auto_complete_image_tags(terms)

    ::Service::RegistryApi.new(:url => @registry.url).list_repository_tags(terms).keys

  end

  def registry_search_image(terms)

    r = ::Service::RegistryApi.new(:url => @registry.url).search(terms)

    r['results']

  end

  def action_permission

    case params[:action]

    when 'auto_complete_repository_name', 'auto_complete_image_tag', 'search_repository'

      :search_repository

    else

      super

    end

  end

  def find_resource

    if !params[:registry_id].empty?

      @registry = DockerRegistry.authorized(:view_registries).find(params[:registry_id])

    else

      @cr = ComputeResource.authorized(:view_compute_resources).find(params[:id])

    end

  rescue ActiveRecord::RecordNotFound

    not_found

  end

end

    registries = DockerRegistry.with_taxonomy_scope_override(@location, @organization)

      .authorized(:view_registries)

    field(f, 'docker_container_wizard_states_image[registry_id]', :label => _("Registry")) do

      collection_select :wizard_states_image, :registry_id,

                        registries,

                        :class => "form-control", :disabled => registries.size == 0

                                   :class_name => 'EnvironmentVariable',

                                   :validate => false

class DockerContainerWizardState < ActiveRecord::Base

  has_one :preliminary, :class_name => DockerContainerWizardStates::Preliminary,

          :dependent => :destroy, :validate => true, :autosave => true

  has_one :image, :class_name => DockerContainerWizardStates::Image,

          :dependent => :destroy, :validate => true, :autosave => true

  has_one :configuration, :class_name => DockerContainerWizardStates::Configuration,

          :dependent => :destroy, :validate => true, :autosave => true

  has_one :environment, :class_name => DockerContainerWizardStates::Environment,

          :dependent => :destroy, :validate => true, :autosave => true

  delegate :compute_resource_id, :to => :preliminary

  delegate :environment_variables, :to => :environment

  def container_attributes

    { :repository_name => image.repository_name,

      :tag => image.tag,

      :registry_id => image.registry_id,

      :name  => configuration.name,

      :compute_resource_id => preliminary.compute_resource_id,

      :tty => environment.tty,

      :memory => configuration.memory,

      :entrypoint => configuration.entrypoint,

      :command => configuration.command,

      :attach_stdout => environment.attach_stdout,

      :attach_stdin => environment.attach_stdin,

      :attach_stderr => environment.attach_stderr,

      :cpu_shares => configuration.cpu_shares,

      :cpu_set => configuration.cpu_set }

  end

end

module DockerContainerWizardStates

  class Configuration < ActiveRecord::Base

    self.table_name_prefix = 'docker_container_wizard_states_'

    belongs_to :wizard_state, :class_name => DockerContainerWizardState,

                              :foreign_key => :docker_container_wizard_state_id

  end

end

module DockerContainerWizardStates

  class Environment < ActiveRecord::Base

    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

    accepts_nested_attributes_for :environment_variables, :allow_destroy => true

    def parameters_symbol

      :environment_variables

    end

  end

end

module DockerContainerWizardStates

  class EnvironmentVariable < Parameter

    belongs_to :environment, :foreign_key => :reference_id, :inverse_of => :environment_variables,

               :class_name => 'DockerContainerWizardStates::Environment'

    validates :name, :uniqueness => { :scope => :reference_id }

  end

end

module DockerContainerWizardStates

  class Image < ActiveRecord::Base

    self.table_name_prefix = 'docker_container_wizard_states_'

    belongs_to :wizard_state, :class_name => DockerContainerWizardState,

                              :foreign_key => :docker_container_wizard_state_id

    delegate :compute_resource_id, :to => :wizard_state

    validates :tag,   :presence => true

    validates :repository_name, :presence => true

  end

end

module DockerContainerWizardStates

  class Preliminary < ActiveRecord::Base

    self.table_name_prefix = 'docker_container_wizard_states_'

    belongs_to :wizard_state, :class_name => DockerContainerWizardState,

                              :foreign_key => :docker_container_wizard_state_id

    validates :compute_resource_id, :presence => true

  end

end

module Service

  class Containers

    def self.start_container!(wizard_state)

      ActiveRecord::Base.transaction do

        container = Container.new(wizard_state.container_attributes) do |r|

          # eagerly load environment variables

          state = DockerContainerWizardState.includes(:environment => [:environment_variables])

            .find(wizard_state.id)

          state.environment_variables.each do |e|

            r.environment_variables.build(

                :name => e.name, :value => e.value, :priority => e.priority)

          end

        end

        started = start_container(container)

        fail ActiveRecord::Rollback unless started

        container.save!

        destroy_wizard_state(wizard_state)

        container

      end

    end

    def self.start_container(container)

      started = container.compute_resource.create_container(container.parametrize)

      container.uuid = started.id if started

      started

    end

    def self.destroy_wizard_state(wizard_state)

      wizard_state.destroy

      DockerContainerWizardState.destroy_all(["updated_at < ?", (Time.now - 24.hours)])

    end

  end

end

  <%= form_for @configuration, :url => wizard_path, :method => :put do |f| %>

  <%= form_for @environment, :url => wizard_path, :method => :put do |f| %>

        <%= f.fields_for :environment_variables, @environment.environment_variables do |builder| %>

    <%= form_for @image, :class => 'form-horizontal', :url => wizard_path, :method => :put do |f| %>

              <%= label_tag "image_id", _('Search'), :class=>"col-sm-2 control-label" %>

                <%= auto_complete_docker_search('docker_container_wizard_states_image[repository_name]', '',

                                         :'data-url'  => auto_complete_repository_name_image_search_path(@image.compute_resource_id),

                                 :'data-url' => search_repository_image_search_path(@image.compute_resource_id),

                          :'data-url' => auto_complete_image_tag_image_search_path(@image.compute_resource_id) %>

  <%= form_for @preliminary, :url => wizard_path, :method => :put do |f| %>

        <%= select_f f, 'compute_resource_id', @container_resources, :id, :to_label, {}, { :label => _('Deploy on') } %>

<% repositories.each do |repository| %>

    <h3><%= link_to repository['name'], '#', :onclick => 'repoSelected(this)' %></h3>

    <p>

      <%= '<span class="glyphicon glyphicon-certificate" title="Official"></span>'.html_safe if repository['is_official'] %>

      <%= '<span class="glyphicon glyphicon-thumbs-up" title="Trusted"></span>'.html_safe    if repository['is_trusted'] %>

      <span class="glyphicon glyphicon-star"></span> <%= repository['star_count'] %>

    </p>

    <p>

      <%= trunc(repository['description']) %>

      <%= link_to '<span class="glyphicon glyphicon-share"></span>'.html_safe, hub_url(repository), :target => '_blank' %>

    </p>

<% end %>

  end

  resources :wizard_states, :only => [] do

  end

  resources :image_search, :only => [] do

    get :auto_complete_image_tag, :on => :member

      fail NotImplementedError, "Unknown adapter type '#{connection.adapter_name.downcase.to_sym}'"

class CreateWizardStates < ActiveRecord::Migration

  # rubocop:disable Metrics/MethodLength

  def change

    create_table :docker_container_wizard_states do |t|

      t.timestamps

    end

    create_table :docker_container_wizard_states_preliminaries do |t|

      t.integer :compute_resource_id, :null => false

      t.references :docker_container_wizard_state, :null => false

      t.timestamps

    end

    create_table  :docker_container_wizard_states_images do |t|

      t.integer :registry_id

      t.string :repository_name, :null => false

      t.string :tag, :null => false

      t.references :docker_container_wizard_state, :null => false

      t.timestamps

    end

    create_table  :docker_container_wizard_states_configurations do |t|

      t.string :name

      t.string :command

      t.string :entrypoint

      t.integer :cpu_set

      t.float :cpu_shares

      t.string :memory

      t.references :docker_container_wizard_state, :null => false

      t.timestamps

    end

    create_table :docker_container_wizard_states_environments do |t|

      t.boolean :tty

      t.boolean :attach_stdin, :default => true

      t.boolean :attach_stdout, :default => true

      t.boolean :attach_stderr, :default => true

      t.references :docker_container_wizard_state, :null => false

      t.timestamps

    end

  end

end

          permission :view_containers,    :containers         => [:index, :show]

        security_block :image_search do

          permission :search_repository_image_search,

                     :image_search => [:auto_complete_repository_name,

                                       :auto_complete_image_tag,

                                       :search_repository]

        end

      state = DockerContainerWizardState.create!

      Service::Containers.expects(:start_container!).with(equals(state)).returns(@container)

      put :update, { :wizard_state_id => state.id,

                     :id => :environment,

                     :docker_container_wizard_states_environment => { :tty => false } },

          set_session_user

require 'test_plugin_helper'

class ContainersServiceTest <  ActiveSupport::TestCase

  setup do

    @state = DockerContainerWizardState.create! do |s|

      s.build_preliminary(:compute_resource_id => FactoryGirl.create(:docker_cr).id)

      s.build_image(:repository_name => 'test', :tag => 'test')

      s.build_configuration(:name => 'test')

      s.build_environment(:tty => false)

    end

  end

  test 'removes current state after successful container creation' do

    ForemanDocker::Docker.any_instance

      .expects(:create_container)

      .returns(OpenStruct.new(:uuid => 1))

    Service::Containers.start_container!(@state)

    assert DockerContainerWizardState.where(:id => @state.id).count == 0

  end

end