picsolve_docker_builder 0.1.0

data/lib/picsolve_docker_builder/helpers/kubernetes/rc.rb

@@ -0,0 +1,98 @@
+require 'picsolve_docker_builder/helpers/kubernetes/pod'
+require 'picsolve_docker_builder/helpers/kubernetes/resource'
+
+module PicsolveDockerBuilder
+  module Helpers
+    module Kubernetes
+      # Ruby representation of a kuberentes replication cluster
+      class Rc < Resource
+        def existing_rcs
+          client.get_replication_controllers(
+            namespace: @image.composer.namespace
+          ).select do |rc|
+            rc.metadata.name.match(/^#{@image.name}/)
+          end
+        end
+
+        def config_rc
+          # configure the service
+          @rc.metadata = {} unless @rc.metadata
+          @rc.metadata.name = "#{@image.name}-#{@image.composer.hash}"
+          @rc.metadata.namespace = @image.composer.namespace
+          @rc.metadata.labels = template_labels
+          @rc.spec = {} unless @rc.spec
+          @rc.spec.replicas = 1
+          @rc.spec.selector = template_labels_pods
+          @rc.spec.template = {
+            'metadata' => {
+              'labels' => template_labels_pods
+            },
+            'spec' => {
+              'containers' => containers
+            }
+          }
+        end
+
+        def containers
+          [{
+            'name'  => @image.name,
+            'image' => @image.repo_tag_unique,
+            'ports' => @image.ports_rc
+          }]
+        end
+
+        def deploy
+          @old_rcs = existing_rcs
+          @rc = Kubeclient::ReplicationController.new
+          config_rc
+          log.debug "create replication controller #{@rc.metadata.name}"
+          client.create_replication_controller @rc
+        end
+
+        def wait
+          ready?
+        end
+
+        def ready?
+          pods.each do |pod|
+            result = pod.ready?
+            return false unless result
+          end
+          true
+        end
+
+        def pods
+          # TODO: better handling of selectors
+          client.get_pods(
+            namespace: @rc.metadata.namespace,
+            label_selector: "name=#{@rc.spec.selector.name}" \
+            ",deployment=#{@rc.spec.selector.deployment}"
+          ).map do |pod|
+            Pod.new(pod, @kubernetes)
+          end
+        end
+
+        def remove
+          log.debug "remove replication controller #{@rc.metadata.name}"
+          client.delete_replication_controller(
+            @rc.metadata.name,
+            @rc.metadata.namespace
+          )
+          remove_pods_by_rc(@rc)
+        end
+
+        def remove_old_rcs
+          @old_rcs.each do |rc|
+            Pod.remove_by_rc(self, rc)
+          end
+        end
+
+        def template_labels_pods
+          c = template_labels
+          c['deployment'] = @image.composer.hash
+          c
+        end
+      end
+    end
+  end
+end

data/lib/picsolve_docker_builder/helpers/kubernetes/resource.rb

@@ -0,0 +1,28 @@
+require 'picsolve_docker_builder/base'
+
+module PicsolveDockerBuilder
+  module Helpers
+    module Kubernetes
+      # A generic kuberntes resource
+      class Resource
+        include PicsolveDockerBuilder::Base
+        def initialize(image, kubernetes)
+          @image = image
+          @kubernetes = kubernetes
+        end
+
+        def client
+          @kubernetes.client
+        end
+
+        def template_labels
+          {
+            'name' => @image.name,
+            'app_name' => @image.composer.app_name,
+            'stage' => @image.composer.stage
+          }
+        end
+      end
+    end
+  end
+end

data/lib/picsolve_docker_builder/helpers/kubernetes/service.rb

@@ -0,0 +1,50 @@
+require 'picsolve_docker_builder/helpers/kubernetes/resource'
+
+module PicsolveDockerBuilder
+  module Helpers
+    module Kubernetes
+      # A generic kuberntes resource
+      class Service < Resource
+        def config
+          # workaround a bug on updating TODO: remove when fixed upstream
+          @service.name = @image.name
+
+          # configure the service
+          @service.metadata = {} unless @service.metadata
+          @service.metadata.name = @image.name
+          @service.metadata.namespace = @image.composer.namespace
+          @service.metadata.labels = template_labels
+          @service.spec = {} unless @service.spec
+          @service.spec.ports = @image.ports
+          @service.spec.selector = {
+            'name' => @image.name
+          }
+        end
+
+        def deploy
+          @existing = false
+          begin
+            @service = client.get_service @image.name, @image.composer.namespace
+            @existing = true
+          rescue KubeException
+            @service = Kubeclient::Service.new
+          end
+          # config service
+          config
+
+          if @existing
+            log.debug \
+              "update service '#{@image.composer.namespace}/#{@image.name}' " \
+              'on kubernetes'
+            client.update_service @service
+          else
+            log.debug \
+              "create service '#{@image.composer.namespace}/#{@image.name}' " \
+              'on kubernetes'
+            client.create_service @service
+          end
+        end
+      end
+    end
+  end
+end

data/lib/picsolve_docker_builder/helpers/kubernetes_manager.rb

@@ -0,0 +1,102 @@
+require 'picsolve_docker_builder/helpers/kubeclient'
+require 'picsolve_docker_builder/helpers/kubernetes/rc'
+require 'picsolve_docker_builder/helpers/kubernetes/service'
+require 'picsolve_docker_builder/helpers/kubernetes/pod'
+require 'picsolve_docker_builder/helpers/ssh_forward'
+require 'picsolve_docker_builder/base'
+
+module PicsolveDockerBuilder
+  module Helpers
+    # Ruby representation of a kuberentes cluster
+    class KubernetesManager
+      include PicsolveDockerBuilder::Base
+
+      def create_client
+        Kubeclient::Client.new kubernetes_url, 'v1beta3'
+      end
+
+      def kubernetes_url
+        @ssh_forward = SshForward.new(
+          ssh_host: kubernetes_host,
+          remote_host: '127.0.0.1',
+          remote_port: 8080
+        )
+        port = @ssh_forward.start
+        at_exit do
+          @ssh_forward.stop unless @ssh_forward.nil?
+        end
+        "http://127.0.0.1:#{port}"
+      end
+
+      def kubernetes_host
+        # TODO: Need to be touched for multi cluster support
+        config['compose']['clusters'].first
+      end
+
+      def client
+        @client ||= create_client
+      end
+
+      def service(image)
+        Kubernetes::Service.new(image, self)
+      end
+
+      def rc(image)
+        Kubernetes::Rc.new(image, self)
+      end
+
+      def template_labels_pods(i)
+        c = template_labels(i)
+        c['deployment'] = i.composer.hash
+        c
+      end
+
+      def template_labels(i)
+        {
+          'name' => i.name,
+          'app_name' => i.composer.app_name,
+          'stage' => i.composer.stage
+        }
+      end
+
+      def config_service(s, i)
+        # workaround a bug on updating TODO: remove when fixed upstream
+        s.name = i.name
+
+        # configure the service
+        s.metadata = {} unless s.metadata
+        s.metadata.name = i.name
+        s.metadata.namespace = i.composer.namespace
+        s.metadata.labels = template_labels(i)
+        s.spec = {} unless s.spec
+        s.spec.ports = i.ports
+        s.spec.selector = {
+          'name' => i.name
+        }
+      end
+
+      def deploy_service(i)
+        existing = false
+        begin
+          s = client.get_service i.name, i.composer.namespace
+          existing = true
+        rescue KubeException
+          s = Kubeclient::Service.new
+        end
+
+        # config config
+        config_service(s, i)
+
+        if existing
+          log.debug \
+            "update service '#{i.composer.namespace}/#{i.name}' on kubernetes"
+          client.update_service s
+        else
+          log.debug \
+            "create service '#{i.composer.namespace}/#{i.name}' on kubernetes"
+          client.create_service s
+        end
+      end
+    end
+  end
+end

data/lib/picsolve_docker_builder/helpers/repository.rb

@@ -0,0 +1,24 @@
+require 'picsolve_docker_builder/base'
+
+module PicsolveDockerBuilder
+  module Helpers
+    # This helper should help with paring of docker image names
+    # (as they are not very well defined)
+    class Repository
+      include PicsolveDockerBuilder::Base
+      def initialize(name)
+        parse_input(name)
+      end
+
+      def parse_input(input)
+        input.split('/')
+      end
+
+      def name=(_name)
+      end
+
+      def repo_tag
+      end
+    end
+  end
+end

data/lib/picsolve_docker_builder/helpers/ssh_forward.rb

@@ -0,0 +1,75 @@
+require 'picsolve_docker_builder/base'
+require 'net/ssh'
+
+module PicsolveDockerBuilder
+  module Helpers
+    # Ruby class that can forward a remote port over SSH
+    class SshForward
+      include PicsolveDockerBuilder::Base
+      attr_reader :options
+      def initialize(opts)
+        @options = opts
+      end
+
+      def connection
+        @connection ||= Net::SSH.start(ssh_host, ssh_user)
+      end
+
+      def bind_port
+        tries = 0
+        port = local_port
+        begin
+          connection.forward.local(port, remote_host, remote_port)
+          return port
+        rescue Errno::EADDRINUSE => e
+          # raise after five failed tries
+          raise e if tries > 5
+          tries += 1
+          port += 1
+          retry
+        end
+      end
+
+      def start
+        log.debug "Connecting via ssh to host '#{ssh_user}@#{ssh_host}'"
+
+        # bind remote service to local port
+        port = bind_port
+
+        # start thread with ssh
+        @thread = Thread.new do
+          connection.loop { true }
+        end
+        port
+      end
+
+      def stop
+        return if @thread.nil?
+        @thread.kill
+        @thread.join
+        log.debug \
+          "Disconnected ssh connection to host '#{ssh_user}@#{ssh_host}'"
+      end
+
+      def ssh_user
+        options[:ssh_user] = 'core'
+      end
+
+      def ssh_host
+        options[:ssh_host]
+      end
+
+      def remote_host
+        options[:remote_host]
+      end
+
+      def remote_port
+        options[:remote_port]
+      end
+
+      def local_port
+        options[:local_port] || remote_port
+      end
+    end
+  end
+end

data/lib/picsolve_docker_builder/scala.rb

@@ -0,0 +1,196 @@
+require 'rubygems/package'
+require 'zlib'
+require 'picsolve_docker_builder/frame'
+require 'picsolve_docker_builder/builder/builder'
+
+module PicsolveDockerBuilder
+  # Build a scala project
+  class Scala < Frame
+    def default_config
+      c = super
+      c['scala'] = {
+        'sbt' => {
+          'build_task' => [
+            'clean test universal:packageZipTarball'
+          ]
+        }
+      }
+      c
+    end
+
+    def prepare_volumes
+      volumes = volumes_sbt.map do |v|
+        v[1]
+      end
+
+      cmd = [
+        'chown',
+        '-c',
+        build_user,
+        build_user_home
+      ]
+
+      cmd += volumes
+
+      execute cmd
+    end
+
+    def docker_build_files
+      f = []
+      f << Builder::File.new(
+        'app.tar.gz',
+        source: universal_tar_gz,
+        destination: '/opt'
+      )
+      unless run_script.nil?
+        f << Builder::File.new(
+          run_script[:destination],
+          run_script
+        )
+      end
+      f
+    end
+
+    def docker_builder
+      Builder::Builder.new(
+        base_image: image_name,
+        maintainer: 'Picsolve Onlineops <onlineops@picsolve.com>',
+        ports: [9000],
+        hooks: {
+          before_adds: [
+            '# add play users',
+            'RUN groupadd -r play && \\',
+            '    useradd -r -g play play',
+            '# create pid dir',
+            'RUN mkdir -p /var/run/play && \\',
+            '    chown play:play /var/run/play'
+          ],
+          after_adds: [
+            '# chown app directories',
+            'RUN chown -R play:play /opt'
+          ]
+        },
+        command: ['gosu', 'play', bin_path],
+        files: docker_build_files
+      )
+    end
+
+    def docker_build
+      @docker_build = docker_builder.build
+    end
+
+    def dirs_sbt
+      [
+        '.sbt',
+        '.ivy2',
+        '.m2'
+      ]
+    end
+
+    def bin_path
+      @bin_path ||= detect_bin_path
+    end
+
+    def detect_bin_path
+      path = universal_bin_path
+      unless path.nil?
+        log.debug "run script detected in '#{path}'"
+        return path
+      end
+      path = run_script
+      unless path.nil?
+        path = run_script[:destination]
+        log.debug "run script detected in '#{path}'"
+        return path
+      end
+      fail 'No run script detected'
+    end
+
+    def run_script
+      @run_script ||= detect_run_script
+    end
+
+    def detect_run_script
+      path = run_script_path
+      return nil unless File.exist? path
+      basename = ::File.basename(path)
+      {
+        basename: basename,
+        source: path,
+        destination: "/#{basename}"
+      }
+    end
+
+    def run_script_path
+      File.join(base_dir, 'run.sh')
+    end
+
+    def volumes_sbt
+      dirs_sbt.map do |dir|
+        [
+          File.join(base_dir, dir),
+          File.join(build_user_home, dir)
+        ]
+      end
+    end
+
+    def volumes_array
+      super + volumes_sbt
+    end
+
+    def sbt_command
+      runs = config['scala']['sbt']['build_task'].map do |tasks|
+        "sbt #{tasks}"
+      end
+      runs.join ' && '
+    end
+
+    def asset_build
+      log.info "start asset building with image #{image_name}"
+
+      start
+
+      prepare_volumes
+
+      build_cmd = [
+        'gosu', build_user, 'bash', '-c', sbt_command
+      ]
+
+      execute_attach build_cmd
+
+      log.info "finished asset building with image #{image_name}"
+
+      stop
+    end
+
+    def universal_bin_path
+      Zlib::GzipReader.open(universal_tar_gz) do |gunzip|
+        gunzip_io = StringIO.new(gunzip.read)
+        Gem::Package::TarReader.new gunzip_io do |tar|
+          tar.each do |entry|
+            next unless entry.file?
+            next unless entry.full_name.match(%r{/bin})
+            next if entry.full_name.match(/\.bat$/)
+            return File.join('/opt', entry.full_name)
+          end
+        end
+      end
+      nil
+    end
+
+    def universal_tar_gz
+      build_asset_glob = File.join(base_dir, 'target/**/*.tgz')
+      tgz_files = Dir.glob(build_asset_glob)
+      fail "no universal_tar_gz found: #{build_asset_glob}" \
+        if tgz_files.length < 1
+      fail "more than one universal_tar_gz found: #{build_asset_glob}" \
+        if tgz_files.length > 1
+      tgz_files[0]
+    end
+
+    def build
+      asset_build
+      docker_build
+    end
+  end
+end