kopia lustrzana https://github.com/ctjacobs/pyqso
355 wiersze
14 KiB
Python
355 wiersze
14 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# Copyright (C) 2013 Christian T. Jacobs.
|
|
|
|
# This file is part of PyQSO.
|
|
|
|
# PyQSO is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# PyQSO is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with PyQSO. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from gi.repository import Gtk, GObject
|
|
import logging
|
|
import telnetlib
|
|
import unittest
|
|
import unittest.mock
|
|
import configparser
|
|
import os.path
|
|
|
|
from pyqso.telnet_connection_dialog import *
|
|
|
|
BOOKMARKS_FILE = os.path.expanduser('~/.config/pyqso/bookmarks.ini')
|
|
|
|
|
|
class DXCluster(Gtk.VBox):
|
|
|
|
""" A tool for connecting to a DX cluster (specifically Telnet-based DX clusters). """
|
|
|
|
def __init__(self, parent):
|
|
""" Set up the DX cluster's Gtk.VBox, and set up a timer so that PyQSO can retrieve new data from the Telnet server every few seconds.
|
|
|
|
:arg parent: The parent Gtk window.
|
|
"""
|
|
logging.debug("Setting up the DX cluster...")
|
|
Gtk.VBox.__init__(self, spacing=2)
|
|
|
|
self.connection = None
|
|
self.parent = parent
|
|
|
|
# Set up the menubar
|
|
self.menubar = Gtk.MenuBar()
|
|
|
|
self.items = {}
|
|
|
|
# CONNECTION ######
|
|
mitem_connection = Gtk.MenuItem(label="Connection")
|
|
self.menubar.append(mitem_connection)
|
|
subm_connection = Gtk.Menu()
|
|
mitem_connection.set_submenu(subm_connection)
|
|
|
|
# Connect
|
|
mitem_connect = Gtk.ImageMenuItem(label="Connect to Telnet Server")
|
|
icon = Gtk.Image()
|
|
icon.set_from_stock(Gtk.STOCK_CONNECT, Gtk.IconSize.MENU)
|
|
mitem_connect.set_image(icon)
|
|
subm_connection.append(mitem_connect)
|
|
self.items["CONNECT"] = mitem_connect
|
|
|
|
subm_connect = Gtk.Menu()
|
|
|
|
# New
|
|
mitem_new = Gtk.MenuItem(label="New...")
|
|
mitem_new.connect("activate", self.new_server)
|
|
subm_connect.append(mitem_new)
|
|
|
|
# From Bookmark
|
|
mitem_bookmark = Gtk.MenuItem(label="From Bookmark")
|
|
self.subm_bookmarks = Gtk.Menu()
|
|
mitem_bookmark.set_submenu(self.subm_bookmarks)
|
|
self._populate_bookmarks()
|
|
subm_connect.append(mitem_bookmark)
|
|
|
|
mitem_connect.set_submenu(subm_connect)
|
|
|
|
# Disconnect
|
|
mitem_disconnect = Gtk.ImageMenuItem(label="Disconnect from Telnet Server")
|
|
icon = Gtk.Image()
|
|
icon.set_from_stock(Gtk.STOCK_DISCONNECT, Gtk.IconSize.MENU)
|
|
mitem_disconnect.set_image(icon)
|
|
mitem_disconnect.connect("activate", self.telnet_disconnect)
|
|
subm_connection.append(mitem_disconnect)
|
|
self.items["DISCONNECT"] = mitem_disconnect
|
|
|
|
self.pack_start(self.menubar, False, False, 0)
|
|
|
|
# A TextView object to display the output from the Telnet server.
|
|
self.renderer = Gtk.TextView()
|
|
self.renderer.set_editable(False)
|
|
self.renderer.set_cursor_visible(False)
|
|
sw = Gtk.ScrolledWindow()
|
|
sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
|
|
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
|
|
sw.add(self.renderer)
|
|
self.buffer = self.renderer.get_buffer()
|
|
self.pack_start(sw, True, True, 0)
|
|
|
|
# Set up the command box.
|
|
self.commandbox = Gtk.HBox(spacing=2)
|
|
self.command = Gtk.Entry()
|
|
self.commandbox.pack_start(self.command, True, True, 0)
|
|
self.send = Gtk.Button(label="Send Command")
|
|
self.send.connect("clicked", self.telnet_send_command)
|
|
self.commandbox.pack_start(self.send, False, False, 0)
|
|
self.pack_start(self.commandbox, False, False, 0)
|
|
|
|
self.set_items_sensitive(True)
|
|
|
|
self.show_all()
|
|
|
|
logging.debug("DX cluster ready!")
|
|
|
|
return
|
|
|
|
def new_server(self, widget=None):
|
|
""" Get Telnet server host and login details specified in the Gtk.Entry boxes in the TelnetConnectionDialog and attempt a connection. """
|
|
dialog = TelnetConnectionDialog(self.parent)
|
|
response = dialog.run()
|
|
|
|
if(response == Gtk.ResponseType.OK):
|
|
connection_info = dialog.get_connection_info()
|
|
host = connection_info["HOST"].get_text()
|
|
port = connection_info["PORT"].get_text()
|
|
username = connection_info["USERNAME"].get_text()
|
|
password = connection_info["PASSWORD"].get_text()
|
|
|
|
# Save the server details in a new bookmark, if desired.
|
|
if(connection_info["BOOKMARK"].get_active()):
|
|
try:
|
|
config = configparser.ConfigParser()
|
|
config.read(BOOKMARKS_FILE)
|
|
|
|
# Use the host name as the bookmark's identifier.
|
|
try:
|
|
config.add_section(host)
|
|
except configparser.DuplicateSectionError:
|
|
# If the hostname already exists, assume the user wants to update the port number, username and/or password.
|
|
logging.warning("A server with hostname '%s' already exists. Over-writing existing details..." % (host))
|
|
config.set(host, "host", host)
|
|
config.set(host, "port", port)
|
|
config.set(host, "username", username)
|
|
config.set(host, "password", password)
|
|
|
|
# Write the bookmarks to file.
|
|
if not os.path.exists(os.path.expanduser('~/.config/pyqso')):
|
|
os.makedirs(os.path.expanduser('~/.config/pyqso'))
|
|
with open(BOOKMARKS_FILE, 'w') as f:
|
|
config.write(f)
|
|
|
|
self._populate_bookmarks()
|
|
|
|
except IOError:
|
|
# Maybe the bookmarks file could not be written to?
|
|
logging.error("Bookmark could not be saved. Check bookmarks file permissions? Going ahead with the server connection anyway...")
|
|
|
|
dialog.destroy()
|
|
|
|
try:
|
|
# Convert port (currently of type str) into an int.
|
|
port = int(port)
|
|
# Attempt a connection with the server.
|
|
self.telnet_connect(host, port, username, password)
|
|
except ValueError as e:
|
|
logging.error("Could not convert the server's port information to an integer.")
|
|
logging.exception(e)
|
|
|
|
else:
|
|
dialog.destroy()
|
|
return
|
|
|
|
def _populate_bookmarks(self):
|
|
""" Populate the list of bookmarked Telnet servers in the menu. """
|
|
config = configparser.ConfigParser()
|
|
have_config = (config.read(BOOKMARKS_FILE) != [])
|
|
|
|
if(have_config):
|
|
try:
|
|
# Clear the menu of all current bookmarks.
|
|
for i in self.subm_bookmarks.get_children():
|
|
self.subm_bookmarks.remove(i)
|
|
|
|
# Add all bookmarks in the config file.
|
|
for bookmark in config.sections():
|
|
mitem = Gtk.MenuItem(label=bookmark)
|
|
mitem.connect("activate", self.bookmarked_server, bookmark)
|
|
self.subm_bookmarks.append(mitem)
|
|
|
|
except Exception as e:
|
|
logging.error("An error occurred whilst populating the DX cluster bookmarks menu.")
|
|
logging.exception(e)
|
|
|
|
self.show_all() # Need to do this to update the bookmarks list in the menu.
|
|
|
|
return
|
|
|
|
def bookmarked_server(self, widget, name):
|
|
""" Get Telnet server host and login details from an existing bookmark and attempt a connection.
|
|
|
|
:arg str name: The name of the bookmark. This is the same as the server's hostname.
|
|
"""
|
|
|
|
config = configparser.ConfigParser()
|
|
have_config = (config.read(BOOKMARKS_FILE) != [])
|
|
try:
|
|
if(not have_config):
|
|
raise IOError("The bookmark's details could not be loaded.")
|
|
|
|
host = config.get(name, "host")
|
|
port = int(config.get(name, "port"))
|
|
username = config.get(name, "username")
|
|
password = config.get(name, "password")
|
|
self.telnet_connect(host, port, username, password)
|
|
|
|
except ValueError as e:
|
|
# This exception may occur when casting the port (which is a str) to an int.
|
|
logging.exception(e)
|
|
except IOError as e:
|
|
logging.exception(e)
|
|
except Exception as e:
|
|
logging.error("Could not connect to Telnet server '%s'" % name)
|
|
logging.exception(e)
|
|
|
|
return
|
|
|
|
def telnet_connect(self, host, port=23, username=None, password=None):
|
|
""" Connect to a user-specified Telnet server.
|
|
|
|
:arg str host: The Telnet server's hostname.
|
|
:arg int port: The Telnet server's port number. If no port is specified, the default Telnet server port of 23 will be used.
|
|
:arg str username: The user's username. This is an optional argument.
|
|
:arg str password: The user's password. This is an optional argument.
|
|
"""
|
|
|
|
if(host == "" or host is None):
|
|
logging.error("No Telnet server specified.")
|
|
return
|
|
if(port == "" or port is None):
|
|
port = 23 # Use the default Telnet port
|
|
|
|
try:
|
|
self.connection = telnetlib.Telnet(host, port)
|
|
|
|
if(username):
|
|
self.connection.read_until("login: ".encode())
|
|
self.connection.write((username + "\n").encode())
|
|
if(password):
|
|
self.connection.read_until("password: ".encode())
|
|
self.connection.write((password + "\n").encode())
|
|
except Exception as e:
|
|
logging.error("Could not create a connection to the Telnet server")
|
|
logging.exception(e)
|
|
self.connection = None
|
|
return
|
|
|
|
self.set_items_sensitive(False)
|
|
|
|
self.check_io_event = GObject.timeout_add(1000, self._on_telnet_io)
|
|
|
|
return
|
|
|
|
def telnet_disconnect(self, widget=None):
|
|
""" Disconnect from a Telnet server and remove the I/O timer. """
|
|
if(self.connection):
|
|
self.connection.close()
|
|
self.buffer.set_text("")
|
|
self.connection = None
|
|
self.set_items_sensitive(True)
|
|
|
|
# Stop checking for server output once disconnected.
|
|
try:
|
|
GObject.source_remove(self.check_io_event)
|
|
except AttributeError:
|
|
# This may happen if a connection hasn't yet been established.
|
|
pass
|
|
|
|
return
|
|
|
|
def telnet_send_command(self, widget=None):
|
|
""" Send the user-specified command in the Gtk.Entry box to the Telnet server (if PyQSO is connected to one). """
|
|
if(self.connection):
|
|
self.connection.write((self.command.get_text() + "\n").encode())
|
|
self.command.set_text("")
|
|
return
|
|
|
|
def _on_telnet_io(self):
|
|
""" Retrieve any new data from the Telnet server and print it out in the Gtk.TextView widget.
|
|
|
|
:returns: Always returns True to satisfy the GObject timer.
|
|
:rtype: bool
|
|
"""
|
|
if(self.connection):
|
|
text = self.connection.read_very_eager().decode()
|
|
try:
|
|
text = text.replace("\u0007", "") # Remove the BEL Unicode character from the end of the line
|
|
except UnicodeDecodeError:
|
|
pass
|
|
|
|
# Allow auto-scrolling to the new text entry if the focus is already at
|
|
# the very end of the Gtk.TextView. Otherwise, don't auto-scroll
|
|
# in case the user is reading something further up.
|
|
# Note: This is based on the code from http://forums.gentoo.org/viewtopic-t-445598-view-next.html
|
|
end_iter = self.buffer.get_end_iter()
|
|
end_mark = self.buffer.create_mark(None, end_iter)
|
|
self.renderer.move_mark_onscreen(end_mark)
|
|
at_end = self.buffer.get_iter_at_mark(end_mark).equal(end_iter)
|
|
self.buffer.insert(end_iter, text)
|
|
if(at_end):
|
|
end_mark = self.buffer.create_mark(None, end_iter)
|
|
self.renderer.scroll_mark_onscreen(end_mark)
|
|
|
|
return True
|
|
|
|
def set_items_sensitive(self, sensitive):
|
|
""" Enable/disable the relevant buttons for connecting/disconnecting from a DX cluster, so that users cannot click the connect button if PyQSO is already connected.
|
|
|
|
:arg bool sensitive: If True, enable the Connect button and disable the Disconnect button. If False, vice versa.
|
|
"""
|
|
self.items["CONNECT"].set_sensitive(sensitive)
|
|
self.items["DISCONNECT"].set_sensitive(not sensitive)
|
|
self.send.set_sensitive(not sensitive)
|
|
return
|
|
|
|
|
|
class TestDXCluster(unittest.TestCase):
|
|
|
|
""" The unit tests for the DXCluster class. """
|
|
|
|
def setUp(self):
|
|
""" Set up the objects needed for the unit tests. """
|
|
self.dxcluster = DXCluster(parent=None)
|
|
|
|
def tearDown(self):
|
|
""" Destroy any unit test resources. """
|
|
pass
|
|
|
|
def test_on_telnet_io(self):
|
|
""" Check that the response from the Telnet server can be correctly decoded. """
|
|
|
|
telnetlib.Telnet = unittest.mock.Mock(spec=telnetlib.Telnet)
|
|
connection = telnetlib.Telnet("hello", "world")
|
|
connection.read_very_eager.return_value = b"Test message from the Telnet server."
|
|
self.dxcluster.connection = connection
|
|
result = self.dxcluster._on_telnet_io()
|
|
assert(result)
|
|
|
|
if(__name__ == '__main__'):
|
|
unittest.main()
|