hubeye 0.3.3 → 0.3.5

data/lib/hubeye/server/server.rb

@@ -1,6 +1,14 @@
 require "hubeye/shared/hubeye_protocol"
 require "hubeye/log/logger"
 require "hubeye/helpers/time"
+require "hubeye/config/parser"
+require "hubeye/notification/finder"
+require "hubeye/hooks/command"
+require "hubeye/hooks/git"
+
+require File.expand_path("../strategies/decision", __FILE__)
+require File.expand_path("../tracker", __FILE__)
+require File.expand_path("../session", __FILE__)
 
 include Hubeye::Helpers::Time
 include Hubeye::Log
@@ -8,20 +16,7 @@ include Hubeye::Log
 module Hubeye
   module Server
     attr_accessor :remote_connection
-    attr_reader :socket, :sockets, :session, :daemonized
-
-    require 'yaml'
-    require 'json'
-    require 'open-uri'
-    require 'forwardable'
-
-    require_relative "commit"
-    require_relative "session"
-
-    require "hubeye/config/parser"
-    require "hubeye/notification/finder"
-    require "hubeye/hooks/git_hooks"
-    require "hubeye/hooks/executer"
+    attr_reader :socket, :sockets, :tracker, :session, :daemonized
 
     CONFIG_FILE = File.join(ENV['HOME'], ".hubeye", "hubeyerc")
     CONFIG = {}
@@ -61,495 +56,57 @@ module Hubeye
     end
 
     if CONFIG[:notification_wanted]
-      CONFIG[:desktop_notification] =
-        Notification::Finder.find_notify
-    end
-
-    class Exit
-      def call
-        socket = server.socket
-        session = server.session
-        socket.deliver "Bye!"
-        # mark the session as continuous to not wipe the log file
-        session.continuous = true
-        Logger.log "Closing connection to #{socket.peeraddr[2]}"
-        server.remote_connection = false
-        unless session.tracker.empty?
-          Logger.log "Tracking: #{session.tracker.keys.join ', '}"
-        end
-        Logger.log ""
-        server.sockets.delete(socket)
-        socket.close
-      end
+      CONFIG[:desktop_notification] = Notification::Finder.find_notify
     end
 
-    class Shutdown
-      def call
-        socket = server.socket
-        Logger.log "Closing connection to #{socket.peeraddr[2]}"
-        Logger.log "Shutting down... (#{NOW})"
-        Logger.log ""
-        Logger.log ""
-        socket.deliver "Shutting down server"
-        server.sockets.delete(socket)
-        socket.close
-        unless server.daemonized
-          STDOUT.puts "Shutting down gracefully."
-        end
-        exit 0
-      end
-    end
-
-    class SaveHook
-      def call
-        socket = server.socket
-        hooks = server.session.hooks
-        if !hooks.empty?
-          file = "#{ENV['HOME']}/.hubeye/hooks/#{@matches[2]}.yml"
-          if File.exists? file
-            override?
-          end
-          File.open(file, "w") do |f_out|
-            ::YAML.dump(hooks, f_out)
-          end
-          socket.deliver "Saved hook#{@matches[1]} as #{@matches[2]}"
-        else
-          socket.deliver "No hook#{@matches[1]} to save"
-        end
-      end
-
-      private
-      def override?
-      end
-    end
-
-    class SaveRepo
-      def call
-        socket = server.socket
-        if !server.session.tracker.empty?
-          file = "#{ENV['HOME']}/.hubeye/repos/#{@matches[2]}.yml"
-          if File.exists? file
-            override?
-          end
-          # dump only the repository names, not the shas
-          File.open(file, "w") do |f_out|
-            ::YAML.dump(server.session.tracker.keys, f_out)
-          end
-          socket.deliver "Saved repo#{@matches[1]} as #{@matches[2]}"
-        else
-          socket.deliver "No remote repos are being tracked"
-        end
-      end
-
-      private
-      def override?
-      end
-    end
-
-    class LoadHook
-      def call
-        socket = server.socket
-        if _t = @options[:internal]
-          @silent = _t
-        end
-        hookfile = "#{ENV['HOME']}/.hubeye/hooks/#{@matches[2]}.yml"
-        new_hooks = nil
-        if File.exists?(hookfile)
-          File.open(hookfile) do |f|
-            new_hooks = ::YAML.load(f)
-          end
-          # need to fix this to check if there are already commands for that
-          # repo
-          server.session.hooks.merge!(new_hooks)
-          unless @silent
-            socket.deliver "Loaded #{@matches[1]} #{@matches[2]}"
-          end
-        else
-          unless @silent
-            socket.deliver "No #{@matches[1]} file to load from"
-          end
-        end
-      end
-    end
-
-    class LoadRepo
-      def call
-        socket = server.socket
-        if _t = @options[:internal]
-          @silent = _t
-        end
-        if File.exists?(repo_file = "#{ENV['HOME']}/.hubeye/repos/#{@matches[2]}.yml")
-          new_repos = nil
-          File.open(repo_file) do |f|
-            new_repos = ::YAML.load(f)
-          end
-          if !new_repos
-            socket.deliver "Unable to load #{@matches[2]}: empty file" unless @silent
-            return
-          end
-          new_repos.each do |r|
-            # add the repo name to the hubeye tracker
-            commit = server.track(r)
-            server.session.tracker.add_or_replace!(commit.repo, commit.sha)
-          end
-          unless @silent
-            socket.deliver "Loaded #{@matches[2]}.\nTracking:\n#{server.session.tracker.keys.join ', '}"
-          end
-        else
-          socket.deliver "No file to load from"  unless @silent
-        end
-      end
-    end
-
-    class AddHook
-      def call
-        socket = server.socket
-        cwd   = File.expand_path('.')
-        repo  = @matches[1]
-        _dir  = @matches[3]
-        cmd   = @matches[4]
-        hooks = server.session.hooks
-        if repo.nil? and cmd.nil?
-          socket.deliver "Format: 'hook add user/repo [dir: /my/dir/repo ] cmd: some_cmd'"
-          return
-        end
-        if hooks[repo]
-          _dir ? dir = _dir : dir = cwd
-          if hooks[repo][dir]
-            hooks[repo][dir] << cmd
-          else
-            hooks[repo][dir] = [cmd]
-          end
-        else
-          dir = _dir || cwd
-          hooks[repo] = {dir => [cmd]}
-        end
-        socket.deliver "Hook added"
-      end
-    end
-
-    class ListHooks
-      def call
-        socket = server.socket
-        hooks = server.session.hooks
-        if hooks.empty?
-          socket.deliver "No hooks"
-          return
-        end
-        pwd = File.expand_path('.')
-        format_string = ""
-        hooks.each do |repo, hash|
-          local_dir = nil
-          command = nil
-          hash.each do |dir,cmd|
-            if dir.nil?
-              local_dir = pwd
-              command = cmd.join("\n" + (' ' * 8))
-            else
-              command = cmd
-              local_dir = dir
-            end
-          end
-          format_string << <<EOS
-remote: #{repo}
-dir:    #{local_dir}
-cmds:   #{command}\n
-EOS
-        end
-        socket.deliver format_string
-      end
-    end
-
-    class ListTracking
-      def call
-        socket = server.socket
-        tracker = server.session.tracker
-        output = ''
-        if @options[:details]
-          commit_list = []
-          tracker.keys.each do |repo|
-            commit = server.track(repo, :list => true)
-            commit_list << commit
-          end
-          commit_list.each do |c|
-            output << c.repo + "\n"
-            underline = '=' * c.repo.length
-            output << underline + "\n\n"
-            output << c.commit_message + "\n=> " +
-              c.committer_name + "\n"
-            output << "\n" unless c.repo == commit_list.last.repo
-          end
-        else
-          output << tracker.keys.join(', ')
-        end
-        output = "none" if output.empty?
-        socket.deliver output
-      end
-    end
-
-    class Next
-      def call
-        server.socket.deliver ""
-      end
-    end
-
-    class RmRepo
-      def call
-        socket  = server.socket
-        session = server.session
-        username  = session.username
-        repo_name = session.repo_name
-        m1 = @matches[1]
-        if m1.include?('/')
-          username, repo_name = m1.split('/')
-        else
-          repo_name = m1
-        end
-        full_repo_name = "#{username}/#{repo_name}"
-        rm = session.tracker.delete(full_repo_name)
-        if rm
-          socket.deliver "Stopped watching repository #{full_repo_name}"
-        else
-          socket.deliver "Repository #{full_repo_name} not currently being watched"
-        end
-      end
-    end
-
-    class AddRepo
-      def call
-        session = server.session
-        if @options and @options[:fullpath]
-          session.username, session.repo_name = input.split('/')
-        else
-          session.repo_name = input
-        end
-        add_repo
-      end
-
-      private
-      def add_repo
-        socket = server.socket
-        session = server.session
-        full_repo_name = "#{session.username}/#{session.repo_name}"
-        commit = server.track(full_repo_name, :latest => true)
-        new_sha = commit.sha
-        commit_msg = commit.commit_message
-        committer  = commit.committer_name
-        msg = "#{commit_msg}\n=> #{committer}"
-        change = session.tracker.add_or_replace!(full_repo_name, new_sha)
-        # new repo to track
-        if !change
-          socket.deliver "Repository #{full_repo_name} has not changed"
-          return
-        elsif change[:add]
-          # log the fact that the user added a repo to be tracked
-          Logger.log("Added to tracker: #{full_repo_name} (#{NOW})")
-          # show the user, via the client, the info and commit msg for the commit
-          socket.deliver msg
-        elsif change[:replace]
-          change_msg = "New commit on #{full_repo_name}\n"
-          change_msg << msg
-          socket.deliver change_msg
-          if server.daemonized
-            Logger.log_change(full_repo_name, commit_msg, committer)
-          else
-            Logger.log_change(full_repo_name, commit_msg, committer,
-                              :include_terminal => true)
-          end
-        end
-      end
-    end
-
-    class Strategy
-      attr_reader :server, :input
-
-      UnknownStrategy = Class.new(StandardError)
-      extend Forwardable
-      def_delegator :@server, :socket
-
-      def initialize(server, options={})
-        @server = server
-        opts = {:internal_input => nil}.merge options
-        invalid_input = lambda {
-          @server.remote_connection = false
-          throw(:invalid_input)
-        }
-
-        if !opts[:internal_input]
-          begin
-            @input = socket.read_all
-          rescue => e
-            STDOUT.puts e
-            invalid_input.call
-          end
-          # check if the client pressed ^C or ^D
-          if @input.nil?
-            invalid_input.call
-          end
-        else
-          @input = opts[:internal_input]
-        end
-        @input = @input.strip.downcase
-        @input.gsub! /diiv/, '/'
-      end
-
-      STRATEGY_CLASSES = [ "Shutdown", "Exit", "SaveHook", "SaveRepo",
-        "LoadHook", "LoadRepo", "AddHook", "ListHooks", "ListTracking",
-        "Next", "RmRepo", "AddRepo" ]
-
-      STRATEGY_CLASSES.each do |klass_str|
-        klass = eval "::Hubeye::Server::#{klass_str}"
-        klass.class_eval do
-          extend Forwardable
-          def_delegators :@strategy, :input, :server
-          def initialize matches, strategy, options={}
-            @matches  = matches
-            @strategy = strategy
-            @options  = options
-            call
-          end
-        end
-      end
-
-      # strategy classes
-
-      # STRATEGIES hash
-      # ===============
-      # keys: input matches
-      # OR
-      # lambda {|input| input.something?} => value
-      #
-      # values: lambda {|matchdata, basestrategy| SomeStrategy.new(matchdata, basestrategy)}
-      STRATEGIES = {
-        %r{\Ashutdown\Z} => lambda {|m, s| Shutdown.new(m, s)},
-        %r{\Aquit|exit\Z} => lambda {|m, s| Exit.new(m, s)},
-        %r{\Atracking\s*\Z} => lambda {|m, s| ListTracking.new(m, s)},
-        %r{\Atracking\s*-d\Z} => lambda {|m, s| ListTracking.new(m, s, :details => true)},
-        %r{\A\s*save hook(s?) as (.+)\Z} => lambda {|m, s| SaveHook.new(m, s)},
-        %r{\A\s*save repo(s?) as (.+)\Z} => lambda {|m, s| SaveRepo.new(m, s)},
-        %r{\A\s*load hook(s?) (.+)\Z} => lambda {|m, s| LoadHook.new(m, s)},
-        %r{\A\s*load repo(s?) (.+)\Z} => lambda {|m, s| LoadRepo.new(m, s)},
-        %r{\A\s*internal load hook(s?) (.+)\Z} => lambda {|m, s| LoadHook.new(m, s, :internal => true)},
-        %r{\A\s*internal load repo(s?) (.+)\Z} => lambda {|m, s| LoadRepo.new(m, s, :internal => true)},
-        %r{\Ahook add ([-\w]+/[-\w]+) (dir:\s?(.*))?\s*cmd:\s?(.*)\Z} => lambda {|m, s| AddHook.new(m, s)},
-        %r{\Ahook list\Z} => lambda {|m, s| ListHooks.new(m, s)},
-        %r{^\s*$} => lambda {|m, s| Next.new(m, s)},
-        %r{\Arm ([-\w]+/?[-\w]*)\Z} => lambda {|m, s| RmRepo.new(m, s)},
-        lambda {|inp| inp.include? '/'} => lambda {|m, s| AddRepo.new(m, s, :fullpath => true)},
-        lambda {|inp| not inp.nil?} => lambda {|m, s| AddRepo.new(m, s)}
-      }
-
-      def call
-        STRATEGIES.each do |inp,strat|
-          if inp.respond_to? :match
-            if m = @input.match(inp)
-              return strat.call(m, self)
-            end
-          elsif inp.respond_to? :call
-            if m = inp.call(@input)
-              return strat.call(m, self)
-            end
-          end
-        end
-        raise UnknownStrategy
-      end
-    end # end of Strategy
-
-
+    # main server loop
     def start(port, options={})
       listen(port)
       setup_env(options)
       loop do
-        waiting = catch(:connect) do
-          look_for_changes unless @remote_connection
+        unless @remote_connection
+          look_for_changes
+          client_connect(@sockets)
         end
-        client_connect(@sockets) if waiting
         catch(:invalid_input) do
-          strategy = Strategy.new(self)
-          strategy.call
+          decision = Strategies::Decision.new(self)
+          decision.call_strategy
         end
-        @session.cleanup
+        @session.cleanup!
       end
     end
 
-    #TODO: refactor this into its own class. Getting unwieldy.
-    # The track method closes over a list variable to store recent info on
-    # tracked repositories.
-    # Options: :sha, :latest, :full, :list (all boolean).
-    # The :list => true option gives back the commit object from the list.
-    list = []
-
-    define_method :track do |repo, options={}|
-      if repo.include? '/'
-        username, repo_name = repo.split '/'
-        full_repo_name = repo
-      else
-        username, repo_name = @session.username, repo
-        full_repo_name = "#{username}/#{repo_name}"
-      end
-    unless options[:list]
-      hist = nil
-      begin
-        open "https://api.github.com/repos/#{username}/" \
-        "#{repo_name}/commits" do |f|
-          hist = JSON.parse f.read
-        end
-      rescue
-        @socket.deliver "Not a Github repository name"
-        throw(:invalid_input)
-      end
-      new_info =
-        {full_repo_name =>
-          {'sha' => hist.first['sha'],
-            'commit' =>
-          {'message' => hist.first['commit']['message'],
-            'committer' => {'name' => hist.first['commit']['committer']['name']}
-          }
-          }
-      }
-      commit = Commit.new(new_info)
-      # update the list
-      list.reject! {|cmt| cmt.repo == full_repo_name}
-      list << commit
-    end
-    if options[:full]
-      # unsupported so far
-      raise ArgumentError.new
-    elsif options[:latest]
-      commit.dup
-    elsif options[:list]
-      list.each {|c| return c if c.repo == full_repo_name}
-      nil
-    else
-      Commit.new full_repo_name => {'sha' => hist.first['sha']}
-    end
+    def full_repo_name(repo)
+      return repo if repo.include? '/'
+      [@session.username, repo].join '/'
     end
 
     private
     def listen(port)
-      @server = TCPServer.open(port)
+      @tcp_server = TCPServer.open(port)
     end
 
     def setup_env(options={})
       @remote_connection = false
       @daemonized = options[:daemon]
-      @sockets = [@server]  # An array of sockets we'll monitor
+      @sockets = [@tcp_server]
       trap_signals 'INT', 'KILL'
       @session = Session.new
       @session.username = CONFIG[:username]
+      @tracker = Tracker.new
       unless CONFIG[:default_track].empty?
-        repos = CONFIG[:default_track].dup
+        repos = CONFIG[:default_track]
         repos.each do |repo|
-          commit = track(repo)
-          @session.tracker.add_or_replace! commit.repo => commit.sha
+          repo_name = full_repo_name(repo)
+          @tracker << repo_name
         end
       end
       unless CONFIG[:load_hooks].empty?
-        hooks = CONFIG[:load_hooks].dup
+        hooks = CONFIG[:load_hooks]
         session_load :hooks => hooks
       end
       unless CONFIG[:load_repos].empty?
-        repos = CONFIG[:load_repos].dup
+        repos = CONFIG[:load_repos]
         session_load :repos => repos
       end
     end
@@ -558,7 +115,7 @@ EOS
       sigs.each do |sig|
         trap(sig) do
           @sockets.each {|s| s.close}
-          STDOUT.puts
+          STDOUT.print "\n"
           exit 1
         end
       end
@@ -568,94 +125,88 @@ EOS
       opts = {:hooks => nil, :repos => nil}.merge options
       if hooks = opts[:hooks]
         hooks.each do |h|
-          strat = Strategy.new(self, :internal_input => "internal load hook #{h}")
-          strat.call
+          decision = Strategies::Decision.new(self, :internal_input => "internal load hook #{h}")
+          decision.call_strategy
         end
       elsif repos = opts[:repos]
         repos.each do |r|
-          strat = Strategy.new(self, :internal_input => "internal load repo #{r}")
-          strat.call
+          decision = Strategies::Decision.new(self, :internal_input => "internal load repo #{r}")
+          decision.call_strategy
         end
       else
         raise ArgumentError.new "Must load either hooks or repos"
       end
     end
 
-    #TODO: refactor this ugly, long method into a new class
     def look_for_changes
-      # if no client is connected, and the tracker hash is non-empty
-      if @sockets.size == 1 and !@session.tracker.empty?
-        loop do
-          sleep_amt = CONFIG[:oncearound] / @session.tracker.length
-          @session.tracker.each do |repo,sha|
-            start_time = Time.now
-            commit = track(repo, :latest => true)
-            api_time = (Time.now - start_time).to_i
-            if commit.sha == sha
-              (sleep_amt - api_time).times do
-                sleep 1
-                @remote_connection = client_ready(@sockets) ? true : false
-                throw(:connect, true) if @remote_connection
-              end
-            else
-              # There was a change to a tracked repository.
-              full_repo_name = commit.repo
-              commit_msg     = commit.commit_message
-              committer      = commit.committer_name
-              new_sha        = commit.sha
-              change_msg = "Repo #{full_repo_name} has changed\nNew commit: " \
-                "#{commit_msg}\n=> #{committer}"
-              case CONFIG[:desktop_notification]
-              when "libnotify"
-                Notification::GnomeNotify.notify("Hubeye", change_msg)
-              when "growl"
-                Autotest::Growl.growl("Hubeye", change_msg)
-              when nil
-                unless @daemonized
-                  Logger.log_change(full_repo_name, commit_msg, committer, :include_terminal => true)
-                  already_logged = true
-                end
+      if @tracker.length.zero?
+        @remote_connection = client_ready(@sockets, :block => true)
+      end
+      while not @remote_connection
+        sleep_amt = CONFIG[:oncearound] / @tracker.length
+        @tracker.repo_names.each do |repo_name|
+          change_state = @tracker << repo_name
+          if change_state  == :unchanged
+            (sleep_amt).times do
+              @remote_connection = client_ready(@sockets)
+              return if @remote_connection
+            end
+          else
+            # There was a change to a tracked repository.
+            commit = @tracker.last
+            full_repo_name = commit.repo
+            commit_msg     = commit.message
+            committer      = commit.committer_name
+            new_sha        = commit.sha
+            change_msg = "Repo #{full_repo_name} has changed\nNew commit: " \
+              "#{commit_msg}\n=> #{committer}"
+            case CONFIG[:desktop_notification]
+            when "libnotify"
+              Notification::GnomeNotify.notify("Hubeye", change_msg)
+            when "growl"
+              Autotest::Growl.growl("Hubeye", change_msg)
+            when nil
+              unless @daemonized
+                Logger.log_change(full_repo_name, commit_msg, committer, :include_terminal => true)
+                already_logged = true
               end
-              Logger.log_change(full_repo_name, commit_msg, committer) unless
+            end
+            Logger.log_change(full_repo_name, commit_msg, committer) unless
               already_logged
-              # execute any hooks for that repository
-              unless @session.hooks.empty?
-                if hooks = @session.hooks[full_repo_name]
-                  hooks.each do |dir,cmds|
-                    Hooks::Command.execute(cmds, :directory => dir, :repo => full_repo_name)
-                  end
+            # execute any hooks for that repository
+            unless @session.hooks.empty?
+              if hooks = @session.hooks[full_repo_name]
+                hooks.each do |dir,cmds|
+                  Hooks::Command.execute(cmds, :directory => dir, :repo => full_repo_name)
                 end
               end
-              @session.tracker.add_or_replace!(full_repo_name, new_sha)
             end
           end
-        end # end of loop
-      else
-        @remote_connection = client_ready(@sockets, :block => true) ? true : false
-        throw(:connect, true) if @remote_connection
+        end
       end
     end
 
     def client_ready(sockets, options={})
       if options[:block]
-        select(sockets, nil, nil)
+        r = select(sockets, nil, nil)
       else
-        select(sockets, nil, nil, 1)
+        r = select(sockets, nil, nil, 1)
       end
+      not r.nil?
     end
 
     def client_connect(sockets)
       ready = select(sockets)
       readable = ready[0]
       readable.each do |socket|
-        if socket == @server
-          @socket = @server.accept
-          @socket.sync = false
+        if socket == @tcp_server
+          @socket = @tcp_server.accept
+          @socket.sync = true
           sockets << @socket
           # Inform the client of connection
           basic_inform = "Hubeye running on #{Socket.gethostname} as #{@session.username}"
-          if !@session.tracker.empty?
-            @socket.deliver "#{basic_inform}\nTracking: #{@session.tracker.keys.join ', '}"
+          if !@tracker.empty?
+            @socket.deliver "#{basic_inform}\nTracking: #{@tracker.repo_names.join ', '}"
           else
             @socket.deliver basic_inform
           end
@@ -679,8 +230,5 @@ EOS
         @debug = debug
       end
     end
-
   end # of Server module
-
 end # end of Hubeye module
-