Viewing file:  FileBlackBox.py (5.97 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#!/usr/bin/python
import Alchemist
import gzip
import os
import stat
import sys
import time
def ReadContextFromFile(file_path):
"""
ReadContextFromFile: read a context from a given file
@file_path: the path to the file
This function reads a context from a gzip'ed file
returns: the context from the file
exceptions: FileIO
"""
try:
xml_string = gzip.open(file_path).read()
except IOError:
xml_string = open(file_path).read()
return Alchemist.Context(xml = xml_string)
def WriteContextToFile(file_path, context, mode = 0600, compressed = 9):
"""
WriteContextFromFile: write a context to a given file
@file_path: the path to the file
@context: the context to write
This function writes a context to a gzip'ed file
returns: none
exceptions: FileIO
"""
xml_string = context.toXML()
if os.path.exists(file_path):
os.unlink(file_path)
fd = os.open(file_path, os.O_WRONLY | os.O_CREAT| os.O_TRUNC, mode)
file = os.fdopen(fd, "w")
if compressed:
file = gzip.GzipFile(file_path, "w", compresslevel = compressed, fileobj = file)
file.write(xml_string)
file.close()
def getBox(box_cfg):
"""
getBox: get a BlackBox from this module
@box_cfg: a box_cfg conformant AdmList element containing
the following elements:
path: type string, the path to the context file (required)
readable: type bool, flag, if the box should be readable (optional)
writable: type bool, flag, if the box should be writable (optional)
returns: FileBlackBox object
"""
return FileBlackBox(box_cfg)
class FileBlackBox(Alchemist.BlackBox):
"""
The FileBlackBox class provides a class to read and write Contexts
from and to files.
"""
def __init__ (self, box_cfg):
"""
__init__: Initialize a BlackBox
@self: the class instance
@box_cfg: a box_cfg conformant AdmList element containing
the following elements:
path: type string, the path to the context file (required)
readable: type bool, flag, if the box should
be readable (optional)
writable: type bool, flag, if the box should
be writable (optional)
mode: an integer file mode
This function is the initializer for FileBlackBoxes.
"""
self.status = 0
self.me = self.__class__.__module__
self._errNo = 0
self._errStr = None
self.readable = 1
self.writable = 1
Alchemist.validateBoxCfg(box_cfg)
try:
self.path = box_cfg.getChildByName("path").getValue()
except:
raise ValueError, "FileBlackBox box_cfgs must contain a 'path' element"
try:
self.readable = box_cfg.getChildByName("readable").getValue()
except:
pass
try:
self.writable = box_cfg.getChildByName("writable").getValue()
except:
pass
try:
self.mode = box_cfg.getChildByName("mode").getValue()
except:
self.mode = 0600
pass
def isReadable (self):
"""
isReadable: if a read were attempted now, would it succede?
@self: this BlackBox instance
"""
return (self.readable and os.access(self.path, os.R_OK))
def isWritable (self):
"""
isWritable: if a write were attempted now, would it succede?
@self: this BlackBox instance
"""
writable = 0
if os.access(self.path, os.W_OK):
writable = 1
elif (not os.access(self.path, os.F_OK)) and os.access(os.path.dirname(self.path), os.W_OK):
writable = 1
return self.writable and writable
def read (self):
"""
read: read the contents of the FileBlackBox
@self: this FileBlackBox instance
This function is callable multiple times, and if it cannot
succede on a given call, it returns None. It does not
cache returns information in the normal sense, unless the data
is not dynamic. And it does not keep a reference to the
AdmContext it returns.
It also sets the serial of the returned context to the modify
time of the file.
"""
# am I readable?
if (not self.isReadable()):
return None
version = self.version()
context = ReadContextFromFile(self.path)
context.getIdentityRoot().setSerial(version)
return context
def version(self):
"""
version: returns the version of this FileBlackBox's context
@self: this FileBlackBox instance
This function returns the modification time (in seconds since the epoch)
of the file referenced by self.path
"""
if os.path.exists(self.path):
return os.stat(self.path)[8]
return None
def write (self, context):
"""
write: write the contents of the FileBlackBox
@self: this FileBlackBox instance
This function is callable multiple times. It writes a
Context out to the file the FileBlackBox is initialized with.
It returns 0 on failure, and a non-zero, positive integer
on success.
"""
# am I writable?
if (not self.isWritable()):
return 0
# write the context out
try:
WriteContextToFile(self.path, context, mode = self.mode)
except Exception, e:
if len(e.args) == 1:
self._errNo = 1
self._errStr = e.args[0]
else:
self._errStr = e.args[1]
self._errNo = e.args[0]
return 0
###########################################################################
#
# Test
#
###########################################################################
#if __name__ == '__main__':
# boxpath = '/var/tmp/BootStrap'
# bbc = Alchemist.Context(name = 'FileBlackBox', serial = 1)
# broot = bbc.getDataRoot()
# list = broot.addChild(Alchemist.Data.ADM_TYPE_LIST, 'box_cfg')
# list.addChild(Alchemist.Data.ADM_TYPE_STRING, 'path').setValue(boxpath)
# list.addChild(Alchemist.Data.ADM_TYPE_STRING, 'box_type').setValue('FileBlackBox')
# list.addChild(Alchemist.Data.ADM_TYPE_BOOL, 'readable').setValue(true)
# list.addChild(Alchemist.Data.ADM_TYPE_BOOL, 'writable').setValue(true)
# bb = FileBlackBox(list)
# if bb.errNo():
# print 'Error creating FileBlackBox: ' + bb.strError()
# sys.exit(10)
# if bb.isWritable():
# if bb.write(bbc) != true:
# if bb.errNo():
# print 'Error writing to BlackBox: ' + bb.strError()
# else:
# print bbc.toXML()
# else: print 'Error: ' + boxpath + ' is not writable!'
|