123456789_123456789_123456789_123456789_123456789_

Class: EventMachine::ProcessWatch

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Connection
Instance Chain:
self, Connection
Inherits: EventMachine::Connection
Defined in: lib/em/process_watch.rb

Overview

This is subclassed from Connection for use with the process monitoring API. Read the documentation on the instance methods of this class, and for a full explanation see ::EventMachine.watch_process.

Constant Summary

Class Method Summary

Connection - Inherited

.new

Override .new so subclasses don't have to call super and can ignore connection-specific arguments.

Instance Attribute Summary

Connection - Inherited

#comm_inactivity_timeout

comm_inactivity_timeout returns the current value (float in seconds) of the inactivity-timeout property of network-connection and datagram-socket objects.
#comm_inactivity_timeout=

Allows you to set the inactivity-timeout property for a network connection or datagram socket.
#error?

Returns true if the connection is in an error state, false otherwise.
#notify_readable=

Watches connection for readability.
#notify_readable?,
#notify_writable=

Watches connection for writeability.
#notify_writable?

Returns true if the connection is being watched for writability.
#paused?,
#pending_connect_timeout

The duration after which a TCP connection in the connecting state will fail.
#pending_connect_timeout=

Sets the duration after which a TCP connection in a connecting state will fail.
#signature, #watch_only?

Instance Method Summary

  • #pid

    Returns the pid that EventMachine::watch_process was originally called with.

  • #process_exited

    Should be redefined with the user's custom callback that will be fired when the process exits.

  • #process_forked

    Should be redefined with the user's custom callback that will be fired when the prcess is forked.

  • #receive_data(data) Internal use only Internal use only
  • #stop_watching

    Discontinue monitoring of the process.

Connection - Inherited

#associate_callback_target

conn_associate_callback_target.
#close_connection

EventMachine::Connection#close_connection is called only by user code, and never by the event loop.
#close_connection_after_writing

A variant of #close_connection.
#connection_completed

Called by the event loop when a remote TCP connection attempt completes successfully.
#detach

Removes given connection from the event loop.
#disable_keepalive

t_disable_keepalive.
#enable_keepalive

t_enable_keepalive.
#get_cipher_bits, #get_cipher_name, #get_cipher_protocol,
#get_idle_time

The number of seconds since the last send/receive activity on this connection.
#get_outbound_data_size

conn_get_outbound_data_size.
#get_peer_cert

If TLS is active on the connection, returns the remote X509 certificate as a string, in the popular PEM format.
#get_peername

This method is used with stream-connections to obtain the identity of the remotely-connected peer.
#get_pid

Returns the PID (kernel process identifier) of a subprocess associated with this Connection object.
#get_proxied_bytes

The number of bytes proxied to another connection.
#get_sni_hostname, #get_sock_opt,
#get_sockname

Used with stream-connections to obtain the identity of the local side of the connection.
#get_status

Returns a subprocess exit status.
#initialize

Stubbed initialize so legacy superclasses can safely call super.
#original_method,
#pause

Pause a connection so that #send_data and #receive_data events are not fired until #resume is called.
#post_init

Called by the event loop immediately after the network connection has been established, and before resumption of the network loop.
#proxy_completed

called when the reactor finished proxying all of the requested bytes.
#proxy_incoming_to

EventMachine::Connection#proxy_incoming_to is called only by user code.
#proxy_target_unbound

Called by the reactor after attempting to relay incoming data to a descriptor (set as a proxy target descriptor with enable_proxy) that has already been closed.
#receive_data

Called by the event loop whenever data has been received by the network connection.
#reconnect

Reconnect to a given host/port with the current instance.
#resume

Resume a connection's #send_data and #receive_data events.
#send_data

Call this method to send data to the remote end of the network connection.
#send_datagram

Sends UDP messages.
#send_file_data

Like Connection#send_data, this sends data to the remote end of the network connection.
#set_sock_opt,
#ssl_handshake_completed

Called by ::EventMachine when the SSL/TLS handshake has been completed, as a result of calling #start_tls to initiate SSL/TLS on the connection.
#ssl_verify_peer

Called by ::EventMachine when :verify_peer => true has been passed to #start_tls.
#start_tls

Call #start_tls at any point to initiate TLS encryption on connected streams.
#stop_proxying

A helper method for disable_proxy
#stream_file_data

Open a file on the filesystem and send it to the remote peer.
#unbind

called by the framework whenever a connection (either a server or client connection) is closed.

Constructor Details

This class inherits a constructor from EventMachine::Connection

Instance Method Details

#pid

Returns the pid that EventMachine::watch_process was originally called with.

[ GitHub ] 

  


# File 'lib/em/process_watch.rb', line 22



def pid
  @pid
end


  








  

    #process_exited  
  



  

    
Should be redefined with the user's custom callback that will be fired when the process exits.



stop_watching is called automatically after this callback


  



  [ GitHub ]


  

  


# File 'lib/em/process_watch.rb', line 35



def process_exited
end


  








  

    #process_forked  
  



  

    
Should be redefined with the user's custom callback that will be fired when the prcess is forked.



There is currently not an easy way to get the pid of the forked child.


  



  [ GitHub ]


  

  


# File 'lib/em/process_watch.rb', line 29



def process_forked
end


  








  

    #receive_data(data)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/em/process_watch.rb', line 12



def receive_data(data)
  case data
  when Cfork
    process_forked
  when Cexit
    process_exited
  end
end


  








  

    #stop_watching  
  



  

    
Discontinue monitoring of the process.
This will be called automatically when a process dies. User code may call it as well.


  



  [ GitHub ]


  

  


# File 'lib/em/process_watch.rb', line 40



def stop_watching
  EventMachine::unwatch_pid(@signature)
end