aio_elin 0.0.1

data/lib/aio/core/module_manager.rb.bak

@@ -0,0 +1,78 @@
+# 管理，保存各个加载的模块
+class Aio::ModuleManager
+	
+#	def [](key)
+#	end
+
+	attr_accessor :modules, :modules_count
+
+	# NOTE modules[reference_name] = {
+	# 							:device_type
+	#	  						:full_path
+  #							  :klass
+	def initialize
+#		self.module_info_by_path = {}
+#		self.module_load_error_by_path = {}
+#		self.module_paths = []
+		self.modules = {}
+		self.modules_count = {}
+	end
+
+	# 加载一个目录下的所有模块
+	# @param [String] path 目录的路径
+	# @param [Hash] options
+	def load_modules(path, options={})
+	end
+
+	# 将实例化后的模块类放到 modules 中
+	def add_module(path, device_type, reference_name, module_klass)
+
+		modules[reference_name] = {:device_type => device_type,
+															 :full_path => path, 
+															 :klass	=> module_klass
+															}
+	end
+
+	# 通过设备类型获得模块类
+	# 返回类型为： 数组
+	def get_module_by_device_type(device_type)
+		return_array = []
+
+		device_type = device_type.to_s
+		modules.each do |m|
+			type = m[:device_type]
+			if device_type == type
+				return_array << m[:klass]
+			end
+			next
+		end
+
+		return return_array
+	end
+				
+	# 获得所有加载模块的设备类型的字符串型
+	# 返回类型为： 数组
+	def get_modules_device_type_to_str
+		return_array = []
+		
+		modules_counts.keys do |key|
+			return_array << key.to_s
+		end
+
+		return return_array
+	end
+			
+			
+	# 判断此设备类型的模块是否加载
+	def device_type_enable?(device_type)
+		true
+	end
+
+	def notify(opts={})
+		if opts[:count_by_device_type]
+			@modules_count = opts[:count_by_device_type]
+		end
+	end
+			
+
+end

data/lib/aio/core/parse/file.rb

@@ -0,0 +1,19 @@
+module Aio::Parse
+
+	class File
+
+	attr_accessor :file_open
+
+	def initialize(file_path)
+		self.file_open = File.open(file_path, "r+")
+	end
+
+	def each_line
+		file_open.each_line do |line|
+		# 改进点，加入sefe_string方法
+			yield line
+		end
+	end
+
+	
+end

data/lib/aio/core/parse/parser.rb

@@ -0,0 +1,91 @@
+#coding=utf-8
+
+module Aio::Parse
+	class Parser
+		attr_accessor :device_manager
+		attr_accessor :parser_machine
+
+		# 重要！在分析前需要确定input_klass
+		# input_klass 的类为input模块的类
+		# Aio::Module::InputStyle
+		attr_accessor :input_klass
+
+		include Aio::Ui::Verbose
+		
+		def initialize(device_manager, parser_machine)
+			self.device_manager = device_manager
+			self.parser_machine = parser_machine
+
+			@invalid_input = Aio::Base::Toolkit::Regexp.merge([
+				Aio::Device::Cisco::InvalidInput,
+				Aio::Device::H3C::InvalidInput,
+				Aio::Device::Huawei::InvalidInput,
+				Aio::Device::Maipu::InvalidInput,
+				Aio::Device::Juniper::InvalidInput,
+			])
+		end
+
+		# 通过巡检文件的方式获得关键信息，并按cmd模块逐个解析
+		def parse_by_module
+
+			# 注意这里manager_ip可有可无, 没有的话默认为nil
+			print_good "正在加载信息..."
+			@input_klass.parse do |device_name, cmd, context, manager_ip|
+				device_info = {
+									:device_name => device_name,
+									:cmd   			 => cmd.strip,
+									:context		 => Aio::Text::Context.new(context),
+									:manager_ip  => manager_ip
+				}
+
+				# 判断 context 是否有效
+				next if invalid?(context)
+
+				# 所有判断交到状态机处理
+				self.parser_machine.get_device(device_info)
+				self.parser_machine.get_full(device_info)
+			end
+			print_good "信息加载完成"
+
+			total = device_manager.devices_number
+			print_good "总共 #{total} 台设备"
+			print_good "正在对各个设备进行分析..."
+			device_manager.each_devices_with_index do |name, klass, i|
+				# 将解析命令后，并修改了自身类的实例覆盖掉原来父类
+				progress_bar(total, i+1, name)
+
+				# Debug处
+				if name == "B_HBWHA_CAM_DS01"
+					#puts "now"
+				end
+				new_klass = klass.parse
+				device_manager[name] = new_klass.instance
+			end
+			clear_line
+			print_good "设备信息分析完成"
+		end
+
+		# 判断 context 是否有效
+		def invalid?(context)
+			return true if context.empty?
+			return true if @invalid_input.match(context[1])
+			return false
+		end
+
+		# 通过output/compare_xml生成的XML文件解析，直接将结果保存
+		# compare_klass 为比较模块
+		# 其中只比较useful的值，并不会去比较warning
+		# warning 有原本device中以及比较中共同得出
+		def parse_by_compare(compare_klass)
+
+			# device_hash 为提供比较文件的hash
+			print_good "正在将比较文件转换为内部Hash表"
+			device_hash = @input_klass.parse
+			compare_klass.device_manager = device_manager
+			compare_klass.input_benchmark = device_hash
+			compare_hash = compare_klass.parse
+			device_manager.merge_warning(compare_hash)
+		end
+				
+	end
+end

data/lib/aio/core/parse/parser_machine/bak/has_cmd_state.rb

@@ -0,0 +1,14 @@
+module Aio::Parse::ParserMachine
+	class HasCmdState < ParentState
+		
+		def get_cmd
+		end
+
+		def get_context
+		end
+
+		def no_context
+		end
+
+	end
+end

data/lib/aio/core/parse/parser_machine/bak/has_context_state.rb

@@ -0,0 +1,11 @@
+module Aio::Parse::ParserMachine
+	class HasContextState < ParentState
+		
+		def get_context
+		end
+
+		def parse_context_ok
+		end
+	
+	end
+end

data/lib/aio/core/parse/parser_machine/bak/no_cmd_state.rb

@@ -0,0 +1,11 @@
+module Aio::Parse::ParserMachine
+	class NoCmdState < ParentState
+		
+		def no_cmd
+		end
+
+		def get_cmd
+		end
+
+	end
+end

data/lib/aio/core/parse/parser_machine/bak/no_context_state.rb

@@ -0,0 +1,11 @@
+module Aio::Parse::ParserMachine
+	class NoContextState < ParentState
+		
+		def no_context
+		end
+
+		def get_context
+		end
+
+	end
+end

data/lib/aio/core/parse/parser_machine/full_state.rb

@@ -0,0 +1,12 @@
+module Aio::Parse
+	class FullState < ParentState
+		
+		def get_device(opts)
+			@machine.to_has_device_state
+			@machine.state.get_device(opts)
+		end
+	
+	end
+end
+
+		

data/lib/aio/core/parse/parser_machine/has_device_state.rb

@@ -0,0 +1,44 @@
+module Aio::Parse
+	class HasDeviceState < ParentState
+
+		def get_device(opts)
+			self.device_manager.add_device(opts)
+		end
+
+		def get_full(opts)
+
+			if ! check_full(opts)
+				no_full
+			elsif
+				@machine.to_full_state
+			end
+			
+		end
+
+		def no_full
+		end
+
+		# 验证是否有cmd和context了
+		def check_full(opts={})
+			device_name = opts[:device_name]
+			device_klass = self.device_manager.devices[device_name]
+
+			org_cmd = opts[:cmd]
+			org_context = opts[:context]
+			org_cmd_reg = Aio::Base::Toolkit::Regexp.to_reg(org_cmd)
+			device_klass.cmds_context.each_pair do |cmd, context|
+
+				# 只有当有cmd, 并且context不为空的时候才算有
+				# :NOTE 可以在这里的context类加入.check_avlid? 查看是否有效
+				if org_cmd_reg.match(cmd)
+					if ! context.empty?
+						return true
+					end
+				end
+
+			end
+			return false
+		end
+
+	end
+end

data/lib/aio/core/parse/parser_machine/no_device_state.rb

@@ -0,0 +1,12 @@
+module Aio::Parse
+	class NoDeviceState < ParentState
+
+		def get_device(opts={})
+			# 首先判断是否已经存在，但是这是初始状态，所以一定没有
+			self.device_manager.add_device(opts)
+
+			@machine.to_has_device_state
+		end
+
+	end
+end

data/lib/aio/core/parse/parser_machine/parent_state.rb

@@ -0,0 +1,26 @@
+#coding=utf-8
+
+module Aio::Parse
+	class ErrorMachineMethod < StandardError
+		def to_s; "请重载此状态机方法"; end
+	end
+
+	class ParentState
+		def initialize(machine)
+			@machine = machine
+		end
+
+    def get_device
+      raise ErrorMachineMethod.new
+    end
+
+		def get_full
+			raise ErrorMachineMethod.new
+		end
+		
+		def device_manager
+			@machine.device_manager
+		end
+	end
+end
+

data/lib/aio/core/parse/parser_machine.rb

@@ -0,0 +1,47 @@
+module Aio::Parse
+	
+	require "aio/core/parse/parser_machine/parent_state"
+	require "aio/core/parse/parser_machine/no_device_state"
+	require "aio/core/parse/parser_machine/has_device_state"
+	require "aio/core/parse/parser_machine/full_state"
+
+	class ParserMachine
+		# 保存状态机的状态
+		attr_reader :state
+
+		# device_manager
+		attr_reader :device_manager
+
+		def initialize(device_manager)
+			@device_manager = device_manager
+			
+			@no_device_state 	= Aio::Parse::NoDeviceState.new(self)
+			@has_device_state	= Aio::Parse::HasDeviceState.new(self)
+			@full_state				= Aio::Parse::FullState.new(self)
+
+			@state = @no_device_state
+		end
+
+		def get_device(opts)
+			@state.get_device(opts)
+		end
+
+		def get_full(opts)
+			@state.get_full(opts)
+		end
+
+		# 状态的切换
+		def to_no_device_state
+			@state = @no_device_state
+		end
+
+		def to_has_device_state
+			@state = @has_device_state
+		end
+
+		def to_full_state
+			@state = @full_state
+		end
+	end
+end
+

data/lib/aio/core/parse.rb

@@ -0,0 +1,6 @@
+module Aio::Parse
+
+	require "aio/core/parse/parser_machine"
+	require "aio/core/parse/parser"
+
+end

data/lib/aio/core/text/context.rb

@@ -0,0 +1,211 @@
+#coding=utf-8
+
+module Aio::Text
+	class Context < ::Array
+
+		class OutLineError < StandardError; end
+
+		include Aio::Ui::Verbose
+
+		attr_reader :count_line, :backup_line
+
+		def initialize(*arr)
+			super
+			self.each_with_index do |str, i|
+				self[i] = Aio::Text::LineString.new(str.chomp)
+			end
+			@backup_line = nil
+			@count_line = 0
+		end
+
+		# 到下一行
+		def next
+			@count_line += 1
+		end
+
+		# 对每行进行read, 判断是单步运行还是循环运行
+		# 修改了此处的backup_line 逻辑
+		def readline_match_block(reg, single = false, &block)
+
+			reg = Aio::Base::Toolkit::Regexp.safe(reg)
+
+			first = true
+			loop do 
+				line_str = self[@count_line]
+
+				if first
+					@backup_line = @count_line
+				end
+
+				# 如果出界，有可能是因为循环导致
+				# 跳出循环
+				# 此处有问题，无法判断是否为最后一个，并跳出此模块
+				if @backup_line > self.size and line_str.nil?
+					@count_line = @backup_line
+					if Aio::Base::Debug.mismatch?
+						puts "[-] Can't match this line: "
+						puts caller
+						puts "  line_string: #{self[@backup_line]}"
+						puts "  regexp: #{reg}"
+					end
+					raise OutLineError
+				end
+
+				if line_str.nil?
+					@count_line = @backup_line
+					break
+				end
+
+				first = false
+				begin
+					res = line_str.match_block(reg) do |b|
+						block.call(b) unless block.nil?
+					end
+				rescue IndexError => e
+					print_error "IndexError: 请检查模块block提取信息名称"
+					puts "caller"
+					puts caller
+					exit
+				rescue NoMethodError
+					if Aio::Base::Debug.module_debug?
+						print_error "NoMethodError: 请检查模块block中useful是否定义正确"
+						puts caller
+					end
+					exit
+				rescue ArgumentError => e
+					if Aio::Base::Debug.module_debug?
+						puts "ArgumentError:"
+						puts e.message
+						puts caller
+					end
+				end
+
+				@count_line += 1
+
+				# 如果匹配到，跳出循环
+				break if res
+
+				# 如果只是单步运行，就返回
+				break if single
+			end
+		end
+
+		# 单行循环
+    # stop 为停止出，在停止处之前的每一行都将输出
+		def readline_match_block_loop(start, stop, &block)
+			stop = Aio::Base::Toolkit::Regexp.safe(stop)
+			loop do 
+				readline_match_block(start, true, &block)
+			  break if stop.match(self[@count_line])
+				break if self[@count_line].nil?
+			end
+		end
+			
+		# 读取一个区间，并返回块
+		# 只会执行一次
+		# stop 作为分裂符
+		# opt 当last为false时，不会对stop一行输出
+		# opt 当before为true时，只会分裂stop的前一行，count_line保留
+		def readline_range(start, stop, opt={:last=>false}, &block)
+			str_context = Context.new
+			start = Aio::Base::Toolkit::Regexp.safe(start)
+			stop = Aio::Base::Toolkit::Regexp.safe(stop)
+			backup_line = @count_line
+
+			loop do 
+				line_str = self[@count_line]
+
+				if line_str.nil?
+					@count_line = backup_line
+					raise OutLineError
+				end
+
+				if start =~ line_str
+					str_context << line_str
+					@count_line += 1
+					break
+				end
+				@count_line += 1
+			end
+
+			loop do 
+				line_str = self[@count_line]
+				#raise OutLineError if line_str.nil?
+				if stop =~ line_str or line_str.nil?
+					str_context << line_str if opt[:last]
+					@count_line += 1 unless opt[:before]
+					break
+				else
+					str_context << line_str
+				end
+				@count_line += 1
+			end
+
+			block.call(str_context)
+		end
+
+		# 当需要多次循环时使用
+		# 此方法用于循环更加安全
+		def readline_range_loop(start, stop, opt={:last=>false}, &block)
+			loop do 
+				begin
+					readline_range(start, stop, opt, &block)
+				rescue OutLineError
+					break
+				end
+			end
+		end
+
+		# 读取一个区间并返回块
+		# 在起始位置之后的行中，满足条件, 则放入同一区间。否则返回
+		def readline_range_if(start, condition, &block)
+			str_context = Context.new
+			start = Aio::Base::Toolkit::Regexp.safe(start)
+			condition = Aio::Base::Toolkit::Regexp.safe(condition)
+
+			loop do
+				line_str = self[@count_line]
+				raise OutLineError if line_str.nil?
+				if start =~ line_str
+					str_context << line_str
+					@count_line += 1
+					break
+				end
+				@count_line += 1
+			end
+
+			loop do
+				line_str = self[@count_line]
+				if condition =~ line_str
+					str_context << line_str
+					@count_line += 1
+				else
+					break
+				end
+			end
+
+			block.call(str_context)
+		end
+
+		def readline_range_if_loop(start, condition, &block)
+			loop do
+				begin
+					readline_range_if(start, condition, &block)
+				rescue OutLineError
+					break
+				end
+			end
+		end
+
+		def count_line
+			self[@count_line]
+		end
+
+		def method_missing(mid, *arg, &block)
+			print_error "#{mid} 方法未定义，请检查方法名拼写"
+			puts caller[0]
+			super
+		end
+
+	end
+end

data/lib/aio/core/text/line_string.rb

@@ -0,0 +1,74 @@
+#coding=utf-8
+
+module Aio::Text
+	class LineString < String
+		class Mismatch < StandardError; end
+
+		include Aio::Ui::Verbose
+
+		# 获得区块
+		def match_block(reg)
+			block = reg.match(self)
+			#raise Mismatch.new, "reg: #{reg}\nstr: #{self.to_s}" if block.nil?
+			if block.nil?
+				return false
+			end
+
+			# 有两种更新的方式，不加str 那么就是从block中的提取
+			# 如果有str， 则直接使用str
+			def block.update(info, sym, str=nil)
+				sym = sym.to_sym
+				if info.nil?
+					print_error "请检查update中的第一个参数是否定义" 
+					pp caller
+				end
+
+				if str.nil?
+					info[sym] = self[sym].strip
+				else
+					info[sym] = str.strip
+				end
+			end
+
+			def block.update_arr(info, sym)
+				sym = sym.to_sym
+				info[sym] ||= []
+				info[sym] << self[sym].strip
+			end
+
+			def block.update_hash(info, sym, key, val)
+				sym = sym.to_sym
+				info[sym] ||= {}
+				info[sym][key] = val.strip
+			end
+
+			# 参数info 放置useful
+      # 参数sym  为Symbol类型的标示
+			# 参数level 为 :serious 或 :ordinary
+			# 参数mod  一般为self
+			# 参数opt[:string] 当block中没有sym项时使用
+			def block.warning(info, sym, level, mod, opt={})
+				sym = sym.to_sym
+				self.update(info, sym, opt[:string])
+				# Aio::Text::Warning 类中的warning方法
+				mod.warning_klass.warning(info, sym, level, mod, opt[:force])
+			end
+
+			def block.warning_serious(info, sym, mod, opt={})
+				sym = sym.to_sym
+				self.update(info, sym, opt[:string])
+				mod.warning_klass.warning_serious(info, sym, mod, opt[:force])
+			end
+
+			def block.warning_ordinary(info, sym, mod, opt={})
+				sym = sym.to_sym
+				self.update(info, sym, opt[:string])
+				mod.warning_klass.warning_ordinary(info, sym, mod, opt[:force])
+			end
+
+			yield block
+		end
+
+	end
+end
+