fpm-fry 0.1.3

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

@@ -0,0 +1,176 @@
+require 'fpm/fry/plugin'
+module FPM::Fry::Plugin::ScriptHelper
+
+  class Script
+
+    attr :renderer
+
+    def initialize(renderer)
+      @renderer = renderer
+    end
+
+    def to_s
+      renderer.call(self)
+    end
+
+    def name
+      self.class.name.split('::').last.gsub(/([^A-Z])([A-Z])/,'\1_\2').downcase
+    end
+  end
+
+  module RenderErb
+    def render_path(script, path)
+      _erbout = ""
+      erb = ERB.new(
+        IO.read(File.join(File.dirname(__FILE__),'..','templates',path, "#{script.name}.erb"))
+      )
+      script.instance_eval(erb.src)
+      return _erbout
+    end
+  end
+
+  module DebianRenderer
+    extend RenderErb
+    def self.call(script)
+      render_path(script,'debian')
+    end
+  end
+
+  module RedhatRenderer
+    extend RenderErb
+    def self.call(script)
+      render_path(script,'redhat')
+    end
+  end
+
+  class BeforeInstall < Script
+
+    # deb: $1 == install
+    # rpm: $1 == 1
+    attr :install
+
+    # deb: $1 == upgrade
+    # rpm: $1 >= 2
+    attr :upgrade
+
+    def initialize(*_)
+      super
+      @install = []
+      @upgrade = []
+    end
+
+  end
+
+  class AfterInstall < Script
+
+    def initialize(*_)
+      super
+      @configure = []
+    end
+
+    # deb: $1 == configure
+    # rpm: -always-
+    attr :configure
+
+  end
+
+  class BeforeRemove < Script
+
+    def initialize(*_)
+      super
+      @remove = []
+      @upgrade = []
+    end
+
+    # deb: $1 == remove
+    # rpm: $1 == 0
+    attr :remove
+
+    # deb: $1 == upgrade
+    # rpm: $1 >= 1
+    attr :upgrade
+
+  end
+
+  class AfterRemove < Script
+
+    def initialize
+      @remove = []
+      @upgrade = []
+    end
+
+    # deb: $1 == upgrade
+    # rpm: $1 == 1
+    attr :upgrade
+
+    # deb: $1 == remove
+    # rpm: $1 == 0
+    attr :remove
+
+  end
+
+  NAME_TO_SCRIPT = {
+    before_install: BeforeInstall,
+    after_install: AfterInstall,
+    before_remove: BeforeRemove,
+    after_remove: AfterRemove
+  }
+
+  SCRIPT_TO_NAME = NAME_TO_SCRIPT.invert
+
+  class DSL < Struct.new(:builder)
+
+# before(install) => before_install:install
+# before(upgrade) => before_install:upgrade
+# after(install_or_upgrade) => after_install:configure
+# before(remove_for_upgrade) => before_remove:upgrade
+# before(remove) => before_remove:remove
+# after(remove) => after_remove:remove
+# after(remove_for_upgrade) => after_remove:upgrade
+
+    def after_install_or_upgrade(*scripts)
+      find(:after_install).configure.push(*scripts)
+    end
+
+    def before_remove_entirely(*scripts)
+      find(:before_remove).remove.push(*scripts)
+    end
+
+    def after_remove_entirely(*scripts)
+      find(:after_remove).remove.push(*scripts)
+    end
+  private
+
+    def find(type)
+      klass = NAME_TO_SCRIPT[type]
+      script = builder.script(type).find{|s| s.kind_of? klass }
+      if script.nil?
+        script = klass.new( renderer )
+        builder.script(type,script)
+      end
+      return script
+    end
+
+    def renderer
+      @renderer ||= case(builder.flavour)
+                    when 'debian' then DebianRenderer
+                    when 'redhat' then RedhatRenderer
+                    else
+                      raise "Unknown flavour: #{builder.flavour.inspect}"
+                    end
+    end
+
+  end
+
+  def self.apply(builder, options = {}, &block)
+    dsl = DSL.new(builder)
+    if block
+      if block.arity == 1 
+        yield dsl
+      else
+        dsl.instance_eval(&block)
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,100 @@
+require 'fpm/fry/plugin'
+require 'fpm/fry/plugin/init'
+require 'fpm/fry/plugin/edit_staging'
+require 'erb'
+require 'shellwords'
+module FPM::Fry::Plugin ; module Service
+
+  class Environment < Struct.new(:name,:command, :description)
+
+    def render(file)
+      _erbout = ""
+      erb = ERB.new(
+        IO.read(File.join(File.dirname(__FILE__),'..','templates',file))
+      )
+      eval(erb.src)
+      return _erbout
+    end
+
+  end
+
+  class DSL
+
+    def initialize(*_)
+      super
+      @name = nil
+      @command = []
+    end
+
+    def name( n = nil )
+      if n
+        @name = n
+      end
+      return @name
+    end
+
+    def command( *args )
+      if args.any?
+        @command = args
+      end
+      return @command
+    end
+
+    # @api private
+    def add!(builder)
+      name = self.name || builder.name || raise
+      init = Init.detect_init(builder.variables)
+      edit = builder.plugin('edit_staging')
+      env = Environment.new(name, command, "")
+      case(init)
+      when 'upstart' then
+        edit.add_file "/etc/init/#{name}.conf",StringIO.new( env.render('upstart.erb') )
+        edit.ln_s '/lib/init/upstart-job', "/etc/init.d/#{name}"
+        builder.plugin('script_helper') do |sh|
+          sh.after_install_or_upgrade(<<BASH)
+if status #{Shellwords.shellescape name} 2>/dev/null | grep -q ' start/'; then
+  # It has to be stop+start because upstart doesn't pickup changes with restart.
+  stop #{Shellwords.shellescape name}
+fi
+start #{Shellwords.shellescape name}
+BASH
+          sh.before_remove_entirely(<<BASH)
+if status #{Shellwords.shellescape name} 2>/dev/null | grep -q ' start/'; then
+  stop #{Shellwords.shellescape name}
+fi
+BASH
+        end
+      when 'sysv' then
+        edit.add_file "/etc/init.d/#{name}",StringIO.new( env.render('sysv.erb') ), chmod: '750'
+        builder.plugin('script_helper') do |sh|
+          sh.after_install_or_upgrade(<<BASH)
+update-rc.d #{Shellwords.shellescape name} defaults
+/etc/init.d/#{Shellwords.shellescape name} restart
+BASH
+          sh.before_remove_entirely(<<BASH)
+/etc/init.d/#{Shellwords.shellescape name} stop
+update-rc.d -f #{Shellwords.shellescape name} remove
+BASH
+        end
+      when 'systemd' then
+
+      end
+    end
+
+  end
+
+  def self.apply(builder, &block)
+    d = DSL.new
+    if !block
+      raise ArgumentError, "service plugin requires a block"
+    elsif block.arity == 1
+      block.call(d)
+    else
+      d.instance_eval(&block)
+    end
+    d.add!(builder)
+    return nil
+  end
+
+end end
+

data/lib/fpm/fry/plugin.rb

@@ -0,0 +1,3 @@
+module FPM::Fry::Plugin
+
+end

data/lib/fpm/fry/recipe/builder.rb

@@ -0,0 +1,267 @@
+require 'fpm/fry/recipe'
+require 'forwardable'
+module FPM::Fry
+  class Recipe
+
+    class NotFound < StandardError
+    end
+
+    class PackageBuilder < Struct.new(:variables, :package_recipe)
+
+      attr :logger
+
+      def initialize( variables, recipe = PackageRecipe.new, options = {})
+        super(variables, recipe)
+        @logger = options.fetch(:logger){ Cabin::Channel.get }
+      end
+
+      def flavour
+        variables[:flavour]
+      end
+
+      def distribution
+        variables[:distribution]
+      end
+      alias platform distribution
+
+      def distribution_version
+        variables[:distribution_version]
+      end
+      alias platform_version distribution_version
+
+      def codename
+        variables[:codename]
+      end
+
+      def iteration(value = Not)
+        get_or_set('@iteration',value)
+      end
+      alias revision iteration
+
+      def version(value = Not)
+        get_or_set('@version',value)
+      end
+
+      def name(value = Not)
+        get_or_set('@name',value)
+      end
+
+      def vendor(value = Not)
+        get_or_set('@vendor',value)
+      end
+
+      def depends( name , options = {} )
+        name, options = parse_package(name, options)
+        package_recipe.depends[name] = options
+      end
+
+      def conflicts( name , options = {} )
+        name, options = parse_package(name, options)
+        package_recipe.conflicts[name] = options
+      end
+
+      def provides( name , options = {} )
+        name, options = parse_package(name, options)
+        package_recipe.provides[name] = options
+      end
+
+      def replaces( name , options = {} )
+        name, options = parse_package(name, options)
+        package_recipe.replaces[name] = options
+      end
+
+      def files( pattern )
+        package_recipe.files << pattern
+      end
+
+      def plugin(name, *args, &block)
+        logger.debug('Loading Plugin', name: name, args: args, block: block, load_path: $LOAD_PATH)
+        if name =~ /\A\./
+          require name
+        else
+          require File.join('fpm/fry/plugin',name)
+        end
+        module_name = File.basename(name,'.rb').gsub(/(?:\A|_)([a-z])/){ $1.upcase }
+        mod = FPM::Fry::Plugin.const_get(module_name)
+        if mod.respond_to? :apply
+          mod.apply(self, *args, &block)
+        else
+          extend(mod)
+        end
+      end
+
+      def script(type, value = Not)
+        if value != Not
+          package_recipe.scripts[type] << value
+        end
+        return package_recipe.scripts[type]
+      end
+
+      def before_install(*args)
+        script(:before_install, *args)
+      end
+      alias pre_install before_install
+      alias preinstall before_install
+
+      def after_install(*args)
+        script(:after_install, *args)
+      end
+      alias post_install after_install
+      alias postinstall after_install
+
+      def before_remove(*args)
+        script(:before_remove, *args)
+      end
+      alias before_uninstall before_remove
+      alias pre_uninstall before_remove
+      alias preuninstall before_remove
+
+      def after_remove(*args)
+        script(:after_remove, *args)
+      end
+      alias after_uninstall after_remove
+      alias post_uninstall after_remove
+      alias postuninstall after_remove
+
+      def output_hooks
+        package_recipe.output_hooks
+      end
+
+    protected
+
+      def parse_package( name, options = {} )
+        if options.kind_of? String
+          options = {version: options}
+        end
+        case(v = options[:version])
+        when String
+          if v =~ /\A(<=|<<|>=|>>|<>|=|>|<)(\s*)/
+            options[:version] = ' ' + $1 + ' ' + $'
+          else
+            options[:version] = ' = ' + v
+          end
+        end
+        return name, options
+      end
+
+
+      Not = Module.new
+      def get_or_set(name, value = Not)
+        if value == Not
+          return package_recipe.instance_variable_get(name)
+        else
+          return package_recipe.instance_variable_set(name, value)
+        end
+      end
+
+    end
+
+    class Builder < PackageBuilder
+
+      attr :recipe
+
+      def initialize( variables, recipe = Recipe.new, options = {})
+        variables = variables.dup
+        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
+          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
+        end
+        if !variables[:codename] && OsDb[variables[:distribution]] && variables[:distribution_version]
+          codename = OsDb[variables[:distribution]][:codenames].find{|name,version| variables[:distribution_version].start_with? version }
+          variables[:codename] = codename[0] if codename
+        end
+        variables.freeze
+        @recipe = recipe
+        super(variables, recipe.packages[0], options = {})
+      end
+
+      def load_file( file )
+        file = File.expand_path(file)
+        begin
+          content = IO.read(file)
+        rescue Errno::ENOENT => e
+          raise NotFound, e
+        end
+        basedir = File.dirname(file)
+        Dir.chdir(basedir) do
+          instance_eval(content,file,0)
+        end
+      end
+
+      def source( url , options = {} )
+        options = options.merge(logger: logger)
+        source = Source::Patched.decorate(options) do |options|
+          guess_source(url,options).new(url, options)
+        end
+        recipe.source = source
+      end
+
+      def run(*args)
+        if args.first.kind_of? Hash
+          options = args.shift
+        else
+          options = {}
+        end
+        command = args.shift
+        name = options.fetch(:name){ [command,*args].select{|c| c[0] != '-' }.join('-') }
+        recipe.steps[name] = Shellwords.join([command, *args])
+      end
+
+      def build_depends( name , options = {} )
+        name, options = parse_package(name, options)
+        recipe.build_depends[name] = options
+      end
+
+      def input_hooks
+        recipe.input_hooks
+      end
+
+      def package(name, &block)
+        pr = PackageRecipe.new
+        pr.name = name
+        pr.version = package_recipe.version
+        pr.iteration = package_recipe.iteration
+        recipe.packages << pr
+        PackageBuilder.new(variables, pr).instance_eval(&block)
+      end
+
+    protected
+
+      def source_types
+        @source_types  ||= {
+          git:  Source::Git,
+          http: Source::Package,
+          tar:  Source::Package,
+          dir:  Source::Dir
+        }
+      end
+
+      def register_source_type( name, klass )
+        if !klass.respond_to? :new
+          raise ArgumentError.new("Expected something that responds to :new, got #{klass.inspect}")
+        end
+        source_types[name] = klass
+      end
+
+      NEG_INF = (-1.0/0.0)
+
+      def guess_source( url, options = {} )
+        if w = options[:with]
+          return source_types.fetch(w){ raise ArgumentError.new("Unknown source type: #{w}") }
+        end
+        scores = source_types.values.uniq\
+          .select{|klass| klass.respond_to? :guess }\
+          .group_by{|klass| klass.guess(url) }\
+          .sort_by{|score,_| score.nil? ? NEG_INF : score }
+        score, klasses = scores.last
+        if score == nil
+          raise ArgumentError.new("No source provide found for #{url}.\nMaybe try explicitly setting the type using :with parameter. Valid options are: #{source_types.keys.join(', ')}")
+        end
+        if klasses.size != 1
+          raise ArgumentError.new("Multiple possible source providers found for #{url}: #{klasses.join(', ')}.\nMaybe try explicitly setting the type using :with parameter. Valid options are: #{source_types.keys.join(', ')}")
+        end
+        return klasses.first
+      end
+
+    end
+  end
+end

data/lib/fpm/fry/recipe.rb

@@ -0,0 +1,141 @@
+require 'fpm/fry/source'
+require 'fpm/fry/source/package'
+require 'fpm/fry/source/dir'
+require 'fpm/fry/source/patched'
+require 'fpm/fry/source/git'
+require 'fpm/fry/plugin'
+require 'fpm/fry/os_db'
+require 'shellwords'
+require 'cabin'
+require 'open3'
+module FPM; module Fry
+
+  class Recipe
+
+    class PackageRecipe
+      attr_accessor :name,
+        :iteration,
+        :version,
+        :maintainer,
+        :vendor,
+        :depends,
+        :provides,
+        :conflicts,
+        :replaces,
+        :suggests,
+        :recommends,
+        :scripts,
+        :output_hooks,
+        :files
+
+
+      def initialize
+        @name = nil
+        @iteration = nil
+        @version = '0.0.0'
+        @maintainer = nil
+        @vendor = nil
+        @depends = {}
+        @provides = {}
+        @conflicts = {}
+        @replaces = {}
+        @scripts = {
+          before_install: [],
+          after_install:  [],
+          before_remove:  [],
+          after_remove:   []
+        }
+        @output_hooks = []
+        @files = []
+      end
+
+      alias dependencies depends
+
+      def apply_output( package )
+        package.name = name
+        package.version = version
+        package.iteration = iteration
+        package.maintainer = maintainer if maintainer
+        package.vendor = vendor if vendor
+        scripts.each do |type, scripts|
+          package.scripts[type] = scripts.join("\n") if scripts.any?
+        end
+        [:dependencies, :conflicts, :replaces, :provides].each do |sym|
+          send(sym).each do |name, options|
+            package.send(sym) << "#{name}#{options[:version]}"
+          end
+        end
+        output_hooks.each{|h| h.call(self, package) }
+        return package
+      end
+
+      alias apply apply_output
+
+      SYNTAX_CHECK_SHELLS = ['/bin/sh','/bin/bash', '/bin/dash']
+
+      def lint
+        problems = []
+        problems << "Name is empty." if name.to_s == ''
+        scripts.each do |type,scripts|
+          next if scripts.none?
+          s = scripts.join("\n")
+          if s == ''
+            problems << "#{type} script is empty. This will produce broken packages."
+            next
+          end
+          m = /\A#!([^\n]+)\n/.match(s)
+          if !m
+            problems << "#{type} script doesn't have a valid shebang"
+            next
+          end
+          begin
+            args = m[1].shellsplit
+          rescue ArgumentError => e
+            problems << "#{type} script doesn't have a valid command in shebang"
+          end
+          if SYNTAX_CHECK_SHELLS.include? args[0]
+            sin, sout, serr, th = Open3.popen3(args[0],'-n')
+            sin.write(s)
+            sin.close
+            if th.value.exitstatus != 0
+              problems << "#{type} script is not valid #{args[0]} code: #{serr.read.chomp}"
+            end
+            serr.close
+            sout.close
+          end
+        end
+        return problems
+      end
+    end
+
+    attr_accessor :source, :steps, :packages, :build_depends, :input_hooks
+
+    def initialize
+      @source = Source::Null
+      @steps = {}
+      @packages = [PackageRecipe.new]
+      @packages[0].files << '**'
+      @build_depends = {}
+      @input_hooks = []
+    end
+
+    def depends
+      depends = @packages.map(&:depends).inject(:merge)
+      @packages.map(&:name).each do | n |
+        depends.delete(n)
+      end
+      return depends
+    end
+
+    def lint
+      packages.flat_map(&:lint)
+    end
+
+    def apply_input( package )
+      input_hooks.each{|h| h.call(self, package) }
+      return package
+    end
+
+  end
+
+end ; end