vuderacha-syrup 0.1.0

data/lib/syrup/runner.rb

@@ -0,0 +1,71 @@
+# Handler class for actually running an application
+module Syrup
+  class Runner
+    # Initializes the runner with the given configuration store
+    def initialize(config_store, logger)
+      @config_store = config_store
+      @logger = logger
+    end
+    
+    # Runs the application
+    def run(app_name)
+      @logger.debug "Preparing to execute #{app_name}"
+      app = @config_store.applications[app_name]
+      
+      # Gather the properties
+      props = {}
+        # {}.merge! won't work since the config_store properties aren't a real hash...
+      @config_store.properties.each do |k,v| props[k] = v end
+      app.properties.each do |k,v| props[k] = v end
+      
+      # Find the Fabric by going from app-specific to env-specific to default
+      fabric = app.fabric
+      fabric = @config_store.fabric if fabric.nil?
+      fabric = default_fabric if fabric.nil?
+      
+      # Calculate the application executable
+      @app_path = app.app
+      
+      # Activate all of the properties
+      props.each do |k,v|
+        @logger.debug "Applying constant #{k}=#{v}" if @verbose
+        Kernel.const_set k, v
+      end
+      
+      @@active_runner = self    # Record the active instance of this runner
+      old_argv = ARGV.clone
+      begin
+        # Overwrite ARGV
+        ARGV.replace(app.start_parameters)
+        
+        # Execute the fabric, which should internally perform a Syrup::Runner.run_application when it has prepared
+        # adequately for the application to execute
+        load fabric
+      ensure
+        ARGV.replace(old_argv)
+        @@active_runner = nil
+      end
+    end
+    
+    def run_application
+      raise "Cannot execute application outside of Fabric" if @app_path.nil?
+      
+      load @app_path
+    end
+    
+    def self.run_application
+      raise "Cannot execute application outside of Fabric" if @@active_runner.nil?
+      
+      active.run_application
+    end
+    
+    def self.active
+      @@active_runner
+    end
+    
+    private
+      def default_fabric
+        File.join(File.dirname(__FILE__), 'fabrics', 'default.rb')
+      end
+  end
+end

data/lib/syrup.rb

@@ -0,0 +1,211 @@
+require 'optparse'
+require 'ostruct'
+require 'syrup/daemon'
+require 'syrup/manager'
+require 'syrup/runner'
+require 'syrup/fabric_support'
+
+module Syrup
+  # The main application class for Syrup. Handles parsing of command line arguments, configuration, and
+  # delegation to the appropriate control classes.
+  class Application
+    def self.version
+      # Load the version from the VERSION.yml file
+      version = YAML::load_file(File.join(File.dirname(__FILE__), '..', 'VERSION.yml'))
+      
+      "#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+    end
+
+    def self.logger
+      @logger ||= Syrup::Logger.new
+    end
+    
+    def run(arguments)
+      # Get the logger
+      logger = Syrup::Application.logger
+      
+      # Configure defaults
+      @options = OpenStruct.new
+      @options.directory = File.expand_path('~/.syrup')
+      @options.verbose = false
+      @options.application = nil
+      
+      # Parse the options
+      @opts = build_options
+      @opts.parse! arguments
+      
+      # Work out what command was issued
+      command, command_args = determine_command(arguments)
+      fail "No command given" if command.nil?
+      
+      # Ensure that the configured directory exists
+      logger.info "Configured directory as #{@options.directory}" if @options.verbose
+      FileUtils.mkdir_p @options.directory if not File.directory? @options.directory
+      
+      # Create a manager instance
+      manager = Syrup::Manager.new @options.directory, logger, @options.verbose
+      
+      # Handle the command
+      daemon = Syrup::Daemon.new @options.directory, manager
+      case command
+        when 'start'
+          if command_args.length < 1
+            manager.start_all
+          else
+            command_args.each { |arg| manager.start arg }
+          end
+        when 'stop'
+          if command_args.length < 1
+            manager.stop_all
+          else
+            manager.stop(command_args)
+          end
+        when 'restart'
+          if command_args.length < 1
+            manager.stop_all
+            manager.start_all
+          else
+            command_args.each { |arg| manager.stop arg }
+            command_args.each { |arg| manager.start arg }
+          end
+        when 'activate'
+          fail "No application given to activate a script for!" if command_args.length < 1
+          fail "No path given to activate!" if command_args.length < 2
+          manager.activate command_args[0], command_args[1], command_args.slice(2, command_args.length - 2)
+        when 'run'
+          # Provide the command line if provided
+          if command_args.length < 1
+            manager.run_all
+          else
+            manager.run command_args
+          end
+        # when 'run_app'
+        #   fail('No application name provided') if command_args.length == 0
+        #   manager.run_app command_args[0] #, command_args.slice(1, command_args.length - 1)
+        when 'set'
+          fail("No properties provided to set") if command_args.length < 1
+          if @options.application
+            manager.set_app_properties @options.application, command_args
+          else
+            manager.set_global_properties command_args
+          end
+        when 'unset'
+          fail("No properties provided to unset") if command_args.length < 1
+          if @options.application
+            manager.unset_app_properties @options.application, command_args
+          else
+            manager.unset_global_properties command_args
+          end
+        when 'clear'
+          if @options.application
+            manager.clear_app_properties @options.application
+          else
+            manager.clear_global_properties
+          end
+        when 'weave'
+          fail("No fabric provided to weave") if command_args.length < 1
+          if @options.application
+            manager.weave_for_application @options.application, command_args[0]
+          else
+            manager.weave_global command_args[0]
+          end
+        when 'unweave'
+          if @options.application
+            manager.unweave_for_application @options.application
+          else
+            manager.unweave_global
+          end
+        else
+          fail("Unrecognised command \"#{command}\"")
+      end
+    end
+    
+    def build_options
+      opts = OptionParser.new
+      opts.banner = "Usage: syrup [options] start [name] | stop [name] | run [<path> | name] | activate [name] <path> |\n" +
+                    "                       set <prop>=<value> | unset <prop> | clear | weave <fabric> | unweave"
+      opts.separator ""
+      opts.separator "Ruby options:"
+      opts.on('-d', '--debug', 'set debugging flags (set $DEBUG to true)') { $DEBUG = true }
+      opts.on("-I", "--include PATH", "specify $LOAD_PATH (may be used more than once)") { |path|
+        $LOAD_PATH.unshift(*path.split(":"))
+      }
+      opts.on("-r", "--require LIBRARY", "require the library, before executing your script") { |library|
+        require library
+      }
+      
+      opts.separator ""
+      opts.separator "Syrup options:"
+      opts.on('-p', '--path PATH', "Sets the base path for this syrup configuration. Defaults to ~/.syrup. See also the --local option to set this") { |value| 
+        @options.directory = value
+      }
+      opts.on('--local', "Sets the configuration base path to ./.syrup, allowing for a local configuration") {
+        @options.directory = File.expand_path('./.syrup')
+      }
+      opts.on('--application NAME', "Selects the application that should be updated. Defaults to global settings.") { |value|
+        @options.application = value
+      }
+      opts.on('--verbose', "Places Syrup in verbose mode.") {
+        @options.verbose = true
+      }
+      
+      opts.separator ""
+      opts.separator "Common options:"
+      opts.on_tail("-h", "--help", "Show this message") { puts opts; exit 0 }
+      opts.on_tail('-v', '--version', "Print the version and exit") { output_version; exit 0 }
+      
+      opts
+    end
+    
+    # Determines the command issued in the provided arguments
+    def determine_command(arguments)
+      command = nil
+      command_args = []
+      
+      # Work through each argument until we reach the command. Then, consume everything
+      # after it as arguments to the command
+      arguments.each do |arg|
+        if command.nil?
+          command = arg unless arg =~ /^-/
+        else
+          command_args << arg
+        end
+      end
+      
+      return command, command_args
+    end
+    
+    # Outputs the version
+    def output_version
+      puts "Syrup version #{Syrup::Application.version}"
+    end
+    
+    def fail(msg)
+      puts "ERROR: #{msg}"
+      puts @opts
+      exit
+    end
+  end
+  
+  class Logger
+    def error(msg)
+      puts "ERROR: #{msg}"
+    end
+    def warn(msg)
+      puts "WARN: #{msg}"
+    end
+    def info(msg)
+      puts "INFO: #{msg}"
+    end
+    def debug(msg)
+      puts "DEBUG: #{msg}"
+    end
+  end
+
+  # Module Singleton methods
+  class << self
+    def application
+      @application ||= Syrup::Application.new
+    end
+  end
+end

data/spec/syrup/config_store_spec.rb

@@ -0,0 +1,190 @@
+require 'syrup/config_store'
+require 'fileutils'
+
+describe Syrup::ConfigStore do
+  before :each do
+    # Ensure that we have a clear test data directory
+    @path = File.join(File.dirname(__FILE__), '..', '..', 'test-data')
+    FileUtils.rm_r @path if File.directory? @path
+    FileUtils.mkdir_p @path
+    
+    # Create the store
+    @store = Syrup::ConfigStore.new @path
+  end
+  
+  it "should return an empty list of applications when unconfigured" do
+    @store.applications.length.should == 0
+  end
+  
+  it "should create an application when requested" do
+    @store.create_application 'myapp'
+    @store.applications['myapp'].should_not be_nil
+  end
+  
+  it "should return the created application when one is created" do
+    @store.create_application('myapp').name.should == 'myapp'
+  end
+  
+  it "should return no properties on a new config" do
+    @store.create_application 'myapp'
+    @store.applications['myapp'].properties.length.should == 0
+  end
+  
+  it "should allow properties to be stored in a global context" do
+    @store.create_application 'myconfapp'
+    @store.properties['a']= 'b'
+    @store.properties['a'].should == 'b'
+  end
+  
+  it "should allow properties to be cleared for the global content" do
+    @store.create_application 'myconfapp'
+    @store.properties['a']= 'b'
+    @store.properties.clear
+    @store.properties.length.should == 0
+  end
+  
+  it "should allow properties to be deleted for the global context" do
+    @store.create_application 'myconfapp'
+    @store.properties['a']= 'b'
+    @store.properties['b']= 'c'
+    @store.properties.delete 'b'
+    @store.properties.length.should == 1
+    @store.properties['a'].should == 'b'
+  end
+  
+  it "should allow all properties to be deleted for the global context" do
+    @store.create_application 'myconfapp'
+    @store.properties['a']= 'b'
+    @store.properties['b']= 'c'
+    @store.properties.delete 'a'
+    @store.properties.delete 'b'
+    @store.properties.length.should == 0
+  end
+  
+  it "should return no properties on a new application" do
+    @store.create_application 'myapp'
+    @store.applications['myapp'].properties.length.should == 0
+  end
+  
+  it "should allow properties to be stored for an application" do
+    @store.create_application 'myconfapp'
+    @store.applications['myconfapp'].properties['a']= 'b'
+    @store.applications['myconfapp'].properties['a'].should == 'b'
+  end
+  
+  it "should allow properties to be cleared for an application" do
+    @store.create_application 'myconfapp'
+    @store.applications['myconfapp'].properties['a']= 'b'
+    @store.applications['myconfapp'].properties.clear
+    @store.applications['myconfapp'].properties.length.should == 0
+  end
+  
+  it "should allow properties to be deleted for an application" do
+    @store.create_application 'myconfapp'
+    @store.applications['myconfapp'].properties['a']= 'b'
+    @store.applications['myconfapp'].properties['b']= 'c'
+    @store.applications['myconfapp'].properties.delete 'b'
+    @store.applications['myconfapp'].properties.length.should == 1
+    @store.applications['myconfapp'].properties['a'].should == 'b'
+  end
+
+  it "should allow all properties to be deleted for an application" do
+    @store.create_application 'myconfapp'
+    @store.applications['myconfapp'].properties['a']= 'b'
+    @store.applications['myconfapp'].properties['b']= 'c'
+    @store.applications['myconfapp'].properties.delete 'a'
+    @store.applications['myconfapp'].properties.delete 'b'
+    @store.applications['myconfapp'].properties.length.should == 0
+  end
+  
+  it "should return a nil fabric by default" do
+    @store.fabric.should be_nil
+  end
+  
+  it "should store the fabric location when set" do
+    @store.fabric = '../myfabric'
+    Syrup::ConfigStore.new(@path).fabric.should == File.expand_path('../myfabric')
+  end
+  
+  it "should allow the fabric to be cleared" do
+    @store.fabric = '../myfabric'
+    @store.fabric = nil
+    Syrup::ConfigStore.new(@path).fabric.should be_nil
+  end
+
+  it "should return a nil fabric by default for applications" do
+    @store.create_application('myfabapp')
+    @store.applications['myfabapp'].fabric.should be_nil
+  end
+
+  it "should store the fabric location when set for applications" do
+    @store.create_application('myfabapp')
+    @store.applications['myfabapp'].fabric = '../myappfabric'
+    Syrup::ConfigStore.new(@path).applications['myfabapp'].fabric.should == File.expand_path('../myappfabric')
+  end
+
+  it "should allow the fabric to be cleared for application" do
+    @store.create_application('myfabapp')
+    @store.applications['myfabapp'].fabric = '../myappfabric'
+    @store.applications['myfabapp'].fabric = nil
+    Syrup::ConfigStore.new(@path).applications['myfabapp'].fabric.should be_nil
+  end
+
+  it "should return a nil application path by default for applications" do
+    @store.create_application('myfabapp')
+    @store.applications['myfabapp'].app.should be_nil
+  end
+
+  it "should store the application path when set for applications" do
+    @store.create_application('myfabapp')
+    @store.applications['myfabapp'].app = '../myapp.rb'
+    Syrup::ConfigStore.new(@path).applications['myfabapp'].app.should == File.expand_path('../myapp.rb')
+  end
+
+  it "should allow the application path to be cleared for application" do
+    @store.create_application('myfabapp')
+    @store.applications['myfabapp'].app = '../myapp.rb'
+    @store.applications['myfabapp'].app = nil
+    Syrup::ConfigStore.new(@path).applications['myfabapp'].app.should be_nil
+  end
+  
+  it "should return an empty list of start parameters for a new application" do
+    @store.create_application('mynpapp')
+    @store.applications['mynpapp'].start_parameters.should == []
+  end
+  
+  it "should allow start parameters to be stored for an application" do
+    @store.create_application('mypapp')
+    @store.applications['mypapp'].start_parameters = ['param1', 'param 2']
+    
+    Syrup::ConfigStore.new(@path).applications['mypapp'].start_parameters.should == ['param1', 'param 2']
+  end  
+  
+  it "should allow start parameters to be cleared for an application" do
+    @store.create_application('mycapp')
+    @store.applications['mycapp'].start_parameters = ['param1', 'param 2']
+    @store.applications['mycapp'].start_parameters = []
+    
+    Syrup::ConfigStore.new(@path).applications['mycapp'].start_parameters.should == []
+  end  
+  
+  it "should return a nil pid for a new application" do
+    @store.create_application('mypidapp')
+    @store.applications['mypidapp'].pid.should be_nil
+  end
+  
+  it "should allow start parameters to be stored for an application" do
+    @store.create_application('mypidapp')
+    @store.applications['mypidapp'].pid = 1234
+    
+    Syrup::ConfigStore.new(@path).applications['mypidapp'].pid.should == 1234
+  end  
+  
+  it "should allow the pid to be cleared for an application" do
+    @store.create_application('mypidapp')
+    @store.applications['mypidapp'].pid = 1234
+    @store.applications['mypidapp'].pid = nil
+    
+    Syrup::ConfigStore.new(@path).applications['mypidapp'].pid.should be_nil
+  end
+end