(Message newsletter:11)
Return-Path: <treese@mit-theseus>
Received: from mit-theseus (mit-theseus.ARPA) by mit-jason (4.12/4.7)
	id AA06679; Thu, 14 Feb 85 16:59:46 est
Received: by mit-theseus (4.12/4.7)
	id AA13230; Thu, 14 Feb 85 17:06:55 est
From: treese@mit-theseus (Win Treese)
Message-Id: <8502142206.AA13230@mit-theseus>
Date: 14 Feb 1985 1706-EST (Thursday)
To: lbm@mit-theseus
Subject: Consultant's corner for March newsletter


Here it is.   If you have any suggestions, let me know.

	Thanks,
	  Win

=========================================================================
@device(Imprint10)
@style(font computermodernroman10)
@heading(Consultant's Corner)
@i(Win Treese, Student Consultant Staff)

Beginning this term, many users of Project Athena computers will find
themselves with accounts on more than one machine.  In most cases, one
account will be on one of the Student Center machines (often referred
to as the "W20 cluster" or "Ringworld"), and one will be on a computer
used by a particular class.  Students in two classes using Project
Athena machines may also have two accounts, one for each class.  Each
account should be under the same username, however.

There are several commands available on the system to make life easier
when you have more than one account.  These include @b(rlogin, rcp,
rsh, rwho, and ruptime).  The first three are used to communicate with other
computers, and they assume that you have the same username on both machines
involved. The first one, @b(rlogin), allows you to
log in to another machine.  Its general syntax is

@begin(example)
rlogin <@i[machine-name]>
@end(example)

The following command, for example, will log you in to mit-speaker in the
Student Center, assuming that you have an account there.

@begin(example)
mnemosyne% rlogin speaker
@end(example)

You could also just type @b(speaker) as an
abbreviation.  When you log out of speaker, you will be back on your
original machine (in this case, mnemosyne).

The command @b(rcp) stands for "remote copy".  It allows you to copy
files from one machine to another.  It behaves much like @b(cp),
except that you must specify either a source machine or a destination
machine.  It takes two forms:

@begin(example)
rcp @i(file1 file2)

or

rcp @i(file1 file2 ... directory)
@end(example)

Each argument @i(file) is either a normal file on the local machine
or a remote file named as in "machine:filename", where "machine" is
the computer that the file is on.  The argument @i(directory) also has
this form, except that it names a directory.
For example, if you are logged on to mnemosyne,

@begin(example)
mnemosyne% rcp speaker:.cshrc .cshrc
@end(example)

will copy your ".cshrc" file from speaker to mnemosyne.  To go the
other way, try

@begin(example)
mnemosyne% rcp .cshrc speaker:.cshrc
@end(example)

You can also use "wildcards" like '*' or '?' to specify files.  If
you want to specify files using wildcards on the remote machine, you
must quote them using a backslash, '\', or quotation marks. So, to
copy all of the files beginning with the letter 'a' in your home directory
on speaker to mnemosyne, you would type

@begin(example)
mnemosyne% rcp speaker:a\* .
@end(example)

The '.' specifies your current directory on mnemosyne, just as it
normally does.

Another useful command is @b(rsh), which stands for "remote shell".
It allows you to execute a command on another machine.  Again
suppose that you are logged in to mnemosyne and you also have an
account on speaker.  If you wanted to, say, list the files that you
have on speaker without actually logging in to it, you could type

@begin(example)
mnemosyne% rsh speaker ls
myfile
paper.mss
paper.lpt
test.c
@end(example)

In general, you would type

@begin(example)
rsh <@i(machine-name)> <@i(command)>
@end(example)

where <command> is any valid UNIX command (there are a few commands
that won't work properly; they are generally interactive programs like
@b(emacs)).  As with @b(rcp), you can use wildcard characters, but
they must be quoted to work correctly.

Finally, there are two commands for finding information about what is
happening on the network: @b(ruptime) and @b(rwho).  The command @b(ruptime)
is like @b(uptime), but it tells you about the machines in your cluster.
For example, running @b(ruptime) on mnemosyne shows something like:

@begin(example)
mnemosyne% ruptime
mit-calliope  up 15+04:09,     3 users,  load 1.29, 1.34, 1.21
mit-clio      up  9+01:38,     1 user,   load 0.42, 0.34, 0.25
mit-erato     up 15+04:09,     4 users,  load 0.20, 0.42, 0.50
mit-euterpe   up 15+04:09,     1 user,   load 0.07, 0.06, 0.06
mit-mnemosyn  up 15+04:10,     6 users,  load 1.12, 1.08, 0.83
mit-polyhymn  up 14+02:25,     4 users,  load 1.21, 0.77, 0.53
mit-urania    up  1+19:17,     0 users,  load 0.05, 0.07, 0.06
@end(example)

Each line contains the name of a machine, how long it has been up,
how many users are on it, and what the load average is.  If a machine
were down, this would be noted in the "up" column; sometimes, however,
a machine may be listed as "down" when it is merely not communicating with
the other machines.

The second information command is @b(rwho).  It is much like @b(who), but
it lists everyone who is logged on in your cluster.  On mnemosyne, its
output might look something like:

@begin(example)
mnemosyne% rwho 
*aruser  mit-euterpe:tty01    Feb 13 15:16
*someone mit-calliope:tty02   Feb 13 14:58 :01
aruser   mit-mnemosyne:ttyp1  Feb 13 15:15
paulgray mit-polyhymnia:tty03 Feb 12 07:56
someone  mit-polyhymnia:ttyp0 Feb 12 09:17
@end(example)

A '*' in front of a name means that the user is logged in to a machine
through the login server on the listed computer.  Otherwise, the user is
logged in to the machine shown.

As always, there is more to these commands than is mentioned here.  Detailed
information may be found in the UNIX manual, available in the Project Athena
terminal rooms or on-line by using the @b(man) command.


