pleaserun 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+.rspec_system/
+.*.sw*
+.vagrant
+.bundle

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+gem "clamp"
+gem "cabin"
+gem "stud"
+gem "mustache"
+gem "insist"
+
+# For testing
+gem "rspec"
+gem "guard"
+gem "guard-rspec"
+gem "net-ssh"
+gem "peach"

data/Gemfile.lock

@@ -0,0 +1,73 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    atomic (1.1.15)
+    avl_tree (1.1.3)
+    cabin (0.6.1)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    clamp (0.6.3)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.3)
+    formatador (0.2.4)
+    guard (2.2.5)
+      formatador (>= 0.2.4)
+      listen (~> 2.1)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.0.4)
+      guard (>= 2.1.1)
+      rspec (~> 2.14)
+    hitimes (1.2.1)
+    insist (1.0.0)
+    listen (2.4.0)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.4)
+    method_source (0.8.2)
+    metriks (0.9.9.6)
+      atomic (~> 1.0)
+      avl_tree (~> 1.1.2)
+      hitimes (~> 1.1)
+    mustache (0.99.5)
+    net-ssh (2.8.0)
+    peach (0.5.1)
+    pry (0.9.12.4)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.3)
+      ffi (>= 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    slop (3.4.7)
+    stud (0.0.17)
+      ffi
+      metriks
+    thor (0.18.1)
+    timers (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cabin
+  clamp
+  guard
+  guard-rspec
+  insist
+  mustache
+  net-ssh
+  peach
+  rspec
+  stud

data/Guardfile

@@ -0,0 +1,17 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+notification :tmux,
+  display_message: true,
+  timeout: 5, # in seconds
+  default_message_format: '%s >> %s',
+  success: 'green',
+  default_message_color: 'black',
+  line_separator: ' > ', # since we are single line we need a separator
+  color_location: 'status-left-bg' # to customize which tmux element will change color
+
+guard :rspec, cmd: 'rspec --color --order rand:$RANDOM' do
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/.*\.rb$}) { |m| m[0] }
+end
+

data/Makefile

@@ -0,0 +1,50 @@
+GEMSPEC=$(shell ls *.gemspec)
+VERSION=$(shell awk -F\" '/spec.version/ { print $$2 }' $(GEMSPEC))
+NAME=$(shell awk -F\" '/spec.name/ { print $$2 }' $(GEMSPEC))
+GEM=$(NAME)-$(VERSION).gem
+
+.PHONY: test
+test:
+	sh notify-failure.sh ruby test/all.rb
+
+.PHONY: testloop
+testloop:
+	while true; do \
+		$(MAKE) test; \
+		$(MAKE) wait-for-changes; \
+	done
+
+.PHONY: serve-coverage
+serve-coverage:
+	cd coverage; python -mSimpleHTTPServer
+
+.PHONY: wait-for-changes
+wait-for-changes:
+	-inotifywait --exclude '\.swp' -e modify $$(find $(DIRS) -name '*.rb'; find $(DIRS) -type d)
+
+.PHONY: package
+package: | $(GEM)
+
+.PHONY: gem
+gem: $(GEM)
+
+$(GEM):
+	gem build $(GEMSPEC)
+
+.PHONY: test-package
+test-package: $(GEM)
+	# Sometimes 'gem build' makes a faulty gem.
+	gem unpack $(GEM)
+	rm -rf $(NAME)-$(VERSION)/
+
+.PHONY: publish
+publish: test-package
+	gem push $(GEM)
+
+.PHONY: install
+install: $(GEM)
+	gem install $(GEM)
+
+.PHONY: clean
+clean:
+	-rm -rf .yardoc $(GEM) $(NAME)-$(VERSION)/

data/README.md

@@ -0,0 +1,98 @@
+# Please, Run!
+
+Pleaserun is a tool to generate startup scripts for the wasteland of sorrow
+that is process launchers.
+
+Ideally, you should be able to specify a configuration of how to run a given
+service command (like apache, syslog-ng, whatever), and this tool should
+be able to spit out a script or config file for your target platform.
+
+## Installation
+
+```
+gem install pleaserun
+```
+
+## Your First Process
+
+First, we need a program to run!
+
+### Example: redis
+
+For no particular reason, this example will choose redis to run. The idea is to
+simulate the same workflow you would normally go through in production: acquire
+software, deploy it, run it. Pleaserun helps you with the 'run it' part, but
+first let's get redis and build it.
+
+```
+wget http://download.redis.io/releases/redis-2.8.6.tar.gz
+tar -zxf redis-2.8.6.tar.gz
+cd redis-2.8.6
+make -j4
+make install PREFIX=/tmp/redis
+```
+
+Assuming the above succeeds (it did for me!), we now have redis installed to `/tmp/redis`:
+
+```
+% ls /tmp/redis/bin
+redis-benchmark  redis-check-aof  redis-check-dump  redis-cli  redis-server
+```
+
+You might be thinking - why /tmp? This is just a demo! That's why! :)
+
+### Generate a runner
+
+What platform are you on? Do you know the best way to run a server process? I
+can never remember.
+
+Luckily, pleaserun remembers.
+
+```
+# Run as root so pleaserun has permissions to write to
+# any files required to install this as a service!
+% sudo pleaserun --install /tmp/redis/bin/redis-server
+No platform selected. Autodetecting... {:platform=>"upstart", :version=>"1.5", :level=>:warn}
+No name given, setting reasonable default {:name=>"redis-server", :level=>:warn}
+Writing file {:destination=>"/etc/init/redis-server.conf"}
+Writing file {:destination=>"/etc/init.d/redis-server"}
+```
+
+Note: The `--install` flag above tells pleaserun to install it on this current system. The
+default behavior without this flag is to install it in a temp directory so you can copy
+it elsewhere if desired.
+
+Now what? You can see above it automatically detected that "Upstart 1.5" was
+the right process runner to target. Let's try using it!
+
+```
+% status redis-server
+redis-server stop/waiting
+
+% sudo start redis-server
+redis-server start/running, process 395
+
+% status redis-server
+redis-server start/running, process 395
+
+% ps -fwwp 395
+UID        PID  PPID  C STIME TTY          TIME CMD
+root       395     1  0 06:27 ?        00:00:00 /tmp/redis/bin/redis-server *:6379
+
+# Is it running? Let's check with redis-cli
+% redis-cli
+127.0.0.1:6379> ping
+PONG
+
+% sudo stop redis-server
+redis-server stop/waiting
+```
+
+Bam. Pretty easy, right? Let's recap!
+
+### Recap
+
+* You ran `pleaserun --install /tmp/redis/bin/redis-server`
+* Pleaserun detected the platform as Upstart 1.5
+* You didn't have to write an init script.
+* You didn't have to know how to write an Upstart config.

data/bin/pleaserun

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+libdir = File.expand_path("../lib", File.dirname(__FILE__))
+$: << libdir if File.exists?(File.join(libdir, "pleaserun", "cli.rb"))
+require "pleaserun/cli"
+
+exit(PleaseRun::CLI.run || 0)

data/examples/runit.rb

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby
+
+require 'pleaserun/runit'
+
+pr = PleaseRun::RunIt.new('debian-7.0')
+pr.name    = 'foo'
+pr.user    = 'nobody'
+pr.command = '/bin/true'
+pr.args    = []
+
+pr.files.each do |path, content|
+  puts path => content.bytes.size
+  puts "#{path}:"
+  puts content.gsub(/^/, '  ')
+end
+

data/lib/pleaserun/cli.rb

@@ -0,0 +1,241 @@
+
+require "pleaserun/namespace"
+require "clamp"
+require "cabin"
+require "stud/temporary"
+
+require "pleaserun/platform/base"
+
+class PleaseRun::CLI < Clamp::Command
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class PlatformLoadError < Error; end
+  class FileWritingFailure < Error; end
+
+  option ["-p", "--platform"], "PLATFORM", "The name of the platform to target, such as sysv, upstart, etc"
+  option ["-v", "--version"], "VERSION", "The version of the platform to target, such as 'lsb-3.1' for sysv or '1.5' for upstart",
+    :default => "default", :attribute_name => :target_version
+
+  option "--log", "LOGFILE", "The path to use for writing pleaserun logs."
+  option "--json", :flag, "Output a result in JSON. Intended to be consumed by other programs. This will emit the file contents and install actions as a JSON object."
+
+  option "--install", :flag, "Install the program on this system. This will write files to the correct location and execute any actions to make the program available to the system."
+
+  option "--verbose", :flag, "More verbose logging"
+  option "--debug", :flag, "Debug-level logging"
+  option "--quiet", :flag, "Only errors or worse will be logged"
+
+  PleaseRun::Platform::Base.attributes.each do |facet|
+    # Skip program and args which we don't want to make into flags.
+    next if [:program, :args, :target_version].include?(facet.name)
+
+    # Turn the attribute name into a flag.
+    option "--#{facet.name}", facet.name.to_s.upcase, facet.description,
+      :attribute_name => facet.name
+  end
+  
+  # TODO(sissel): Make options based on other platforms
+
+  # Make program and args attributes into parameters
+  base = PleaseRun::Platform::Base
+
+  # Load the 'program' attribute from the Base class and use it as the first
+  # cli parameter.
+  program = base.attributes.find { |f| f.name == :program }
+  raise "Something is wrong; Base missing 'program' attribute" if program.nil?
+  parameter "PROGRAM", program.description, :attribute_name => program.name
+
+  # Load the 'args' attribute from the Base class
+  # and use it as the remaining arguments setting
+  args = base.attributes.find { |f| f.name == :args }
+  raise "Something is wrong; Base missing 'args' attribute" if program.nil?
+
+  parameter "[ARGS] ...", args.description, :attribute_name => args.name
+
+  def help
+    return <<-HELP
+Welcome to pleaserun!
+
+This program aims to help you generate 'init' scripts/configs for various
+platforms. The simplest example takes only the command you wish to run.
+For example, let's run elasticsearch:
+
+    % pleaserun /opt/elasticsearch/bin/elasticsearch
+
+The above will automatically detect what platform you are running on
+and try to use the most sensible init system. For Ubuntu, this means
+Upstart. For Debian, this means sysv init scripts. For Fedora, this
+means systemd. 
+
+You can the running environment and settings for your runner with various
+flags. By way of example, let's make our elasticsearch service run as the
+'elasticsearch' user! 
+
+    % pleaserun --user elasticsearch /opt/elasticsearch/bin/elasticsearch
+
+If you don't want the platform autodetected, you can always specify the
+exact process launcher to target:
+
+    # Generate a sysv (/etc/init.d) script for LSB 3.1 (Debian uses this)
+    % pleaserun -p sysv -v lsb-3.1 /opt/elasticsearch/bin/elasticsearch
+
+Let's do another example. How about running nagios in systemd, but we
+want to abort if the nagios config is invalid?
+
+    % pleaserun -t systemd \
+      --prestart "/usr/sbin/nagios -v /etc/nagios/nagios.cfg" \
+      /usr/sbin/nagios /etc/nagios/nagios.cfg
+
+The above makes 'nagios -v ...' run before any start/restart attempts
+are made. If it fails, nagios will not start. Yay!
+
+#{super}
+    HELP
+  end
+
+  def execute
+    setup_logger
+
+    # Provide any dynamic defaults if necessary
+    if platform.nil?
+      require "pleaserun/detector"
+      self.platform, self.target_version = PleaseRun::Detector.detect
+      @logger.warn("No platform selected. Autodetecting...", :platform => platform, :version => target_version)
+    end
+
+    if name.nil?
+      self.name = File.basename(program)
+      @logger.warn("No name given, setting reasonable default", :name => self.name)
+    end
+
+    # Load the platform implementation
+    platform_klass = load_platform(platform)
+    runner = platform_klass.new(target_version)
+
+    platform_klass.all_attributes.each do |facet|
+      # Get the value of this attribute
+      # The idea here is to translate CLI options to runner settings
+      value = send(facet.name)
+      next if value.nil?
+      @logger.debug("Setting runner attribute", :name => facet.name, :value => value)
+
+      # Set the value in the runner we've selected
+      # This is akin to `obj.someattribute = value`
+      runner.send("#{facet.name}=", value)
+    end
+
+    if json?
+      return run_json(runner)
+    else
+      return run_human(runner)
+    end
+    return 0
+  rescue Error => e
+    @logger.error("An error occurred: #{e}")
+    return 1
+  end # def execute
+
+  def run_json(runner)
+    require "json"
+
+    result = {}
+    result["files"] = []
+    runner.files.each do |path, content, perms|
+      result["files"] << {
+        "path" => path,
+        "content" => content,
+        "perms" => perms
+      }
+    end
+
+    result["install_actions"] = runner.install_actions
+
+    puts JSON.dump(result)
+    return 0
+  end # def run_json
+
+  def run_human(runner)
+    tmp = Stud::Temporary.directory
+    errors = []
+
+    runner.files.each do |path, content, perms|
+      #perms ||= (0666 ^ File.umask)
+      fullpath = install? ? path : File.join(tmp, path)
+      success = write(fullpath, content, perms)
+      errors << fullpath unless success
+    end
+
+    if errors.any?
+      raise FileWritingFailure, "Errors occurred while writing files"
+    end
+
+    # TODO(sissel): Refactor this to be less lines of code or put into methods.
+    if runner.install_actions.any?
+      if install?
+        runner.install_actions.each do |action|
+          @logger.info("Running install action", :action => action)
+          system(action)
+          if !$?.success?
+            @logger.warn("Install action failed", :action => action, :code => $?.exitstatus)
+          end
+        end # each install action
+      else
+        path = File.join(tmp, "install_actions.sh")
+        @logger.log("Writing install actions. You will want to run this script to properly activate your service on the target host", :path => path)
+        File.open(path, "w") do |fd|
+          runner.install_actions.each do |action|
+            fd.puts(action)
+          end
+        end
+      end
+    end # if runner.install_actions.any?
+  end # def run_human
+
+  def write(fullpath, content, perms)
+    @logger.log("Writing file", :destination => fullpath)
+    FileUtils.mkdir_p(File.dirname(fullpath))
+    File.write(fullpath, content)
+    @logger.debug("Setting permissions", :destination => fullpath, :perms => perms)
+    File.chmod(perms, fullpath) if perms
+    return true
+  rescue Errno::EACCES
+    @logger.error("Access denied in writing a file. Maybe we need to be root?", :path => fullpath)
+    return false
+  end
+
+  def setup_logger
+    @logger = Cabin::Channel.new
+    if quiet?
+      @logger.level = :error
+    elsif verbose?
+      @logger.level = :info
+    elsif debug?
+      @logger.level = :debug
+    else
+      @logger.level = :warn
+    end
+
+    if log
+      logfile = File.new(logfile, "a")
+      @logger.subscribe(logfile)
+      STDERR.puts "Sending all logs to #{log}" if STDERR.tty?
+    else
+      @logger.subscribe(STDERR)
+    end
+  end # def setup_logger
+
+  def load_platform(v)
+    @logger.debug("Loading platform", :platform => v)
+    platform_lib = "pleaserun/platform/#{v}"
+    require(platform_lib)
+
+    const = PleaseRun::Platform.constants.find { |c| c.to_s.downcase == v.downcase }
+    if const.nil?
+      raise PlatformLoadError, "Could not find platform named '#{v}' after loading library '#{platform_lib}'. This is probably a bug."
+    end
+
+    return PleaseRun::Platform.const_get(const)
+  rescue LoadError => e
+    raise PlatformLoadError, "Failed to find or load platform '#{v}'. This could be a typo or a bug. If it helps, the error is: #{e}"
+  end # def load_platform
+end # class PleaseRun::CLI