percheron 0.5.0 → 0.6.0

data/lib/percheron/container/actions/create.rb

@@ -1,56 +0,0 @@
-module Percheron
-  module Container
-    module Actions
-      class Create
-
-        include Base
-
-        def initialize(container)
-          @container = container
-        end
-
-        def execute!
-          build!
-          insert_post_start_scripts!
-          create!
-        end
-
-        private
-
-          attr_reader :container
-
-          def create_opts
-            {
-              'name'          => container.name,
-              'Image'         => container.image_name,
-              'Hostname'      => container.name,
-              'Env'           => container.env,
-              'ExposedPorts'  => container.exposed_ports,
-              'VolumesFrom'   => container.volumes
-            }
-          end
-
-          def build!
-            unless container.image
-              $logger.debug "Creating '#{container.image_name}' image"
-              Container::Actions::Build.new(container).execute!
-            end
-          end
-
-          def create!
-            $logger.debug "Creating '#{container.name}' container"
-            Docker::Container.create(create_opts)
-          end
-
-          def insert_post_start_scripts!
-            container.post_start_scripts.each do |script|
-              file = Pathname.new(File.expand_path(script, base_dir))
-              new_image = container.image.insert_local('localPath' => file.to_s, 'outputPath' => "/tmp/#{file.basename}")
-              new_image.tag(repo: container.name, tag: container.version.to_s, force: true)
-            end
-          end
-
-      end
-    end
-  end
-end

data/lib/percheron/container/actions/recreate.rb

@@ -1,110 +0,0 @@
-module Percheron
-  module Container
-    module Actions
-      class Recreate
-
-        include Base
-
-        def initialize(container)
-          @container = container
-        end
-
-        def execute!
-          unless temporary_container_exists?
-            create_image!
-            create_container!
-            rename!
-          else
-            $logger.warn "Not recreating '#{container.name}' container as '#{temporary_name}' because '#{temporary_name}' already exists"
-          end
-        end
-
-        private
-
-          attr_reader :container
-
-          def create_opts
-            {
-              'name'          => temporary_name,
-              'Image'         => container.image_name,
-              'Hostname'      => container.name,
-              'Env'           => container.env,
-              'ExposedPorts'  => container.exposed_ports,
-              'VolumesFrom'   => container.volumes
-            }
-          end
-
-          def temporary_name
-            '%s_wip' % container.name
-          end
-
-          # FIXME: brittle
-          def temporary_container_exists?
-            temporary_container.info.empty?
-          rescue Docker::Error::NotFoundError
-            false
-          end
-
-          def create_image!
-            unless container.image
-              $logger.debug "Creating '#{container.image_name}' image"
-              Container::Actions::Build.new(container).execute!
-            end
-          end
-
-          def create_container!
-            $logger.debug "Recreating '#{container.name}' container as '#{temporary_name}'"
-            Docker::Container.create(create_opts)
-          end
-
-          def rename!
-            save_current_running_state!
-            stop_current! if container.running?
-            rename_current_to_old!
-            rename_wip_to_current!
-            start_new! if container_was_running?
-          end
-
-          def rename_current_new_name
-            '%s_%s' % [ container.name, now_timestamp ]
-          end
-
-          def now_timestamp
-            Time.now.strftime('%Y%m%d%H%M%S')
-          end
-
-          def temporary_container
-            Docker::Container.get(temporary_name)
-          end
-
-          def save_current_running_state!
-            @container_was_running = container.running?
-          end
-
-          def stop_current!
-            Container::Actions::Stop.new(container).execute!
-          end
-
-          def rename_current_to_old!
-            $logger.debug "Renaming '#{container.name}' container to '#{rename_current_new_name}'"
-            container.docker_container.rename(rename_current_new_name)
-          end
-
-          def rename_wip_to_current!
-            # FIXME: brittle
-            $logger.debug "Renaming '#{temporary_name}' container to '#{container.name}'"
-            Docker::Container.get(temporary_name).rename(container.name)
-          end
-
-          def start_new!
-            container.start!
-          end
-
-          def container_was_running?
-            @container_was_running
-          end
-
-      end
-    end
-  end
-end

data/lib/percheron/container/actions/start.rb

@@ -1,58 +0,0 @@
-module Percheron
-  module Container
-    module Actions
-      class Start
-
-        include Base
-
-        def initialize(container)
-          @container = container
-        end
-
-        def execute!
-          if container.exists?
-            start!
-            execute_post_start_scripts!
-          else
-            raise Errors::ContainerDoesNotExist.new
-          end
-        end
-
-        private
-
-          attr_reader :container
-
-          def start_opts
-            opts = container.ports.inject({}) do |all, p|
-              destination, source = p.split(':')
-              all[source] = [ { 'HostPort' => destination } ]
-              all
-            end
-
-            {
-              'PortBindings'  => opts,
-              'Links'         => container.links,
-              'Binds'         => container.volumes
-            }
-          end
-
-          def start!
-            $logger.debug "Starting '#{container.name}'"
-            container.docker_container.start!(start_opts)
-          end
-
-          def execute_post_start_scripts!
-            container.post_start_scripts.each do |script|
-              in_working_directory(base_dir) do
-                file = Pathname.new(File.expand_path(script, base_dir))
-                command = '/bin/bash -x /tmp/%s 2>&1' % file.basename
-                $logger.debug "Executing POST create '#{command}' for '#{container.name}' container"
-                container.docker_container.exec(command.split(' '))
-              end
-            end
-          end
-
-      end
-    end
-  end
-end

data/lib/percheron/container/actions/stop.rb

@@ -1,33 +0,0 @@
-module Percheron
-  module Container
-    module Actions
-      class Stop
-
-        include Base
-
-        def initialize(container)
-          @container = container
-        end
-
-        def execute!
-          stop!
-        end
-
-        private
-
-          attr_reader :container
-
-          def stop!
-            if container.running?
-              $logger.debug "Stopping '#{container.name}'"
-              container.docker_container.stop!
-            else
-              $logger.debug "Not stopping '#{container.name}' container as it's not running"
-              raise Errors::ContainerNotRunning.new
-            end
-          end
-
-      end
-    end
-  end
-end

data/lib/percheron/container/main.rb

@@ -1,193 +0,0 @@
-module Percheron
-  module Container
-    class Main
-
-      extend Forwardable
-      extend ConfigDelegator
-
-      def_delegators :container_config, :name
-
-      def_config_item_with_default :container_config, false, :auto_recreate
-      def_config_item_with_default :container_config, [], :env, :ports, :volumes, :dependant_container_names, :pre_build_scripts, :post_start_scripts
-
-      alias_method :auto_recreate?, :auto_recreate
-
-      def initialize(config, stack, container_name)
-        @config = config
-        @stack = stack
-        @container_name = container_name
-        valid?
-        self
-      end
-
-      def id
-        exists? ? info.id[0...12] : 'N/A'
-      end
-
-      def image
-        Docker::Image.get(image_name)
-      rescue Docker::Error::NotFoundError
-        nil
-      end
-
-      def image_name
-        '%s:%s' % [ name, version.to_s ]
-      end
-
-      def version
-        Semantic::Version.new(container_config.version)
-      end
-
-      def built_version
-        exists? ? Semantic::Version.new(built_image_version) : nil
-      end
-
-      def dockerfile
-        container_config.dockerfile ? Pathname.new(File.expand_path(container_config.dockerfile, config.file_base_path)): nil
-      end
-
-      def exposed_ports
-        ports.inject({}) do |all, p|
-          all[p.split(':')[1]] = {}
-          all
-        end
-      end
-
-      def links
-        dependant_container_names.map do |container_name|
-          '%s:%s' % [ container_name, container_name ]
-        end
-      end
-
-      def docker_container
-        Docker::Container.get(name)
-      rescue Docker::Error::NotFoundError, Excon::Errors::SocketError
-        Container::Null.new
-      end
-
-      def stop!
-        Container::Actions::Stop.new(self).execute!
-      rescue Errors::ContainerNotRunning
-        $logger.debug "Container '#{name}' is not running"
-      end
-
-      def start!
-        start_dependant_containers!
-        create!
-        recreate!
-        Container::Actions::Start.new(self).execute!
-      end
-
-      def restart!
-        stop!
-        start!
-      end
-
-      def create!
-        unless exists?
-          $logger.debug "Container '#{name}' does not exist, creating"
-          Container::Actions::Create.new(self).execute!
-          set_dockerfile_md5!
-        else
-          $logger.debug "Not creating '#{name}' container as it already exists"
-        end
-      end
-
-      def recreate!(force_recreate: false, force_auto_recreate: false)
-        if exists?
-          if recreate?(force_recreate: force_recreate, force_auto_recreate: force_auto_recreate)
-            $logger.warn "Container '#{name}' exists and will be recreated"
-            Container::Actions::Recreate.new(self).execute!
-            set_dockerfile_md5!
-          else
-            if recreatable?
-              $logger.warn "Container '#{name}' MD5's do not match, consider recreating"
-            else
-              $logger.debug "Container '#{name}' does not need to be recreated"
-            end
-          end
-        else
-          $logger.warn "Not recreating '#{name}' container as it does not exist"
-        end
-      end
-
-      def recreatable?
-        !dockerfile_md5s_match?
-      end
-
-      def recreate?(force_recreate: false, force_auto_recreate: false)
-        (force_recreate || (recreatable? && versions_mismatch?)) && (force_auto_recreate || auto_recreate?)
-      end
-
-      def running?
-        exists? && info.State.Running
-      end
-
-      def exists?
-        !info.empty?
-      end
-
-      def valid?
-        Validators::Container.new(self).valid?
-      end
-
-      private
-
-        attr_reader :config, :stack, :container_name
-
-        def dockerfile_md5s_match?
-          stored_dockerfile_md5 == current_dockerfile_md5
-        end
-
-        def versions_mismatch?
-          version > built_version
-        end
-
-        def built_image_version
-          info.Config.Image.split(':')[1]
-        end
-
-        def stored_dockerfile_md5
-          dockerfile_md5 || current_dockerfile_md5
-        end
-
-        def metastore_key
-          @metastore_key ||= 'stacks.%s.containers.%s' % [ stack.name, name ]
-        end
-
-        def dockerfile_md5
-          $metastore.get("#{metastore_key}.dockerfile_md5")
-        end
-
-        def set_dockerfile_md5!
-          $logger.debug "Setting MD5 for '#{name}' container to #{current_dockerfile_md5}"
-          $metastore.set("#{metastore_key}.dockerfile_md5", current_dockerfile_md5)
-        end
-
-        def current_dockerfile_md5
-          Digest::MD5.file(dockerfile).hexdigest
-        end
-
-        def info
-          Hashie::Mash.new(docker_container.info)
-        end
-
-        def container_config
-          @container_config ||= stack.container_configs[container_name] || Hashie::Mash.new({})
-        end
-
-        def dependant_containers
-          dependant_container_names.map { |container_name| stack.containers[container_name] }
-        end
-
-        def start_dependant_containers!
-          dependant_containers.each do |container|
-            next if container.running?
-            $logger.debug "Container '#{container.name}' being started as it's a dependancy"
-            container.start!
-          end
-        end
-
-    end
-  end
-end