Scratch

from scratch import *
import threading
import socket
import json

SHOST = raw_input('Host IP: ')
SPORT = int( raw_input('Host Port: ') )

if not SHOST:
    print('You must enter a host.')
    exit(1)

if not SPORT:
    print('You must enter a port.')
    exit(1)

class Client(threading.Thread):
    
    def __init__(self):
        threading.Thread.__init__(self)
        try:
            self.s = Scratch()
        except ScratchConnectionError, e:
            print(e)
            exit(1)

    def run(self):
        s = self.s
        while True:
            try:
                message = s.receive(0)
            except s.ScratchConnectionError, e:
                print(e)
                exit(1)
            print 'Scratch:',message
            server.send( json.dumps(message) )
    
    def send(self, message):
        s = self.s
        message = s.parse_message(message)
        
        print message
        if len( message['broadcast'] ) == 1:
            s.broadcast( message['broadcast'][0] )
        elif len( message['sensor-update'] ) == 1:
            s.sensorupdate( message['sensor-update'] )
    
class Server(threading.Thread):
    
    def __init__(self, ip, port):
        threading.Thread.__init__(self)
        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        
        self.s.connect((ip, port))
    
    def run(self):
        s = self.s
        while True:
            try:
                message = s.recv(1024)
            except:
                exit(1)
            print 'Server:',message
            scratch.send(message)
    
    def send(self, message):
        self.s.send(message)

server = Server(SHOST, SPORT) # Start up the class for Server
server.start() # This starts the 'run' function on the class as well.

scratch = Client() # Start up the class for Scratch
scratch.start() # This starts the 'run' function.

#!/usr/bin/env python 

""" 
An echo server that uses threads to handle multiple clients at a time. 
Entering any line of input at the terminal will exit the server. 
""" 

import select 
import socket 
import sys 
import threading 
import json

class Server: 
    def __init__(self): 
        self.host = '' 
        self.port = int( raw_input("Port: ") )
        self.backlog = 5 
        self.size = 1024 
        self.server = None 
        self.threads = [] 
        self.plugins = ['test']
        for plugin in self.plugins:
            exec( 'import '+plugin )

    def open_socket(self): 
        try: 
            self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
            self.server.bind((self.host,self.port)) 
            self.server.listen(5) 
        except socket.error, (value,message): 
            if self.server: 
                self.server.close() 
            print "Could not open socket: " + message 
            sys.exit(1) 

    def run(self):
        self.open_socket() # Open a socket so people can connect.
        running = 1
        id = 0 # To define each client.
        while running:
            id += 1 # Increase so no client has the same ID.
            c = Client(self.server.accept()) # Waits for a client then accepts it.
            print c.address[0], 'has connected.'
            c.start() # Starts it.
            self.threads.append(c) # Adds it to a list so the variable c and be used for the next client.

        # Disconnect all clients.
        self.server.close() # Disconnect socket.
        for c in self.threads: # For each thread
            c.join() # End that thread.

class Client(threading.Thread): 
    def __init__(self,(client,address)): 
        threading.Thread.__init__(self) 
        self.client = client 
        self.address = address 
        self.size = 1024 
        self.plugins = {}

    def run(self): 
        running = 1 
        while running: 
            try:
                data = self.client.recv(self.size) # Wait and receive data from client
                data = self.parse(data) # Parse it
            except:
                data = ''
            
            print data
            if data:
                for broadcast in data['broadcast']: # For every broadcast, do_broadcast('broadcast')
                    self.do_broadcast( broadcast )
            
                for sensor in data['sensor-update']: # For every sensor-update, do_sensor('sensor', 'value')
                    self.do_sensor( sensor, data['sensor-update'][sensor] )
            else:
                print self.address[0], 'has disconnected.'
                self.client.close()
                running = 0
    
    def parse(self, data): # Parse data
        data = json.loads( data )
    
    def load_plugin(self, plugin): # Load plugin into server plugins
        if plugin not in s.plugins:
            s.plugins.append( plugin )
            try:
                reload( plugin )
            except NameError:
                exec( 'import '+plugin )
        
    
    def unload_plugin(self, plugin): # Unload plugin from server plugins
        if plugin in s.plugins:
            s.plugins.remove( plugin )
            #exec( 'del '+plugin )
    
    def use_plugin(self, plugin): # Add plugin to client
        if plugin in s.plugins: # If it exists
            s.plugins.append( plugin ) # Add it
            exec( '''
            self.plugins[plugin] = '''+plugin+'''.Plugin(self) # Create the class
            '''
            )
            return 'Added plugin.'
        else: # Else, do nothing
            return 'No such plugin.'
    
    def not_plugin(self, plugin):
        if plugin in self.plugins:
            self.plugins.remove( plugin )
            return 'Plugin removed.'
        else:
            return 'No such plugin.'
    
    def do_broadcast(self, broadcast):
        if broadcast: 
            if broadcast[0] == '<':
                self.use_plugin( broadcast[1:-1] )
            elif broadcast[0] == '>':
                self.not_plugin( broadcast[1:-1] )
            elif broadcast[0] == '|':
                self.send_broadcast( broadcast[1:-1] )
            elif broadcast[0] == ':':
                for plugin in self.plugins:
                    try:
                        self.plugins[plugin].broadcast( broadcast[1:-1] )
                    except:
                        pass
        else: 
            self.client.close()
            return False
        return True
    
    def do_sensor(self, name, value):
        return True

    def send_broadcast(self, value):
        broadcast = sendScratchCommand( 'broadcast "'+value+'"' )
        self.client.send( broadcast )
    
    def send_sensor(self, name, value):
        sensor = sendScratchCommand( 'sensor-update "'+name+'" "'+value+'"' )
        self.client.send( sensor )
        
    def sendScratchCommand(cmd): # I was never sure what this did, but it's required.
        n = len(cmd)
        a = array('c')
        a.append(chr((n >> 24) & 0xFF))
        a.append(chr((n >> 16) & 0xFF))
        a.append(chr((n >>  8) & 0xFF))
        a.append(chr(n & 0xFF))
        return (a.tostring() + cmd)

if __name__ == "__main__": 
    s = Server() 
    s.run()

# Test Plugin

class Plugin(object):
    
    def __init__(self, owner):
        self.owner = owner
    
    def broadcast(self, message):
        owner = self.owner
        if message == 'test':
            owner.send_broadcast( "test" )
    
    def sensor(self, name, value):
        pass