Ruby Mini-Skripte
Hier ist eine Sammlung von Ruby-Miniskripten, die sich bei der täglichen Arbeit so ansammeln.
22.11.2010 :: Context-Menu-Einträge Antivir löschen
Bei Windows 2000 stürzt der Rechner gerne ab, wenn man mit der rechten Maustaste das Context-Menü öffnet. Schuld ist ein Eintrag des Avira Scanners. Mit diesem Script löscht man die Einträge. Blöderweise installieren sich die Einträge bei manchem Update wieder neu.
# 2010-11-22
# Loesche Avira Scanner-Einträge im Context-Menu
require 'win32/registry'
begin
puts 'Loesche *\shellex\ContextMenuHandlers\...'
Win32::Registry::HKEY_CLASSES_ROOT.open('*\shellex\ContextMenuHandlers', Win32::Registry::Constants::KEY_ALL_ACCESS) do |reg|
reg.delete_key('Shell Extension for Malware scanning', true)
end
rescue
puts '*\shellex\ContextMenuHandlers\... nicht vorhanden.'
end
begin
puts
puts 'Loesche *\shellex\ContextMenuHandlers\...'
Win32::Registry::HKEY_CLASSES_ROOT.open('Folder\shellex\ContextMenuHandlers', Win32::Registry::Constants::KEY_ALL_ACCESS) do |reg|
reg.delete_key('Shell Extension for Malware scanning', true)
end
rescue
puts 'Folder\shellex\ContextMenuHandlers\... nicht vorhanden.'
end
puts "Tastendruck..."
gets
17.08.2007 :: Update-Backups unter W2K löschen
Bei jedem Windows-Update wird im Verzeichniss c:/winnt ein Ordner $NTUninstall<Updatename>$ angelegt, wo die auszutauschenden Dateien vor dem Update gesichert werden. Dies ermöglicht ein Rollback auf den alten Zustand.
Mit der Zeit sammeln sich hier aber jede Menge Verzeichnisse mit einer Menge an Dateien, die das System immer mehr aufblähen. Deshalb sollten die von Zeit zu Zeit gelöscht werden.
Hier ein Skript, was dies automatisch macht. Es werden nur die Inhalte der Verzeichnisse gelöscht, nicht die Verzeichnisse selber. Dies deshalb, weil man so noch gut sehen kann, welche Updates installiert wurden.
Getestet unter Windows 2000 (W2K), muss für andere Windows-Versionen angepasst werden.
# Lösche Windows Backups im im winnt-Verzeichnis
# Alle c:\winnt\$NtUninstall* Ordner werden durchlaufen
# und die Inhalte gelöscht. Die Ordner bleiben erhalten
windir = "c:/winnt"
Dir.foreach( windir ) do |f|
f_full = File.join( windir, f )
if File.directory?( f_full )
if f =~ /^\$NtUninstall/
delfile = File.join( f_full, "*.*" )
delfile.gsub!( /\//, "\\" )
cmd = sprintf( "del /s /Q %s", delfile )
puts cmd
raise unless cmd =~ /del .* c:\\winnt\\\$NtUninstall/
system( cmd )
end
end
end
24.05.2005 :: G-Code Erzeugung für Planfräsen (CNC, EMC)
Für eine Fräsmaschine, die mit Linux-EMC gesteuert wird, wurde ein kleines Programm gebraucht, welches G-Code für Planfräsen produziert. Im Grunde sollte ein Rechteck mäanderförmig ohne Z-Zustellung plan gefräst werden. Hier ein Programm, welches den G-Code dafür erzeugt.
Übrigens: Auf die neue bdi4-x EMC Version lässt sich der Ruby-Intepreter wunderbar nachinstallieren. Einfach apt-get install ruby eintippen und eine Online-Verbindung haben. Dann sollten die entsprechenden Pakete aus dem Netz heruntergeladen werden. Sobald installiert, kann dieses Programm mit "ruby frplan.rb" gestartet werden, insofern man es unter diesem Namen abgespeichert hat.
Unter Windows hilft der OneClickInstaller für Ruby. Siehe auch http://rubywiki.de/wiki/Erste_Schritte.
Das Ergebnis wird sowohl auf dem Bildschirm ausgegeben wie auch in die Datei test.iso im aktuellen Verzeichnis gespeichert.
# frplan.rb: G-Code Erzeugung für Planfräsen
# Gegeben ist die Breite und Länge eines Werkstückes. Dieses
# Werkstück soll die Maschine mäanderförmig abfahren, um es
# plan zu fräsen. Der Abstand der Mäanderbahnen wird ebenfalls
# definiert.
#
# Winfried Mueller, www.reintechnisch.de
#
Version = "2005/05/23 - 1"
State = "Experimental"
def req_is_a?( var, var_class )
raise unless var.is_a? var_class
end
class Vector
def initialize( x, y, z )
req_is_a?( x, Float )
req_is_a?( y, Float )
req_is_a?( z, Float )
@x = x
@y = y
@z = z
end
attr_accessor :x, :y, :z
end
class GCodeGen
def initialize
@curr_pos = Vector.new( 0.0, 0.0, 0.0 )
@last_line = ""
@speed = 0
end
attr_reader :curr_pos
def speed( speed )
raise unless (speed == 0 || speed == 1)
@speed = speed
end
def speed_as_gcode
case @speed
when 0
"G00"
when 1
"G01"
else
raise "assert"
end
end
private :speed_as_gcode
def go_abs( vect )
x = vect.x - @curr_pos.x
y = vect.y - @curr_pos.y
z = vect.z - @curr_pos.z
@last_line = sprintf( "%s ", speed_as_gcode() )
@moved = false
if x != 0
@last_line << sprintf( "X%3.3f ", x )
@curr_pos.x = x
@moved = true
end
if y != 0
@last_line << sprintf( "Y%3.3f ", y )
@curr_pos.y = y
@moved = true
end
if z != 0
@last_line << sprintf( "Z%3.3f", z )
@curr_pos.z = z
@moved = true
end
if !@moved
@last_line = ""
end
end
def go_rel( vect )
@last_line = sprintf( "%s ", speed_as_gcode() )
@moved = false
if vect.x != 0
@curr_pos.x += vect.x
@last_line << sprintf( "X%3.3f ", @curr_pos.x )
@moved = true
end
if vect.y != 0
@curr_pos.y += vect.y
@last_line << sprintf( "Y%3.3f ", @curr_pos.y )
@moved = true
end
if vect.z != 0
@curr_pos.z += vect.z
@last_line << sprintf( "Z%3.3f", @curr_pos.z )
@moved = true
end
if !@moved
@last_line = ""
end
end
def get_last
@last_line
end
def moved?
@moved
end
end
def input( prompt, format_str, err_msg )
r = nil
loop do
print prompt
r = gets.chomp
if r =~ format_str
break
end
puts "Fehler: #{err_msg}"
end
r
end
# --------------------------------------------------------------
# Configuration
file_header = <<ENDE
%
F3000
ENDE
file_footer = <<ENDE
M30
ENDE
file_name = "test.iso"
# --------------------------------------------------------------
RXP_FLOAT = /^[0-9]+(\.[0-9]+)?$/
breite = input( "Breite (X): ", RXP_FLOAT, "Format z.B. 20.3" ).to_f
laenge = input( "Laenge (Y): ", RXP_FLOAT, "Format z.B. 20.3" ).to_f
abstand = input( "Abstand : ", RXP_FLOAT, "Format z.B. 5.0" ).to_f
=begin
breite = 100.0
laenge = 300.0
abstand = 5.0
=end
gen = GCodeGen.new()
gen.speed( 1 )
vect1 = Vector.new( breite, 0.0, 0.0 )
vect2 = Vector.new( 0.0, abstand, 0.0 )
vect3 = Vector.new( -breite, 0.0, 0.0 )
vectors = [vect1, vect2, vect3, vect2]
f = File.open( file_name, "wb" ) do |f|
f.puts file_header
f.puts "(frplan generated: X: #{breite} Y: #{laenge} D: #{abstand})"
mark_end = false
while !mark_end
vectors.each do |v|
gen.go_rel( v )
if gen.curr_pos.y > laenge
mark_end = true
break
end
f.puts gen.get_last if gen.moved?
end
end
f.puts file_footer
end
File.foreach( file_name ) do |line|
print line
end
puts "Datei #{file_name} im aktuellen Verzeichnis erzeugt."
print "Enter Taste fuer weiter..."
gets
Hier ein Beispiel für den erzeugten Code:
% F3000 (frplan generated: X: 100.0 Y: 10.0 D: 1.0) G01 X100.000 G01 Y1.000 G01 X0.000 G01 Y2.000 G01 X100.000 G01 Y3.000 G01 X0.000 G01 Y4.000 G01 X100.000 G01 Y5.000 G01 X0.000 G01 Y6.000 G01 X100.000 G01 Y7.000 G01 X0.000 G01 Y8.000 G01 X100.000 G01 Y9.000 G01 X0.000 G01 Y10.000 G01 X100.000 M30
05.04.2005 :: Erzeugen von Test-Dateien
Mitunter brauche ich Test-Dateien, wo ein bestimmtes Muster n-mal wiederholt hintereinander geschrieben ist. Sowas kann man z.B. nutzen, um einen Memorystick zu testen. Man erzeugt eine z.B. 512MB große Datei mit verschiedenen Testpattern, schreibt diese auf den Stick und macht eine md5sum. Ist diese korrekt, ist der Stick in Ordnung.
Dies war übrigens auch der Grund, warum dieses Programm entstand. Ich hatte tatsächlich einen 500MB großen Stick, der defekte Sektoren aufwies, wobei das Betriebssystem jedoch keine Fehler erkannte. Seither teste ich jeden neuen Stick erstmal durch.
Das folgende Programm kann solche Muster-Dateien erzeugen. Man kann die Größe angeben, die die Datei annehmen soll. Das Pattern kann wahlweise als String oder als Hexadezimalfolge angegeben werden.
Dieses Programm zeigt auch schön den Einsatz von optparse. Das Programm läuft erst ab Ruby 1.8.
Mit genpfile --help kann man sich die Benutzung anzeigen lassen.
Die Performance ist ganz ok. Auf einem 450 MHz System erzeugt es unter Windows etwa 15 MB/s Daten.
Aufruf-Beispiele:
Erzeuge eine 512MB große Datei mit 0-Bytes: # genpfile -p 00 -s 512M file.bin Erzeuge eine 10KB große Datei mit dem Muster 0x55AA # genpfile -p 55AA -s 10K file.bin Erzeuge eine 512Byte große Datei mit "Hello World" als Stringpattern #genpfile -t 'Hello World' -s 512 file.bin Zeig mir die Hilfe an: # genpfile --help # genpfile -h
Programm:
# genpfile.rb - Generiere eine Pattern-gefüllte Datei mit
# vorgegebener Länge
#
#
# Winfried Mueller, www.reintechnisch.de, (c) 2005, GPL
require 'optparse'
Version = "1.0.3 - 2007/08/03"
options = { :file_size => 1024,
:pattern => "\x00",
:random => false
}
# Hexstring (e.g. 'FF00CD0A') to Binary-String
def hex_to_bin( hex_value )
hv = hex_value
hv.gsub!( / /, "" )
if hv.length % 2 != 0
hv = "0" + hv
end
bin_value = ""
while hv.length > 0
bin_value << hv[0..1].hex
hv = hv[2..-1]
end
bin_value
end
# Strings as '1K', '10M', '1024' to Integer
def size_to_i( size )
mult = 1
rx_KILOBYTE = /K$/i
rx_MEGABYTE = /M$/i
if size =~ rx_KILOBYTE
mult = 1024
elsif size =~ rx_MEGABYTE
mult = 1024 * 1024
end
(size.scan( /[0-9\.]+/ )[0].to_f * mult).to_i
end
def fill_random( buf )
0.upto(buf.length-1) do |i|
buf[i] = rand(256).chr
end
end
# Optionparser Setup
opts = OptionParser.new do |opts|
opts.banner = "Usage: genpfile [options] filename"
opts.separator ""
opts.on( "-s", "--size SIZE",
"File size (e.g. 1024, 1K, 10M)" ) do |size|
options[:file_size] = size_to_i( size )
end
opts.on( "-p", "--pattern PATTERN",
"Write pattern (e.g. '00ABDF51')" ) do |pt|
options[:pattern] = hex_to_bin( pt )
end
opts.on( "-r", "--random",
"Write random data." ) do
options[:random] = true
end
opts.on( "-t", "--text-pattern PATTERN",
"Write textpattern (e.g. 'Hello')" ) do |str|
options[:pattern] = str
end
opts.on_tail("-h", "--help", "Show this message" ) do
puts opts
exit
end
end
begin
opts.parse!( ARGV )
file_name = ARGV[0]
file_size = options[:file_size]
pattern = options[:pattern]
raise "No file specified." if file_name == nil
File.open( file_name, "wb+" ) do |f|
if options[:random]
n = 0
srand
buf_length = 102400
pattern_buf = "a" * buf_length
while n+buf_length < file_size
fill_random( pattern_buf )
f.write( pattern_buf )
n+=buf_length
end
fill_random( pattern_buf )
f.write( pattern_buf[0..(file_size-n-1)] )
else
P_MULT = 102400 / pattern.length
pattern_buf = pattern * P_MULT
pattern_buf_size = pattern_buf.length
n = 0
while n + pattern_buf_size < file_size
f.write( pattern_buf )
n += pattern_buf_size
end
f.write( pattern_buf[0..(file_size-n-1)] )
end
end rescue (raise "Can't create File #{file_name}")
rescue => exc
STDERR.puts exc.message
STDERR.puts opts.to_s
exit 1
end
15.03.2005 :: Linux: Check Medium im CD-Brenner
Unter Linux wird zum CD-Brennen meist cdrecord eingesetzt. Für ein kleines Backupskript brauchte ich die Information, ob ein CD-R oder CD-RW Rohling im Laufwerk liegt. Letzterer muss ja zuvor gelöscht werden, bevor er neu beschrieben wird.
Hierfür ein kleines Skript, welches checkt, ob CD-R oder CD-RW oder gar kein Rohling drin liegt. Hierfür wird `cdrecord -atip` aufgerufen und das Ergebnis geparst.
#!/usr/bin/env ruby
# checkcdmedia.rb Version: 2005/03/15
#
# Winfried Mueller, www.reintechnisch.de
module Config
DEVICE = "0,0"
CDRECORD = "/usr/bin/cdrecord"
end
s = `#{Config::CDRECORD} -atip dev=#{Config::DEVICE} 2>null`
ret = "Not available"
s.each do |line|
if line =~ /^\s+Is erasable/
ret = "Is erasable"
break
end
if line =~ /^\s+Is not erasable/
ret = "Is not erasable"
break
end
end
puts ret
03.03.2005 :: Automatische Installation Windows Security Updates
Bei Windows 2000 sind es mittlerweile 52 Security-Updates, die man nach einer Neuinstallation einspielen muss. Unbegreiflich, warum Microsoft dafür keine kumulierten Updates rausbringt. Man soll es eben nicht leicht haben, wenn man nicht das automatische Update von denen nutzt.
Aber wir haben ja eine Möglichkeit der Automatisierung. Nahezu jeder Patch kann mit patch.exe /u /z aufgerufen werden und nervt dann nicht mehr mit interaktiven Abfragen. Jetzt kann man jeden Patch in eine Batchdatei schreiben und dann wird alles automatisch gemacht.
Ich war zu faul, die Batchdatei immer wieder von Hand zu ergänzen, wenn neue Patches hinzu kommen. Also schrieb ich mir ein Ruby-Skript, welches die install.bat automatisch erstellt.
Man legt alle Patches in ein Verzeichnis und benamt die so, dass sie bei Sortierung die richtige Reihenfolge haben. Ich hänge immer das Datum in den Dateinamen vorne an in der Form YYYY-MM-DD-patchname.exe. Ins gleiche Verzeichnis kommt jetzt dieses Ruby-Skript, welches die install.bat erzeugt.
# makebat.rb - Erzeuge Batchfile zur automatisierten
# Installation von Microsoft-Security Updates
#
# Dieses Skript ins Verzeichnis legen, wo Updates liegen.
#
# Aufruf: ruby makebat.rb
#
# Erzeugt: install.bat
#
# Winfried Mueller, www.reintechnisch.de, 2005/03/03
i_files = Dir.entries(".")
i_files.delete_if {|f| f !~ /\.exe$/i }
i_files.sort
File.open( "install.bat", "w+" ) do |of|
i_files.each do |f|
of.puts f << " /u /z"
end
end
puts "Datei install.bat korrekt erzeugt."
puts "Druecke eine Taste fuer weiter..."
gets
28.02.2005 :: Kleines hexdump Programm
Dieses Programm stellt eine Inputdatei in Hexadezimalform dar. Sehr hilfreich, um binäre Dateien zu betrachten oder um Sonderzeichen in ASCII-Dateien zu erkennen.
Über START kann man einen Offset angeben, ab dem die Datei ausgegeben werden soll. Default ist 0. BYTES_PER_LINE gibt an, wieviele Bytes pro Zeile ausgegeben werden, sinnvoll ist hier 16 bei einem 80 Zeichen Display.
Changelog:
- 08.04.2005: binmode brauchts für Windows
# hexdump.rb
#
START = 0x00
BYTES_PER_LINE = 16
pos = 0
lcount = 0
chars = ""
ARGF.binmode
ARGF.each_byte do |b|
if pos < START
pos +=1
next
end
if lcount == 0
printf "%8.8X ", pos
end
printf "%2.2X ", b
if b >= 0x20 && b <= 0x7F
chars << b.chr
else
chars << "."
end
lcount += 1
pos += 1
if lcount == BYTES_PER_LINE
puts chars
lcount = 0
chars = ""
end
end
Aufruf:
ruby hexdump.rb file
Ausgabebeispiel:
00000000 53 54 41 52 54 20 20 20 START 00000008 20 20 20 20 20 20 20 3D = 00000010 20 30 78 30 30 0A 42 59 0x00.BY 00000018 54 45 53 5F 50 45 52 5F TES_PER_ 00000020 4C 49 4E 45 20 3D 20 38 LINE = 8 00000028 0A 0A 70 6F 73 20 3D 20 ..pos = 00000030 30 0A 6C 63 6F 75 6E 74 0.lcount 00000038 20 3D 20 30 0A 63 68 61 = 0.cha 00000040 72 73 20 3D 20 22 22 0A rs = "". 00000048 0A 0A 41 52 47 46 2E 65 ..ARGF.e 00000050 61 63 68 5F 62 79 74 65 ach_byte 00000058 20 64 6F 20 7C 62 7C 0A do |b|. 00000060 20 20 69 66 20 70 6F 73 if pos 00000068 20 3C 20 53 54 41 52 54 < START 00000070 0A 20 20 20 20 70 6F 73 . pos
28.02.2005 :: Klasse eines Objekts checken
s = "Bin ein String"
case s
when String
puts "Ist ein String"
when Array
puts "Ist ein Array"
when IO
puts "Ist ein IO"
else
puts "Unbekannter Typ"
end
28.02.2005 :: 512MB 0-Byte Datei erzeugen
Um einen 512MB großen Memorystick zu testen, wollte ich eine 0-Byte und eine 0xFF-Byte Datei erzeugen, die über den gesamten Speicherraum des Sticks geht. Ich hatte die Vermutung, dass bestimmte Bytes auf dem Stick defekt sind. Später konnte ich dann mit einem Hexeditor überprüfen, ob alle Bytes korrekt geschrieben sind. Auch md5sum half dabei.
Das folgende Programm erzeugt also eine etwa 500MB große Testdatei:
f = File.new("e:\\test_00.bin", "w+")
x = 0
puts "Erzeuge Datei..."
(1024*499).times do
f.print "\x00"*1024
if (x+=1) == 1000
print "."
x = 0
end
end
f.close