circus-deployment 0.0.1

data/LICENSE

@@ -0,0 +1,23 @@
+## Software License
+> Copyright (c) 2009-2010 Paul Jones <pauljones23@gmail.com>
+> Copyright (c) 2009-2010 LShift Ltd. <query@lshift.net>
+> 
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use, copy,
+> modify, merge, publish, distribute, sublicense, and/or sell copies
+> of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+> DEALINGS IN THE SOFTWARE.

data/bin/circus

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# Circus command line interface script.
+# Run <tt>circus -h</tt> to get more usage.
+
+# If we can see a Gemfile, then we're in dev and should use it
+if File.exists?(File.expand_path('../../Gemfile', __FILE__))
+  ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+  begin
+    # Try to require the preresolved locked set of gems.
+    require File.expand_path('../../.bundle/environment', __FILE__)
+  rescue LoadError
+    # Fall back on doing an unlocked resolve at runtime.
+    require "rubygems"
+    require "bundler"
+    Bundler.setup
+  end
+end
+
+$: << File.expand_path('../../lib', __FILE__)
+$: << File.expand_path('../../vendor/ruby-dbus/lib', __FILE__)
+require File.expand_path('../../lib/circus', __FILE__)
+require File.expand_path('../../lib/circus/cli', __FILE__)
+
+Circus::CLI.start

data/lib/bundler/circus_bundler.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# Circus specific entry-point for bundler that handles the packaging of gems for an application.
+require 'rubygems'
+require 'bundler'
+require 'bundler/cli'
+require File.expand_path('../patches', __FILE__)
+require File.expand_path('../circus_util', __FILE__)
+
+class LoggingShell
+  def say(msg)
+    puts msg
+  end
+end
+
+# Run the bundler install
+dir = File.expand_path('.')
+ENV['BUNDLE_GEMFILE'] = File.join(dir, 'Gemfile')
+Bundler.settings[:path] = 'vendor'
+Bundler.ui = Bundler::UI::Shell.new(LoggingShell.new)
+Gem::DefaultUserInteraction.ui = Bundler::UI::RGProxy.new(Bundler.ui)
+Bundler::Installer.install(Bundler.root, Bundler.definition, {})
+
+Bundler::CircusUtil.fix_external_paths(dir)

data/lib/bundler/circus_util.rb

@@ -0,0 +1,43 @@
+require 'bundler'
+
+module Bundler
+  class CircusUtil
+    def self.fix_external_paths(dir)
+      ENV['BUNDLE_GEMFILE'] = File.join(dir, 'Gemfile')
+      
+      # Correct any path based components in the Gemfile
+      full_dir = File.expand_path(dir)
+      gem_cache_dir = File.join(dir, 'vendor', 'gems')
+      definition = Bundler.definition
+      required_updates = []
+      definition.sources.select { |s| s.is_a? Bundler::Source::Path }.each do |p|
+        unless p.path.to_s.start_with? full_dir
+          FileUtils.mkdir_p(gem_cache_dir)
+          FileUtils.cp_r(p.path, File.join(gem_cache_dir, p.path.basename.to_s))
+         
+          if p.is_a? Bundler::Source::Git
+            required_updates << {:old => /git .*#{p.uri}.*/, :new => "path \"vendor/gems/#{p.path.basename.to_s}\""}
+          else
+            required_updates << {:old => p.options['path'], :new => "vendor/gems/#{p.path.basename.to_s}"}
+          end
+        end
+      end
+      if required_updates.length > 0
+        FileUtils.cp "#{dir}/Gemfile", "#{dir}/Gemfile.circus_orig"
+        gf_content = File.read("#{dir}/Gemfile")
+        required_updates.each do |u|
+          gf_content.gsub!(u[:old], u[:new])
+        end
+        File.open("#{dir}/Gemfile", 'w') do |f|
+          f.write(gf_content)
+        end
+      end
+    end
+    
+    def self.unfix_external_paths(dir)
+      if File.exists? "#{dir}/Gemfile.circus_orig"
+        FileUtils.mv "#{dir}/Gemfile.circus_orig", "#{dir}/Gemfile"
+      end
+    end
+  end
+end

data/lib/bundler/patches.rb

@@ -0,0 +1,18 @@
+#module Bundler
+#  class Environment
+    #def write_rb_lock
+      # Disabled
+    #end
+#  end
+#end
+
+module Bundler
+  module Source
+    # Disable the use of System Gems
+    class SystemGems
+      def specs
+        []
+      end
+    end
+  end
+end

data/lib/circus/act.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+require 'yaml'
+
+module Circus
+  class Act
+    attr_reader :name, :dir, :props, :profile
+    
+    def initialize(name, dir, props = {})
+      @name = name
+      @dir = dir
+      @props = props
+      
+      # Merge act specific properties
+      if File.exists? act_file
+        act_cfg = YAML.load(File.read(act_file))
+        @props.merge! act_cfg
+      end
+    end
+    
+    def should_package?
+      return false if @props['no-package']
+      true
+    end
+    
+    def detect!
+      # Run each profile against the directory to try to find one that matches
+      profile_clazz = Circus::Profiles::PROFILES.find { |p| p.accepts?(@name, @dir, @props) }
+      raise "No profile can run #{@dir}" unless profile_clazz
+      
+      @profile = profile_clazz.new(@name, @dir, @props)
+    end
+    
+    def package_for_dev(logger, run_root_dir)
+      detect! unless @profile
+      
+      # Create our run directory, and tell the profile to package into it
+      run_dir = File.join(run_root_dir, @name)
+      FileUtils.mkdir_p run_dir
+      profile.package_for_dev(logger, run_dir)
+    end
+    
+    def assemble(logger, output_root_dir, overlay_root)
+      detect! unless @profile
+      
+      overlay_dir = File.join(overlay_root, name)
+      FileUtils.mkdir_p(overlay_dir)
+      return false unless profile.package_for_deploy(logger, overlay_dir)
+      
+      begin
+        # Squash the output file
+        include_dirs = ["#{overlay_dir}/*"]
+        include_dirs << "#{@dir}/*" if profile.package_base_dir?
+        include_dirs.concat(profile.extra_dirs)
+        output_name = File.join(output_root_dir, "#{name}.act")
+      
+        ExternalUtil.run_external(logger, 'Output packaging', 
+          "mksquashfs #{include_dirs.join(' ')} #{output_name} -noappend -noI -noD -noF 2>&1")
+      ensure
+        profile.cleanup_after_deploy(logger, overlay_dir)
+      end
+    end
+    
+    def upload(output_root_dir, act_store)
+      detect! unless @profile
+
+      output_name = File.join(output_root_dir, "#{name}.act")
+      act_store.upload_act(output_name)
+    end
+    
+    def act_file
+      File.join(@dir, 'act.yaml')
+    end
+  end
+end

data/lib/circus/actstore_client.rb

@@ -0,0 +1,30 @@
+module Circus
+  class ActStoreClient
+    def initialize(root, logger)
+      @root = root
+      @logger = logger
+    end
+    
+    def upload_act(fn)
+      actname = File.basename(fn)
+      upload_url = "#{@root}/#{actname}"
+      
+      @logger.info "Uploading to #{upload_url}"
+      uri = URI.parse(upload_url)
+      
+      res = Net::HTTP.start(uri.host, uri.port) do |http|
+        req = Net::HTTP::Put.new(uri.request_uri)
+        req.body = File.read(fn)
+        req.content_type = 'application/binary'
+        
+        http.request req
+      end
+      unless res.is_a? Net::HTTPSuccess
+        @logger.error "FAILED: Act Upload"
+        @logger.error "  Status:   #{res.code}"
+        @logger.error "  Response: #{res.body}"
+        return false
+      end
+    end
+  end
+end

data/lib/circus/agents/agent.rb

@@ -0,0 +1,59 @@
+require 'blather/client/dsl'
+require 'circus/agents/params'
+require 'circus/agents/logger'
+require 'circus/agents/connection'
+
+module Circus
+  module Agents
+    class Agent
+      include Blather::DSL
+    
+      class <<self
+        def commands
+          @commands ||= []
+        end
+      
+        def command(name, &body)
+          commands << name
+        
+          define_method("command_#{name}", &body)
+        end
+      end
+    
+      def initialize(connection = nil)
+        @client = (connection || Connection.new)
+      
+        # Approve all subscription requests
+        subscription :request? do |s|
+          write_to_stream s.approve!
+        end
+      
+        # Add a handler for each chat command
+        self.class.commands.each do |name|
+          message :chat?, :body => /^#{name}( .*)?$/ do |m|
+            # begin
+              params = CommandParams.new(m.body[(name.length + 1)..-1])
+              logger = XMPPLogger.new(m.from, m.thread || m.id, lambda { |msg| write_to_stream(msg) })
+          
+              send("command_#{name}", params, logger)
+            # rescue
+              # puts $!, $@
+            # end
+          end
+        end
+      
+        disconnected do
+          puts "Disconnected"
+        end
+      end
+    
+      def configure!(config)
+        client.configure!(config)
+      end
+    
+      def run
+        client.run
+      end
+    end
+  end
+end

data/lib/circus/agents/client.rb

@@ -0,0 +1,77 @@
+require 'circus/agents/encoding'
+require 'monitor'
+
+module Circus
+  module Agents
+    # Client for XMPP based agents.
+    class Client
+      def initialize(connection)
+        @connection = connection
+      end
+    
+      def call(to, name, params = {}, &block)
+        body = if params.length > 0
+            "#{name} #{Encoding.encode(params)}"
+          else
+            name
+          end
+        msg = Blather::Stanza::Message.new to, body
+        msg.id = Blather::Stanza.next_id
+        msg.thread = msg.id
+        
+        promise = Promise.new
+        last = nil
+        @connection.register_thread_handler(msg.thread) do |m|
+          block.call(m)
+
+          begin
+            if Conversation.ended? m
+              result = nil
+              if last and last.body and last.body.start_with? 'ok '
+                result = Encoding.decode(last.body[('ok '.length)..-1])
+              end
+            
+              promise.completed!(result)
+            else
+              last = m
+            end
+          rescue
+            puts $!, $@
+          end
+        end
+        @connection.write(msg)
+      
+        promise
+      end
+    end
+  
+    # A promise provides a reference to an expected future result. Client calls
+    # return immediately upon message dispatch - in order to retrieve the final
+    # result, the promise can be inspected.
+    class Promise
+      def initialize
+        @monitor = Monitor.new
+        @cond = @monitor.new_cond
+        @completed = false
+        @result = nil
+      end
+      
+      def completed!(result)
+        @monitor.synchronize do
+          @completed = true
+          @result = result
+          @cond.signal
+        end
+      end
+      
+      def result
+        @monitor.synchronize do
+          return @result if @completed
+          
+          @cond.wait
+          @result
+        end
+      end
+    end
+  end
+end

data/lib/circus/agents/connection.rb

@@ -0,0 +1,76 @@
+require 'blather/client/client'
+require 'circus/agents/conversation'
+require 'monitor'
+
+module Circus
+  module Agents
+    class Connection < Blather::Client
+      attr_reader :thread_handlers
+    
+      def initialize
+        super
+      
+        @ready_mon = Monitor.new
+        @ready_cond = @ready_mon.new_cond
+        @thread_handlers = {}
+        register_handler :message do |m|
+          process_chat_thread(m)
+        end
+        register_handler :disconnected do
+          puts "Disconnected!"
+        end
+        register_handler :ready do
+          @ready_mon.synchronize {
+            @ready_cond.signal
+          }
+        end
+      end
+    
+      def configure!(config)
+        args = [config.jid, config.password]
+        if config.host
+          args << config.host
+          args << config.port if config.port
+        end 
+      
+        setup *args
+      end
+      
+      def configure_bg!(config)
+        configure!(config)
+        
+        Thread.new {
+          EM.run { 
+            begin
+              run
+            rescue
+              puts $!, $@
+            end
+          }
+        }
+        @ready_mon.synchronize {
+          @ready_cond.wait(2)
+        }
+      end
+    
+      def register_thread_handler(thread_id, &block)
+        thread_handlers[thread_id] = block
+      end
+    
+      def remove_thread_handler(thread_id)
+        thread_handlers.delete(thread_id)
+      end
+    
+      private
+        def process_chat_thread(m)
+          return false unless m.thread and thread_handlers[m.thread]
+        
+          handler = thread_handlers[m.thread]
+          remove_thread_handler(m.thread) if Conversation.ended? m
+        
+          handler.call(m)
+          true
+        end
+    end
+  end
+end

data/lib/circus/agents/conversation.rb

@@ -0,0 +1,17 @@
+module Circus
+  module Agents
+    class Conversation
+      CHAT_STATES = 'http://jabber.org/protocol/chatstates'
+    
+      def self.end(m)
+        gone_el = Nokogiri::XML::Element.new('gone', m.document)
+        gone_el.default_namespace = CHAT_STATES
+        m << gone_el
+      end
+    
+      def self.ended?(m)
+        m.xpath('ns:gone', 'ns' => CHAT_STATES).length > 0
+      end
+    end
+  end
+end

data/lib/circus/agents/dbus_connection.rb

@@ -0,0 +1,85 @@
+require 'dbus'
+require 'uuid'
+
+module Circus
+  module Agents
+    class DBusConnection
+      def initialize(bus = nil)
+        @bus = bus || DBus::SystemBus.instance
+      end
+      
+      def configure_bg!(options = {})
+        Thread.new do
+          l = DBus::Main.new
+          l << @bus
+          l.run
+        end 
+      end
+      
+      def call(target, object, iface, method, args, logger)
+        action_id = UUID.generate
+        
+        @service = @bus.service("com.deployacircus.#{object}")
+        obj = @service.object("/com/deployacircus/#{object}")
+        obj.introspect
+        obj_iface = obj["com.deployacircus.#{iface}"]
+        dbus_method = obj_iface.methods[method]
+        raise ArgumentError.new("Method #{method} on #{object} not found") unless dbus_method
+        
+        msg = DBus::Message.new(DBus::Message::METHOD_CALL)
+        msg.path = obj.path
+        msg.interface = obj_iface.name
+        msg.destination = obj.destination
+        msg.member = dbus_method.name
+        msg.sender = @bus.unique_name
+        dbus_method.params.each do |p|
+          if p.name == 'id'
+            msg.add_param p.type, action_id
+          else
+            msg.add_param(p.type, args[p.name])
+          end
+        end
+        promise = DBusPromise.new(@bus)
+        @bus.on_return(msg) do |rmsg|
+          promise.completed!(rmsg)
+        end
+        obj_iface.on_signal(@bus, 'LogEntry') do |log_action_id, msg|
+          logger.info(msg) if action_id == log_action_id
+        end
+        @bus.send(msg.marshall)
+        
+        promise
+      end
+      
+      def send_file(fn)
+        # Normal DBus connections can see the file locally just fine, so we don't need to
+        # do anything with it.
+        fn
+      end
+    end
+    
+    class DBusPromise
+      def initialize(bus)
+        @bus = bus
+        @l = DBus::Main.new
+        @l << @bus
+        @result = nil
+      end
+      
+      def result
+        @l.run
+        
+        if @result.is_a? DBus::Error
+          raise @result
+        else
+          @result.params[0]
+        end
+      end
+      
+      def completed!(result)
+        @result = result
+        @l.quit
+      end
+    end
+  end
+end

data/lib/circus/agents/dbus_logger.rb

@@ -0,0 +1,34 @@
+module Circus
+  module Agents
+    class DBusLogger
+      def initialize(adapter, action_id)
+        @adapter = adapter
+        @action_id = action_id
+      end
+  
+      def info(content)
+        write(content)
+      end
+
+      def error(content)
+        write("ERROR: #{content}")
+      end
+
+      def failed(msg)
+        write("failed #{msg}")
+      end
+
+      def complete(res = nil)
+        if res
+          write("ok #{Encoding.encode(res)}") 
+        else
+          write('ok')
+        end
+      end
+  
+      def write(msg)
+        @adapter.LogEntry(@action_id, msg)
+      end
+    end
+  end
+end

data/lib/circus/agents/encoding.rb

@@ -0,0 +1,32 @@
+require 'cgi'
+
+module Circus
+  module Agents
+    class Encoding
+      def self.encode(params, sep = '&')
+        params.map do |k,v|
+          if v.is_a? Array
+            v.map do |iv|
+              "#{CGI.escape(k.to_s)}=#{CGI.escape(iv.to_s)}"
+            end.join(sep)
+          else
+            "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+          end
+        end.join(sep)
+      end
+    
+      def self.decode(str)
+        parsed = CGI::parse(str)
+        result = {}
+        parsed.each do |k, v|
+          if v.length == 1
+            result[k] = v.first
+          else
+            result[k] = v
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/circus/agents/logger.rb

@@ -0,0 +1,52 @@
+require 'circus/agents/encoding'
+require 'circus/agents/conversation'
+
+module Circus
+  module Agents
+    class XMPPLogger
+      def initialize(to, thread, writer)
+        @to = to
+        @thread = thread || "thread#{Blather::Stanza.next_id}"
+        @writer = writer
+      end
+    
+      def info(content)
+        write("#{content}")
+      end
+    
+    
+      def error(content)
+        write("ERROR: #{content}")
+      end
+
+      def failed(msg)
+        write("failed #{msg}")
+        gone
+      end
+    
+      def complete(res = nil)
+        if res
+          write("ok #{Encoding.encode(res)}") 
+        else
+          write('ok')
+        end
+        gone
+      end
+    
+      private
+        def write(content)
+          msg = Blather::Stanza::Message.new @to, content
+          msg.thread = @thread
+          @writer.call(msg)
+        end
+      
+        def gone
+          msg = Blather::Stanza::Message.new @to, nil
+          msg.thread = @thread
+      
+          Conversation.end(msg)
+          @writer.call(msg)
+        end
+    end
+  end
+end