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"]
	try:
	    member=MEM.get(memberid)
	except:
	    raise DVD.MEMBERSHIP.NOSUCHMEMBER
	try:
	    title=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...
	logit("RENTAL", "Search for %d member" % memberid)
	#returns diskid, if it exists...
	raise DVD.DISKS.NOSUCHDISK
    def rentdiskinfo (self, diskid):
        print "Finish RENTAL::rentdiskinfo()"
	try:
	    rtl=destringizerentinfo(SRENTAL[idtostring(diskid)])
	    dsk=rtl.memberid
	    
    def diskreturn (self, diskid, returndate):
        print "Finish RENTAL::diskreturn()"
	return 456
    def titleavailable (self, titleid, date):
        print "Finish RENTAL::titleavailable()"
	return [ 2, 3, 4]
    def overduedisks (self, fromdate, todate):
        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
    def queryreservationbytitle (self, titleid, date): 
        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))

poa.the_POAManager.activate()
orb.run()
@


1.5
log
@Sundry updates...
@
text
@d1 1
a1 1
#!/usr/bin/env python   # -*- mode: python; -*-
d361 3
a363 1
	return destringizedisk(record)
d430 4
d436 1
d439 1
@


1.4
log
@*** empty log message ***
@
text
@d174 18
d201 1
a201 1
    return string.join(("%d" % title.titleid, title.titletext, title.asin, title.director, title.genre, title.classification, title.actor1, title.actor2, title.releasedate, title.rentalcost), "\\")
d204 1
a204 1
    (mttl, title.titletext, title.asin, title.director, title.genre, title.classification, title.actor1, title.actor2, title.releasedate, title.rentalcost) = string.split(stitle, "\\")
d269 2
a270 1
       	return rseq
d343 2
d391 1
a392 1

d394 13
d411 1
d436 10
d448 4
d454 2
d458 2
@


1.3
log
@Now supports the interfaces for MEMBERS, DISKS, TITLES
@
text
@d14 46
a59 46
	def maxforall(self):
		self.maxfordisks()
		self.maxformembers()
		self.maxfortitles()
	def maxfordisks(self):
		if DBMAX.has_key("disks"):
			max = DBMAX["disks"]
		else:
			max = 1
		try:
			i=SHDISKS.first()
			while i != None:
				iint = string.atoi(i)
				if iint > max:
					max=iint+1
				i=SHDISKS.next(i)
		except:
			DBMAX["disks"] = max
	def maxformembers(self):
		if DBMAX.has_key("members"):
			max = DBMAX["members"]
		else:
			max = 1    
		try:
			i=SHMEMBERS.first()
			while i != None:
				iint = string.atoi(i)
				if iint > max:
					max=iint+1
				i=SHMEMBERS.next(i)
		except:
			DBMAX["members"] = max
	def maxfortitles(self):
		if DBMAX.has_key("titles"):
			max = DBMAX["titles"]
		else:
			max = 1
		try:
			i=SHTITLES.first()
			while i != None:
				iint = string.atoi(i)
				if iint > max:
					max=iint+1
				i=SHTITLES.next(i)
		except:
			DBMAX["titles"] = max
d63 1
a63 1
	return "%d" % id
d68 2
a69 2
	try:
		LOGORB.addlog(LOG.loginfo(hostname=hostname, 
d74 2
a75 2
	except: 
		print "logging server broken!"
d80 15
a94 14
	-1 : "DVD_ERR_NO_FILE"         ,
	-2 : "DVD_ERR_BAD_TABLE"       ,
	-3 : "DVD_ERR_NO_MEMBER_TABLE" ,
	-4 : "DVD_ERR_BAD_MEMBER_TABLE",
	-5 : "DVD_ERR_BAD_TITLE_TABLE" ,
	-6 : "DVD_ERR_BAD_DISK_TABLE"  ,
	-7 : "DVD_ERR_BAD_SEEK"        ,
	-8 : "DVD_ERR_NULL_POINTER"    ,
	-9 : "DVD_ERR_BAD_WRITE"       ,
	-10 : "DVD_ERR_BAD_READ"       ,
	-11 : "DVD_ERR_NOT_FOUND"      ,
	-12 : "DVD_ERR_NO_MEMORY"      ,
	-13 : "DVD_ERR_BAD_RENTAL_TABLE" ,
	-14 : "DVD_ERR_BAD_RESERVE_TABLE" }
d97 15
a111 15
	"DVD_SUCCESS" : "no error",
	"DVD_ERR_NO_FILE" : "cannot open file",
	"DVD_ERR_BAD_TABLE" : "corrupt table file",
	"DVD_ERR_NO_MEMBER_TABLE" : "no member table",
	"DVD_ERR_BAD_MEMBER_TABLE" : "corrupt member table",
	"DVD_ERR_BAD_TITLE_TABLE" : "corrupt title table",
	"DVD_ERR_BAD_DISK_TABLE" : "corrupt disk table",
	"DVD_ERR_BAD_RENTAL_TABLE" : "corrupt rental table",
	"DVD_ERR_BAD_RESERVE_TABLE" : "corrupt reserve table",
	"DVD_ERR_BAD_SEEK" : "cannot seek in file",
	"DVD_ERR_NULL_POINTER" : "null data pointer",
	"DVD_ERR_BAD_WRITE" : "cannot write to file",
	"DVD_ERR_BAD_READ" : "cannot read file",
	"DVD_ERR_NOT_FOUND" : "no match found",
	"DVD_ERR_NO_MEMORY" : "out of memory"}
d118 54
a171 54
	def UTILITIESFactory(self):
		try:
			return FACTORYOBJECT["utilities"]
		except:
			logit("Factory", "Create Utility Interface")
			new_instance = POA.DVD.UTILITIES(UTILITIES())
			poa.activate_object(new_instance)
			FACTORYOBJECT["utilities"] = poa.servant_to_reference(new_instance)
			return FACTORYOBJECT["utilities"]
	def MEMBERSHIPFactory(self):
		try:
			return FACTORYOBJECT["membership"]
		except:
			logit("Factory", "Create Membership Interface")
			new_instance = POA.DVD.MEMBERSHIP(MEMBERSHIP())
			poa.activate_object(new_instance)
			FACTORYOBJECT["membership"] = poa.servant_to_reference(new_instance)
			return FACTORYOBJECT["membership"]
	def TITLINGFactory(self):
		try:
			return FACTORYOBJECT["titling"]
		except:
			logit("Factory", "Create Titling Interface")
			new_instance = POA.DVD.TITLING(TITLING())
			poa.activate_object(new_instance)
			FACTORYOBJECT["titling"] = poa.servant_to_reference(new_instance)
			return FACTORYOBJECT["titling"]
	def DISKSFactory(self):
		try:
			return FACTORYOBJECT["disks"]
		except:
			logit("Factory", "Create Disks Interface")
			new_instance = POA.DVD.DISKS(DISKS())
			poa.activate_object(new_instance)
			FACTORYOBJECT["disks"] = poa.servant_to_reference(new_instance)
			return FACTORYOBJECT["disks"]
	def RENTALFactory(self):
		try:
			return FACTORYOBJECT["rentals"]
		except:
			logit("Factory", "Create Rental Interface")
			new_instance = POA.DVD.RENTAL(RENTAL())
			poa.activate_object(new_instance)
			FACTORYOBJECT["rentals"] = poa.servant_to_reference(new_instance)
			return FACTORYOBJECT["rentals"]
	def RESERVATIONSFactory(self):
		try:
			return FACTORYOBJECT["reservations"]
		except:
			logit("Factory", "Create Reservations Interface")
			new_instance = POA.DVD.RESERVATIONS(RESERVATIONS())
			poa.activate_object(new_instance)
			FACTORYOBJECT["reservations"] = poa.servant_to_reference(new_instance) 
			return FACTORYOBJECT["reservations"]
d175 5
a179 5
	disk=DVD.DISKS.dvddisks()
	(sd, st) = string.split(sdisk, "\\")
	disk.diskid = string.atoi(sd)
	disk.titleid = string.atoi(st)
	return disk
d181 1
a181 1
	return string.join(("%d"%disk.diskid, "%d"%disk.titleid), "\\")
d183 1
a183 1
	return string.join(("%d" % title.titleid, title.titletext, title.asin, title.director, title.genre, title.classification, title.actor1, title.actor2, title.releasedate, title.rentalcost), "\\")
d185 4
a188 4
	title=DVD.TITLING.dvdtitles()
	(mttl, title.titletext, title.asin, title.director, title.genre, title.classification, title.actor1, title.actor2, title.releasedate, title.rentalcost) = string.split(stitle, "\\")
	title.titleid=string.atoi(mttl)
	return title
d191 5
a195 1
	return string.join(("%d" % member.memberid, member.memberno, member.title, member.fname, member.lname, member.houseflatref, member.address1, member.address2, member.town, member.state, member.phone, member.zipcode), "\\")
d197 6
a202 4
	member=DVD.MEMBERSHIP.storemembers()
	(mid, member.memberno, member.title, member.fname, member.lname, member.houseflatref, member.address1, member.address2, member.town, member.state, member.phone, member.zipcode) = string.split(smember, "\\")
	member.memberid=string.atoi(mid)
	return member
d205 59
a263 56
	def set (self, recordtoupdate):
		logit("Membership", "Set contents for %d" % recordtoupdate.memberid)
		SHMEMBERS[idtostring(recordtoupdate.memberid)]=stringizemember(recordtoupdate)
		SHMEMBERS.sync()
	def get (self, memberid):
		try:
			record=SHMEMBERS[idtostring(memberid)]
		except:
			logit("Membership", "Failure of get() contents for member %d" % memberid)
			raise DVD.MEMBERSHIP.NOSUCHMEMBER
		logit("Membership", "Success of get() contents for member %d" % memberid)
		return destringizemember(record)
	def delete (self, memberid):
		try:
			del SHMEMBERS[idtostring(memberid)]
			logit("Membership", "delete contents for %d" % memberid)
			SHMEMBERS.sync()
		except: