blink_tm 0.4.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aee9807ee73b58a75f7c4c0d09fcda705f6d8087d51e3c5178ab0472ebd2faae
-  data.tar.gz: d9156630e58cc9d4a41b26b7f0666f2abe565de91e8d1636bb8733920a9dfac0
+  metadata.gz: 290de1234088715cb8d957462afdd3a8f54c1c876f2b49ae35de7546cb352da8
+  data.tar.gz: e4a103649d1c326c86eb74931ca4a4796e150c186e9f6ef05926410d33ab31b2
 SHA512:
-  metadata.gz: 204d49f580218bce9aed96a58a27a1f6fae07996e8d9a911749fec17a621b8c4cfcf2f081e71447e0d61788b22032713239c287d0b1194d6c4e6b048fdcd24a1
-  data.tar.gz: 4c269cca6fb02329354483e4495a88da1270c6426a2756315eb8bc88ef0577466165d0f2239181a140bcf04042c04c4ae4b53c0ec53044034bd930954f98f606
+  metadata.gz: 7641d9d08838db8707dd75a327a417090ef0c0ecdddf0f458f34c5caeffb1406dde99272db73ad30d5e3ef288b348534b5834e09365ead845b4db34efa598c5d
+  data.tar.gz: 119773e1b395a46910267f6bee5f6c284a7bb3208953c40649c1d3981f31f6508f39b202d983a658ffedb7988b3dc4082be86c162df01b0063a0bf373352d4c9

data/exe/blink-tm

@@ -1,19 +1,86 @@
 #!/usr/bin/env ruby
 require 'blink_tm'
 
-# Find Device running Blink Taskmanager
-dev = nil
+
+if ARGV.any?(/^\-(\-version|v)$/)
+	puts "BlinkTM Version #{BlinkTM::BOLD}#{BlinkTM::VERSION}#{BlinkTM::RESET}"
+	exit
+end
+
+written_pid = false
+
+BlinkTM::log "BlinkTM Version #{BlinkTM::VERSION}"
+if File.exist?(BlinkTM::LOCKFILE)
+	BlinkTM.log 'error', "Lock file #{BlinkTM::LOCKFILE} already exists! If it's not running you might manually delete this to make blinktm work."
+
+	pid = IO.read(BlinkTM::LOCKFILE) if File.readable?(BlinkTM::LOCKFILE)
+	process_name = File.readable?("/proc/#{pid}/cmdline") ? IO.read("/proc/#{pid}/cmdline") : 'unknown'
+	stat = File.readable?("/proc/#{pid}/stat") ? IO.read("/proc/#{pid}/stat") : nil
+	state = stat ? stat.gsub(/\(.+\)/, '').split[1] : 'unknown'
+	friendly_state = case state
+		when ?S then 'Sleeping'
+		when ?I then 'Idle'
+		when ?Z then 'Zombie'
+		when ?R then 'Running'
+		when ?T then 'Stopped'
+		else 'Unknown'
+	end
+
+	BlinkTM.log 'info', <<~EOF
+		Process Details:
+		\t- ID: #{pid}
+		\t- Command: #{File.basename(process_name.gsub(?\u0000, ?\s))}
+		\t- Status: #{friendly_state}
+	EOF
+
+	exit!
+else
+	begin
+		IO.write(BlinkTM::LOCKFILE, $$)
+		written_pid = true
+	rescue Exception
+		puts "Can't write to #{BlinkTM::LOCKFILE}"
+		exit!
+	end
+end
+
 retry_count = 0
 
-while(!dev)
-	dev = BlinkTM.find_device
+# Find Device running Blink Taskmanager
+dev = BlinkTM::find_device!
+file = nil
+
+begin
+	BlinkTM.start(dev) { |x| file = x }
+rescue BlinkTM::SyncError
+	sleep 1
+	retry
+rescue Errno::ENOENT, Errno::EIO, BlinkTM::NoDeviceError
+	file &.close
+	sleep 0.125
+	dev = BlinkTM::find_device!
+	retry
+rescue Interrupt, SystemExit, SignalException
+	file &.close
+	File.delete(BlinkTM::LOCKFILE)
+rescue Exception
+
+	mesg = <<~EOF
+		:: Time: #{Time.now.strftime("%A %d %B %Y, %H:%M:%S:%5N %p")}:
+		#{$!.full_message}
 
-	if dev
-		puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Device discovered successfully. Path: #{dev}#{BlinkTM::RESET}"
+		Please notify these bugs to the issue tracker.
+		#{'-' * 70}
+	EOF
+
+	if File.writable?(BlinkTM::LOGFILE)
+		log = File.open(BlinkTM::LOGFILE, 'a')
+		log.write(mesg)
+		log.close
 	else
-		puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No device found. Retrying #{retry_count += 1}#{BlinkTM::RESET}"
-		sleep 0.5
+		puts "Logs aren't writable\n\nHere's a detailed message of what has happened:"
+		puts mesg
 	end
+ensure
+	File.delete(BlinkTM::LOCKFILE)
 end
-
-BlinkTM.start(dev)

data/ext/baudrate/baudrate.c

@@ -7,7 +7,7 @@ VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed)
 	char *device = StringValuePtr(dev) ;
 	unsigned int spd = NUM2UINT(speed) ;
 
-	int serial_port = open(device, O_RDWR) ;
+	int serial_port = open(device, O_RDWR | O_NOCTTY) ;
 	struct termios tty ;
 
 	char status = tcgetattr(serial_port, &tty) ;
@@ -22,7 +22,10 @@ VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed)
 		-isig -icanon -iexten -echo -echoe -echok -echoctl -echoke
 	*/
 
-	if(status != 0) return Qnil ;
+	if(status != 0) {
+		close(serial_port) ;
+		return Qnil ;
+	}
 
 	tty.c_cflag &= ~CSIZE ;
 	tty.c_cflag |= CS8 ;
@@ -46,18 +49,20 @@ VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed)
 	cfsetospeed(&tty, spd) ;
 	status = tcsetattr(serial_port, TCSANOW, &tty) ;
 
-	if (status == 0) return Qtrue ;
+	close(serial_port) ;
 
+	if (status == 0) return Qtrue ;
 	return Qfalse ;
 }
 
 VALUE getBaudRate(volatile VALUE obj, volatile VALUE dev) {
 	char *device = StringValuePtr(dev) ;
 
-	int serial_port = open(device, O_RDWR) ;
+	int serial_port = open(device, O_RDWR | O_NOCTTY | O_NONBLOCK) ;
 	struct termios tty ;
 
 	char status = tcgetattr(serial_port, &tty) ;
+	close(serial_port) ;
 
 	if(status == 0) {
 		unsigned int in = cfgetispeed(&tty) ;

data/ext/crc32/crc32.c

@@ -0,0 +1,33 @@
+/*
+	Source:
+	https://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art008
+
+	Note that this obeys the standard and matches with Ruby's Zlib.crc32(...)
+*/
+
+#define CRC32_DIVISOR 0xEDB88320
+#include "ruby.h"
+
+static VALUE getCRC(volatile VALUE obj, volatile VALUE str) {
+	char *input = StringValuePtr(str) ;
+	unsigned char len = strlen(input) ;
+	unsigned long crc = 0xFFFFFFFF ;
+
+	for (unsigned char i = 0 ; i < len ; ++i) {
+		crc ^= input[i] ;
+
+		for (unsigned char k = 8 ; k ; --k) {
+			crc = crc & 1 ? (crc >> 1) ^ CRC32_DIVISOR : crc >> 1 ;
+		}
+	}
+
+	char buffer[11] ;
+	sprintf(buffer, "%lu", crc ^ 0xFFFFFFFF) ;
+
+	return rb_str_new_cstr(buffer) ;
+}
+
+void Init_crc32() {
+	VALUE blinktm = rb_define_module("BlinkTM") ;
+	rb_define_module_function(blinktm, "crc32", getCRC, 1) ;
+}

data/ext/crc32/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'blink_tm/crc32'

data/lib/blink_tm/blink_tm.rb

@@ -4,8 +4,6 @@
 module BlinkTM
 	# Detect device
 	def find_device
-		dev = nil
-
 		Dir.glob('/sys/bus/usb/devices/*').each { |x|
 			v = File.join(x, 'idVendor')
 			vendor = IO.read(v).strip if File.readable?(v)
@@ -14,39 +12,45 @@ module BlinkTM
 			product = IO.read(p).strip if File.readable?(p)
 
 			if vendor == '1a86' && product == '7523'
-				puts "#{BOLD}#{GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: A potential device discovered: #{vendor}:#{product}#{RESET}"
+				log 'warn', "A potential device discovered: #{vendor}:#{product}"
 
 				Dir.glob('/dev/ttyUSB[0-9]*').each { |x|
 					if File.writable?(x)
-						puts "#{BlinkTM::BOLD}#{BlinkTM::BLUE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Changing baudrate to 57600...#{BlinkTM::RESET}"
+						log 'success', "Changing baudrate to 57600..."
 
 						if BlinkTM.set_baudrate(x, BlinkTM::BAUDRATE)
-							puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Successfully Changed baudrate to 57600...#{BlinkTM::RESET}"
+							log 'success', 'Successfully Changed baudrate to 57600...'
 						else
-							puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Cannot change the baudrate#{BlinkTM::RESET}"
+							log 'error', 'Cannot change the baudrate'
 						end
 					else
-						"#{BOLD}#{RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No permission granted to change Baudrate#{RESET}"
+						log 'error', 'No permission granted to change Baudrate'
 					end
 
 					if File.readable?(x)
 						begin
-							if File.open(x).readpartial(30).to_s.scrub.include?("BTM")
-								puts "#{BOLD}#{ORANGE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Multiple Blink Task "\
-								"Manager Hardware Found! "\
-								"Selecting: #{vendor}:#{product}#{RESET}" if dev
-
-								dev = x
-							end
+							return x if File.open(x).read_nonblock(30).to_s.scrub.include?("BTM")
 						rescue EOFError
-							sleep 0.125
+							sleep 0.05
 							retry
+						rescue Errno::ENOENT, Errno::EIO
 						end
 					end
 				}
 			end
 		}
 
+		nil
+	end
+
+	@@retry_count = 0
+	def find_device!
+		while(!(dev = BlinkTM.find_device))
+			log 'error', "No device found. Retrying #{@@retry_count += 1}"
+			sleep 0.5
+		end
+
+		log 'success', "Device discovered successfully. Path: #{dev}#{BlinkTM::RESET}"
 		dev
 	end
 
@@ -79,7 +83,7 @@ module BlinkTM
 		Thread.new {
 			while true
 				_cpu_u = LS::CPU.total_usage(POLLING).to_f
-				cpu_u = _cpu_u.nan? ? 0 : _cpu_u.to_i
+				cpu_u = _cpu_u.nan? ? 255 : _cpu_u.to_i
 			end
 		}
 
@@ -102,91 +106,107 @@ module BlinkTM
 			end
 		}
 
-		begin
-			raise NoDeviceError unless device
-
-			in_sync = false
-			fd = IO.sysopen(device, Fcntl::O_RDWR)
-			file = IO.open(fd)
+		prev_crc32 = ''
+		raise NoDeviceError unless device
 
-			until in_sync
-				# Clear out any extra zombie bits
-				file.syswrite(?~)
-				# Start the device
-				file.syswrite(?#)
-				file.flush
+		in_sync = false
 
-				sleep 0.125
+		fd = IO.sysopen(
+			device,
+			Fcntl::O_RDWR | Fcntl::O_NOCTTY | Fcntl::O_NONBLOCK | Fcntl::O_TRUNC
+		)
 
-				begin
-					if file.readpartial(8000).include?(?~)
-						in_sync = true
-						break
-					end
-				rescue EOFError
-					sleep 0.05
-					retry
-				end
-			end
-
-			puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Device ready!#{BlinkTM::RESET}"
-
-			while true
-				# cpu(01234) memUsed(999993) swapUsed(999992) io_active(0)
-				# netUpload(999991) netDownload(999990)
-				# disktotal(999990) diskused(999990)
+		file = IO.open(fd)
+		yield file
 
-				memstat = LS::Memory.stat
-				mem_u = memstat[:used].to_i.*(1024).*(100).fdiv(memstat[:total].to_i * 1024).round
+		until in_sync
+			# Clear out any extra zombie bits
+			file.syswrite(?~.freeze)
+			# Start the device
+			file.syswrite(?#.freeze)
+			file.flush
 
-				swapstat = LS::Swap.stat
-				swap_u = swapstat[:used].to_i.*(1024).*(100).fdiv(swapstat[:total].to_i * 1024).round
+			sleep 0.125
 
-				# Output has to be exactly this long. If not, blink-taskmanager shows invalid result.
-				# No string is split inside blink-task manager, it just depends on the string length.
-				#
-				# cpu(100) memUsed(100) swapUsed(100)
-				# netDownload(9991) netUpload(9991)
-				# ioWrite(9991) ioRead(9991)
+			begin
+				if file.read_nonblock(8000).include?(?~)
+					in_sync = true
+					break
+				end
+			rescue EOFError
+				sleep 0.05
+				retry
+			end
+		end
 
-				# Debugging string
-				# str = "#{"%03d" % cpu_u} #{"%03d" % mem_u} #{"%03d" % swap_u} "\
-				# "#{convert_bytes(net_u)} #{convert_bytes(net_d)} "\
-				# "#{convert_bytes(io_r)} #{convert_bytes(io_w)}"
+		sync_error_count = 0
+
+		log 'success', 'Device ready!'
+		file.read
+
+		while true
+			# cpu(01234) memUsed(999993) swapUsed(999992) io_active(0)
+			# netUpload(999991) netDownload(999990)
+			# disktotal(999990) diskused(999990)
+
+			memstat = LS::Memory.stat
+			_mem_u = memstat[:used].to_i.*(1024).*(100).fdiv(memstat[:total].to_i * 1024)
+			mem_u = _mem_u.nan? ? 255 : _mem_u.round
+
+			swapstat = LS::Swap.stat
+			_swap_u = swapstat[:used].to_i.*(1024).*(100).fdiv(swapstat[:total].to_i * 1024)
+			swap_u = _swap_u.nan? ? 255 : _swap_u.round
+
+			# Output has to be exactly this long. If not, blink-taskmanager shows invalid result.
+			# No string is split inside blink-task manager, it just depends on the string length.
+			#
+			# cpu(100) memUsed(100) swapUsed(100)
+			# netDownload(9991) netUpload(9991)
+			# ioWrite(9991) ioRead(9991)
+
+			# Debugging string
+			# str = "#{"%03d" % cpu_u} #{"%03d" % mem_u} #{"%03d" % swap_u} "\
+			# "#{convert_bytes(net_u)} #{convert_bytes(net_d)} "\
+			# "#{convert_bytes(io_r)} #{convert_bytes(io_w)}"
+
+			str = "!##{"%03d" % cpu_u}#{"%03d" % mem_u}#{"%03d" % swap_u}"\
+			"#{convert_bytes(net_u)}#{convert_bytes(net_d)}"\
+			"#{convert_bytes(io_r)}#{convert_bytes(io_w)}1~"
+
+			# Rescuing from suspend
+			file.syswrite(str)
+			file.flush
+			crc32 = file.read.scrub![/\d+/]
+
+			unless crc32 == prev_crc32 || prev_crc32.empty?
+				raise SyncError if sync_error_count > 1
+				sync_error_count += 1
+			else
+				sync_error_count = 0 unless sync_error_count == 0
+			end
 
-				str = "!##{"%03d" % cpu_u}#{"%03d" % mem_u}#{"%03d" % swap_u}"\
-				"#{convert_bytes(net_u)}#{convert_bytes(net_d)}"\
-				"#{convert_bytes(io_r)}#{convert_bytes(io_w)}1~"
+			prev_crc32 = BlinkTM.crc32(str[2..-2])
+			sleep REFRESH
+		end
 
-				# Rescuing from suspend
-				file.syswrite(str)
-				file.flush
+		unless device
+			puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Error establishing connection. Don't worry if this is a valid device. Retrying...#{BlinkTM::RESET}"
+			sleep 0.1
+		end
+	end
 
-				sleep REFRESH
-			end
-		rescue Interrupt, SystemExit, SignalException
-			file &.close
-			exit 0
-		rescue Errno::ENOENT, BlinkTM::NoDeviceError
-			file &.close
-			device = find_device
-
-			unless device
-				puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Error establishing connection. Don't worry if this is a valid device. Retrying...#{BlinkTM::RESET}"
-				sleep 0.1
-			end
+	def log(type, message = nil)
+		message, type = type, nil if type && !message
 
-			retry
-		rescue BlinkTM::DeviceNotReady
-			file &.close
-			sleep 0.1
-			retry
-		rescue Exception
-			puts $!.full_message
-			file &.close
-			sleep 0.1
-			retry
+		colour = case type
+			when 0, 'fatal', 'error' then BlinkTM::RED
+			when 1, 'warn' then BlinkTM::ORANGE
+			when 2, 'info' then BlinkTM::BLUE
+			when 3, 'success', 'ok' then BlinkTM::GREEN
+			else ''
 		end
+
+		puts "#{BlinkTM::BOLD}#{colour}:: #{Time.now.strftime('%H:%M:%S.%2N')}: #{message}#{BlinkTM::RESET}"
 	end
 
 	extend(self)

data/lib/blink_tm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BlinkTM
-	VERSION = "0.4.0"
+	VERSION = "2.1.0"
 end

data/lib/blink_tm.rb

@@ -6,18 +6,19 @@ $-v = true
 
 module BlinkTM
 	# Important Constants
-	BAUDRATE = BlinkTM::B57600
+	BAUDRATE = BlinkTM::B38400
 	SCANID = 'BTM'
 
 	# POLLING time, how often should CPU, Net, IO usages should be updated.
 	# Should always be a float.
-	POLLING = 0.375
+	POLLING = 0.250
 
 	# Refresh time, how often the main loop should run
 	REFRESH = 0.5
 
 	# Errors
 	NoDeviceError = Class.new(StandardError)
+	SyncError = Class.new(StandardError)
 	DeviceNotReady = Class.new(StandardError)
 
 	# Units
@@ -33,6 +34,8 @@ module BlinkTM
 	ORANGE = "\e[38;2;245;155;20m"
 	BOLD = "\e[1m"
 	RESET = "\e[0m"
+	LOCKFILE = '/tmp/blinktaskmanager.pid'
+	LOGFILE = '/tmp/blinktaskmanager.err.log'
 
 	# Other constants
 	ROOT_DEV = ::LinuxStat::Mounts.root
@@ -47,3 +50,4 @@ end
 require 'blink_tm/version'
 require 'fcntl'
 require 'blink_tm/blink_tm'
+require 'blink_tm/crc32'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blink_tm
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-07 00:00:00.000000000 Z
+date: 2022-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: linux_stat
@@ -31,11 +31,14 @@ executables:
 - blink-tm
 extensions:
 - ext/baudrate/extconf.rb
+- ext/crc32/extconf.rb
 extra_rdoc_files: []
 files:
 - exe/blink-tm
 - ext/baudrate/baudrate.c
 - ext/baudrate/extconf.rb
+- ext/crc32/crc32.c
+- ext/crc32/extconf.rb
 - lib/blink_tm.rb
 - lib/blink_tm/blink_tm.rb
 - lib/blink_tm/version.rb
@@ -58,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.18
+rubygems_version: 3.3.8
 signing_key:
 specification_version: 4
 summary: A controller for Arduino OLED System Monitor, Blink Task Manager