Das deutsche Python-Forum

Code: Alles auswählen

import socket
import sys
import re
from thread import *

HOST = '' # symbolic name meaning all available interfaces
PORT = 31337 

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# print 'socket created'

try:
	s.bind((HOST, PORT))
except socket.error, msg:
	print 'binding failed, code: ' + str(msg[0]) + ' message: ' + msg[1]
	sys.exit()

# print 'socket bind complete'

s.listen(10)
print 'socket listening'

def clientthread(conn):

	memory = dict()
	key = ''

	# infinite loop
	dataToSave = ''
	waitingForData = False

	conn.sendall('000\n')

	while True:
		# receive from client
		data = conn.recv(1024)
		# split up received data
		result = data.split()
		count = len(result)

		print('Client: ' + data)


		if waitingForData:
			# TODO ask just for NEWLINE PERIOD NEWLINE
			if '.' in data:
				dataToSave = dataToSave + data
				dataToSave = dataToSave.replace(' ', '')[:-3]
				memory[key] = dataToSave
				print('PUT: Stored: ' + dataToSave + ' under ' + key)
				dataToSave = ''
				waitingForData = False
				reply = '000\n'	
			else:
				reply = '001\n'
				print('PUT: Receiving more data')
				dataToSave = dataToSave + data
		else:
			if count > 0:	
				if result[0] == 'PUT' or result[0] == 'GET':
					
					if count == 3:
						length = result[1]
						key = result[2]

						if result[0] == 'PUT':
							# PUT
							if key in memory:
								print('PUT: Key is already in system')
								reply = '102\n'
							else:
								print('PUT: Awaiting data')
								reply = '001\n'
								waitingForData = True
						else:
							# GET
							if key in memory:
								# TODO send data
								print('GET: Client demands ' + key)
								print(memory[key])
								reply = memory[key] + '\n'
								reply = reply + '000\n'
							else:
								print('GET: Key already in system')
								reply = '102\n'
					else: 
						# less than 2 different keywords
						print('Not exactly 3 words received')
						reply = '100\n'

				elif result[0] == 'CLEAR':
					if count == 2:

						key = result[1]

						if key in memory:
							print('CLEAR: Key accepted, deleting data')
							reply = 'deleting data\n'
							# TODO delete data
					else: 
						print('CLEAR: nNot exactly 2 words received')
						reply = '100\n'
				elif result[0] == 'QUIT':
					# quit
					print('QUIT: Client demands quit, quitting')
					conn.close()
				else:
					print('Unknown Command')
					reply = '100\n'
			else:
				print('No words received')
				reply = '100\n'

		if not data:
			break


		conn.sendall(reply)

		
	conn.close()


# keep talking with client
while 1:

	#wait to accept a connection - blocking call
	conn, addr = s.accept()

	# display client information
	print 'Connected with: ' + addr[0] + ' : ' + str(addr[1])

	# start new thread 1st argument is function to be run second is tuple of arguments for function
	start_new_thread(clientthread, (conn,))

s.close()

Code: Alles auswählen

if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function
import sys
from contextlib import closing
from socket import AF_INET, error as SocketError, socket as Socket, SOCK_STREAM
from threading import Thread

HOST = ''  # symbolic name meaning all available interfaces
PORT = 31337

OK_CODE = '000\n'
WAITING_FOR_DATA_CODE = '001\n'
KEY_ERROR_CODE = '002\n'
COMMAND_ERROR_CODE = '100\n'


def serve_client(connection):

    with closing(connection):
        memory = dict()
        key = None

        data_to_save = ''
        waiting_for_data = False

        connection.sendall(OK_CODE)

        while True:
            data = connection.recv(1024)
            print('Client: ' + data)
            if not data:
                break

            reply = None
            if waiting_for_data:
                # TODO ask just for NEWLINE PERIOD NEWLINE
                if '.' in data:
                    assert key is not None
                    data_to_save += data.replace(' ', '')[:-3]
                    memory[key] = data_to_save
                    print(
                        'PUT: Stored: {0!r} under {1!r}'.format(
                            data_to_save, key
                        )
                    )
                    data_to_save = ''
                    waiting_for_data = False
                    key = None
                    reply = OK_CODE
                else:
                    reply = WAITING_FOR_DATA_CODE
                    print('PUT: Receiving more data')
                    data_to_save += data
            else:
                request = data.split()
                count = len(request)
                if count > 0:
                    if request[0] == 'PUT' or request[0] == 'GET':

                        if count == 3:
                            length = request[1]
                            key = request[2]

                            if request[0] == 'PUT':
                                # PUT
                                if key in memory:
                                    print('PUT: Key is already in system')
                                    reply = KEY_ERROR_CODE
                                else:
                                    print('PUT: Awaiting data')
                                    reply = WAITING_FOR_DATA_CODE
                                    waiting_for_data = True
                            else:
                                # GET
                                if key in memory:
                                    # TODO send data
                                    print('GET: Client demands ' + key)
                                    print(memory[key])
                                    reply = memory[key] + '\n'
                                    reply = reply + OK_CODE
                                else:
                                    print('GET: Key already in system')
                                    reply = KEY_ERROR_CODE
                        else:
                            # less than 2 different keywords
                            print('Not exactly 3 words received')
                            reply = COMMAND_ERROR_CODE

                    elif request[0] == 'CLEAR':
                        if count == 2:

                            key = request[1]

                            if key in memory:
                                print('CLEAR: Key accepted, deleting data')
                                reply = 'deleting data\n'
                                # TODO delete data
                        else:
                            print('CLEAR: Not exactly 2 words received')
                            reply = COMMAND_ERROR_CODE
                    elif request[0] == 'QUIT':
                        # quit
                        print('QUIT: Client demands quit, quitting')
                        connection.close()
                    else:
                        print('Unknown Command')
                        reply = COMMAND_ERROR_CODE
                else:
                    print('No words received')
                    reply = COMMAND_ERROR_CODE

            assert reply is not None
            connection.sendall(reply)


def main():
    with closing(Socket(AF_INET, SOCK_STREAM)) as server_socket:

        try:
            server_socket.bind((HOST, PORT))
        except SocketError as error:
            print('binding failed, code: {0[0]} message: {0[1]}'.format(error))
            sys.exit(1)

        server_socket.listen(10)
        print('socket listening')

        while True:
            connection, address = server_socket.accept()
            print('Connected with: {0[0]} : {0[1]}'.format(address))

            thread = Thread(target=serve_client, args=(connection,))
            thread.start()


if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function
import sys
from contextlib import closing
from socket import AF_INET, error as SocketError, socket as Socket, SOCK_STREAM
from threading import Thread
 
HOST = ''  # symbolic name meaning all available interfaces
PORT = 31337

def willAcceptMoreData(data):
    if not '.' in data:
        return True
    else:
        return false

def serve_client(connection):
 
    with closing(connection):

        connection.sendall('000\n')

        while True:
            data = connection.recv(1024)
            if willAcceptMoreData(data):
                reply = None
            
                reply = data
                print('client: ' + data)

                assert reply is not None
                connection.sendall(reply)
            else:
                break
                
            
 
 
def main():
    with closing(Socket(AF_INET, SOCK_STREAM)) as server_socket:
 
        try:
            server_socket.bind((HOST, PORT))
        except SocketError as error:
            print('binding failed, code: {0[0]} message: {0[1]}'.format(error))
            sys.exit(1)
 
        server_socket.listen(10)
        print('socket listening')
 
        while True:
            connection, address = server_socket.accept()
            print('Connected with: {0[0]} : {0[1]}'.format(address))
 
            thread = Thread(target=serve_client, args=(connection,))
            thread.start()
 
 
if __name__ == '__main__':
    main()

Code: Alles auswählen

CS 9163 Working Group                                                   M. Bentz
Matt Declared Protocol: 0001                                                 NYU
                                                                        Sep 2014

                     Arbitrary Storage Protocol (ASP) v1



Status of this Memo

This document specifies a protocol for CS9163 students to implement.  Please
refer to the author for the most current edition of this document.  Distribution
is unlimited.


1. Overview

It is often nice to be able to store arbitrary data on a remote host.  This
statement is exceedingly vague and based on unquestioned assumptions.
Fortunately, the protocol herein described has no real purpose in the world
other than to provide a teachable experience to students in CS9163.


2. Basic Functionality

The protocol supports the storage and retrieval of arbitrary data for the
duration of a network session.  Information exchange between the client and
server are handled in a one-to-one fashion, i.e. each request by the client is
met with a response from the server.  These requests are handled by presenting
access methods to the server.  The server will respond with a response code
which indicates that the client should proceed, the method was a success, or an
error occurred.

The two basic methods GET and PUT store and retrieve those data associated with
a given key.  A type may be associated with each key.  There is no guarantee
that data will survive close of the connection.  The CLEAR method clears a key.
The QUIT method closes the session.


3. Methods


3.1 The PUT Method

The PUT method is the means by which a client requests data of an indicated
length (indicated in decimal integer bytes) be stored by the server under the
supplied key:

   "PUT" <space> <length> <space> <key> <newline>

The server will respond with one of the following codes:

   Proceed, Unknown Error, Length Error, Key Error

Upon receipt of the Proceed code, the client will send its data.  The completion
of this sent data will be indicated by <newline> <period> <newline>, i.e. a
period on its own line.  The server will associate as many bytes of this data as
specified in the method's length.  Superfluous bytes are ignored.  An
under-supply of data will cause a Length Error to result.  A successful store
will result in a Ready code.


3.2 The GET Method

The GET method is the means by which a client requests data associated with the
supplied key to be returned:

   "GET" <space> <length> <space> <key> <newline>

The server will respond with either the requested data and a Ready code or an
error code.  On success, the server immediately begins sending the data
associated with the supplied key up to the given length in bytes.  Upon
completion, it appends a <newline> to the data and sends a Ready code.

In the event of an error, the server may respond with one of the following
codes: 

   Unknown Error, Length Error, Key Error


3.3 The CLEAR Method

The CLEAR method removes a key and its associated data from the server's
consideration.  It is specified as follows:

   "CLEAR" <space> <key> <newline>

And may return one of the following codes:

   Ready, Unknown Error, Key Error


3.4 The QUIT Method

The QUIT method requests that the connection to the server be terminated.  It
results in no response code.


4. Response Codes

Response codes are numeric indicators of direction, information, success, and
failure.  All codes are sent with an immediately following newline.  They are as
follows:


4.1. Ready ("000")

The server is ready to accept the next request.


4.2. Proceed ("001")

The server is ready to receive your information.


4.3. Unknown Error ("100")

An unknown error has occurred.


4.4. Length Error ("101")

The method length is incorrect.  For a PUT method, the server may be unable to
store that amount of data.  For A GET method, the client may have requested more
bytes than were stored with that key.


4.5. Key Error ("102")

There is a problem with the key.  For a PUT method, the key is already present
and thereby in collision.  For a GET or CLEAR method, the key does not exist.


5. Example Sequence

The following is an example session between client and server.  Server sent
information is prepended by S: and client send information by C:

   S: 000
   C: PUT 13 foo
   S: 001
   C: Hello, world!
   C: .
   S: 000
   C: PUT 8 bar
   S: 001
   C: Rutabaga!
   C: .
   S: 000
   C: FEED dog
   S: 100
   C: GET 8 bar
   S: Rutabaga
   S: 000
   C: CLEAR foo
   S: 000
   C: CLEAR foo
   S: 102
   C: PUT 8 foo
   S: 001
   C: I am new data in foo!
   C: .
   S: 000
   C: GET 12 foo
   S: 101
   C: QUIT


6. ABNF Definitions

   <space>   = %x20 ; sp
   <newline> = %x0a ; nl
   <period>  = %x2e ; .
   <key>     = ALPHA / DIGIT
   <length>  = DIGIT


7. References

D. Crocker, "Augmented BNF for Syntax Specifications: ABNF", STD 68, RFC 5234,
Brandenburg InternetWorking, January 2008

Code: Alles auswählen

def willAcceptMoreData(data):
    return '.' not in data

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function
import sys
from contextlib import closing
from socket import AF_INET, error as SocketError, socket as Socket, SOCK_STREAM
from threading import Thread
 
HOST = ''  # symbolic name meaning all available interfaces
PORT = 31337
 
OK_CODE = '000\n'
WAITING_FOR_DATA_CODE = '001\n'
KEY_ERROR_CODE = '002\n'
COMMAND_ERROR_CODE = '100\n'
waiting_for_data = False
memory = dict()
data_to_save = ''
key = None



def get(memory, length, key):
    if key in memory:
        # TODO send data
        print('GET: Client demands ' + key)
        print(memory[key])
        return memory[key] + '\n' + OK_CODE
    else:
        print('GET: Key already in system')
        return KEY_ERROR_CODE

def put(memory, length, key):
    global waiting_for_data
    if key in memory:
        print('PUT: Key is already in system')
        return KEY_ERROR_CODE
    else:
        print('PUT: Awaiting data')
        waiting_for_data = True

        return WAITING_FOR_DATA_CODE

def process_incomming_data(data):
    global waiting_for_data
    global memory
    global data_to_save
    global key
    if waiting_for_data:
        # TODO ask just for NEWLINE PERIOD NEWLINE
        if '.\n' in data:
            assert key is not None
            data_to_save += data.replace(' ', '')[:-3]
            memory[key] = data_to_save
            print(
                'PUT: Stored: {0!r} under {1!r}'.format(
                    data_to_save, key
                )
            )
            data_to_save = ''
            waiting_for_data = False
            key = None
            return OK_CODE
        else:
            print('PUT: Receiving more data')
            data_to_save += data
            return WAITING_FOR_DATA_CODE

    else:
        request = data.split()
        count = len(request)
        if count > 0:
            if request[0] == 'PUT' or request[0] == 'GET':

                if count == 3:
                    length = request[1]
                    key = request[2]

                    if request[0] == 'PUT':
                        return put(memory, length, key)
                    else:
                        return get(memory, length, key)
                else:
                    # less than 2 different keywords
                    print('Not exactly 3 words received')
                    return COMMAND_ERROR_CODE

            elif request[0] == 'CLEAR':
                if count == 2:

                    key = request[1]

                    if key in memory:
                        print('CLEAR: Key accepted, deleting data')
                        return 'deleting data\n'
                        # TODO delete data
                else:
                    print('CLEAR: Not exactly 2 words received')
                    return COMMAND_ERROR_CODE
            elif request[0] == 'QUIT':
                # quit
                print('QUIT: Client demands quit, quitting')
                return 'quitting'
            else:
                print('Unknown Command')
                return COMMAND_ERROR_CODE
        else:
            print('No words received')
            return COMMAND_ERROR_CODE



def serve_client(connection):
 
    with closing(connection):
 
        connection.sendall(OK_CODE)
 
        while True:
            data = connection.recv(1024)
            print('Client: ' + data)
            if not data:
                break
 
            reply = None
            reply = process_incomming_data(data)
            if reply == 'quitting':
                connection.closing()
 
            assert reply is not None
            connection.sendall(reply)
 
 
def main():
    with closing(Socket(AF_INET, SOCK_STREAM)) as server_socket:
 
        try:
            server_socket.bind((HOST, PORT))
        except SocketError as error:
            print('binding failed, code: {0[0]} message: {0[1]}'.format(error))
            sys.exit(1)
 
        server_socket.listen(10)
        print('socket listening')
 
        while True:
            connection, address = server_socket.accept()
            print('Connected with: {0[0]} : {0[1]}'.format(address))
 
            thread = Thread(target=serve_client, args=(connection,))
            thread.start()
 
 
if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function
from collections import namedtuple
from contextlib import closing
from socket import (
    AF_INET, SOCK_STREAM, socket as Socket, SO_REUSEADDR, SOL_SOCKET
)
from threading import Thread


RECV_BUFFER_SIZE = 32 * 1024

READY_CODE = b'000\n'
PROCEED_CODE = b'001\n'
UNKNOWN_ERROR_CODE = b'100\n'
LENGTH_ERROR_CODE = b'101\n'
KEY_ERROR_CODE = b'102\n'


Session = namedtuple('Session', 'connection memory')


class Connection(object):

    def __init__(self, socket, recv_buffer_size=RECV_BUFFER_SIZE):
        self.socket = socket
        self.buffer = ''
        self.recv_buffer_size = recv_buffer_size

    def __iter__(self):
        return self

    __enter__ = __iter__

    def __exit__(self, *args):
        self.close()

    def read(self, end_marker=b'\n'):
        while True:
            try:
                end_index = self.buffer.index(end_marker)
            except ValueError:
                data = self.socket.recv(self.recv_buffer_size)
                if not data:
                    raise StopIteration
                self.buffer += data
            else:
                message = self.buffer[:end_index]
                self.buffer = self.buffer[end_index + len(end_marker):]
                return message

    next = read

    def write(self, data):
        self.socket.sendall(data)

    def close(self):
        self.socket.close()


def parse_length(string):
    result = int(string)
    if result < 0:
        raise ValueError
    return result


def do_put(session, (length, key)):
    try:
        length = parse_length(length)
    except ValueError:
        return UNKNOWN_ERROR_CODE

    if key in session.memory:
        return KEY_ERROR_CODE

    session.connection.write(PROCEED_CODE)
    data = session.connection.read(b'\n.\n')

    if len(data) < length:
        return LENGTH_ERROR_CODE

    session.memory[key] = data[:length]
    return READY_CODE


def do_get(session, (length, key)):
    try:
        length = parse_length(length)
    except ValueError:
        return UNKNOWN_ERROR_CODE

    try:
        data = session.memory[key]
    except KeyError:
        return KEY_ERROR_CODE

    if length > len(data):
        return LENGTH_ERROR_CODE

    session.connection.write(data[:length] + b'\n')
    return READY_CODE


def do_clear(session, (key,)):
    try:
        del session.memory[key]
    except KeyError:
        return KEY_ERROR_CODE
    else:
        return READY_CODE


COMMAND_TO_FUNCTION = {
    b'PUT': (do_put, 2),
    b'GET': (do_get, 2),
    b'CLEAR': (do_clear, 1),
    b'QUIT': (lambda *_: None, 0),
}


def split_arguments(string, count):
    if count != 0:
        result = string.split(' ', count - 1)
        if len(result) != count:
            raise ValueError('less than expected arguments')
    else:
        if string:
            raise ValueError('more than expected arguments')
        result = list()
    return result


def execute_line(session, line):
    command, _, remainder = line.partition(' ')
    do_command, argument_count = COMMAND_TO_FUNCTION.get(
        command, (None, None)
    )

    if not do_command:
        return UNKNOWN_ERROR_CODE

    try:
        arguments = split_arguments(remainder, argument_count)
    except ValueError:
        return UNKNOWN_ERROR_CODE
    else:
        return do_command(session, arguments)


def serve_client(socket):
    with Connection(socket) as connection:
        session = Session(connection, dict())
        session.connection.write(READY_CODE)
        for line in connection:
            response_code = execute_line(session, line)
            if response_code is None:
                break
            session.connection.write(response_code)


def main():
    address = ('localhost', 31337)
    with closing(Socket(AF_INET, SOCK_STREAM)) as server_socket:
        server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
        server_socket.bind(address)
        server_socket.listen(10)
        print('Listening on {0[0]}:{0[1]}...'.format(address))
        try:
            while True:
                socket, _ = server_socket.accept()
                thread = Thread(target=serve_client, args=(socket,))
                thread.daemon = True
                thread.start()
        except KeyboardInterrupt:
            print('Bye...')


if __name__ == '__main__':
    main()

Code: Alles auswählen

$ nc localhost 31337
000

100
PUT 5 foo bar
001
hallo
.
000
GET 5 foo bar
hallo
000
QUIT
$