fpm-fry 0.1.3

data/lib/fpm/fry/command.rb

@@ -0,0 +1,90 @@
+require 'tmpdir'
+require 'fileutils'
+require 'clamp'
+require 'json'
+require 'forwardable'
+require 'fpm/fry/ui'
+require 'fpm/command'
+
+module FPM; module Fry
+
+  class Command < Clamp::Command
+
+    option '--debug', :flag, 'Turns on debugging'
+    option '--[no-]tls', :flag, 'Turns on tls ( default is false for schema unix, tcp and http and true for https )'
+    option '--[no-]tlsverify', :flag, 'Turns off tls peer verification', default:true, environment_variable: 'DOCKER_TLS_VERIFY'
+
+    subcommand 'fpm', 'Works like fpm but with docker support', FPM::Command
+
+    def client
+      @client ||= begin
+        client = FPM::Fry::Client.new(
+          logger: logger,
+          tls: tls?, tlsverify: tlsverify?
+        )
+        logger.info("Docker connected",client.server_version)
+        client
+      end
+    end
+
+    attr_writer :client
+
+    subcommand 'detect', 'Detects distribution from an image, a container or a given name' do
+
+      option '--image', 'image', 'Docker image to detect'
+      option '--container', 'container', 'Docker container to detect'
+      option '--distribution', 'distribution', 'Distribution name to detect'
+
+      attr :ui
+      extend Forwardable
+      def_delegators :ui, :logger
+
+      def initialize(*_)
+        super
+        @ui = UI.new()
+        if debug?
+          ui.logger.level = :debug
+        end
+      end
+
+      def execute
+        require 'fpm/fry/os_db'
+        require 'fpm/fry/detector'
+
+        if image
+          d = Detector::Image.new(client, image)
+        elsif distribution
+          d = Detector::String.new(distribution)
+        elsif container
+          d = Detector::Container.new(client, container)
+        else
+          logger.error("Please supply either --image, --distribution or --container")
+          return 1
+        end
+
+        begin
+          if d.detect!
+            data = {distribution: d.distribution, version: d.version}
+            if i = OsDb[d.distribution]
+              data[:flavour] = i[:flavour]
+            else
+              data[:flavour] = "unknown"
+            end
+            logger.info("Detected distribution",data)
+            return 0
+          else
+            logger.error("Detection failed")
+            return 2
+          end
+        rescue => e
+          logger.error(e)
+          return 3
+        end
+      end
+
+    end
+  end
+
+end ; end
+
+require 'fpm/fry/command/cook'

data/lib/fpm/fry/detector.rb

@@ -0,0 +1,109 @@
+require 'fpm/fry/client'
+module FPM; module Fry
+
+  module Detector
+
+    class String < Struct.new(:value)
+      attr :distribution
+      attr :version
+
+      def detect!
+        @distribution, @version = value.split('-',2)
+        return true
+      end
+
+    end
+
+    class Container < Struct.new(:client,:container)
+      attr :distribution
+      attr :version
+
+      def detect!
+        begin
+          client.read(container,'/etc/lsb-release') do |file|
+            file.read.each_line do |line|
+              case(line)
+              when /\ADISTRIB_ID=/ then
+                @distribution = $'.strip.downcase
+              when /\ADISTRIB_RELEASE=/ then
+                @version = $'.strip
+              end
+            end
+          end
+          return !!(@distribution and @version)
+        rescue Client::FileNotFound
+        end
+        begin
+          client.read(container,'/etc/debian_version') do |file|
+            content = file.read
+            if /\A\d+(?:\.\d+)+\Z/ =~ content
+              @distribution = 'debian'
+              @version = content.strip
+            end
+          end
+          return !!(@distribution and @version)
+        rescue Client::FileNotFound
+        end
+        begin
+          client.read(container,'/etc/redhat-release') do |file|
+            if file.header.typeflag == "2" # centos links this file
+              client.read(container,File.absolute_path(file.header.linkname,'/etc')) do |file|
+                detect_redhat_release(file)
+              end
+            else
+              detect_redhat_release(file)
+            end
+          end
+          return !!(@distribution and @version)
+        rescue Client::FileNotFound
+        end
+        return false
+      end
+
+    private
+      def detect_redhat_release(file)
+        file.read.each_line do |line|
+          case(line)
+          when /\A(\w+) release ([\d\.]+)/ then
+            @distribution = $1.strip.downcase
+            @version = $2.strip
+          end
+        end
+      end
+    end
+
+    class Image < Struct.new(:client,:image,:factory)
+      attr :distribution
+      attr :version
+
+      def initialize(client, image, factory = Container)
+        super
+      end
+
+      def detect!
+        body = JSON.generate({"Image" => image, "Cmd" => "exit 0"})
+        res = client.post( path: client.url('containers','create'),
+                           headers: {'Content-Type' => 'application/json'},
+                           body: body,
+                           expects: [201]
+                         )
+        body = JSON.parse(res.body)
+        container = body.fetch('Id')
+        begin
+          d = factory.new(client,container)
+          if d.detect!
+            @distribution = d.distribution
+            @version = d.version
+            return true
+          else
+            return false
+          end
+        ensure
+          client.delete(path: client.url('containers',container))
+        end
+      end
+    end
+
+
+  end
+end ; end

data/lib/fpm/fry/docker_file.rb

@@ -0,0 +1,149 @@
+require 'fiber'
+require 'shellwords'
+require 'rubygems/package'
+require 'fpm/fry/os_db'
+require 'fpm/fry/source'
+require 'fpm/fry/joined_io'
+module FPM; module Fry
+  class DockerFile < Struct.new(:variables,:cache,:recipe)
+
+    class Source < Struct.new(:variables, :cache)
+
+      def initialize(variables, cache = Source::Null::Cache)
+        variables = variables.dup
+        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
+          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
+        end
+        variables.freeze
+        super(variables, cache)
+      end
+
+      def dockerfile
+        df = []
+        df << "FROM #{variables[:image]}"
+
+        df << "RUN mkdir /tmp/build"
+
+        cache.file_map.each do |from, to|
+          df << "ADD #{map_from(from)} #{map_to(to)}"
+        end
+
+        df << ""
+        return df.join("\n")
+      end
+
+      def tar_io
+        JoinedIO.new(
+          self_tar_io,
+          cache.tar_io
+        )
+      end
+
+      def self_tar_io
+        sio = StringIO.new
+        tar = Gem::Package::TarWriter.new(sio)
+        tar.add_file('Dockerfile','0777') do |io|
+          io.write(dockerfile)
+        end
+        #tar.close
+        sio.rewind
+        return sio
+      end
+
+      def map_to(dir)
+        if ['','.'].include? dir
+          return '/tmp/build'
+        else
+          return File.join('/tmp/build',dir)
+        end
+      end
+
+      def map_from(dir)
+        if dir == ''
+          return '.'
+        else
+          return dir
+        end
+      end
+
+    end
+
+    class Build < Struct.new(:base, :variables, :recipe)
+
+      attr :options
+      private :options
+
+      def initialize(base, variables, recipe, options = {})
+        variables = variables.dup
+        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
+          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
+        end
+        variables.freeze
+        @options = options.dup.freeze
+        super(base, variables, recipe)
+      end
+
+      def dockerfile
+        df = []
+        df << "FROM #{base}"
+        df << "WORKDIR /tmp/build"
+
+        deps = (recipe.build_depends.merge recipe.depends)\
+          .select{|_,v| v.fetch(:install,true) }\
+          .map do |k,v|
+            i = v.fetch(:install,true)
+            if i == true then
+              k
+            else
+              i
+            end
+          end.sort
+        if deps.any?
+          case(variables[:flavour])
+          when 'debian'
+            update = ''
+            if options[:update]
+              update = 'apt-get update && '
+            end
+            df << "RUN #{update}apt-get install --yes #{Shellwords.join(deps)}"
+          when 'redhat'
+            df << "RUN yum -y install #{Shellwords.join(deps)}"
+          else
+            raise "Unknown flavour: #{variables[:flavour]}"
+          end
+        end
+
+        df << "ADD .build.sh /tmp/build/"
+        df << "ENTRYPOINT /tmp/build/.build.sh"
+        df << ''
+        return df.join("\n")
+      end
+
+      def build_sh
+        df = ['#!/bin/bash']
+        df << 'set -e'
+        recipe.steps.each do |k,v|
+          df << "echo -e '\\e[1;32m====> #{Shellwords.escape k}\\e[0m'"
+          df << v.to_s
+        end
+        df << ''
+        return df.join("\n")
+      end
+
+      def tar_io
+        sio = StringIO.new
+        tar = Gem::Package::TarWriter.new(sio)
+        tar.add_file('.build.sh','0777') do |io|
+          io.write(build_sh)
+        end
+        tar.add_file('Dockerfile','0777') do |io|
+          io.write(dockerfile)
+        end
+        #tar.close
+        sio.rewind
+        return sio
+      end
+    end
+
+  end
+end ; end

data/lib/fpm/fry/joined_io.rb

@@ -0,0 +1,63 @@
+module FPM; module Fry
+  class JoinedIO
+    include Enumerable
+
+    def initialize(*ios)
+      @ios = ios
+      @pos = 0
+      @readbytes = 0
+    end
+
+    def read( len = nil )
+      buf = []
+      if len.nil?
+        while chunk = readpartial(512)
+          buf << chunk
+          @readbytes += chunk.bytesize
+        end
+        return buf.join
+      else
+        con = 0
+        while con < len
+          chunk = readpartial(len - con)
+          if chunk.nil?
+            if con == 0
+              return nil
+            else
+              return buf.join
+            end
+          end
+          @readbytes += chunk.bytesize
+          con += chunk.bytesize
+          buf << chunk
+        end
+        return buf.join
+      end
+    end
+
+    def readpartial( len )
+      while (io = @ios[@pos])
+        r = io.read( len )
+        if r.nil?
+          @pos = @pos + 1
+          next
+        else
+          return r
+        end
+      end
+      return nil
+    end
+
+    def pos
+      @readbytes
+    end
+
+    def eof?
+      @pos == @ios.size
+    end
+
+    def close
+      @ios.each(&:close)
+    end
+  end
+end ; end

data/lib/fpm/fry/os_db.rb

@@ -0,0 +1,35 @@
+module FPM; module Fry
+
+  # Structure is
+  #
+  # <distribution> => {
+  #   codenames: {
+  #     <codename> => <version>
+  #   },
+  #   flavour: <flavour>
+  # }
+  OsDb = {
+    'centos' => {
+      codenames: {},
+      flavour: 'redhat'
+    },
+
+    'debian' => {
+      codenames: {
+        'lenny'   => '5',
+        'squeeze' => '6',
+        'wheezy'  => '7'
+      },
+      flavour: 'debian'
+    },
+
+    'ubuntu' => {
+      codenames: {
+        'precise' => '12.04',
+        'trusty'  => '14.04'
+      },
+      flavour: 'debian'
+    }
+  }
+
+end ; end

data/lib/fpm/fry/plugin/alternatives.rb

@@ -0,0 +1,90 @@
+require 'fpm/fry/plugin'
+module FPM::Fry::Plugin::Alternatives
+
+  BASH_HEADER = ['#!/bin/bash']
+  DEFAULT_PRIORITY = 10000
+  EXPECTED_KEYS    = [:path, :link, :priority]
+
+  class DSL < Struct.new(:builder, :alternatives)
+
+    def initialize( b, a = {})
+      super
+    end
+
+    def []=(name, options={}, value)
+      name = name.to_s
+      if value.kind_of? String
+        options = normalize(name, options.merge(path: value) )
+      else
+        options = normalize(name, options.merge(value) )
+      end
+      alternatives[name] = options
+    end
+
+    def add(name, value, options={})
+      self[name, options] = value
+    end
+
+    def finish!
+      install   = alternatives.map{|_,v|   install_command(v) }
+      uninstall = alternatives.map{|_,v| uninstall_command(v) }
+      builder.plugin('script_helper') do
+        after_install_or_upgrade(*install)
+        before_remove_entirely(*uninstall)
+      end
+    end
+
+  private
+    def normalize_without_slaves(name, options)
+      if options.kind_of? String
+        options = {path: options}
+      elsif options.kind_of? Hash
+        additional_keys = options.keys - EXPECTED_KEYS
+        raise ArgumentError, "Unexpected options: #{additional_keys.inspect}" if additional_keys.any?
+        options = options.dup
+      else
+        raise ArgumentError, "Options must be either a Hash or a String, got #{options.inspect}"
+      end
+      options[:name] = name
+      options[:link] ||= File.join('/usr/bin',name)
+      return options
+    end
+
+    def normalize( name, options )
+      slaves  = {}
+      if options.kind_of?(Hash) && options.key?(:slaves)
+        options = options.dup
+        slaves  = options.delete(:slaves)
+      end
+      options = normalize_without_slaves(name, options)
+      options[:slaves] = slaves.map{|k,v| normalize_without_slaves(k, v) }
+      options[:priority] ||= DEFAULT_PRIORITY
+      return options
+    end
+
+    def install_command(options)
+      slaves = options.fetch(:slaves,[]).flat_map{|options| ['--slave', options[:link],options[:name],options[:path]] }
+      Shellwords.join(['update-alternatives','--install',options[:link],options[:name],options[:path],options[:priority].to_s, *slaves])
+    end
+
+    def uninstall_command(options)
+      Shellwords.join(['update-alternatives','--remove',options[:name],options[:path]])
+    end
+  end
+
+  def self.apply(builder, options = {}, &block)
+    dsl = DSL.new(builder)
+    options.each do |k,v|
+      dsl.add(k,v)
+    end
+    if block
+      if block.arity == 1 
+        yield dsl
+      else
+        dsl.instance_eval(&block)
+      end
+    end
+    dsl.finish!
+  end
+
+end

data/lib/fpm/fry/plugin/edit_staging.rb

@@ -0,0 +1,66 @@
+require 'fpm/fry/plugin'
+require 'fileutils'
+module FPM::Fry::Plugin::EditStaging
+
+  class AddFile < Struct.new(:path, :io, :options)
+    def call(_ , package)
+      file = package.staging_path(path)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file,'w') do | f |
+        IO.copy_stream(io, f)
+        if options[:chmod]
+          f.chmod(options[:chmod])
+        end
+      end
+      io.close if io.respond_to? :close
+    end
+  end
+
+  class LnS < Struct.new(:src, :dest)
+    def call(_ , package)
+      file = package.staging_path(dest)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.symlink(src, file)
+    end
+  end
+
+  class DSL < Struct.new(:builder)
+    def add_file(path, io, options = {})
+      options = options.dup
+      options[:chmod] = convert_chmod(options[:chmod]) if options[:chmod]
+      options.freeze
+      io.rewind if io.respond_to? :rewind
+      builder.output_hooks << AddFile.new(path, io, options)
+    end
+
+    def ln_s(src, dest)
+      builder.output_hooks << LnS.new(src,dest)
+    end
+  private
+
+    def convert_chmod(chmod)
+      if chmod.kind_of? Numeric
+        num = chmod
+      elsif chmod.kind_of? String
+        num = chmod.to_i(8)
+      else
+        raise ArgumentError, "Invalid chmod format: #{chmod}"
+      end
+      return num
+    end
+
+  end
+
+  def self.apply(builder, &block)
+    d = DSL.new(builder)
+    if !block
+      return d
+    elsif block.arity == 1
+      block.call(d)
+    else
+      d.instance_eval(&block)
+    end
+    return d
+  end
+
+end

data/lib/fpm/fry/plugin/exclude.rb

@@ -0,0 +1,18 @@
+require 'fpm/fry/plugin'
+module FPM::Fry::Plugin::Exclude
+
+  class Exclude < Struct.new(:matches)
+
+    def call(_, package)
+      (package.attributes[:excludes] ||= []).push(*matches)
+    end
+
+  end
+
+  def exclude(*matches)
+    return if matches.none?
+    input_hooks << Exclude.new(matches)
+  end
+
+end
+

data/lib/fpm/fry/plugin/init.rb

@@ -0,0 +1,53 @@
+require 'fpm/fry/plugin'
+module FPM::Fry::Plugin::Init
+
+  def self.detect_init(variables)
+    if variables[:init]
+      return variables[:init]
+    end
+    d = variables[:distribution]
+    v = variables[:distribution_version].split('.').map(&:to_i)
+    case(d)
+    when 'debian'
+      if v[0] < 8
+        return 'sysv'
+      else
+        return 'systemd'
+      end
+    when 'ubuntu'
+      if v[0] <= 14 && v[1] < 10
+        return 'upstart'
+      else
+        return 'systemd'
+      end
+    when 'centos','redhat'
+      if v[0] <= 5
+        return 'sysv'
+      elsif v[0] == 6
+        return 'upstart'
+      else
+        return 'systemd'
+      end
+    else
+      raise "Unknown init system for #{d} #{v.join '.'}"
+    end
+  end
+
+  def init(*inits)
+    inits = inits.flatten.map(&:to_s)
+    actual = FPM::Fry::Plugin::Init.detect_init(variables)
+    if inits.none?
+      return actual
+    elsif inits.include? actual
+      if block_given?
+        yield
+      else
+        return true
+      end
+    else
+      return false
+    end
+  end
+
+
+end

data/lib/fpm/fry/plugin/platforms.rb

@@ -0,0 +1,10 @@
+module FPM::Fry::Plugin::Platforms
+
+  def platforms(platform, *platforms)
+    p = [platform,platforms].flatten.map(&:to_s)
+    if p.include? distribution
+      yield
+    end
+  end
+
+end