Class: RakeServer::Server

Inherits:
EventMachine::Connection
  • Object
show all
Includes:
EventMachine::Protocols::ObjectProtocol
Defined in:
lib/rake_server/server.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.after_fork(&block) ⇒ Object 



98
99
100
 
# File 'lib/rake_server/server.rb', line 98

def after_fork(&block)
  @after_fork = block
end

.before_fork(&block) ⇒ Object 



94
95
96
 
# File 'lib/rake_server/server.rb', line 94

def before_fork(&block)
  @before_fork = block
end

.run(eager_tasks, options = {}, &block) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/rake_server/server.rb', line 80

def run(eager_tasks, options = {}, &block)
  options = DEFAULT_OPTIONS.merge(options)
  EventMachine.run do
    Rake.application.init
    Rake.application.load_rakefile
    eager_tasks.each { |task| Rake.application[task].invoke }
    EventMachine.start_server(options[:host], options[:port], self)
    unless options[:quiet]
      puts "rake-server listening on #{options[:host]}:#{options[:port]}"
    end
    block.call if block
  end
end

.run_after_fork ⇒ Object 



106
107
108
 
# File 'lib/rake_server/server.rb', line 106

def run_after_fork
  @after_fork.call if @after_fork
end

.run_before_fork ⇒ Object 



102
103
104
 
# File 'lib/rake_server/server.rb', line 102

def run_before_fork
  @before_fork.call if @before_fork
end

.start(eager_tasks, options = {}) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/rake_server/server.rb', line 15

def start(eager_tasks, options = {})
  pid_file = File.join(pid_dir(options), "rake-server.pid")
  if File.exist?(pid_file)
    running_pid = IO.read(pid_file).to_i
    begin
      Process.kill(0, running_pid)
      raise "rake-server is already running on PID #{running_pid}"
    rescue Errno::ESRCH
      STDERR.puts("Cleaning stale PID file at #{pid_file}")
      FileUtils.rm_f(pid_file)
    end
  end
  read, write = IO.pipe
  tmp_pid = fork do
    read.close
    fork do
      Process.setsid
      begin
        run(eager_tasks, options) do
          write.write(Process.pid.to_s)
          write.close
          STDIN.reopen('/dev/null')
          STDOUT.reopen('/dev/null')
          STDERR.reopen(STDOUT)
        end
      rescue => e
        write.write(e.message)
      end
    end
    write.close
  end
  write.close
  status = read.read
  if status =~ /^\d+/ then pid = status.to_i
  else raise(status)
  end
  File.open(pid_file, 'w') { |f| f << pid }
  read.close
  Process.waitpid(tmp_pid)
end

.stop(options = {}) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/rake_server/server.rb', line 56

def stop(options = {})
  if File.exist?(pid_file = File.join(pid_dir(options), "rake-server.pid"))
    pid = IO.read(pid_file).to_i
    pgid = Process.getpgid(pid)
    begin
      Process.kill("TERM", -pgid)
      begin
        loop do
          Process.kill(0, pid)
          sleep(0.1)
        end
      rescue Errno::ESRCH
        # Process is dead
      end
    rescue Errno::ESRCH
      STDERR.puts("No rake-server process running at PID #{pid}")
      # No worries
    end
    FileUtils.rm(pid_file)
  else
    STDERR.puts("No PIDfile at #{pid_file}")
  end
end

Instance Method Details

#receive_object(message) ⇒ Object 



121
122
123
124
125
126
127
128
129
 
# File 'lib/rake_server/server.rb', line 121

def receive_object(message)
  begin
    tasks = message.tasks.map { |task| Rake.application[task.to_sym] }
    pid = fork_and_run_tasks(tasks, message.env || {})
  rescue => e
    send_object("ERR #{e.message}\n")
    send_object(nil)
  end
end