def __init__(self): os.environ['DISPLAY'] = get_display(None)[0] self.dpy = display.Display() self.hub = publisher() self.wm = window_manager(self.hub, self.dpy) self.layout = layout(self.hub, self.wm) self.xec = x_event_controller(self.hub, self.dpy) self.ticker = tick_controller(self.hub) self.hub.defaults['wm'] = self.wm self.hub.defaults['hub'] = self.hub self.hub.attach('tick', self.xec.select_and_emit_all)
def step(self): """Step X11 handler event loop. Returns support for X11""" # Try to accept a new connection x11_channel = self._transport.accept(timeout=0) if x11_channel is not None: # Build connection try: dname, protocol, host, dno, screen = xlib_connect.get_display( os.environ['DISPLAY']) protocol = protocol or None local_x11_socket = xlib_connect.get_socket( dname, protocol, host, dno) except (Xlib.error.DisplayConnectionError, KeyError): return False # X11 is not supported # Prevent sockets from blocking local_x11_socket.setblocking(False) x11_channel.setblocking(False) # Register new sockets self._register(x11_channel, local_x11_socket) self._register(local_x11_socket, x11_channel) # Handle communication over registered sockets if not self._sockets: return True # Windows fails when 'selecting' nothing, so return events = self._sel.select(timeout=0) for key, mask in events: # send data from source to destination src, dest = key.fileobj, key.data try: dest.setblocking(True) data = src.recv(4096) if len(data) == 0: raise OSError if dest.send(data) == 0: raise OSError dest.setblocking(False) except OSError: src.close() dest.close() self._unregister(src) self._unregister(dest) # X11 is supported return True
def __init__(self, display = None): name, host, displayno, screenno = connect.get_display(display) self.display_name = name self.default_screen = screenno self.socket = connect.get_socket(name, host, displayno) auth_name, auth_data = connect.get_auth(self.socket, name, host, displayno) # Internal structures for communication, grouped # by their function and locks # Socket error indicator, set when the socket is closed # in one way or another self.socket_error_lock = lock.allocate_lock() self.socket_error = None # Event queue self.event_queue_read_lock = lock.allocate_lock() self.event_queue_write_lock = lock.allocate_lock() self.event_queue = [] # Unsent request queue and sequence number counter self.request_queue_lock = lock.allocate_lock() self.request_serial = 1 self.request_queue = [] # Send-and-recieve loop, see function send_and_recive # for a detailed explanation self.send_recv_lock = lock.allocate_lock() self.send_active = 0 self.recv_active = 0 self.event_waiting = 0 self.event_wait_lock = lock.allocate_lock() self.request_waiting = 0 self.request_wait_lock = lock.allocate_lock() # Data used by the send-and-recieve loop self.sent_requests = [] self.request_length = 0 self.data_send = '' self.data_recv = '' self.data_sent_bytes = 0 # Resource ID structures self.resource_id_lock = lock.allocate_lock() self.resource_ids = {} self.last_resource_id = 0 # Use an default error handler, one which just prints the error self.error_handler = None # Right, now we're all set up for the connection setup # request with the server. # Figure out which endianess the hardware uses self.big_endian = struct.unpack('BB', struct.pack('H', 0x0100))[0] if self.big_endian: order = 0x42 else: order = 0x6c # Send connection setup r = ConnectionSetupRequest(self, byte_order = order, protocol_major = 11, protocol_minor = 0, auth_prot_name = auth_name, auth_prot_data = auth_data) # Did connection fail? if r.status != 1: raise error.DisplayConnectionError(self.display_name, r.reason) # Set up remaining info self.info = r self.default_screen = min(self.default_screen, len(self.info.roots) - 1)
def __init__(self, display=None): name, host, displayno, screenno = connect.get_display(display) self.display_name = name self.default_screen = screenno self.socket = connect.get_socket(name, host, displayno) auth_name, auth_data = connect.get_auth(self.socket, name, host, displayno) # Internal structures for communication, grouped # by their function and locks # Socket error indicator, set when the socket is closed # in one way or another self.socket_error_lock = lock.allocate_lock() self.socket_error = None # Event queue self.event_queue_read_lock = lock.allocate_lock() self.event_queue_write_lock = lock.allocate_lock() self.event_queue = [] # Unsent request queue and sequence number counter self.request_queue_lock = lock.allocate_lock() self.request_serial = 1 self.request_queue = [] # Send-and-recieve loop, see function send_and_recive # for a detailed explanation self.send_recv_lock = lock.allocate_lock() self.send_active = 0 self.recv_active = 0 self.event_waiting = 0 self.event_wait_lock = lock.allocate_lock() self.request_waiting = 0 self.request_wait_lock = lock.allocate_lock() # Data used by the send-and-recieve loop self.sent_requests = [] self.request_length = 0 self.data_send = '' self.data_recv = '' self.data_sent_bytes = 0 # Resource ID structures self.resource_id_lock = lock.allocate_lock() self.resource_ids = {} self.last_resource_id = 0 # Use an default error handler, one which just prints the error self.error_handler = None # Right, now we're all set up for the connection setup # request with the server. # Figure out which endianess the hardware uses self.big_endian = struct.unpack('BB', struct.pack('H', 0x0100))[0] if self.big_endian: order = 0x42 else: order = 0x6c # Send connection setup r = ConnectionSetupRequest(self, byte_order=order, protocol_major=11, protocol_minor=0, auth_prot_name=auth_name, auth_prot_data=auth_data) # Did connection fail? if r.status != 1: raise error.DisplayConnectionError(self.display_name, r.reason) # Set up remaining info self.info = r self.default_screen = min(self.default_screen, len(self.info.roots) - 1)
def conne(): # if options if selProg.get() == 'labview': prog = 'labview64' elif selProg.get() == 'octave': prog = 'octave --force-gui' elif selProg.get() == 'Matlab': prog = 'matlab' elif selProg.get() == 'eButterfly': prog = 'eButterfly' if selProg.get() == 'Programs': tkMessageBox.showerror("Error", "Select a Program") else: ssh_client = paramiko.SSHClient() ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh_client.connect(txthost.get(), username=txtusr.get(), password=txtpwd.get(), port=txtprt.get()) #del password # maintain map # { fd: (channel, remote channel), ... } channels = {} poller = select.poll() def x11_handler(channel, (src_addr, src_port)): '''handler for incoming x11 connections for each x11 incoming connection, - get a connection to the local display - maintain bidirectional map of remote x11 channel to local x11 channel - add the descriptors to the poller - queue the channel (use transport.accept())''' x11_chanfd = channel.fileno() local_x11_socket = xlib_connect.get_socket(*local_x11_display[:4]) local_x11_socket_fileno = local_x11_socket.fileno() channels[x11_chanfd] = channel, local_x11_socket channels[local_x11_socket_fileno] = local_x11_socket, channel poller.register(x11_chanfd, select.POLLIN) poller.register(local_x11_socket, select.POLLIN) LOGGER.debug('x11 channel on: %s %s', src_addr, src_port) transport._queue_incoming_channel(channel) def flush_out(session): while session.recv_ready(): sys.stdout.write(session.recv(4096)) while session.recv_stderr_ready(): sys.stderr.write(session.recv_stderr(4096)) # get local disply local_x11_display = xlib_connect.get_display(os.environ['DISPLAY']) # start x11 session transport = ssh_client.get_transport() session = transport.open_session() session.request_x11(handler=x11_handler) session.exec_command(prog) session_fileno = session.fileno() poller.register(session_fileno, select.POLLIN) # accept first remote x11 connection transport.accept() # event loop while not session.exit_status_ready(): poll = poller.poll() # accept subsequent x11 connections if any if len(transport.server_accepts) > 0: transport.accept() if not poll: # this should not happen, as we don't have a timeout. break for fd, event in poll: if fd == session_fileno: flush_out(session) # data either on local/remote x11 socket if fd in channels.keys(): channel, counterpart = channels[fd] try: # forward data between local/remote x11 socket. data = channel.recv(4096) counterpart.sendall(data) except socket.error: channel.close() counterpart.close() del channels[fd] print 'Exit status:', session.recv_exit_status() flush_out(session) session.close()