dvd-server.py,v

Perfession Linux Programming examples

	    (key,value)=SHMEMBERS.first()
	    while 1 == 1:
		lst = string.split(value, "\\")
		no = lst[1]
		if no == memberno:
		    return string.atoi(key)
		(key,value) = SHMEMBERS.next()
	except:
	    raise DVD.MEMBERSHIP.NOSUCHMEMBER
class Titling:
    def set (self, recordtoupdate):
	try:
	    SHTITLES[idtostring(recordtoupdate.titleid)]= stringizetitle(recordtoupdate) 
	    SHTITLES.sync()
	except:
	    logit("TITLING", "Failure of set() contents for title %d"
		  % recordtoupdate.titleid) 
	logit("TITLING", "Success of set() contents for title %d" %
	      recordtoupdate.titleid) 
    def get (self, titleid):
	try:
	    record=SHTITLES[idtostring(titleid)]
	except:
	    logit("TITLING", "failure of get() contents for title %d"
		  % titleid) 
	    raise DVD.TITLING.NOSUCHTITLE
	logit("TITLING", "Success of get() contents for title %d" % titleid)
	return destringizetitle(record)
    def delete (self, titleid):
	try:
	    del SHTITLES[idtostring(titleid)]
	    SHTITLES.sync()
	    logit("Titling", "delete contents for %d" % titleid)
	except:
	    raise DVD.TITLING.NOSUCHTITLE
    def create (self, recordtoadd):
	lastid = DBMAX["titles"]
	lastid = lastid + 1
	logit("Titling", "Create new title record - %d" % lastid)
	DBMAX["titles"] = lastid
	recordtoadd.memberid = lastid
	SHTITLES[idtostring(lastid)]=stringizetitle(recordtoadd)
	SHTITLES.sync()
	return lastid
    def search (self, title, name):
	rseq = []
	try:
	    (key,value)=SHTITLES.first()
	    while 1 == 1:
		lst=string.split(value, "\\")
		titletext=lst[1]
		director=lst[3]
		actor1=lst[6]
		actor2=lst[7]
		keep="NO"
		if string.upper(director) == string.upper(name):
		    keep = "YES"
		if string.upper(actor1) == string.upper(name):
		    keep = "YES"
		if string.upper(actor2) == string.upper(name):
		    keep = "YES"
		if string.upper(titletext) == string.upper(title):
		    keep = "YES"
		if keep == "YES":
		    rseq.append (string.atoi(key))
		(key,value)=SHTITLES.next()
	except:
	    done = ""
	logit("Titling", "Search for %s" % title)
	#rseq.sort(lambda x, y: x-y)
	rseq.sort()
	return rseq
class Disks:
    def set (self, recordtoupdate):
	try:
	    SHDISKS[idtostring(recordtoupdate.diskid)]= stringizedisk(recordtoupdate)
	    SHDISKS.sync()
	except:
	    logit("DISKS", "Failure to set %d" % recordtoupdate.diskid)
	logit("DISKS", "Success of set() contents for disk %d" % recordtoupdate.diskid)
    def get (self, diskid):
	try:
	    record=SHDISKS[idtostring(diskid)]
	except:
	    logit("DISKS", "Failure of get() contents for disk %d" % diskid)
	    raise DVD.DISKS.NOSUCHDISK
	logit("DISKS", "Success of get() contents for disk %d" % diskid)
	ds=destringizedisk(record)
	print "Disk: ", ds.diskid, ds.titleid
	return ds
    def create (self, recordtoadd):
	lastid = DBMAX["disks"]
	lastid = lastid + 1
	logit("DISKS", "Create new disk record - %d" % lastid)
	DBMAX["disks"] = lastid
	recordtoadd.diskid = lastid
	SHDISKS[idtostring(lastid)]=stringizedisk(recordtoadd)
	SHDISKS.sync()
	logit("DISKS", "Create new disk for %d" % lastid)
	return lastid
    def delete (self, diskid):
	try:
	    del SHDISKS[idtostring(diskid)]
	    SHDISKS.sync()
	    logit("Disks", "delete contents for %d" % diskid)
	except:
	    raise DVD.DISKS.NOSUCHDISK
    def search (self, titleid):
	rseq = []
	try:
	    (key,value)= SHDISKS.first()
	    while 1 == 1:
		lst=string.split(value, "\\")
		if string.atoi(lst[1]) == titleid:
		    rseq.append (string.atoi(key))
		(key,value)= SHDISKS.next()
	except:
	    done = ""
	logit("DISKS", "Search for %s" % titleid)
	rseq.sort(lambda x, y: x-y)
	return rseq
class Rental:
    def set(self, disk, rentinfo):
	SHRENTALS[idtostring(disk)] = stringizerentinfo(rentinfo)
	# This should raise exceptions, but doesn't, at this point.
	# It's only being used internally in the server by the other
        # functions, and error checking is done in them
    def get(self, disk):
	try:
	    record=SHRENTALS[idtostring(disk)]
	except:
	    logit("DISKS", "Failure of get() contents for disk %d" % disk)
	    raise DVD.DISKS.NOSUCHDISK
	logit("DISKS", "Success of get() contents for disk %d" % disk)
	return destringizerentinfo(record)
    def renttitle (self, memberid, titleid):
	MEM= FACTORYOBJECT["membership"]
	TTL= FACTORYOBJECT["titling"]
	DSK= FACTORYOBJECT["disks"]
	RNT= FACTORYOBJECT["rentals"]
	RES= FACTORYOBJECT["reservations"]
	try:
	    mbr=MEM.get(memberid)
	except:
	    raise DVD.MEMBERSHIP.NOSUCHMEMBER
	try:
	    ttl=TTL.get(titleid)
	except:
	    raise DVD.TITLING.NOSUCHTITLE
	### If we stored info on what classifications were permissible
	### for each member, we'd process handling of 
	### DVD.RENTAL.FORBIDDENRATING here...
	dlist = DSK.search(titleid)  # Get disk list...
	# Next, check the items on the list to see if they are available
	availabledisk = 0
	for d in dlist:
	    # Look for rental
	    #    If rented, continue
	    try:
		r=RNT.get(d)
		if r.datec != "":
		    skip="Y"
	    except: 
	         skip="N"
	    # Look for reservation
	    # If reserved, by matching memberid, then we've got a result
	    if skip == "N":
	        try:
		    r=RES.get(d)
		    if (r.memberid == memberid) and (r.titleid == titleid):
		        founddisk = d
	        except: pass
	    # If all is OK, set availabledisk, then break
	    if skip != "Y":
	        founddisk = d
	        break
	# Now, rent the disk...
	try:
	    logit("Rental", "rentdiskinfo - disk %d - failed" % diskid)
	    rrec=DVD.Rental.rentinfo(diskid=founddisk, memberid=memberid, 
		drented="20000801")
	    SRENTAL[idtostring(founddisk)]= stringizerentinfo(rrec)
	    logit("Rental", "rentdisk - disk %d member %d" % (founddisk, memberid))
	    # If the member had reserved this title, then cancel that
	    # now...
	except:
	    logit("Rental", "rentdiskinfo - failed for %d" % titleid)
	    raise DVD.DISKS.NOSUCHDISK
	try:
	    rtitle = RES.queryreservationbymember(memberid)
	    if rtitle == titleid:
		RES.cancelreservation(memberid)
	except:
	    raise DVD.MEMBERSHIP.NOSUCHMEMBER
	return founddisk
	#returns diskid, if it exists...
    def rentdiskinfo (self, diskid):
        print "Finish RENTAL::rentdiskinfo()"
	try:
	    rtl=destringizerentinfo(SRENTAL[idtostring(diskid)])
	    mbr=rtl.memberid
	    dt=rtl.drented
            logit("Rental", "rentdiskinfo - disk %d - Found member %d date %s" % (diskid, mbr, returndate))
	except:
	    logit("Rental", "rentdiskinfo - disk %d - failed" % diskid)
	    raise DVD.DISKS.NOSUCHDISK
	return mbr, dt
    def diskreturn (self, diskid, returndate):
	try:
	    dsk= destringizerentinfo(SRENTAL[idtostring(diskid)])
	    del SRENTAL[idtostring(diskid)]
            logit("Rental", "Return disk %d %s" % (diskid, returndate))
	    return dsk.memberid
        except:
	    raise DVD.DISKS.NOSUCHDISK
    def titleavailable (self, titleid, date):
        print "titleavailable not yet used, so no need..."
	return [2, 3, 4] 
    def overduedisks (self, fromdate, todate):
	print "overduedisks not yet used, so no need..."
        return []

class Reservations:
    def set(self, mid, reserve):
	SHRESERVATIONS[idtostring(mid)] = stringizerentinfo(reserve)
    def get(self, mid):
	try:
	    record= SHRESERVATIONS[idtostring(mid)]
	except:
	    logit("RESERVATIONS", "Failure of get() contents for reservation %d" % mid)
	    raise DVD.RESERVATION.NOSUCHRESERVATION
	logit("RESERVATIONS", "Success of get() contents for reservation %d" % mid)
	return destringizereservationinfo(record)
    def reservetitle (self, needed, titleid, memberid):
        print "Finish RESERVATIONS::reservetitle()"
	#returns nothing
	#raise DVD.TITLING.NOSUCHTITLE
	#raise DVD.MEMBERSHIP.NOSUCHMEMBER
	#raise DVD.RENTAL.FORBIDDENRATING
    def cancelreservation (self, memberid):
        print "Finish RESERVATIONS::cancelreservation()"
	#returns nothing
	#raise DVD.MEMBERSHIP.NOSUCHMEMBER
    def queryreservationbymember (self, memberid):
        print "Finish RESERVATIONS::queryreservationbymember()"
	#returns titleid
	#raise DVD.MEMBERSHIP.NOSUCHMEMBER
	return 1
    def queryreservationbytitle (self, titleid, date): 
	print "Not used, so not yet implemented..."
        print "Finish RESERVATIONS::reservetitle()"

class Utilities:
    def getclassifications(self):
	logit("Utilities", "Query Classifications ")
        return ["E", "U", "PG", "12", "15", "18", "XXX"]
    def getgenres(self):
	logit("Utilities", "Query Genres")
        return ["Action", "Education", "Comedy", "Thriller",
        "Foreign", "Romance", "Science Fiction"]
    def errortext(self, errnumber):
	logit("Utilities", "Get Errnum for %d" % errnumber)
        # This uses dictionaries defined below...
        try: 
            errname=ERRNDICT[errnumber]
            errmsg=ERRMSGDICT[errname]
        except:
            errmsg="Unknown error type: %d " % errnumber
        return errmsg
    def today(self):
        return strftime("%Y%m%d", localtime(time()))

CORBA.load_idl("dvdc.idl")
CORBA.load_idl("logger.idl")
orb = CORBA.ORB_init((), CORBA.ORB_ID)
poa = orb.resolve_initial_references("RootPOA")
try:
    logior = open("./logger.ior").readline()
    LOGORB = orb.string_to_object(logior)
    print LOGORB.__repo_id
    LOGORB.addlog(LOG.loginfo(hostname="knuth", userid="cbbrowne",
			      application="dvd-server",
			      messagetype="info",
			      shortmessage="Start up DVD Server"))
except:
    print "Could not open Logger!"
servant = POA.DVD.FACTORY(Factory())
poa.activate_object(servant)
ref = poa.servant_to_reference(servant)
open("./dvd-server.ior", "w").write(orb.object_to_string(ref))
print "Starting up DVD Server"
poa.the_POAManager.activate()
orb.run()
@