#!/usr/bin/python
#
# Check the free space available on a writable DVD
# Should always exit with 0 status, otherwise it indicates a serious error.
# (wrong number of arguments, Python exception...)
#
#  called:  dvd-handler <dvd-device-name> operation args
#
#  where operation is one of
#    free
#    write
#
#  further arguments:
#    free: one argument: 0 to keep the existing data on disk, i.e.
#	   free space is measured
#			 anything else: overwrite entire disk, so
#	   free space is always maximum space
#
# in case of operation ``free'' returns:
# Prints on the first output line the free space available in bytes.
# If an error occurs, prints a negative number (-errno), followed,
# on the second line, by an error message.
# 
# $Id$
#

# end of configurable values

import popen2
import os
import errno
import sys
import re
import signal
import time

class disk:
   # Configurable values:
   df = "@DF@ -P"
   dvdrwmediainfo = "@DVDRWMEDIAINFO@"
   growisofs = "@GROWISOFS@"
   margin = 10485760 # 10 mb security margin
   # We disable 4GB boundary checking - function free should handle this
   # already, and it doesn't seem to work anyway (here: 2.6.8-24.18 from SuSE,
   # LG GSA-5163D, dvd+rw-tools 5.21
   growcmd = growisofs + " -use-the-force-luke=notray -use-the-force-luke=4gms "
   growcmd += "-A 'Bacula Data' -input-charset=default -iso-level 3 -pad " + \
	      "-publisher 'ITS Lehmann info@its-lehmann.de' " + \
	      "-p 'dvd-handler / growisofs' -sysid 'BACULADATA'"

###############################################################################
#
# This class represents a DVD disk (various flavours).
# When instantiated, it needs a device name.
# Status information about the device and the disk loaded is collected.
#
# The following methods are implemented:
# __init__	we need that...
#		NOTE: Currently, this class only works with DVD+RW
#		and simply refuses to work with anything else.
#		This is because I had to start with some sort of disk,
#		and I learned that +RW and -RW are quite different, so
#		I decided to play it safe.
# __repr__	this seems to be a good idea to have.
#		Quite minimalistic implementation, though.
# __str__	For casts to string. Return the current disk information
# is_empty	Returns TRUE if the disk is empty, blank... this needs more
#		work, especially concerning non-RW media and blank vs. no
#		filesystem considerations. Here, we should also look for
#		other filesystems - probably we don't want to silently
#		overwrite UDF or ext2 or anything not mentioned in fstab...
# is_RW 	TRUE if disk is rewritable. We need that to determine if
#		a new filesystem can be written onto a used disk.
# lasterr	returns a string describing the last error in the class.
#		Valuable after creating the object and after free()
# free		Returns the available free space, distinguishing between
#		new volume disks (overwrite everything) and appending
#		There are some assumtions about disk status and usage that
#		need work.
# write 	Writes one part file to disk, either starting a new file
#		system on disk, or appending to it.
#		This method should also prepare a blank disk so that a
#		certain part of the disk is used to allow detection of a
#		used disk by all / more disk drives.
# blank 	NOT IMPLEMENTED
#
###############################################################################
   def __init__(self, devicename):
      self.device = "none"
      self.disktype = "none"
      self.leadout = -1
      self.track = -1
      self.maximum = -1
      self.used = 0
      self.lasterror = "none"
      self.hardwaredevice = "none"
      self.pid = 0

      # first, we collect information about the media as reported by
      # dvd+rw-mediainfo
      # we need an indication of the usable total size.

      self.cmd = self.dvdrwmediainfo + " " + devicename
      self.processi = popen2.Popen4(self.cmd)
      self.status = self.processi.wait()
      if not os.WIFEXITED(self.status):
	 self.lasterror = self.dvdrwmediainfo + " process did not exit correctly."
	 return
      if os.WEXITSTATUS(self.status) != 0:
	 self.lasterror = "Cannot get media info from " + self.dvdrwmediainfo
	 return
      self.device = str(devicename)
      self.result = self.processi.fromchild.read()
      self.hardware = re.search(r"INQUIRY:\s+(.*)\n", self.result, re.MULTILINE)
      self.mediatype = re.search(r"\sMounted Media:\s+([0-9A-F]{2})h, (\S*)\s",
	 self.result, re.MULTILINE)
      self.tracksize = re.search(r"\sTrack Size:\s+(\d+)\*2KB\s",
	 self.result, re.MULTILINE)
      self.leadout = re.search(r"\sLegacy lead-out at:\s+(\d+)\*2KB=(\d+)\s",
	 self.result, re.MULTILINE)
      if self.hardware:
	 self.hardwaredevice = self.hardware.group(1)
      if self.mediatype:
	 self.disktype = self.mediatype.group(2)
      else:
	 self.lasterror = "Media type not found."
      if self.leadout:
	 self.leadout = long(self.leadout.group(1))*2048
      else:
	 self.lasterror = "Lead-out block not found."
      if self.tracksize:
	 self.track = long(self.tracksize.group(1))*2048
      else:
	 self.lasterror = "Track size not found."
      self.result = 0
      if ( "DVD+RW" == self.disktype ):
	 if self.leadout > self.track:
	    self.result = self.leadout
	 else:
	    self.result = self.track
      else:
	 self.lasterror = "Unsupported media: " + self.disktype
      self.maximum = self.result - self.margin
      if self.maximum < 0:
	 self.maximum = 0

      # now, the actual size used on the disk.
      # here, we use what df reports, although the
      # current track size should give us the necessary information,
      # too. Well, depending on the media type, it seems.
      # We should see if the media is mounted, try to mount, if possible
      # proceed and, if necessary, unmount. Otherwise assume 0 used bytes.
      # __init__ and __del__ would be the right places to mount and
      # unmount - mounting before df'ing is always a good idea,
      # and setting the previos state might be important.

      self.cmd = self.df + " " + self.device
      self.process = popen2.Popen4(self.cmd)
      self.status = self.process.wait()
      if not os.WIFEXITED(self.status):
	 self.lasterror = self.df + " process did not not exit correctly."
	 return
      self.exitstat = os.WEXITSTATUS(self.status) & ~0x80
      if self.exitstat == errno.ENOSPC:
	 self.used = 0
      elif self.exitstat != 0:
	 self.lasterror = os.strerror(self.exitstat)
	 return
      self.dftext = self.process.fromchild.read()
      self.blocks = re.search(self.device + r"\s+(\d+)\s+",
	 self.dftext, re.MULTILINE)
      if self.blocks:
	 self.used = long(self.blocks.group(1))*1024
      else:
	 self.used = 0
	 self.lasterror = "No blocks found in " + self.cmd + " output:\n"
	 self.lasterror += self.dftext
      return

   def __repr__(self):
      return "disk(" + self.device + ") # This is an instance of class disk"

   def __str__(self):
      self.me  = "Class disk, initialized with device " + self.device + "\n"
      self.me += "type = " + self.disktype + " leadout = " + str(self.leadout)
      self.me += " track = " + str(self.track) + " maximum = " + str(self.maximum) + "\n"
      self.me += "used = " + str(self.used) + "\n"
      self.me += "Hardware device is " + self.hardwaredevice + "\n"
      self.me += "last error = " + self.lasterror + "\n"
      return self.me

   def is_empty(self):
      return 0 == self.used
   # This works for DVD+RW, probably for all rewritable media. self.blank for -R?
   # This is quite definitely not the best method. I need something
   # that detects if a session exists on disk, but I didn't do any
   # experiments with non-RW media yet.

   def is_RW(self):
      return "DVD-RW" == self.disktype or "DVD+RW" == self.disktype or "DVD-RAM" == self.disktype

   def free(self, newvol):
      if self.used < 0 or self.maximum <= 0:
	 return -1
      elif newvol:
	 self.ret = self.maximum
	 if not self.is_empty() and not self.is_RW():
	    # better check real disks usage state as read from dvd+rw-mediainfo.
	    # introduce self.blank
	    self.ret = -1
	    self.lasterror = self.disktype + " can not be overwritten and is already used"
      else:
	 self.ret = self.maximum - self.used
	 if self.used > 4278190080:	 # if more than 4GB-16MB are already used
	    self.ret = 0
      return self.ret

   def lasterr(self):
      return self.lasterror

   def term_handler(self, signum, frame):
      print 'dvd-handler: Signal term_handler called with signal', signum
      if self.pid != 0:
	 print "dvd-handler: Sending SIGTERM to pid", self.pid
	 os.kill(self.pid, signal.SIGTERM)
	 time.sleep(10)
	 print "dvd-handler: Sending SIGKILL to pid", self.pid
	 os.kill(self.pid, signal.SIGKILL)
	 sys.exit(1)

   def write(self, newvol, partfile):
      self.lasterror = "none"
      self.partstat = os.stat(partfile)
      if not self.partstat:
	 self.lasterror = "Could not stat " + str(partfile) + " which is a fatal error."
	 return
      if self.partstat.st_size > self.free(newvol):
	 self.lasterror = "Part " + str(partfile) + " is too big: " \
	    + str(self.partstat.st_size) + ", free " + str(self.free(newvol))
	 return
      if "DVD-RW" == self.disktype:
	 self.cmd = self.growcmd + " -R "
	 if newvol:
	    self.cmd += "-Z "
	 else:
	    self.cmd += "-M "
	 self.cmd += self.device + " " + str(partfile)
	 self.oldsig = signal.signal(signal.SIGTERM, self.term_handler)
	 self.proc = popen2.Popen4(self.cmd)
	 self.pid = self.proc.pid
	 self.status = self.proc.poll()
	 while -1 == self.status:
	    self.out = self.proc.fromchild.read(512)
	    while "" != self.out:
	       sys.stdout.write(self.out)
	       self.out = self.proc.fromchild.read(512)
	    time.sleep(1)
	    self.status = self.proc.poll()
	 self.pid = 0
	 print
	 signal.signal(signal.SIGTERM, self.oldsig)
	 if 0 != os.WEXITSTATUS(self.status):
	    self.lasterror = self.cmd + " exited with status " + str(os.WEXITSTATUS(self.status))
	    print self.cmd + " exited with signal/status " + hex(self.status)	      
      else:	# Other disk type
	 self.lasterror = "Can't write to " + self.disktype
# class disk ends here.


if len(sys.argv) < 3:
   print "Wrong number of arguments."
   print """
This program needs to be called with the following parameters.

device operation [more arguments]

where device is a device name like /dev/sr0 or /dev/dvd and
operation can be "test", "free" or "write".

Operations:
test	   Scan the device and report the information found.
	   This operation needs no further arguments.
free	   Scan the device and report the available space.
	   "free" needs one additional argument to determine
	   if data is to be appended or if the disk will be
	   started from the beginning: "0" means append,
	   everything else indicates a new volume.
write	   Write a part file to disk.
	   This operation needs two additional arguments.
	   The first indicates to append or restart the
	   disk; see above. The second is the file to write.
"""
   sys.exit(1)

dvd = disk(sys.argv[1])

if "free" == sys.argv[2]:
   if len(sys.argv) == 4:
      newvol = 1
      if "0" == sys.argv[3]:
	 newvol = 0
      free = dvd.free(newvol)
      print free
      if free >= 0:
	 print "No Error reported."
      else:
	 print dvd.lasterr()
   else:
      print "Wrong number of arguments."
      sys.exit(1)
elif "test" == sys.argv[2]:
   print str(dvd)
   print "Empty disk: " + str(dvd.is_empty()) + " ReWritable disk: " + str(dvd.is_RW())
   print "Free for new volume: " + str(dvd.free(1))
   print "Free for append:     " + str(dvd.free(0))
elif "write" == sys.argv[2]:
   if len(sys.argv) == 5:
      newvol = 1
      if "0" == sys.argv[3]:
	 newvol = 0
      dvd.write(newvol, sys.argv[4])
      if "none" != dvd.lasterr():
	 print str(dvd.lasterr())
	 sys.exit(1)
      else:
	 print "Part file " + sys.argv[4] + " successfully written to disk."
   else:
      print "Wrong number of arguments."
      sys.exit(1)
else:
   print "No operation - use test, free or write."
   print "THIS MIGHT BE A CASE OF DEBUGGING BACULA OR AN ERROR!"
sys.exit(0)