start_transaction (Merb::BootLoader::LoadClasses)

    # File lib/merb-core/bootloader.rb, line 687
        def start_transaction
          Merb.logger.warn! "Parent pid: #{Process.pid}"
          reader, writer = nil, nil

          if GC.respond_to?(:copy_on_write_friendly=)
            GC.copy_on_write_friendly = true
          end

          loop do
            # create two connected endpoints
            # we use them for master/workers communication
            reader, @writer = IO.pipe
            pid = Kernel.fork

            # pid means we're in the parent; only stay in the loop if that is case
            break unless pid
            # writer must be closed so reader can generate EOF condition
            @writer.close

            # master process stores pid to merb.main.pid
            Merb::Server.store_pid("main") if Merb::Config[:daemonize] || Merb::Config[:cluster]

            if Merb::Config[:console_trap]
              Merb.trap("INT") {}
            else
              # send ABRT to worker on INT
              Merb.trap("INT") do
                Merb.logger.warn! "Reaping Workers"
                begin
                  Process.kill(reap_workers_signal, pid)
                rescue SystemCallError
                end
                exit_gracefully
              end
            end

            Merb.trap("HUP") do
              Merb.logger.warn! "Doing a fast deploy\n"
              Process.kill("HUP", pid)
            end

            reader_ary = [reader]
            loop do
              # wait for worker to exit and capture exit status
              #
              #
              # WNOHANG specifies that wait2 exists without waiting
              # if no worker processes are ready to be noticed.
              if exit_status = Process.wait2(pid, Process::WNOHANG)
                # wait2 returns a 2-tuple of process id and exit
                # status.
                #
                # We do not care about specific pid here.
                exit_status[1] && exit_status[1].exitstatus == 128 ? break : exit
              end
              # wait for data to become available, timeout in 0.25 of a second
              if select(reader_ary, nil, nil, 0.25)
                begin
                  # no open writers
                  next if reader.eof?
                  msg = reader.readline
                  if msg =~ /128/
                    Process.detach(pid)
                    break
                  else
                    exit_gracefully
                  end
                rescue SystemCallError
                  exit_gracefully
                end
              end
            end
          end

          reader.close

          # add traps to the worker
          if Merb::Config[:console_trap]
            Merb::Server.add_irb_trap
            at_exit { reap_workers }
          else
            Merb.trap('INT') do
              Merb::BootLoader.before_worker_shutdown_callbacks.each { |cb| cb.call }
            end
            Merb.trap('ABRT') { reap_workers }
            Merb.trap('HUP') { reap_workers(128, "ABRT") }
          end
        end