head	1.6;
access;
symbols;
locks
	cbbrowne:1.6; strict;
comment	@# @;


1.6
date	2000.06.25.05.27.30;	author cbbrowne;	state Exp;
branches;
next	1.5;

1.5
date	2000.06.25.02.29.53;	author cbbrowne;	state Exp;
branches;
next	1.4;

1.4
date	2000.06.24.03.27.58;	author cbbrowne;	state Exp;
branches;
next	1.3;

1.3
date	2000.06.21.05.18.05;	author cbbrowne;	state Exp;
branches;
next	1.2;

1.2
date	2000.06.21.01.20.28;	author cbbrowne;	state Exp;
branches;
next	1.1;

1.1
date	2000.06.19.06.19.06;	author cbbrowne;	state Exp;
branches;
next	;


desc
@@


1.6
log
@Sundry updates...
@
text
@#!/usr/bin/env python 
import CORBA, sys, regex, string, random, time, shelve, bsddb, os 
from string import split, strip, joinfields
from random import randint
from time import localtime, strftime, time
###  Connect Associative arrays to Files
SHDISKS=bsddb.btopen("disks.db", "c")
SHMEMBERS=bsddb.btopen("members.db", "c")
SHRENTALS=bsddb.btopen("rentals.db", "c")
SHRESERVATIONS=bsddb.btopen("reservations.db", "c")
SHTITLES=bsddb.btopen("titles.db", "c")

class SETUPCOUNTERS:
    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

### Now, for utilities...
def idtostring (id):
    return "%d" % id

uname = os.uname()
hostname = uname[1]
def logit(type, info):
    try:
	LOGORB.addlog(LOG.loginfo(hostname=hostname, 
				  userid="%d" % os.getuid(),
				  application="dvd-server",
				  messagetype=type,
				  shortmessage=info))
    except: 
	print "logging server broken!"
### Initialization of non-ORB stuff...
FACTORYOBJECT = {}
DBMAX = {}
ERRNDICT = {
     0 : "DVD_SUCCESS"             ,
    -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" }

ERRMSGDICT = {
    "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"}


SETUP=SETUPCOUNTERS()
SETUP.maxforall()

class FACTORY:
    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"]

### Functions to pack/unpack the DBM file information
def destringizereservationinfo(sres):
    rout=DVD.RESERVATIONS.reservation
    (mbr, ttl, dd)=string.split(sres, "\\")
    rout.memberid=string.atoi(mbr)
    rout.titleid=string.atoi(ttl)
    rout.due=dd
    return rout
def stringizereservation(res):
    return string.join(("%d"%res.memberid, "%d"%res.titleid, res.due), "\\")
def destringizerentinfo(srental):
    rout=DVD.RENTAL.rentinfo
    (dsk, mbr, dd) = string.split(srental, "\\")
    rout.diskid=string.atoi(dsk)
    rout.memberid=string.atoi(mbr)
    rout.due=dd
    return rout
def stringizerentinfo(rrec):
    return string.join(("%d"%rrec.diskid, "%d"%rrec.memberid, rrec.due), "\\")
def destringizedisk(sdisk):
    disk=DVD.DISKS.dvddisks()
    (sd, st) = string.split(sdisk, "\\")
    disk.diskid = string.atoi(sd)
    disk.titleid = string.atoi(st)
    return disk
def stringizedisk(disk):
    return string.join(("%d"%disk.diskid, "%d"%disk.titleid), "\\")
def stringizetitle(title):
    return string.join(("%d" % title.titleid, title.titletext, title.asin, title.director, title.genre, title.classification, title.actor1, title.actor2, title.releasedate, title.rentalcost, title.image), "\\")
def destringizetitle(stitle):
    title=DVD.TITLING.dvdtitles()
    (mttl, title.titletext, title.asin, title.director, title.genre, title.classification, title.actor1, title.actor2, title.releasedate, title.rentalcost, title.image) = string.split(stitle, "\\")
    title.titleid=string.atoi(mttl)
    return title
	
def stringizemember(member):
    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), "\\")
def destringizemember(smember):
    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

class MEMBERSHIP:
    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)
	    print "Couldn't get member", 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:
	    raise DVD.MEMBERSHIP.NOSUCHMEMBER
    def create (self, recordtoadd):
	lastid = DBMAX["members"]
	lastid = lastid + 1
	logit("Membership", "Create new member record - %d" % lastid)
	DBMAX["members"] = lastid
	recordtoadd.memberid = lastid
	recordtoadd.memberno = "%d" % lastid
	SHMEMBERS[idtostring(lastid)]=stringizemember(recordtoadd)
	SHMEMBERS.sync()
	logit("Membership", "Create new member  for %d" % lastid)
	return lastid
    def search (self, lname):
	rseq = []
	try:
	    (key,value)=SHMEMBERS.first()
	    while 1 == 1:
		lst=string.split(value, "\\")
		surname=lst[4]
		if string.upper(surname) == string.upper(lname):
		    rseq.append (string.atoi(key))
		(key,value)=SHMEMBERS.next()
	except:
	    done = ""
	logit("Membership", "Search for %s" % lname)
	rseq.sort()
	return rseq
    def idfromnumber (self, memberno):
	logit("Membership", "id-to-number for %s" % memberno)
	try:
	    (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"]
	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:
			raise DVD.MEMBERSHIP.NOSUCHMEMBER
	def create (self, recordtoadd):
		lastid = DBMAX["members"]
		lastid = lastid + 1
		logit("Membership", "Create new member record - %d" % lastid)
		DBMAX["members"] = lastid
		recordtoadd.memberid = lastid
		recordtoadd.memberno = "%d" % lastid
		SHMEMBERS[idtostring(lastid)]=stringizemember(recordtoadd)
		SHMEMBERS.sync()
		logit("Membership", "Create new member  for %d" % lastid)
		return lastid
	def search (self, lname):
		rseq = []
		try:
			(key,value)=SHMEMBERS.first()
			while 1 == 1:
				lst=string.split(value, "\\")
				surname=lst[4]
				if string.upper(surname) == string.upper(lname):
					rseq.append (string.atoi(key))
				(key,value)=SHMEMBERS.next()
		except:
			done = ""
		logit("Membership", "Search for %s" % lname)
		return rseq
	def idfromnumber (self, memberno):
		logit("Membership", "id-to-number for %s" % memberno)
		try:
			(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
d265 60
a324 57
	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)
		return rseq
d328 2
a329 2
		SHDISKS[idtostring(recordtoupdate.diskid)]= stringizedisk(recordtoupdate)
		SHDISKS.sync()
d331 1
a331 1
		logit("DISKS", "Failure to set %d" % recordtoupdate.diskid)
d335 1
a335 1
		record=SHDISKS[idtostring(diskid)]
d337 2
a338 2
		logit("DISKS", "Failure of get() contents for disk %d" % diskid)
		raise DVD.DISKS.NOSUCHDISK
d353 3
a355 3
		del SHDISKS[idtostring(diskid)]
		SHDISKS.sync()
		logit("Disks", "delete contents for %d" % diskid)
d357 1
a357 1
		raise DVD.DISKS.NOSUCHDISK
d361 6
a366 6
		(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()
d368 1
a368 1
		done = ""
d374 17
a390 1
        print "Finish RENTAL::renttitle()"
a420 1
	print "Errortext..."
d435 7
a441 7
	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"))
d443 1
a443 1
	print "Could not open Logger!"
@


1.2
log
@*** empty log message ***
@
text
@a12 1
print "SHMEMBERS: ", SHMEMBERS
a18 1
		print "SHDISKS in maxfordisks()", SHDISKS
d22 10
a31 6
			max = 1    
		for i in SHDISKS.keys():
			iint=string.atoi(i)
			if iint > max:
				max=iint+1
		DBMAX["disks"] = max
a32 1
		print "SHMEMBERS in maxformembers()", SHMEMBERS
d37 9
a45 5
		for i in SHMEMBERS.keys():
			iint=string.atoi(i)
			if iint > max:
				max=iint+1
		DBMAX["members"] = max
a46 1
		print "SHTITLES in maxfortitles()", SHTITLES
d50 10
a59 6
			max = 1    
		for i in SHTITLES.keys():
			iint=string.atoi(i)
			if iint > max:
				max=iint+1
		DBMAX["titles"] = max
a114 2
for i in DBMAX.keys():
	print "  Max for ", i, " is : ", DBMAX[i]
d173 16
a199 1
		print "Update id:", recordtoupdate.memberid, " with: ", recordtoupdate
a201 1
                print "Finish MEMBERSHIP::set()"
a210 1
		logit("Membership", "delete contents for %d" % memberid)
d213 1
d216 1
a216 1
			raise MEMBERSHIP.NOSUCHMEMBER
a219 1
		print ("New Member ID: %d" % lastid)
d226 1
d230 11
a240 6
		for i in SHMEMBERS.keys():
			print SHMEMBERS[i]
			lst=string.split(SHMEMBERS[i], "\\")
			surname=lst[4]
			if string.upper(surname) == string.upper(lname):
				rseq.append (string.atoi(i))
d243 11
a253 5
		for i in SHMEMBERS.keys():
			(id, no) = string.split(SHMEMBERS(i))
			if no == memberno:
				return string.atoi(id)
		raise MEMBERSHIP.NOSUCHMEMBER
d257 2
a258 1
			SHTITLES[idtostring(recordtoupdate.titleid)]=recordtoupdate
a260 1
			raise MEMBERSHIP.NOSUCHTITLE
d262 1
a262 2
		print "Finish TITLING::set()"
	def get (self, memberid):
d264 1
a264 1
			record=SHTITLES[idtostring(memberid)]
d266 4
a269 6
			logit("TITLING", "failure of get() contents for title %d" % recordtoupdate.titleid)
			raise TITLING.NOSUCHTITLE
		logit("TITLING", "Success of get() contents for title %d" % recordtoupdate.titleid)
		return record
	def create (self, recordtoadd):
		print "Finish TITLING::get()"
d273 2
d276 1
a276 2
			raise MEMBERSHIP.NOSUCHMEMBER
		print "Finish TITLING::delete()"
d278 34
a311 4
		print "Finish TITLING::get()"
	def search (self, name):
		print "Finish TITLING::search()"

d314 6
a319 1
        print "Finish DISKS::set()"
d321 7
a327 1
        print "Finish DISKS::get()"
d329 9
a337 1
        print "Finish DISKS::get()"
d339 6
a344 1
        print "Finish DISKS::delete()"
d346 12
a357 1
        print "Finish DISKS::search()"
@


1.1
log
@Initial revision
@
text
@d2 1
a2 1
import CORBA, sys, regex, string, random, time, shelve, bsddb
d6 104
d115 1
d124 1
d133 1
d142 1
d151 1
d160 1
d165 10
d177 4
a180 5
		try:
			print "Update id:", recordtoupdate.memberid, " with: ", recordtoupdate
			SHMEMBERS[idtostring(recordtoupdate.memberid)]=recordtoupdate
		except:
			raise MEMBERSHIP.NOSUCHMEMBER
d186 4
a189 2
			raise MEMBERSHIP.NOSUCHMEMBER
		return record
d191 1
d194 1
d198 10
a207 1
		print "Finish MEMBERSHIP::create()"
d209 8
a216 1
		print "Finish MEMBERSHIP::search()"
d218 5
a222 1
		print "Finish MEMBERSHIP::idfromnumber()"
d228 1
d230 1
d236 1
d238 1
d289 1
d292 1
d296 1
a307 84
class SETUPCOUNTERS:
	def maxforall(self):
		self.maxfordisks()
		self.maxformembers()
		self.maxfortitles()
	def maxfordisks(self):
		if DBMAX.has_key("disks"):
			max = DBMAX["disks"]
		else:
			max = 1    
		for i in SHDISKS.keys():
			rec=SHDISKS[i]
			if rec.diskid > max:
				max=rec.diskid+1
		DBMAX["disks"] = max
	def maxformembers(self):
		if DBMAX.has_key("members"):
			max = DBMAX["members"]
		else:
			max = 1    
		for i in SHMEMBERS.keys():
			rec=SHMEMBERS[i]
			if rec.memberid > max:
				max=rec.memberid+1
		DBMAX["members"] = max
	def maxfortitles(self):
		if DBMAX.has_key("titles"):
			max = DBMAX["titles"]
		else:
			max = 1    
		for i in SHTITLES.keys():
			rec=SHTITLES[i]
			if rec.titleid > max:
				max=rec.titleid+1
		DBMAX["titles"] = max
def idtostring (id):
	return "%d" % id

### Initialization of non-ORB stuff...
FACTORYOBJECT = {}
DBMAX = {}
ERRNDICT = {
	-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" }

ERRMSGDICT = {
	"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"}

###  Connect Python "Shelves" to the various objects
SHDISKS=shelve.open("disks.db")
SHMEMBERS=shelve.open("members.db")
SHRENTALS=shelve.open("rentals.db")
SHRESERVATIONS=shelve.open("reservations.db")
SHTITLES=shelve.open("titles.db")

SETUP=SETUPCOUNTERS()
SETUP.maxforall()

d312 1
a312 2

try: 
@
