symphony 0.3.0.pre20140327204419

data/lib/symphony/tasks/ssh.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+require 'shellwords'
+require 'symphony/task' unless defined?( Symphony::Task )
+
+
+### A base SSH class for connecting to remote hosts, running commands,
+### and collecting output.
+class Symphony::Task::SSH < Symphony::Task
+	extend MethodUtilities
+
+	### Create a new SSH task for the given +job+ and +queue+.
+	def initialize( queue, job )
+		super
+
+		# The default path to the ssh binary.
+		@path = self.options[:ssh_path] || '/usr/bin/ssh'
+
+		# Default ssh behavior arguments.
+		@ssh_args = self.options[:ssh_args] || [
+			'-e', 'none',
+			'-T',
+			'-x',
+			'-q',
+			'-o', 'CheckHostIP=no',
+			'-o', 'BatchMode=yes',
+			'-o', 'StrictHostKeyChecking=no'
+		]
+
+		# required arguments
+		@hostname = self.options[:hostname] or raise ArgumentError, "no hostname specified"
+		@command  = self.options[:command]  or raise ArgumentError, "no command specified"
+
+		# optional arguments
+		@port = self.options[:port] || 22
+		@user = self.options[:user] || 'root'
+		@key  = self.options[:key]
+
+		@output = nil
+		@return_value = nil
+	end
+
+	# The default path to the ssh binary.
+	attr_reader :path
+
+	# Default ssh behavior arguments.
+	attr_reader :ssh_args
+
+	# The hostname to connect to.
+	attr_reader :hostname
+
+	# The command to run on the remote host.
+	attr_reader :command
+
+	# The key to use for authentication.
+	attr_reader :key
+
+	# The remote ssh port.
+	attr_reader :port
+
+	# Connect to the remote host as this user. Defaults to 'root'.
+	attr_reader :user
+
+
+	### Call ssh and capture output.
+	def run
+		@return_value = self.open_connection do |reader, writer|
+			self.log.debug "Writing command #{self.command}..."
+			writer.puts( self.command )
+			self.log.debug "  closing child's writer."
+			writer.close
+			self.log.debug "  reading from child."
+			reader.read
+		end
+	end
+
+
+	### Emit the output from the remote ssh call
+	def on_completion
+		if @return_value
+			self.log.info "Remote exited with %d, output: %s" % [ @return_value.exitstatus, @output ]
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Call ssh and yield the remote IO objects to the caller,
+	### cleaning up afterwards.
+	def open_connection
+		raise LocalJumpError, "no block given" unless block_given?
+
+		fqdn = self.expand_hostname( self.hostname ).
+			find {|hostname| self.ping(hostname, self.port) } or
+			raise "Unable to find an on-network host for %s:%d" % [ self.hostname, self.port ]
+
+		cmd = []
+		cmd << self.path
+		cmd += self.ssh_args
+		cmd << '-p' << self.port.to_s
+		cmd << '-i' << self.key if self.key
+		cmd << '-l' << self.user
+		cmd << fqdn
+		cmd.flatten!
+		self.log.debug "Running SSH command with: %p" % [ Shellwords.shelljoin(cmd) ]
+
+		parent_reader, child_writer = IO.pipe
+		child_reader, parent_writer = IO.pipe
+
+		pid = spawn( *cmd, :out => child_writer, :in => child_reader, :close_others => true )
+		child_writer.close
+		child_reader.close
+
+		self.log.debug "Yielding back to the run block."
+		@output = yield( parent_reader, parent_writer )
+		self.log.debug "  run block done."
+
+		pid, status = Process.waitpid2( pid )
+		return status
+	end
+
+
+end # class Symphony::Task::SSH
+

data/lib/symphony/tasks/sshscript.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+require 'net/ssh'
+require 'net/sftp'
+require 'tmpdir'
+require 'inversion'
+require 'symphony/task' unless defined?( Symphony::Task )
+
+
+# A task to execute a script on a remote host via SSH.
+class Symphony::Task::SSHScript < Symphony::Task
+	extend Loggability,
+	       MethodUtilities
+
+	# Loggability API -- Log to symphony's logger
+	log_to :symphony
+
+
+	# Template config
+	TEMPLATE_OPTS = {
+		:ignore_unknown_tags => false,
+		:on_render_error     => :propagate,
+		:strip_tag_lines     => true
+	}
+
+	# The defaults to use when connecting via SSH
+	DEFAULT_SSH_OPTIONS = {
+		:auth_methods            => [ "publickey" ],
+		:compression             => true,
+		:config                  => false,
+		:keys_only               => true,
+		# :logger                  => Loggability[ Net::SSH ],
+		:paranoid                => false,
+		:timeout                 => 10.seconds,
+		# :verbose                 => :debug,
+		:global_known_hosts_file => '/dev/null',
+		:user_known_hosts_file   => '/dev/null',
+	}
+
+
+	### Create a new SSH task for the given +job+ and +queue+.
+	def initialize( queue, job )
+		super
+
+		# required arguments
+		@hostname   = self.options[:hostname] or raise ArgumentError, "no hostname specified"
+		@template   = self.options[:template] or raise ArgumentError, "no script template specified"
+		@key        = self.options[:key]      or raise ArgumentError, "no private key specified"
+
+		# optional arguments
+		@port       = self.options[:port] || 22
+		@user       = self.options[:user] || 'root'
+		@attributes = self.options[:attributes] || {}
+		@nocleanup  = self.options[:nocleanup] ? true : false
+	end
+
+
+	######
+	public
+	######
+
+	# The name of the host to connect to
+	attr_reader :hostname
+
+	# The path to the script template
+	attr_accessor :template
+
+	# The path to the SSH key to use for auth
+	attr_reader :key
+
+	# The SSH port to use
+	attr_reader :port
+
+	# The user to connect as
+	attr_reader :user
+
+	# Attributes that will be set on the script template.
+	attr_reader :attributes
+
+	# Flag that will cause the uploaded script to not be cleaned up after running. Useful for
+	# diagnostics.
+	attr_reader :nocleanup
+
+
+	### Load the script as an Inversion template, sending and executing
+	### it on the remote host.
+	def run
+		fqdn = self.expand_hostname( self.hostname ).
+			find {|hostname| self.ping(hostname, self.port) }
+
+		unless fqdn
+			self.log.debug "Unable to find an on-network host for %s:%d" %
+				[ self.hostname, self.port ]
+			return
+		end
+
+		remote_filename = self.make_remote_filename
+		source = self.generate_script
+
+		# Establish the SSH connection
+		ssh_options = DEFAULT_SSH_OPTIONS.merge( :port => self.port, :keys => [self.key] )
+		self.with_timeout do
+			Net::SSH.start( fqdn, self.user, ssh_options ) do |conn|
+				self.upload_script( conn, source, remote_filename )
+				self.run_script( conn, remote_filename )
+			end
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Return a human-readable description of details of the task.
+	def description
+		return "Running script '%s' on '%s:%d' as '%s'" % [
+			File.basename( self.template ),
+			self.hostname,
+			self.port,
+			self.user,
+		]
+	end
+
+
+	### Generate a unique filename for the script on the remote host.
+	def make_remote_filename
+		template = self.template
+		basename = File.basename( template, File.extname(template) )
+
+		tmpname = Dir::Tmpname.make_tmpname( basename, Process.pid )
+
+		return "/tmp/#{tmpname}"
+	end
+
+
+	### Generate a script by loading the script template, populating it with
+	### attributes, and rendering it.
+	def generate_script
+		tmpl = Inversion::Template.load( self.template, TEMPLATE_OPTS )
+
+		tmpl.attributes.merge!( self.attributes )
+		tmpl.task   = self
+
+		return tmpl.render
+	end
+
+	### Render the given +template+ as script source, then use the specified +conn+ object
+	### to upload it.
+	def upload_script( conn, source, remote_filename )
+		self.log.debug "Uploading script (%d bytes) to %s:%s." %
+			[ source.bytesize, self.hostname, remote_filename ]
+		conn.sftp.file.open( remote_filename, "w", 0755 ) do |fh|
+			fh.print( source )
+		end
+		self.log.debug "  done with the upload."
+	end
+
+
+	### Run the script on the remote host.
+	def run_script( conn, remote_filename )
+		output = conn.exec!( remote_filename )
+		self.log.debug "Output was:\n#{output}"
+		conn.exec!( "rm #{remote_filename}" ) unless self.nocleanup
+	end
+
+end # class Symphony::Task::SSHScript
+

data/lib/symphony.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'loggability'
+require 'configurability'
+
+# Symphony -- an evented asynchronous thingie.
+#
+# See the README for additional guidance.
+#
+module Symphony
+	extend Loggability,
+	       Configurability
+
+	# Library version constant
+	VERSION = '0.3.0'
+
+	# Version-control revision constant
+	REVISION = %q$Revision$
+
+
+	# The name of the environment variable to check for config file overrides
+	CONFIG_ENV = 'GROUNDCONTROL_CONFIG'
+
+	# The path to the default config file
+	DEFAULT_CONFIG_FILE = 'etc/config.yml'
+
+
+	# Loggability API -- set up symphony's logger
+	log_as :symphony
+
+
+	### Get the loaded config (a Configurability::Config object)
+	def self::config
+		Configurability.loaded_config
+	end
+
+
+	### Load the specified +config_file+, install the config in all objects with
+	### Configurability, and call any callbacks registered via #after_configure.
+	def self::load_config( config_file=nil, defaults=nil )
+		config_file ||= ENV[ CONFIG_ENV ] || DEFAULT_CONFIG_FILE
+		defaults    ||= Configurability.gather_defaults
+
+		self.log.info "Loading config from %p with defaults for sections: %p." %
+			[ config_file, defaults.keys ]
+		config = Configurability::Config.load( config_file, defaults )
+		config.install
+	end
+
+
+	require 'symphony/mixins'
+	require 'symphony/queue'
+	require 'symphony/task'
+
+end # module Symphony
+

data/spec/helpers.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+# SimpleCov test coverage reporting; enable this using the :coverage rake task
+require 'simplecov' if ENV['COVERAGE']
+
+require 'loggability'
+require 'loggability/spechelpers'
+require 'configurability'
+require 'configurability/behavior'
+
+require 'rspec'
+
+Loggability.format_with( :color ) if $stdout.tty?
+
+
+### RSpec helper functions.
+module Loggability::SpecHelpers
+end
+
+
+### Mock with RSpec
+RSpec.configure do |config|
+	config.run_all_when_everything_filtered = true
+	config.filter_run :focus
+	config.order = 'random'
+	config.expect_with( :rspec )
+	config.mock_with( :rspec ) do |mock|
+		mock.syntax = :expect
+	end
+
+	config.include( Loggability::SpecHelpers )
+end
+
+# vim: set nosta noet ts=4 sw=4:
+

data/spec/symphony/mixins_spec.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env rspec -wfd
+
+require_relative '../helpers'
+
+require 'symphony/mixins'
+
+
+describe Symphony, 'mixins' do
+
+	describe Symphony::MethodUtilities, 'used to extend a class' do
+
+		let!( :extended_class ) do
+			klass = Class.new
+			klass.extend( Symphony::MethodUtilities )
+			klass
+		end
+
+		it "can declare a class-level attribute reader" do
+			extended_class.singleton_attr_reader :foo
+			expect( extended_class ).to respond_to( :foo )
+			expect( extended_class ).to_not respond_to( :foo= )
+			expect( extended_class ).to_not respond_to( :foo? )
+		end
+
+		it "can declare a class-level attribute writer" do
+			extended_class.singleton_attr_writer :foo
+			expect( extended_class ).to_not respond_to( :foo )
+			expect( extended_class ).to respond_to( :foo= )
+			expect( extended_class ).to_not respond_to( :foo? )
+		end
+
+		it "can declare a class-level attribute reader and writer" do
+			extended_class.singleton_attr_accessor :foo
+			expect( extended_class ).to respond_to( :foo )
+			expect( extended_class ).to respond_to( :foo= )
+			expect( extended_class ).to_not respond_to( :foo? )
+		end
+
+		it "can declare a class-level alias" do
+			def extended_class.foo
+				return "foo"
+			end
+			extended_class.singleton_method_alias( :bar, :foo )
+
+			expect( extended_class.bar ).to eq( 'foo' )
+		end
+
+		it "can declare an instance attribute predicate method" do
+			extended_class.attr_predicate :foo
+			instance = extended_class.new
+
+			expect( instance ).to_not respond_to( :foo )
+			expect( instance ).to_not respond_to( :foo= )
+			expect( instance ).to respond_to( :foo? )
+
+			expect( instance.foo? ).to eq( false )
+
+			instance.instance_variable_set( :@foo, 1 )
+			expect( instance.foo? ).to eq( true )
+		end
+
+		it "can declare an instance attribute predicate and writer" do
+			extended_class.attr_predicate_accessor :foo
+			instance = extended_class.new
+
+			expect( instance ).to_not respond_to( :foo )
+			expect( instance ).to respond_to( :foo= )
+			expect( instance ).to respond_to( :foo? )
+
+			expect( instance.foo? ).to eq( false )
+
+			instance.foo = 1
+			expect( instance.foo? ).to eq( true )
+		end
+
+	end
+
+end