ratchet 0.3.0

data/lib/ratchet/configuration.rb

@@ -0,0 +1,278 @@
+=begin
+	This file is part of the Ratchet project, a client for Icecap.
+    Copyright (C) 2005-6  Andrew Thompson
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+=end
+
+#### configuration.rb ####
+# This file contains the Connection class, a class that contains ratchet's
+# config, it provides default values (loaded from a yaml file), it also
+# tracks changes and allows reversion to defaults. Additionally it encodes/decodes
+# data for storage in icecap's config storage.
+####
+
+module Ratchet
+	class Configuration
+		attr_reader :values, :defaults
+		def initialize
+			#set some defaults... probably too soon be overriden by the user's config, but you gotta start somewhere :P
+			p = Pathname.new(__FILE__)
+			@values = YAML.load_file(DATADIR+'/defaults.yaml')
+			
+			#store defaults
+			@defaults = duplicate_config
+			
+			@statuscolors = [@values['defaultcolor'], @values['neweventcolor'], @values['newmessagecolor'], @values['highlightcolor']]
+	
+			@oldvalues = {}
+		end
+		
+		def dump
+			File.open(DATADIR+'/defaults.yaml', "w+") {|f| YAML.dump(@values, f)}
+		end
+	
+		def gettabmodelconfig
+	
+			if @values['tabsort'] == 'case sensitive'
+				sort = SENSITIVE
+			elsif @values['tabsort'] == 'case sensitive no hash'
+				sort = INSENSITIVE_NOHASH
+			elsif @values['tabsort'] == 'case sensitive no hash'
+				sort = SENSITIVE_NOHASH
+			else
+				sort = INSENSITIVE
+			end
+	
+			if @values['tabstructure'] == 'flat'
+				structure = FLAT
+			else
+				structure = HIERARCHICAL
+			end
+	
+			return [structure, sort]
+		end
+	
+		#converts status into a color
+		def getstatuscolor(status)
+			if status.nil?
+				return @statuscolors[0]
+			end
+			return @statuscolors[status]
+		end
+	
+		#retrieves a value
+		def [](value)
+			if @values[value]
+				return @values[value]
+			else
+				return false
+			end
+		end
+	
+		def []=(key, value)
+			value = decode_value(value) if value.class == String
+			@values[key] = value
+			#update the color array on the off-chance we changed it :(
+			@statuscolors = [@values['defaultcolor'], @values['neweventcolor'], @values['newmessagecolor'], @values['highlightcolor']]
+		end
+	
+		#send the config to irssi2
+		def changes
+			cmdstring = ''
+	
+			configs = []
+	
+			@values.each do |k, v|
+				value = encode_value(v)
+				if @oldvalues[k] != value or  !@oldvalues[k]
+					key = 'rirc_'+k unless k['rirc_']
+	
+					configs.push(key+'='+escape(value)) if k and value
+					puts k+" HAS changed"
+					puts v.inspect
+				else
+				end
+			end
+	
+			if configs.length == 0
+				puts 'no changes'
+				return
+			else
+				cmdstring = 'config set;'+configs.join(';')
+			end
+			
+			cmdstring
+			#$main.send_command('sendconfig', cmdstring)
+		end
+	
+		#request the config from irssi2
+		#~ def get_config
+			#~ $main.send_command('getconfig', 'config get;*')
+			#~ while $main.replies['getconfig']
+				#~ sleep 1
+			#~ end
+		#~ end
+	
+		#encode the values so they can be stored by irssi2
+		#this function recursively encodes arrays in hashes to handle n dimensional structures
+		def encode_value(value)
+			if value.class == Color
+				colors = value.to_a[0..2]
+				'color{' + colors.map {|color| "#{color}" }.join(":")+'}'
+			elsif value.class == Array
+				'array{' + value.map {|v| encode_value(v)}.join(":")+'}'
+			elsif value.class == Hash
+				'hash{' + value.map {|k, v| encode_value(k) + ':' + encode_value(v) }.join("::")+'}'
+			elsif value =~ /^(color|array|hash)\:(\d+)\:(\d+)\:(\d+)$/
+				return value
+			elsif value.nil? #we don't want nil being encoded to "", this fux0rs arrays...
+				return 'nil'
+			elsif value.respond_to? :to_s #everythign else gets converted to a string
+				return value.to_s.gsub(':', '\,')
+			else #if we can't convert it to a string, don't store it
+				return nil
+			end
+		end
+	
+		#decode values retrieved from irssi2
+		#recursively decodes arrays and hashes, gets a bit hairy though...
+		def decode_value(value)
+			value = unescape(value) if value
+			if value == 'true'
+				return true
+			elsif value == 'false'
+				return false
+			elsif value == 'nil'
+				return nil
+			else
+				if value.nil?
+					return nil
+				end
+				values = value.split('{', 2)
+				values[1].chomp!('}') if values[1]
+				if values[0] == 'array'
+					x = []
+					#~ values[1].split(':').each do |v|
+						#~ if v =~ /^(array|hash|color)\{/
+							#~ puts v
+						#~ end
+						#~ x.push(decode_value(v))
+					#~ end
+					string = values[1]
+					while string
+						#check if the next part of the source string is an object
+						if string =~ /^((?:array|hash|color)\{.+?\}(?:\:|$))/
+							match = $1
+							#trim the trailing : and decode it and then push it onto the array
+							x.push(decode_value($1.chomp(':')))
+							#remove the match from the source string and skip to the next loop iteration
+							string.slice!(match)
+							next
+						end
+						part, string = string.split(':', 2)
+						x.push(decode_value(part)) if part
+					end
+					x
+				elsif values[0] == 'hash'
+					x = {}
+					#~ values[1].split('::').each do |y|
+						#~ k, v = y.split(':')
+						#~ x[decode_value(k)] = decode_value(v)
+					#~ end
+					string = values[1]
+					while string
+						#check for an object
+						if string =~ /^((?:array|hash|color)\{.+?\}.+?(?:\:\:|\}$))/
+							#store the match in a variable so it doesn't get clobbered later on
+							match = $1
+							#heh, trim the trailing :: and split by the last :
+							key, value = $1.chomp('::').reverse.split(':', 2).map{|y| y.reverse}.reverse
+							#stick it in the hash
+							x[decode_value(key)] = decode_value(value)
+							#remove the match from the string
+							string.slice!(match)
+							next
+						end
+						part, string = string.split('::', 2)
+						if part
+							k, v = part.split(':', 2)
+							x[decode_value(k)] = decode_value(v)
+						end
+					end
+					x
+				elsif values[0] == 'color'
+					r, g, b = values[1].split(':').map {|x| x.to_i }
+					Color.new(r, g, b)
+				elsif value.numeric?
+					if value.include? '.'
+						value.to_f
+					else
+						value.to_i
+					end
+				else
+					value.gsub('\,', ':')
+				end
+			end
+		end
+	
+		#parse the configs retrieved from irssi2
+		def parse_config(reply)
+			reply.lines.each do |line| 
+				if line['key'] and line['value']
+					value = decode_value(line['value'])
+					@values[line['key'].sub('rirc_', '')] = value
+					#puts line['key'].sub('rirc_', '')+'=>'+value.to_s
+				end
+			end
+			create_config_snapshot
+		end
+	
+		#create a copy of the config so we can compare for changes
+		def create_config_snapshot
+			@values.each do |k, v|
+				@oldvalues[k.dup] = encode_value(v)
+			end
+		end
+	
+		def update_snapshot(hash)
+			hash.each{|k,v| hash[k] = encode_value(v)}
+			@oldvalues.merge!(hash)
+		end
+	
+		def duplicate_config
+			vals = {}
+			@values.each do |k, v|
+				vals[k.dup] = decode_value(encode_value(v))
+			end
+			vals
+		end
+	
+		def revert_to_defaults
+			@values = {}
+			@defaults.each do |k,v|
+				@values[k] = v
+			end
+		end
+	
+		def get_pattern(name)
+			if @values[name].class == String
+				return @values[name].dup #don't escape_xml here
+			else
+				return ''
+			end
+		end
+	end
+end

data/lib/ratchet/connections.rb

@@ -0,0 +1,403 @@
+=begin
+	This file is part of the Ratchet project, a client for Icecap.
+    Copyright (C) 2005-6  Andrew Thompson
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+=end
+
+#### connections.rb ####
+# This file contains the different classes for Connection objects
+# which allow various methods of connection to icecap but present
+# a unified interface
+####
+
+module Ratchet
+	class Connection
+		def listen(object)
+			@listenthread = Thread.new do
+				loop do
+					begin
+						if res = select([@output], nil, nil, nil) and res[0]
+							line = res[0][0].gets
+							@main.parse_line(line.chomp) if line
+						end
+					end
+				end
+			end
+		end
+
+		def send(data)
+			begin
+				@input.puts(data)
+			rescue Errno::EPIPE
+				puts 'Write error: '+$!
+				return false
+			end
+			return true
+		end
+	end
+	class SSHConnection < Connection
+		def initialize(main, settings, connectionwindow)
+			@main = main
+			require 'open3'
+			require 'expect'
+			@input = nil
+			@output = nil
+			@error = nil
+			cmdstring = 'setsid ssh '
+			cmdstring += '-l '+settings['username']+' ' if settings['username']
+			cmdstring += '-p '+settings['port']+' ' if settings['port']
+			cmdstring += settings['host']+' '+settings['binpath']
+#         puts cmdstring
+			@input, @output, @error = Open3.popen3(cmdstring)
+			#puts @output.gets
+
+			begin
+				@output.expect(/^\*;preauth;time=(\d+);$/) do |x, y|
+					connectionwindow.send_text('logged in')
+					@main.calculate_clock_drift(y)
+				end
+
+			rescue NoMethodError
+				connectionwindow.send_text('Something is borked, make sure sshd is running on selected host')
+				raise IOError, "one of the many things that could go wrong, has"
+			end
+
+		end
+
+		#     def send(data)
+		#         begin
+		#             @input.puts(data)
+		#             #~ rescue SystemCallError
+		#             #~ puts 'Write error: '+$!
+		#             #~ return false
+		#         rescue Errno::EPIPE
+		#             puts 'Write error: '+$!
+		#             return false
+		#         end
+		#         return true
+		#     end
+
+		#     def listen(object)
+		#         @listenthread = Thread.new do
+		#             loop do
+		#                 begin
+		#                     while line = @output.gets
+		#                         #puts 'o: '+line
+		#                         object.parse_lines(line)
+		#                     end
+
+		#                 rescue Errno::EPIPE
+		#                     puts 'listen: closed stream, disconnecting '+$!
+		#                     close
+		#                     object.disconnect
+		#                     object.connect
+		#                     break
+		#                 end
+		#             end
+		#         end
+		#     end
+
+		def close
+			@listenthread.kill if @listenthread
+			@input.close
+			@output.close
+			@error.close
+		end
+	end
+
+	class LocalConnection < Connection
+		#attr_reader :connected
+		def initialize(main, settings, connectionwindow)
+			require 'open3'
+			require 'expect'
+			@main = main
+			@input = nil
+			@output = nil
+			@error = nil
+			if settings['binpath'][0].chr == '/'
+				unless File.exists? settings['binpath']
+					raise IOError, "Cannot find binary at #{settings['binpath']}"
+				end
+			elsif settings['binpath'].include? '/'
+				path = Pathname.new(settings['binpath'])
+				unless path.file?
+					raise IOError, "Cannot find binary at #{path.realpath}"
+				end
+			else
+				exists = false
+				ENV['PATH'].split(':').each do |d| #: is not windows compatible, but that's not really relevant
+					#                 puts d
+					if File.exists? d+'/'+settings['binpath']
+						exists = true
+						break
+					end
+				end
+				unless exists
+					raise IOError, "Cannot find binary #{settings['binpath']} in $PATH"
+				end
+			end
+			@input, @output, @error = Open3.popen3(settings['binpath'])
+			begin
+				@output.expect(/^\*;preauth;time=(\d+);\n/) do |x, y|
+					connectionwindow.send_text('logged in')
+					@main.calculate_clock_drift(y)
+				end
+
+			rescue NoMethodError
+				connectionwindow.send_text('Something is borked')
+				raise IOError, "one of the many things that could go wrong, has"
+			end
+		end
+
+		#     def send(data)
+		#         begin
+		#             @input.puts(data)
+		#         rescue Errno::EPIPE
+		#             puts 'Write error: '+$!
+		#             return false
+		#         end
+		#         true
+		#     end
+
+		#     def listen(object)
+		#         @listenthread = Thread.new do
+		#             loop do
+		#                                 puts 'bar'
+		#                 begin
+		#                                         while line = @output.gets
+		#puts 'o: '+line
+		#                                             object.parse_lines(line)
+		#                                         end
+		#                     if res = select([@output], nil, nil, nil) and res[0]
+		#                                                 puts res[0].inspect
+		#                                                 puts res[0][0].read.class
+		#                         @main.parse_line(res[0][0].gets.chomp)
+
+		#                         #Thread.new do
+		#                                                     @main.parse_lines(res[0][0].readlines("\n"))
+		#                         #end
+		#                     else
+		#                         puts 'no IO'
+		#                     end
+		#                                     rescue Errno::EPIPE
+		#                                         puts 'listen: closed stream, disconnecting '+$!
+		#                                         close
+		#                                         object.disconnect
+		#                                         object.connect
+		#                                         break
+		#                 end
+		#             end
+		#         end
+		#     end
+
+		def close
+			@listenthread.kill if @listenthread
+			@input.close
+			@output.close
+			@error.close
+		end
+	end
+
+	class NetSSHConnection < Connection
+		def initialize(main, settings, connectionwindow)
+			@main = main
+			begin
+				@session = Net::SSH.start(settings['host'], settings['username'], :auth_methods => %w(password), :port => settings['port'])
+
+				@input, @output, @error = @session.process.popen3(settings['binpath'])
+
+			rescue Errno::EHOSTUNREACH
+				raise(IOError, 'Could not connect to host')
+			rescue Net::SSH::AuthenticationFailed
+				raise(IOError, 'Authentication Failed')
+			rescue Errno::ECONNREFUSED
+				raise(IOError, 'Connection Refused')
+			end
+			sleep 2
+			if @error.data_available?
+				error = @error.read
+				raise(IOError, error, caller)
+			end
+
+			#@sshthread = Thread.new{
+			#	@session.loop
+			#}
+			puts 'connected via ssh'
+		end
+
+		def send(data)
+			begin
+				@input.puts(data)
+			rescue Errno::EPIPE
+				puts 'Write error: '+$!
+				return false
+			end
+			return true
+		end
+
+		def listen(object)
+			@listenthread = Thread.start do
+				while true
+					begin
+						if @output.data_available?
+							out = @output.read
+							object.parse_lines(out)
+						end
+						sleep 0.01 #sleep a little, this seems to be important
+					rescue IOError
+						puts 'listen: closed stream, disconnecting '+$!
+						close
+						object.disconnect
+						object.connect
+						break
+					end
+				end
+			end
+		end
+
+		def close
+			@session.close if @session
+			@sshthread.kill if @sshthread
+			@input = nil
+			@output = nil
+			@error = nil
+		end
+
+	end
+
+
+	class UnixSockConnection < Connection
+		def initialize(settings, connectionwindow)
+			if File.exist?(settings['location'])
+				begin
+					@socket = UNIXSocket.open(settings['location'])
+				rescue
+					raise(IOError, 'Could not connect to socket')
+				end
+				connectionwindow.send_text('Connected via unix socket')
+			else
+				raise(IOError, 'Socket File does not exist')
+			end
+		end
+
+		def send(data)
+			begin
+				@socket.send(data, 0)
+			rescue SystemCallError
+				puts 'Broken Pipe to Irssi, disconnecting '+$!
+				close
+				return false
+			end
+			return true
+		end
+
+		def listen(object)
+			@listenthread = Thread.start{
+				input = ''
+				begin
+					while line = @socket.recv(70)
+						if line.length == 0
+							sleep 1
+						end
+						input += line
+						if input.count("\n") > 0
+							pos = input.rindex("\n")
+							string = input[0, pos]
+							input = input[pos, input.length]
+							Thread.start{
+								object.parse_lines(string)
+							}
+						end
+					end
+
+				rescue SystemCallError
+					puts 'Broken Pipe to Irssi, disconnecting '+$!
+					close
+				end
+			}
+		end
+
+		def close
+			@listenthread.kill
+			@socket.close
+			@client = nil
+		end
+
+	end
+
+
+	class InetdConnection < Connection
+		def initialize(main, settings, connectionwindow)
+			@main = main
+			begin
+				@socket = TCPSocket.new(settings['host'], settings['port'].to_i)
+			rescue
+				raise(IOError, 'Could not connect to socket')
+			end
+			connectionwindow.send_text('Connected via TCP socket')
+		end
+
+		def send(data)
+			begin
+				@socket.send(data, 0)
+			rescue SystemCallError
+				puts 'Broken Pipe to Irssi, disconnecting '+$!
+				close
+				return false
+			end
+			return true
+		end
+
+		def listen(object)
+			@listenthread = Thread.start{
+				loop do
+					if res = select([@socket], nil, nil, nil) and res[0]
+						@main.parse_line(res[0][0].gets.chomp)
+					end
+				end
+			}
+		end
+
+		def close
+			@listenthread.kill
+			@socket.close
+			@client = nil
+		end
+
+	end
+
+	class ConnectionFactory
+
+		# Create a class variable constant of the various available connection
+		# types.
+
+		Types = {
+			"ssh" => SSHConnection,
+			"socket" => UnixSockConnection,
+			"inetd" => InetdConnection,
+			"local" => LocalConnection,
+			"net_ssh" => NetSSHConnection }
+
+		def self.spawn( type, *params )
+			object = Types[type]
+			unless object
+				raise( ArgumentError, "Supplied connection type \"" + type + "\" is not available." )
+			end
+			return object.new( *params )
+		end
+
+	end
+end