TCPHandler #Eventghost

__init__.py

import eg
import json
import socket
import threading
from threading import Event, Thread
import wx.lib.scrolledpanel as scrolled

eg.RegisterPlugin(
    name="TCP handler",
    author="Glu",
    guid = "{F84DA764-CCCE-4458-A5D1-BA2B8333CD41}",
    version="0.1.0",
    kind="other",
    description="This will Send TCP Message"
)

class ScrollPanel(scrolled.ScrolledPanel):
    def __init__(self, parent):
        scrolled.ScrolledPanel.__init__(self, parent, -1)


class TcpHandlerObject():
    def __init__(self):
        pass
    def send(self,server,message,timeout):
        try:
            client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client.settimeout(timeout)
            client.connect(server)
            client.send(message)
            client.close()
            print('Message Sent')
        except:
            print('Sending error')
            pass


class ThreadedServer(object):
    def __init__(self, host, port, plugin):
        self.plugin = plugin
        self.host = host
        self.port = port
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.sock.bind((self.host, self.port))
        print('Listening :  ' + str(socket.gethostbyname(socket.gethostname())) + ': ' + str(self.port))
        self.connect = True
        self.client = None

    def disconnect(self):
        # self.sock.shutdown(socket.SHUT_RDWR)
        self.connect = False
        if (self.client is not None):
            print('Cleint closed')
            self.client.close()
        self.sock.close()
        print('Diconnected...')

    def stopsock(self):
        client = socket.socket(socket.AF_INET,
                               socket.SOCK_STREAM)  # we wan to close the .accept alse so we mock connection
        client.connect(("127.0.0.1", self.port))

    def listen(self):
        self.sock.listen(5)
        self.connect = True
        while (self.connect):
            self.client, address = self.sock.accept()
            self.client.settimeout(60)
            threading.Thread(target=self.listenToClient, args=(self.client, address)).start()

    def listenToClient(self, client, address):
        size = 1024
        response = ""
        if (self.connect == False):
            client.close()
            print('Plugin is closed')
            return
        #print(address)
        while (True):
            try:
                data = client.recv(size)
                if '\r\n' in data:
                    response = response + data
                    client.send(" ")#Here we send response back
                    client.close()
                    break;
                if data:
                    # Set the response to echo back the recieved data
                    response = response + data
                else:
                    response = response + data  
                    client.close()
                    break
            except:
                client.close()
                break
        client.close()
        ##here we got the message
        self.plugin.TriggerEvent(str(address), response)
        #print("Already closed")
        #print(response)

class TCPhandler(eg.PluginBase):
    def __init__(self):
        self.AddAction(Control)

    def addLine(self, label, control, width=400):
        if (label is not None):
            self.boxsizer.Add(wx.StaticText(self.panel, -1, label + ":"), 0, wx.TOP, 3)
        try:
            control.Size.SetWidth(width)
        except AttributeError:
            print("no Width: " + str(label))
        self.boxsizer.Add(control, 0)
        return control

    def addGroup(self, label):
        sb = wx.StaticBox(self.spanel, label=label)
        self.boxsizer = wx.StaticBoxSizer(sb, wx.VERTICAL)
        self.panel.sizer.Add(self.boxsizer)

    def Configure(self, myport='8989'):
        panel = eg.ConfigPanel(resizable=False)
        self.panel = panel
        self.spanel = ScrollPanel(panel)
        self.spanel.SetupScrolling()
        panel.sizer.Add(self.spanel, 1, wx.ALL | wx.EXPAND)
        self.addGroup("EventGhost Properties")
        # publicIpCtrl = self.addLine("Your Public IP or Host Name (like a dyndns host name). Leave blank to get it automatically", "")
        # textControl = wx.TextCtrl(panel, -1, myport)
        text = 'Please select the port of your choice.\n\nIf it is not working please\nchange the port'
        text = text + ',as the port might\nbe use in another service\n\n\n'
        portCtrl = self.addLine(text + "Port", panel.SpinIntCtrl(myport, min=1, max=65535))
        # panel.sizer.Add(textControl, 1, wx.EXPAND)
        while panel.Affirmed():
            panel.SetResult(portCtrl.GetValue())

    def __start__(self,port):
        self.port = port
        self.stopThreadEvent = Event()
        thread = Thread(
            target=self.ThreadLoop,
        )
        thread.start()
    def ThreadLoop(self):
        self.treadserver = ThreadedServer('', int(self.port), self)
        threading.Thread(target=self.treadserver.listen, ).start()

    def __stop__(self):
        try:
            self.treadserver.disconnect()
            self.treadserver.stopsock()
        except:
            print('Error in disconnect')
            pass


class SendingThread(threading.Thread):
    def __init__(self,tcphandler,server,message,timeout):
        super(SendingThread, self).__init__()
        self.tcphandler=tcphandler
        self.server=server
        self.message=message
        self.timeout=timeout

    def run(self):
        self.tcphandler.send(self.server,self.message,self.timeout)

class Control(eg.ActionBase):
    name = "Send Message"
    description = "Send message to another device...."

    def __call__(self,server,message,timeout):
        tcphandler=TcpHandlerObject()
        thread = SendingThread(tcphandler,server,message,timeout)
        thread.start()