aio_elin 0.0.1

data/lib/aio/core/device/parent_device.rb

@@ -0,0 +1,275 @@
+#coding=utf-8
+
+module Aio::Device
+	class ParentDevice
+
+		include Aio::Ui::Verbose
+		
+		attr_accessor :device_name
+
+		# cmds_context = { "cmd_full_name" => [ {
+		#					device_type_1 => klass1, 
+		#					device_type_2 => klass2},
+		#			  context ] }
+		attr_accessor :cmds_context
+
+		# 管理IP
+		attr_accessor :manager_ip
+
+		# 设备的基本信息
+		attr_accessor :device_info
+
+		# 按cmd名称管理有用信息
+		# Hash = { cmd_name => { :case => useful } }
+		attr_accessor :cmds_useful
+
+		# Warning信息模块
+		attr_accessor 	:warning_klass
+
+		# 设备类型
+		#attr_reader :device_type
+
+		InvalidInput = /Invalid input detected/
+
+		Interface = {
+			:geth => "GigabitEthernet",
+			:feth	=> "FastEthernet",
+			:eth	=> "Ethernet",
+			:loopback => "Loopback",
+		}
+
+		def interface
+			Interface
+		end
+
+		def initialize
+		  self.cmds_context = {}
+			self.device_name = ""
+			self.cmds_useful = {}
+
+			@warning_klass = Aio::Text::Warning.new
+			@device_type = ""
+			@device_info = {}
+		end
+
+		def instance
+			self
+		end
+
+		def inspect
+			"#<#{self.class}>"
+		end
+
+		def device_type
+			if @device_type.empty?
+				return "other"
+			end
+
+			@device_type
+		end
+
+		# 判断是否有cmd的信息
+		def has_cmd?(cmd)
+			@cmds_useful.has_key?(cmd)
+		end
+
+		# 增加cmd
+		# @Param klass_info 为Array
+		# 			 klass_info = ["maybe_device_type", cmd_klass]
+		def add_cmd(klass_info)
+			maybe_device_type = klass_info[0]
+			cmd_klass = klass_info[1]
+
+			cmd_full_name = cmd_klass.cmd_full
+			
+			# 有可能已经有了其他设备类型的模块
+			# 那么通过Hash的方式存储所有的模块
+			cmds_context[cmd_full_name] ||= []
+			cmds_context[cmd_full_name][0] ||= {}
+			cmds_context[cmd_full_name][0][maybe_device_type] = cmd_klass
+			return cmd_full_name
+		end
+
+		# 两种用法：
+		# 在有klass的时候可以添加为完整cmds_context
+		# 当没有klass的话，也可以加。那么klass项为nil
+		def add_cmd_context_by_cmd_name(cmd_full_name, context)
+			cmds_context[cmd_full_name] ||= []
+			cmds_context[cmd_full_name][1] = context
+		end
+
+		# 整合上面两个方法，成为一步
+		def add_cmd_context_by_klass(klass_info, context)
+			cmd_full_name = add_cmd(klass_info)
+			add_cmd_context_by_cmd_name(cmd_full_name, context)
+			return cmds_context[cmd_full_name]
+		end
+
+		# 最终解析的地方
+		# 一定要确定设备类型，否则的话只能单一设备
+		# cmds_context = { cmd_name => [ {
+		#					device_type_1 => klass1, 
+		#					device_type_2 => klass2},
+		#			  context ] }
+		def parse
+
+			# 做两次循环，第一次确定设备类型
+			2.times do |t|
+				cmds_context.each_pair do |cmd_name, info|
+					context = info[1]
+
+					# 如果没有cmd模块， 那么就跳过
+					next if info[0].nil?
+
+					info[0].each_pair do |device_type, module_klass|
+
+						#module_klass.clear_useful
+
+						# 如果找到了设备类型
+						# 那么之后就只对该类型进行解析,其他的跳过
+						if ! @device_type.empty? and @device_type != device_type
+							next
+						end
+							
+						module_klass.context = context
+						module_klass.warning_klass = @warning_klass
+
+							# 循环模块对内容进行解析
+							# 当是第一遍遍历的时候，只找可以决定是什么设备类型的命令
+							# 一般都是通过show version 这类命令找到， 那么同时也能找到设备型号和软件版本
+							if t == 0 and not module_klass.key_stand
+								next
+
+							elsif t == 0 and module_klass.key_stand
+								module_klass.parse
+								push_device_info(module_klass)
+
+								module_klass.clear_useful
+								# 当device_type 有内容时，确定为已知设备类型，那么进行下次循环遍历
+								if @device_type.empty?
+									next
+								else
+									@warning_klass.clear
+									break
+								end
+							end
+									
+						begin
+						# 当是第二遍的时候，则全部解析
+							module_klass.clear_useful
+							module_klass.device_info = device_info
+							module_klass.ext_info = {:device_name => @device_name}
+							module_klass.parse
+						rescue Aio::Text::Context::OutLineError
+						rescue NoMethodError
+							print_error "未找到方法，请检查模块的方法名拼写"
+						rescue Exception => e
+							print_error "#{e.class} : #{module_klass.class}"
+							print_error e.message
+						ensure
+							push_useful(module_klass, cmd_name)
+							next
+						end
+					end
+				end
+			end
+
+			# 当所有解析循环完成后，如果找到了设备类型
+			# 就将此类转为对应子类
+			# changeto
+			if ! @device_type.empty?
+				to = self.send("changeto_#{@device_type}")
+			end
+
+			return to ? to : self
+		end
+
+		# 存放设备基本信息
+		def push_device_info(module_klass)
+			@device_type = module_klass.useful[:device_type].to_s
+			@device_info[:device_model] = module_klass.useful[:device_model].to_s
+			@device_info[:device_version] = module_klass.useful[:device_version].to_s
+			@device_info[:device_template] = module_klass.useful[:device_template].to_s
+		end
+
+		# 当一个模块解析完毕后，将有用信息放入cmds_useful
+		# 当有用信息中device_type类为真时，
+		# 就可以将此父类转变为具体的类型了
+		# check
+		def push_useful(module_klass, cmd_name)
+
+			if Aio::Base::Debug.enable?
+				puts "parent_device#push_useful"
+				pp module_klass
+			end
+
+			# 将有用信息放入整体有用信息
+			cmds_useful[cmd_name] = module_klass.useful 
+		end
+
+=begin
+		def warning_info
+			warning_klass.warning_info
+		end
+
+		def warning_info_serious
+			warning_klass.warning_info_serious
+		end
+
+		def warning_info_ordinary
+			warning_klass.warning_info_ordinary
+		end
+
+		def warning_info_compare
+			warning_klass.warning_info_compare
+		end
+=end
+
+		# 1.导向命令方法模块
+		# 2.导向Warning类
+		def method_missing(m, *args, &block)
+			if Aio::Device::Methods.respond_to?(m)
+				Aio::Device::Methods.klass = self
+				Aio::Device::Methods.send(m)
+
+			elsif Aio::Text::Warning.instance_methods(false).include?(m.to_sym)
+				warning_klass.send(m, *args)
+			else
+				super
+			end
+		end
+		
+private
+		
+		def changeto_cisco
+			to = Cisco.new
+			clone(to)
+		end
+
+		def changeto_huawei
+			to = Huawei.new
+			clone(to)
+		end
+
+		def changeto_maipu
+			to = Maipu.new
+			clone(to)
+		end
+
+		def changeto_h3c
+			to = H3C.new
+			clone(to)
+		end
+
+		def clone(to)
+			to.device_name 		= Aio::Base::Toolkit::DeepClone.clone(self.device_name)
+			to.cmds_context 	= Aio::Base::Toolkit::DeepClone.clone(self.cmds_context)
+			to.manager_ip			=	Aio::Base::Toolkit::DeepClone.clone(self.manager_ip)
+			to.device_info 		= Aio::Base::Toolkit::DeepClone.clone(self.device_info)
+			to.cmds_useful		= Aio::Base::Toolkit::DeepClone.clone(self.cmds_useful)
+			to.warning_klass	= Aio::Base::Toolkit::DeepClone.clone(self.warning_klass)
+			to
+		end
+	end
+end
+						

data/lib/aio/core/device.rb

@@ -0,0 +1,15 @@
+module Aio
+module Device
+
+	require "aio/core/device/parent_device"
+	require "aio/core/device/cisco"
+	require "aio/core/device/huawei"
+	require "aio/core/device/maipu"
+	require "aio/core/device/h3c"
+	require "aio/core/device/juniper"
+	require "aio/core/device/cmd_switch"
+	require "aio/core/device/methods"
+
+end
+end
+

data/lib/aio/core/device_manager.rb

@@ -0,0 +1,207 @@
+class Aio::DeviceManager
+
+	# 保存所有设备类
+	# devices = {"device_name" => device_klass}
+	attr_accessor :devices
+
+	# 按设备型号保存cmd
+	# cmds = {"device_type" => [module_klass1, module_klass2]}
+	attr_accessor :cmds
+	
+	# 命令的正则表达式匹配
+	# cmds_reg = {module_klass => ["device_type", "cmd_reg"]}
+	attr_accessor :cmds_reg
+
+	# 警告信息汇总类
+	attr_reader	:warning_summarize
+
+	# 模块管理信息,只读
+	attr_accessor :module_manager
+
+	# 当初始化完成，所有cmd模块已经整理完毕
+	def initialize(module_manager)
+		self.cmds = {}
+		self.cmds_reg = {}
+		self.devices = {}
+		@module_manager = module_manager
+		@warning_summarize = Aio::Warning::WarningSummarize.new(self)
+		tidy_cmds
+	end
+
+	def []=(key, val)
+		@devices[key] = val
+	end
+
+	def [](key)
+		@devices[key]
+	end
+
+	# 设备台数
+	def devices_number
+		self.devices.keys.size
+	end
+
+	# 整理cmds 和 cmds_reg
+	# 返回为Hash = {"cisco" => [klass, klass]}
+	def tidy_cmds
+		device_type = @module_manager.get_modules_device_type_to_s
+		
+		device_type.each do |type|
+			# 整理cmds
+			type_modules = @module_manager.get_modules_by_device_type(type)
+			self.cmds[type] = type_modules
+
+			# 整理cmds_reg
+			type_modules.each do |cmd_klass|
+
+				# 将cmd_short转变为正则表达式
+				# 相同的cmd_short会导致重复
+				cmd_short_reg = Aio::Base::Toolkit::Regexp.to_reg(cmd_klass.cmd_short)
+				cmds_reg[cmd_klass] = [type, cmd_short_reg]
+			end
+		end
+		return cmds
+	end
+
+	# 仅仅返回各个命令的正则表达式的数组,在input/console中使用
+	def just_cmds_reg
+		res = []
+		cmds_reg.each_pair do |klass, info|
+			res << info[1]
+		end
+		return res
+	end
+
+	def each_devices
+		devices.each_pair do |device_name, device_klass|
+			yield device_name, device_klass
+		end
+	end
+
+	def each_devices_with_index
+		i = 0
+		devices.each_pair do |device_name, device_klass|
+			yield device_name, device_klass, i
+			i += 1
+		end
+	end
+
+	# 轮询设备名以及有用信息
+	def each_devices_with_useful
+		each_devices do |device_name, device_klass|
+			useful = device_klass.cmds_useful
+			yield device_name, useful
+		end
+	end
+
+	# 判断设备名是否存在
+	def device_exist?(opts={})
+		each_devices do |devices, _|
+			if devices == opts[:device_name]
+				return true
+			end
+		end
+		return false
+	end
+
+	# 设备类型分类
+	# 返回 { "cisco" => [device_name1, ...] }
+	def device_type_classify
+		res = {}
+		each_devices do |device_name, device_klass|
+			type = device_klass.device_type
+			unless res.has_key?(type)
+				res[type] = []
+			end
+			res[type] << device_name
+		end
+
+		return res
+	end
+	# 查找是否有符合指定的cmd模块
+  # 有可能两种设备类型同时存在同样的命令，在不确定设备类型的情况下，全部输出
+	# 注意此处输出的样式为 res = [ [device_type, cmd_klass], ... ]
+	# info = { cmd_klass => [type, cmd_reg] }
+	def cmd_module_assign(opts)
+		cmd = opts[:cmd]
+		res = []
+
+		device_type = opts[:device_type]
+		cmds_reg.each do |cmd_klass, info|
+			reg = info[1]
+			type = info[0]
+			if reg.match(cmd)
+
+				# 判断如果没有指定device_type,那么全部输出
+				# 如果指定，则只输出指定类型
+				if device_type == type
+					res << [type, cmd_klass]
+				elsif device_type.nil?
+					res << [type, cmd_klass]
+				end
+
+			end
+		end
+		
+		return res.empty? ? nil : res
+	end
+		
+		
+	# 在状态机中使用了，添加设备，并添加cmd-context
+	def add_device(opts)
+
+		# 判断是否已经有了device，如果有，则沿用，如果没有则新建
+		if has_device?(opts)
+			device_klass = self.devices[opts[:device_name]]
+		else
+			device_klass = Aio::Device::ParentDevice.new
+			device_klass.device_name = opts[:device_name]
+		end
+
+		# cmd 和 context 必须同时存在的情况下才能加载的
+		if opts[:cmd] and opts[:context]
+			
+			cmd_arr = cmd_module_assign(opts)
+			if cmd_arr.nil?
+				device_klass.add_cmd_context_by_cmd_name(
+									opts[:cmd],
+									opts[:context]
+				)
+			elsif cmd_arr.size == 1
+				device_klass.add_cmd_context_by_klass(
+									cmd_arr[0],
+									opts[:context]
+				)
+			else
+				# 有多个cmd模块的情况，全部依次加进去，但是最后分析的时候，出现明显问题的将被删除
+				cmd_arr.each do |cmd_klass|
+					device_klass.add_cmd_context_by_klass(
+									cmd_klass,
+									opts[:context]
+					)
+				end
+			end
+
+		end
+
+		self.devices[opts[:device_name]] = device_klass
+	end
+
+	# 将compare中得到的warning信息合并到各个设备的warning_klass中
+	def merge_warning(info)
+		info.each do |name, warn|
+			self[name].warning_klass.warning_compare(warn)
+		end
+	end
+
+	# 整理汇总警告信息
+	def warning_summarize_tidy
+		@warning_summarize.tidy_warning
+	end
+
+	# 是否已经有device_name
+	def has_device?(opts)
+		self.devices.has_key?(opts[:device_name])
+	end
+
+end

data/lib/aio/core/module/cmd.rb

@@ -0,0 +1,160 @@
+#coding=utf-8
+
+module Aio::Module
+	class Cmd
+		
+		include Aio::Ui::Verbose
+
+		class MethodError < StandardError
+			def to_s; "请重载此方法"; end
+		end
+
+		class MismatchError < StandardError; end
+
+		autoload :Ranking, 'aio/module/ranking'
+		autoload :Platform, 'aio/module/platform'
+
+		# 加载的欲解析的文本
+		attr_accessor :context
+
+		# 模块的信息
+		attr_accessor :cmd_info
+
+		# 解析后得到的有用信息
+		# 以Hash = { :case => info }
+		attr_accessor :useful
+
+		# 加载warning信息
+		attr_accessor :warning_klass
+
+		# 加载设备的基本信息
+		# :device_version
+		# :device_model
+		attr_accessor :device_info
+
+		# 获取一些额外的信息，有device提供
+		attr_accessor :ext_info
+
+		def initialize(info = {})
+			@cmd_info = info.dup
+			@useful = {}
+			set_defaults()
+		end
+
+		def set_defaults
+			self.cmd_info = {
+				:cmd_full		=> 'No full name',
+				:cmd_short 	=> 'No short name',
+				:author			=> nil,
+				:description => 'No command description',
+				:ranking		=> Ranking_1,
+				# 用于确定设备类型
+				:key_stand	=> false,
+				:benchmark  => {},
+				# 平台，是 route, switch 还是 failware
+				:platform		=> nil,
+				:license		=> Aio::AIO_LICENSE,
+			}.update(@cmd_info)
+		end
+
+		def type
+			Aio::Module::Cmd
+		end
+
+		def clear_useful
+			@useful = {}
+		end
+
+		# 所有Cmd模块都必须重载此方法，用于解析命令
+		def parse
+			raise MethodError.new
+		end
+
+		def cmd_full;	 self.cmd_info[:cmd_full]; 	end
+		def cmd_short; self.cmd_info[:cmd_short]; end
+		def author;		 self.cmd_info[:author];		end
+		def description;	self.cmd_info[:description];	end
+		def ranking;	 self.cmd_info[:ranking];		end
+		def benchmark; self.cmd_info[:benchmark]; end
+		def platform;	 self.cmd_info[:platform];	end
+		def license;	 self.cmd_info[:license];		end
+		def key_stand; self.cmd_info[:key_stand];		end
+
+ protected
+
+ 		# 直接调用平级CMD模块
+ 		def call_cmd(cmd_constant)
+			begin
+				cmd_klass = cmd_constant.new
+				cmd_klass.useful = @useful
+				cmd_klass.context = @context
+				cmd_klass.warning_klass = @warning_klass
+			rescue Exception => e
+				print_error "<call_cmd> 方法调用失败: #{cmd_constant}"
+			end
+			cmd_klass.parse
+		end
+
+		def key_stand_cisco
+			useful[:device_type] = "cisco"
+		end
+
+		def key_stand_huawei
+			useful[:device_type] = "huawei"
+		end
+
+		def key_stand_h3c
+			useful[:device_type] = "h3c"
+		end
+
+		def key_stand_maipu
+			useful[:device_type] = "maipu"
+		end
+
+		def key_stand_juniper
+			useful[:device_type] = "juniper"
+		end
+
+		# 确定软件版本
+		def key_stand_version(ver)
+			useful[:device_version] = ver
+		end
+
+		def device_version
+			device_info[:device_version]
+		end
+
+		# 确定设备型号
+		def key_stand_model(model)
+			useful[:device_model] = model
+		end
+
+		def device_model
+			device_info[:device_model]
+		end
+
+		def key_stand_template(template)
+			begin
+				template.instance
+			rescue
+				raise RuntimeError, "请使用Template类" 
+			end
+			useful[:device_template] = template.to_s
+		end
+
+		def device_template
+			Object::const_get(device_info[:device_template]).instance
+		end
+
+		def reg_blank
+			Aio::Base::Toolkit::Regexp.blank
+		end
+
+	end
+end
+
+class Aio::Module::Cmd::Cisco < Aio::Module::Cmd; end
+class Aio::Module::Cmd::Huawei < Aio::Module::Cmd; end
+class Aio::Module::Cmd::H3C < Aio::Module::Cmd; end
+class Aio::Module::Cmd::Maipu < Aio::Module::Cmd; end
+class Aio::Module::Cmd::Juniper < Aio::Module::Cmd; end

data/lib/aio/core/module/description.rb

@@ -0,0 +1,67 @@
+#coding=utf-8
+
+module Aio::Module
+	class Description
+
+		attr_accessor :description_info
+
+		def initialize(info={})
+			@description_info = info.dup
+			set_defaults()
+		end
+
+		def set_defaults
+			self.description_info = {
+				:author			=> nil,
+				:case 			=> nil,
+				:name				=> nil,
+				:title			=> nil,
+				:description	=> nil,
+				:license			=> ::Aio::AIO_LICENSE,
+			}.update(@description_info)
+		end
+
+		def type
+			Aio::Module::Description
+		end
+
+		# 重载方法
+		def to_s
+			"暂无描述信息。"
+		end
+
+		# 判断是否是 Description 父类
+		def parent?
+			self.class == type ? true : false
+		end
+
+		# 创建临时信息,用于在没有描述类的时候使用
+		def temp(cs)
+			clear
+			@description_info[:case] = cs
+			@description_info[:name] = cs.to_s.upcase
+			@description_info[:title] = cs.to_s.upcase + "检查"
+			self
+		end
+
+		# 清楚基本信息
+		def clear
+			self.description_info = {
+				:author			=> nil,
+				:case 			=> nil,
+				:name				=> nil,
+				:title			=> nil,
+				:description	=> nil,
+				:license			=> ::Aio::AIO_LICENSE,
+			}
+		end
+
+		def author;			description_info[:author];	end
+		def case;				description_info[:case];		end
+		def name;				description_info[:name];		end
+		def title;			description_info[:title];		end
+		def description;	description_info[:description];		end
+		def license;		description_info[:license];	end
+
+	end
+end