hosttag 0.12

data/bin/htset

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+#
+# Hosttag update client, redis version
+#
+# Usage:
+#   htset <host1> [<host2> ...] <tag> [<tag2> ...]
+#   htdel <host1> [<host2> ...] <tag> [<tag2> ...]
+#
+
+require 'optparse'
+require 'fileutils'
+require 'pp'
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'hosttag'
+include Hosttag
+
+# ------------------------------------------------------------------------------
+# Subroutines
+
+def die(error)
+  puts error
+  exit 1
+end
+
+def parse_options(me)
+  options = { :all => false, :autoconfirm => false }
+  opts = OptionParser.new
+  opts.banner = "Usage: #{me} [options] <host> [<host2> ...] <tag> [<tag2>...]"
+  opts.on('-?', '-h', '--help') do
+    puts opts
+    exit
+  end
+  opts.on('-h', '--help', '-?', 'Show this usage information') do
+    die(opts)
+  end
+  opts.on('-A', '--all', '(htdel) Delete all tags from hosts') do
+    options[:all] = true
+  end
+  opts.on('-y', '--yes', "(htdel) Don't ask for confirmation on delete all operations") do
+    options[:autoconfirm] = true
+  end
+  opts.on('-H', '--host', '--hosts', 'Treat unrecognised elements as hosts') do
+    options[:host_mode] = true
+  end
+  opts.on('-T', '--tag', '--tags', 'Treat unrecognised elements as tags') do
+    options[:tag_mode] = true
+  end
+  opts.on('--ns=STR', '--namespace=STR', String, 'Namespace into which we load hosttag data. Default: hosttag') do |val|
+    options[:namespace] = val
+  end
+  opts.on('-s=ARG', '--server=ARG', String, 'Server hostname to connect to') do |val|
+    options[:server] = val
+  end
+  opts.on('-p=ARG', '--port=ARG', Integer, 'Server port to connect to') do |val|
+    options[:port] = val
+  end
+  opts.on('-v', '--verbose', 'Verbose output') do
+    options[:verbose] = true
+  end
+
+  # Parse options
+  begin
+    args = opts.parse(ARGV) 
+  rescue => e
+    die(opts) 
+  end
+
+  if args.length < 2 and not options[:all]
+    die(opts) 
+  end
+  if options[:all] and me =~ /set$/
+    warn "Error: --all not available with #{me}"
+    die(opts)
+  end 
+  if options[:host_mode] and options[:tag_mode]
+    warn "Error: --host and --tag options are mutually exclusive"
+    die(opts)
+  end
+
+  return options, args
+end
+
+# Classify args into hosts, tags, and uncertain buckets
+def classify_args(args, options)
+  results = { :host => [], :tag => [], :uncertain => [] }
+  verbose = options[:verbose]
+
+  # First arg must be host, and last tag, by definition
+  results[:host].push(args.shift)
+  last_tag = args.pop
+
+  # Classify remainder by doing lookups
+  while a = args.shift do
+    begin
+      tags = hosttag_lookup_hosts(a, options)
+      if tags.length > 0
+        # if 'a' is a valid host, then everything already in uncertain must be too
+        if results[:uncertain].length > 0
+          results[:host].push(*results[:uncertain])
+          results[:uncertain] = []
+        end
+        results[:host].push(a)
+      end
+    rescue
+      # 'a' is not a known host, check if a tag
+      begin
+        hosts = hosttag_lookup_tags(a, options)
+        if hosts.length > 0
+          # If 'a' is a valid tag, then everything else in args must be too
+          results[:tag].push(a, *args)
+          args = []
+        end
+      rescue
+        # 'a' is not a known host or tag, add to uncertain list
+        results[:uncertain].push(a)
+      end
+    end
+  end
+
+  results[:tag].push(last_tag)
+
+  return results
+end
+
+# ------------------------------------------------------------------------------
+# Main
+
+mode = $0.sub(/^.*\//, '')
+
+options, args = parse_options(mode)
+
+# Normal mode
+if (not options[:all])
+  results = classify_args(args, options)
+  if options[:verbose] 
+    print "+ results: "
+    pp results 
+  end
+
+  if results[:uncertain].length > 0
+    # --hosts: treat unknown elements as hosts
+    if options[:host_mode]
+      results[:host].push(*results[:uncertain])
+    elsif options[:tag_mode]
+      results[:tag].push(*results[:uncertain])
+    else
+      # TODO: do something useful here - ask the user?
+      die("Error: can't auto-classify '#{results[:uncertain].join(',')}' - aborting")
+    end
+  end
+
+  if (mode =~ /del$/)
+    hosttag_delete_tags(results[:host], results[:tag], options)
+  else
+    hosttag_add_tags(results[:host], results[:tag], options)
+  end
+
+# htdel --all mode
+elsif (mode =~ /del$/)
+  hosttag_delete_all_tags(args, options)
+
+end
+

data/etc/Makefile

@@ -0,0 +1,16 @@
+all: import export
+	
+import:
+	# redis has essentially open write permissions, so htimport is limited to root
+	sudo /usr/sbin/htimport
+
+export:
+	# htexport is already limited by filesystem permissions, so doesn't need to be root
+	/usr/bin/htexport
+
+import-delete:
+	sudo /usr/sbin/htimport --delete
+
+export-delete:
+	/usr/bin/htexport --delete
+

data/etc/README

@@ -0,0 +1,10 @@
+To add hosttags, create host directories in the /etc/hosttag directory,
+and touch tag files within the host directories e.g.
+
+  cd /etc/hosttag
+  mkdir host1 host2 host3
+  touch host1/{tag1,tag2,tag3}
+  touch host2/{tag1,tag2,tag3}
+
+and then run 'make' to update the hosttag database.
+

data/hosttag.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = "hosttag"
+  s.version = "0.12"
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Gavin Carr"]
+  s.email = ["gavin@openfusion.net"]
+  s.homepage = "http://github.com/gavincarr/hosttag"
+  s.summary = "Hosttag is a client for tagging hostnames into classes using a redis datastore"
+  s.description = "Hosttag is a client for tagging hostnames into groups or classes,
+storing them in a redis datastore"
+  s.rubyforge_project = s.name
+
+  s.required_rubygems_version = ">= 1.3.6"
+  
+  # If you have runtime dependencies, add them here
+  s.add_runtime_dependency "redis", "~> 2.0"
+  
+  # The list of files to be contained in the gem
+  s.files = `git ls-files`.split("\n")
+  
+  s.require_path = 'lib'
+end
+

data/hosttag.spec

@@ -0,0 +1,179 @@
+%define ruby_sitelib %(ruby -rrbconfig -e "puts Config::CONFIG['sitelibdir']")
+
+Summary: Hosttag client
+Name: hosttag
+Version: 0.12
+Release: 1%{org_tag}%{dist}
+URL: http://www.openfusion.com.au/labs/
+Source0: http://www.openfusion.com.au/labs/dist/%{name}-%{version}.tar.gz
+License: GPL
+Group: Applications/System
+BuildRoot: %{_tmppath}/%{name}-%{version}
+BuildArch: noarch
+Requires: rubygems, rubygem-redis >= 2.0.0
+
+%description
+Hosttag is a client for tagging hostnames into groups or classes, storing
+the mappings in a redis datastore.
+
+This package contains the hosttag client utilities.
+
+%package server-utils
+Summary: Hosttag server utilities
+Group: Applications/System
+Requires: hosttag = %version
+Requires: redis, rubygems, rubygem-redis >= 2.0
+Obsoletes: hosttag-server
+Conflicts: hosttag-server
+
+%description server-utils
+Hosttag is a client for tagging hostnames into groups or classes, storing
+the mappings in a redis datastore.
+
+This package contains optional hosttag server utilities, allowing you to
+export and import hosttag mappings to disk. It's not required for normal
+use, however.
+
+%prep
+%setup
+
+%build
+
+%install
+test "%{buildroot}" != "/" && rm -rf %{buildroot}
+
+mkdir -p %{buildroot}%{ruby_sitelib}/hosttag
+install -m0644 lib/hosttag.rb %{buildroot}%{ruby_sitelib}/hosttag.rb
+install -m0644 lib/hosttag/server.rb %{buildroot}%{ruby_sitelib}/hosttag
+
+mkdir -p %{buildroot}%{_bindir}
+install -m0755 bin/hosttag %{buildroot}%{_bindir}/hosttag
+install -m0755 bin/htexport %{buildroot}%{_bindir}/htexport
+
+# htset and htimport are executable by root only, to restrict tagging to root
+install -m0700 bin/htset %{buildroot}%{_bindir}/htset
+install -m0700 bin/htimport %{buildroot}%{_bindir}/htimport
+#install -m0700 bin/htdump %{buildroot}%{_bindir}/htdump
+
+mkdir -p %{buildroot}%{_sysconfdir}/%{name}
+install -m0644 etc/Makefile %{buildroot}%{_sysconfdir}/%{name}
+install -m0644 etc/README %{buildroot}%{_sysconfdir}/%{name}
+
+cd %{buildroot}%{_bindir}
+ln -s hosttag ht
+cd %{buildroot}%{_bindir}
+ln -s htset htdel
+
+%clean
+test "%{buildroot}" != "/" && rm -rf %{buildroot}
+
+%files
+%defattr(-,root,root)
+%{ruby_sitelib}/hosttag.rb
+%{ruby_sitelib}/hosttag/*
+%{_bindir}/hosttag
+%{_bindir}/ht
+%attr(0700,root,root) %{_bindir}/htset
+%{_bindir}/htdel
+#%attr(0700,root,root) %{_bindir}/htdump
+%doc README LICENCE
+
+%files server-utils
+%defattr(-,root,root)
+%config(noreplace) %{_sysconfdir}/%{name}/Makefile
+%{_sysconfdir}/%{name}/README
+%attr(0755,root,root) %{_bindir}/htexport
+%attr(0700,root,root) %{_bindir}/htimport
+
+%changelog
+* Mon Nov 21 2011 Gavin Carr <gavin@openfusion.com.au> 0.12
+- Cleanups and tweaks for better compatibility with ruby 1.9.x.
+
+* Wed Feb 02 2011 Gavin Carr <gavin@openfusion.com.au> 0.11
+* Add Hosttag::Server support for HOSTTAG_{SERVER,PORT,NAMESPACE} env variables.
+- Rename hosttag-server subpackage to hosttag-server-utils.
+
+* Thu Jan 13 2011 Gavin Carr <gavin@openfusion.com.au> 0.10.5
+- Remove htdump from spec file, since it clashes with htdig utility.
+
+* Wed Jan 12 2011 Gavin Carr <gavin@openfusion.com.au> 0.10.4
+- Add support for hosttag -A -l and -T -l.
+
+* Wed Jan 12 2011 Gavin Carr <gavin@openfusion.com.au> 0.10.3
+- Fix hosttag.render to handle nil results better.
+
+* Tue Jan 11 2011 Gavin Carr <gavin@openfusion.com.au> 0.10.2
+- Fix some buglets in htset.
+- Move root utils from %{_sbindir} to %{_bindir}.
+
+* Fri Jan 07 2011 Gavin Carr <gavin@openfusion.com.au> 0.10.1
+- Fix a couple of small bugs in 0.10.
+
+* Thu Jan 06 2011 Gavin Carr <gavin@openfusion.com.au> 0.10
+- Librification release, creating new Hosttag module with core functionality.
+- Rewrite hosttag, htset, and htimport to use new Hosttag module.
+- Rewrite hosttag_{add,delete}_tags routines to handle tricksy SKIP corner cases.
+- Create lib versions of unit tests alongside existing bin ones.
+- Expand unit test coverage for htset/htdel.
+- Update unit tests to use library calls instead of calling out to utils.
+- Change all_{hosts,tags}_* key names for greater clarity.
+
+* Mon May 24 2010 Gavin Carr <gavin@openfusion.com.au> 0.9
+- Migrate redis api calls over to redis 2.0.0 gem.
+- Add --all option to htdel, for deleting all tags from a host.
+- Add --host and --tag option to htset for ambiguous elements.
+
+* Fri Feb 12 2010 Gavin Carr <gavin@openfusion.com.au> 0.8.1
+- Add a -1 argument to hosttag to list results one per line.
+
+* Mon Feb 08 2010 Gavin Carr <gavin@openfusion.com.au> 0.8
+- Refactor, pulling server bits into Hosttag::Server.
+- Add htset unit test, and fix bugs arising.
+
+* Mon Feb 08 2010 Gavin Carr <gavin@openfusion.com.au> 0.7.1
+- Fix typo in htset.
+
+* Fri Feb 05 2010 Gavin Carr <gavin@openfusion.com.au> 0.7
+- Add namespace option to all binaries.
+- Add options to htdump.
+- Add missing htdump to spec file.
+
+* Wed Feb 03 2010 Gavin Carr <gavin@openfusion.com.au> 0.6.9
+- Add missing htdel symlink to hosttag package.
+
+* Tue Feb 02 2010 Gavin Carr <gavin@openfusion.com.au> 0.6.8
+- Fix bug with htset not deleting host from noskip list if SKIP tag set.
+
+* Wed Jan 13 2010 Gavin Carr <gavin@openfusion.com.au> 0.6.7
+- Add --list mode to hosttag.
+
+* Thu Dec 31 2009 Gavin Carr <gavin@openfusion.com.au> 0.6.6
+- Rename hosttag_export to htexport, and hosttag_load_data to htimport.
+- Change old --import parameter to htimport to --delete, like htexport.
+- Make htimport more verbose, like htexport.
+
+* Tue Dec 29 2009 Gavin Carr <gavin@openfusion.com.au> 0.6.5
+- Add hosttag_export utility to export redis db back to directory tree.
+
+* Tue Dec 08 2009 Gavin Carr <gavin@openfusion.com.au> 0.6
+- Move from tokyo cabinet/tyrant server to redis-based one.
+- Rewrite client in ruby.
+
+* Wed Nov 04 2009 Gavin Carr <gavin@openfusion.com.au> 0.5
+- Fixes to hosttag_load_data.
+- Add SKIP tag support to hosttag_load_data.
+- Mode fixes to hosttag.
+- Add htserver init scripts to hosttag-server package.
+
+* Thu Oct 01 2009 Gavin Carr <gavin@openfusion.com.au> 0.4
+- Rename data to etc, and load_data to hosttag_load_data.
+- Add -server subpackage to hosttag.spec.
+
+* Thu Oct 01 2009 Gavin Carr <gavin@openfusion.com.au> 0.3
+- Change -h|--hosts parameters to -t|--tags (and deprecate -h).
+- Allow bare 'ht -t' for listing all tags.
+- Add default rel for multitag and multihost queries.
+
+* Thu Feb 19 2009 Gavin Carr <gavin@openfusion.com.au> 0.1
+- Initial package, version 0.1.
+

data/lib/hosttag.rb

@@ -0,0 +1,402 @@
+
+require 'hosttag/server'
+
+module Hosttag
+
+  # Lookup the given tag(s), returning an array of hosts to which they apply.
+  # If multiple tags are given, by default the list of hosts is those to
+  # which ALL of the tags apply i.e. results are ANDed or intersected. To
+  # change this, pass :rel => :or in the options hash.
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :rel - either :and or :or, specifying the relationship to use when
+  #   interpreting the set of tags. :rel => :and returns the set of hosts to
+  #   which ALL the given tags apply; :rel => :or returns the set of hosts
+  #   to which ANY of the tags apply. Default: :rel => :and.
+  # - :include_skip? - flag indicating whether to include hosts that have
+  #   the SKIP tag set. Default: false i.e. omit hosts tagged with SKIP.
+  def hosttag_lookup_tags(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    return lookup_keys(args, options.merge({ :type => :tag }))
+  end
+
+  # Lookup the given host(s), returning an array of tags that apply to
+  # them. If multiple hosts are given, by default the list of tags is
+  # those applying to ANY of the given hosts i.e. the results are ORed or
+  # unioned. To change this pass an explicit :rel => :and in the options
+  # hash.
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :rel - either :and or :or, specifying the relationship to use when
+  #   interpreting the set of hosts. :rel => :and returns the set of tags
+  #   that apply to ALL the given hosts; :rel => :or returns the set of tags
+  #   that apply to ANY of the given hosts. Default: :rel => :or.
+  # - :include_skip? - flag indicating whether to include hosts that have
+  #   the SKIP tag set. Default: false i.e. omit hosts tagged with SKIP.
+  def hosttag_lookup_hosts(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    return lookup_keys(args, options.merge({ :type => :host }))
+  end
+
+  # Lookup the given host(s) or tag(s), returning an array of tags or hosts,
+  # as appropriate. If a :type option is not explicitly given, first tries
+  # the lookup using hosttag_lookup_tags, and if that fails retries using
+  # hosttag_lookup_hosts.
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :type - either :host or :tag, specifying how to interpret the given
+  #   arguments: :type => :host specifies that the arguments are hosts, and
+  #   that the resultset should be a list of tags; :type => :tag specifies
+  #   that the arguments are tags, and the resultset should be a list of
+  #   hosts. Required, no default.
+  # - :rel - either :and or :or, specifying the relationship to use when
+  #   interpreting the set of results. :rel => :and returns only results
+  #   that have ALL of the given attributes i.e. the AND result set;
+  #   :rel => :or returns results that have ANY of the given attributes
+  #   i.e. the OR result set. Default: depends on :type - :and for :type
+  #   => :host, and :or for :type => :tag.
+  # - :include_skip? - flag indicating whether to include hosts that have
+  #   the SKIP tag set. Default: false i.e. omit hosts tagged with SKIP.
+  def hosttag_lookup(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    return lookup_keys(args, options) if options[:type]
+
+    begin
+      return hosttag_lookup_tags(args, options)
+    rescue => e
+      begin
+        return hosttag_lookup_hosts(args, options)
+      rescue
+        # If both lookups failed, re-raise original error
+        raise e
+      end
+    end
+  end
+
+  # Return an array of all hosts
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :include_skip? - flag indicating whether to include hosts that have
+  #   the SKIP tag set. Default: false i.e. omit hosts tagged with SKIP.
+  def hosttag_all_hosts(options)
+    r = hosttag_server(options)
+    key = r.get_key(options[:include_skip?] ? 'all_hosts_full' : 'all_hosts')
+    $stderr.puts "+ key: #{key}" if options[:debug]
+    return r.smembers(key).sort
+  end
+
+  # Return an array of all tags
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :include_skip? - flag indicating whether to include the SKIP tag.
+  #   Default: false. Included for completeness.
+  def hosttag_all_tags(options)
+    r = hosttag_server(options)
+    key = r.get_key(options[:include_skip?] ? 'all_tags_full' : 'all_tags')
+    $stderr.puts "+ key: #{key}" if options[:debug]
+    return r.smembers(key).sort
+  end
+
+  # Add the given tags to all the given hosts
+  def hosttag_add_tags(hosts, tags, options)
+    r = hosttag_server(options)
+
+    # Add tags to each host
+    skip_host = {}
+    all_hosts_skip_hosts = true
+    hosts.each do |host|
+      key = r.get_key('host', host)
+      tags.each { |tag| r.sadd(key, tag) }
+
+      if r.sismember(key, 'SKIP')
+        skip_host[host] = true
+      else
+        all_hosts_skip_hosts = false
+      end
+
+      # Add to all_hosts sets
+      all_hosts = r.get_key('all_hosts')
+      all_hosts_full = r.get_key('all_hosts_full')
+      # all_hosts shouldn't include SKIP hosts, so those we remove
+      if skip_host[host]
+        r.srem(all_hosts, host)
+      else
+        r.sadd(all_hosts, host)
+      end
+      r.sadd(all_hosts_full, host)
+    end
+
+    # Add hosts to each tag
+    recheck_for_skip = false
+    tags.each do |tag|
+      # If we've added a SKIP tag to these hosts, flag to do some extra work
+      recheck_for_skip = true if tag == 'SKIP'
+
+      key = r.get_key('tag', tag)
+      hosts.each do |host|
+        # The standard case is to add the host to the list for this tag.
+        # But we don't want SKIP hosts being included in these lists, so
+        # for them we actually do a remove to make sure they're omitted.
+        if skip_host[host] and tag != 'SKIP'
+          r.srem(key, host)
+        else
+          r.sadd(key, host)
+        end
+      end
+
+      # Add to all_tags sets
+      all_tags = r.get_key('all_tags')
+      all_tags_full = r.get_key('all_tags_full')
+      r.sadd(all_tags, tag) unless all_hosts_skip_hosts
+      r.sadd(all_tags_full, tag)
+    end
+
+    # If we've added a SKIP tag here, we need to recheck all tags for all skip hosts
+    recheck_skip_change_for_all_tags(skip_host.keys, :add, r) if recheck_for_skip
+  end
+
+  # Delete the given tags from all the given hosts
+  def hosttag_delete_tags(hosts, tags, options)
+    r = hosttag_server(options)
+
+    # Delete tags from each host
+    non_skip_host = {}
+    hosts.each do |host|
+      key = r.get_key('host', host)
+      tags.each { |tag| r.srem(key, tag) }
+
+      if r.sismember(key, 'SKIP')
+        skip_host = true
+      else
+        non_skip_host[host] = true
+      end
+
+      # Delete from all_hosts sets
+      all_hosts = r.get_key('all_hosts')
+      all_hosts_full = r.get_key('all_hosts_full')
+      # If all tags have been deleted, or this is a SKIP host, remove from all_hosts
+      if r.scard(key) == 0 or skip_host
+        r.srem(all_hosts, host)
+      else
+        # NB: we explicitly add here in case we've deleted a SKIP tag
+        r.sadd(all_hosts, host)
+      end
+      if r.scard(key) == 0
+        r.srem(all_hosts_full, host)
+        r.del(key)
+      end
+    end
+
+    # Delete hosts from each tag
+    recheck_for_skip = false
+    all_tags = r.get_key('all_tags')
+    all_tags_full = r.get_key('all_tags_full')
+    tags.each do |tag|
+      # If we've deleted a SKIP tag from these hosts, flag to do some extra work
+      recheck_for_skip = true if tag == 'SKIP'
+
+      tag_key = r.get_key('tag', tag)
+      hosts.each { |host| r.srem(tag_key, host) }
+
+      # Delete from all_tags sets
+      # If all hosts have been deleted (or this is the SKIP tag), remove from all_tags
+      if r.scard(tag_key) == 0 or tag == 'SKIP'
+        r.srem(all_tags, tag)
+      else
+        # NB: we explicitly add here in case we've deleted a SKIP tag
+        r.sadd(all_tags, tag)
+      end
+      if r.scard(tag_key) == 0
+        r.srem(all_tags_full, tag)
+        r.del(tag_key)
+      end
+    end
+    r.del(all_tags) if r.scard(all_tags) == 0
+    r.del(all_tags_full) if r.scard(all_tags_full) == 0
+
+    # If we've deleted a SKIP tag here, we need to recheck all tags for all non-skip hosts
+    recheck_skip_change_for_all_tags(non_skip_host.keys, :delete, r) if recheck_for_skip
+  end
+
+  # Delete all hosts and tags in the hosttag datastore. This is the nuclear option,
+  # used in hosttag_import_from_directory if :delete => true. Interactively confirms
+  # unless the :autoconfirm option is set.
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :autoconfirm - if true, truncate without asking for any confirmation
+  def hosttag_truncate(options)
+    if not options[:autoconfirm]
+      print "Do you really want to delete EVERYTHING from your datastore? [yN] "
+      $stdout.flush
+      confirm = $stdin.gets.chomp
+      return unless confirm =~ %r{^y}i
+    end
+
+    r = hosttag_server(options)
+    r.keys(r.get_key("*")).each { |k| r.del(k) }
+  end
+
+  # Delete all tags from the given hosts. Interactively confirms the deletions
+  # unless the :autoconfirm option is set.
+  # The final argument may be an options hash, which accepts the following
+  # keys:
+  # - :autoconfirm - if true, do deletes without asking for any confirmation
+  def hosttag_delete_all_tags(hosts, options)
+    if not options[:autoconfirm]
+      host_str = hosts.join(' ')
+      print "Do you want to delete all tags on the following host(s):\n  #{host_str}\nConfirm? [yN] "
+      $stdout.flush
+      confirm = $stdin.gets.chomp
+      return unless confirm =~ %r{^y}i
+    end
+
+    hosts.each do |host|
+      begin
+        tags = hosttag_lookup_hosts(host, options)
+        hosttag_delete_tags([ host ], tags, options)
+      rescue
+        warn "Warning: invalid host '#{host}' - cannot delete"
+      end
+    end
+  end
+
+  # Import hosts and tags from the given directory. The directory is
+  # expected to contain a set of directories, representing hosts; each
+  # file within those directories is treated as a tag that applies to
+  # that host.
+  # Options is a hash which accepts the following keys:
+  # - :delete - if true, delete ALL hosts and tags from the datastore
+  #   before doing the import.
+  # - :autoconfirm - if true, don't interactively confirm deletions
+  def hosttag_import_from_directory(datadir, options)
+    # Delete ALL hosts and tags from the datastore if options[:delete] set
+    hosttag_truncate(options) if options[:delete]
+
+    # Load directory into a { host => [ taglist ] } hash
+    host_tag_hash = load_directory(datadir, options)
+
+    # Add all hosts and tags
+    host_tag_hash.each do |host, tags|
+      hosttag_add_tags([ host ], tags, options)
+    end
+  end
+
+  private
+
+  # Lookup the given keys in the redis datastore, returning an array of
+  # results. If more than one key is specified, resultsets are merged
+  # (either ANDed or ORed) depending on the value of the :rel option.
+  # The final argument must be an options hash, which accepts the
+  # following options:
+  # - :type - specifies the type of keys to lookup, either :host or :tag.
+  #   Required.
+  # - :rel - specifies how to merge multiple resultsets, either :and (set
+  #   intersection) or :or (set union).
+  def lookup_keys(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    args.flatten!
+
+    type = options[:type]
+    throw "Required option 'type' missing" if not type
+    rel = options[:rel]
+
+    r = hosttag_server(options)
+
+    # Default a rel if we have multiple args
+    if args.length > 1 and not rel
+      rel = (type == :tag ? :and : :or)
+    end
+    $stderr.puts "+ rel (#{type}): #{rel}" if rel and options[:debug]
+
+    # Map keys to fetch
+    keys = args.collect {|v| r.get_key(type, v) }
+    $stderr.puts "+ keys: #{keys.join(' ')}" if options[:debug]
+
+    # Check all keys exist
+    keys.each do |k|
+      if not r.exists(k)
+        item = k.sub(%r{^[^:]+::[^:]+:}, '')
+        raise "Error: #{type} '#{item}' not found."
+      end
+    end
+
+    # Lookup and return
+    if keys.length == 1
+      r.smembers(keys[0]).sort
+    elsif rel == :and
+      r.sinter(*keys).sort
+    else
+      r.sunion(*keys).sort
+    end
+  end
+
+  # If we've added or removed a SKIP tag, we now have to recheck all tags for
+  # the given hosts, removing or re-adding them from/to those tag sets, and
+  # then recalculate the all_tags set for each of those tags
+  def recheck_skip_change_for_all_tags(hosts, change, r)
+    recheck_tags = {}
+    hosts.each do |host|
+      host_key = r.get_key('host', host)
+      r.smembers(host_key).each do |tag|
+        next if tag == 'SKIP'
+
+        tag_key = r.get_key('tag', tag)
+        # If we've added SKIP tags, then we remove the host from tagsets
+        # (or vice-versa)
+        if change == :add
+          r.srem(tag_key, host)
+        else
+          r.sadd(tag_key, host)
+        end
+
+        recheck_tags[tag] = tag_key
+      end
+    end
+
+    # Now recheck the all_tags set, adding tags that have hosts, and
+    # removing any that don't
+    all_tags = r.get_key('all_tags')
+    recheck_tags.each do |tag, tag_key|
+      tag_host_count = r.scard(tag_key)
+      if tag_host_count == 0
+        r.srem(all_tags, tag)
+      else
+        r.sadd(all_tags, tag)
+      end
+    end
+    r.del(all_tags) if r.scard(all_tags) == 0
+  end
+
+  # Load all host/tag files in datadir, returning a { host => [ taglist ] } hash
+  def load_directory(datadir, options)
+    host_tag_hash = {}
+
+    Dir.glob("#{datadir}/*").each do |host_path|
+      next if not File.directory?(host_path)
+      host = host_path.sub(/^#{datadir}\//, '')
+
+      host_tag_hash[host] = []
+      Dir.glob("#{host_path}/*").each do |tag_path|
+        next if not File.file?(tag_path)
+        tag = File.basename(tag_path)
+        host_tag_hash[host].push(tag)
+      end
+    end
+
+    return host_tag_hash
+  end
+
+  def die(error)
+    warn error
+    exit 1
+  end
+
+  def hosttag_server(options)
+    begin
+      r = Hosttag::Server.new(options)
+    rescue Resolv::ResolvError => e
+      die e
+    end
+  end
+
+end