pleaserun 0.0.1

data/lib/pleaserun/configurable.rb

@@ -0,0 +1,143 @@
+require "pleaserun/namespace"
+require "insist"
+
+# A mixin class that provides 'attribute' to a class.
+# The main use for such attributes is to provide validation for mutators.
+#
+# Example:
+#
+#     class Person
+#       include PleaseRun::Configurable
+#
+#       attribute :greeting, "A simple greeting" do |greeting|
+#         # do any validation here.
+#         raise "Greeting must be a string!" unless greeting.is_a?(String)
+#       end
+#     end
+#
+#     person = Person.new
+#     person.greeting = 1234 # Fails!
+#     person.greeting = "Hello, world!"
+#
+#     puts person.greeting
+#     # "Hello, world!"
+module PleaseRun::Configurable
+  class ConfigurationError < ::StandardError; end
+  class ValidationError < ConfigurationError; end
+
+  def self.included(klass)
+    klass.extend(ClassMixin)
+
+    m = respond_to?(:initialize) ? method(:initialize) : nil
+    define_method(:initialize) do |*args, &block|
+      m.call(*args, &block) if m
+      configurable_setup
+    end
+  end # def self.included
+
+  def configurable_setup
+    @attributes = {}
+    self.class.ancestors.each do |ancestor|
+      next unless ancestor.include?(PleaseRun::Configurable)
+      ancestor.attributes.each do |facet|
+        @attributes[facet.name] = facet.clone
+      end
+    end
+  end # def configurable_setup
+
+  module ClassMixin
+    # Define an attribute on this class.
+    def attribute(name, description, options={}, &validator)
+      facet = Facet.new(name, description, options, &validator)
+      attributes << facet
+
+      # define '<name>' and '<name>=' methods
+      define_method(name.to_sym) do
+        # object instance, not class ivar
+        @attributes[name.to_sym].value
+      end
+
+      define_method("#{name}=".to_sym) do |value|
+        # object instance, not class ivar
+        @attributes[name.to_sym].value = value
+      end
+
+      define_method("#{name}?".to_sym) do
+        return @attributes[name.to_sym].set?
+      end
+    end # def attribute
+
+    def attributes
+      return @attributes ||= []
+    end
+
+    def all_attributes
+      return ancestors.select { |a| a.respond_to?(:attributes) }.collect{ |a| a.attributes }.flatten
+    end # def attributes
+  end # def ClassMixin
+
+  class FacetBuilder
+    def initialize(facet, &block)
+      @facet = facet
+      instance_eval(&block)
+    end
+
+    def validate(&block)
+      @facet.validator = block
+    end
+    def munge(&block)
+      @facet.munger = block
+    end
+  end
+
+  class Facet
+    attr_reader :name
+    attr_reader :description
+
+    def initialize(name, description, options={}, &validator)
+      insist { name }.is_a?(Symbol)
+      insist { description }.is_a?(String)
+      insist { options }.is_a?(Hash)
+      
+      @name = name
+      @description = description
+      @options = options
+
+      FacetBuilder.new(self, &validator) if block_given?
+
+      if @options[:default]
+        validate(@options[:default])
+      end
+    end # def initialize
+
+    def validator=(callback)
+      @validator = callback
+    end # def validator=
+
+    def munger=(callback)
+      @munger = callback
+    end # def munger=
+
+    def value=(v)
+      v = @munger.call(v) if @munger
+      validate(v)
+      @value = v
+    end # def value=
+
+    def validate(v)
+      return @validator.call(v) if @validator
+    rescue => e
+      raise ValidationError, "Invalid value '#{v.inspect}' for attribute '#{name}' (#{e})"
+    end # def validate
+
+    def value
+      return @value if @value
+      return @options[:default] if @options.include?(:default)
+      return nil
+    end # def value
+
+    def set?
+      return !@value.nil?
+    end # def set?
+  end # class Facet
+end # module PleaseRun::Configurable

data/lib/pleaserun/detector.rb

@@ -0,0 +1,58 @@
+require "cabin"
+class PleaseRun::Detector
+  class UnknownSystem < StandardError; end
+
+  MAPPING = {
+    ["ubuntu", "12.04"] => ["upstart", "1.5"],
+    ["ubuntu", "12.10"] => ["upstart", "1.5"],
+    ["ubuntu", "13.04"] => ["upstart", "1.5"],
+    ["ubuntu", "13.10"] => ["upstart", "1.5"],
+    ["debian", "7"] => [ "sysv", "lsb-3.1"],
+    ["debian", "6"] => [ "sysv", "lsb-3.1"],
+    ["fedora", "18"] => [ "systemd", "default"],
+    ["fedora", "19"] => [ "systemd", "default"],
+    ["fedora", "20"] => [ "systemd", "default"]
+  }
+
+  def self.detect
+    @logger ||= Cabin::Channel.get
+    begin
+      platform, version = detect_ohai
+    rescue LoadError => e
+      @logger.debug("Failed to load ohai", :exception => e)
+      begin
+        platform, version = detect_facter
+      rescue LoadError
+      end
+    end
+
+    raise UnknownSystem if platform.nil? || version.nil?
+    system = MAPPING[ [platform, version] ]
+    raise UnknownSystem if system.nil?
+    return system
+  end # def detect
+
+  def self.detect_ohai
+    require "ohai/system"
+    ohai = Ohai::System.new
+    # TODO(sissel): Loading all plugins takes a long time (seconds). 
+    # TODO(sissel): Figure out how to load just the platform plugin correctly.
+    ohai.all_plugins
+
+    platform = ohai["platform"]
+    platform_version = ohai["platform_version"]
+    version = case platform
+      # Take '6.0.8' and make it just '6' since debian never makes major
+      # changes in a minor release
+      when "debian" ; platform_version[/^[0-9]+/]
+      else ; platform_version
+    end # case platform
+
+    return platform, version
+  end # def detect_ohai
+
+  def self.detect_facter
+    require "facter"
+  end
+
+end

data/lib/pleaserun/mustache_methods.rb

@@ -0,0 +1,41 @@
+require "pleaserun/namespace"
+require "shellwords" # stdlib
+require "mustache" # gem 'mustache'
+
+module PleaseRun::MustacheMethods
+  def escaped_args
+    return if args.nil?
+    return Shellwords.shellescape(Shellwords.shelljoin(args))
+  end # def escaped_args
+
+  def escaped(str)
+    return Shellwords.shellescape(Mustache.render(str, self))
+  end # def escaped
+
+  def shell_args
+    return if args.nil?
+    return args.collect { |a| shell_quote(a) }.join(" ")
+  end # def shell_args
+
+  def shell_quote(str)
+    # interpreted from POSIX 1003.1 2004 section 2.2.3 (Double-Quotes)
+
+    # $ is has meaning, escape it.
+    value = str.gsub(/(?<![\\])\$/, "\\$")
+    # ` is has meaning, escape it.
+    value = value.gsub(/`/) { "\\`" }
+
+    # Backslash means escape a literal unless followed by one of $`"\
+    value = value.gsub(/\\[^$`"\\]/) { |v| "\\#{v}" }    
+
+    return "\"" + value + "\""
+  end # def shell_quote
+
+  def shell_continuation(str)
+    return render(str).split("\n").reject { |l| l =~ /^\s*$/ }.join(" \\\n")
+  end # def shell_continuation
+
+  def quoted(str)
+    return shell_quote(render(str))
+  end
+end

data/lib/pleaserun/namespace.rb

@@ -0,0 +1,3 @@
+module PleaseRun
+  module Platform; end
+end

data/lib/pleaserun/platform/base.rb

@@ -0,0 +1,144 @@
+require "pleaserun/namespace"
+require "pleaserun/configurable"
+require "pleaserun/mustache_methods"
+
+require "insist" # gem 'insist'
+
+class PleaseRun::Platform::Base
+  include PleaseRun::Configurable
+  include PleaseRun::MustacheMethods
+
+  class InvalidTemplate < ::StandardError; end
+
+  attribute :name, "The name of this program." do
+    validate do |name|
+      insist { name.is_a?(String) }
+    end
+  end
+
+  attribute :program, "The program to execute. This can be a full path, like " \
+    "/usr/bin/cat, or a shorter name like 'cat' if you wish to search $PATH." do
+    validate do |program|
+      insist { program.is_a?(String) } 
+    end
+  end
+
+  attribute :args, "The arguments to pass to the program." do
+    validate do |args|
+      insist { args }.is_a?(Array)
+      args.each { |a| insist { a }.is_a?(String) }
+    end
+  end
+
+  attribute :user, "The user to use for executing this program.",
+            :default => "root" do
+    validate do |user|
+      insist { user }.is_a?(String)
+    end
+  end
+
+  attribute :group, "The group to use for executing this program.",
+            :default => "root" do
+    validate do |group|
+      insist { group }.is_a?(String)
+    end
+  end
+
+  attribute :target_version, "The version of this runner platform to target." do
+    validate do |version|
+      insist { version.is_a?(String) }
+    end
+  end
+  
+  attribute :description, "The human-readable description of your program",
+            :default => "no description given" do
+    validate do |description|
+      insist { description }.is_a?(String)
+    end
+  end
+
+  # TODO(sissel): Should this be a numeric, not a string?
+  attribute :umask, "The umask to apply to this program",
+            :default => "022" do
+    validate do |umask|
+      insist { umask }.is_a?(String)
+    end
+  end
+
+  attribute :chroot, "The directory to chroot to", :default => "/" do
+    validate do |chroot|
+      insist { chroot }.is_a?(String)
+    end
+  end
+
+  attribute :chdir, "The directory to chdir to before running" do
+    validate do |chdir|
+      insist { chdir }.is_a?(String)
+    end
+  end
+
+  attribute :nice, "The nice level to add to this program before running" do
+    validate do |nice|
+      insist { nice }.is_a?(Fixnum)
+    end
+    munge do |nice|
+      next nice.to_i
+    end
+  end
+
+  attribute :prestart, "A command to execute before starting and restarting. A failure of this command will cause the start/restart to abort. This is useful for health checks, config tests, or similar operations."
+
+  def initialize(target_version)
+    configurable_setup
+    self.target_version = target_version
+  end # def initialize
+
+  # Get the platform name for this class.
+  # The platform name is simply the lowercased class name, but this can be overridden by subclasses (but don't, because that makes things confusing!)
+  def platform
+    return self.class.name.split(/::/)[-1].downcase
+  end # def platform
+
+  # Get the template path for this platform.
+  def template_path
+    return File.join("templates", platform)
+  end # def template_path
+
+  def render_template(name)
+    possibilities = [ 
+      File.join(template_path, target_version, name),
+      File.join(template_path, "default", name),
+      File.join(template_path, name)
+    ]
+
+    possibilities.each do |path|
+      next if !(File.readable?(path) && File.file?(path))
+      return render(File.read(path))
+    end
+
+    raise InvalidTemplate, "Could not find template file for '#{name}'. Tried all of these: #{possibilities.inspect}"
+  end # def render_template
+
+  # Render a text input through Mustache based on this object.
+  def render(text)
+    return Mustache.render(text, self)
+  end # def render
+
+  # Get a safe-ish filename.
+  #
+  # This renders `str` through Mustache and replaces spaces with underscores.
+  def safe_filename(str)
+    return render(str).gsub(" ","_")
+  end # def safe_filename
+
+  # The default install_actions is none.
+  #
+  # Subclasses which need installation actions should implement this method.
+  # This method will return an Array of String commands to execute in order
+  # to install this given runner.
+  #
+  # For examples, see launchd and systemd platforms.
+  def install_actions
+    return []
+  end # def install_actions
+end # class PleaseRun::Base

data/lib/pleaserun/platform/launchd.rb

@@ -0,0 +1,27 @@
+require "pleaserun/platform/base"
+require "pleaserun/namespace"
+
+class PleaseRun::Platform::LaunchD < PleaseRun::Platform::Base
+  # Returns the file path to write this launchd config
+  def daemons_path
+    # Quoting launchctl(1):      
+    #    "/Library/LaunchDaemons         System wide daemons provided by the administrator."
+    return safe_filename("/Library/LaunchDaemons/{{ name }}.plist")
+  end # def daemons_path
+
+  def files
+    return Enumerator::Generator.new do |out|
+      out.yield [ daemons_path, render_template("program.plist") ]
+    end
+  end # def files
+
+  def install_actions
+    return [ "launchctl load #{daemons_path}", ]
+  end # def install_actions
+
+  def xml_args
+    return if args.nil?
+    return args.collect { |a| "<string>#{a}</string>" }.join("\n        ")
+  end # def xml_args
+end
+

data/lib/pleaserun/platform/runit.rb

@@ -0,0 +1,18 @@
+require 'pleaserun/namespace'
+require "pleaserun/platform/base"
+
+class PleaseRun::Platform::Runit < PleaseRun::Platform::Base
+  attribute :service_path, "The path runit service directory",
+            :default => "/service" do |path|
+    validate do
+      insist { path }.is_a?(String)
+    end
+  end
+
+  def files
+    return Enumerator::Generator.new do |enum|
+      enum.yield [ safe_filename("{{ service_path }}/{{ name }}/run"), render_template('run') ]
+      enum.yield [ safe_filename("{{ service_path }}/{{ name}}/log/run"), render_template('log') ]
+    end
+  end
+end

data/lib/pleaserun/platform/systemd.rb

@@ -0,0 +1,24 @@
+require 'pleaserun/namespace'
+require "pleaserun/platform/base"
+
+class PleaseRun::Platform::Systemd < PleaseRun::Platform::Base
+  def files
+    begin
+      # TODO(sissel): Make it easy for subclasses to extend validation on attributes.
+      insist { program } =~ /^\//
+    rescue Insist::Failure
+      raise PleaseRun::Configurable::ValidationError, "In systemd, the program must be a full path. You gave '#{program}'."
+    end
+
+    return Enumerator::Generator.new do |enum|
+      enum.yield [ safe_filename("/lib/systemd/system/{{{ name }}}.service"), render_template("program.service") ]
+      if prestart
+        enum.yield [ safe_filename("/lib/systemd/system/{{{ name }}}-prestart.sh"), render_template("prestart.sh"), 0755 ]
+      end
+    end
+  end # def files
+
+  def install_actions
+    return [ "systemctl --system daemon-reload" ]
+  end
+end # class PleaseRun::Platform::Systemd