spectools 1.0.0

data/lib/spectools/version.rb

@@ -0,0 +1,9 @@
+module Spectools #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/vnmsh.rb

@@ -0,0 +1,1930 @@
+#!/usr/bin/ruby
+
+include SpecTools
+
+if defined?(SpecTools::Attr)
+	class SpecTools::Attr
+		#Take a line of CLI <tt>show attributes mh=</tt> output and populate a new Attr object
+		def self.cli_parse_mh(line)
+			specattr = Attr.new()
+			#Because the instance identifier may not fit into the column space allocated, we can't reliably use unpack
+			#to parse the data. Instead, we'll use a regex. This means that the attr name can't contain whitespace,
+			#but it should be okay.
+			if line.chomp =~ /^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$/
+				specattr.id = $1 
+				specattr.name = $2
+				specattr.list = true
+				specattr.value_table[$3] = $4
+			elsif line.chomp =~ /^(\S+)\s+(\S+)\s+(.+)$/
+				specattr.id = $1
+				specattr.name = $2
+				specattr.value = $3
+			end
+			return specattr
+		end
+
+		#Take a line of CLI <tt>show attributes mth=</tt> output and populate a new Attr object
+		def self.cli_parse_mth(line)
+			attr = Attr.new
+			attr.id,attr.name,attr.type,flags = line.chomp.unpack('A12A33A18A23')
+			flags.split(/,/).each do |flag|
+				case flag
+					when 'E'
+						attr.external = true
+					when 'R'
+						attr.readable = true
+					when 'W'
+						attr.writeable = true
+					when 'S'
+						attr.shared = true
+					when 'T'
+						attr.list = true
+					when 'G'
+						attr.guaranteed = true
+					when 'O' 
+						attr.global = true
+					when 'M'
+						attr.memory = true
+					when 'D'
+						attr.database = true
+					when 'P'
+						attr.polled = true
+					when 'L'
+						attr.logged = true
+					when 'V'
+						attr.preserve = true
+				end
+			end
+			return attr
+		end
+
+		#Use CLI to retrieve the enumerations for the Attr.
+		#Returns a new hash of enumerations.
+		def cli_get_enums(session=nil)
+			unless self.id.hex?
+				raise ArgumentError, 'To enumerate this Attr, the Attr must have a valid id.'
+			end
+			enums = Hash.new
+			session = VNMSH.get_session(session)
+			enum_output = session.show_enumerations(:attr,self)
+			if enum_output != nil
+				enum_output.each do |line|
+					line.chomp!
+					id,str,val = line.unpack('A12A34A12')
+					val.sub!(/\s+/, '')
+					str.sub!(/\s+$/, '')
+					enums[val] = str
+				end
+			else
+				return nil
+			end
+			return enums
+		end
+
+
+		#Execute cli_get_enums and modify the Attr object in place.
+		def cli_get_enums!(session=nil)
+			new_enums = cli_get_enums(session)
+			self.enums = new_enums
+		end
+
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::MType)
+	class SpecTools::MType
+		#Take a line of CLI <tt>show types</tt> output and populate a new MType object.
+		def self.cli_parse(line)
+			handle,name,flags = line.unpack('A12A1025A11')
+			type = MType.new(handle,name)
+			flags.chomp.split(/,/).each do |flag|
+				case flag
+					when 'V'
+						type.visible = true
+					when 'I'
+						type.instantiable = true
+					when 'D'
+						type.derivable = true
+					when 'N'
+						type.destroyable = false
+					when 'U'
+						type.unique = true
+					when 'R'
+						type.required = true
+				end
+			end
+			return type
+				
+		end
+
+		#Take a line of CLI <tt>show inheritance</tt> output and populate a new MType object.
+		def self.cli_parse_inheritance(line)
+			handle,name,flags,inheritance = line.chomp.unpack('A12A18A13A10')
+			type = MType.new(handle,name)
+			type.inheritance = inheritance
+			flags.split(/,/).each do |flag|
+				
+				case flag
+					when 'V'
+						type.visible = true
+					when 'I'
+						type.instantiable = true
+					when 'D'
+						type.derivable = true
+					when 'N'
+						type.destroyable = false
+					when 'U'
+						type.unique = true
+					when 'R'
+						type.required = true
+				end
+			end
+		return type
+		end
+
+		#Use CLI to locate Model Types. Returns an array of MType objects.
+		# 
+		#<tt>filter</tt> is a hash of filter types and thier values.
+		#
+		#If no filter is passed, returns all MTypes for the connected Landscape.
+		#Filter options:
+		#
+		#* <tt>:flag</tt> - filters on the provided flag
+		#  * Example: <tt>MType.cli_find({:flag,:unique})</tt>
+		#* <tt>:range</tt> - filters on a range of model types 
+		#  * Range can either be a single string, an Array of handles, or an Array of MTypes.
+		#  * Example: <tt>MType.cli_find({:range,'0x400000-0x500000'})</tt>
+		#  * Example: <tt>MType.cli_find(:range,['0x400000','0x500000']})</tt>
+		#* <tt>:name</tt> - filters on the model type's name (partials accepted) 
+		#  * Example: <tt>MType.cli_find({:name,'VNM'})</tt>
+		#* <tt>:landscape</tt> - filters on the given Landscape.
+		#  * Example: <tt>MType.cli_find({:landscape,'0x400000'})</tt>
+		def self.cli_find(filter=nil,session=nil)
+			session = VNMSH.get_session(session)
+			mtypes = Array.new
+			if filter && filter[:flag]
+				filter[:flag] = case filter[:flag]
+				when :visible then 'V'
+				when :instantiable then 'I'
+				when :derivable then 'D'
+				when :nodestroy then 'N'
+				when :unique then 'U'
+				when :required then 'R'
+				end
+			end
+			mtype_output = session.show_types(filter)
+			mtype_output.each do |line|
+				mtypes.push(MType.parse(line))
+			end
+			return mtypes
+		end	
+
+		#Use CLI to retrieve a hash of Attr objects for a given MType.
+		#
+		#<tt>filter</tt> is a hash of filter types and thier values.
+		#
+		#If no filter is given, all attributes are returned.
+		#
+		#Filter options.
+		#
+		#* <tt>:range</tt> - returns attributes whose ID in in the specified range.
+		#  * Range can take a single range string, or an array of MType handles or MTypes.
+		#  * Example: <tt>mtype.cli_get_attrs({:range,['0x10000','0x1000a])</tt>
+		#  * Example: <tt>mtype.cli_get_attrs({:range,'0x10000-0x1000a'})</tt>
+		#* <tt>:name</tt> - returns attributes whose name contains the specified string. 
+		#  * Example: <tt>mtype.cli_get_attrs({:name,'Condition'})</tt>
+		#* <tt>:flag</tt> - returns attributes that have the specified flag set. 
+		#  * Example: <tt>mtype.cli_get_attrs({:flag,:global})</tt>
+		#* <tt>:landscape</tt> - returns attributes in the specified landscape. 
+		#  * landscape can be a Landscape object or a landscape handle.
+		#  * Example: <tt>mtype.cli_get_attrs({:landscape,'0x400000'})</tt>
+		def cli_get_attrs(filter=nil,session=nil)
+			unless self.handle.hex?
+				raise ArgumentError, 'Must supply a valid model type handle'
+			end
+			attrs = Hash.new
+			session = VNMSH.get_session(session)
+			if filter && filter[:flag]
+				flag = case filter[:flag]
+				       when :external then 'E'
+				       when :readable then 'R'
+				       when :writable then 'W'
+				       when :shared then 'S'
+				       when :list then 'T'
+				       when :guaranteed then 'G'
+				       when :global then 'O'
+				       when :memory then 'M'
+				       when :database then 'B'
+				       when :polled then 'P'
+				       when :logged then 'L'
+				       when :preserve then 'V'
+				       else
+					       raise ArgumentError, 'Invalid flag'
+				       end
+				filter[:flag] = flag
+			end
+			attr_output = session.show_attributes(:mtype,self,filter,false)
+			attr_output.each do |line|
+				tmpattr = Attr.parse_mth(line)
+				attrs[tmpattr.id] = tmpattr
+			end
+			return attrs
+		end
+
+		#Call cli_get_attrs and populate the MType's attrs attribute.
+		def cli_get_attrs!(filter=nil,session=nil)
+			attrs = self.cli_get_attrs(filter,session)
+			self.attrs = attrs
+		end
+
+		#Create a new Model via CLI for this type.
+		#attrs is an Array of Attr objects that you want to be set on the
+		#model when it is created.
+		def cli_create_model(attrs=nil,lh=nil,session=nil)
+			session = VNMSH.get_session(session)
+			return session.create_model(self,attrs,lh)
+		end
+
+
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Model)
+	class SpecTools::Model	
+		#Take a line of CLI <tt>show models</tt> or <tt>seek</tt> output and populate a new Model object.
+		def self.cli_parse(line)
+			mhandle,mname,mthandle,mtname = line.chomp.unpack('A12A1025A12A20')
+			mtype = MType.new(mthandle,mtname)
+			model = Model.new(mhandle,mname,mtype)
+			return model
+		end
+
+		#Use CLI to locate Models. Returns an array of Model objects.
+		#
+		#
+		#<tt>filter</tt> is a hash of filter types and thier values.
+		#
+		#If no filter is passed, returns all Models for the connected Landscape.
+		#
+		#If <tt>devices</tt> is true, returns all devices. In this case,
+		#<tt>filter</tt> is ignored.
+		#
+		#Filter options:
+		#
+		#* <tt>:range</tt> - filters on a range of models.
+		#  * Range can either be a single string, an Array of handles, or an Array of Models.
+		#  * Example: <tt>Model.cli_find({:range,'0x400000-0x500000'})</tt>
+		#  * Example: <tt>Model.cli_find(:range,['0x400000','0x500000']})</tt>
+		#* <tt>:name</tt> - filters on the model's name (partials accepted) 
+		#  * Example: <tt>Model.cli_find({:name,'VNM'})</tt>
+		#* <tt>:landscape</tt> - filters on the given Landscape.
+		#  * Example: <tt>Model.cli_find({:landscape,'0x400000'})</tt>
+		#* <tt>:mtype</tt> - Returns all models of the specified type. 
+		#  * Type can either be an MType object, or a model type handle.
+		#  * Examples: 
+		#    * <tt>Model.cli_find(:mtype, '0x13d0018')</tt>
+		#    * <tt>Model.cli_find(:mtype, MType.new('0x13d0018'))</tt>
+		#
+		def self.cli_find(filter=nil,devices=false,session=nil)
+			session = VNMSH.get_session(session)
+			models = Array.new
+			if devices
+				if filter && filter[:landscape]
+					model_output = session.show_devices(filter[:landscape])
+				else
+					model_output = session.show_devices
+				end
+			else	
+				model_output = session.show_models(filter)
+			end
+			model_output.each do |line|
+				models.push(Model.parse(line))
+			end
+			return models
+		end
+
+		#Use CLI to locate Models by attribute.
+		#
+		#<tt>specattr</tt> may be an Attr object or an attribute ID.
+		#If <tt>specattr</tt> is an Attr and has the value attribute set,
+		#<tt>value</tt> does not have to be set. However, you can override
+		#the Attr object's value in the search by providing your own
+		#<tt>value</tt>.
+		#
+		#If <tt>specattr.value</tt> is nil, or of <tt>specattr</tt> is simply
+		#an attribute ID, <tt>value</tt> must be set.
+		#
+		#If <tt>substring</tt> is true, a partial string match is performed.
+		#
+		#If <tt>nocase</tt> is true, case is ignored.
+		#
+		def self.cli_find_by_attr(specattr,value=nil,substring=false,nocase=false,session=nil)
+			session = VNMSH.get_session(session)
+			models = Array.new
+			model_output = session.seek(specattr,value,substring,nocase)
+			model_output.each do |line|
+				models.push(Model.parse(line))
+			end
+			return models
+		end
+
+		#Use CLI to retrieve a hash of Attr objects for a given Model.
+		#
+		#<tt>filter</tt> is a hash of filter types and thier values.
+		#
+		#If no filter is given, all attributes are returned.
+		#If <tt>enumerate</tt> is set to true, the values will
+		#be automatically enumerated.
+		#
+		#Filter options.
+		#
+		#* <tt>:id</tt> - returns the specific attribute.
+		#  * Takes an Attr or an attribute ID.
+		#  * Returns all instances for a list attribute.
+		#  * Example: <tt>model.cli_get_attrs({:id,'0x10000'})</tt>
+		#* <tt>:instance</tt> = returns a specific instance of an attribute.
+		#  * Takes a 2 element array.
+		#    * The first element must be an Attr or an attribute id.
+		#    * The second element must be an instance identifier.
+		#  * Example: <tt>model.cli_get_attrs({:instance,['0x10000','192.168.1.1']})</tt>
+		#* <tt>:range</tt> - returns attributes whose ID in in the specified range.
+		#  * Range can take a single range string, or an array of Model handles or Models.
+		#  * Example: <tt>model.cli_get_attrs({:range,['0x10000','0x1000a])</tt>
+		#  * Example: <tt>model.cli_get_attrs({:range,'0x10000-0x1000a'})</tt>
+		#* <tt>:name</tt> - returns attributes whose name contains the specified string. 
+		#  * Example: <tt>model.cli_get_attrs({:name,'Condition'})</tt>
+		def cli_get_attrs(filter=nil,enumerate=false,session=nil)
+			unless self.handle.hex?
+				raise ArgumentError, 'Must supply a valid model handle'
+			end
+			attrs = Hash.new
+			session = VNMSH.get_session(session)
+
+			attr_output = session.show_attributes(:model,self,filter,enumerate)
+			attr_output.each do |line|
+				tmpattr = Attr.parse_mh(line)
+				if attrs[tmpattr.id] && tmpattr.list && attrs[tmpattr.id].value_table
+					newiid = tmpattr.value_table.keys.first
+					attrs[tmpattr.id].value_table[newiid] = 
+						tmpattr.value_table[newiid]
+				else
+					attrs[tmpattr.id] = tmpattr
+				end
+			end
+			return attrs
+		end
+
+		#Use CLI to retreive the children of the current model.
+		#Returns an array of Model objects.
+		#
+		#If <tt>relation</tt> is set to a Relation or a relation
+		#name, only parents with the given relation will be 
+		#retrieved.
+		def cli_get_children(relation=nil,session=nil)
+			models = Array.new
+			session = VNMSH.get_session(session)
+			model_output = session.show_children(self,relation)
+			model_output.each do |line|
+				models.push(Model.parse(line))
+			end
+			return models
+		end
+
+		#Use CLI to retreive the parents of the current model.
+		#Returns an array of Model objects.
+		#
+		#If <tt>relation</tt> is set to a Relation or a relation
+		#name, only parents with the given relation will be 
+		#retrieved.
+		def cli_get_parents(relation=nil,session=nil)
+			models = Array.new
+			session = VNMSH.get_session(session)
+			model_output = session.show_parents(self,relation)
+			model_output.each do |line|
+				models.push(Model.parse(line))
+			end
+			return models
+		end
+
+		#Use CLI to retreive the watches of the current model.
+		#Returns an array of Watch objects.
+		def cli_get_watches(session=nil)
+			watches = Array.new
+			session = VNMSH.get_session(session)
+			watch_output = session.show_watch(self)
+			watch_output.each do |line|
+				watches.push(SpecTools::Watch.parse(line))
+			end
+			return watches
+		end
+
+		#Call cli_get_attrs and populate the current Model's attrs attribute.
+		#Takes the same arguments as cli_get_attrs
+		def cli_get_attrs!(filter=nil,enumerate=false,session=nil)
+			attrs = self.cli_get_attrs(filter,enumerate,session)
+			self.attrs = attrs
+		end
+
+	        #Use CLI to destroy a model.
+		#<tt>model</tt> can be either a valid Model, or a model handle.
+		def self.cli_destroy(model,session=nil)
+			session = VNMSH.get_session(session)
+			session.destroy_model(model)
+		end
+
+		#Use CLI to destroy this model.
+		def cli_destroy(session=nil)
+			self.class.destroy(self.handle,session)
+		end
+
+		#Use CLI to create a new model by IP.
+		#
+		#Options:
+		#* <tt>ip</tt> - Required. The device's IP address.
+		#* <tt>community</tt> - Optional. The community string.
+		#* <tt>timeout</tt> - Optional. The device's timeout.
+		#* <tt>retries</tt> - Optional. The number of times to attempt to contact the device.
+		#* <tt>sdm</tt> - Optional. The address of the Secure Domain Connector.
+		#* <tt>landscape</tt> - Optional. The landscape to creat the device on. 
+		#
+		def self.cli_discover(ip,community=nil,timeout=nil,retries=nil,sdm=nil,landscape=nil,session=nil)
+			session = VNMSH.get_session(session)
+			session.discover_device(ip,community,timeout,retries,sdm,landscape)
+		end
+
+		#Use CLI to create a new model.
+		#<tt>mtype</tt> may either be a valid MType object, or a model type handle.
+		#<tt>attrs</tt> is an array of Attr objects that you want to be set on the
+		#model when it is created.
+		def self.cli_create(mtype,attrs=nil,lh=nil,session=nil)
+			session = VNMSH.get_session(session)
+			return session.create_model(mtype,attrs,lh)
+		end
+
+		#Use CLI to update a model's attributes.
+		#
+		#<tt>attrs</tt> can be a single Attr object, or an array of Attr objects.
+		#
+		#If <tt>update_model</tt> is true , the attrs of the model will be updated, as well.
+		def cli_update_attrs(attrs,update_model = false,session=nil)
+			session = VNMSH.get_session(session)
+			result = session.update_model(self,attrs)
+			if result && update_model
+				attrs.each do |specattr|
+					self.attrs[specattr.id] = specattr
+				end
+			end
+			return result
+		end
+
+		#Use CLI to associate this model with another.
+		#<tt>position</tt> is either <b>:left</b> or <b>:right</b>, and indicates
+		#which side of this assocaition the current model will
+		#reside.
+		#The <tt>model</tt> argument may be a valid Model or a model handle. 
+		#* Example: <tt>left_model.associate(:left,right_model,relation)</tt>
+		def cli_associate(position,model,relation,session = nil)
+			session = VNMSH.get_session(session)
+			if position == :left
+				return session.create_association(relation,self,model)
+			elsif position == :right
+				return session.create_association(relation,model,self)
+			else
+				raise ArgumentError, "Valid options are :left or :right"
+			end
+		end
+
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Relation)
+	class SpecTools::Relation
+		#Take a line of CLI <tt>show relations</tt> output and populate a new Relation object.
+		def self.cli_parse(line)
+			name,type = line.chomp.unpack('A33A15')
+			rel = Relation.new(name,type)
+			return rel
+		end
+
+		#Use CLI to locate Reltions. Returns an array of Relation objects.
+		#
+		#If <tt>lanscape</tt> is set to a Landscape or a landscape handle,
+		#will only show relations for the given landscape.
+		def self.cli_find(landscape=nil,session=nil)
+			relations = Array.new
+			session = VNMSH.get_session(session)
+			rel_output = session.show_relations(landscape)
+			rel_output.each do |line|
+				relations.push(Relation.parse(line))
+			end
+			return relations
+		end
+
+		#Retrieve an Array of Rules for the given Relation.
+		#
+		#If <tt>lanscape</tt> is set to a Landscape or a landscape handle,
+		#will only show rules for the given landscape.
+		def cli_get_rules(landscape=nil,session=nil)
+			session = VNMSH.get_session(session)
+			rules = Array.new
+			rule_output = session.show_rules(self)
+			rule_output.each do |line|
+				rules.push(Rule.parse(line))
+			end
+			return rules
+		end
+
+		#Use CLI to create a new Association based on this Relation.
+		#Model arguments may be Model objects or model handles. 
+		def cli_associate(left_model,right_model,session=nil)
+			session = VNMSH.get_session(session)
+			return session.create_association(self,left_model,right_model)
+		end
+		
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Association)
+	class SpecTools::Association
+		#Take a line of CLI <tt>show associations</tt> output and populate a new Association object
+		def self.parse(line)
+			assoc = Association.new()
+			lmhandle,lmname,rel,rmhandle,rmname = line.chomp.unpack('A12A1025A33A12A1024')
+			assoc.left_model.handle = lmhandle
+			assoc.left_model.name = lmname
+			assoc.relation.name = rel
+			assoc.right_model.handle = rmhandle
+			assoc.right_model.name = rmname
+			return assoc
+		end
+
+		#Take a line of CLI <tt>show children</tt> output and populate a new Association object
+		def self.parse_child(line)
+			mhandle,mname,mthandle,mtname,rel = line.chomp.unpack('A12A1025A12A17A31')
+			mtype = MType.new(mthandle,mtname)
+			model = Model.new(mhandle,mname,mtype)
+			relation = Relation.new(rel)
+			assoc = Association.new(nil,model,relation)
+			return assoc
+		end
+
+		#Take a line of CLI <tt>show parents</tt> output and populate a new Association object
+		def self.parse_parent(line)
+			mhandle,mname,mthandle,mtname,rel = line.chomp.unpack('A12A1025A12A17A31')
+			mtype = MType.new(mthandle,mtname)
+			model = Model.new(mhandle,mname,mtype)
+			relation = Relation.new(rel)
+			assoc = Association.new(model,nil,relation)
+			return assoc
+		end
+
+		#Use CLI to destroy a given association.
+		#<tt>left_model</tt> and <tt>right_model</tt>  may be Model objects or model handles. 
+		#The <tt>relation</tt> argument may be a Relation or a valid relation name.
+		def self.cli_destroy(left_model,right_model,relation,session=nil)
+			session = VNMSH.get_session(session)
+			session.destroy_association(relation,left_model,right_model)
+		end
+
+		#Use CLI to destroy this association.
+		def cli_destroy(session=nil)
+			self.class.cli_destroy(left_model,right_model,relation,session)
+		end
+
+		#Use CLI to create a new Association
+		#<tt>left_model</tt> and <tt>right_model</tt>  may be Model objects or model handles. 
+		#The <tt>relation</tt> argument may be a Relation or a valid relation name.
+		def self.cli_create(relation,left_model,right_model,session = nil)
+			session = VNMSH.get_session(session)
+			return session.create_association(relation,left_model,right_model)
+		end
+
+
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Alarm)
+	class SpecTools::Alarm
+		#Take a line of CLI <tt>show</tt> output and populate a new Alarm object
+		def self.cli_parse(line)
+			alarm = Alarm.new
+			#OK, here we go. Unfortunately, we have no guidelines to parse this data. It doesn't tend to be fixed-width, and
+			#there are no delimteres for a good regex. So, here we have to mix the 2 as best we can.
+			#First, we can use a regex to grab out the first few fields.
+			line =~ /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/
+			alarm.id = $1
+			date = $2
+			time = $3
+			alarm.causeid = $4
+			alarm.model.handle = $5
+			rest = $6
+			month,day,year = date.split(/\//)
+			hour,min,sec = time.split(/:/)
+			alarm.time = Time.local(year,month,day,hour,min,sec)
+			#Alright, now we know that the model name is 1024 characters, so I can grab that with unpack
+			alarm.model.name,rest = rest.unpack('A1025A8192')
+			#Now, we have to use a regex to extract the model type name, as it will extend and not truncate. 
+			#We're lucky that Model type names usually don't contain whitespace.
+			rest =~ /^(\S+)\s+(.*)$/
+			alarm.model.type.name = $1
+			rest = $2
+			#Now, whether we like it or not, we have to use unpack for the rest
+			alarm.severity,ack,stale,alarm.assignment,alarm.status = rest.unpack('A14A4A6A25A4096')
+			if ack =~ /Yes/
+				alarm.ack = true
+			end
+			if stale =~ /Yes/
+				alarm.stale = true
+			end
+			return alarm
+		end
+
+		#Use CLI to find Alarms. Returns an array of Alarm objects.
+		#Available find types:
+		#* <tt>:standard</tt> - Retrieves the standard list of alarms.
+		#* <tt>:all</tt> - Retrieves all alarms, including MAINTENANCE.
+		#* <tt>:model</tt> - Retrieves standard alarms for a given model. 
+		#  * If set, <tt>mh_or_lh</tt> must be a valid Model or model handle.
+		#* <tt>:model</tt> - Identical to :model, except returns all alarms.
+		#* <tt>:landscape</tt> - Retrieves standards alarms for a given landscape.
+		#  * If set, <tt>mh_or_lh</tt> must be a valid Landscape or landscape handle.
+		#
+		#Setting <tt>probcause</tt> to true will include the Probable Cause
+		#information in the <tt>message</tt> attribute of each Alarm.
+		def self.cli_find(type=:standard,mh_or_lh=nil,probcause=false,session=nil)
+			session = VNMSH.get_session(session)
+			alarms = Array.new
+			alarm_output = session.show_alarms(type,mh_or_lh,probcause)
+			causes = Hash.new
+			alarm_output.each do |line|
+				if line =~ /\d+\s+\d\d\/\d\d\/\d\d\d\d/ 
+					alarms.push(Alarm.parse(line))
+				elsif line =~ /^(0x[a-fA-F0-9]+)\s/
+					causeid = $1
+					causes[causeid] = line.sub(/^(0x[a-fA-F0-9]+)\s/,"")
+				end
+			end
+			if probcause
+				alarms.each do |alarm|
+					alarm.message = causes[alarm.causeid]
+				end
+			end
+			return alarms
+		end
+		
+		#Use CLI to destroy an alarm.
+		def self.cli_destroy(aid,landscape=nil,session=nil)
+			session = VNMSH.get_session(session)
+			session.destroy_alarm(aid,landscape)
+		end
+		
+		#Use CLI to destroy this alarm.
+		def cli_destroy(landscape=nil,session=nil)
+			self.class.cli_destroy(id,landscape,session)
+		end
+
+		#Use CLI to save all attributes of this alarm.
+		def cli_save(session=nil)
+			session = VNMSH.get_session(session)
+			result = true
+			result = session.update_alarm(id, :ticket, ticket, true) && result if ticket != nil
+			result = session.update_alarm(id, :assign, assignment, true) && result if assignment != nil
+			result = session.update_alarm(id, :status, status, true) && result if status != nil
+			result = session.update_alarm(id, :ack, ack) && result if ack != nil
+			result = session.update_alarm(id, :url, url, true) && result if url != nil
+			result
+		end
+
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Event)
+	class SpecTools::Event
+		#Take a line of CLI <tt>show</tt> output and populate a new Event object.
+		def self.cli_parse(line)
+			event = Event.new
+			date,time,type,mhandle,mname,mtname,evformat = line.chomp.unpack('A10A12A12A12A1025A15A4096')
+			month,day,year = date.split(/\//)
+			hour,min,sec = time.split(/:/)
+			event.time = Time.local(year,month,day,hour,min,sec)
+			event.type = type
+			event.model.handle = mhandle
+			event.model.name = mname
+			event.model.type.name = mtname
+			return event
+		end
+
+		#Use CLI to find Events. Returns an array of Event objects. Available find types:
+		#* <tt>:all</tt> - Retrieve all events.
+		#* <tt>:model</tt> - Retrieve all events for a given model.
+		#  * If set, mh_or_lh must be a valid Model or a model handle.
+		#* <tt>:landscape</tt> - Retrieve all events for a given landscape.
+		#  * If set, mh_or_lh must be a valid Landscape or a landscape handle.
+		#Options:
+		#* <tt>limit</tt> - Set the maximum number of events to retrieve.
+		#  * Default is 2000, Setting to :all is equivalent to setting to 10000
+		#* <tt>evformat</tt> - If set to true, populate the Events with the event message.
+		def self.cli_find(type=:all,mh_or_lh=nil,limit=2000,evformat=false,session=nil)
+			session = VNMSH.get_session(session)
+			events = Array.new
+			event_output = session.show_events(type,mh_or_lh,limit,evformat)
+			event_output.each do |line|
+				if line =~ /^\d\d\/\d\d\/\d\d\d\d/
+					events.push(Event.parse(line))
+				else
+					events.last.message = events.last.message + line
+				end
+			end
+			return events
+			
+		end
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Rule)
+	class SpecTools::Rule
+		#Take a line of CLI <tt>show rules</tt> output and populate a new Rule object.
+		def self.cli_parse(line)
+			line.chomp =~ /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+).*$/
+			#lmthandle,lmtname,rmthandle,rmtname = line.chomp.unpack('A12A18A12A18')
+			lmthandle = $1
+			lmtname = $2
+			rmthandle = $3
+			rmtname = $4
+			lmtype = MType.new(lmthandle,lmtname)
+			rmtype = MType.new(rmthandle,rmtname)
+			rule = Rule.new(lmtype,rmtype)
+			return rule
+		end
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Watch)
+	class SpecTools::Watch
+		#Take a line of CLI <tt>show watch</tt> output and populate a new Watch object.
+		def self.cli_parse(line)
+			id,name,type,status = line.chomp.unpack('A11A33A17A10')
+			watch = Watch.new(id,name,type,status)
+			return watch
+		end
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+
+if defined?(SpecTools::Landscape)	
+	class SpecTools::Landscape
+		#Take a line of CLI <tt>show landscapes</tt> output and populate a new Landscape object.
+		def self.cli_parse(line)
+			ssname,precedence,port,service,handle = line.chomp.unpack('A33A14A8A12A10')
+			landscape = Landscape.new(handle,ssname,precedence,port,service )
+			return landscape
+		end
+
+		#Use CLI to retrieve all available landscapes.
+		def self.cli_get_landscapes(session=nil)
+			session = VNMSH.get_session(session)
+			landscapes = Array.new
+			lscape_output = session.show_landscapes
+			lscape_output.each do |line|
+				landscapes.push(Landscape.parse(line))
+			end
+			return landscapes
+		end
+	end
+else
+	raise NameError, 'You must require the spectools lib in order to use VNMSH'
+end
+	
+# == SpecTools::VNMSH
+# Represents a CLI session to VNMSH
+class VNMSH
+	
+	#The ID of the connected session.
+	attr_reader :session_id
+	#The currently connected landscape.
+	attr_reader :current_landscape
+	#The number of reconncects performed before a command is considered unsuccessful.
+	attr_accessor :reconnect_retries
+
+	class << self
+		#The default session to use to execute VNMSH commands.
+		attr_accessor :default_session
+	end
+	
+	#Create a new VNMSH session. <tt>specroot</tt> is accessed from the SPECROOT
+	#environement variable, if no <tt>specroot</tt> is passed.
+	def initialize(specroot = nil)
+		@vnmshdir = '/vnmsh/'
+		vnmshcommands = ['ack','connect','create','destroy','disconnect','seek','show','update']
+		if specroot.nil?
+			@specroot = ENV['SPECROOT']
+		else
+			@specroot = specroot
+		end
+		vnmshcommands.each do |vnmshcommand|
+			command = @specroot + @vnmshdir + vnmshcommand
+			unless File.exists?(command)
+				raise EnvironmentError, "Command #{command} is not available"
+			end
+		end
+		@session_id = rand(20000)
+		@connected = false
+		@reconnect_retries = 3
+	end
+	
+	#Take a parameter check to see if either the session was explictly passed,
+	#or if SpecTools::VNMSH#default_session is set.
+	#Returns a valid VNMSH object if successful.
+	#Raises ArgumentError if no valid VNMSH session is found.
+	def self.get_session(arg)
+		if arg.instance_of? VNMSH
+			return arg
+		elsif VNMSH::default_session.instance_of? VNMSH
+			return VNMSH::default_session
+		else
+			raise ArgumentError, 'You must pass a valid session or set SpecTools::VNMSH.default_session to a valid session'
+		end
+	end
+
+
+	#Connect to the SpectroSERVER
+	#If successful, returns a Landscape object indicating what landscape we connected to.
+	#Returns a ConnectError if it fails
+	def connect(ss = nil, landscape = nil)
+		connectcmd = @specroot + '/vnmsh/connect '
+		unless ss.nil? 
+			connectcmd = connectcmd + ss
+		end
+		connectcmd = connectcmd + ' 2>&1'
+		output = StringIO.new(`#{connectcmd}`)
+		result = output.readline
+		if result =~ /^connect: successful (.*)/
+			@current_landscape = Landscape.new()
+			@current_landscape.ss = $1
+			output.readline =~ /current landscape is (0x\d+)/
+			@current_landscape.handle = $1
+			@connected = true
+			return @current_landscape
+		elsif result =~ /^connect: already connected to/
+			return @current_landscape
+		else
+			raise ConnectError, result
+		end
+	end
+
+	#Disconnect from the SS. Returns true if the command succeeds, 
+	#otherwise returns the error string of the disconnect. 
+	#Either way, session will be marked as disconnected.
+	def disconnect
+		disconnectcmd = @specroot + '/vnmsh/disconnect 2>&1'
+		output = StringIO.new(`#{disconnectcmd}`)
+		@connected = false
+		result = output.readline
+		if result =~ /^disconnect: successful/
+			return true
+		else 
+			return result
+		end
+	end
+
+	#Execute a VNMSH command.
+	#Returns a StringIO object with the command's output.
+	#Raises a NotConnectedError if the command exceeds
+	#<tt>reconnect_retries</tt>.
+	def exec_cmd(cmd)
+		@retries = 0
+		unless self.connected?
+			raise NotConnectedError
+		end
+		cmd = @specroot + '/vnmsh/' + cmd + ' 2>&1'
+		ENV['CLIMNAMEWIDTH'] = 1024.to_s
+		ENV['CLISESSID'] = self.session_id.to_s
+		begin
+			output = `#{cmd}`
+			if $?.exitstatus > 0 && StringIO.new(output).readline =~ /Please connect first/
+				raise NotConnectedError
+			else
+				return StringIO.new(output)
+			end
+		rescue NotConnectedError
+			@retries = @retries + 1
+			unless @retries > self.reconnect_retries
+				self.disconnect
+				self.connect
+				retry
+			else
+				raise
+			end
+		end 
+			
+	end
+		
+	
+
+	#Returns true if the session is currently connceted to a SpectroSERVER.
+	def connected?
+		return @connected
+	end
+
+	#Check to see if the show response returned invalid model or landscape handle.
+	def show_invalid_mh_or_lh?(result)
+		if result =~ /invalid model handle/
+			raise CommandError, result
+		elsif result =~ /invalid landscape handle/
+			raise CommandError, result
+		elsif result =~ /no current model defined/
+			raise CommandError, result
+		end
+	end
+
+		
+		
+	#Execute the <tt>show alarms</tt> command.
+	#
+	#Available show types:
+	#* <tt>:standard</tt> - Retrieves the standard list of alarms.
+	#* <tt>:all</tt> - Retrieves all alarms, including MAINTENANCE.
+	#* <tt>:model</tt> - Retrieves standard alarms for a given model. 
+	#  * If set, <tt>mh_or_lh</tt> must be a valid Model or model handle.
+	#* <tt>:model</tt> - Identical to :model, except returns all alarms.
+	#* <tt>:landscape</tt> - Retrieves standards alarms for a given landscape.
+	#  * If set, <tt>mh_or_lh</tt> must be a valid Landscape or landscape handle.
+	#
+	#Setting <tt>probcause</tt> to true will include the Probable Cause
+	#information in the <tt>message</tt> attribute of each Alarm.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_alarms(type=:standard,mh_or_lh=nil,probcause=false)
+		valid_types = [ :standard,
+				:model,
+				:model_all,
+				:landscape,
+				:landscape_all,
+				:all ]
+		showcmd = 'show alarms '
+		valid_type = false
+		valid_types.each do |v_type|
+			valid_type = v_type || valid_type
+		end
+
+		raise ArgumentError, 'Valid show types are :standard, :all, 
+				      :model, :model_all, :landscape, or :landscape_all' unless valid_type
+
+		if type == :all || type == :model_all || type == :landscape_all
+			showcmd = showcmd + ' -a '
+		end
+		showcmd = showcmd + ' -x ' if probcause
+		if type == :model_all || type == :model
+			showcmd += ' mh='
+			showcmd = showcmd + get_handle(mh_or_lh,Model)
+		end
+		if type == :landscape_all || type == :landscape
+			showcmd += ' lh='
+			showcmd = showcmd + get_handle(mh_or_lh,Landscape)
+		end
+		output = exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^ID\s+/
+			return output
+		end
+	end 
+
+	#Execute the <tt>show models</tt> command.
+	#
+	#If no filter is passed, returns all model listings for the connected Landscape.
+	#
+	#Filter options:
+	#
+	#* <tt>:range</tt> - filters on a range of models.
+	#  * Range can either be a single string, an Array of handles, or an Array of Models.
+	#  * Example: <tt>show_models({:range,'0x400000-0x500000'})</tt>
+	#  * Example: <tt>show_models(:range,['0x400000','0x500000']})</tt>
+	#* <tt>:name</tt> - filters on the model's name (partials accepted) 
+	#  * Example: <tt>show_models{:name,'VNM'})</tt>
+	#* <tt>:landscape</tt> - filters on the given Landscape.
+	#  * Example: <tt>show_models({:landscape,'0x400000'})</tt>
+	#* <tt>:mtype</tt> - Returns all models of the specified type. 
+	#  * Type can either be an MType object, or a model type handle.
+	#  * Examples: 
+	#    * <tt>show_models(:mtype, '0x13d0018')</tt>
+	#    * <tt>show_models(:mtype, MType.new('0x13d0018'))</tt>
+	#
+	#Returns a StringIO with the command's ouput.
+	#
+	def show_models(filter=nil)
+		showcmd = 'show models '
+		if filter
+			filter.keys.each do |option| 
+				case option
+				when :range
+					showcmd += ' mhr=' 
+					showcmd += filter[option] if filter[option].kind_of?(String)
+					showcmd += get_handle(filter[option][0],Model) + '-' + 
+						get_handle(filter[option][1],Model) if filter[option].kind_of?(Array)
+				when :type
+					showcmd += ' mth=' + get_handle(filter[option],MType)	
+				when :name
+					showcmd += ' mname=' + filter[option]
+				when :landscape
+					showcmd += ' lh=' + get_handle(filter[option],Landscape)
+				else
+					raise ArgumentError, 'Valid filter options are :range, :name, :flag, or :landscape'
+				end
+			end
+		end
+
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /MHandle\s+/
+			return output
+		end
+	end
+
+	#Execute <tt>seek</tt>.
+	#
+	#<tt>specattr</tt> may be an Attr object or an attribute ID.
+	#If <tt>specattr</tt> is an Attr and has the value attribute set,
+	#<tt>value</tt> does not have to be set. However, you can override
+	#the Attr object's value in the search by providing your own
+	#<tt>value</tt>.
+	#
+	#If <tt>specattr.value</tt> is nil, or of <tt>specattr</tt> is simply
+	#an attribute ID, <tt>value</tt> must be set.
+	#
+	#If <tt>substring</tt> is true, a partial string match is performed.
+	#
+	#If <tt>nocase</tt> is true, case is ignored.
+	#
+	#Returns a StringIO with the command's ouput.
+	def seek(specattr,value=nil,substring=false,nocase=false,landscape=nil)
+		seekcmd = 'seek'
+		seekcmd += ' -s' if substring
+		seekcmd += ' -i' if nocase
+		seekcmd += ' attr=' + get_id(specattr,Attr)
+		if specattr.kind_of?(Attr)
+			value = specattr.value unless value
+		end
+		raise ArgumentError, 'When seeking by attribute, must pass in a SpecTools::Attr
+				     with a valid value, or an explict attribute value' unless value
+		seekcmd += ',val="' + value + '"'
+		seekcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = exec_cmd(seekcmd)
+		result = output.readline
+		if result =~ /^MHandle\s+/
+			return output
+		else
+			raise CommandError, result
+		end
+	
+	end
+			
+
+
+	#Execute <tt>show devices</tt>
+	#
+	#If <tt>landscape</tt> is set, only devices for the 
+	#given landscape are gathered.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_devices(landscape = nil)
+		showcmd = 'show devices '
+		showcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /MHandle\s+/
+			return output
+		end
+	end
+
+	#Execute <tt>show types</tt>
+	#
+	#<tt>filter</tt> is a hash of filter types and thier values.
+	#
+	#If no filter is passed, returns all model type listings
+	#for the connected Landscape.
+	#Filter options:
+	#
+	#* <tt>:flag</tt> - filters on the provided flag
+	#  * Example: <tt>show_types({:flag,:unique})</tt>
+	#* <tt>:range</tt> - filters on a range of model types 
+	#  * Range can either be a single string, an Array of handles, or an Array of MTypes.
+	#  * Example: <tt>show_types({:range,'0x400000-0x500000'})</tt>
+	#  * Example: <tt>show_types(:range,['0x400000','0x500000']})</tt>
+	#* <tt>:name</tt> - filters on the model type's name (partials accepted) 
+	#  * Example: <tt>show_types({:name,'VNM'})</tt>
+	#* <tt>:landscape</tt> - filters on the given Landscape.
+	#  * Example: <tt>show_types({:landscape,'0x400000'})</tt>
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_types(filter=nil)
+		showcmd = 'show types '
+		if filter
+			filter.keys.each do |option| 
+				case option
+				when :range
+					showcmd += ' mthr=' 
+					showcmd += filter[option] if filter[option].kind_of?(String)
+					showcmd += get_handle(filter[option][0],MType) + '-' + 
+						get_handle(filter[option][1],MType) if filter[option].kind_of?(Array)
+					
+				when :name
+					showcmd += ' mtname=' + filter[option]
+				when :flag
+					showcmd += ' flags=' + filter[option]
+				when :landscape
+					showcmd += ' lh=' + get_handle(filter[option],Landscape)
+				else
+					raise ArgumentError, 'Valid filter options are :range, :name, :flag, or :landscape'
+				end
+			end
+		end
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /Handle\s+/
+			return output
+		end
+	end
+
+	#Execute <tt>show relations</tt>
+	#
+	#If <tt>landscape</tt> is set to a Landscape or a ladnscape handle,
+	#shows relations for the given <tt>landscape</tt>.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_relations(landscape=nil)
+		showcmd = 'show relations '
+		showcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /Name\s+/
+			return output
+		end
+	end
+
+	#Execute <tt>show associations</tt>.
+	#
+	#<tt>mh</tt> can be either a Model, or a model handle.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_associations(mh)
+		showcmd = 'show associations ' + mh
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^LMHandle\s+/
+			return output
+		end
+	end
+
+	#Execute <tt>show parents</tt>.
+	#
+	#<tt>model</tt> can be a Model or a model handle.
+	#If <tt>relation</tt> is set to a Relation or a relation
+	#name, only parents with the given relation will be 
+	#retrieved.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_parents(model,relation=nil)
+		showcmd = 'show parents '
+		showcmd += ' rel=' + get_relation(relation) if relation
+		showcmd += ' mh=' + get_handle(model,Model)
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^MHandle\s+/
+			return output
+		elsif result =~ /invalid relation/
+			raise CommandError, result
+		end
+	end
+
+				
+	#Execute <tt>show children</tt>
+	#
+	#<tt>model</tt> can be a Model or a model handle.
+	#If <tt>relation</tt> is set to a Relation or a relation
+	#name, only parents with the given relation will be 
+	#retrieved.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_children(model,relation=nil)
+		showcmd = 'show children '
+		showcmd += ' rel=' + get_relation(relation) if relation
+		showcmd += ' mh=' + get_handle(model,Model)
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^MHandle\s+/
+			return output
+		elsif result =~ /invalid relation/
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>show events</tt>
+	#
+	#Available types:
+	#* <tt>:all</tt> - Retrieve all events.
+	#* <tt>:model</tt> - Retrieve all events for a given model.
+	#  * If set, mh_or_lh must be a valid Model or a model handle.
+	#* <tt>:landscape</tt> - Retrieve all events for a given landscape.
+	#  * If set, mh_or_lh must be a valid Landscape or a landscape handle.
+	#Options:
+	#* <tt>limit</tt> - Set the maximum number of events to retrieve.
+	#  * Default is 2000, Setting to :all is equivalent to setting to 10000
+	#* <tt>evformat</tt> - If set to true, populate the Events with the event message.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_events(type=:all,mh_or_lh=nil,limit=2000,evformat=false)
+		showcmd = 'show events '
+		if limit == :all
+			showcmd += ' -a '
+		elsif limit != 2000 && limit
+			showcmd += ' -n ' + limit.to_s
+		end
+		if evformat
+			showcmd += ' -x '
+		end
+		if type == :model
+			showcmd += ' mh=' + get_handle(mh_or_lh,Model)
+		end
+		if type == :landscape
+			showcmd += ' lh=' + get_handle(mh_or_lh,Landscape)
+		end
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^Date\s+/
+			return output
+		end
+	end 
+	
+	#Execute <tt>show inheritance</tt>
+	#
+	#<tt>mtype</tt> can be an MType or a model type handle.
+	#If <tt>landscape</tt> is set, only gethers inheritance for
+	#the given landscape.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_inheritance(mtype,landscape = nil)
+		showcmd = 'show inheritance mth=' + get_handle(mtype,MType)
+		showcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^Handle\s+/
+			return output
+		elsif result =~ /invalid model type handle/
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>show rules</tt>
+	#
+	#<tt>relation</tt> can be wither a Relation or a relation name.
+	#If <tt>lanscape</tt> is set to a Landscape or a landscape handle,
+	#will only show rules for the given landscape.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_rules(relation,landscape = nil)
+		showcmd = 'show rules rel=' + get_relation(relation)
+		showcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^LMTHandle\s+/
+			return output
+		elsif result =~ /invalid relation/
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>show enumerations</tt>
+	#
+	#Available types are:
+	#
+	#* <b>:mtype</b> - enumerations by model type.
+	#  * When set, <tt>mtype_landscape_attr</tt> must be a valid MType or a model type handle.
+	#  * May also specify an optional <tt>landscape</tt>, which can be either a Landscape or a landscape handle.
+	#* <b>:landscape</b> - all enumerations for a specific landscape.
+	#  * When set, <tt>mtype_landscape_attr</tt> must be a valid Landscape or landscape handle.
+	#* <b>:attr</b> - enumerations for a spceific attribute.
+	#  * When set, <tt>mtype_landscape_attr</tt> must be an Attr or an attribute id.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_enumerations(type=:all,mtype_landscape_attr=nil,landscape=nil)
+		showcmd = 'show enumerations '
+		case type
+		when :mtype
+			showcmd += ' mth=' + get_handle(mtype_landscape_attr,MType)
+			showcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		when :landscape
+			showcmd += ' lh=' + get_handle(mtype_landscape_attr,Landscape)
+		when :attr
+			showcmd += ' attr=' + get_id(mtype_landscape_attr,Attr)
+		end
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /Id\s+/
+			return output
+		elsif result =~ /invalid attribute/
+			raise CommandError, result
+		elsif result =~ /invalid model type handle/
+			raise CommandError, result
+		end
+	end
+	
+	#Execute <tt>show watch</tt>
+	#
+	#<tt>model</tt> can either be a Model or a model handle.
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_watch(model)
+		showcmd = 'show watch '
+		showcmd += ' mh=' + get_handle(model,Model)
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^Watch_Id\s+/
+			return output
+		end
+	end
+	
+	#Execute <tt>show landscapes</tt>
+	#
+	#Returns a StringIO with the command's ouput.
+	def show_landscapes
+		showcmd = 'show landscapes'
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		if result =~ /SSName/
+			return output
+		end
+	end
+
+	#Execute <tt>show attributes</tt>
+	#
+	#Available types:
+	#
+	#* <b>:model</b> - Get attributes for a given model. 
+	#  * When set, mh_or_mth must be a Model or a model handle.
+	#  * If <tt>enumerate</tt> is set, values will be automatically enumerated.
+	#* <b>:mtype</b> - get attributes for a given model type.
+	#  * When set, mh_or_mth must be a MType or a model type handle.
+	#  * <tt>enumerate</tt> is ignored.
+	#
+	#Filter options.
+	#
+	#* <tt>:id</tt> - returns the specific attribute. 
+	#  * Only valid for the <tt>:model</tt> type.
+	#  * Takes an Attr or an attribute ID.
+	#  * Returns all instances for a list attribute.
+	#  * Example: <tt>show_attributes(:model,{:id,'0x10000'})</tt>
+	#* <tt>:instance</tt> = returns a specific instance of an attribute. 
+	#  * Only valid for the <tt>:model</tt> type.
+	#  * Takes a 2 element array.
+	#    * The first element must be an Attr or an attribute id.
+	#    * The second element must be an instance identifier.
+	#  * Example: <tt>show_attributes(:model,{:instance,['0x10000','192.168.1.1']})</tt>
+	#* <tt>:range</tt> - returns attributes whose ID in in the specified range. 
+	#  * Valid for both <tt>:model</tt> and <tt>:mtype</tt> types.
+	#  * :range can take a single range string, or an array of Model handles or Models.
+	#  * Example: <tt>show_attributes(:mtype,{:range,['0x10000','0x1000a])</tt>
+	#  * Example: <tt>show_attributes(:model,{:range,'0x10000-0x1000a'})</tt>
+	#* <tt>:name</tt> - returns attributes whose name contains the specified string. 
+	#  * Valid for both <tt>:model</tt> and <tt>:mtype</tt>.
+	#  * Example: <tt>show_attributes(:mtype{:name,'Condition'})</tt>
+	#* <tt>:flag</tt> - returns attributes that have the specified flag set. 
+	#  * Only valid for the <tt>:mtype</tt> type.
+	#  * Example: <tt>show_attributes(:mtype,{:flag,'G'})</tt>
+	#* <tt>:lanscape</tt> - returns attributes in the specified landscape. 
+	#  * Only valid for the <tt>:mtype</tt> type.
+	#  * landscape can be a Landscape object or a landscape handle.
+	#  * Example: <tt>show_attributes(:mtype,{:landscape,'0x400000'})</tt>
+	def show_attributes(type,mh_or_mth,filter=nil,enumerate=false)
+		showcmd = 'show attributes '
+		if type == :model
+			showcmd += ' -e ' if enumerate
+			if filter
+				filter.keys.each do |option|
+					case option
+					when :id
+						showcmd += ' attr=' + get_id(filter[option],Attr)
+					when :instance
+						if filter[option].kind_of?(Attr)
+							instance = filter[option].instance
+							attrid = filter[option].id
+						else
+							instance = filter[option][1]
+							attrid = filter[option][0]
+						end
+						raise ArgumentError, 'instance is not an instance identifier' unless
+							instance =~ /^\d+(\.\d+)*$/ 
+						showcmd += ' attr=' + get_id(attrid,Attr) + ',iid=' + instance
+					when :name
+						showcmd += ' attrname=' + filter[option]
+					when :range
+						showcmd += ' attrr='
+						showcmd += filter[option] if filter[option].kind_of?(String)
+						showcmd += get_id(filter[option][0],Attr) + '-' + 
+						           get_id(filter[option][1],Attr) if filter[option].kind_of?(Array)
+					end
+				end
+			end
+			showcmd += ' mh=' + get_handle(mh_or_mth,Model)
+		elsif type == :mtype
+			showcmd += ' mth=' + get_handle(mh_or_mth,MType)
+			if filter
+				filter.keys.each do |option|
+					case option
+					when :range
+						showcmd += ' attrr='
+						showcmd += filter[option] if filter[option].kind_of?(String)
+						showcmd += get_id(filter[option][0],Attr) + '-' + 
+						           get_id(filter[option][1],Attr) if filter[option].kind_of?(Array)
+					when :name
+						showcmd += ' attrname=' + filter[option]
+					when :flag
+						showcmd += ' flags=' + filter[option]
+					when :landscape
+						showcmd += ' lh=' + get_handle(filter[option],Landscape)
+					end
+				end
+			end
+		else
+			raise ArgumentError, 'Valid types are :model or :mtype'
+		end
+		output = self.exec_cmd(showcmd)
+		result = output.readline
+		show_invalid_mh_or_lh?(result)
+		if result =~ /^Id\s+/
+			return output
+		elsif result =~ /invalid model type handle/
+			raise CommandError, result
+		elsif result =~ /non list attribute/
+			raise CommandError, result
+		elsif result =~ /invalid attribute/
+			raise CommandError,result
+		elsif result =~ /invalid instance/
+			raise CommandError,result
+		end
+	end
+
+	#Execute <tt>destroy model</tt>.
+	#
+	#<tt>model</tt> can either be a Model or a model handle
+	#
+	#Returns true if the destroy succeeded, otherwise CommandError
+	#is raised.
+	def destroy_model(model)
+		destroycmd = 'destroy model -n mh=' + get_handle(model,Model)
+		output = exec_cmd(destroycmd)
+		result = output.readlines.last
+		if result =~ /destroy model: successful/
+			return true
+		else
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>destroy association</tt>.
+	#
+	#Returns true if the destroy succeeded, otherwise CommandError
+	#is raised.
+	def destroy_association(relation,left_model,right_model)
+		destroycmd = 'destroy association -n ' 
+		destroycmd += ' rel=' + get_relation(relation)
+		destroycmd += ' lmh=' + get_handle(left_model,Model)
+		destroycmd += ' rmh=' + get_handle(right_model,Model)
+		output = exec_cmd(destroycmd)
+		result = output.readlines.last
+		if result =~ /destroy association: successful/
+			return true
+		else
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>destroy alarm</tt>
+	#
+	#<tt>alarm</tt> can be an Alarm or an alarm ID.
+	#
+	#If <tt>landscape</tt> is set, will detroy the alarm
+	#on the specified landscape.
+	#<tt>landscape</tt> can be a Landscape object or a valid
+	#landscape handle.
+	#
+	#Returns true if the destroy succeeded, otherwise CommandError
+	#is raised.
+	def destroy_alarm(alarm,landscape=nil)
+		destroycmd = 'destroy alarm -n aid=' + get_id(alarm,Alarm)
+		destroycmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = exec_cmd(destroycmd)
+		result = output.readlines.last
+		if result =~ /destroy alarm: successful/
+			return true
+		else
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>create model</tt> with the IP
+	#option.
+	#
+	#Options:
+	#* <tt>ip</tt> - Required. The device's IP address.
+	#* <tt>comm</tt> - Optional. The community string.
+	#* <tt>timeout</tt> - Optional. The device's timeout.
+	#* <tt>retries</tt> - Optional. The number of times to attempt to contact the device.
+	#* <tt>sdm</tt> - Optional. The address of the Secure Domain Connector.
+	#* <tt>landscape</tt> - Optional. The landscape to create the device on. 
+	#
+	#If creation is sucessful, returns a new Model with the handle filled in.
+	#otherwise, raises a CommandError.
+	def discover_device(ip,comm=nil,timeout=nil,retries=nil,sdm=nil,landscape=nil)
+		createcmd = 'create model ip=' + ip
+		createcmd += ' sec_dom=' + sdm if sdm
+		createcmd += ' comm=' + comm if comm
+		createcmd += ' to=' + timeout if timeout
+		createcmd += ' tc=' + retries if retries
+		createcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = exec_cmd(createcmd)
+		result = output.readlines.last
+		if result =~ /created model handle\s+=\s+(0x[0-f]+)/
+			model = Model.new
+			model.handle = $1
+			return model
+		else
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>create model</tt> without the
+	#IP option.
+	#<tt>mtype</tt> may either be a valid MType object, or a model type handle.
+	#<tt>attrs</tt> is an array of Attr objects that you want to be set on the
+	#model when it is created.
+	#<tt>landscape</tt> is the landscape you wish to create the model on.
+	#<tt>landscape</tt> may be a Landscape object or a landscape handle.
+	def create_model(mtype,attrs=nil,landscape=nil)
+		createcmd = 'create model mth='
+		createcmd += get_handle(mtype,MType)
+		createcmd += expand_attrs(attrs) if attrs
+		createcmd += ' lh=' + get_handle(landscape,Landscape) if landscape
+		output = exec_cmd(createcmd)
+		result = output.readlines.last
+		if result =~ /created model handle\s+=\s+(0x[0-f]+)/
+			model = Model.new
+			model.handle = $1
+			model.attrs = attrs
+			if mtype.instance_of?(MType)
+				model.type = mtype
+			else
+				model.type = MType.new(mtype)
+			end
+			return model
+		else
+			raise CommandError, result
+		end
+
+	end
+
+	#Execute <tt>update model</tt>.
+	#<tt>model</tt> can be a Model object or a model handle.
+	#<tt>attrs</tt> is an array of Attr objects to update.
+	#
+	#Returns true if the update succeeded, or raises a CommandError.
+	def update_model(model,attrs)
+		updatecmd = 'update mh='
+		updatecmd += get_handle(model,Model)
+		updatecmd += expand_attrs(attrs)
+		output = exec_cmd(updatecmd)
+		result = output.readlines.first
+		if result =~ /^Id/
+			return true
+		else
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>update alarm</tt>.
+	#<tt>alarm</tt> can be an Alarm object or an alarm id.
+	#<tt>action</tt> is the field that will be updated.
+	#Valid actions are:
+	#* <tt>:assign</tt>
+	#* <tt>:ticket</tt>
+	#* <tt>:url</tt>
+	#* <tt>:ack</tt>
+	#* <tt>:status</tt>
+	#
+	#<tt>action</tt> may also be a Hash of alarm attributes to set.
+	#If <tt>action</tt> is a single attribute, <tt>value</tt> must be set.
+	#<tt>replace</tt> will replace the existing value, as opposed to just
+	#appending. <tt>replace</tt> is only valid when updating <tt>:ticket</tt>
+	#and <tt>status</tt>.
+	#
+	def update_alarm(alarm,action,val=nil,replace=false)
+		if action.kind_of?(Symbol) && val == nil
+			raise ArgumentError, 'When updating an individual alarm attribute, you must pass a value'
+		elsif action.kind_of?(Hash) && replace == true
+			raise ArgumentError, 'Field replacement may only be done by updating a single alarm attribute'
+		end
+		unless action.kind_of?(Hash) || action.kind_of?(Symbol)
+			raise ArgnumentError, 'Valid actions may be a single Symbol or a Hash'
+		end
+		updatecmd = 'update alarm aid='
+		if alarm.instance_of?(Alarm)
+			updatecmd += alarm.id
+		else
+			updatecmd += alarm
+		end
+		if action.kind_of?(Symbol)
+			updatecmd += ' -r ' if replace
+			updatecmd += process_alarm_action(action,val)
+		end
+		if action.kind_of?(Hash)
+			action.keys.each do |key|
+				updatecmd += process_alarm_action(key,action[key])
+			end
+		end
+		result = exec_cmd(updatecmd)
+		if $?.exitstatus == 0
+			return true
+		else
+			raise CommandError, result
+		end
+	end
+
+
+
+		
+	#Execute <tt>create association</tt>.
+	#
+	#<tt>relation</tt> can be a Relation object or a relation name.
+	#<tt>left_model</tt> and <tt>right_model</tt> can be a
+	#Model object or a model handle.
+	def create_association(relation,left_model,right_model)
+		createcmd = 'create association '
+		createcmd += ' rel='  + get_relation(relation)
+		createcmd += ' lmh='
+		createcmd += get_handle(left_model,Model)
+		createcmd += ' rmh='
+		createcmd += get_handle(right_model,Model)
+
+		output = exec_cmd(createcmd)
+		result = output.readlines.last
+		if result =~ /create association: successful/
+			if relation.kind_of? String
+				rel = Relation.new(rel)
+			end
+			if left_model.kind_of? String
+				left_model = Model.new(left_model)
+			end
+			if right_model.kind_of? String
+				right_model = Model.new(right_model)
+			end
+			return Association.new(left_model,right_model,relation)
+		else
+			raise CommandError, result
+		end
+	end
+
+	#Execute <tt>create alarm</tt>.
+	#* <tt>severity</tt> is the alarm severity. Allowable options are:
+	#  * CRITICAL
+	#  * MAJOR
+	#  * MINOR
+	#  * SUPPRESSED
+	#  * MAINTENANCE
+	#  * INITIAL
+	#* <tt>cause</tt> is the probable cause code.
+	#* <tt>model</tt> is the model to assert the alarm on.
+	#  * <tt>model</tt> can be a Model object or a model handle.
+	#* If <tt>replace</tt> is true, will replace an existing alarm on the model.
+	#
+	#Returns the created Alarm object if sucessful, otherwise raises a CommandError.
+	def create_alarm(severity,cause,model,replace = false)
+		createcmd = 'create alarm '
+		createcmd += '-nr ' if replace
+		if severity =~ /CRITICAL/i ||
+					/MAJOR/i ||
+					/MINOR/i ||
+					/SUPPRESSED/i ||
+					/MAINTENANCE/i ||
+					/INITIAL/i
+			createcmd += "sev=#{severity} "
+		else
+			raise ArgumentError, 'Severity must be CRITICAL, MAJOR, MINOR, SUPPRESSED, MAINTENANCE, or INITIAL'
+		end
+		if cause.instance_of?(Alarm)
+			createcmd += "cause=#{cause.causeid} "
+		elsif cause.kind_of?(String)
+			createcmd += "cause=#{cause} "
+		else
+			raise ArgumentError, 'You must pass a valid Probable Cause code'
+		end
+		createcmd += 'mh='+get_handle(model,Model)
+		output = exec_cmd(createcmd).readlines
+		if output.first =~ /^ID/
+			return Alarm.parse(output.last)
+		else
+			raise CommandError, output.last
+		end
+	end
+
+	#Execute <tt>create event</tt>.
+	#
+	#<tt>model</tt> can be a Model or a model handle.
+	#<tt>evcode</tt> is a valid event code.
+	#<tt>text</tt> is the event text.
+	#
+	#Returns true if the event was created, otherwise returns
+	#a CommandError.
+	#
+	def create_event(model,evcode,text='')
+		createcmd = 'create event type='
+		if evcode.instance_of?(Event)
+			createcmd += evcode.type
+			createcmd += ' text=\"' + evcode.message + '\"'
+		elsif evcode.kind_of?(String) && evcode.hex?
+			createcmd += evcode
+			createcmd += ' text=\"' + text + '\"'
+		else
+			raise ArgumentError, 'You must pass a valid Event Code'
+		end
+		createcmd += ' mh=' + get_handle(model,Model)
+		output = exec_cmd(createcmd)
+		if $?.exitstatus > 0
+			raise CommandError, output.readlines.first
+		else
+			return true
+		end
+	end
+			
+		
+		
+
+
+
+
+			
+
+	private
+
+	def valid_alarm_action?(action)
+		validactions = [ :ticket,
+				 :assign,
+				 :status,
+				 :ack,
+				 :url ]
+		ret = false
+		validactions.each do |validaction|
+			if action == validaction
+				ret=true
+			end
+		end
+		return ret
+	end
+
+	def process_alarm_action(action,value)
+		if valid_alarm_action?(action)
+			return ' ' + action.to_s + '="' + value.to_s + '"'
+		else
+			raise ArgumentError, 'The requested field to update, ' + action.to_s + ', is not valid'
+		end
+	end
+
+
+	def get_handle(obj,match_class)
+		if obj.instance_of?(match_class)
+			raise ArgumentError, match_class.to_s + ' must have a valid handle.' unless obj.handle && obj.handle.hex?
+			return obj.handle
+		elsif obj.kind_of?(String) && obj.hex?
+			return obj
+		else
+			raise ArgumentError, 'Argument must be a ' + match_class.to_s + ' object or a valid handle.'
+		end
+	end
+
+	def get_id(obj,match_class)
+		if obj.instance_of?(match_class)
+			formaterror = match_class.to_s + ' must have a valid id.'
+			if obj.instance_of?(Alarm)
+				raise ArgumentError, formaterror unless obj.id == obj.id.to_i.to_s
+			else
+				raise ArgumentError, formaterror unless obj.id && obj.id.hex?
+			end
+			return obj.id
+		elsif (obj.kind_of?(String) && obj.hex? && match_class != Alarm) ||
+		      (match_class == Alarm && obj.to_s == obj.to_i.to_s)
+			return obj
+		else
+			raise ArgumentError, 'Argument must be a ' + match_class.to_s + ' object or a valid id.'
+		end
+	end
+
+	def get_relation(rel)
+		if rel.instance_of?(Relation)
+			raise ArgumentError, 'Relation must have a valid name.' unless rel.name
+			return rel.name
+		else
+			return rel
+		end
+	end
+
+	def expand_attr(specattr,instance=nil)
+		unless specattr.instance_of?(Attr)
+			raise ArgumentError, 'Argument must be a SpecTools::Attr'
+		end
+		str = ' attr=' + specattr.id
+	        if specattr.list
+			if specattr.value_table && spceattr.value_table[instance]
+				str += ',iid=' + instance
+				val = value_table[instance]
+			else
+				raise IsAListAttrError, 'Attempt to update a list attribute without an instance'
+			end
+		else
+			val = specattr.value
+		end
+		str += ',val="' + val + '"'
+			
+	end
+
+	def expand_attrs(attrs)
+		cmd=''
+		if attrs.kind_of?(Array)
+			attrs.each do |specattr|
+				cmd += expand_attr(specattr)
+			end
+		else
+			cmd += expand_attr(attrs)
+		end
+		return cmd
+	end
+
+	def append_lh(cmd,landscape)
+		if landscape.instance_of?(Landscape)
+			cmd += ' lh=' + landscape.handle
+		elsif landscape.kind_of?(String) && landscape.hex?
+			cmd += ' lh=' + landscape
+		end
+	end
+
+		
+
+
+
+			
+	public
+
+	# == SpecTools::EnvironmentError
+	# This error means that the module was unable to detect a proper environment for VNMSH.
+	# Possible causes might be that the Specroot passwed was invalid, or the user does not
+	# have execute permissions to the VNMSH commands.
+	class EnvironmentError < StandardError
+	end
+
+	# == SpecTools::ConnectError
+	# This error means that the module was unable to connect to a SpectroSERVER.
+	class ConnectError < StandardError
+	end
+
+	# == SpecTools::NotConnectedError
+	# This error means that you attempted to use a session that was not yet connected.
+	class NotConnectedError < StandardError
+	end
+
+	# == SpecTools::CommandError
+	# This error means that the attempted command failed to execute
+	class CommandError < StandardError
+	end
+				
+end
+	
+
+
+