Changes in / [b77e57e:079ef11]


Ignore:
Location:
server
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • server/lib/gutenbach/server/errors.py

    r5e70cc2 r951ab1b  
    1313
    1414class InvalidPrinterStateException(Exception):
    15     errstr = {
    16         3: "idle",
    17         4: "processing",
    18         5: "stopped"
    19         }
    20    
    2115    def __init__(self, state):
    22         self.state = int(state)
     16        self.state = hex(state)
    2317    def __str__(self):
    24         return "Invalid printer state: %s (%s)" % \
    25                (self.errstr[self.state], hex(self.state))
     18        return "Invalid printer state: %s" % self.state
    2619
    2720class InvalidJobStateException(Exception):

  • server/lib/gutenbach/server/job.py

    r0494098 rbd5bffc  
    415415            raise errors.InvalidJobStateException(self.state)
    416416
    417         logger.debug("restarting job %d", self.id)
     417        logger.debug("restarting job %d" % (self.id, self.document))
    418418
    419419        self._why_done = None
    420         fh = self.player.fh
    421 
    422         if not fh or fh.closed:
    423             raise RuntimeError, "file handler is closed"
    424 
    425         self.player = Player(fh)
     420        self.spool(self.document)

  • server/lib/gutenbach/server/printer.py

    r7e29e6a r57bc2dc  
    8585
    8686        self.lock = threading.RLock()
    87         self._running = False
     87        self.running = False
    8888        self.paused = False
    8989
    … …  
    9191        self._next_job_id = 1
    9292
    93     @sync
    9493    def __repr__(self):
    9594        return str(self)
    9695
    97     @sync
    9896    def __str__(self):
    99         return "<Printer '%s'>" % self.name
     97        return "<Printer '%s'>" % self.name 
    10098
    10199    def run(self):
    102         self._running = True
    103         while self._running:
    104             try:
    105                 with self.lock:
    106                     if self.current_job is None:
     100        self.running = True
     101        while self.running:
     102            with self.lock:
     103                try:
     104                    if not self.paused and self.current_job is None:
    107105                        self.start_job()
    108106                    elif self.current_job.is_done:
    109107                        self.complete_job()
    110             except:
    111                 logger.fatal(traceback.format_exc())
    112                 sys.exit(1)
     108                except:
     109                    logger.fatal(traceback.format_exc())
     110                    sys.exit(1)
    113111            time.sleep(0.1)
    114112
    115     def stop(self):
    116         with self.lock:
    117             self._running = False
    118         if self.ident is not None and self.isAlive():
    119             self.join()
    120 
    121113    ######################################################################
    122114    ###                          Properties                            ###
    123115    ######################################################################
    124 
    125     @property
    126     def name(self):
    127         return self._name
    128     @name.setter
    129     def name(self, val):
    130         try:
    131             self._name = str(val)
    132         except:
    133             self._name = "gutenbach-printer"
    134 
    135     @property
    136     def config(self):
    137         return self._config
    138     @config.setter
    139     def config(self, val):
    140         try:
    141             _config = dict(val).copy()
    142         except:
    143             raise ValueError, "not a dictionary"
    144         if 'ipp-versions' not in _config:
    145             raise ValueError, "missing ipp-versions"
    146         self._config = _config
    147116
    148117    @property
    … …  
    159128    @sync
    160129    def state(self):
    161         if self.is_running and self.current_job is not None:
    162             state = States.PROCESSING
    163         elif self.is_running and len(self.pending_jobs) == 0:
    164             state = States.IDLE
     130        if self.current_job is not None:
     131            return States.PROCESSING
     132        elif len(self.pending_jobs) == 0:
     133            return States.IDLE
    165134        else:
    166             state = States.STOPPED
    167         return state
     135            return States.STOPPED
    168136
    169137    @property
    … …  
    175143        return jobs
    176144
    177     @property
    178     def is_running(self):
    179         running = self.ident is not None and self.isAlive() and self._running
    180         return running
    181 
    182145    ######################################################################
    183146    ###                            Methods                             ###
    … …  
    185148
    186149    @sync
    187     def assert_running(self):
    188         if not self.is_running:
    189             raise RuntimeError, "%s not started" % str(self)
    190 
    191     @sync
    192150    def start_job(self):
    193         self.assert_running()
    194         if not self.paused and self.current_job is None:
     151        if self.current_job is None:
    195152            try:
    196153                job_id = heapq.heappop(self.pending_jobs)
    … …  
    205162    @sync
    206163    def complete_job(self):
    207         self.assert_running()
    208         if not self.paused and self.current_job is not None:
    209             try:
    210                 if not self.current_job.is_done:
    211                     self.current_job.stop()
    212             finally:
    213                 self.finished_jobs.append(self.current_job.id)
    214                 self.current_job = None
     164        if self.current_job is None:
     165            return
     166
     167        try:
     168            if not self.current_job.is_done:
     169                self.current_job.stop()
     170        finally:
     171            self.finished_jobs.append(self.current_job.id)
     172            self.current_job = None
    215173
    216174    @sync
    217175    def get_job(self, job_id):
    218         self.assert_running()
    219176        if job_id not in self.jobs:
    220177            raise InvalidJobException(job_id)
    … …  
    227184    @property
    228185    def printer_uri_supported(self):
    229         self.assert_running()
    230186        return ipp.PrinterUriSupported(self.uri)
    231187    @printer_uri_supported.setter
    232188    def printer_uri_supported(self, val):
    233         self.assert_running()
    234189        raise ipp.errors.AttributesNotSettable("printer-uri-supported")
    235190
    236191    @property
    237192    def uri_authentication_supported(self):
    238         self.assert_running()
    239193        return ipp.UriAuthenticationSupported("none")
    240194    @uri_authentication_supported.setter
    241195    def uri_authentication_supported(self, val):
    242         self.assert_running()
    243196        raise ipp.errors.AttributesNotSettable("uri-authentication-supported")
    244197
    245198    @property
    246199    def uri_security_supported(self):
    247         self.assert_running()
    248200        return ipp.UriSecuritySupported("none")
    249201    @uri_security_supported.setter
    250202    def uri_security_supported(self, val):
    251         self.assert_running()
    252203        raise ipp.errors.AttributesNotSettable("uri-security-supported")
    253204
    254205    @property
    255206    def printer_name(self):
    256         self.assert_running()
    257207        return ipp.PrinterName(self.name)
    258208    @printer_name.setter
    259209    def printer_name(self, val):
    260         self.assert_running()
    261210        raise ipp.errors.AttributesNotSettable("printer-name")
    262211
    263212    @property
    264213    def printer_state(self):
    265         self.assert_running()
    266214        return ipp.PrinterState(self.state)
    267215    @printer_state.setter
    268216    def printer_state(self, val):
    269         self.assert_running()
    270217        raise ipp.errors.AttributesNotSettable("printer-state")
    271218
    272219    @property
    273220    def printer_state_reasons(self):
    274         self.assert_running()
    275221        return ipp.PrinterStateReasons("none")
    276222    @printer_state_reasons.setter
    277223    def printer_state_reasons(self, val):
    278         self.assert_running()
    279224        raise ipp.errors.AttributesNotSettable("printer-state-reasons")
    280225
    281226    @property
    282227    def ipp_versions_supported(self):
    283         self.assert_running()
    284228        return ipp.IppVersionsSupported(*self.config['ipp-versions'])
    285229    @ipp_versions_supported.setter
    286230    def ipp_versions_supported(self, val):
    287         self.assert_running()
    288231        raise ipp.errors.AttributesNotSettable("ipp-versions-supported")
    289232
    … …  
    291234    @property
    292235    def operations_supported(self):
    293         self.assert_running()
    294236        return ipp.OperationsSupported(ipp.OperationCodes.GET_JOBS)
    295237    @operations_supported.setter
    296238    def operations_supported(self, val):
    297         self.assert_running()
    298239        raise ipp.errors.AttributesNotSettable("operations-supported")
    299240
    300241    @property
    301242    def charset_configured(self):
    302         self.assert_running()
    303243        return ipp.CharsetConfigured("utf-8") # XXX
    304244    @charset_configured.setter
    305245    def charset_configured(self, val):
    306         self.assert_running()
    307246        raise ipp.errors.AttributesNotSettable("charset-configured")
    308247       
    309248    @property
    310249    def charset_supported(self):
    311         self.assert_running()
    312250        return ipp.CharsetSupported("utf-8") # XXX
    313251    @charset_supported.setter
    314252    def charset_supported(self, val):
    315         self.assert_running()
    316253        raise ipp.errors.AttributesNotSettable("charset-supported")
    317254
    318255    @property
    319256    def natural_language_configured(self):
    320         self.assert_running()
    321257        return ipp.NaturalLanguageConfigured("en-us")
    322258    @natural_language_configured.setter
    323259    def natural_language_configured(self, val):
    324         self.assert_running()
    325260        raise ipp.errors.AttributesNotSettable("natural-language-configured")
    326261
    327262    @property
    328263    def generated_natural_language_supported(self):
    329         self.assert_running()
    330264        return ipp.GeneratedNaturalLanguageSupported("en-us")
    331265    @generated_natural_language_supported.setter
    332266    def generated_natural_language_supported(self, val):
    333         self.assert_running()
    334267        raise ipp.errors.AttributesNotSettable("generated-natural-language-supported")
    335268
    336269    @property
    337270    def document_format_default(self):
    338         self.assert_running()
    339271        return ipp.DocumentFormatDefault("application/octet-stream")
    340272    @document_format_default.setter
    341273    def document_format_default(self, val):
    342         self.assert_running()
    343274        raise ipp.errors.AttributesNotSettable("document-format-default")
    344275
    345276    @property
    346277    def document_format_supported(self):
    347         self.assert_running()
    348278        return ipp.DocumentFormatSupported("application/octet-stream", "audio/mp3")
    349279    @document_format_supported.setter
    350280    def document_format_supported(self, val):
    351         self.assert_running()
    352281        raise ipp.errors.AttributesNotSettable("document-format-supported")
    353282
    354283    @property
    355284    def printer_is_accepting_jobs(self):
    356         self.assert_running()
    357285        return ipp.PrinterIsAcceptingJobs(True)
    358286    @printer_is_accepting_jobs.setter
    359287    def printer_is_accepting_jobs(self, val):
    360         self.assert_running()
    361288        raise ipp.errors.AttributesNotSettable("printer-is-accepting-jobs")
    362289
    363290    @property
    364291    def queued_job_count(self):
    365         self.assert_running()
    366292        return ipp.QueuedJobCount(len(self.active_jobs))
    367293    @queued_job_count.setter
    368294    def queued_job_count(self, val):
    369         self.assert_running()
    370295        raise ipp.errors.AttributesNotSettable("queued-job-count")
    371296
    372297    @property
    373298    def pdl_override_supported(self):
    374         self.assert_running()
    375299        return ipp.PdlOverrideSupported("not-attempted")
    376300    @pdl_override_supported.setter
    377301    def pdl_override_supported(self, val):
    378         self.assert_running()
    379302        raise ipp.errors.AttributesNotSettable("pdl-override-supported")
    380303
    381304    @property
    382305    def printer_up_time(self):
    383         self.assert_running()
    384306        return ipp.PrinterUpTime(int(time.time()) - self.time_created)
    385307    @printer_up_time.setter
    386308    def printer_up_time(self, val):
    387         self.assert_running()
    388309        raise ipp.errors.AttributesNotSettable("printer-up-time")
    389310
    390311    @property
    391312    def compression_supported(self):
    392         self.assert_running()
    393313        return ipp.CompressionSupported("none")
    394314    @compression_supported.setter
    395315    def compression_supported(self, val):
    396         self.assert_running()
    397316        raise ipp.errors.AttributesNotSettable("compression-supported")
    398317
    399318    @property
    400319    def multiple_operation_time_out(self):
    401         self.assert_running()
    402320        return ipp.MultipleOperationTimeOut(240)
    403321    @multiple_operation_time_out.setter
    404322    def multiple_operation_time_out(self, val):
    405         self.assert_running()
    406323        raise ipp.errors.AttributesNotSettable("multiple-operation-time-out")
    407324
    408325    @property
    409326    def multiple_document_jobs_supported(self):
    410         self.assert_running()
    411327        return ipp.MultipleDocumentJobsSupported(False)
    412328    @multiple_document_jobs_supported.setter
    413329    def multiple_document_jobs_supported(self, val):
    414         self.assert_running()
    415330        raise ipp.errors.AttributesNotSettable("multiple-document-jobs-supported")
    416331
    … …  
    420335
    421336    def job_id(self, job_id):
    422         self.assert_running()
    423337        job = self.get_job(job_id)
    424338        return ipp.JobId(job.id)
    425339
    426340    def job_name(self, job_id):
    427         self.assert_running()
    428341        job = self.get_job(job_id)
    429342        return ipp.JobName(job.name)
    430343
    431344    def job_originating_user_name(self, job_id):
    432         self.assert_running()
    433345        job = self.get_job(job_id)
    434346        return ipp.JobOriginatingUserName(job.creator)
    435347
    436348    def job_k_octets(self, job_id):
    437         self.assert_running()
    438349        job = self.get_job(job_id)
    439350        return ipp.JobKOctets(job.size)
    440351
    441352    def job_state(self, job_id):
    442         self.assert_running()
    443353        job = self.get_job(job_id)
    444354        return ipp.JobState(job.state)
    445355
    446356    def job_printer_uri(self, job_id):
    447         self.assert_running()
    448357        job = self.get_job(job_id)
    449358        return ipp.JobPrinterUri(self.uri)
    … …  
    453362    ######################################################################
    454363
    455     @sync
    456364    def print_job(self, document, document_name=None, document_format=None,
    457365                  document_natural_language=None, requesting_user_name=None,
    458366                  compression=None, job_name=None, job_k_octets=None):
    459 
    460         self.assert_running()
    461367
    462368        # create the job
    … …  
    479385        return job_id
    480386
    481     @sync
    482     def validate_job(self, document_name=None, document_format=None,
    483                      document_natural_language=None, requesting_user_name=None,
    484                      compression=None, job_name=None, job_k_octets=None):
    485 
    486         self.assert_running()
     387    def verify_job(self, document_name=None, document_format=None,
     388                  document_natural_language=None, requesting_user_name=None,
     389                  compression=None, job_name=None, job_k_octets=None):
    487390
    488391        job_id = self._next_job_id
    … …  
    495398        del job
    496399
    497     @sync
    498400    def get_jobs(self, requesting_user_name=None, which_jobs=None,
    499401                 requested_attributes=None):
    500402       
    501         self.assert_running()
    502 
    503403        # Filter by the which-jobs attribute
    504404        if which_jobs is None:
    … …  
    525425        return job_attrs
    526426
    527     @sync
    528427    def print_uri(self):
    529         self.assert_running()
    530 
    531     @sync
     428        pass
     429
    532430    def create_job(self, requesting_user_name=None, job_name=None,
    533431                   job_k_octets=None):
    534 
    535         self.assert_running()
    536432
    537433        job_id = self._next_job_id
    … …  
    554450        Does nothing if the printer is already paused.
    555451        """
    556        
    557         self.assert_running()
    558         if not self.paused:
    559             if self.current_job is not None and self.current_job.is_playing:
    560                 self.current_job.pause()
    561             self.paused = True
    562             logger.info("%s paused", str(self))
     452        if self.paused:
     453            return
     454
     455        if self.current_job is not None and self.current_job.is_playing:
     456            self.current_job.pause()
     457
     458        self.paused = True
    563459
    564460    @sync
    … …  
    568464        Does nothing if the printer is not paused.
    569465        """
    570        
    571         self.assert_running()
    572         if self.paused:
    573             if self.current_job is not None:
    574                 self.current_job.resume()
    575             self.paused = False
    576             logger.info("%s unpaused", str(self))
     466        if not self.paused:
     467            return
     468
     469        if self.current_job is not None:
     470            self.current_job.resume()
     471
     472        self.paused = False
    577473
    578474    @sync
    579475    def get_printer_attributes(self, requested_attributes=None):
    580         self.assert_running()
    581476        if requested_attributes is None:
    582477            requested = self.printer_attributes
    … …  
    590485
    591486    @sync
    592     def set_printer_attributes(self, attributes):
    593         self.assert_running()
     487    def set_printer_attributes(self, job_id, attributes):
    594488        for attr in attributes:
    595489            try:
    … …  
    600494    @sync
    601495    def cancel_job(self, job_id, requesting_user_name=None):
    602         self.assert_running()
    603496        job = self.get_job(job_id)
    604497        try:
    … …  
    614507                      last_document=None):
    615508
    616         self.assert_running()
    617509        job = self.get_job(job_id)
    618510        job.spool(document)
    … …  
    623515                 requesting_user_name=None, compression=None,
    624516                 last_document=None):
    625 
    626         self.assert_running()
    627517        job = self.get_job(job_id)
    628518        # XXX: need to validate URI
    … …  
    632522    @sync
    633523    def get_job_attributes(self, job_id, requested_attributes=None):
    634 
    635         self.assert_running()
    636524        if requested_attributes is None:
    637525            requested = self.job_attributes
    … …  
    646534    @sync
    647535    def set_job_attributes(self, job_id, attributes):
    648 
    649         self.assert_running()
    650536        job = self.get_job(job_id)
    651537        for attr in attributes:
    … …  
    659545    @sync
    660546    def restart_job(self, job_id, requesting_user_name=None):
    661 
    662         self.assert_running()
    663547        job = self.get_job(job_id)
    664548        try:
    … …  
    677561        # completes, this one will go next
    678562       
    679         self.assert_running()
    680563        job = self.get_job(job_id)
    681564        job.priority = 1 # XXX we need to actually do something

  • server/lib/gutenbach/server/requests.py

    rb77e57e r079ef11  
    169169
    170170        """
    171 
    172171        operation = request.attribute_groups[0]
    173172        document = request.data       
    … …  
    179178        compression = None
    180179        last_document = None
     180
     181
    181182        # requested printer uri
    182183        if 'printer-uri' not in operation:

  • server/test/server/job.py

    r0494098 rbd5bffc  
    201201
    202202    def testRestart(self):
    203         self.assertRaises(errors.InvalidJobStateException, self.job.restart)
    204 
    205         self.job.play()
    206         self.assertTrue(self.job.is_playing)
    207         self.assertFalse(self.job.is_done)
    208 
    209         self.assertRaises(errors.InvalidJobStateException, self.job.restart)
    210 
    211         self.job.cancel()
    212         self.assertFalse(self.job.is_playing)
    213         self.assertTrue(self.job.is_done)
    214         self.assertTrue(self.job.is_cancelled)
    215         self.assertFalse(self.job.is_aborted)
    216 
    217         self.job.restart()
    218         self.assertTrue(self.job.is_ready)
     203        # XXX: Todo
     204        pass
    219205
    220206if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.