#!/usr/bin/python2.5
# -*- coding: utf-8 -*-

import os
import re
import sys
from types import *
import time
from datetime import datetime
from datetime import timedelta

class RaidState(object):

	basecmd = "/path/to/arcconf32"
	devTypePhys = "PD"
	devTypeLog = "LD" 

	def __init__(self,controller=None):
		self.data = None
		self.controller = controller
		self.devType = None

	def is_data_valid(self):
		if not self.controller:
			print "No controller specified"
			return False
		return True

	def set_controller(self,controller):
		try:
			self.controller = int(controller)
		except:
			print "Controller has to be identified as an integer."

	def set_dev_type(self,dev_type):
		self.devType = dev_type
	
	
	def read_lines(self,cmd):			
		self.data = os.popen(cmd).readlines()
		for line in self.data:
			yield line

	def get_value(self,dev_type,attr=None,disk=None):
		if not self.is_data_valid():
			exit

		# Regexp to find single device and value
		reDev = re.compile(r'Device #(\d)') if dev_type == "PD" else re.compile(r'Logical drive number (\d)')
		reValue = re.compile(r'%s\s*?:\s*?([\w\d]*)$' % attr)
		
		# matches
		device = None
		value = None
	
		runcmd = "%s %s %i %s" % (RaidState.basecmd,"getconfig",self.controller,dev_type)
		if dev_type == "LD" and disk:
			runcmd = "%s %i" % (runcmd,disk)

		for line in self.read_lines(runcmd):
			if not device:
				# Get device
				m = re.search(reDev,line.strip())
				if m is not None:
					# Disk equals current match?
					if disk and m.group(1) == unicode(disk):
						device = disk
			else:
				# Get value
				m = re.search(reValue,line.strip())
				if m is not None:
					return m.group(1)


	def set_dev_type_config(self,dev_type=None):
		self.dev_type = dev_type


	# Convenience methods
	def get_physical_disk_state(self,disk=None):
		self.set_dev_type(RaidState.devTypePhys)
		return self.get_value(self.devType,"State",disk)

	def get_physical_disk_firmware(self,disk=None):
		self.set_dev_type(RaidState.devTypePhys)
		return self.get_value(self.devType,"Firmware",disk)

	def get_physical_disk_fru(self,disk=None):
		self.set_dev_type(RaidState.devTypePhys)
		return self.get_value(self.devType,"FRU",disk)

	def get_logical_drive_status(self,disk=None):
		self.set_dev_type(RaidState.devTypeLog)
		return self.get_value(self.devType,"Status of logical drive",disk)

	def get_logical_drive_defunct_stripes(self,disk=None):
		self.set_dev_type(RaidState.devTypeLog)
		return self.get_value(self.devType,"Defunct stripes",disk)

	def get_logical_drive_name(self,disk=None):
		self.set_dev_type(RaidState.devTypeLog)
		return self.get_value(self.devType,"Logical drive name",disk)

	def get_logical_drive_raid_level(self,disk=None):
		self.set_dev_type(RaidState.devTypeLog)
		return self.get_value(self.devType,"RAID level",disk)
	
	@staticmethod
	def help(prog):
		print """
You must supply arguments specifying what you want to check.
	
Usage: %s <type> <disk>

<type> refers to what kind of information that is to be checked. Possible 
values are:

	PS - get physical disk state
	PFW - get physical firmware version
	PFR - get FRU state for physical disk

	LS - get logical drive status
	LDS - get logical drive defunct stripes	
	LN - get logocal drive name
	LRL - get logical raid level


<disk> is the number of the disk to be checked. Check what disks that are 
available by running %s
""" % (prog,RaidState.basecmd)
				


if __name__ == "__main__":
	if len(sys.argv) < 3 or sys.argv[1] == "help":
		RaidState.help(sys.argv[0])		
		sys.exit()

	cmd = sys.argv[1]
	disk = sys.argv[2]

	rs = RaidState(controller=1)
	if cmd == "PS":
		print rs.get_physical_disk_state(disk)
	elif cmd == "PFW":
		print rs.get_physical_disk_firmware(disk)
	elif cmd == "PFR":
		print rs.get_physical_disk_fru(disk)
	elif cmd == "LS":
		print rs.get_logical_drive_status(disk)
	elif cmd == "LDS":
		print rs.get_logical_drive_defunct_stripes(disk)
	elif cmd == "LN":
        	print rs.get_logical_drive_name(disk)
	elif cmd == "LRL":
        	print rs.get_logical_drive_raid_level(disk)
	else:
		RaidState.help(sys.argv[0])
	rs = None