Python + amlabel = Bulklabeling!

/root/bin/tapelabel

#!/usr/bin/python
 
import os
import sys
import commands
from optparse import OptionParser
 
SLOT_COMMAND = '/usr/sbin/changer -slot %i'
WRITE_COMMAND = '/usr/sbin/amlabel %s %s'
WRITE_COMMAND_FORCE = '/usr/sbin/amlabel -f %s %s'
READ_COMMAND = '/usr/bin/readlabel /dev/rmt/current'
 
options = config = fs = startValue = None
 
def change_slot(slot):
	dePrint("Changing to slot %i..." % slot)
	if (not options.dryrun):
		(status, output) = commands.getstatusoutput(SLOT_COMMAND % slot)
		if (status != 0):
			print >>sys.stderr, "Error while changing tape: %s" % output
			sys.exit(-1)
	dePrint("\tDone.", 2)
 
def write_label(val):
	global options, config, fs
 
	label = fs % val
	dePrint("Writing label '%s'..." % label)
 
	if (not options.dryrun):
		if (options.force):
			(status, output) = commands.getstatusoutput(WRITE_COMMAND_FORCE % (config, label))
		else:
			(status, output) = commands.getstatusoutput(WRITE_COMMAND % (config, label))
		if (status != 0):
			if (status == 127):
				print >>sys.stderr, "amlabel reported '%s'. You might want to use -f to override this and force the label." % output
				sys.exit(-2)
			else:
				print >>sys.stderr, "Error while labeling: '%s'" % output
				sys.exit(-3)
	dePrint("\tDone.", 2)
 
def verify_label(val):
	global options, config, fs
 
	label = fs % val
	dePrint("Verifying label '%s'..." % label)
	if (not options.dryrun):
		(status, output) = commands.getstatusoutput(READ_COMMAND)
		if (status != 0):
			print >>sys.stderr, "Error while reading label: '%s'" % output
			sys.exit(-4)
 
		current_label = output.split()[-1]
		dePrint("\tRead label '%s'." % current_label, 2)
 
	if (not options.dryrun):
		return (label == current_label)
	else:
		dePrint("\tRead label '%s'." % label, 2)
		return True
 
def main():
	global options, config, fs, startValue	
 
	setup()
 
	try:
		slot = options.firstSlot
		for i in range(options.count):
			change_slot(slot)
			write_label(startValue + i)
			if (verify_label(startValue + i)):
				slot = slot + 1
			else:
				print >>sys.stderr, "Verification of label failed."
				sys.exit(-4)
	except KeyboardInterrupt:
		dePrint("# KeyboardInterrupt caught", level=0)	
 
def setup():
	global options, fs, config,startValue
 
	minVer = [2, 4]
	ver = sys.version_info[0:2]
	if not (ver[0] > minVer[0] or (ver[0] == minVer[0] and ver[1] >= minVer[1])):
		print >>sys.stderr, "This program requires Python >=%s, aborting." % ",".join(map(str, minVer))
		sys.exit(-1)
 
	## argument parsing setup
	#
	parser = OptionParser(version = "%prog 0.1")
	parser.set_usage("%prog [options] config formatstring number")
 
	parser.add_option("-v", "--verbose",
		action = "count", dest = "verbose", default = 0,
		help = "verbose output, use multiple times for spam"
	)
	parser.add_option("-q", "--quite",
		action = "count", dest = "quite", default = 0,
		help = "suppress output, use multiple times for silence"
	)
 
	parser.add_option("-f", "--firstslot",
		type = "int", dest = "firstSlot", default = 1,
		help = "specifies slot of first tape to label "
		     +  "[default: '%default']"
	)
	parser.add_option("-l", "--lastslot",
		type = "int", dest = "lastSlot", default = None,
		help = "specifies slot of last tape to label"
	)
	parser.add_option("-c", "--count",
		type = "int", dest = "count", default = None,
		help = "specifies count of tapes to label "
		     + "[default: '%default']"
	)
	parser.add_option("-F", "--force",
		action = "store_true", dest = "force",
		help = "force writing of label"
	)
 
	parser.add_option("--dry-run",
		action = "store_true", dest = "dryrun",
		help = "simulates run"
	)
 
	(options, fs) = parser.parse_args()
 
	if (len(fs) == 0):
		parser.error("You need to supply a format string.")
	elif (len(fs) != 3):
		parser.error("Need config, formatstring and start value.")
	else:
		(config, fs, startValue) = fs
		startValue = int(startValue)
 
	if (not options.lastSlot and not options.count):
		parser.error("You need to supply either a count of tapes to label or the number of the last slot which to label.")
	elif (not options.lastSlot and options.count):
		options.lastSlot = options.firstSlot + options.count - 1
	elif (options.lastSlot and not options.count):
		options.count = options.lastSlot - options.firstSlot + 1
	elif (options.lastSlot and options.count and not (options.count == options.lastSlot - options.firstSlot + 1)):
		parser.error("Start slot plus tape count does not equal end slot. Please decide on either count or endslot.")
 
	# verbosity
	if options.quite:
		options.verbose = -options.quite
 
 
def dePrint(str, level=1):
	"""prints (debug) messages"""
 
	if (options.verbose - level) >= 0:
		print str
 
 
if __name__ == "__main__":
	main()