def handleSetPath(self):
logger.info("set path request")
unit = self.tipi_io.receive()[0]
pathname = str(self.tipi_io.receive(), 'ascii').strip()
logger.info("unit: %d, path: %s", unit, pathname)
# test if device is mapped
localfilename = self.getLocalName(unit,"")
if localfilename is None:
logger.info("passing request to next device")
self.tipi_io.send([EDVNAME])
return True
if not os.path.exists(localfilename):
logger.info("device not mapped")
self.tipi_io.send([EDEVERR])
return True
target = tinames.devnameToLocal(pathname)
if not (os.path.exists(target) and os.path.isdir(target)):
logger.info("target %s does not exist", target)
self.tipi_io.send([EDEVERR])
return True
self.unitpath[unit] = pathname
logger.info("set unit %s path to %s", unit, pathname)
self.tipi_io.send([SUCCESS])
return True
def handleSetPath(self):
logger.info("set path request")
unit = self.tipi_io.receive()[0]
pathname = str(self.tipi_io.receive(), 'latin1').strip()
logger.info("unit: %d, path: %s", unit, pathname)
# test if device is mapped
if unit:
# only check unit greater than 0. TIPI is unit 0 and doesn't
# get mapped
mapped = tipi_config.get(f"DSK{unit}_DIR")
if not mapped:
logger.info("device not mapped")
self.tipi_io.send([EDEVERR])
return True
target = tinames.devnameToLocal(pathname)
if not (os.path.exists(target) and os.path.isdir(target)):
logger.info("target %s does not exist", target)
self.tipi_io.send([EDEVERR])
return True
self.unitpath[unit] = pathname
logger.info("set unit %s path to %s", unit, pathname)
self.tipi_io.send([SUCCESS])
return True
def handleWrite(self, pab, devname):
logger.info("Opcode 3 Write - %s", devname)
logPab(pab)
localPath = tinames.devnameToLocal(devname)
if not localPath in self.openFiles:
# pass to a different device.
self.sendErrorCode(EDEVERR)
return
try:
open_file = self.openFiles[localPath]
if open_file == None:
self.sendErrorCode(EFILERR)
return
self.sendSuccess()
bytes = self.tipi_io.receive()
open_file.writeRecord(bytes, pab)
self.sendSuccess()
return
except Exception as e:
traceback.print_exc()
self.sendErrorCode(EFILERR)
self.sendErrorCode(EDEVERR)
def handleSave(self, pab, devname):
logger.info("Opcode 6 Save - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
logger.debug("unix_name for program is %s", unix_name)
if unix_name == "" or unix_name is None:
self.sendErrorCode(EDVNAME)
return
oled.info("SAVE:/%s", devname)
logger.debug("saving program to %s", unix_name)
if self.parentExists(unix_name):
self.sendSuccess()
fdata = self.tipi_io.receive()
logger.debug("received program image")
try:
if unix_name.lower().endswith(basicSuffixes):
prog_file = BasicFile.create(fdata)
else:
prog_file = ProgramImageFile.create(devname, unix_name, fdata)
logger.debug("created file object")
prog_file.save(unix_name)
self.sendSuccess()
except Exception as e:
logger.exception("failed to save PROGRAM")
self.sendErrorCode(EDEVERR)
return
self.sendErrorCode(EDEVERR)
def handleRead(self, pab, devname):
logger.debug("Opcode 2 Read - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
recNum = recordNumber(pab)
if unix_name is None:
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
if unix_name not in self.openFiles:
# pass to a different device.
self.sendErrorCode(EDVNAME)
return
try:
open_file = self.openFiles[unix_name]
if not open_file.isLegal(pab):
logger.error("illegal read mode for %s", devname)
self.sendErrorCode(EFILERR)
return
rdata = open_file.readRecord(recNum)
if rdata is None:
logger.debug("received None for record %d", recNum)
self.sendErrorCode(EEOF)
else:
self.sendSuccess()
self.tipi_io.send(rdata)
return
except Exception as e:
traceback.print_exc()
self.sendErrorCode(EFILERR)
def handleWrite(self, pab, devname):
logger.info("Opcode 3 Write - %s", devname)
logPab(pab)
localPath = tinames.devnameToLocal(devname)
recNum = recordNumber(pab)
oled.info("WRITE %d:/%s", recNum, devname)
if localPath is None:
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
if localPath not in self.openFiles:
# pass to a different device.
self.sendErrorCode(EDVNAME)
return
try:
open_file = self.openFiles[localPath]
if open_file == None:
self.sendErrorCode(EFILERR)
return
self.sendSuccess()
bytes = self.tipi_io.receive()
open_file.writeRecord(bytes, pab)
self.sendSuccess()
return
except Exception as e:
traceback.print_exc()
self.sendErrorCode(EFILERR)
self.sendErrorCode(EDEVERR)
def handleRestore(self, pab, devname):
logger.info("Opcode 4 Restore - %s", devname)
logPab(pab)
localPath = tinames.devnameToLocal(devname)
recNum = recordNumber(pab)
oled.info("RESTORE %d:/%s", recNum, devname)
if localPath is None:
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
if localPath not in self.openFiles:
# pass as well
self.sendErrorCode(EDVNAME)
return
try:
open_file = self.openFiles[localPath]
if open_file == None:
self.sendErrorCode(EFILERR)
return
open_file.restore(pab)
self.sendSuccess()
except Exception as e:
traceback.print_exc()
self.sendErrorCode(EFILERR)
def handleLoad(self, pab, devname):
logger.info("Opcode 5 LOAD - %s", devname)
logPab(pab)
maxsize = recordNumber(pab)
unix_name = tinames.devnameToLocal(devname)
if not os.path.exists(unix_name):
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
try:
if (not ti_files.isTiFile(unix_name)
) and unix_name.lower().endswith(basicSuffixes):
prog_file = BasicFile.load(unix_name)
else:
prog_file = ProgramImageFile.load(unix_name)
filesize = prog_file.getImageSize()
bytes = prog_file.getImage()
if filesize > maxsize:
logger.debug(
"TI buffer too small, only loading %d of %d bytes",
maxsize, filesize)
bytes = bytes[:maxsize]
self.sendSuccess()
logger.info("LOAD image size %d", filesize)
self.tipi_io.send(bytes)
except Exception as e:
# I don't think this will work. we need to check for as
# many errors as possible up front.
self.sendErrorCode(EFILERR)
logger.exception("failed to load file - %s", devname)
def handleDelete(self, pab, devname):
logger.info("Opcode 7 Delete - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
if unix_name is None:
self.sendErrorCode(EDVNAME)
return
logger.debug("deleting file %s", unix_name)
try:
del self.openFiles[unix_name]
except Exception as e:
logger.debug(
"removing open file on delete: file was not open! Good")
try:
# check protect flag
if ti_files.isTiFile(unix_name):
fh = open(unix_name, "rb")
header = bytearray(fh.read())[:128]
if ti_files.isProtected(header):
self.sendErrorCode(EWPROT)
return
os.unlink(unix_name)
self.sendSuccess()
except Exception as e:
logger.exception("failed to delete a file")
self.sendErrorCode(EDEVERR)
def handleStatus(self, pab, devname):
logger.info("Opcode 9 Status - %s", devname)
logPab(pab)
statbyte = 0
localPath = tinames.devnameToLocal(devname)
if not os.path.exists(localPath):
# TODO? Should we pass to other controllers here?
if devname.startswith(("TIPI.", "DSK0.")):
statbyte |= STNOFILE
else:
self.sendErrorCode(EDEVERR)
return
else:
open_file = self.openFiles[localPath]
if open_file != None:
statbyte = open_file.getStatusByte()
else:
if ti_files.isTiFile(localPath):
fh = open(localPath, "rb")
header = bytearray(fh.read())[:128]
if ti_files.isVariable(header):
statbyte |= STVARIABLE
if ti_files.isProgram(header):
statbyte |= STPROGRAM
if ti_files.isInternal(header):
statbyte |= STINTERNAL
else:
statbyte = NativeFile.status(localPath)
self.tipi_io.send([SUCCESS])
self.tipi_io.send([statbyte])
def handleRead(self, pab, devname):
logger.debug("Opcode 2 Read - %s", devname)
logPab(pab)
localPath = tinames.devnameToLocal(devname)
if not localPath in self.openFiles:
# pass to a different device.
self.sendErrorCode(EDEVERR)
return
try:
open_file = self.openFiles[localPath]
recNum = recordNumber(pab)
if not open_file.isLegal(pab):
logger.error("illegal read mode for %s", devname)
self.sendErrorCode(EFILERR)
return
rdata = open_file.readRecord(recNum)
if rdata is None:
logger.debug("received None for record %d", recNum)
self.sendErrorCode(EEOF)
else:
self.sendSuccess()
self.tipi_io.send(rdata)
return
except Exception as e:
traceback.print_exc()
self.sendErrorCode(EFILERR)
def handleLoad(self, pab, devname):
logger.info("Opcode 5 LOAD - %s", devname)
logPab(pab)
maxsize = recordNumber(pab)
unix_name = tinames.devnameToLocal(devname)
if unix_name is None or not os.path.exists(unix_name):
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
try:
if (not ti_files.isTiFile(unix_name)
) and unix_name.lower().endswith(basicSuffixes):
prog_file = BasicFile.load(unix_name)
elif 'DV' == ti_files.get_file_type(
unix_name) and unix_name.lower().endswith(basicSuffixes):
# if it has a basic suffix, lets try to coerce it
# from DISPLAY VARIABLE maybe
prog_file = BasicFile.load(unix_name)
else:
prog_file = ProgramImageFile.load(unix_name)
filesize = prog_file.getImageSize()
bytes = prog_file.getImage()
if filesize > maxsize:
logger.debug(
"TI buffer too small, only loading %d of %d bytes",
maxsize,
filesize,
)
bytes = bytes[:maxsize]
dirname = os.path.dirname(unix_name)
if tipi_config.get("AUTO") == "on":
tipidirname = tinames.local2tipi(dirname)
logger.debug("tmp mapping DSK1 to %s", tipidirname)
tipi_config.settmp("DSK1_DIR", tipidirname)
else:
logger.debug("AUTO mapping not enabled")
tipifile = os.path.join(dirname, "TIPI")
if os.path.isfile(tipifile):
config_records = load_internal(tipifile)
tipi_config.applyrecords(config_records)
self.sendSuccess()
logger.info("LOAD image size %d", filesize)
self.tipi_io.send(bytes)
except Exception as e:
# I don't think this will work. we need to check for as
# many errors as possible up front.
self.sendErrorCode(EFILERR)
logger.exception("failed to load file - %s", devname)
def handleClose(self, pab, devname):
logger.debug("Opcode 1 Close - %s", devname)
logPab(pab)
localPath = tinames.devnameToLocal(devname)
if not localPath in self.openFiles:
# not open by us, maybe some other controller handled it.
self.sendErrorCode(EDEVERR)
return
try:
open_file = self.openFiles[localPath]
open_file.close(localPath)
del self.openFiles[localPath]
self.sendSuccess()
except Exception as e:
self.sendErrorCode(EFILERR)
pass
def handleDelete(self, pab, devname):
logger.info("Opcode 7 Delete - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
if unix_name is None:
self.sendErrorCode(EDVNAME)
return
logger.debug("deleting file %s", unix_name)
try:
del self.openFiles[unix_name]
except Exception as e:
logger.debug(
"removing open file on delete: file was not open! Good")
try:
os.unlink(unix_name)
self.sendSuccess()
except Exception as e:
logger.exception("failed to delete a file")
self.sendErrorCode(EDEVERR)
def handleStatus(self, pab, devname):
logger.info("Opcode 9 Status - %s", devname)
logPab(pab)
statbyte = 0
unix_name = tinames.devnameToLocal(devname)
if unix_name is None:
self.sendErrorCode(EDVNAME)
return
if not os.path.exists(unix_name):
statbyte |= STNOFILE
else:
if not os.path.isdir(unix_name):
open_file = None
try:
open_file = self.openFiles[unix_name]
except:
pass
if open_file is not None:
statbyte = open_file.getStatusByte()
else:
if ti_files.isTiFile(unix_name):
fh = open(unix_name, "rb")
header = bytearray(fh.read())[:128]
if ti_files.isVariable(header):
statbyte |= STVARIABLE
if ti_files.isProgram(header):
statbyte |= STPROGRAM
if ti_files.isInternal(header):
statbyte |= STINTERNAL
else:
statbyte = NativeFile.status(unix_name)
oled.info("STATUS %d:/%s", statbyte, devname)
self.tipi_io.send([SUCCESS])
self.tipi_io.send([statbyte])
def handleClose(self, pab, devname):
logger.debug("Opcode 1 Close - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
if unix_name is None:
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
if unix_name not in self.openFiles:
# not open by us, maybe some other controller handled it.
self.sendErrorCode(EDVNAME)
return
try:
open_file = self.openFiles[unix_name]
open_file.close(unix_name)
del self.openFiles[unix_name]
self.sendSuccess()
except Exception as e:
self.sendErrorCode(EFILERR)
pass
def handleSave(self, pab, devname):
logger.info("Opcode 6 Save - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
logger.debug("unix_name for program is %s", unix_name)
if unix_name == "" or unix_name is None:
self.sendErrorCode(EDVNAME)
return
logger.debug("saving program to %s", unix_name)
if self.parentExists(unix_name):
# check protect flag
if ti_files.isTiFile(unix_name):
fh = open(unix_name, "rb")
header = bytearray(fh.read())[:128]
if ti_files.isProtected(header):
self.sendErrorCode(EWPROT)
return
self.sendSuccess()
fdata = self.tipi_io.receive()
logger.debug("received program image")
try:
if unix_name.lower().endswith(basicSuffixes):
prog_file = BasicFile.create(fdata)
else:
prog_file = ProgramImageFile.create(
devname, unix_name, fdata)
logger.debug("created file object")
prog_file.save(unix_name)
self.sendSuccess()
except Exception as e:
logger.exception("failed to save PROGRAM")
self.sendErrorCode(EDEVERR)
return
self.sendErrorCode(EDEVERR)
def handleOpen(self, pab, devname):
logger.debug("Opcode 0 Open - %s", devname)
logPab(pab)
localPath = tinames.devnameToLocal(devname)
logger.debug(" local file: " + localPath)
if mode(pab) == INPUT and not os.path.exists(localPath):
logger.info("Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
if os.path.isdir(localPath):
try:
self.sendSuccess()
cat_file = CatalogFile.load(localPath, pab)
self.tipi_io.send([cat_file.getRecordLength()])
self.openFiles[localPath] = cat_file
return
except Exception as e:
self.sendErrorCode(EOPATTR)
logger.exception("failed to open dir - %s", devname)
return
if os.path.exists(localPath):
try:
open_file = None
if ti_files.isTiFile(localPath):
if recordType(pab) == FIXED:
open_file = FixedRecordFile.load(localPath, pab)
else:
open_file = VariableRecordFile.load(localPath, pab)
else:
open_file = NativeFile.load(localPath, pab)
fillInRecordLen = open_file.getRecordLength()
self.sendSuccess()
self.tipi_io.send([fillInRecordLen])
self.openFiles[localPath] = open_file
return
except Exception as e:
self.sendErrorCode(EOPATTR)
logger.exception("failed to open file - %s", devname)
return
else:
if self.parentExists(localPath):
if recordType(pab) == VARIABLE:
open_file = VariableRecordFile.create(
devname, localPath, pab)
else:
open_file = FixedRecordFile.create(devname, localPath, pab)
self.openFiles[localPath] = open_file
self.sendSuccess()
self.tipi_io.send([open_file.getRecordLength()])
return
else:
# EDEVERR triggers passing on the pab request to other controllers.
self.sendErrorCode(EDEVERR)
return
self.sendErrorCode(EFILERR)
def handleOpen(self, pab, devname):
logger.info("Opcode 0 Open - %s", devname)
logPab(pab)
unix_name = tinames.devnameToLocal(devname)
if unix_name is None:
logger.info("(1) Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
logger.debug(" local file: " + unix_name)
if mode(pab) == INPUT and not os.path.exists(unix_name):
logger.info("(2) Passing to other controllers")
self.sendErrorCode(EDVNAME)
return
if os.path.isdir(unix_name):
try:
if recordLength(pab) == 0 or recordLength(pab) == 146:
cat_file = CatalogFileTimestamps.load(
unix_name, pab, devname)
else:
cat_file = CatalogFile.load(unix_name, pab, devname)
self.sendSuccess()
self.tipi_io.send([cat_file.getRecordLength()])
self.openFiles[unix_name] = cat_file
return
except Exception as e:
self.sendErrorCode(EOPATTR)
logger.exception("failed to open dir - %s", devname)
return
if os.path.exists(unix_name):
try:
if ti_files.isTiFile(unix_name):
# check protect flag
if mode(pab) != INPUT:
fh = open(unix_name, "rb")
header = bytearray(fh.read())[:128]
if ti_files.isProtected(header):
self.sendErrorCode(EWPROT)
return
if recordType(pab) == FIXED:
open_file = FixedRecordFile.load(unix_name, pab)
else:
open_file = VariableRecordFile.load(unix_name, pab)
else:
open_file = NativeFile.load(unix_name, pab)
if open_file is None:
self.sendErrorCode(EOPATTR)
return
fillInRecordLen = open_file.getRecordLength()
self.sendSuccess()
self.tipi_io.send([fillInRecordLen])
self.openFiles[unix_name] = open_file
return
except Exception as e:
self.sendErrorCode(EOPATTR)
logger.error("failed to open file - %s", devname)
return
else:
if self.parentExists(unix_name):
if recordType(pab) == VARIABLE:
open_file = VariableRecordFile.create(
devname, unix_name, pab)
else:
open_file = FixedRecordFile.create(devname, unix_name, pab)
self.openFiles[unix_name] = open_file
self.sendSuccess()
self.tipi_io.send([open_file.getRecordLength()])
return
else:
# EDEVERR triggers passing on the pab request to other controllers.
self.sendErrorCode(EDVNAME)
return
self.sendErrorCode(EFILERR)
def getLocalName(self,unit,filename):
if self.unitpath[unit] != "":
devname = self.unitpath[unit] + filename
else:
devname = "DSK" + str(unit) + "." + filename
return tinames.devnameToLocal(devname)
