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 __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()
