butler 1.8.0

data/lib/access/role.rb

@@ -0,0 +1,102 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Access
+	# Access::Role's are a set of privileges with (optionally)
+	# an additional restriction (which is applied globally).
+	class Role
+		module Base
+			# Create a new Role
+			def create(role, description=nil, privileges=[])
+				raise "Role #{role} already exists" if exists?(role)
+				role        = Role.new(role, description)
+				role.access = access
+				role.base   = self
+				add(role)
+				role
+			end
+	
+			# Restore an Access::Privilege from it's storable data
+			def load(*args) # :nodoc:
+				return nil unless data = super
+				roles        = access.role
+				data[:roles] = data[:roles].map { |role| roles[role] }
+				array        = data.values_at(:id, :description)
+				array       << data
+				role         = new(*array)
+				role.access  = access
+				role.base    = self
+				role
+			end
+		end
+
+		attr_reader :id
+		attr_reader :description
+
+		def initialize(role, description=nil, other={})
+			@id          = role
+			@privileges  = Privileges.new(self, other[:privileges])
+			@roles       = Roles.new(self, other[:roles])
+			@description = description || "No description"
+		end
+		
+		def storable
+			{
+				:id          => @id,
+				:description => @description,
+				:privileges  => @privileges.storable,
+				:roles       => @roles.storable,
+			}
+		end
+
+		def allows?(privilege, condition=nil)
+			@privileges.allow?(privilege, condition) || @roles.allow?(privilege, condition)
+		end
+
+		def eql?(other)
+			self.class == other.class && @id.eql?(other.id)
+		end
+		
+		def hash
+			@id.hash
+		end
+	end
+	
+	class Roles
+		def initialize(owner, roles=nil)
+			@owner = owner
+			@roles = roles || []
+		end
+		
+		def allow?(privilege, condition=nil)
+			@roles.any? { |role| role.allows?(privilege, condition) }
+		end
+
+		def add(role)
+			@roles << role
+			@owner.save
+		end
+		
+		def delete(role)
+			@roles.delete(role)
+			@owner.save
+		end
+		
+		def list
+			@roles
+		end
+
+		def each(&block)
+			@roles.each(&block)
+		end
+		
+		def storable
+			@roles.map { |role| role.id }
+		end
+	end
+end

data/lib/access/savable.rb

@@ -0,0 +1,18 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Access
+	module Savable
+		attr_accessor :access
+		attr_accessor :base
+
+		def save
+			base.save(id())
+		end
+	end
+end

data/lib/access/user.rb

@@ -0,0 +1,180 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'access'
+require 'access/savable'
+require 'access/admin'
+
+
+
+class Access
+	# Access::User
+	# Use nil-id if you don't want the object to be stored.
+	class User
+		include Savable
+
+		module Base
+			# Create a new - inactive(!) - user
+			def create(user_id, credentials, meta=nil, admin=false, opt={})
+				raise "User-id #{user_id} already exists" if exists?(user_id)
+				credentials = credentials ? access.hash_credentials(credentials, user_id) : "*"
+				user        = User.new(
+					user_id,
+					credentials,
+					meta,
+					admin,
+					{:active => !!opt.delete(:active)}.merge(opt)
+				)
+				user.access = access
+				user.base   = self
+				add(user)
+				user
+			end
+	
+			# Restore an Access::User from it's storable data
+			def load(*args) # :nodoc:
+				return nil unless data = super
+				array       = data.values_at(:id, :credentials, :meta, :admin)
+				array      << data
+				user        = User.new(*array)
+				user.access = access
+				user.base   = self
+				user
+			end
+		end
+
+		attr_reader :id
+		attr_reader :credentials
+		attr_reader :privileges
+		attr_reader :roles
+
+		attr_accessor :meta
+
+		# The data needed to restore a user.
+		# Simplified to hashes and scalar values.
+		def storable
+			{
+				:id          => @id,
+				:credentials => @credentials,
+				:meta        => @meta,
+				:admin       => @admin,
+				:active      => @active,
+				:privileges  => @privileges.storable,
+				:roles       => @roles.storable,
+			}
+		end
+		
+		# access: the access-instance the user is tied to (necessary for storing)
+		# id: a string/integer, identifying the user
+		# credentials: (if not subclassed) a string authenticating the user, will be hashed before storing.
+		# meta: meta data about the user
+		# admin: admin's have all privileges granted
+		def initialize(id, credentials, meta=nil, admin=false, other={})
+			@id          = id
+			@credentials = credentials
+			@admin       = admin
+			@active      = other.has_key?(:active) ? other[:active] : false
+			@meta        = meta
+			@roles       = Roles.new(self, other[:role])
+			@privileges  = Privileges.new(self, other[:privileges])
+			@logged      = false
+
+			extend(Admin) if @admin
+		end
+		
+		def credentials=(value)
+			@credentials = value ? access.hash_credentials(value, @id) : "*"
+			save
+		end
+		
+		# Check if a user has sufficient privileges to be allowed for certain
+		# privilege with certain restriction parameters.
+		# WARNING! This method does not care about login- nor active-state.
+		# Use authorized? to do that
+		def privileged?(privilege, parameters=nil)
+			@privileges.allow?(privilege, parameters) || @roles.allow?(privilege, parameters)
+		end
+		
+		# Same as privileged? but also takes active? and logged? into consideration.
+		# I.e. if a user is inactive or not logged in, he is not authorized for anything.
+		def authorized?(*args)
+			@active && @logged && privileged?(*args)
+		end
+
+		# Check if user is admin
+		def admin?
+			false
+		end
+
+		# Check if user is activated (deactivated users have no privileges)
+		def active?
+			@active
+		end
+
+		# Check if user is deactivated (deactivated users have no privileges)
+		def inactive?
+			!@active
+		end
+		
+		# Activate a user
+		def activate
+			@active = true
+			save
+		end
+		
+		# Deactivate a user (deactivated users have no privileges)
+		def deactivate
+			@active = false
+			save
+		end
+		
+		# Set active state to value
+		def active=(value)
+			@active = value
+			save
+		end
+		
+		def login
+			@logged = true
+		end
+		
+		def logout
+			@logged = false
+		end
+		
+		def logged=(value)
+			@logged = value
+		end
+		
+		def logged?
+			@logged
+		end
+		
+		def eql?(other)
+			self.class == other.class && @id.eql?(other.id)
+		end
+		alias == eql? # in ruby1.8 that's unecessary as == uses eql? per default
+		
+		def hash
+			@id.hash
+		end
+
+		def inspect # :nodoc:
+			"#<%s:0x%08x base: %s id: %s credentials: %s %s%s%s>" %  [
+				self.class,
+				object_id << 1,
+				"#{@base.class}(#{(class <<@base; self; end).ancestors.first})",
+				@id.inspect,
+				@credentials,
+				@active ? 'active' : 'inactive',
+				admin? ? ' admin' : '',
+				logged? ? ' logged' : ''
+			]
+		end
+	end
+end

data/lib/access/yamlbase.rb

@@ -0,0 +1,126 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'access'
+require 'yaml'
+
+
+
+class Access
+	# An Access compatible storage backend
+	class YAMLBase
+		include Enumerable
+
+		attr_accessor :access
+
+		#	extender:  a module that will extend this instance and provide additional
+		#            functionality
+		#	framework: the Access instance this data-storage is tied to
+		#	path:      the path to the data		
+		def initialize(extender, path=nil)
+			@path      = path
+			@extender  = extender
+			@data      = {}
+			extend(extender)
+
+			@path    ||= default_path
+			raise "Path must be a directory (#@path)" unless File.directory?(@path)
+		end
+		
+		#	The full path and filename to the data object belonging to id
+		def filename(id)
+			"#{@path}/#{escape(id)}.yaml"
+		end
+		
+		def escape(id)
+			id.gsub(/[\x00-\x1f.%]/) { |m| "%%%02x"%m }.gsub("/", ".")
+		end
+		
+		def path2id(path)
+			path[(@path.length+1)..-6].gsub(".", "/").gsub(/%([\dA-Fa-f]{2})/) { $1.to_i(16).chr }
+		end
+
+		# Load an entry, will not write to cache, returns nil if entry doesn't exist
+		def load(id)
+			file = filename(id)
+			File.exist?(file) ? YAML.load_file(file) : nil
+		end
+
+		# Loads all entries into cache
+		def cache_all
+			slice = (@path.length+1)..-6
+			Dir.glob("#{@path}/*.yaml") { |path| # /**
+				id = path[slice]
+				@data[id] ||= load(id)
+			}
+		end
+			
+
+		#	Retrieve the object with id, if force_load cache will be ignored.
+		def [](id, force_load=false)
+			if force_load then
+				@data[id] = load(id)
+			else
+				@data[id] ||= load(id)
+			end
+		end
+		
+		#	Add a record to the storage
+		def <<(record)
+			@data[record.id]	= record
+			save(record.id)
+		end
+		alias add <<
+
+		#	Delete a record from the storage
+		def delete(record)
+			id	= record.kind_of?(@type) ? record.id : record
+			@data.delete(id)
+			File.delete(filename(id))
+		end
+		
+		def keys
+			Dir.glob("#{@path}/*.yaml").map { |path|
+				path2id(path)
+			}
+		end
+
+		#	Iterate over records, yielding id and object
+		def each
+			slice = (@path.length+1)..-6
+			Dir.glob("#{@path}/*.yaml") { |path|
+				id = path[slice]
+				yield(id, @data[id] || load(id))
+			}
+		end
+
+		#	Iterate over records, yielding id
+		def each_key
+			Dir.glob("#{@path}/*.yaml") { |path|
+				yield(path2id(path))
+			}
+		end
+
+		#	Check existency of an object.
+		def exists?(id)
+			@data.has_key?(id) || File.exists?(filename(id))
+		end
+		alias exist? exists?
+		
+		#	Synchronize data-cache with filesystem.
+		def save(id=nil)
+			if @data.has_key?(id) then
+				File.open(filename(id), 'w') { |fh| fh.write(@data[id].storable.to_yaml) }
+			elsif id.nil? then
+				@data.each_key { |key| save(key) }
+			else
+				raise "Could not save '#{id}' since it's not in @data"
+			end
+		end
+	end
+end

data/lib/butler.rb

@@ -0,0 +1,188 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'access'
+require 'butler/initialvalues'
+require 'butler/version'
+require 'configuration'
+require 'fileutils'
+require 'log/comfort'
+require 'rbconfig'
+require 'ruby/file/write'
+require 'ruby/kernel/daemonize'
+require 'yaml'
+
+
+
+class Butler
+	@path       = nil
+	@log_device = nil
+	extend Log::Comfort
+
+	class <<self
+		attr_accessor :path
+
+		# start a bot
+		# if you provide a block, it will yield the bot instance and you can control
+		# it. If not, it will enter the Bot#event_loop.
+		# options:
+		# -:in_dir => path to the directory the bot can be found [Butler.bots]
+		# -:daemonize => whether this script should become a deamon or not [true]
+		# -...
+		def start(path, botname, opts={}, &block)
+			Thread.abort_on_exception = true # if $DEBUG # FIXME
+			path    ||= @path
+			butler    = nil
+			
+			if opts.delete(:daemonize) then
+				start_daemon(path, botname, opts, &block)
+			else
+				start_interactive(path, botname, opts, &block)
+			end
+		end
+		
+		def start_daemon(path, botname, opts={}, &block)
+			butler, pidfile = nil, nil
+			info "Daemonizing"
+			pidfile = test_pidfile(path.run, botname)
+			daemonize(path.base) { }
+			begin
+				File.write(pidfile, $$)
+				butler  = Bot.new(path, botname)
+				path    = butler.path
+				$stderr = File.open(path.log+"/error.log", "w")
+				$stdout = File.open(path.log+"/out.log", "w")
+				trap("SIGHUP") { butler.quit }
+				butler.output_to_logfiles
+				butler.plugins.load_all
+				butler.login
+				info("Running #{botname} with PID #{$$} as daemon")
+				if block then butler.event_loop(&block) else sleep end
+			rescue SystemExit => e
+				info("Exit, terminating #{botname} (in #{e.backtrace.first}")
+			rescue Exception => e
+				exception(e)
+			else
+				info("EventLoop ended, terminating #{botname}")
+			ensure
+				butler.quit if butler
+				File.delete(pidfile) if pidfile and File.exist?(pidfile)
+				info("Terminated")
+			end
+		end
+		
+		def start_interactive(path, botname, opts, &block)
+			butler, pidfile = nil, nil
+			pidfile = test_pidfile(path.run, botname)
+			File.write(pidfile, $$)
+			info("Running #{botname} with PID #{$$} interactively")
+			butler  = Bot.new(path, botname)
+			butler.plugins.load_all
+			butler.login
+			if block then butler.event_loop(&block) else sleep end
+		rescue SystemExit => e
+			info("Exit #{botname} (in #{e.backtrace.first}")
+		rescue Interrupt => e
+			info("Interrupt, terminating #{botname} (in #{e.backtrace.first}")
+		rescue Exception => e
+			exception(e)
+		ensure
+			File.delete(pidfile) if pidfile and File.exist?(pidfile)
+			butler.quit if butler #and butler.logged_in? # FIXME, make the commented code happen
+			info("Terminated")
+		end
+		
+		def test_pidfile(path, botname)
+			pidfile = "#{path}/#{botname}.pid"
+			FileUtils.mkdir_p(path, :mode => 0755)
+			raise "Can't write to pid-directory (#{path.run})" if !File.writable?(path)
+			if File.exist?(pidfile) && pid = File.read(pidfile) then
+				if pid.empty? then
+					raise "Already a Butler named '#{botname}' starting up"
+				else
+					raise "Already a Butler named '#{botname}' running with PID #{pid.chomp}"
+				end
+			end
+			pidfile
+		end
+		
+		def stop(path, botname)
+			path    ||= @path
+			pidfile   = "#{path.run}/#{botname}.pid"
+			if File.exist?(pidfile) then
+				pid       = File.read(pidfile).to_i
+				begin
+					Process.kill("HUP", pid)
+				rescue Errno::ESRCH; end
+				begin
+					File.delete(pidfile)
+				rescue Errno::ENOENT; end
+			end
+		rescue => e
+			exception(e)
+			nil
+		end
+		
+		# creates a backup of all important files of a bot
+		def backup(path, botname, backup)
+			path     ||= @path
+			bot_path   = "#{path.bots}/#{botname}"
+			FileUtils.mkdir_p(File.dirname(backup), :mode => 0755)
+			FileUtils.cp_r(bot_path, backup)
+		end
+		
+		# tests if a bot named +botname+ exists
+		def exists?(path, botname)
+			path     ||= @path
+			bot_path   = "#{path.bots}/#{botname}"
+			File.directory?(bot_path)
+		end
+		
+		# returns a list with bots
+		def list(path)
+			path ||= @path
+			Dir[path.bots+"/*/"].map { |dir| dir[%r{([^/]+)/$}, 1] }
+		end
+
+		# creates a new bot
+		def create(path, botname, opts={})
+			path     ||= @path
+			bot_path   = "#{path.bots}/#{botname}"
+			Structure.each { |dir, mode|
+				FileUtils.mkdir_p(dir.sub(/BOTPATH/, bot_path),	:mode => mode)
+			}
+			conf = Configuration.new(
+				ConfigurationStructure.first.sub(/BOTPATH/, bot_path),
+				ConfigurationStructure[1..-1]
+			)
+			EmptyConfig.each { |k,v|
+				conf[k] = v
+			}
+			FileUtils.cp_r(path.plugin_repository, bot_path)
+		end
+
+		# deletes a bot
+		def delete(path, botname)
+			path     ||= @path
+			bot_path   = "#{path.bots}/#{botname}"
+			FileUtils.rm_r(bot_path)
+		end
+
+		# renames a bot
+		def rename(path, old_name, new_name)
+			path         ||= @path
+			old_bot_path   = "#{path.bots}/#{old_name}"
+			new_bot_path   = "#{path.bots}/#{new_name}"
+			FileUtils.mv(old_bot_path, new_bot_path)
+		end
+		
+		def new(*args, &block)
+			Bot.new(*args, &block)
+		end
+	end # <<Butler
+end