Changeset 275

Show
Ignore:
Timestamp:
12/15/07 03:28:40 (8 months ago)
Author:
gethema..@gmail.com
Message:

check in code that fixes issue with rails environment loading stuff

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/framework/connection.rb

    r217 r275  
    33 
    44module Packet 
    5   class Connection 
    6     # method gets called when connection to external server is completed 
    7     def connection_completed 
    8  
     5  module Connection 
     6    def send_data p_data 
     7      begin 
     8        write_data(p_data,connection) 
     9      rescue DisconnectError => sock_error 
     10        close_connection 
     11      end 
    912    end 
    1013 
    11     # method gets called when external client is disconnected 
    12     def unbind 
    13  
     14    def invoke_init 
     15      @initialized = true 
     16      post_init if respond_to?(:post_init) 
    1417    end 
    1518 
    16     # method gets called just at the beginning of initializing things. 
    17     def post_init 
    18  
     19    def close_connection 
     20      unbind if respond_to?(:unbind) 
     21      reactor.remove_connection(connection) 
    1922    end 
    2023 
    21     def send_data 
    22  
     24    def close_connection_after_writing 
     25      connection.flush 
     26      close_connection 
    2327    end 
    2428 
    25     def ask_worker 
    26  
    27     end 
    28  
    29     def receive_data 
    30  
     29    def send_object p_object 
     30      dump_object(p_object,connection) 
    3131    end 
    3232  end # end of class Connection 

  • trunk/framework/core.rb

    r269 r275  
    6565      def accept_connection(sock_opts) 
    6666        sock_io = sock_opts[:socket] 
    67  
     67        puts "Someone is attempting a connection" 
    6868        begin 
    6969          client_socket,client_sockaddr = sock_io.accept_nonblock 
    …… 
    131131      def start_server(ip,port,t_module,&block) 
    132132        BasicSocket.do_not_reverse_lookup = true 
    133         configure_socket_options 
     133        # configure_socket_options 
    134134        t_socket = TCPServer.new(ip,port.to_i) 
    135         t_socket.setsockopt(*@tcp_defer_accept_opts) rescue nil 
     135        # t_socket.setsockopt(*@tcp_defer_accept_opts) rescue nil 
    136136        listen_sockets[t_socket.fileno] = { :socket => t_socket,:block => block,:module => t_module } 
    137137        @read_ios << t_socket 

  • trunk/framework/meta_pimp.rb

    r229 r275  
    55  # initializer of pimp 
    66  attr_accessor :callback_hash 
    7   attr_accessor :worker_status 
     7  attr_accessor :worker_status, :worker_key 
    88  def pimp_init 
    99    @callback_hash ||= {} 
    1010    @worker_status = nil 
    1111    @worker_result = nil 
     12    @worker_key = nil 
    1213    @tokenizer = BinParser.new 
    1314  end 
    …… 
    3940 
    4041  def save_worker_status(data_options = { }) 
    41     @worker_status = data_options[:data] 
     42    # @worker_status = data_options[:data] 
     43    reactor.update_result(worker_key,data_options[:data]) 
    4244  end 
    4345 

  • trunk/framework/nbio.rb

    r258 r275  
    6464        p_sock.write_nonblock(final_data) 
    6565      rescue Errno::EAGAIN 
    66         puts "Lol" 
     66        puts "EAGAIN Error while writing socket" 
    6767        return 
    6868      rescue Errno::EINTR 

  • trunk/framework/packet_master.rb

    r259 r275  
    1 # FIXME: Some code is duplicated between worker class and this Reactor class, that can be fixed 
    2 # with help of creation of Connection class and enabling automatic inheritance of that class and 
    3 # mixing in of methods from that class. 
    41module Packet 
    52  class Reactor 
    63    include Core 
    74    attr_accessor :fd_writers, :msg_writers,:msg_reader 
     5    attr_accessor :result_hash 
     6 
    87    attr_accessor :live_workers 
    98    after_connection :provide_workers 
    …… 
    1514    def self.run 
    1615      master_reactor_instance = new 
     16      master_reactor_instance.result_hash = {} 
    1717      master_reactor_instance.live_workers = DoubleKeyedHash.new 
    1818      yield(master_reactor_instance) 
    …… 
    2121    end # end of run method 
    2222 
     23    def update_result(worker_key,result) 
     24      @result_hash ||= {} 
     25      @result_hash[worker_key.to_sym] = result 
     26    end 
     27 
    2328    def provide_workers(handler_instance,t_sock) 
    2429      class << handler_instance 
    …… 
    2631        attr_accessor :workers,:connection,:reactor, :initialized,:signature 
    2732        include NbioHelper 
    28  
    29         def send_data p_data 
    30           begin 
    31             write_data(p_data,connection) 
    32           rescue Errno::EPIPE 
    33             # probably a callback, when there is a error in writing to the socket 
    34           end 
    35         end 
    36  
    37         def invoke_init 
    38           @initialized = true 
    39           post_init 
    40         end 
    41  
    42         def close_connection 
    43           unbind 
    44           reactor.remove_connection(connection) 
    45         end 
    46  
    47         def close_connection_after_writing 
    48           connection.flush 
    49           unbind 
    50           reactor.remove_connection(connection) 
    51         end 
    52  
     33        include Connection 
    5334        def ask_worker(*args) 
    5435          worker_name = args.shift 
    …… 
    5940        end 
    6041 
    61         def send_object p_object 
    62           dump_object(p_object,connection) 
    63         end 
    6442        def_delegators(:@reactor, :start_server, :connect, :add_periodic_timer, \ 
    6543                         :add_timer, :cancel_timer,:reconnect, :start_worker,:delete_worker) 
    …… 
    157135        @live_workers[worker_name_key,master_read_end.fileno] = pimp_klass.new(master_write_end,pid,self) 
    158136      else 
    159         @live_workers[worker_name_key,master_read_end.fileno] = Packet::MetaPimp.new(master_write_end,pid,self) 
     137        t_pimp = Packet::MetaPimp.new(master_write_end,pid,self) 
     138        t_pimp.worker_key = worker_name_key 
     139        @live_workers[worker_name_key,master_read_end.fileno] = t_pimp 
    160140      end 
    161141 

  • trunk/framework/worker.rb

    r217 r275  
    6363        attr_accessor :worker, :connection, :reactor, :initialized, :signature 
    6464        include NbioHelper 
    65         def send_data p_data 
    66           begin 
    67             write_data(p_data,connection) 
    68           rescue Errno::EPIPE 
    69             # probably a callback 
    70           end 
    71         end 
    72  
    73         def invoke_init 
    74           @initialized = true 
    75           post_init 
    76         end 
    77  
    78         def close_connection 
    79           unbind 
    80           reactor.remove_connection(connection) 
    81         end 
    82  
    83         def close_connection_after_writing 
    84           connection.flush 
    85           unbind 
    86           reactor.remove_connection(connection) 
    87         end 
    88  
    89         def send_object p_object 
    90           dump_object(p_object,connection) 
    91         end 
    92  
     65        include Connection 
    9366        def_delegators :@reactor, :start_server, :connect, :add_periodic_timer, :add_timer, :cancel_timer,:reconnect 
    9467      end 

  • trunk/script/backgroundrb

    r269 r275  
    3232    if config_file[:backgroundrb][:log].nil? or config_file[:backgroundrb][:log] != 'foreground' 
    3333      log_file = File.open(SERVER_LOGGER,"w+") 
    34       p "***************** : changing file descriptors" 
    3534      [STDIN, STDOUT, STDERR].each {|desc| desc.reopen(log_file)} 
    36     else 
    37       p "***************** : everything on stdout" 
    3835    end 
    3936    MasterProxy.new() 

  • trunk/server/master_worker.rb

    r269 r275  
    11#!/usr/bin/env ruby 
    2 # PACKET_APP = File.expand_path(File.join(File.dirname(__FILE__) + "/..")) 
    3 # RAILS_HOME = File.expand_path(File.join(File.dirname(__FILE__) + "/../..")) 
    4  
    52 
    63module BackgrounDRb 
    …… 
    7269  def process_status(t_data) 
    7370    worker_name = t_data[:worker] 
    74     status_data = workers[worker_name].worker_status 
     71    job_key = t_data[:job_key] 
     72    worker_name_key = gen_worker_key(worker_name,job_key) 
     73    status_data = reactor.result_hash[worker_name_key.to_sym] 
    7574    send_object(status_data) 
    7675  end 
    …… 
    113112  def initialize 
    114113    config_file = YAML.load(ERB.new(IO.read("#{RAILS_HOME}/config/backgroundrb.yml")).result) 
     114    load_rails_env(config_file) 
    115115    Packet::Reactor.run do |t_reactor| 
    116116      t_reactor.start_worker(:worker => :log_worker) 
    …… 
    118118    end 
    119119  end 
     120 
     121  def load_rails_env(config_file) 
     122    ActiveRecord::Base.allow_concurrency = true 
     123    db_config_file = YAML.load(ERB.new(IO.read("#{RAILS_HOME}/config/database.yml")).result) 
     124    run_env = config_file[:backgroundrb][:environment] || 'development' 
     125    ENV["RAILS_ENV"] = run_env 
     126    RAILS_ENV.replace(run_env) if defined?(RAILS_ENV) 
     127    require RAILS_HOME + '/config/environment.rb' 
     128    ActiveRecord::Base.establish_connection(db_config_file[run_env]) 
     129  end 
    120130end 
    121131 

  • trunk/server/meta_worker.rb

    r271 r275  
    1 # FIXME: need to wrap workers within a namespace 
    21module BackgrounDRb 
    32  # this class is a dummy class that implements things required for passing data to 
    …… 
    1514    end 
    1615  end 
     16  # == MetaWorker class 
     17  # BackgrounDRb workers are asynchrounous reactors which work using events 
     18  # You are free to use threads in your workers, but be reasonable with them. 
     19  # Following methods are available to all workers from parent classes. 
     20  # * BackgrounDRb::MetaWorker#connect 
     21  # 
     22  #   Above method connects to an external tcp server and integrates the connection 
     23  #   within reactor loop of worker. For example: 
     24  # 
     25  #        class TimeClient 
     26  #          def receive_data(p_data) 
     27  #            worker.get_external_data(p_data) 
     28  #          end 
     29  # 
     30  #          def post_init 
     31  #            p "***************** : connection completed" 
     32  #          end 
     33  #        end 
     34  # 
     35  #        class FooWorker < BackgrounDRb::MetaWorker 
     36  #          set_worker_name :foo_worker 
     37  #          def create(args = nil) 
     38  #            external_connection = nil 
     39  #            connect("localhost",11009,TimeClient) { |conn| external_connection = conn } 
     40  #          end 
     41  # 
     42  #          def get_external_data(p_data) 
     43  #            puts "And external data is : #{p_data}" 
     44  #          end 
     45  #        end 
     46  # * BackgrounDRb::MetaWorker#start_server 
     47  # 
     48  #   Above method allows you to start a tcp server from your worker, all the 
     49  #   accepted connections are integrated with event loop of worker 
     50  #      class TimeServer 
     51  # 
     52  #        def receive_data(p_data) 
     53  #        end 
     54  # 
     55  #        def post_init 
     56  #          add_periodic_timer(2) { say_hello_world } 
     57  #        end 
     58  # 
     59  #        def connection_completed 
     60  #        end 
     61  # 
     62  #        def say_hello_world 
     63  #          p "***************** : invoking hello world #{Time.now}" 
     64  #          send_data("Hello World\n") 
     65  #        end 
     66  #      end 
     67  # 
     68  #      class ServerWorker < BackgrounDRb::MetaWorker 
     69  #        set_worker_name :server_worker 
     70  #        def create(args = nil) 
     71  #          # start the server when worker starts 
     72  #          start_server("0.0.0.0",11009,TimeServer) do |client_connection| 
     73  #            client_connection.say_hello_world 
     74  #          end 
     75  #        end 
     76  #      end 
    1777 
    1878  class MetaWorker < Packet::Worker 
    …… 
    2484    attr_accessor :logger 
    2585 
     86    # does initialization of worker stuff and invokes create method in 
     87    # user defined worker class 
    2688    def worker_init 
    2789      @config_file = YAML.load(ERB.new(IO.read("#{RAILS_HOME}/config/backgroundrb.yml")).result) 
    28       load_rails_env 
     90      # load_rails_env 
    2991      @logger = PacketLogger.new(self) 
    3092      if(@worker_options && @worker_options[:schedule] && no_auto_load) 
    …… 
    41103    end 
    42104 
     105    # loads workers schedule from options supplied from rails 
    43106    # a user may pass trigger arguments to dynamically define the schedule 
    44107    def load_schedule_from_args 
    …… 
    47110    end 
    48111 
     112    # receives requests/responses from master process or other workers 
    49113    def receive_data p_data 
    50114      if p_data[:data][:worker_method] == :exit 
    …… 
    58122    end 
    59123 
     124    # method is responsible for invoking appropriate method in user 
    60125    def process_request(p_data) 
    61126      user_input = p_data[:data] 
    …… 
    187252    end 
    188253 
    189     private 
    190     def load_rails_env 
    191       ActiveRecord::Base.allow_concurrency = true 
    192       db_config_file = YAML.load(ERB.new(IO.read("#{RAILS_HOME}/config/database.yml")).result) 
    193       run_env = @config_file[:backgroundrb][:environment] || 'development' 
    194       require RAILS_HOME + '/config/environment.rb' 
    195       ENV['RAILS_ENV'] = run_env 
    196       ActiveRecord::Base.establish_connection(db_config_file[run_env]) 
    197     end 
     254#     private 
     255#     def load_rails_env 
     256#       ActiveRecord::Base.allow_concurrency = true 
     257#       db_config_file = YAML.load(ERB.new(IO.read("#{RAILS_HOME}/config/database.yml")).result) 
     258#       run_env = @config_file[:backgroundrb][:environment] || 'development' 
     259#       ENV["RAILS_ENV"] = run_env 
     260#       RAILS_ENV.replace(run_env) if defined?(RAILS_ENV) 
     261#       require RAILS_HOME + '/config/environment.rb' 
     262#       ActiveRecord::Base.establish_connection(db_config_file[run_env]) 
     263#     end 
    198264  end # end of class MetaWorker 
    199265end # end of module BackgrounDRb