luna_scanner 0.0.3

data/lib/luna_scanner/device.rb

@@ -0,0 +1,132 @@
+#encoding: utf-8
+require 'csv'
+
+module LunaScanner
+  class Device
+    attr_accessor :ip, :sn, :model, :dialno, :version, :to_change_ip
+    IP_REGEX = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
+
+    def initialize(options={})
+      # ip, sn, model, version, to_change_ip=nil
+      @ip      = options[:ip] || ""
+      @sn      = options[:sn] || ""
+      @model   = options[:model] || ""
+      @version = options[:version] || ""
+      @to_change_ip = options[:to_change_ip]
+    end
+
+    def self.display_header
+      "-----SN--------IP-------------MODEL------VERSION------"
+    end
+
+    def ip_from_sn
+      raise "SN not valid. 8 numbers." if self.sn !~ /^\d{8}$/
+
+      sn_integer = self.sn.to_i
+      ip = "8.128.#{2+sn_integer/250}.#{sn_integer%250}"
+      ip
+    end
+
+    def new_ip
+      ip_template = <<TXT
+# and how to activate them. For more information, see interfaces(5).
+
+# The loopback network interface
+auto lo
+iface lo inet loopback
+
+#enable this if you are using 100Mbps
+auto eth0
+allow-hotplug eth0
+iface eth0 inet static
+address 0.0.0.0
+
+auto eth1
+allow-hotplug eth1
+iface eth1 inet static
+address #{ip_from_sn}
+netmask 255.255.252.0
+gateway 8.128.3.254
+TXT
+      ip_template
+    end
+
+    def write_ip_to_config
+      File.open("/tmp/interfaces", "w") do |f|
+        f.puts self.new_ip
+      end
+    end
+
+    def display
+      " #{sn}  #{ip.ljust(15)}  #{model.ljust(8)}  #{version}" # two space
+    end
+
+    def dev?
+      sn.start_with?("f")
+    end
+
+    def ==(other)
+      return false if not other.is_a?(Device)
+
+      self.sn == other.sn
+    end
+
+    def self.load_from_file(file_name)
+      if file_name && file_name.to_s.end_with?(".csv")
+        self.validate_change_ip_csv_file!(file_name)
+
+        devices = Array.new
+        CSV.foreach(file_name) do |row|
+          # sn,changed_ip
+          devices << Device.new({
+                                    :ip => nil, :sn => row[0], :model => nil, :version => nil, :to_change_ip => row[1]
+                                })
+        end
+        return devices
+      end
+
+      ip_file = File.read(file_name)
+      devices = Array.new
+
+      ip_file.each_line do |ip_line|
+        temp = ip_line.split(",")
+        if temp.size < 5
+          raise "ip file not valid, please check."
+        end
+      end
+
+      ip_file.each_line do |ip_line|
+        temp = ip_line.split(",")
+        #f.puts "#{device.ip},#{device.sn},#{device.model},#{device.version},#{device.ip_from_sn}"
+        devices << Device.new(:ip => temp[0], :sn => temp[1], :model => temp[2], :version => temp[3], :to_change_ip => temp[4]) if temp[1] && !temp[1].start_with?("f")
+      end
+      devices
+    end
+
+    def self.validate_change_ip_csv_file!(file_name)
+      return false if file_name.nil? || !file_name.to_s.end_with?(".csv")
+
+      changed_sn = Array.new
+      changed_ip = Array.new
+      CSV.foreach(file_name) do |row|
+        abort "SN is blank!" if row[0].to_s.strip.length == 0
+        abort "SN length in file #{file_name} should be 8" if row[0].to_s.strip.length != 8
+        changed_sn << row[0].to_s.strip
+
+        abort "IP is blank!" if row[1].to_s.strip.length == 0
+        abort "IP #{row[1]} in file #{file_name} is an invalid ip string!" if row[1].to_s !~ IP_REGEX
+
+        changed_ip << row[1].to_s.strip
+      end
+
+      if changed_sn.uniq.size != changed_sn.size
+        abort "SN duplicated in file #{file_name}"
+      end
+
+      if changed_ip.uniq.size != changed_ip.size
+        abort "IP duplicated in file #{file_name}"
+      end
+    end
+
+  end
+end

data/lib/luna_scanner/logger.rb

@@ -0,0 +1,32 @@
+require 'socket'
+require 'net/ssh'
+
+module LunaScanner
+  class Logger
+    class << self
+      def info message, options={}
+        if options[:time] == false
+          $stderr.puts "\r#{message.to_s}"
+        else
+          $stderr.puts "\r#{Time.now.strftime("%H:%M:%S")} > #{message.to_s}"
+        end
+      end
+
+      def success message, options={}
+        if options[:time] == false
+          $stdout.puts "\r\e[32m#{message.to_s}\e[0m"
+        else
+          $stdout.puts "\r#{Time.now.strftime("%H:%M:%S")} > \e[32m#{message.to_s}\e[0m"
+        end
+      end
+
+      def error message, options={}
+        if options[:time] == false
+          $stderr.puts "\r\e[33m#{message.to_s}\e[0m"
+        else
+          $stderr.puts "\r#{Time.now.strftime("%H:%M:%S")} > \e[33m#{message.to_s}\e[0m"
+        end
+      end
+    end
+  end
+end

data/lib/luna_scanner/rcommand.rb

@@ -0,0 +1,128 @@
+#encoding: utf-8
+
+require 'erb'
+require 'net/ssh'
+require 'net/scp'
+
+module LunaScanner
+  class Rcommand # mean remote command execute.
+
+    @@ip_max_length = 7 #1.1.1.1
+    @@total_devices_count = 0
+    @@success_devices_count = 0
+
+    def reboot!(ip)
+      return false if ip.nil?
+
+      Logger.info "Try to reboot #{ip} ..."
+      begin
+        Net::SSH.start(
+            "#{ip}", 'root',
+            :auth_methods => ["publickey"],
+            :user_known_hosts_file => "/dev/null",
+            :timeout => 3,
+            :keys => [ "#{LunaScanner.root}/keys/yu_pri" ]  # Fix key permission: chmod g-wr ./yu_pri  chmod o-wr ./yu_pri  chmod u-w ./yu_pri
+        ) do |session|
+          session.exec!("reboot")
+        end
+      rescue
+        Logger.error "              #{ip} no response. #{$!.message}"
+      end
+    end
+
+    def change_ip(connect_device, is_reboot)
+      if connect_device.ip == ''
+        Logger.error "Device #{connect_device.sn} not found in LAN."
+        return false
+      end
+
+      begin
+        LunaScanner.start_ssh(connect_device.ip) do |shell|
+          Logger.info "Changed device #{connect_device.sn} [#{connect_device.ip.ljust(@@ip_max_length)}] to new ip #{connect_device.to_change_ip.ljust(15)}"
+          shell.exec!("echo '#{connect_device.new_ip}' > /etc/network/interfaces")
+          shell.exec!("reboot") if is_reboot
+        end
+      rescue
+        Logger.error "Failed to change device #{connect_device.sn} to new ip #{connect_device.new_ip.ljust(15)} #Error reason: #{$!.message}"
+        return false
+      else
+        return true
+      end
+    end
+
+    def self.batch_change_ip(options={})
+      target_devices = Device.load_from_file(options[:input_ip])
+      @@total_devices_count = target_devices.size
+
+      Logger.info "->  Start batch change ip.", :time => false
+
+      thread_pool = []
+      10.times do
+        ssh_thread = Thread.new do
+          go = true
+          while go
+            device = target_devices.pop
+            if device.nil?
+              go = false
+            else
+              rcommand = self.new
+              if rcommand.change_ip(device, options[:reboot])
+                @@success_devices_count += 1
+              end
+            end
+          end
+        end
+
+        thread_pool << ssh_thread
+      end
+
+      thread_pool.each{|thread| thread.join }
+
+      Logger.info "\n#{@@success_devices_count}/#{@@total_devices_count} devices changed.", :time => false
+      Logger.info "Restart all devices to make changes work.", :time => false if !options[:reboot]
+    end
+
+    def self.batch_update(options={})
+      update_script_file = File.expand_path("../update_firmware.sh", __FILE__)
+      target_devices = Device.load_from_file(options[:input_ip])
+      Logger.info "->  Start batch update.", :time => false
+
+      thread_pool = []
+      10.times do
+        ssh_thread = Thread.new do
+          go = true
+          while go
+            device = target_devices.pop
+            if device.nil?
+              go = false
+            else
+              begin
+
+                    Logger.info "->  Update #{device.ip} #{device.sn}"
+                    LunaScanner.start_ssh(device.ip) do |shell|
+                      shell.scp.upload!("#{update_script_file}", "/usr/local/luna-client/script/update_firmware.sh")
+                      shell.exec!("chmod a+x /usr/local/luna-client/script/update_firmware.sh")
+                      shell.exec!("sed -i 's/iface eth0 inet dhcp/iface eth0 inet static\naddress 0.0.0.0/' /etc/network/interfaces")
+                      shell.exec!("/usr/local/luna-client/script/update_firmware.sh http://8.128.3.254 1500k")
+                    end
+
+
+              rescue
+                Logger.error "Failed to update device #{device.sn} #{device.ip}  #{$!.message}"
+               # return false
+              else
+               # return true
+              end
+            end
+          end
+        end
+
+        thread_pool << ssh_thread
+      end
+
+      thread_pool.each{|thread| thread.join }
+
+    end
+
+  end
+end

data/lib/luna_scanner/scanner.rb

@@ -0,0 +1,156 @@
+require 'socket'
+require 'net/ssh'
+
+module LunaScanner
+  class Scanner
+
+    @@found_devices = Array.new
+
+    def initialize(thread_size, start_ip, end_ip)
+      raise "thread pool size not correct!" if thread_size.to_i <= 0
+      @thread_size = thread_size.to_i
+      Logger.info "Local ip #{LunaScanner.local_ip}"
+
+      @scan_ip_range = Util.ip_range(start_ip, end_ip)
+    end
+
+    def generate_ip_range(options)
+      if options[:input_ip].to_s.length > 0 # get ip range from file
+        raise "IP input file not exist." if !File.exist?(options[:input_ip])
+
+
+      else                                  # get ip range from start_ip to end_ip
+        if options[:start_ip].to_s.length == 0 || options[:end_ip].to_s.length == 0
+          raise "Require arguments to get ip range"
+        end
+
+
+      end
+
+    end
+
+    def scan(is_reboot, shell_command)
+      thread_pool = []
+      @scan_ip_range.reverse!
+      @thread_size.times do
+        ssh_thread = Thread.new do
+          go = true
+          while go
+            ip = @scan_ip_range.pop
+            if ip.nil?
+              go = false
+            else
+              begin
+                Logger.info "Scan ip #{ip} ..."
+                LunaScanner.start_ssh(ip) do |shell|
+                  sn      = shell.exec!('cat /proc/itc_sn/sn').chomp
+                  model   = shell.exec!('cat /proc/itc_sn/model').chomp
+                  version = shell.exec!('cat /jenkins_version.txt').chomp
+
+                  if shell_command.to_s.length > 0
+                    Logger.info "        execute command: #{shell_command} ...", :time => false
+                    shell.exec!("#{shell_command}")
+                  end
+
+                  if sn != "cat: /proc/itc_sn/sn: No such file or directory"
+                    @@found_devices << Device.new(:ip => ip, :sn => sn, :model => model, :version => version)
+                    Logger.success "                   #{ip} #{sn} #{model} #{version}", :time => false
+                    shell.exec!("reboot") if is_reboot
+                  end
+                end
+              rescue
+                      Logger.error "                   #{ip} no response. #{$!.message}", :time => false
+              end
+            end
+          end
+        end
+
+        thread_pool << ssh_thread
+      end
+
+      thread_pool.each{|thread| thread.join }
+    end
+
+    def self.scan!(options={})
+      start_ip = options[:start_ip] || Util.begin_ip(LunaScanner.local_ip)
+      end_ip   = options[:end_ip] || Util.end_ip(LunaScanner.local_ip)
+      scanner = self.new(options[:thread_size], start_ip, end_ip)
+
+      Logger.info "Start scan from #{start_ip} to #{end_ip} #{options[:reboot] ? '(reboot)' : ''} ..."
+      scanner.scan(options[:reboot], options[:command])
+
+      Logger.info "\n#{Device.display_header}", :time => false
+      @@found_devices.each do |device|
+        Logger.success device.display, :time => false
+      end
+      Logger.info "\n#{@@found_devices.size} devices found. #{options[:reboot] ? '(reboot)' : ''}", :time => false
+      if options[:result]
+        begin
+          File.open(options[:result], "w") do |f|
+            @@found_devices.each do |device|
+              f.puts "#{device.ip},#{device.sn},#{device.model},#{device.version},#{device.ip_from_sn}"
+            end
+          end
+        rescue
+          Logger.error "Failed to write scan result to #{options[:result]}", :time => false
+        else
+          Logger.error "Write scan result to #{options[:result]}", :time => false
+        end
+      end
+      Logger.info "\n", :time => false
+    end
+
+    def self.upload!(source_file, target_file, options={}, &block)
+      require 'net/scp'
+      if options[:input_ip] # Scan from given input ip file.
+        source_devices = File.read(options[:input_ip])
+        upload_hosts = Array.new
+        source_devices.each_line do |device|
+          ip,sn,model,version = device.split(" ")
+          upload_hosts << ip
+        end
+        upload_hosts.uniq!
+
+        return if upload_hosts.size == 0
+
+        thread_pool = []
+        options[:thread_size].times do
+          ssh_thread = Thread.new do
+            go = true
+            while go
+              ip = upload_hosts.pop
+              if ip.nil?
+                go = false
+              else
+                begin
+                  Logger.info "Connect to ip #{ip} ..."
+                  LunaScanner.start_ssh(ip) do |shell|
+                    Logger.info "         upload file #{source_file} to #{ip} #{target_file}", :time => false
+                    shell.scp.upload!(source_file, target_file)
+                    block.call(shell) if block
+                  end
+                rescue
+                  Logger.error "             #{ip} not connected. #{$!.message}"
+                end
+              end
+            end
+          end
+
+          thread_pool << ssh_thread
+        end
+
+        thread_pool.each{|thread| thread.join }
+
+      else
+        # self.scan!(options)
+        puts "Not implement yet."
+        exit 4
+      end
+    end
+
+    def self.found_devices
+      @@found_devices
+    end
+
+  end
+end