Changeset 7c143c9 for server

Timestamp:

Dec 27, 2011, 10:20:10 PM (12 years ago)

Author:

Jessica B. Hamrick <jhamrick@…>

Branches:

no-cups

Children:

e58af05

Parents:

ee8e6d0

git-author:

Jessica B. Hamrick <jhamrick@…> (12/27/11 22:20:10)

git-committer:

Jessica B. Hamrick <jhamrick@…> (12/27/11 22:20:10)

Message:

Add support for chunking, i.e. receiving file data

Location:

server/lib/gutenbach

Files:

• ipp/core/request.py (modified) (5 diffs)
• server/printer.py (modified) (2 diffs)
• server/requests.py (modified) (3 diffs)
• server/server.py (modified) (2 diffs)

server/lib/gutenbach/ipp/core/request.py

@@ -3 +3 @@
 from .constants import AttributeTags
 from .value import Value
+from .errors import ClientErrorBadRequest
 import sys
 import struct
 import logging
+import tempfile
 
 # initialize logger
@@ -83 +85 @@
         # that file handle
         if request is not None:
+            # minimum length is
+            if length < 9:
+                raise ClientErrorBadRequest("length (%d) < 9" % length)
+            
             # read the version-number (two signed chars)
             self.version        = struct.unpack('>bb', request.read(2))
@@ -105 +111 @@
             # read in the next byte
             next_byte = struct.unpack('>b', request.read(1))[0]
-            length -=1
+            length -= 1
             logger.debug("next byte : 0x%X" % next_byte)
 
@@ -179 +185 @@
             # once we hit the end-of-attributes tag, the only thing
             # left is the data, so go ahead and read all of it
-            assert length >= 0
-            self.data = request.read(length)
-            logger.debug("data : %s" % self.data)
+            if length < 0:
+                raise ClientErrorBadRequest("length (%d) < 0" % length)
+            
+            self.data = tempfile.TemporaryFile()
+            self.data.write(request.read(length))
+            self.data.seek(0)
+            
+            logger.debug("data : %d bytes" % length)
 
         # otherwise, just set the class variables to the keyword
@@ -228 +239 @@
         end_of_attributes_tag = struct.pack('>b', AttributeTags.END)
 
-        # convert the data to binary
-        if self.data is not None:
-            data = ''.join([struct.pack('>b', x) for x in self.data])
-        else:
-            data = ''
-
         # append everything together and return it
-        return preattributes + attribute_groups + end_of_attributes_tag + data
+        return preattributes + attribute_groups + end_of_attributes_tag, self.data
 
     def __repr__(self):

server/lib/gutenbach/server/printer.py

@@ -67 +67 @@
         self.jobs = {}
 
-        self._next_jobid = 0
+        # cups ignores jobs with id 0, so we have to start at 1
+        self._next_jobid = 1 
 
     def __getattr__(self, attr):
@@ -218 +219 @@
         self.jobs[job_id] = job
         self.active_jobs.append(job_id)
-        print self.active_jobs
         return job
 

server/lib/gutenbach/server/requests.py

@@ -41 +41 @@
 
     def __init__(self):
-        print "init"
         self.printers = {
             "test": GutenbachPrinter(name="test")
@@ -89 +88 @@
         # actually get the handler
         handler = getattr(self, handler_name)
-        logger.info("Handling request of type '%s'" % handler_name)
+        logger.info("request is '%s'" % handler_name)
 
         # try to handle the request
@@ -116 +115 @@
 
     def unknown_operation(self, request, response):
-        logger.warning("Received unknown operation 0x%x" % request.operation_id)
+        logger.warning("unknown operation 0x%x" % request.operation_id)
         response = make_empty_response(request)
         response.operation_id = ipp.StatusCodes.OPERATION_NOT_SUPPORTED

server/lib/gutenbach/server/server.py

@@ -5 +5 @@
 import sys
 import traceback
+import tempfile
 
 # initialize logger
@@ -13 +14 @@
 
 class GutenbachIPPServer(BaseHTTPServer.BaseHTTPRequestHandler):
+    def send_continue(self):
+        self.send_response(100, "continue")
+        self.send_header("Content-Type", "application/ipp")
+        self.end_headers()
+
+    def send_ok(self, response):
+        logger.debug(repr(response))
+        binary, data_file = response.packed_value
+            
+        self.send_response(200, "ok")
+        self.send_header("Content-Type", "application/ipp")
+        self.send_header("Connection", "close")
+        self.end_headers()
+        
+        self.wfile.write(binary)
+        if data_file is not None:
+            data = data_file.read(1024)
+            while data != '':
+                self.wfile.write(data)
+                data = data_file.read(1024)
+
+    def log_request(self, code=0, size=0):
+        logger.info("response (%s)" % code)
+
+    def log_message(self, fmt, *args):
+        logger.info(fmt % args)
+
+    def read_chunks(self):
+        size = sys.maxint
+        totalsize = 0
+
+        with tempfile.SpooledTemporaryFile() as tmp:
+            while size > 0:
+                a, b = self.rfile.read(2)
+                size = a + b
+                while not (a == "\r" and b == "\n"):
+                    a = b
+                    b = self.rfile.read(1)
+                    size += b
+                size = int(size[:-2], base=16)
+                totalsize += size
+                chunk = self.rfile.read(size)
+                clrf = self.rfile.read(2)
+                assert clrf == "\r\n"
+                tmp.write(chunk)
+
+            tmp.seek(0)
+            request = ipp.Request(request=tmp, length=totalsize)
+
+        return request
+                
     def do_POST(self):
-        # Receive a request
         length = int(self.headers.getheader('content-length', 0))
-        if length == 0:
-            logger.warning("content-length == 0")
-            return
-        request = ipp.Request(request=self.rfile, length=length)
+        expect = self.headers.getheader('expect', None)
+        encoding = self.headers.getheader('transfer-encoding', None)
+
+        logger.info("request %s (%d bytes)" % (self.command, length))
+        logger.debug(str(self.headers))
+
+        # Parse the request
+        if length == 0 and encoding == "chunked":
+            request = self.read_chunks()
+        else:
+            request = ipp.Request(request=self.rfile, length=length)
 
         # Get the handler and pass it the request and response
         # objects.  It will fill in values for the response object or
         # throw a fatal error.
-        logger.debug("Received request: %s" % repr(request))
-        try:
-            response = handler.handle(request)
-        except:
-            logger.fatal(traceback.format_exc())
-            sys.exit(1)
-
-        # Send the response across HTTP
-        logger.debug("Sending response: %s" % repr(response))
-        try:
-            binary = response.packed_value
-        except:
-            logger.fatal(traceback.format_exc())
-            sys.exit(1)
-            
-        self.send_response(200, "Gutenbach IPP Response")
-        self.send_header("Content-Type", "application/ipp")
-        self.send_header("Connection", "close")
-        self.end_headers()
-        self.wfile.write(binary)
+        logger.debug("request: %s" % repr(request))
+        response = handler.handle(request)
+        self.send_ok(response)