396 lines
9.2 KiB
Plaintext
Executable File
396 lines
9.2 KiB
Plaintext
Executable File
#!/bin/perl5
|
|
# $Modified: Thu Aug 7 14:25:02 1997 by cwilson $
|
|
# $Revision: 1.2 $
|
|
#
|
|
# churn annex portsfile into ktools nis map.
|
|
#
|
|
|
|
print "$0: invoked as $0 @ARGV\n";
|
|
|
|
require 'newgetopt.pl';
|
|
|
|
&NGetOpt('u', 'kwho=s', 'kreset=s', 'kcons=s', 'version=s');
|
|
|
|
# note that you can't specify these arguments and command-line switches.
|
|
#
|
|
$PORTSFILE = $ARGV[0] || '/var/domain/ktools.configuration';
|
|
$MAPFILE = $ARGV[1] || '/var/domain/ktools.map';
|
|
$CONFIGDIR = $ARGV[2] || '/var/domain/annex-config/';
|
|
|
|
|
|
&ReadPortsfile;
|
|
|
|
open ($MAPFILE, ">$MAPFILE")
|
|
|| die "Couldn't open $MAPFILE, $!\n";
|
|
|
|
# print classes available
|
|
#
|
|
print $MAPFILE "classes\t" . join('`', keys %{$Class}) . "\n\n";
|
|
|
|
# print class config
|
|
#
|
|
foreach (sort keys %{$Class}) {
|
|
print $MAPFILE $_ . "_config\t";
|
|
print $MAPFILE join('`',
|
|
$Class->{$_}->{desc} || 'description here',
|
|
$Class->{$_}->{owner} || 'owner here',
|
|
$Class->{$_}->{email} || 'email here',
|
|
666,
|
|
join(',', @{$Class->{$_}->{connectors}}),
|
|
);
|
|
print $MAPFILE "\n";
|
|
}
|
|
print $MAPFILE "\n\n";
|
|
|
|
# print the annexes available
|
|
#
|
|
# OLD # strip out the sgi.com bit because the value is too large for a dbm map!
|
|
#
|
|
# NEW: if length is > 1k then split up into multiple keys.
|
|
#
|
|
|
|
$joined_connectors = join('`', keys %{$Connector});
|
|
|
|
if ( length($joined_connectors) > 1000) {
|
|
$connector_count++;
|
|
|
|
while (($key, $value) = each %{$Connector} ) {
|
|
$connectors{$connector_count} .= "$key`";
|
|
if (length ($connectors{$connector_count}) > 1000) {
|
|
$connector_count++;
|
|
}
|
|
}
|
|
|
|
foreach (sort keys %connectors) {
|
|
chop $connectors{$_};
|
|
print $MAPFILE "(connectors_$_)\t" . $connectors{$_} . "\n";
|
|
$all_connectors .= "(connectors_$_) ";
|
|
}
|
|
print $MAPFILE "_connectors\t$all_connectors\n";
|
|
|
|
}
|
|
|
|
$joined_connectors =~ s/.sgi.com//g;
|
|
|
|
print $MAPFILE "annexes\t" . $joined_connectors . "\n\n";
|
|
|
|
|
|
# print each annex's config
|
|
#
|
|
foreach (sort keys %{$Connector}) {
|
|
print $MAPFILE $_ . "_config\t";
|
|
print $MAPFILE join('`',
|
|
$Connector->{$_}->{ports},
|
|
$Connector->{$_}->{boot},
|
|
$Connector->{$_}->{loc},
|
|
$Connector->{$_}->{owner},
|
|
$Connector->{$_}->{email},
|
|
$Connector->{$_}->{type},
|
|
);
|
|
print $MAPFILE "\n";
|
|
}
|
|
print $MAPFILE "\n\n";
|
|
|
|
# print the machine configuration, and extract the connector, so that
|
|
# we can list the machines hooked up to each connector.
|
|
# also extract the rtelnet-able ports.
|
|
#
|
|
foreach (sort keys %{$Object}) {
|
|
print $MAPFILE "$_\t";
|
|
|
|
local($consoles, $debugs);
|
|
($consoles = $Object->{$_}->{consoles}) =~
|
|
s/(r?)(\d+)/sprintf("$1%.2d", $2)/ge;
|
|
($debugs = $Object->{$_}->{debugs}) =~
|
|
s/(r?)(\d+)/sprintf("$1%.2d", $2)/ge;
|
|
|
|
print $MAPFILE join('`',
|
|
$Object->{$_}->{desc},
|
|
$Object->{$_}->{cputype},
|
|
$Object->{$_}->{mktgtype},
|
|
$Object->{$_}->{chassis},
|
|
$Object->{$_}->{gfx},
|
|
$Object->{$_}->{memory},
|
|
$Object->{$_}->{hw},
|
|
$Object->{$_}->{loc},
|
|
$Object->{$_}->{asset},
|
|
$Object->{$_}->{serial},
|
|
$Object->{$_}->{notes},
|
|
$Object->{$_}->{owner},
|
|
$Object->{$_}->{email},
|
|
666,
|
|
$Object->{$_}->{ports},
|
|
$Object->{$_}->{connector},
|
|
$Object->{$_}->{reset_method},
|
|
$consoles,
|
|
$debugs,
|
|
666,
|
|
);
|
|
print $MAPFILE "\n";
|
|
|
|
push (@{$xref{ $Object->{$_}->{connector} } }, $_);
|
|
|
|
if ($Object->{$_}->{consoles} =~ /r/) {
|
|
foreach $c ( split(',', $Object->{$_}->{consoles})) {
|
|
$rtelnetd_con .= "$_:$c`"
|
|
if $c =~ s/r//;
|
|
}
|
|
}
|
|
|
|
if ($Object->{$_}->{debugs} =~ /r/) {
|
|
foreach $c ( split(',', $Object->{$_}->{debugs})) {
|
|
$rtelnetd_dbg .= "$_:$c`"
|
|
if $c =~ s/r//;
|
|
}
|
|
}
|
|
}
|
|
|
|
# print list of machines connected to each annex
|
|
#
|
|
foreach (sort keys %xref) {
|
|
print $MAPFILE $_ . "_machines\t";
|
|
print $MAPFILE join('`', sort @{$xref{$_}});
|
|
print $MAPFILE "\n";
|
|
}
|
|
|
|
# print rtelnetd entries
|
|
#
|
|
print $MAPFILE "rtelnetd_con\t$rtelnetd_con\n" if $rtelnetd_con;
|
|
print $MAPFILE "rtelnetd_dbg\t$rtelnetd_dbg\n" if $rtelnetd_dbg;
|
|
|
|
# now add the version tags for the ktools programs:
|
|
#
|
|
# Evil evil evil
|
|
#
|
|
if (!$opt_kwho) {
|
|
$foo = `grep rcsversion kwho.c`;
|
|
($kwho_version) = $foo =~ /(\d\.\d+)/;
|
|
} else {
|
|
$kwho_version = $opt_kwho;
|
|
}
|
|
print $MAPFILE "kwho_version\t$kwho_version\n";
|
|
|
|
if (!$opt_kcons) {
|
|
$foo = `grep Revision kcons`;
|
|
($kcons_version) = $foo =~ /(\d\.\d+)/;
|
|
} else {
|
|
$kcons_version = $opt_kcons;
|
|
}
|
|
print $MAPFILE "kcons_version\t$kcons_version\n";
|
|
|
|
if (!$opt_kreset) {
|
|
$foo = `grep Revision kreset`;
|
|
($kreset_version) = $foo =~ /(\d\.\d+)/;
|
|
} else {
|
|
$kreset_version = $opt_kreset;
|
|
}
|
|
print $MAPFILE "kreset_version\t$kreset_version\n";
|
|
|
|
# Add a timestamp, so that rtelnetd can know when to update.
|
|
#
|
|
print $MAPFILE "timestamp\t" . time . "\n";
|
|
|
|
|
|
# Now, update annex configurations
|
|
#
|
|
foreach $connector (sort keys %xref ) {
|
|
|
|
# skip if not an annex
|
|
next if $Connector->{$connector}->{type} !~ /annex/i;
|
|
|
|
undef %ports_used;
|
|
|
|
rename ( "$CONFIGDIR/$connector.config",
|
|
"$CONFIGDIR/$connector.config.old" );
|
|
open (FILE, '>' . "$CONFIGDIR/$connector.config")
|
|
|| warn "unable to open $CONFIGDIR/$connector.config for writing, $!";
|
|
|
|
print FILE "# Changes to the some annexes CU device configuration\n";
|
|
print FILE "# Effective: " . `date` . "\n\n";
|
|
print FILE "annex $connector\n\n";
|
|
|
|
# iterate through each machine
|
|
#
|
|
foreach $ob ( sort @{$xref{$connector}} ) {
|
|
$ref = $Object->{$ob};
|
|
|
|
# iterate through each console and debug port
|
|
$portcount = 0;
|
|
foreach ( split(/,/, $ref->{consoles})) {
|
|
s/r//;
|
|
print FILE "set port=$_ location\t\"" . $ref->{name} . '.con.' .
|
|
$portcount++ . "\"\n";
|
|
print FILE "set port=$_ mode \"slave\"\n";
|
|
$ports_used{$_}++;
|
|
}
|
|
|
|
$portcount = 0;
|
|
foreach ( split(/,/, $ref->{debugs})) {
|
|
s/r//;
|
|
print FILE "set port=$_ location\t\"" . $ref->{name} . '.dbg.' .
|
|
$portcount++ . "\"\n";
|
|
print FILE "set port=$_ mode \"slave\"\n";
|
|
$ports_used{$_}++;
|
|
}
|
|
}
|
|
|
|
# now mark all the other ports unused if we know how many ports
|
|
# this annex has
|
|
#
|
|
if ($Connector->{$connector}->{ports}) {
|
|
for ($i = 1; $i < $Connector->{$connector}->{ports}; $i++) {
|
|
next if $ports_used{$i} || $ports_used{ sprintf('%.2d', $i) };
|
|
print FILE "set port=$i location\t\"unknown\"\n";
|
|
print FILE "set port=$i mode \"slave\"\n";
|
|
}
|
|
}
|
|
|
|
close FILE;
|
|
}
|
|
|
|
|
|
# push new config to annexes if desired
|
|
if ($opt_u) {
|
|
foreach $connector (sort keys %xref ) {
|
|
|
|
# skip if not an annex
|
|
if ($Connector->{$connector}->{type} !~ /annex/i) {
|
|
print "not updating $connector, not an annex [$Connector->{$connector}->{type}]" .
|
|
" or an unknown connector.\n";
|
|
next;
|
|
}
|
|
# only push if changes
|
|
if (`diff $CONFIGDIR/$connector.config $CONFIGDIR/$connector.config.old | wc -l` > 4) {
|
|
print "updating $connector\n";
|
|
print `/usr/annex/na < $CONFIGDIR/$connector.config`;
|
|
} else {
|
|
print "not updating $connector, insufficient differences.\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
#======================================================================
|
|
# Read the portsfile...
|
|
#
|
|
sub ReadPortsfile {
|
|
|
|
@Mach_Vars = (
|
|
name,
|
|
desc,
|
|
cputype,
|
|
mktgtype,
|
|
chassis,
|
|
gfx,
|
|
memory,
|
|
hw,
|
|
loc,
|
|
asset,
|
|
serial,
|
|
notes,
|
|
owner,
|
|
email,
|
|
ext,
|
|
ports,
|
|
connector,
|
|
reset_method,
|
|
consoles,
|
|
debugs,
|
|
access,
|
|
);
|
|
|
|
@Annex_Vars = (
|
|
name,
|
|
ports,
|
|
boot,
|
|
loc,
|
|
owner,
|
|
email,
|
|
ext,
|
|
);
|
|
|
|
@Class_Vars = (
|
|
name,
|
|
desc,
|
|
owner,
|
|
uname,
|
|
ext,
|
|
connectors,
|
|
);
|
|
|
|
|
|
open(P, $PORTSFILE) || die "unable to open $PORTSFILE, $!";
|
|
|
|
$tag = <P>;
|
|
|
|
if ($tag !~ /Version 2/) {
|
|
|
|
# slurp in a whole definition.
|
|
#
|
|
$/ = ")\n";
|
|
|
|
while (<P>) {
|
|
|
|
split(/\n/);
|
|
|
|
# ignore commentary
|
|
#
|
|
while ($_[0] =~ /^\#/) {
|
|
shift @_;
|
|
}
|
|
|
|
# remove leading, trailing markers
|
|
$_[0] =~ s/\(//;
|
|
pop @_;
|
|
|
|
$what = shift(@_);
|
|
|
|
grep(s/^\s+(.*)\s+\#.*$\n*/$1/g, @_ ); # remove leading whitespace
|
|
grep(s/\s*$//, @_); # nuke trailing whitespace and newline
|
|
# and trailing comment
|
|
# name of object
|
|
#
|
|
$ob = $_[0];
|
|
next if ! $ob;
|
|
|
|
if ($what =~ /^annex/ || /^connector/) {
|
|
foreach (@Annex_Vars) {
|
|
$Connector->{$ob}->{$_} = shift(@_);
|
|
}
|
|
} elsif ($what =~ /^class/) {
|
|
foreach (@Class_Vars) {
|
|
$Class->{$ob}->{$_} = shift(@_);
|
|
}
|
|
$Class->{$ob}->{connectors} =
|
|
[ split( /,/, $Class->{$ob}->{connectors} ) ];
|
|
} elsif ($what =~ /^machine/ || $what =~ /^object/) {
|
|
# slurp info into hashed struct.
|
|
#
|
|
foreach (@Mach_Vars) {
|
|
$x = shift(@_);
|
|
$Object->{$ob}->{$_} = $x if length($x);
|
|
}
|
|
|
|
# tie the connector ports to the object
|
|
#
|
|
if (0) {
|
|
foreach $c (split(',', $Object->{$ob}->{'consoles'}),
|
|
split(',', $Object->{$ob}->{'consoles'}) ) {
|
|
$c =~ s/r//;
|
|
push ( @{ $Connector->{ $Object->{$ob}->{'connector'} }
|
|
->{'port'}->{$c} },
|
|
$Object->{$ob} );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
# version 2
|
|
@x = <P>; # <burp>
|
|
eval (join('', @x));
|
|
print;
|
|
}
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|