#!@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
#
# 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$
#

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

# Configurable values:
dvdrwmediainfo = "@DVDRWMEDIAINFO@"
growcmd = "@GROWISOFS@"
margin = 10485760 # 10 mb security margin

# Comment the following line if you want the tray to be reloaded
# when writing ends.
growcmd += " -use-the-force-luke=notray"

# end of configurable values

## Check if we want to allow growisofs to cross the 4gb boundary
def is4gbsupported():
   processi = popen2.Popen4("uname -s -r")
   status = processi.wait()
   if not os.WIFEXITED(status):
#      print "dvd-writepart: Cannot execute uname, allowing to cross the 4gb boundary."
      return 1
   if os.WEXITSTATUS(status) != 0:
#      print "dvd-writepart: Cannot execute uname, allowing to cross the 4gb boundary."
      return 1
   strres = processi.fromchild.readline()[0:-1]
   res = strres.split(" ")
   if len(res) != 2:
#      print "dvd-writepart: Unable to parse uname (" + strres + "), allowing to cross the 4gb boundary."
      return 1
   if res[0] != "Linux":
#      print "dvd-writepart: The current OS is no Linux, allowing to cross the 4gb boundary."
      return 1
   ver = res[1].split(".")
   if len(ver) < 3:
#      print "dvd-writepart: Unable to parse version string (" + res[1] + "), allowing to cross the 4gb boundary."
      return 1
   subver = ver[2].split("-")
   
   if ((not ver[0].isdigit()) or (not ver[1].isdigit()) or (not subver[0].isdigit())):
#      print "dvd-writepart: Unable to parse version string (" + res[1] + "), allowing to cross the 4gb boundary."
      return 1
   
   if (int(ver[0]) > 2) or (int(ver[1]) > 6) or ((int(ver[0]) == 2) and (int(ver[1]) == 6) and (int(subver[0]) >= 8)):
#      print "dvd-writepart: Kernel version >=2.6.8, allowing to cross the 4gb boundary."
      return 1
   else:
#      print "dvd-writepart: Kernel version <2.6.8, not allowing to cross the 4gb boundary."
      return 0

class DVDError(Exception):
   def __init__(self, errno, value):
      self.errno = errno
      self.value = value
      if self.value[-1] == '\n':
         self.value = self.value[0:-1]
   def __str__(self):
      return str(self.value) + " || errno = " + str(self.errno) + " (" + os.strerror(self.errno & 0x7F) + ")"

class disk:
###############################################################################
#
# This class represents DVD disk informations.
# When instantiated, it needs a device name.
# Status information about the device and the disk loaded is collected only when
# asked for (for example dvd-freespace doesn't need to know the media type, and
# dvd-writepart doesn't not always need to know the free space).
#
# The following methods are implemented:
# __init__       we need that...
# __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...
#                (NB: I don't think it is a problem)
# free           Returns the available free space.
# 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          Blank the device
#
###############################################################################
   def __init__(self, devicename):
      self.device = devicename
      self.disktype = "none"
      self.hardwaredevice = "none"
      self.pid = 0
      self.next_session = -1
      self.capacity = -1

      self.freespace_collected = 0
      self.mediumtype_collected = 0

      return

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

   def __str__(self):
      if not self.freespace_collected:
         self.collect_freespace();
      if not self.mediumtype_collected:
         self.collect_mediumtype();
      
      self.me  = "Class disk, initialized with device " + self.device + "\n"
      self.me += "type = " + self.disktype
      self.me += " next_session = " + str(self.next_session) + " capacity = " + str(self.capacity) + "\n"
      self.me += "Hardware device is " + self.hardwaredevice + "\n"
      return self.me

   def collect_freespace(self): # Collects current free space
      self.cmd = growcmd + " -F " + self.device
      processi = popen2.Popen4(self.cmd)
      status = processi.wait()
      if not os.WIFEXITED(status):
         raise DVDError(0, "growisofs process did not exit correctly.")
      result = processi.fromchild.read()
      if os.WEXITSTATUS(status) != 0:
         if (os.WEXITSTATUS(status) & 0x7F) == errno.ENOSPC:
            # Kludge to force dvd-handler to return a free space of 0
            self.next_session = 1
            self.capacity = 1
            self.freespace_collected = 1
            return
         else:
            raise DVDError(os.WEXITSTATUS(status), "growisofs returned with an error " + result + ". Please check your are using a patched version of dvd+rw-tools.")
      next_sess = re.search(r"\snext_session=(\d+)\s", result, re.MULTILINE)
      capa = re.search(r"\capacity=(\d+)\s", result, re.MULTILINE)
   
      if next_sess and capa:
         self.next_session = long(next_sess.group(1))
         self.capacity = long(capa.group(1))
         
         # testing cheat (emulate 4GB boundary at 100MB)
         #if self.next_session > 100000000:
         #   self.capacity = self.next_session
      else:
         raise DVDError(0, "Cannot get next_session and capacity from growisofs.\nReturned: " + result)
      
      self.freespace_collected = 1
      return
   
   def collect_mediumtype(self): # Collects current medium type
      self.lasterror = ""
      cmd = dvdrwmediainfo + " " + self.device
      processi = popen2.Popen4(cmd)
      status = processi.wait()
      if not os.WIFEXITED(status):
         raise DVDError(dvdrwmediainfo + " process did not exit correctly.")
      if os.WEXITSTATUS(status) != 0:
         raise DVDError("Cannot get media info from " + dvdrwmediainfo)
         return
      result = processi.fromchild.read()
      
      hardware = re.search(r"INQUIRY:\s+(.*)\n", result, re.MULTILINE)
      mediatype = re.search(r"\sMounted Media:\s+([0-9A-F]{2})h, (\S*)\s", result, re.MULTILINE)
      
      if hardware:
         self.hardwaredevice = hardware.group(1)
      if mediatype:
         self.disktype = mediatype.group(2)
      else:
         raise DVDError("Media type not found in " + dvdrwmediainfo + " output")
      self.mediumtype_collected = 1
      return

   def is_empty(self):
      if not self.freespace_collected:
         self.collect_freespace();
      
      return 0 == self.next_session

   def is_RW(self):
      if not self.mediumtype_collected:
         self.collect_mediumtype();
      
      return "DVD-RW" == self.disktype or "DVD+RW" == self.disktype or "DVD-RAM" == self.disktype

   def free(self):
      if not self.freespace_collected:
         self.collect_freespace();
      
      return self.capacity-self.next_session-margin

   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):
      # Blank DVD+/-RW/-RAM when there is no data on it
      # Ideally, we should only have to do it once, but I don't know how to
      # identify if a disk is blank of if it is brand-new.
      if newvol and self.is_RW() and self.is_empty():
         print "DVD looks brand-new, blank it to fix some DVD-writers bugs."
         self.blank()
         print "Done, now writing the real part file."
      
      cmd = growcmd + growparams
      if newvol:
         cmd += " -Z "
      else:
         cmd += " -M "
      cmd += self.device + " " + str(partfile)
      print "Running " + cmd
      oldsig = signal.signal(signal.SIGTERM, self.term_handler)
      proc = popen2.Popen4(cmd)
      self.pid = proc.pid
      status = proc.poll()
      while status == -1:
         line = proc.fromchild.readline()
         while len(line) > 0:
            print line,
            line = proc.fromchild.readline()
         time.sleep(1)
         status = proc.poll()
      self.pid = 0
      print
      signal.signal(signal.SIGTERM, oldsig)
      if os.WEXITSTATUS(status) != 0:
         raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status))

   def blank(self):
      cmd = growcmd + " -Z " + self.device + "=/dev/zero"
      print "Running " + cmd
      oldsig = signal.signal(signal.SIGTERM, self.term_handler)
      proc = popen2.Popen4(cmd)
      self.pid = proc.pid
      status = proc.poll()
      while status == -1:
         line = proc.fromchild.readline()
         while len(line) > 0:
            print line,
            line = proc.fromchild.readline()
         time.sleep(1)
         status = proc.poll()
      self.pid = 0
      print
      signal.signal(signal.SIGTERM, oldsig)
      if os.WEXITSTATUS(status) != 0:
         raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status))

# class disk ends here.

def usage():
   print "Wrong number of arguments."
   print """
Usage:

dvd-handler DEVICE test
dvd-handler DEVICE free
dvd-handler DEVICE write APPEND FILE

where DEVICE is a device name like /dev/sr0 or /dev/dvd.

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.
write      Write a part file to disk.
           This operation needs two additional arguments.
           The first indicates to append (0) or restart the
           disk (1). The second is the file to write.
"""
   sys.exit(1)

if len(sys.argv) < 3:
   usage()

growcmd += " -quiet"
 
if is4gbsupported():
   growcmd += " -use-the-force-luke=4gms"

growparams = " -A 'Bacula Data' -input-charset=default -iso-level 3 -pad " + \
              "-p 'dvd-handler / growisofs' -sysid 'BACULADATA' -R"

dvd = disk(sys.argv[1])

if "free" == sys.argv[2]:
   if len(sys.argv) == 3:
      try:
         free = dvd.free()
      except DVDError, e:
         if e.errno != 0:
            print -e.errno
         else:
            print errno.EPIPE
         print str(e)
      else:
         print free
         print "No Error reported."
   else:
      print "Wrong number of arguments for free operation."
      usage()
elif "test" == sys.argv[2]:
   try:
      print str(dvd)
      print "Empty disk: " + str(dvd.is_empty()) + " ReWritable disk: " + str(dvd.is_RW())
      print "Free space: " + str(dvd.free())
   except DVDError, e:
      print "Error while getting informations: ", str(e)
elif "write" == sys.argv[2]:
   if len(sys.argv) == 5:
      try:
         dvd.write(long(sys.argv[3]), sys.argv[4])
      except DVDError, e:
         print "Error while writing part file: ", str(e)
         if e.errno != 0:
            sys.exit(e.errno & 0x7F)
         else:
            sys.exit(errno.EPIPE)
      else:
         print "Part file " + sys.argv[4] + " successfully written to disk."
   else:
      print "Wrong number of arguments for write operation."
      usage()
      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)