def __init__(self, mcast_address, mcast_port, action):
super(Udp_Multicast_Listener, self).__init__()
self.action = action
self.groupAddress = QtNetwork.QHostAddress(mcast_address)
self.udpSocket = QtNetwork.QUdpSocket(self)
self.udpSocket.bind(mcast_port,
QtNetwork.QUdpSocket.DefaultForPlatform)
self.udpSocket.joinMulticastGroup(self.groupAddress)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
def download(self, blocking=True):
if blocking:
self.image = QtGui.QImage.fromData(urllib2.urlopen(self.url).read())
else:
self.image = None
self._networkManager = QtNetwork.QNetworkAccessManager()
request = QtNetwork.QNetworkRequest()
request.setUrl(QtCore.QUrl(self.url))
self._networkReply = self._networkManager.get(request)
self._networkReply.finished.connect(self._finishDownload)
self._networkReply.downloadProgress.connect(self._downloadProgress)
def update_author(cls, url, callback):
"""
We're assuming callback is the same all the time.
"""
if cls._network is None:
cls._network = QtNetwork.QNetworkAccessManager()
cls._network.finished.connect(cls.on_update_author)
cls._callback = callback
if not url.endswith(STORY_INDEX):
if not url.endswith('/'):
url += '/'
url += STORY_INDEX
cls._network.get(QtNetwork.QNetworkRequest(QtCore.QUrl(url)))
def ensure_singleton(self, name=None):
if not name:
name = self.applicationName()
from PySide import QtNetwork
self._l_socket = QtNetwork.QLocalSocket()
self._l_socket.connectToServer(name, QtCore.QIODevice.WriteOnly)
if self._l_socket.waitForConnected():
self._stop()
sys.exit(0)
else:
self._l_server = QtNetwork.QLocalServer()
if not self._l_server.listen(name):
QtNetwork.QLocalServer.removeServer(name)
self._l_server.listen(name)
self._l_server.newConnection.connect(self._show_window)
def __init__(self, parent=None):
QtCore.QObject.__init__(self, parent)
self.__server = QtNetwork.QTcpServer(self)
self.__server.newConnection.connect(self.__onNewConnection)
self.__queue = []
def run(self):
logger.debug("<-- TCP connection")
socket = QtNetwork.QTcpSocket()
socket.setSocketDescriptor(self.socket_descriptor)
socket.waitForReadyRead(1000)
data_stream = QtCore.QDataStream(socket)
data_stream.setVersion(QtCore.QDataStream.Qt_4_8)
data_size = data_stream.readUInt32()
data_uuid = data_stream.readString()
data_stream.unsetDevice()
logger.debug("<-- TCP incoming data size: %i bytes" % data_size)
data = QtCore.QByteArray()
read_iterations = 0
while data.size() < data_size and read_iterations < self.max_socket_read_iterations:
data_read = socket.readAll()
logger.debug("<-- READ %i bytes" % data_read.size())
data.append(data_read)
read_iterations += 1
socket.waitForReadyRead(100)
logger.debug("<-- TCP read %i bytes" % data.size())
if data.size() != data_size:
# broken data received
data.clear()
self.complete.emit(data_uuid, data)
def run(self):
socket = QtNetwork.QTcpSocket()
socket.connectToHost(self.host, self.port)
if not socket.waitForConnected(500):
# retry connection
socket.connectToHost(self.host, self.port)
if not socket.waitForConnected(500):
logger.info("--> TCP connection timeout")
self.complete.emit()
return
data_stream = QtCore.QDataStream(socket)
data_stream.setVersion(QtCore.QDataStream.Qt_4_8)
data_stream.writeUInt32(self.data.size())
data_stream.writeString(unicode(APP_UUID))
data_stream.unsetDevice()
socket.write(self.data.data())
socket.flush()
while socket.bytesToWrite() > 0:
if socket.state() == socket.ConnectedState:
socket.waitForBytesWritten(100)
else:
logger.debug("--> TCP host suddenly disconnected")
self.complete.emit()
return
logger.debug("--> TCP written %i bytes" % self.data.size())
socket.disconnectFromHost()
logger.debug("--> TCP disconnected")
self.complete.emit()
def __init__(self, socketId, parent=None):
super(updateServerThread, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.app = None
self.tableMod = "updates_faf"
self.tableModFiles = "updates_faf_files"
self.socket = QtNetwork.QTcpSocket(self)
self.socket.setSocketDescriptor(socketId)
self.parent = parent
self.patchToCreate = []
if self.socket.state() == 3 and self.socket.isValid():
self.nextBlockSize = 0
self.blockSize = 0
self.socket.readyRead.connect(self.readDatas)
self.socket.disconnected.connect(self.disconnection)
self.socket.error.connect(self.displayError)
self.parent.db.open()
def init(p_qt_webpage,
p_cookies_file_path,
p_on_request_handler_fun,
p_on_reply_handler_fun,
p_log_fun,
p_verbose_bool = False):
if p_verbose_bool: p_log_fun('FUN_ENTER','gf_test_web_net_mngr.init()')
assert inspect.isfunction(p_on_request_handler_fun)
assert inspect.isfunction(p_on_reply_handler_fun)
# Network Access Manager and cookies
#:QtNetwork.QNetworkAccessManager
qt_net_mngr = QtNetwork.QNetworkAccessManager()
p_qt_webpage.setNetworkAccessManager(qt_net_mngr)
set_net_mngr_event_handlers(qt_net_mngr,
p_on_request_handler_fun,
p_on_reply_handler_fun,
p_log_fun)
if not p_cookies_file_path == None:
gf_test_web_cookies.init_cookies(qt_net_mngr,
p_cookies_file_path,
p_log_fun)
def init_socket(self):
self.socket = QtNetwork.QUdpSocket(self)
#self.socket.bind(QtNetwork.QHostAddress.LocalHost, 3020)
self.socket.readyRead.connect(self.read_datagrams)
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.demo_write)
self.timer.start(10)
def configureNetwork(self): #self.blockSize = 0 self.socket = QtNetwork.QTcpServer() self.socket.name = 'Brainstorms Server' if self.DEBUG: print "<---- [%s] Initializing server on %s:%i" % \ (self.socket.name, self.server_interface, self.server_port) if (self.server_interface == ''): address=QtNetwork.QHostAddress.Any else: address=address=self.server_interface port = self.server_port result = self.socket.listen(address, port) if not result: if self.DEBUG: print "ERROR [%s] Unable to start the server:" % self.socket.name, print self.socket.errorString() self.socket.close() return self.socket.newConnection.connect(self.processConnection)
def __init__(self, socketId, parent=None):
super(tournamentServerThread, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.app = None
challonge.set_credentials(CHALLONGE_USER, CHALLONGE_KEY)
self.socket = QtNetwork.QTcpSocket(self)
self.socket.setSocketDescriptor(socketId)
self.parent = parent
if self.socket.state() == 3 and self.socket.isValid():
self.nextBlockSize = 0
self.blockSize = 0
self.socket.readyRead.connect(self.readDatas)
self.socket.disconnected.connect(self.disconnection)
#self.socket.error.connect(self.displayError)
self.parent.db.open()
self.pingTimer = QtCore.QTimer(self)
self.pingTimer.start(31000)
self.pingTimer.timeout.connect(self.ping)
def __init__(self, socket, parent=None):
super(GWServerThread, self).__init__(parent)
self.parent = parent
self.log = logging.getLogger(__name__)
self.log.debug("Incoming GW server socket started")
self.socket = None
self.socket = QtNetwork.QTcpSocket(self)
if self.socket.setSocketDescriptor(socket) == False:
self.log.debug("awful error : Socket descriptor not set")
self.socket.abort()
return
self.socket.readyRead.connect(self.readDatas)
self.socket.disconnected.connect(self.disconnection)
self.socket.error.connect(self.displayError)
self.socket.stateChanged.connect(self.stateChange)
self.blockSize = 0
try:
if not self.parent.games.isaContainer("gw"):
self.parent.games.addContainer(
"gw",
gwGamesContainerClass(self.parent.db, self.parent.games))
self.parent.games.reloadContainer("gw", force=True)
except:
self.log.exception(
"Something awful happened trying to put that thing!")
self.log.debug("Init done")
def init_socket(self):
self.socket = QtNetwork.QUdpSocket(self)
self.socket.readyRead.connect(self.read_datagrams)
self.socket.bind(
3010, QtNetwork.QUdpSocket.ShareAddress
| QtNetwork.QUdpSocket.ReuseAddressHint)
log.info("Listening on UDP 3010")
def __init__(self, ucast_port, action):
super(Udp_Unicast_Listener, self).__init__()
self.action = action
self.udpSocket = QtNetwork.QUdpSocket(self)
self.udpSocket.bind(ucast_port,
QtNetwork.QUdpSocket.DefaultForPlatform)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
def _new_request(self, path):
url = QtCore.QUrl("http://" + self.host + ":" + str(self.port) + "/" +
path)
request = QtNetwork.QNetworkRequest(url)
request.setHeader(request.ContentTypeHeader, "application/json")
request.setRawHeader("Accept", "application/json")
return request
def load_app(self):
self.view.load(QtCore.QUrl(PIXELATED_URI))
self.view.page().setForwardUnsupportedContent(True)
self.view.page().unsupportedContent.connect(self.download)
self.manager = QtNetwork.QNetworkAccessManager()
self.manager.finished.connect(self.finished)
def send(self, mtask):
# mpoints = melt(text, reverse_complement(text), M_CONDS)
# t = calc_t_at_conc([C_10, C_90], mpoints)
# self.setWindowTitle('{}/{}'.format(conc[C_10], conc[C_90]))
plots = [{
'action': 'add_graph',
'a': mpot.a,
'b': mpot.b,
'length': mpot.length_of_a,
'gc%': mpot.gc_of_a,
't10': mpot.t10,
't90': mpot.t90,
'mpoints': mpot.mpoints_as_XY,
'color': 'rnd',
'marker': 'rnd',
} for mpot in mtask.melting_pots]
messages = [yaml.dump({'plots': [plot]}) for plot in plots]
# message = yaml.dump({'plots':plots})
# print(message)
# self.__socket.writeDatagram(message,
# QtNetwork.QHostAddress(QtNetwork.QHostAddress.Broadcast),
# 45454)
for message in messages:
self.__socket.writeDatagram(
message,
QtNetwork.QHostAddress(QtNetwork.QHostAddress.Broadcast),
45454)
def __init__(self, parent=None):
super(Sender, self).__init__(parent)
self.statusLabel = QtGui.QLabel("Ready to broadcast datagrams on port 45454")
self.startButton = QtGui.QPushButton("&Start")
quitButton = QtGui.QPushButton("&Quit")
buttonBox = QtGui.QDialogButtonBox()
buttonBox.addButton(self.startButton, QtGui.QDialogButtonBox.ActionRole)
buttonBox.addButton(quitButton, QtGui.QDialogButtonBox.RejectRole)
self.timer = QtCore.QTimer(self)
self.udpSocket = QtNetwork.QUdpSocket(self)
self.messageNo = 1
self.startButton.clicked.connect(self.startBroadcasting)
quitButton.clicked.connect(self.close)
self.timer.timeout.connect(self.broadcastDatagramm)
mainLayout = QtGui.QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Broadcast Sender")
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
from PySide import QtNetwork
# Webkit is used to create icons from SVG files. This could cause a deadlock
# when setting up the internally used network interface. Doing this before
# creating the icons fixes the issue.
QtNetwork.QNetworkConfigurationManager()
def ensure_singleton(self, name=None):
if not name:
name = self.applicationName()
from PySide import QtNetwork
self._l_socket = QtNetwork.QLocalSocket()
self._l_socket.connectToServer(name, QtCore.QIODevice.WriteOnly)
if self._l_socket.waitForConnected():
self.worker.thread().quit()
self.deleteLater()
time.sleep(0.01) # Without this the process sometimes stalls.
sys.exit(0)
else:
self._l_server = QtNetwork.QLocalServer()
if not self._l_server.listen(name):
QtNetwork.QLocalServer.removeServer(name)
self._l_server.listen(name)
self._l_server.newConnection.connect(self._show_window)
def __init__(self):
QtCore.QObject.__init__(self)
self.server = QtNetwork.QTcpServer(self)
self.server.listen(QtNetwork.QHostAddress.Any, PORT)
self.server.newConnection.connect(self.addConnection)
self.clients = []
def configureNetwork(self):
#self.blockSize = 0
self.socket = QtNetwork.QTcpServer()
self.socket.name = 'ThinkGear Server'
if self.DEBUG:
print "<---- [%s] Initializing server on %s:%i" % \
(self.socket.name, self.server_interface, self.server_port)
if ((self.server_interface == '') or \
(self.server_interface == '*')):
address=QtNetwork.QHostAddress.Any
else:
#address=self.server_interface
address=QtNetwork.QHostAddress(self.server_interface)
result = self.socket.listen(address, self.server_port)
if not result:
try:
QtGui.QMessageBox.information( \
self.parent, \
self.socket.name, \
"Unable to start the server on %s:%i" % \
(self.server_interface, self.server_port))
except:
pass
if self.DEBUG:
print "ERROR [%s] Unable to start the server:" % self.socket.name,
print self.socket.errorString()
#self.parent.stopThinkGearConnectServer()
#self.parent.pushButtonThinkGearConnect.nextCheckState()
#self.parent.pushButtonThinkGearConnect.toggle()
#self.parent.pushButtonThinkGearConnect.test.emit(QtCore.SIGNAL("clicked()"))
self.socket.close()
return
self.socket.newConnection.connect(self.processConnection)
def connectToHost(self, host, port = 8128):
self.socket = QtNetwork.QTcpSocket()
self.socket.connectToHost(host, port)
if self.socket.waitForConnected(1000):
self.socket.readyRead.connect(self.receiveMessage)
self.socket.write('*,dump:%s|' % self.widgets['main'].zone.dump())
else:
raise netExceptConnectToHost
def __init__(self, address, port, action):
super(Tcp_Unicast_Listener, self).__init__()
self.action = action
self.tcpSocket = QtNetwork.QTcpSocket(self)
self.tcpSocket.readyRead.connect(self.read)
self.tcpSocket.abort()
self.tcpSocket.connectToHost(address, port)
def ensureSingle(self):
serverName = "MCEdit.Application"
socket = QtNetwork.QLocalSocket()
socket.connectToServer(serverName)
if socket.waitForConnected(500):
# xxx maybe write argv to the running app and have it open files?
log.error("%s already running", serverName)
raise SystemExit # Already running
def newConnection():
newSocket = server.nextPendingConnection()
newSocket.close()
self.mainWindow.activateWindow()
self.mainWindow.raise_()
server = QtNetwork.QLocalServer(newConnection=newConnection)
server._listener = newConnection
server.listen(serverName)
def connectToHost(self, host, port):
self.socket = QtNetwork.QTcpSocket()
self.socket.connectToHost(host, port)
if self.socket.waitForConnected(100):
self.socket.disconnected.connect(self.disconnectFromHost)
self.socket.readyRead.connect(self.receiveMessage)
self.connected = True
else:
raise netExceptConnectToHost
def __init__(self):
QtCore.QObject.__init__(self)
self.socket = QtNetwork.QUdpSocket(self)
self.timer = QtCore.QTimer()
self.timer.setInterval(500)
self.timer.timeout.connect(self.send_packet)
self.timer.start()
def onReturnPressed(self):
url = QtCore.QUrl(u'https://graph.facebook.com/me/feed')
url.addQueryItem(u'access_token', self.accessToken)
url.addQueryItem(u'message', self.input.text())
if len(self.picture.text()) > 0:
url.addQueryItem(u'picture', self.picture.text())
self.reply = self.nasm.post(QtNetwork.QNetworkRequest(url),
url.encodedQuery())
self.reply.finished.connect(self.onReply)
def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.urlLineEdit = QtGui.QLineEdit(
"http://www.ietf.org/iesg/1rfc_index.txt")
self.urlLabel = QtGui.QLabel(self.tr("&URL:"))
self.urlLabel.setBuddy(self.urlLineEdit)
self.statusLabel = QtGui.QLabel(
self.tr("Please enter the URL of a file "
"you want to download."))
self.quitButton = QtGui.QPushButton(self.tr("Quit"))
self.downloadButton = QtGui.QPushButton(self.tr("Download"))
self.downloadButton.setDefault(True)
self.progressDialog = QtGui.QProgressDialog(self)
self.http = QtNetwork.QHttp(self)
self.outFile = None
self.httpGetId = 0
self.httpRequestAborted = False
self.connect(self.urlLineEdit, QtCore.SIGNAL("textChanged(QString &)"),
self.enableDownloadButton)
self.connect(self.http, QtCore.SIGNAL("requestFinished(int, bool)"),
self.httpRequestFinished)
self.connect(self.http, QtCore.SIGNAL("dataReadProgress(int, int)"),
self.updateDataReadProgress)
self.connect(
self.http,
QtCore.SIGNAL("responseHeaderReceived(QHttpResponseHeader &)"),
self.readResponseHeader)
self.connect(self.progressDialog, QtCore.SIGNAL("canceled()"),
self.cancelDownload)
self.connect(self.downloadButton, QtCore.SIGNAL("clicked()"),
self.downloadFile)
self.connect(self.quitButton, QtCore.SIGNAL("clicked()"), self,
QtCore.SLOT("close()"))
topLayout = QtGui.QHBoxLayout()
topLayout.addWidget(self.urlLabel)
topLayout.addWidget(self.urlLineEdit)
buttonLayout = QtGui.QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(self.downloadButton)
buttonLayout.addWidget(self.quitButton)
mainLayout = QtGui.QVBoxLayout()
mainLayout.addLayout(topLayout)
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle(self.tr("HTTP"))
self.urlLineEdit.setFocus()
