ghost 0.3.0 → 1.0.0.pre

data/lib/ghost/linux-host.rb

@@ -1,158 +0,0 @@
-require 'socket'
-
-module Ghost
-  class Host
-
-    attr_reader :host, :ip
-
-    def initialize(host, ip)
-      @host = host
-      @ip = ip
-    end
-
-    def ==(other)
-      @host == other.host && @ip = other.ip
-    end
-
-    alias :to_s :host
-    alias :name :host
-    alias :hostname :host
-
-    @@hosts_file = '/etc/hosts'
-    @@start_token, @@end_token = '# ghost start', '# ghost end'
-
-    class << self
-      protected :new
-
-      def list
-        with_exclusive_file_access(true) do |file|
-          entries = []
-          in_ghost_area = false
-          file.pos = 0
-
-          file.each do |line|
-            if !in_ghost_area and line =~ /^#{@@start_token}/
-              in_ghost_area = true
-            elsif in_ghost_area
-              if line =~ /^#{@@end_token}/o
-                in_ghost_area = false
-              elsif line =~ /^(\d+\.\d+\.\d+\.\d+)\s+(.*)$/
-                ip = $1
-                hosts = $2.split(/\s+/)
-                hosts.each { |host| entries << Host.new(host, ip) }
-              end
-            end
-          end
-
-          entries
-        end
-      end
-
-      def add(host, ip = "127.0.0.1", force = false)
-        with_exclusive_file_access do
-          if find_by_host(host).nil? || force
-            hosts = list
-            hosts = hosts.delete_if { |h| h.name == host }
-
-            unless ip[/^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/]
-              ip = Socket.gethostbyname(ip)[3].bytes.to_a.join('.')
-            end
-
-            new_host = Host.new(host, ip)
-
-            hosts << new_host
-            write_out!(hosts)
-
-            new_host
-          else
-            raise Ghost::RecordExists, "Can not overwrite existing record"
-          end
-        end
-      end
-
-      def find_by_host(hostname)
-        list.find { |host| host.hostname == hostname }
-      end
-
-      def find_by_ip(ip)
-        list.find_all{ |host| host.ip == ip }
-      end
-
-      def empty!
-        write_out!([])
-      end
-
-      def delete(name)
-        with_exclusive_file_access do
-          hosts = list
-          hosts = hosts.delete_if { |host| host.name == name }
-          write_out!(hosts)
-        end
-      end
-
-      def delete_matching(pattern)
-        with_exclusive_file_access do
-          pattern = Regexp.escape(pattern)
-          hosts = list.select { |host| host.name.match(/#{pattern}/) }
-          hosts.each { |host| delete(host.name) }
-          hosts
-        end
-      end
-
-      protected
-
-      def with_exclusive_file_access(read_only = false)
-        return_val = nil
-        flag = read_only ? 'r' : 'r+'
-
-        if @_file
-          return_val = yield @_file
-        else
-          File.open(@@hosts_file, flag) do |f|
-            f.flock File::LOCK_EX
-            begin
-              @_file = f
-              return_val = yield f
-            ensure
-              @_file = nil
-            end
-          end
-        end
-
-        return_val
-      end
-
-      def write_out!(hosts)
-        with_exclusive_file_access do |f|
-          new_ghosts = hosts.inject("") {|s, h| s + "#{h.ip} #{h.hostname}\n" }
-
-          output = ""
-          in_ghost_area, seen_tokens = false,false
-          f.pos = 0
-
-          f.each do |line|
-            if line =~ /^#{@@start_token}/o
-              in_ghost_area, seen_tokens = true,true
-              output << line << new_ghosts
-            elsif line =~ /^#{@@end_token}/o
-              in_ghost_area = false
-            end
-            output << line unless in_ghost_area
-          end
-          if !seen_tokens
-            output << surround_with_tokens( new_ghosts )
-          end
-
-          f.pos = 0
-          f.print output
-          f.truncate(f.pos)
-        end
-      end
-
-
-      def surround_with_tokens(str)
-        "\n#{@@start_token}\n#{str}#{@@end_token}\n"
-      end
-    end
-  end
-end

data/lib/ghost/mac-host.rb

@@ -1,116 +0,0 @@
-require 'socket'
-
-module Ghost
-  class Host
-    ListCmd   = "dscl localhost -list /Local/Default/Hosts 2>&1"
-    ReadCmd   = "dscl localhost -read /Local/Default/Hosts/%s 2>&1"
-    CreateCmd = "dscl localhost -create /Local/Default/Hosts/%s IPAddress %s 2>&1"
-    DeleteCmd = "dscl localhost -delete /Local/Default/Hosts/%s 2>&1"
-
-    class << self
-      protected :new
-
-      def list
-        list = `#{ListCmd}`
-        list = list.split("\n")
-        list.collect { |host| Host.new(host.chomp) }
-      end
-
-      def add(host, ip = "127.0.0.1", force = false)
-        if find_by_host(host).nil? || force
-          unless ip[/^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/]
-            ip = Socket.gethostbyname(ip)[3].bytes.to_a.join('.')
-          end
-
-          `#{CreateCmd % [host, ip]}`
-          flush!
-          find_by_host(host)
-        else
-          raise Ghost::RecordExists, "Can not overwrite existing record"
-        end
-      end
-
-      def find_by_host(host)
-        @hosts ||= {}
-        @hosts[host] ||= begin
-          output = `#{ReadCmd % host}`
-
-          if output =~ /eDSRecordNotFound/
-            nil
-          else
-            host = parse_host(output)
-            ip = parse_ip(output)
-
-            Host.new(host, ip)
-          end
-        end
-      end
-
-      def find_by_ip(ip)
-        nil
-      end
-
-      def empty!
-        list.each { |h| delete(h) }
-        nil
-      end
-
-      def delete(host)
-        `#{DeleteCmd % host.to_s}`
-        flush!
-      end
-
-      def delete_matching(pattern)
-        pattern = Regexp.escape(pattern)
-        hosts = list.select { |h| h.to_s.match(/#{pattern}/) }
-        hosts.each do |h|
-          delete(h)
-        end
-        flush! unless hosts.empty?
-        hosts
-      end
-
-      # Flushes the DNS Cache
-      def flush!
-        `dscacheutil -flushcache`
-        @hosts = {}
-        true
-      end
-
-      protected
-      def parse_host(output)
-        parse_value(output, 'RecordName')
-      end
-
-      def parse_ip(output)
-        parse_value(output, 'IPAddress')
-      end
-
-      def parse_value(output, key)
-        match = output.match(Regexp.new("^#{key}: (.*)$"))
-        match[1] unless match.nil?
-      end
-    end
-
-    def initialize(host, ip=nil)
-      @host = host
-      @ip = ip
-    end
-
-    def hostname
-      @host
-    end
-    alias :to_s :hostname
-    alias :host :hostname
-    alias :name :hostname
-
-    def ip
-      @ip ||= self.class.send(:parse_ip, dump)
-    end
-
-    private
-    def dump
-      @dump ||= `#{ReadCmd % hostname}`
-    end
-  end
-end

data/lib/ghost/ssh_config.rb

@@ -1,110 +0,0 @@
-module Ghost
-  class SshConfigDuplicateError < StandardError; end
-
-  class SshConfig
-    @@ssh_config = "#{ENV['HOME']}/.ssh/config"
-
-    attr_accessor :host, :hostname, :user, :port
-    alias :to_s :host
-
-    def initialize(host, hostname, user, port)
-      @host = host
-      @hostname = hostname
-      @user = user
-      @port = port
-    end
-
-    class << self
-      protected :new
-
-      def list
-        lines = File.read(@@ssh_config).split("\n")
-
-        entries = []
-        current_entry = []
-
-        lines << ""
-        lines.each do |line|
-          if line.strip.empty?
-            entries << parse(current_entry) if current_entry.any?
-            current_entry = []
-          else
-            current_entry << line
-          end
-        end
-
-        entries
-      end
-
-      def add(args)
-        host = args[:host]
-        hostname = args[:hostname]
-        user = args[:user] || "root"
-        port = args[:port] || "22"
-
-        force = args[:force]
-
-        if find_by_host(host).nil? || force
-          delete(host)
-
-          new_config = SshConfig.new(host, hostname, user, port)
-
-          configs = list
-          configs << new_config
-
-          write(configs)
-
-          new_config
-        else
-          raise SshConfigDuplicateError, "Can not overwrite existing record"
-        end
-      end
-
-      def find_by_host(host)
-        list.find { |c| c.host == host }
-      end
-
-      def empty!
-        write([])
-      end
-
-      def delete(host)
-        configs = list
-        configs = configs.delete_if { |c| c.host == host }
-        write(configs)
-      end
-
-      def write(configs)
-        hosts = []
-
-        configs.sort! { |a,b| a.host <=> b.host }
-        configs.each do |c|
-          hosts << "Host #{c.host}"
-          hosts << "  HostName #{c.hostname}"
-          hosts << "  User #{c.user}" if c.user
-          hosts << "  Port #{c.port}" if c.port
-          hosts << ""
-        end
-
-        File.open(@@ssh_config, 'w') {|f| f.print hosts.join("\n") }
-      end
-
-      def parse(config)
-        host = config.first[/Host (.*)/, 1]
-        config_hash = {}
-
-        config[1..-1].each do |entry|
-          entry.strip!
-          next if entry.empty?
-          key, value = entry.strip.split(" ")
-          config_hash[key.downcase] = value
-        end
-
-        SshConfig.new(host,
-          config_hash['hostname'], config_hash['user'],
-          config_hash['port'])
-      end
-
-    end
-  end
-end

data/spec/etc_hosts_spec.rb

@@ -1,190 +0,0 @@
-require 'ghost/linux-host'
-
-$hosts_file   = File.expand_path(File.join(File.dirname(__FILE__), "etc_hosts"))
-
-describe Ghost::Host do
-  before(:all) do
-    class Ghost::Host
-      @@hosts_file = $hosts_file
-    end
-  end
-  before { `touch #{$hosts_file.inspect}` }
-  after  { `rm -f #{$hosts_file.inspect}` }
-
-  it "has an IP" do
-    hostname = 'ghost-test-hostname.local'
-
-    Ghost::Host.add(hostname)
-    host = Ghost::Host.list.first
-    host.ip.should eql('127.0.0.1')
-
-    Ghost::Host.empty!
-
-    ip = '169.254.23.121'
-    host = Ghost::Host.add(hostname, ip)
-    host.ip.should eql(ip)
-  end
-
-  it "has a hostname" do
-    hostname = 'ghost-test-hostname.local'
-
-    Ghost::Host.add(hostname)
-    host = Ghost::Host.list.first
-    host.hostname.should eql(hostname)
-
-    Ghost::Host.empty!
-
-    ip = '169.254.23.121'
-    Ghost::Host.add(hostname, ip)
-    host.hostname.should eql(hostname)
-  end
-
-  describe ".list" do
-    it "returns an array" do
-      Ghost::Host.list.should be_instance_of(Array)
-    end
-
-    it "contains instances of Ghost::Host" do
-      Ghost::Host.add('ghost-test-hostname.local')
-      Ghost::Host.list.first.should be_instance_of(Ghost::Host)
-    end
-
-    it "gets all hosts on a single /etc/hosts line" do
-      example = <<-EoEx
-              127.0.0.1      localhost.localdomain
-              # ghost start
-                 123.123.123.1     project_a.local\t\tproject_b.local   project_c.local
-                 127.0.0.1         local.bb
-              # ghost end
-      EoEx
-      File.open($hosts_file, 'w') {|f| f << example.gsub!(/^\s*/, '')}
-      hosts = Ghost::Host.list
-      hosts.should have(4).items
-      hosts.map{|h|h.ip}.uniq.sort.should == ['123.123.123.1', '127.0.0.1']
-      hosts.map{|h|h.host}.sort.should == %w[local.bb project_a.local project_b.local project_c.local]
-
-      Ghost::Host.add("project_d.local")
-      Ghost::Host.list.should have(5).items
-    end
-  end
-
-
-  it "does not change hosts files outside of control tokens" do
-    f = File.open($hosts_file, 'w')
-    f.write "10.0.0.23 adserver.example.com\n"
-    f.close
-    hosts = Ghost::Host.list
-    hosts.should have(0).items
-
-    hostname = "ghost-test-hostname-b.local"
-    Ghost::Host.add(hostname)
-    Ghost::Host.list.should have(1).items
-
-    hostsfile = File.read($hosts_file)
-    hostsfile.should =~ /^10.0.0.23 adserver.example.com\n/
-  end
-
-  it "adds control tokens to untouched hosts files" do
-    f = File.open($hosts_file, 'w')
-    f.write "10.0.0.23 adserver.example.com\n"
-    f.close
-    hostname = "ghost-test-hostname-b.local"
-    ip = '123.45.67.89'
-    Ghost::Host.add(hostname, ip)
-
-    hostsfile = File.read($hosts_file)
-    hostsfile.should =~ /# ghost start\n#{ip}\s+#{hostname}\n# ghost end/
-  end
-
-  describe "#to_s" do
-    it "returns hostname" do
-      hostname = 'ghost-test-hostname.local'
-
-      Ghost::Host.add(hostname)
-      host = Ghost::Host.list.first
-      host.to_s.should eql(hostname)
-    end
-  end
-
-  describe "finder methods" do
-    before do
-      Ghost::Host.add('abc.local')
-      Ghost::Host.add('def.local')
-      Ghost::Host.add('efg.local', '10.2.2.4')
-    end
-
-    it "returns valid Ghost::Host when searching for host name" do
-      Ghost::Host.find_by_host('abc.local').should be_instance_of(Ghost::Host)
-    end
-  end
-
-  describe ".add" do
-    it "returns Ghost::Host object when passed hostname" do
-      Ghost::Host.add('ghost-test-hostname.local').should be_instance_of(Ghost::Host)
-    end
-
-    it "returns Ghost::Host object when passed hostname" do
-      Ghost::Host.add('ghost-test-hostname.local', '10.0.0.2').should be_instance_of(Ghost::Host)
-    end
-
-    it "raises error if hostname already exists and not add a duplicate" do
-      Ghost::Host.empty!
-      Ghost::Host.add('ghost-test-hostname.local')
-      lambda { Ghost::Host.add('ghost-test-hostname.local') }.should raise_error
-      Ghost::Host.list.should have(1).thing
-    end
-
-    it "overwrites existing hostname if forced" do
-      hostname = 'ghost-test-hostname.local'
-
-      Ghost::Host.empty!
-      Ghost::Host.add(hostname)
-
-      Ghost::Host.list.first.hostname.should eql(hostname)
-      Ghost::Host.list.first.ip.should eql('127.0.0.1')
-
-      Ghost::Host.add(hostname, '10.0.0.1', true)
-      Ghost::Host.list.first.hostname.should eql(hostname)
-      Ghost::Host.list.first.ip.should eql('10.0.0.1')
-
-      Ghost::Host.list.should have(1).thing
-    end
-
-    it "should add a hostname using second hostname's ip" do
-      hostname = 'ghost-test-hostname.local'
-      alias_hostname = 'ghost-test-alias-hostname.local'
-
-      Ghost::Host.empty!
-
-      Ghost::Host.add(hostname)
-      Ghost::Host.add(alias_hostname, hostname)
-
-      Ghost::Host.list.last.ip.should eql(Ghost::Host.list.first.ip)
-    end
-
-    it "should raise SocketError if it can't find hostname's ip" do
-      Ghost::Host.empty!
-      lambda { Ghost::Host.add('ghost-test-alias-hostname.google', 'google') }.should raise_error(SocketError)
-    end
-  end
-
-  describe ".empty!" do
-    it "empties the hostnames" do
-      Ghost::Host.add('ghost-test-hostname.local') # add a hostname to be sure
-      Ghost::Host.empty!
-      Ghost::Host.list.should have(0).things
-    end
-  end
-
-  describe ".delete_matching" do
-    it "deletes matching hostnames" do
-      keep = 'ghost-test-hostname-keep.local'
-      Ghost::Host.add(keep)
-      Ghost::Host.add('ghost-test-hostname-match1.local')
-      Ghost::Host.add('ghost-test-hostname-match2.local')
-      Ghost::Host.delete_matching('match')
-      Ghost::Host.list.should have(1).thing
-      Ghost::Host.list.first.hostname.should eql(keep)
-    end
-  end
-end