def on_forward_button_clicked(self, widget):
dport = self._get_selected_opt_from_combobox('data')
cport = self._get_selected_opt_from_combobox('control')
speed = int(self._get_selected_opt_from_combobox('speed'))
if cport == _("No control port"):
cport = None
software = self.view['software_checkbutton'].get_active()
hardware = self.view['hardware_checkbutton'].get_active()
title = _('Connecting to device...')
apb = dialogs.ActivityProgressBar(title, self, True)
def get_remote_plugin_eb(failure):
failure.trap(SerialException)
apb.close()
port = cport and cport or dport
message = _('Exception received connecting to %s') % port
details = _("""
The following error was received while trying to establish a connection:
%s""") % failure.getErrorMessage()
dialogs.open_warning_dialog(message, details)
from vmc.common.hardware import HardwareRegistry
hw = HardwareRegistry()
d = hw.get_plugin_for_remote_dev(speed, dport, cport)
d.addCallback(self._im_done, apb)
d.addErrback(get_remote_plugin_eb)
def on_forward_button_clicked(self, widget):
dport = self._get_selected_opt_from_combobox('data')
cport = self._get_selected_opt_from_combobox('control')
speed = int(self._get_selected_opt_from_combobox('speed'))
if cport == _("No control port"):
cport = None
software = self.view['software_checkbutton'].get_active()
hardware = self.view['hardware_checkbutton'].get_active()
title = _('Connecting to device...')
apb = dialogs.ActivityProgressBar(title, self, True)
def get_remote_plugin_eb(failure):
failure.trap(SerialException)
apb.close()
port = cport and cport or dport
message = _('Exception received connecting to %s') % port
details = _("""
The following error was received while trying to establish a connection:
%s""") % failure.getErrorMessage()
dialogs.open_warning_dialog(message, details)
from vmc.common.hardware import HardwareRegistry
hw = HardwareRegistry()
d = hw.get_plugin_for_remote_dev(speed, dport, cport)
d.addCallback(self._im_done, apb)
d.addErrback(get_remote_plugin_eb)
def setUpClass(self):
self.sconn = None
self.serial = None
self.device = None
hw = HardwareRegistry()
d = hw.get_devices()
def get_devices_cb(devices):
self.device = attach_serial_protocol(devices[0], test=False)
self.sconn = self.device.sconn
self.sport = self.device.sport
return self.device.preinit()
d.addCallback(get_devices_cb)
return d
def setUpClass(self):
self.sconn = None
self.serial = None
self.device = None
hw = HardwareRegistry()
d = hw.get_devices()
def get_devices_cb(devices):
self.device = attach_serial_protocol(devices[0], test=False)
self.sconn = self.device.sconn
self.sport = self.device.sport
return self.device.preinit()
d.addCallback(get_devices_cb)
return d
device = devices[0]
cli = VMCClient(device, config)
cli.start_it()
def device_not_found_eb(failure):
failure.trap(ex.DeviceNotFoundError)
log.msg("I couldn't find a device to use through DBus")
reactor.stop()
def device_lacks_extractinfo_eb(failure):
failure.trap(ex.DeviceLacksExtractInfo)
log.msg("Your card has been properly recognized but I couldn't infer")
log.msg("from DBus what ports should use to communicate with device")
reactor.stop()
hw = HardwareRegistry()
hw_reg = HardwareRegistry()
d = hw_reg.get_devices()
d.addCallback(get_devices_cb)
d.addErrback(device_not_found_eb)
d.addErrback(device_lacks_extractinfo_eb)
class VMCClient(object):
def __init__(self, device, config):
self.device = device
self.config = config
self.wrapper = None
self.connsm = None
def start_it(self):
def detect_hardware(self, ignored=None):
def _ask_user_for_device(devices, callback, splash):
cached_devices = DeviceProfileCache.get_cached_devices()
for cached_device in list(cached_devices):
if isinstance(cached_device, DBusDevicePlugin) \
and not cached_device in devices:
cached_devices.remove(cached_device)
all_devices = cached_devices + [device for device in devices
if device not in cached_devices]
controller = DeviceSelectionController(Model(),
all_devices, callback, splash)
view = DeviceSelectionView(controller)
view.show()
def _device_select(devices, callback, splash):
try:
last_device_id = config.get_last_device()
device = DeviceProfileCache.load(last_device_id)
#If device is a DBus device, it has to have been detected to be
#used.
if (isinstance(device, DBusDevicePlugin) and
not device in devices):
_ask_user_for_device(devices, callback, splash)
else:
callback(device)
except IOError:
_ask_user_for_device(devices, callback, splash)
def device_serial_eb(failure):
from vmc.gtk import dialogs
failure.trap(SerialException)
message = _('Device setup not completed')
details = _("""
Your device has been detected but it has been impossible to connect to it.
%s""") % failure.getErrorMessage()
dialogs.open_warning_dialog(message, details)
_device_select([], self.configure_hardware, self.splash)
def device_not_found_eb(failure):
failure.trap(ex.DeviceNotFoundError)
_device_select([], self.configure_hardware, self.splash)
def device_lacks_extractinfo_eb(failure):
failure.trap(ex.DeviceLacksExtractInfo)
from vmc.gtk import dialogs
from vmc.common.shutdown import shutdown_core
device = failure.value.args[0]
info = dict(name=device.name, vmc=APP_LONG_NAME)
message = _('Device setup not completed')
details = _("""
Your device "%(name)s" is not properly registered with the kernel. %(vmc)s
needs at least two serial ports to communicate with your %(name)s.
The program includes a set of udev rules plus some binaries that make sure
that your device is always recognised properly. If you've installed from
source, then make sure to copy the relevant files in the contrib dir
""") % info
dialogs.open_warning_dialog(message, details)
shutdown_core(delay=.2)
def device_timeout_eb(failure):
failure.trap(ex.ATTimeout)
from vmc.gtk import dialogs
from vmc.common.shutdown import shutdown_core
message = _('Device not responding')
details = _("""
Your device took more than 15 seconds to reply to my last command. Unplug it,
plug it again, and try in a moment.""")
dialogs.open_warning_dialog(message, details)
shutdown_core(delay=.2)
def get_devices_cb(devices):
_device_select(devices, self.configure_hardware, self.splash)
hw_reg = HardwareRegistry()
d = hw_reg.get_devices()
d.addCallback(get_devices_cb)
d.addErrback(device_not_found_eb)
d.addErrback(device_lacks_extractinfo_eb)
d.addErrback(device_timeout_eb)
d.addErrback(device_serial_eb)
d.addErrback(log.err)
cli = VMCClient(device, config)
cli.start_it()
def device_not_found_eb(failure):
failure.trap(ex.DeviceNotFoundError)
log.msg("I couldn't find a device to use through DBus")
reactor.stop()
def device_lacks_extractinfo_eb(failure):
failure.trap(ex.DeviceLacksExtractInfo)
log.msg("Your card has been properly recognized but I couldn't infer")
log.msg("from DBus what ports should use to communicate with device")
reactor.stop()
hw = HardwareRegistry()
hw_reg = HardwareRegistry()
d = hw_reg.get_devices()
d.addCallback(get_devices_cb)
d.addErrback(device_not_found_eb)
d.addErrback(device_lacks_extractinfo_eb)
class VMCClient(object):
def __init__(self, device, config):
self.device = device
self.config = config
self.wrapper = None
self.connsm = None
def start_it(self):
if self.config['connect']:
def detect_hardware(self, ignored=None):
def _ask_user_for_device(devices, callback, splash):
cached_devices = DeviceProfileCache.get_cached_devices()
for cached_device in list(cached_devices):
if isinstance(cached_device, DBusDevicePlugin) \
and not cached_device in devices:
cached_devices.remove(cached_device)
all_devices = cached_devices + [
device for device in devices if device not in cached_devices
]
controller = DeviceSelectionController(Model(), all_devices,
callback, splash)
view = DeviceSelectionView(controller)
view.show()
def _device_select(devices, callback, splash):
try:
last_device_id = config.get_last_device()
device = DeviceProfileCache.load(last_device_id)
#If device is a DBus device, it has to have been detected to be
#used.
if (isinstance(device, DBusDevicePlugin)
and not device in devices):
_ask_user_for_device(devices, callback, splash)
else:
callback(device)
except IOError:
_ask_user_for_device(devices, callback, splash)
def device_serial_eb(failure):
from vmc.gtk import dialogs
failure.trap(SerialException)
message = _('Device setup not completed')
details = _("""
Your device has been detected but it has been impossible to connect to it.
%s""") % failure.getErrorMessage()
dialogs.open_warning_dialog(message, details)
_device_select([], self.configure_hardware, self.splash)
def device_not_found_eb(failure):
failure.trap(ex.DeviceNotFoundError)
_device_select([], self.configure_hardware, self.splash)
def device_lacks_extractinfo_eb(failure):
failure.trap(ex.DeviceLacksExtractInfo)
from vmc.gtk import dialogs
from vmc.common.shutdown import shutdown_core
device = failure.value.args[0]
info = dict(name=device.name, vmc=APP_LONG_NAME)
message = _('Device setup not completed')
details = _("""
Your device "%(name)s" is not properly registered with the kernel. %(vmc)s
needs at least two serial ports to communicate with your %(name)s.
The program includes a set of udev rules plus some binaries that make sure
that your device is always recognised properly. If you've installed from
source, then make sure to copy the relevant files in the contrib dir
""") % info
dialogs.open_warning_dialog(message, details)
shutdown_core(delay=.2)
def device_timeout_eb(failure):
failure.trap(ex.ATTimeout)
from vmc.gtk import dialogs
from vmc.common.shutdown import shutdown_core
message = _('Device not responding')
details = _("""
Your device took more than 15 seconds to reply to my last command. Unplug it,
plug it again, and try in a moment.""")
dialogs.open_warning_dialog(message, details)
shutdown_core(delay=.2)
def get_devices_cb(devices):
_device_select(devices, self.configure_hardware, self.splash)
hw_reg = HardwareRegistry()
d = hw_reg.get_devices()
d.addCallback(get_devices_cb)
d.addErrback(device_not_found_eb)
d.addErrback(device_lacks_extractinfo_eb)
d.addErrback(device_timeout_eb)
d.addErrback(device_serial_eb)
d.addErrback(log.err)
