ghost 0.3.0 → 1.0.0.pre

data/lib/ghost/cli/task/list.rb

@@ -0,0 +1,40 @@
+Ghost::Cli.task :list do
+  desc "Show all (or a filtered) list of hosts"
+  def perform(filter = nil)
+    hosts = get_hosts(filter)
+
+    puts "Listing #{hosts.size} host(s):"
+
+    pad = hosts.map {|h| h.name.length }.max
+    hosts.each do |host|
+      puts "#{host.name.rjust(pad + 2)} -> #{host.ip}"
+    end
+  end
+
+  help do
+    <<-EOF.unindent
+    Usage: ghost list [<regex>]
+
+    #{desc}.
+
+    If no regular expression is provided, a summary of all hosts is
+    shown. If a regular expression is provided, only hosts whose
+    host names match the regular expression are listed.
+
+    Examples:
+      ghost list                # will list every host name
+      ghost list /^fo+\\.com$/  # will list fo.com, fooooo.com, etc.
+    EOF
+  end
+
+  private
+
+  def get_hosts(filter)
+    hosts = if filter
+      filter = $1 if filter =~ %r|^/(.*)/$|
+      Ghost.store.find(/#{filter}/i)
+    else
+      Ghost.store.all
+    end
+  end
+end

data/lib/ghost/host.rb

@@ -0,0 +1,34 @@
+require 'socket'
+
+module Ghost
+  class Host < Struct.new(:name, :ip)
+    class NotResolvable < Exception; end
+
+    alias :to_s :name
+    alias :host :name
+    alias :hostname :name
+    alias :ip_address :ip
+
+    def initialize(host, ip = "127.0.0.1")
+      super(host, resolve_ip(ip))
+    end
+
+    def <=>(host)
+      if ip == host.ip
+        name <=> host.name
+      else
+        ip <=> host.ip
+      end
+    end
+
+    def match(name)
+      host.match(name)
+    end
+
+    def resolve_ip(ip_or_hostname)
+      IPSocket.getaddress(ip_or_hostname)
+    rescue SocketError
+      raise Ghost::Host::NotResolvable, "#{ip_or_hostname} is not resolvable."
+    end
+  end
+end

data/lib/ghost/store.rb

@@ -0,0 +1,12 @@
+module Ghost
+  class << self
+    attr_accessor :store
+  end
+end
+
+
+require 'ghost/store/hosts_file_store'
+Ghost.store = Ghost::Store::HostsFileStore.new
+
+# TODO: only load on OS X and make it default when compatible
+require 'ghost/store/dscl_store'

data/lib/ghost/store/dscl_store.rb

@@ -0,0 +1,71 @@
+require 'ghost/host'
+require 'set'
+
+module Ghost
+  module Store
+    class DsclStore
+      class Dscl
+        class << self
+          def list(domain)
+            `dscl % -readall /Local/Default/Hosts 2>&1` % domain
+          end
+
+          # TODO is shell injection a concern here?
+          def read(domain, host)
+            `dscl % -read /Local/Default/Hosts/%s 2>&1` % [domain, host]
+          end
+
+          def create(domain, host, ip)
+            `dscl % -create /Local/Default/Hosts/%s IPAddress %s 2>&1` % [domain, host, ip]
+          end
+
+          def delete(domain, host)
+            `dscl % -delete /Local/Default/Hosts/%s 2>&1` % [domain, host]
+          end
+        end
+      end
+
+      attr_accessor :domain
+
+      def initialize(domain = "localhost")
+        self.domain = domain
+      end
+
+      def add(host)
+        Dscl.create(domain, host.name, host.ip)
+        true
+      end
+
+      def all
+        Dscl.list(domain).map do |host|
+          name = host.scan(/^RecordName: (.+)$/).flatten.first
+          ip   = host.scan(/^IPAddress: (.+)$/).flatten.first
+
+          Ghost::Host.new(name, ip)
+        end
+      end
+
+      def find(regex)
+        all.select { |h| h.name =~ regex }
+      end
+
+      def delete(host)
+        result = SortedSet.new
+
+        all.each do |existing_host|
+          next unless host.match(existing_host.name)
+          next if host.respond_to?(:ip) && host.ip != existing_host.ip
+
+          Dscl.delete(domain, existing_host.name)
+          result << existing_host
+        end
+
+        result.to_a
+      end
+
+      def empty
+        all.each { |host| Dscl.delete(domain, host.name) }
+      end
+    end
+  end
+end

data/lib/ghost/store/hosts_file_store.rb

@@ -0,0 +1,123 @@
+require 'set'
+
+require 'ghost/host'
+require 'ghost/tokenized_file'
+
+module Ghost
+  module Store
+    # TODO: A lot of this duplicates Resolv::Hosts in Ruby stdlib.
+    #       Can that be modifiied to use tokens in place of this?
+    class HostsFileStore
+      attr_accessor :path, :file
+
+      # TODO: Support windows locations:
+      #   Windows 95/98/Me  c:\windows\hosts
+      #   Windows NT/2000/XP Pro  c:\winnt\system32\drivers\etc\hosts
+      #   Windows XP Home c:\windows\system32\drivers\etc\hosts
+      def initialize(path = "/etc/hosts")
+        self.path = path
+        self.file = Ghost::TokenizedFile.new(path, "# ghost start", "# ghost end")
+      end
+
+      def add(host)
+        sync do |buffer|
+          buffer[host.ip] << host.name
+          buffer_changed!
+        end
+
+        true
+      end
+
+      def all
+        sync do |buffer|
+          buffer.map do |ip, hosts|
+            hosts.map { |h| Ghost::Host.new(h, ip) }
+          end.flatten.sort
+        end
+      end
+
+      def find(filter)
+        all.select { |host| host.name =~ filter }
+      end
+
+      def delete(host)
+        result = SortedSet.new
+        sync do |buffer|
+          buffer.each do |ip, names|
+            names.dup.each do |name|
+              next unless host.match(name)
+              next if host.respond_to?(:ip) && host.ip != ip
+
+              result << Ghost::Host.new(name, ip)
+              names.delete(name)
+              buffer_changed!
+            end
+          end
+        end
+        result.to_a
+      end
+
+      def empty
+        result = false
+        sync do |buffer|
+          unless buffer.empty?
+            result = true
+            buffer.replace({})
+            buffer_changed!
+          end
+        end
+        result
+      end
+
+      private # TODO: Add buffer management code to new class
+
+      def buffer_changed?
+        @buffer_changed
+      end
+
+      def buffer_changed!
+        @buffer_changed = true
+      end
+
+      def with_buffer
+        @buffer_changed = false
+        yield(Hash.new { |hash, key| hash[key] = SortedSet.new })
+      end
+
+      def parse_into_buffer(lines, buffer)
+        lines.split($/).each do |line|
+          ip, hosts = *line.scan(/^\s*([^\s]+)\s+([^#]*)/).first
+
+          return unless ip and hosts
+
+          hosts.split(/\s+/).each do |host|
+            buffer[ip] << host
+          end
+        end
+      end
+
+      def sync
+        result = nil
+
+        with_buffer do |buffer|
+          parse_into_buffer(file.read, buffer)
+          result = yield(buffer)
+          file.write(content(buffer)) if buffer_changed?
+        end
+
+        result
+      end
+
+      def content(buffer)
+        ips   = buffer.keys.sort
+        lines = ips.map do |ip|
+          unless (hosts = buffer[ip]).empty?
+            "#{ip} #{buffer[ip].to_a.join(" ")}"
+          end
+        end
+
+        lines.compact.join($/)
+      end
+    end
+  end
+end

data/lib/ghost/tokenized_file.rb

@@ -0,0 +1,65 @@
+module Ghost
+  # TODO: make it not necessarily line-based tokenization
+  # TODO: make it delegate or inherit from File/IO/StringIO to allow it to be a
+  #       drop-in to things expecting an IO.
+  #         - Allow consumer to manipulate a real IO, and sync the contents
+  #           into the real file between the tokens?
+  # TODO: make this it's own gem/library. This has nothing to do (specifically)
+  #       with hosts file management
+  class TokenizedFile
+    attr_accessor :path, :start_token, :end_token
+
+    def initialize(path, start_token, end_token)
+      self.path        = path
+      self.start_token = start_token
+      self.end_token   = end_token
+    end
+
+    def read
+      read_capturing
+    end
+
+    def write(content)
+      existing_lines = []
+
+      # TODO: how to do this without closing the file so
+      #       we can reopen with write mode and maintain a
+      #       lock
+      read_capturing { |line| existing_lines << line}
+
+      # TODO: lock file
+      File.open(path, 'w') do |file|
+        file.puts(existing_lines)
+
+        unless content.nil? || content.empty?
+          file.puts(start_token)
+          file.puts(content)
+          file.puts(end_token)
+        end
+      end
+    end
+
+    private
+
+    def read_capturing
+      between_tokens = false
+      lines = []
+
+      File.open(path, 'r') do |file|
+        file.each_line do |line|
+          if line =~ /^#{start_token}\s*$/
+            between_tokens = true
+          elsif line =~ /^#{end_token}\s*$/
+            between_tokens = false
+          elsif between_tokens
+            lines << line
+          else
+            yield(line) if block_given?
+          end
+        end
+      end
+
+      lines.join
+    end
+  end
+end

data/lib/ghost/version.rb

@@ -0,0 +1,3 @@
+module Ghost
+  VERSION = "1.0.0.pre"
+end

data/spec/ghost/cli/task/add_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  # FIXME: these are petty silly tests to have. Find a nice way to check
+  # that documentation is accessible and printable for all meaninful tests
+  # but don't test actual contents...
+  describe "help add" do
+    specify do
+      ghost("help add").should == <<-EOF.unindent
+        Usage: ghost add <local host name> [<remote host name>|<IP address>]
+
+        Add a host.
+
+        If a second parameter is not provided, it defaults to 127.0.0.1
+
+        Examples:
+          ghost add my-localhost          # points to 127.0.0.1
+          ghost add google.dev google.com # points to the IP of google.com
+          ghost add router 192.168.1.1    # points to 192.168.1.1
+        EOF
+    end
+  end
+
+  describe "add" do
+    context "with a local hostname" do
+      let(:host) { Ghost::Host.new("my-app.local") }
+
+      it "adds the host pointing to 127.0.0.1" do
+        ghost("add my-app.local")
+        store.all.should include(Ghost::Host.new("my-app.local", "127.0.0.1"))
+      end
+
+      it "outputs a summary of the operation" do
+        ghost("add my-app.local").should == "[Adding] my-app.local -> 127.0.0.1\n"
+      end
+
+      context "when an entry for that hostname already exists" do
+        it "outputs an error message"
+      end
+
+      context "and an IP address" do
+        let(:host) { Ghost::Host.new("my-app.local", "192.168.1.1") }
+
+        it "adds the host pointing to the IP address" do
+          ghost("add my-app.local 192.168.1.1")
+          store.all.should include(Ghost::Host.new("my-app.local", "192.168.1.1"))
+        end
+
+        it "outputs a summary of the operation" do
+          ghost("add my-app.local 192.168.1.1").should == "[Adding] my-app.local -> 192.168.1.1\n"
+        end
+      end
+
+      context "and a remote hostname" do
+        # TODO: replace this stub once DNS resolution works
+        let(:host) { Ghost::Host.new("my-app.local", "google.com") }
+        before { Ghost::Host.any_instance.stub(:resolve_ip => "74.125.225.99") }
+
+        it "adds the host pointing to the IP address" do
+          ghost("add my-app.local google.com")
+          store.all.should include(host)
+        end
+
+        it "outputs a summary of the operation" do
+          ghost("add my-app.local google.com").should ==
+            "[Adding] my-app.local -> 74.125.225.99\n"
+        end
+
+        context "when the remote hostname can not be resolved" do
+          before { Ghost::Host.stub(:new).and_raise(Ghost::Host::NotResolvable) }
+
+          it "outputs an error message" do
+            ghost("add my-app.local google.com").should == "Unable to resolve IP address for target host \"google.com\".\n"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ghost/cli/task/delete_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  describe "delete" do
+    context 'with filtering pattern' do
+      it 'deletes only entries whose hostname matches the pattern' do
+        store.should_receive(:delete).with(/fo*.com?/i)
+        ghost("delete /fo*.com?/")
+      end
+    end
+
+    context 'without filtering pattern' do
+      it 'deletes the specified hostname' do
+        store.should_receive(:delete).with('foo.com')
+        ghost("delete foo.com")
+      end
+    end
+  end
+end