Changeset 345c476


Ignore:
Timestamp:
Jan 11, 2012, 8:36:27 PM (12 years ago)
Author:
Jessica B. Hamrick <jhamrick@…>
Branches:
no-cups
Children:
a2b0582
Parents:
09790fe
git-author:
Jessica B. Hamrick <jhamrick@…> (01/11/12 20:36:27)
git-committer:
Jessica B. Hamrick <jhamrick@…> (01/11/12 20:36:27)
Message:

Make status handling better in job.py

Location:
server
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r33ea505 r345c476  
    1010class GutenbachJob(object):
    1111
    12     def __init__(self, job_id=None, creator=None, name=None):
     12    def __init__(self, job_id=None, creator=None, name=None,
     13                 priority=None, document=None):
    1314        """Create an empty Gutenbach job.
    1415
    … …  
    1617
    1718        self.player = None
     19        self.document = None
    1820
    1921        self.id = job_id
    2022        self.creator = creator
    2123        self.name = name
    22         self.state = States.HELD
    23         self.priority = 1
    24         self.document = None
     24        self.priority = priority
     25        self._why_done = None
     26
     27        if document is not None:
     28            self.spool(document)
    2529
    2630    def __repr__(self):
    … …  
    4751    def id(self, val):
    4852        try:
    49             self._id = int(val)
     53            self._id = max(int(val), -1)
    5054        except TypeError:
    5155            self._id = -1
     56
     57    @property
     58    def priority(self):
     59        return self._priority
     60    @priority.setter
     61    def priority(self, val):
     62        try:
     63            self._priority = max(int(val), 1)
     64        except TypeError:
     65            self._priority = 1
    5266
    5367    @property
    … …  
    90104
    91105    @property
     106    def is_valid(self):
     107        """Whether the job is ready to be manipulated (spooled,
     108        played, etc).  Note that playing the job still requires it to
     109        be spooled first.
     110
     111        """
     112        return self.id > 0 and \
     113               self.priority > 0
     114
     115    @property
     116    def is_ready(self):
     117        """Whether the job is ready to be played.
     118
     119        """
     120        return self.is_valid and \
     121               self.player is not None and \
     122               not self.player.is_playing and \
     123               not self._why_done == "cancelled" and \
     124               not self._why_done == "aborted"
     125
     126    @property
    92127    def is_playing(self):
    93         return self.state == States.PROCESSING
    94 
    95     @property
    96     def is_ready(self):
    97         return self.state == States.PENDING
    98 
    99     @property
    100     def is_finished(self):
    101         return self.state != States.PENDING and \
    102                self.state != States.PROCESSING and \
    103                self.state != States.HELD
    104        
     128        """Whether the job is currently playing (regardless of whether
     129        it's paused).
     130
     131        """
     132        return self.is_valid and \
     133               self.player is not None and \
     134               self.player.is_playing
     135
     136    @property
     137    def is_paused(self):
     138        """Whether the job is currently paused.
     139
     140        """
     141        return self.is_valid and \
     142               self.player is not None and \
     143               self.player.is_paused       
     144
     145    @property
     146    def is_done(self):
     147        return (self.is_valid and \
     148                self.player is not None and \
     149                self.player.is_done) or \
     150                (self._why_done == "cancelled" or \
     151                 self._why_done == "aborted")
     152
     153    @property
     154    def state(self):
     155        if self.is_ready:
     156            state = States.PENDING
     157        elif self.is_playing and not self.is_paused:
     158            state = States.PROCESSING
     159        elif self.is_playing and self.is_paused:
     160            state = States.STOPPED
     161        elif self.is_done and self._why_done == "completed":
     162            state = States.COMPLETE
     163        elif self.is_done and self._why_done == "cancelled":
     164            state = States.CANCELLED
     165        elif self.is_done and self._why_done == "aborted":
     166            state = States.ABORTED
     167        else:
     168            state = States.HELD
     169        return state
     170
    105171    ######################################################################
    106172    ###                            Methods                             ###
    107173    ######################################################################
    108174
    109     def spool(self, document, username=None):
    110         if self.state != States.HELD:
    111             raise InvalidJobStateException(self.state)
    112 
     175    def spool(self, document):
     176        if not self.is_valid:
     177            raise InvalidJobStateException(self.state)
    113178        self.document = document.name
    114179        self.player = Player(document)
    115         self.creator = username
    116         self.state = States.PENDING
    117 
    118180        logger.debug("document for job %d is '%s'" % (self.id, self.document))
    119 
    120181
    121182    def play(self):
    … …  
    140201        def _completed():
    141202            logger.info("completed job %s" % str(self))
    142             self.state = States.COMPLETE
    143             self.player = None
    144 
    145         self.state = States.PROCESSING
     203            self._why_done = "completed"
    146204        self.player.callback = _completed
    147205        self.player.start()
    … …  
    155213        if not self.is_playing:
    156214            raise InvalidJobStateException(self.state)
    157        
    158215        self.player.mplayer_pause()
    159         self.state = States.STOPPED
    160216
    161217    def cancel(self):
    162         def _canceled():
    163             logger.info("canceled job %s" % str(self))
    164             self.state = States.CANCELLED
    165             self.player = None
     218        def _cancelled():
     219            logger.info("cancelled job %s" % str(self))
     220            self._why_done = "cancelled"
    166221
    167222        if self.is_playing:
    168             self.player.callback = _canceled
     223            self.player.callback = _cancelled
    169224            self.player.mplayer_stop()
    170         elif self.is_finished:
    171             raise InvalidJobStateException(self.state)
    172        
    173         self.state = States.CANCELLED
     225        elif self.is_done and not self._why_done == "cancelled":
     226            raise InvalidJobStateException(self.state)
     227        else:
     228            _cancelled()
    174229
    175230    def abort(self):
    176231        def _aborted():
    177232            logger.info("aborted job %s" % str(self))
    178             self.state = States.ABORTED
    179             self.player = None
     233            self._why_done = "aborted"
    180234
    181235        if self.is_playing:
    182236            self.player.callback = _aborted
    183237            self.player.mplayer_stop()
    184         elif self.is_finished:
    185             raise InvalidJobStateException(self.state)
    186        
    187         self.state = States.ABORTED
    188 
    189 
     238        elif self.is_done and not self._why_done == "aborted":
     239            raise InvalidJobStateException(self.state)
     240        else:
     241            _aborted()
     242
     243

  • server/lib/gutenbach/server/player.py

    r33ea505 r345c476  
    1717            self.player = None
    1818            self._callback = None
     19            self._paused = False
    1920
    2021    @property
    … …  
    2324            playing = self.player and self.player.poll() is None
    2425        return playing
     26
     27    @property
     28    def is_paused(self):
     29        with self.lock:
     30            paused = self.is_playing and self._paused
     31        return paused
     32
     33    @property
     34    def is_done(self):
     35        with self.lock:
     36            done = self.player and self.player.poll() is not None
     37        return done
    2538
    2639    @property
    … …  
    4154                self.callback()
    4255
    43         self.fh.close()
    44         self.fh = None
    45 
    4656    def mplayer_play(self):
     57        if not self.isAlive():
     58            return
     59       
    4760        logger.info("playing file '%s'" % self.fh.name)
     61        self._paused = False
    4862       
    4963        # open mplayer
    … …  
    6377                break
    6478            time.sleep(0.1)
    65            
     79
    6680        logger.info("mplayer finished with code %d" % self.player.returncode)
    6781
    … …  
    7791
    7892    def mplayer_pause(self):
     93        if not self.isAlive():
     94            return
     95       
    7996        with self.lock:
    8097            if self.is_playing:
    8198                self.player.stdin.write("pause\n")
     99                self._paused = not(self._paused)
    82100               
    83101    def mplayer_stop(self):
     102        if not self.isAlive():
     103            return
     104       
    84105        with self.lock:
    85106            if self.is_playing:

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

    r33ea505 r345c476  
    101101                    if self.current_job is None:
    102102                        self.start_job()
    103                     elif self.current_job.is_finished:
     103                    elif self.current_job.is_done:
    104104                        self.complete_job()
    105105                except:
    … …  
    164164
    165165            try:
    166                 if not self.current_job.is_finished:
     166                if not self.current_job.is_done:
    167167                    self.current_job.stop()
    168168            finally:
    … …  
    382382
    383383        job = self.get_job(job_id)
    384         job.spool(document, username=requesting_user_name)
     384        job.spool(document)
    385385
    386386    def send_uri(self):

  • server/test/server/job.py

    r09790fe r345c476  
    3232
    3333    def testStateProperties(self):
     34        self.assertFalse(self.job.is_valid)
     35        self.assertFalse(self.job.is_ready)
    3436        self.assertFalse(self.job.is_playing)
    35         self.assertFalse(self.job.is_ready)
    36         self.assertFalse(self.job.is_finished)
     37        self.assertFalse(self.job.is_paused)
     38        self.assertFalse(self.job.is_done)
    3739
    3840    def testSpool(self):
    3941        fh = make_tempfile()
     42        # This should fail, because the id hasn't been set
     43        self.assertFalse(self.job.is_valid)
     44        self.job.id = 1
     45        self.assertTrue(self.job.is_valid)
     46        self.assertFalse(self.job.is_ready)
    4047        self.job.spool(fh)
    4148        self.assertEqual(self.job.document, fh.name)
    … …  
    4350        self.assertEqual(self.job.creator, "")
    4451        self.assertEqual(self.job.state, States.PENDING)
    45         # This should fail, because the id hasn't been set
    46         self.assertFalse(self.job.is_ready)
    47         self.job.id = 1
    4852        self.assertTrue(self.job.is_ready)
    4953        self.job.abort()
Note: See TracChangeset for help on using the changeset viewer.