vuderacha-syrup 0.1.0

data/README.rdoc

@@ -0,0 +1,57 @@
+= Syrup - Service Management
+Syrup provides mechanism for managing your application daemons. Instead of needing
+to manually background processes (such as queue workers), you just configure
+a config.sy file, and then start and stop it.
+
+== Getting Started
+Syrup assumes that you'll deploy one application group per user account. You can
+run more if you want to, but Syrup makes it a lot easier if you don't...
+
+Firstly, download and install syrup
+  git clone git://github.com/vuderacha/syrup.git
+  cd syrup
+  rake install
+
+Assuming you have a simple application such as:
+  # test_service.rb
+  while true
+    File.open('/tmp/test.txt', 'a') {|f| f << "a\n"}
+    sleep 2
+
+Create a configuration file for Syrup to run it:
+  # config.sy
+  service 'myservice', 'test-service.rb'
+
+For Syrup to use an application, you need to "activate" it. This informs Syrup about the
+path of the application, and allows it to automatically start the app again later when you
+may not be around to tell it about it! Assuming that you've put your app into /home/syruptest/app,
+then you'll just issue the command:
+  syrup activate /home/syruptest/app
+
+This will create a file called "activated" in /home/syruptest/.syrup containing the path to this app.
+
+Finally, start the application with:
+  syrup start
+
+Conversely, stop it with:
+  syrup stop
+
+== Supported Application Types
+Syrup currently supports two types of application. Services are declared in the form
+  service "<name>", "<file>"
+
+Rack applications are also supported. To run a rack application, add the following to your config.sy:
+  rack "<name>", "<rack arguments>"
+Note that if your config.ru doesn't require any arguments, then the second parameter is entirely optional.
+
+== Persistent Configuration
+Often, applications need per deployment configuration. One example is configuring whether a given host is
+production or development. Whilst there are many ways to do this, Syrup adds yet another. Within a given
+account, commands like the following can be issued:
+  syrup set PROP=VALUE
+This property will be permanently stored (in ~/.syrup/props), and will be applied into the environment of
+all applications loaded through Syrup at their next start. So, for example, if your app had a line that read
+  puts RACK_ENV
+then executing
+  syrup set RACK_ENV=production
+would result in the application reporting "production" upon reaching the aforementioned line.

data/Rakefile

@@ -0,0 +1,69 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_opts  = ["-cfs"]
+	t.spec_files = FileList['spec/**/*_spec.rb']
+	t.libs = ['lib']
+end
+
+desc "Print specdocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+	t.spec_opts = ["--format", "specdoc", "--dry-run"]
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Generate RCov code coverage report"
+Spec::Rake::SpecTask.new('rcov') do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.rcov = true
+	t.rcov_opts = ['--exclude', 'examples']
+end
+
+task :default => :spec
+
+######################################################
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+include FileUtils
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "syrup"
+  	s.summary = "Ruby service application manager."
+  	s.description = "Syrup is a process manager for working with services. It provides the ability to deploy and manage long-running services."
+  	s.author = "Paul Jones"
+  	s.email = "pauljones23@gmail.com"
+  	s.homepage = "http://github.com/vuderacha/syrup/"
+  	s.executables = [ "syrup" ]
+  	s.default_executable = "syrup"
+  	
+  	s.files = %w(Rakefile README.rdoc VERSION.yml) + Dir.glob("{bin,lib,spec}/**/*")
+
+  	s.require_path = "lib"
+  	s.bindir = "bin"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :test => [ :spec ]
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'rdoc'
+	t.title    = "Syrup -- Process Manager"
+	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('README.rdoc')
+	t.rdoc_files.include('lib/syrup/*.rb')
+end
+
+CLEAN.include [ 'build/*', '**/*.o', '**/*.so', '**/*.a', 'lib/*-*', '**/*.log', 'pkg', 'lib/*.bundle', '*.gem', '.config' ]
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 1

data/bin/syrup

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'syrup'
+rescue LoadError
+  require 'rubygems'
+  require 'syrup'
+end
+a = Syrup::Application.new
+a.run ARGV

data/lib/launcher.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'syrup'
+rescue LoadError
+  require 'rubygems'
+  require 'syrup'
+end
+a = Syrup::Application.new
+a.run ARGV

data/lib/syrup/config_store.rb

@@ -0,0 +1,169 @@
+module Syrup
+  # Module that allows a given object to store a Fabric. Requires the including module to have
+  # a fabric_fn method.
+  module WithFabric
+    def fabric
+      return File.read(fabric_fn) if File.file? fabric_fn
+      return nil
+    end
+    
+    def fabric=(path)
+      unless path.nil?
+        File.open(fabric_fn, 'w'){ |f| f.write(File.expand_path(path)) }
+      else
+        File.delete fabric_fn if File.file? fabric_fn
+      end
+    end
+  end
+  
+  class ConfigStore
+    include WithFabric
+    
+    attr_reader :properties
+    
+    # Initializes the configuration store with the given storage directory.
+    def initialize(path)
+      @path = path
+      @properties = StoredHash.new File.join(@path, 'props')
+    end
+    
+    # Retrieves all of the applications that are configured within the system
+    def applications
+      apps = {}
+      Dir[File.join(@path, '*')].each do |store_dir|
+        name = File.basename(store_dir)
+        
+        apps[name] = ApplicationConfiguration.new name, store_dir
+      end
+      
+      apps
+    end
+    
+    # Creates a new application
+    def create_application(name)
+      store_dir = File.join(@path, name)
+      FileUtils.mkdir_p store_dir
+      
+      ApplicationConfiguration.new name, store_dir
+    end
+    
+    def fabric_fn
+      File.join(@path, 'fabric')
+    end
+  end
+  
+  class ApplicationConfiguration
+    include WithFabric
+    
+    attr_reader :name
+    attr_reader :properties
+    
+    def initialize(name, path)
+      @name = name
+      @path = path
+      @properties = StoredHash.new File.join(@path, 'props')
+      @start_parameters = if File.file? start_params_fn then YAML::load_file(start_params_fn) else [] end
+    end
+
+    def app
+      return File.read(activated_fn) if File.file? activated_fn
+      return nil
+    end
+    
+    def app=(path)
+      unless path.nil?
+        File.open(activated_fn, 'w'){ |f| f.write(File.expand_path(path)) }
+      else
+        File.delete activated_fn if File.file? activated_fn
+      end
+    end
+    
+    def pid
+      result = File.read(pid_fn) rescue nil
+      return result.to_i unless result.nil?
+      
+      nil
+    end
+    
+    def pid=(i)
+      unless i.nil?
+        File.open(pid_fn, 'w'){ |f| f.write(i) }
+      else
+        File.delete pid_fn if File.file? pid_fn
+      end
+    end
+    
+    def start_parameters
+      @start_parameters
+    end
+    
+    def start_parameters=(params)
+      @start_parameters = params
+      
+      unless params.nil? or params.length == 0
+        File.open(start_params_fn, 'w') { |f| f.write(params.to_yaml) }
+      else
+        File.delete start_params_fn if File.file? start_params_fn
+      end
+    end
+
+    def activated_fn
+      File.join(@path, 'activated')
+    end
+    
+    def props_fn
+      File.join(@path, 'props')
+    end
+
+    def fabric_fn
+      File.join(@path, 'fabric')
+    end
+    
+    def start_params_fn
+      File.join(@path, 'start_params')
+    end
+    
+    def pid_fn
+      File.join(@path, 'pid')
+    end
+  end
+  
+  class StoredHash
+    def initialize(file)
+      @file = file
+      @props = if File.file? file then YAML::load_file(file) else {} end
+    end
+    
+    def [](k)
+      @props[k]
+    end
+    
+    def []=(k, v)
+      @props[k] = v
+      
+      save!
+    end
+    
+    def length
+      @props.length
+    end
+    
+    def clear
+      @props.clear
+      File.delete @file if File.file? @file
+    end
+    
+    def delete(key)
+      @props.delete(key)
+      save!
+    end
+    
+    def each(&block)
+      @props.each(&block)
+    end
+    
+    def save!
+      File.open(@file, 'w') {|f| f << @props.to_yaml}
+    end
+  end
+end

data/lib/syrup/daemon.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+
+module Syrup
+  class Daemon
+    def initialize(config_directory, app)
+      @config_directory = config_directory
+      @app = app
+    end
+    
+    def start
+      # Check if the process is already running first
+      if File.file? pid_fn
+        running = (not Process.getpgid(recall_pid).nil?) rescue false
+        if running
+          puts "Syrup is already running. Stop Syrup before trying to start it"
+          exit
+        end
+      end
+      
+      fork do
+        Process.setsid
+        exit if fork
+        store_pid(Process.pid)
+        #Dir.chdir WorkingDirectory
+        File.umask 0000
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen STDOUT
+        trap("TERM") {@app.stop; exit}
+        @app.start
+      end
+    end
+  
+    def stop
+      if !File.file?(pid_fn)
+        puts "Pid file not found. Is the daemon started?"
+        exit
+      end
+      pid = recall_pid
+      FileUtils.rm(pid_fn)
+      pid && Process.kill("TERM", pid)
+    end
+    
+    private
+      def pid_fn
+        File.join(File.expand_path(@config_directory), 'syrup.pid')
+      end
+    
+      def store_pid(pid)
+        FileUtils.mkdir_p File.dirname(pid_fn)
+        File.open(pid_fn, 'w') {|f| f << pid}
+      end
+
+      def recall_pid
+        IO.read(pid_fn).to_i rescue nil
+      end
+  end
+end

data/lib/syrup/executor.rb

@@ -0,0 +1,20 @@
+module Syrup
+  class Executor
+    # Executes a script in the "foreground" (ie, it only forks once). The pid is recorded
+    # in memory, and the process will return.
+    def execute_foreground(name, script, fabric, props)
+      
+    end
+    
+    # Kills all processes running in the foreground.
+    def kill_all_foreground
+    end
+    
+    # Starts a script as a daemon. Returns the pid.
+    def execute_daemon(name, script, fabric, props)
+    end
+    
+    def stop_daemon(name, pid)
+    end
+  end
+end

data/lib/syrup/fabric_support.rb

@@ -0,0 +1,31 @@
+# Support functions added to the kernel for Fabrics to work with
+module Kernel
+  # Indicates that a Fabric feature with the given name is required for the application to
+  # proceed. If the feature is initialized on demand, then it is expected that this feature
+  # will be initialized before this method returns.
+  def fabric_requirement(name)
+    Syrup.fabric_support.require_feature(name)
+  end
+end
+
+module Syrup
+  class FabricSupport
+    def initialize
+      @features = []
+    end
+    
+    def require_feature(name)
+      raise "Feature #{name} was not provided by the Fabric!" unless @features.include? name
+    end
+    
+    def register_feature(name)
+      @features << name
+    end
+  end
+  
+  class <<self
+    def fabric_support
+      @fabric_support ||= Syrup::FabricSupport.new
+    end
+  end
+end

data/lib/syrup/fabrics/default.rb

@@ -0,0 +1,2 @@
+# Very simple default fabric. Just execute the application!
+Syrup::Runner.run_application

data/lib/syrup/fabrics/rack.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rack'
+
+Syrup::Runner.run_application

data/lib/syrup/manager.rb

@@ -0,0 +1,253 @@
+require 'syrup/config_store'
+require 'yaml'
+
+module Syrup
+  # Manager for controlling the Syrup functionality
+  class Manager
+    def initialize(config_dir, logger, verbose)
+      @config_dir = config_dir
+      @logger = logger
+      @verbose = verbose
+      
+      @config_store = Syrup::ConfigStore.new @config_dir
+      @runner = Syrup::Runner.new @config_store, @logger
+    end
+    
+    # Informs the manager to start all configured applications
+    def start_all
+      if @config_store.applications.length == 0
+        @logger.warn 'No Applications activated yet. Nothing to do!'
+        return true
+      end
+      
+      @config_store.applications.each do |app_name, app|
+        start(app_name)
+      end
+    end
+    
+    # Informs the manager to start the specified application
+    def start(app_name)
+      # Retrieve the details of the application to check that it is valid
+      app = get_application(app_name, false)
+      return false if app.nil?
+      
+      fork do
+        Process.setsid
+        exit if fork
+        
+        # Record our PID
+        app.pid = Process.pid
+        
+        #Dir.chdir @working_dir
+        File.umask 0000
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "log/#{app_name}.txt", "a"
+        STDERR.reopen STDOUT
+        trap("TERM") {exit}
+        
+        at_exit do
+          # Release our pid
+          app.pid = nil
+        end
+        
+        # Run the application
+        run_app(app_name)
+      end
+      
+      return true
+    end
+    
+    # Informs the manager to stop all configured applications
+    def stop_all
+      if @config_store.applications.length == 0
+        @logger.warn 'No Applications activated yet. Nothing to do!'
+        return true
+      end
+      
+      stop(@config_store.applications.keys)
+    end
+    
+    # Informs the manager to stop the named applications
+    def stop(app_names)
+      pids = []
+      @config_store.applications.each do |app_name, app|
+        pids << app.pid if app_names.include? app_name and not app.pid.nil? 
+      end
+      
+      kill_pids pids
+    end
+    
+    # Informs the manager to activate the given path
+    def activate name, path, args
+      # Retrieve ourselves an application object
+      app = @config_store.applications[name]
+      app = @config_store.create_application(name) if app.nil?
+      
+      # Store the path to the application
+      app.app = File.expand_path(path)
+      app.start_parameters = args
+      
+      true
+    end
+    
+    # Informs the manager to run the given application in the foreground
+    def run(names)
+      # Create sub-processes for each of the named applications
+      pids = []
+      names.each do |name|
+        pids << fork do
+          run_app(name)
+        end
+      end
+      
+      # Register an at_exit handler to kill off all the pids
+      at_exit do
+        kill_pids pids
+      end
+      
+      # Wait for all children to die
+      Process.waitall.each do |pid, status|
+        # We won't need to kill the processes that successfully exited
+        pids.delete pid if status.exited?
+      end
+    end
+    
+    # Informs the manager to run the given application within the current process
+    def run_app(name)
+      @runner.run(name)
+    end
+    
+    # Requests that the manager store the given variables as persistent configuration for the given application.
+    def set_app_properties(app_name, properties)
+      app = @config_store.applications[app_name]
+      if app.nil?
+        @logger.error "Unknown Application. Cannot set properties."
+        return false
+      end
+      
+      props.each do |pair|
+        k,v = pair.split('=')
+        if k.nil? or v.nil?
+          @logger.error "Invalid set command. #{pair} not in the form K=V"
+          return false
+        end
+        
+        app.properties[k] = v
+      end
+    end
+    
+    # Requests that the manager store the given variables as persistent configuration that will be
+    # restored when all applications are started
+    def set_global_properties(props)
+      props.each do |pair|
+        k,v = pair.split('=')
+        if k.nil? or v.nil?
+          @logger.error "Invalid set command. #{pair} not in the form K=V"
+          return false
+        end
+        
+        @config_store.properties[k] = v
+      end
+    end
+        
+    # Requests that the manager remove the given keys from the stored properties for the given app.
+    def unset_app_properties(app_name, props)
+      app = @config_store.applications[app_name]
+      if app.nil?
+        @logger.error "Unknown Application. Cannot unset properties."
+        return false
+      end
+      
+      props.each do |prop|
+        app.properties.delete prop
+      end
+    end
+    
+    # Requests that the manager remove the given keys from the stored properties
+    def unset_global_properties(props)
+      props.each do |prop|
+        @config_store.properties.delete prop
+      end
+    end
+        
+    # Removes all stored properties for the current profile
+    def clear_app_properties
+      app = @config_store.applications[app_name]
+      return true if app.nil?
+      
+      app.properties.clear
+    end
+    
+    # Removes all stored properties for the current profile
+    def clear_global_properties
+      @config_store.properties.clear
+    end
+
+    # Requests that the manager load the given fabric for applications within the current profile
+    def weave_global(fabric)
+      @config_store.fabric = fabric
+    end
+    
+    def unweave_global
+      @config_store.fabric = nil
+    end
+    
+    def weave_for_application(app_name, fabric)
+      app = get_application(app_name, false)
+      return false if app.nil?
+      
+      app.fabric = fabric
+    end
+    
+    def unweave_for_application(app_name)
+      app = get_application(app_name, false)
+      return false if app.nil?
+      
+      app.fabric = nil
+    end
+    
+    private
+      def get_application(app_name, create_if_missing)
+        app = @config_store.applications[app_name]
+        app = @config_store.create_application(app_name) if create_if_missing and app.nil?
+        
+        if app.nil?
+          @logger.error "Unknown Application #{app_name}"
+        end
+        
+        app
+      end
+      
+      def kill_pids(pids)
+        # List of pids waiting at each round
+        waiting_pids = []
+        
+        (1..5).each do
+          waiting_pids = []
+          pids.each do |pid|
+            pid && Process.kill("TERM", pid) && waiting_pids << pid rescue puts "WARNING: Failed to kill #{pid}"
+          end
+        
+          # Wait for the process to die
+          (1..20).each do
+            waiting_pids.each do |pid|
+              running = (not Process.getpgid(pid).nil?) rescue false
+              waiting_pids.delete pid unless running
+            end
+
+            break if waiting_pids.empty?
+            STDERR.write "."
+            sleep 0.5
+          end
+          
+          break if waiting_pids.empty?
+          pids.replace waiting_pids
+        end
+
+        # Write a newline to clear the '.'s
+        STDERR.write "\n"
+
+        @logger.warn "Process(es) #{waiting_pids.inspect} did not terminate" unless waiting_pids.empty?
+      end
+  end
+end