Softpanorama

May the source be with you, but remember the KISS principle ;-)
Home Switchboard Unix Administration Red Hat TCP/IP Networks Neoliberalism Toxic Managers
(slightly skeptical) Educational society promoting "Back to basics" movement against IT overcomplexity and  bastardization of classic Unix

Solaris Jumpstart

Old News ;-)

See also

 Books Recommended Links Jumpstart-related Blueprints Selected Blueprints Selected man pages Presentations
Boot Server Install Server Rules file Finish scripts DHCP Usage for boot server Tips Random Findings Etc

The Jumpstart is pretty neat NFS-based installation process for Solaris available for both UltraSparc and x86. It provides flexible "unattended installation" allowing system administrators to categorize machines on their network and install different system components or even versions of OS based on the category to which a system belongs. It also provides the infrastructure to preserve installation information from one generation of sysadmins to another.

In its simplest form the Jumpstart process involves the following stages (RARP based IP address retrieval is OK for installation from "Jumpstart laptop" via crossover cable which is the classic way to use Jumpstart; if the images are somewhere on the the bootable CD/DVD is the way to go):

  1. Admin issues the boot net - install command from the 'ok' prompt of the client
     
  2. Client machine broadcasts a RARP request to the local subnet
     
  3. The Boot Server responds via RARPD (in.rarpd) with the IP address in /etc/ethers (or the ethers NIS map depending on the ethers setting in /etc/nsswitch.conf ) matching the hostname listed for the client's MAC address in the server's /etc/ethers file
     
  4. The client sends a tftp request for a bootimage.
     
  5. On the boot server, the "inetd" daemon listens for and handles tftp requests. After receiving the tftp request it spawns the  in.tftpd daemon to handle this request. . The server starts in.tftp from inetd and sends the small net kernel image. This way the Jumpstart boot image is sent back to the client
     
  6. Client downloads and boots the boot image
     
  7. Client starts bootparams client and requests boot information from Boot Server:  boot image issues a hostconfig request  for boot parameters.
     
  8. rpc.bootparams server on Boot Server responds to a hostconfig request with the NFS location of a Jumpstart directory, an install-root filesystem, and the location of sysidcfg directory. rpc.bootparamd is a server process that usually provides information from a bootparams database to diskless clients at boot time. Under Solaris rpc.bootparamd usually is started by the nfs.server init script if the directory /tftpboot exists.
     
  9. Client NFS-mounts Boot Server's Jumpstart directory as its root filesystem. After that client NFS-mounts Install server's Jumpstart directory and launches Solaris install
     
  10. Solaris install on the client begins "System Indentification" stage of install. You might recognize this stage as where the install program asks for host, network, locale, date and time information. Client NFS-mounts the sysidcfg directory it was given by the rpc.bootparams daemon on the Boot server.
     
  11. Client reads host configuration information from the configuration  file named 'sysidcfg' inside the sysidcfg directory it has mounted. Client switched to interactive mode for any information not contained in this file
     
  12. Client begins "System Install" stage of install. If you are familiar with CD installs of Solaris, you will recognize this stage as where the install program asks you to choose a partition layout for system and to choose a package cluster/and or individual software packages to install.
     
  13. Client finds line matching it's own system architecture, hostname, IP address, etc. in 'rules.ok' text file in Install server's Jumpstart directory. From this line the Client retrieves the name of a begin-script, profile, and finish-script. The profile is a text file, the begin and finish scripts Bourne shell scripts. All three files are located in the Install server's Jumpstart directory
     
  14. Client executes the begin-script, if any
     
  15. Client partitions and formats its disks according to rules in its profile
     
  16. Client installs software packages according to rules in its profile
     
  17. Client installs any system patches found in the Install server's Jumpstart/Patches directory, if any. It installs these patches in date-wise order (that is to say according to their time-stamps) from oldest to newest
     
  18. Client executes the finish scripts, if any. Note that we did not rebooted the computer yet, so available to us tools are limited. Usually it makes more sense to reboot the computer, connect to it using ssh and execute finish scripts at this point.
     
  19. Client reboots

Among positive features:

  1. Simplifies installations  and permits its automation
  2. Faster and less tedious then CD-ROM installation as most answers can be preprogrammed and there is not need to change disks.
  3. Allows unattended/automatic  installation with post-processing (for example, hardening using JASS)
  4. Replication - creation of multiple identical or semi-identical systems across the enterprise

Among negative features:

Top Visited
 Switchboard
Latest
Past week
Past month

NEWS CONTENTS

Old News ;-)

[May 20, 2010] Solaris x86 jumpstart on ISC DHCP

February 18th, 2008 | A look into Solaris, by Derek Crudgington

If you are using the Solaris dhcp server, stop now. Save yourself hours of time of trying to figure out pntadm, dhtadm, and just use ISC DHCP on Solaris. It's very simple, painless, and you will be glad you did. The only problem I ran across was compiling the ISC dhcp straight off the website, it compiled fine, but I ran into issues where it wouldn't see packets properly. So I just used the one off Blastwave instead. Here's how to get a jumpstart going with ISC:

- CD setup

Copy the CD contents to an existing directory:

# /cdrom/Solaris_11/Tools/setup_install_server /jumpstart/solx86b81

Set the /jumpstart directory shared NFS:

# zfs set sharenfs=ro,anon=0 pool/jumpstart

- Jumpstart configuration

Create /jumpstart/configs/sysidcfg, /jumpstart/configs/any_machine and /jumpstart/configs/rules:

sysidcfg:

system_locale=C
timezone=US/Central
terminal=xterms
security_policy=NONE
root_password=yTUdfabsalkjfE
timeserver=localhost
network_interface=primary
{dhcp
protocol_ipv6=no}
name_service=NONE
nfs4_domain=dynamic
service_profile=limited_net

any_machine:

install_type initial_install
system_type standalone
partitioning default
cluster SUNWCXall
fdisk all solaris all
partitioning explicit
filesys rootdisk.s0 20000 /
filesys rootdisk.s1 20000 swap
filesys rootdisk.s7 free /zfs

rules:

any - - any_machine -

Run /jumpstart/configs/check to create the rules.ok file:

# /jumpstart/configs/check

- Client setup

Run the add_install_client tool, this creates everything in /tftpboot:

# /cdrom/Solaris_11/Tools/add_install_client -d -e 06:00:00:00:00:00 -s 192.168.0.177:/jumpstart/solx86crossbow -c 192.168.0.177:/jumpstart/configs -p 192.168.0.177:/jumpstart/configs -t /jumpstart/solx86crossbow/boot i86pc

-d : it will be a dhcp client
-e : mac address of client
-s : ip and directory of where cd is located
-c : ip and directory of where rules file is located
-p : ip and directory of where the sysidcfg is located
-t : path where the boot image is located

- ISC DHCP configuration

The ISC DHCP 4 off of the ISC website compiles fine and runs fine, but doesn't see DHCP requests properly. This is due to the Solaris DLPI issue described here. There is a fix to uncomment a line in the code but then it doesn't compile properly.

The ISC dhcp that comes out of Blastwave is version 3 and it works fine seeing requests and sending them.

- Configuration

Configuration of ISC DHCP is very simple and painless, especially if you are used to Solaris DHCP. Most of the options in the configuration file are self explanatory and you don't even need to look up what they mean (if you are familiar with how DHCP works).

Here's the dhcpd.conf for jumpstart (values will need to be changed depending on your network):

option domain-name-servers 192.168.0.1;
default-lease-time 1000;
max-lease-time 10000;
allow bootp;
allow booting;

ddns-update-style none;
ignore unknown-clients;

authoritative;

option space SUNW;
option SUNW.root-mount-options code 1 = text;
option SUNW.root-server-ip-address code 2 = ip-address;
option SUNW.root-server-hostname code 3 = text;
option SUNW.root-path-name code 4 = text;
option SUNW.swap-server-ip-address code 5 = ip-address;
option SUNW.swap-file-path code 6 = text;
option SUNW.boot-file-path code 7 = text;
option SUNW.posix-timezone-string code 8 = text;
option SUNW.boot-read-size code 9 = unsigned integer 16;
option SUNW.install-server-ip-address code 10 = ip-address;
option SUNW.install-server-hostname code 11 = text;
option SUNW.install-path code 12 = text;
option SUNW.sysid-config-file-server code 13 = text;
option SUNW.JumpStart-server code 14 = text;
option SUNW.terminal-name code 15 = text;
option SUNW.SbootURI code 16 = text;

subnet 192.168.0.0 netmask 255.255.255.0 {
range 192.168.0.100 192.168.0.250;
option subnet-mask 255.255.255.0;
option broadcast-address 192.168.0.255;
option routers 192.168.0.1;
}

group {
use-host-decl-names on;
vendor-option-space SUNW;

filename "pxegrub.I86PC.Solaris_11-1″;
next-server 192.168.0.177;
option SUNW.JumpStart-server "192.168.0.177:/jumpstart";

host box {
hardware ethernet 00:e0:81:33:74:d4;
fixed-address 192.168.0.50;
option SUNW.sysid-config-file-server = "192.168.0.177:/jumpstart/configs/sysidcfg";
}
}

The *filename* option may change between Solaris versions, so check your /tftpboot directory for the pxegrub image that exists in there.

- Starting ISC dhcp

ISC dhcpd has a few options and is run like:

# /opt/csw/sbin/dhcpd interface0

If you run it without interface0 it will run on all interfaces.

-d : debug mode
-cf : alternate configuration file
-lf : alternate lease file
-p : port (default 67)
-f : run in foreground
-q : don't print out copyright message
-t : test configuration for correct syntax
-T : test lease file syntax

When dhcpd is started, it reads two files at startup: the dhcpd.conf configuration file, and the leases file. The lease file holds all of the dhcp leases it gives out and by default is at /var/db/dhcpd.leases. For the Blastwave installation, it is at /var/opt/csw/dhcp/dhcpd.leases. You may need to create this file first before starting dhcpd. The pid file for the daemon is at /var/opt/csw/dhcp/dhcpd.pid.

For debugging, the best way to run it is:

# /opt/csw/sbin/dhcpd -d -f -cf /path/to/dhcpd.conf

Posted in Network Install, General | 1 Comment "

[May 19, 2010] Discussion Sun Certified Solaris Administrator LinkedIn

Yogesh Raheja:

Jumpstart server for x-86 (solaris intel) in vmware?
I have one Solaris 10 virtual machine on vmware, I made it a jumpstart server for automated installation testing. As it is different than sparc versions so getting some errors while installing the machines through jumpstart. Can anyone plz share there experiences in this.
Thanks Heaps,

Muhammad Anwar:

http://www.sun.com/bigadmin/features/articles/jumpstart_x86_x64.jsp

Chafik Belhaoues:

You just need to specify the architecture while installing that's it I've done that a billion of times have fun

Yogesh Raheja:

Following are the files setting and the errors I am getting..:(

Geeting errors while Installing a x-86 (solaris 10 server) through jumpstart?

yogesh$./add_install_client -i xxxxxxxxx -e xxxxxxx -s yogesh:/export/install -p yogesh:/export/config -c yogesh:/export/config test i86pc
cleaning up preexisting install client "test"
removing test from bootparams
removing /etc/bootparams, since it is empty
rm: /tftpboot/ is a directory
enabling network/rarp service
updating /etc/bootparams
copying boot file to /tftpboot /pxegrub.I86PC.Solaris_10-1
ln: cannot create /tftpboot/ /pxegrub.I86PC.Solaris_10-1 : File exists

Create a grub floppy and edit GRUB menu to contain
the following entry:
min_mem64 1024
title Solaris netinstall
rarp
kernel$ /I86PC.Solaris_10-1/multiboot kernel/$ISADIR/unix -B install_media=yogesh:/export/install,install_boot=yogesh:/export/install/boot
module$ /I86PC.Solaris_10-1/$ISADIR/x86.miniroot

=================

Grub entries:
--------------------
#---------- ADDED BY BOOTADM - DO NOT EDIT ----------
title Solaris 10 10/09 s10x_u8wos_08a X86
findroot (rootfs0,0,a)
kernel /platform/i86pc/multiboot
module /platform/i86pc/boot_archive
#---------------------END BOOTADM--------------------
#---------- ADDED BY BOOTADM - DO NOT EDIT ----------
title Solaris failsafe
findroot (rootfs0,0,a)
kernel /boot/multiboot kernel/unix -s
module /boot /x86.miniroot-safe
#---------------------END BOOTADM--------------------
min_mem64 1024
title Solaris netinstall
rarp
kernel$ /I86PC.Solaris_10-1/multiboot kernel/$ISADIR/unix -B install_media=yogesh:/export/install,install_boot=yogesh:/export/install/boot
module$ /I86PC.Solaris_10-1/$ISADIR/x86.miniroot

==================

yogesh$ls -lrt
total 184
-r-xr-xr-x 1 root root 17375 May 16 02:57 analyze_patches
dr-xr-xr-x 2 root root 512 May 16 02:57 database
-r--r--r-- 1 root root 685 May 16 02:57 x86-begin
dr-xr-xr-x 3 root root 512 May 16 02:57 jumpstart_sample
-r--r--r-- 1 root root 4738 May 16 02:59 original_rules
-rw-r--r-- 1 root root 220 May 16 03:04 x86-class
-r-xr-xr-x 1 root root 64357 May 16 03:07 check
-rw-r--r-- 1 root root 300 May 16 03:37 sysidcfg
-rw-r--r-- 1 root root 91 May 16 03:59 rules.ok
-rw-r--r-- 1 root root 108 May 16 04:01 rules
yogesh$

=======================

yogesh$more rules
# The following rule matches any system:

any - - any_machine -
arch i386 x86-begin x86-class -

yogesh$

================

yogesh$more sysidcfg
network_interface=e1000 {hostname=test
ip_address=xxxxxxxxx
netmask=xxxxxxxx
protocol_ipv6=no
default_route=NONE}
timezone=US/Central
security_policy=NONE
root_password=R1bVELFZUDF9U
name_service=NONE
timeserver=localhost
system_locale=en_US

=================

Any suggestion will be highly appreciated.
Posted 2 days ago

Sigbjorn Lie:

Have a look at sun.com for JET (Jumpstart Enterprise Toolkit). That will do it easily for you.

Ersen ELMAOGULLARI:

More accurate address is http://wikis.sun.com/display/JET

Bruce Porter:

Also, worth signing up to the [email protected] list/forum, JET module authors external to Sun can supply help.

The JET templates make switching between x86/sparc installs very simple.

Some FAQ (and resource) pages exist at
http://jet.maui.co.uk/wiki/index.php/Faq

The "7 step" guide is at http://www.sun.com/bigadmin/content/jet/

[Sep 8, 2008] BigAdmin Description - Less Known Solaris Features - Jumpstart Enterprise Toolkit

Description: A sixteen part tutorial about the configuration of the Jumpstart Enterprise Toolkit (JET).

Jumpstart and Jet have several ways and means to do an automatic installation, thus making the live of the admin much easier after you´ve done the initial setup.

This tutorial will show you that this setup is really easy.

[Apr 2, 2007] BigAdmin Feature Article Using Solaris JumpStart With the Solaris 10 OS for x86-x64 Platforms

... Using Solaris JumpStart software on the Solaris 10 OS for x86/x64 platforms is essentially the same as on Solaris 10 OS for SPARC platforms. However, there are some subtle differences that need to be addressed for correct operation.

This document provides the steps and explanations necessary to set up a JumpStart server for the Solaris 10 OS on a Sun x86/x64 machine, along with configuring JumpStart for two or more clients.

As a general reference, refer to the Sun online document Using Custom JumpStart.

[Jan 7, 2007] BigAdmin Submitted Article UberJS A More Flexible Solaris JumpStart System by by John Dickerson and Brett Trotter, Iowa State University

Extracting the Slices from the CD (Creating a Work Space)
Modifying the Images
Modifying the JumpStart Scripts
uberjs-exec Script
Install Configuration Files on the CD
Configuration Files for All Options
The UberJS sysidcfg File on the JumpStart Server
Burning the CD-ROM
Creating an ISO Image
Credits
References
About the Authors

Installing the Solaris Operating System usually comes down to a choice between using CDs or JumpStart. Nobody wants to install more than a couple of machines using CDs and a generic configuration, so most administrators use Sun's Solaris JumpStart software if they want to customize their builds.

JumpStart is a powerful tool that makes unattended Solaris installs possible with fine-grained control over machine configurations, but it has a few shortcomings. JumpStart is fairly limited in booting flexibility, but is still very capable when it comes to machine profiles. JumpStart only works if the JumpStart boot server is on the same network segment as the machine you're installing, and before you can do a network build of a machine you have to configure the JumpStart server using Sun's add_install_client script. If you've made an error in one of the many JumpStart configuration files and you're down the hall from the server, you can burn through a lot of shoe leather because of a typo.

In the College of Engineering at Iowa State University, we wanted to make JumpStart a little easier. We install Sun boxes on many LANs where we can't afford a JumpStart server or it isn't practical to manage one. For a while we built our machines using JumpStart on an Intel laptop running Linux that we carried from building to building, but the setup time got to be a headache. We needed a solution that was portable, easy to use, and didn't require touching the JumpStart server for every new machine. We wanted to preserve JumpStart's ability to apply different build profiles from a central location, and we wanted unattended install capability.

We've developed a system we call UberJS (for Uber JumpStart). We modeled it after Red Hat's Kickstart so a person can boot a machine from CD, type a simple command and walk away. With some clever hacking of the JumpStart install scripts and a CD burner, we created a bootable JumpStart CD that handles the networking initialization usually provided by a JumpStart boot server, but still allows us to access build profiles in a remote JumpStart or Flash install repository. With the UberJS CD, we can jumpstart machines even when there is no JumpStart server on the LAN. What's more, we incorporated more general configuration files that give us more flexibility and spontaneity than Sun's JumpStart provides.

To understand UberJS, let's first review what happens during a typical JumpStart or Flash install. (Kevin Amorin provides an excellent summary of the process: Solaris JumpStart Automated Installation.)

When you boot a Sun box with boot net - install, it uses reverse ARP to get its IP address from a JumpStart boot server, which has that machine in its ethers list. Once its IP address is determined, the client sends a TFTP request to the server for a network boot kernel image. A symlink must be created in a TFTP directory on the server beforehand, linking the hex version of the IP address of the machine to the boot image for that specific hardware. The client boots and sends an rpc.bootparams request to the boot server that specifies which NFS servers the client is to use for Solaris install packages, sysidcfg (system configuration) settings, and the install profiles. The client then mounts the paths from the NFS servers, reads the sysidcfg settings, determines its build profile, and installs the packages. The rules.ok file on the install profile server tells the Sun installer what profile to use, and each profile dictates either JumpStart or Flash install, which packages to install, and what pre- and post-installation scripts to run (if any). As you might expect, getting this all working can be a little tricky.

UberJS gives us some key improvements over JumpStart:

Keep in mind that UberJS still assumes you have a JumpStart or Flashstart install repository available via NFS that includes predefined build profiles. We won't go into detail about how to set that up here. Use Kevin Amorin's page or JumpStart documentation from Sun for details.

All of our scripts and methods were developed using the Solaris 9 08/03 Release.

Here's a quick summary of what it takes to set up an UberJS build.

  1. Extract the data from a Solaris 9 Install V1 CD and mount the slices for editing.
  2. Add a script called uberjs-exec to the existing scripts. This script performs the essence of the behavior added by UberJS, including prompting you for inputs, setting up the network, downloading configuration files from an FTP server, and processing of UberJS-specific configuration files.
  3. Modify Sun's rcS and sysidfind scripts. Normally, the rcS and sysidfind scripts do most of the network setup and location of server paths. We modify rcS to call uberjs-exec instead to handle the networking and server path mounting. We also add a mechanism to turn off the twirling dial since it interferes with screen prompts. sysidfind usually fetches the sysidcfg file from a network mount and copies it to the miniroot, but since uberjs-exec does all of the mounting and copying, we need to modify the sysidfind script to simply check to see if the file already exists.
  4. Create a few configuration files and either copy them to the CD slices or to an accessible FTP server. The configuration files can be used either to hard code the paths to the JumpStart configuration files or to set up where those files can be downloaded at build time.
  5. Make an ISO image out of the modified slices and burn a new CD.
  6. Boot the client machine with boot cdrom - install.
  7. Sit back and enjoy a hot beverage.

In case you want to cut to the chase, we created a script called mkuber that can automate the entire CD creation process for you. Simply place a Solaris 9 Install V1 CD in the drive and run the script. All that is left to do after the script runs is add any site-specific configuration files, as discussed below. mkuber is available on the UberJS web site. If you wish to perform the alterations manually and/or become more familiar with UberJS, the following methods will create a successful UberJS CD.

[Jan 28, 2006] BigAdmin Submitted Article Server Configuration for Solaris JumpStart Software by Mohammad Shafiuddin Sharif

Looks like a plagiarized from SA-299 (not timezone (US/Mountain) and directories used).

The Solaris 9 Operating System offers an automatic installation process, Solaris JumpStart software. The Solaris JumpStart procedure enables you to install the Solaris OS automatically and configure it differently, depending on the characteristics of client systems. These identifying characteristics are used to select the correct configuration for each client system.

The following tasks are required to configure a single JumpStart server to provide basic software installation services using the JumpStart procedures:

  1. Spool the operating system image.
  2. Edit the sysidcfg file.
  3. Edit the profile and rules.
  4. Run the check script.
  5. Run the add_install_client script.
  6. Boot the client.
Step #1

To spool the Solaris 9 boot and installation images to a local disk, complete the following steps:

Create a directory with at least 800 Mbytes of space available to hold the Solaris OS image. Usually the /export/install directory is used.

# mkdir /export/install

Insert the Solaris 9 Software 1 of 2 CD-ROM in the CD-ROM drive or the Solaris 9 DVD in the DVD drive.

Change the directory to the location of the setup_install_server script.

# cd /cdrom/cdrom0/s0/Solaris_9/Tools

Run the setup_install_server script to copy the Solaris 9 OS installation images to the local disk.

#./setup_install_server /export/install

When the setup_install_server script finishes, change the directory to root (/), and eject the CD-ROM or DVD.

#cd /
#eject cdrom

If you use CD-ROM media, insert the Solaris 9 Software 2 of 2 CD-ROM in the CD-ROM drive.

Change the directory to the location of the add_to_install_server script.

# cd /cdrom/cdrom0/Solaris_9/Tools

Run the add_to_install_server script to copy the remainder of the installation image to the local disk.

#./add_to_install_server /export/install

When add_to_install_server finishes, change the directory to root (/), and eject the CD-ROM.

# cd /
# eject cdrom

Step #2

The sysidcfg file keeps the various types of system information such as locale, time_zone, and so on, and supplies the information to the client at the booting time.

Create a directory to hold the sysidcfg file. Typically the /export/config directory holds the sysidcfg file.

# mkdir /export/config

Change the directory to /export/config, and create a file called sysidcfg using a text editor.

# cd /export/config
# vi sysidcfg

In the sysidcfg file, add the following lines. Substitute values that are appropriate for your systems, location, and network.

network-interface=primary {protocol-ipv6=no
				netmask=255.255.255.0}

security_policy=none
name_service=none
time_zone=US/Mountain
system_locale=en_us

Save the sysidcfg file, and exit your edit session.

Step #3

a. Rules

Create a directory to hold the rules file if this directory does not already exist. Usually, the /export/config directory holds the rules file.

# mkdir /export/config

Change the directory to /export/config, and create a file called rules using a text editor.

# cd /export/config
# vi rules

In the rules file, add the following line: 

hostname client_name - profile1 -

For client_name, substitute the name of your JumpStart client. For example:

hostname	sun1	- profile   -

Save the rules file, and exit your edit session.

b. Profiles

Usually, the /export/config directory holds the profile file.

Change the directory to /export/config, and create a file called profile using a text editor.

# cd /export/config

# vi profile1

Add the following lines to the profile1 file:

install_type	initial_install
system_type	standalone
partitioning	explicit
filesys		c0t0d0s0	 free	/
filesys		c0t0d0s1	128	swap
cluster		SUNWCXall

Save the profile1 file, and exit your edit session.

Step #4

Before a JumpStart client can use a configuration provided by a JumpStart server, you must run the check script to produce a file called rules.ok. The check script validates the syntax of the rules file and the profile files. If the validation completes successfully, the check script creates the rules.ok file.

Change the directory to the location of the check script.

# cd /export/install/Solaris_9/Misc/JumpStart_sample

Copy the check script to the /export/config directory.

# cp check /export/config

Change the directory to /export/config, and run the check script.

# cd /export/config
#./check
Validating rules...
Validating profile profile1...
The custom JumpStart configuration is ok.
Step #5

a. Add a host entry.

Edit the /etc/ethers file, and add an entry for the JumpStart client.

#vi /etc/ethers 

00-C0-26-84-34-A1		sun1

Save and exit from the ethers file.

Edit the /etc/inet/hosts file, and add an entry for the JumpStart client.

#vi /etc/inet/hosts

192.168.1.1	sun1

Save and exit from the hosts file.

b. Add a client.

Change the directory to the location of the add_install_client script on the server.

# cd /export/install/Solaris_9/Tools

Run the add_install_client script, and specify server and client information as follows. (Note: The following line of code should all be entered on one line.) 

#./add_install_client -c server_name:/export/config \
    -p server_name:/export/config client_name platform_group

For example:

#./add-install-client -c sun:/export/config -p sun:/export/config sun1 sun4u

Edit the /etc/dfs/dfstab file to add the following line:

#vi /etc/dfs/dfstab

share -F nfs -o ro, anon=0 /export/install

share -F nfs -o ro, anon=0 /export/config

Save and exit from the dfstab file.

Run the shareall command to share the /export/config and /export/install directories.

#shareall

Verify that the /export/config and /export/install directories are currently shared.

#share
Step #6

Booting the JumpStart Client

After the JumpStart server has been configured to provide all of the required services, you can initiate the installation process on the JumpStart client. To boot the JumpStart client, perform the following steps:

a. Bring the JumpStart client to run state 0.

# init 0

b. Boot the client to initiate the software installation using the JumpStart procedure.

ok boot net - install

docs.sun.com Solaris 9 Installation Guide

Jumpstart can be performed on a stanalone system. In this case floppy should contain rules and profiles and DVD-ROM should contain instllation media

After you validate the rules file and the profiles, you can begin a custom JumpStart installation. The JumpStart program reads the rules.ok file. Then, the JumpStart program searches for the first rule with defined system attributes that match the system on which the JumpStart program is attempting to install the Solaris software. If a match occurs, the JumpStart program uses the profile that is specified in the rule to install the Solaris software on the system.

Figure 22–1 illustrates how a custom JumpStart installation works on a standalone, non-networked system. The system administrator initiates the custom JumpStart installation on Pete's system. The JumpStart program accesses the rules files on the diskette in the system's diskette drive. The JumpStart program matches rule 2 to the system. rule 2 specifies that the JumpStart program use Pete's profile to install the Solaris software. The JumpStart program reads Pete's profile and installs the Solaris software, based on the instructions that the system administrator specified in Pete's profile.

docs.sun.com Solaris 9 Installation Guide

A diskette that contains a JumpStart directory is called a profile diskette. A system that is not connected to the network does not have access to a profile server. As a result, you must create a JumpStart directory on a diskette if a system is not connected to a network. The system on which you create a profile diskette must have a diskette drive.

The JumpStart directory contains all of the essential custom JumpStart files, for example, the rules file, rules.ok file, and profiles. You must save the JumpStart directory in the root (/) directory of the profile diskette.

SPARC: To Create a Profile Diskette

Note -

This procedure assumes that the system is running Volume Manager. If you are not using Volume Manager to manage diskettes, CDs, and DVDs, refer to System Administration Guide: Basic Administration for detailed information about managing removable media without Volume Manager.

  1. Log in as superuser on a SPARC system to which a diskette drive is attached.
  2. Insert a blank diskette or a diskette that can be overwritten in the diskette drive.
  3. Mount the diskette. 
    # volcheck
  4. Determine if the diskette contains a UNIX file system (UFS).

    Examine the contents of the file /etc/mnttab on the system for an entry such as the following:


    /vol/dev/diskette0/scrap /floppy/scrap ufs suid,rw,largefiles,dev=1740008 927147040
  5. Format the diskette.
    Caution - Formatting erases all data on the diskette.
    # fdformat -U
  6. Create a UFS on the diskette. 
    # newfs /vol/dev/aliases/floppy0
  7. Determine if you want to copy examples of custom JumpStart files to your JumpStart directory.
    Example Locations Instructions
    The Solaris 9 SPARC Platform Edition DVD or the Solaris 9 Software 1 of 2 SPARC Platform Edition CD Insert the Solaris 9 SPARC Platform Edition DVD or the Solaris 9 Software 1 of 2 SPARC Platform Edition CD into the server's CD-ROM drive.

    Volume Manager automatically mounts the CD.

    An image of the Solaris 9 SPARC Platform Edition DVD or the Solaris 9 Software 1 of 2 SPARC Platform Edition CD on a local disk Change the directory to the location of the Solaris 9 SPARC Platform Edition DVD or the Solaris 9 Software 1 of 2 SPARC Platform Edition CD image. For example, type the following command:

    cd /export/install

  8. Copy the example custom JumpStart files into the JumpStart directory on the profile diskette. 
    # cp -r media_path/Solaris_9/Misc/jumpstart_sample/* jumpstart_dir_path
    media_path The path to the CD, DVD, or image on the local disk
    jumpstart_dir_path The path to the profile diskette where you want to place the example custom JumpStart files
    Note -

    You must place all custom JumpStart installation files in the root (/) directory on the diskette.

    For example, the following command copies the contents of jumpstart_sample on the Solaris 9 Software 1 of 2 SPARC Platform Edition CD to the root (/) directory on a profile diskette that is named scrap:

    cp -r /cdrom/sol_9_sparc/s0/Solaris_9/Misc/jumpstart_sample/* /floppy/scrap
  9. Update the example JumpStart files on the profile diskette so that the files work in your environment.
  10. Ensure that root owns the JumpStart directory and that permissions are set to 755.
  11. Eject the diskette.

    # eject floppy

    You have completed the creation of a profile diskette. You can now update the rules file and create profiles on the profile diskette to perform custom JumpStart installations. To continue, go to "Creating the rules File".

[PDF] Configuring JumpStart™ Servers to Provision Sun™ x86-64 Systems (February 2005) -by Pierre Reynes
File Format: PDF/Adobe Acrobat - View as HTML

Organizations are constantly challenged to deploy systems throughout the enterprise with consistent and reliable configurations. Solaris JumpStart technology provides a mechanism for fully automating the Solaris Operating System (Solaris OS) installation process. With the ability to locate installation information over the network or from a local CD-ROM drive, and use customized profiles, JumpStart facilitates the rapid and consistent deployment of Solaris OS-based systems.

Many organizations have relied on UltraSPARC/Solaris platforms for years, and use JumpStart technology for operating system deployment. With the introduction of Sun x86-64 based systems, organizations are now seeking ways to use existing JumpStart servers to deploy the Solaris OS and Linux operating environment on Sun x86-64 based systems. This article describes how to modify existing JumpStart servers to support the deployment of the Solaris OS and Linux operating environment on Sun x86-64 based systems, as well as how to use standard Linux installation tools for configuring Sun x86-64 based systems.

Solaris 8 Jumpstart Setup-How-To By Scott D. Matott sXe [email protected]

I wrote this page to document how I built a jumpstart server for my group and to help others. Although it didn't take me long to build a jumpstart server, it did take a lot of internet searching, reading of Sun docs and some previous jumpstart experience to figure out what all the pieces were and how they fit together. My hope in writing this document and posting it on the web is to create a place where others can go to find out most of all they need to know to setup a jumpstart server, thus saving them some of the searching, reading and trouble that I had to endure.

Solaris x86 umpstart on VMware
1: Installation from local CD-Roms and Floppies. The automatic installation of
Solaris can be done using CD-Rom or DVD Media. In this case the JumpStart ...
jan.exss.de/en/vms_install_auto.html - 14k - Jan 9, 2006 - Cached - Similar pages

[PDF] Solaris Jumpstart Basics by Hal Pomeranz, Deer Run Associates
File Format: PDF/Adobe Acrobat - View as HTML
Sun's primary reference for Jumpstart configuration is the Solaris Advanced
Installation. Guide which may be found on the Web at ...
www.deer-run.com/~hal/jumpstart/Jumpstart.pdf - Similar pages

[Dec 30 2005] Creating a Customized Boot CD/DVD for the Solaris Operating System for x86 Platforms by John Cecere, Dana Fagerstrom

This article explains the mechanics of the boot process on the Solaris Operating System for x86 platforms so that you understand what is needed to create a customized CD/DVD. It discusses both the hard disk and CD/DVD boot processes, and points out the differences between the two.

There are a number of practical applications for this topic, including:

This article begins by examining the layout of a hard disk in the x86 architecture and the components on it that are used for booting. It then describes the pieces that are unique to a CD boot. Finally, this article puts the pieces together and creates an image file that can be burned to CD.

Using Live Upgrade 2.0 With JumpStart Technology and Web Start Flash

[Apr 30, 2004] Building a Bootable DVD to Deploy a Solaris Flash Archive -by John S. Howard

This article provides techniques to augment a DVD-ROM-based installation with the services and behaviors typically provided by a JumpStart server. The techniques presented in this article can be used when you need to perform an automated installation of a Solaris Flash archive, but are unable to use a JumpStart server. This article describes a procedure to create a bootable installation DVD-ROM with a complete software stack on a DVD that you can use to perform a standardized and fully automated installation of the software stack from the DVD.

This article also examines the structure of a bootable Solaris OS DVD and provides information about modifying installation behaviors to perform an automated install of a Solaris Flash archive from a DVD.

[Sep 30 2003] Deploying the Solaris Operating Environment Using a Solaris Security Toolkit CD by Steven Spadaccini


The Solaris Security Toolkit is a collection of shell scripts combined to form a flexible and extensible framework for rapidly deploying hardened platforms running the Solaris Operating Environment. The Toolkit is, however, quite versatile and can be used for much more than just hardening a system. This article discusses how the Toolkit can be used to construct a bootable CD, based on Sun's JumpStart framework, for building and configuring new systems. This article is authored for intermediate and advanced system administrators.

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 3 (September 2000) by Alex Noordergraaf


This article is third in a three part series describing an automated toolkit for implementing the security modifications documented in earlier Sun BluePrints onLine articles. In conjuction with this final article the toolkit itself is being made freely available.

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 2 (August 2000) by Alex Noordergraaf


This article is part two of a three part series that presents the JumpStart Architecture and Security Scripts toolkit. We continue with an in-depth review of the configuration files, directories, and scripts used by the toolkit to enhance the security of Solaris Operating Environment systems. This series is a must read for anyone interested in upgrading the security of their site.

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 1 (July 2000) by Alex Noordergraaf


This article is part one of a three part series presenting the JumpStart Architecture and Security Scripts tool (Toolkit) for the Solaris Operating Environment. The Toolkit is a set of scripts which automatically harden and minimize Solaris Operating Environment systems. The modifications made are based on the recommendations made in the previously published Sun BluePrints OnLine security articles.

[Nov 30, 2001] WebStart Flash by John S. Howard and Alex Noordergraaf

The Solaris Operating Environment Flash installation component extends JumpStart technology by adding a mechanism to create a system archive, a snapshot of an installed system, and installation of the Solaris Operating Environment from that archive. This article introduces the concepts and best practices for a Flash archive, describes the master machine, and suggested storage strategies, and provides a complete example of creating a Flash archive and installing a Web server with Flash.

Recommended Links

Google matched content

Softpanorama Recommended

Top articles

Sites

Solaris Jumpstart Automated Install www.amorin.org/professional/jumpstart.php - 102k - Dec 16, 2005

Enterprise Rollouts with JumpStart by Jason Heiss also [PDF] Enterprise Rollouts with JumpStart

Solaris Jumpstart

Solaris Jumpstart Automated Install

Solaris Jumpstart Basics

Jumpstart Information and Related Links

BigAdmin Submitted Article- UberJS- A More Flexible Solaris ...

Setting Up a Solaris™ Operating Environment Install Server and the ...

Solaris Jumpstart

The UNIX Forums - Create a Solaris Jumpstart from iso

Solaris Jumpstart AFS install

Solaris jumpstart installation @ DESY

Jon's Configuring Solaris Jumpstart Without a Name Service Lab

Blueprints

[PDF] Configuring JumpStart™ Servers to Provision Sun™ x86-64 Systems (February 2005) -by Pierre Reynes
File Format: PDF/Adobe Acrobat - View as HTML

Organizations are constantly challenged to deploy systems throughout the enterprise with consistent and reliable configurations. Solaris JumpStart technology provides a mechanism for fully automating the Solaris Operating System (Solaris OS) installation process. With the ability to locate installation information over the network or from a local CD-ROM drive, and use customized profiles, JumpStart facilitates the rapid and consistent deployment of Solaris OS-based systems.

Many organizations have relied on UltraSPARC/Solaris platforms for years, and use JumpStart technology for operating system deployment. With the introduction of Sun x86-64 based systems, organizations are now seeking ways to use existing JumpStart servers to deploy the Solaris OS and Linux operating environment on Sun x86-64 based systems. This article describes how to modify existing JumpStart servers to support the deployment of the Solaris OS and Linux operating environment on Sun x86-64 based systems, as well as how to use standard Linux installation tools for configuring Sun x86-64 based systems.

Creating a Customized Boot CD/DVD for the Solaris Operating System for x86 Platforms (December 2005)
-by John Cecere, Dana Fagerstrom

This article explains the mechanics of the boot process on the Solaris Operating System for x86 platforms so that you understand what is needed to create a customized CD/DVD. It discusses both the hard disk and CD/DVD boot processes, and points out the differences between the two.

There are a number of practical applications for this topic, including:

This article begins by examining the layout of a hard disk in the x86 architecture and the components on it that are used for booting. It then describes the pieces that are unique to a CD boot. Finally, this article puts the pieces together and creates an image file that can be burned to CD.

Performing Network Installations Without a Local Boot Server (May 2004)
-by John S. Howard
In some instances, it might be necessary or advantageous to boot an installation client from local boot media, such as a CD or DVD, but have the Solaris product installed from a JumpStart (or installation) server. This article describes the system startup and installation processes for the Solaris Operating System and explains how to modify them to change the location from which the Solaris product is installed.

Building a JumpStart Infrastructure (April 2001)
-by Alex Noordergraaf
This article discussed how the core JumpStart components interract. Recommendations on how to structure the JumpStart server are provided in addition to step by step instructions on how to get a basic automated JumpStart environment up and running as quickly as possible.

Customizing the JumpStart Boot Image Recovery (March 2001)
-by John S. Howard
This article includes techniques and recommendations for creating a recovery platform by augmenting the Solaris OE boot image (mini-root). This article will also examine the boot and installation processes by demonstrating how to adapt those processes for system recovery.

Building a Bootable JumpStart Installation CD-ROM (March 2001)
-by John S. Howard
This article presents an examination of the structure of a bootable Solaris Operating Environment (Solaris OE) CD-ROM and procedures for how to create a bootable JumpStart installation CD-ROM. This CD can be used to complete a standardized, hands-free Solaris OE installation in environments where the disk space or networking constraints do not allow for a JumpStart server.

JumpStart Mechanics: Using JumpStart Application for Hands- Free Installation of Unbundled Software - Part 2 Automatic Encapsulation of the Root Disk (June 2000)
-by John S. Howard
John provides procedures to fully automate the initial configuration of Sun Enterprise Volume Manager and automate encapsulation of the boot disk using JumpStart.

Setting Up a Solaris Operating Environment Install Server and the Solaris JumpStart Feature (December 1999)
-by Rob Snevely
A walkthrough on setting up an install server.

JumpStart: NIS and sysidcfg (October 1999)
-by Rob Snevely
How to use JumpStart technology to allows automation of the install process.

MR System for Rapid Recovery (January 2001)
-by John S. Howard
This article is an introduction to the MR system for rapid recovery. As the system uptime requirements have become more exacting, the length of time it takes to boot these larger and more complex systems has grown. By implementing MR on your JumpStart servers it may be possible to reduce the number of reboots required during a system recovery or service event. This minimization of reboots will speed recovery and service time as well as enable the system administrator to use datacenter tools during system recovery procedures.

Ethernet Autonegotiation Best Practices
-by Steve Hodnett and Jim Eggers
Issues related to network performance, delays, jumpstart problems and link failures due to incorrect ethernet link speed and duplex settings are becoming more common due to outdated Ethernet link policies adopted by many administrators. This is largely due to misunderstanding of Ethernet autonegotation standards and experiences with older ethernet drivers and switches.

This article details Sun's recommendation to leave Ethernet autonegotiation enabled (default) when connecting Solaris Operating System 100Mb and 1000Mb Ethernet NICs to switches and hubs that are IEEE 802.3 compliant. Customers are unnecessarily setting 100Mb and 1000Mb ethernet interfaces parameters in /etc/system and driver.conf, or using ndd, without fully understanding the possible ramifications and negative results.

Performing Network Installations Without a Local Boot Server -by John S. Howard
In some instances, it might be necessary or advantageous to boot an installation client from local boot media, such as a CD or DVD, but have the Solaris product installed from a JumpStart (or installation) server. This article describes the system startup and installation processes for the Solaris Operating System and explains how to modify them to change the location from which the Solaris product is installed.

Building a Bootable DVD to Deploy a Solaris Flash Archive
-by John S. Howard
This article provides techniques to augment a DVD-ROM-based installation with the services and behaviors typically provided by a JumpStart server. The techniques presented in this article can be used when you need to perform an automated installation of a Solaris Flash archive, but are unable to use a JumpStart server. This article describes a procedure to create a bootable installation DVD-ROM with a complete software stack on a DVD that you can use to perform a standardized and fully automated installation of the software stack from the DVD.

This article also examines the structure of a bootable Solaris OS DVD and provides information about modifying installation behaviors to perform an automated install of a Solaris Flash archive from a DVD.

Deploying the Solaris Operating Environment Using a Solaris Security Toolkit CD
-by Steven Spadaccini
The Solaris Security Toolkit is a collection of shell scripts combined to form a flexible and extensible framework for rapidly deploying hardened platforms running the Solaris Operating Environment. The Toolkit is, however, quite versatile and can be used for much more than just hardening a system. This article discusses how the Toolkit can be used to construct a bootable CD, based on Sun's JumpStart framework, for building and configuring new systems. This article is authored for intermediate and advanced system administrators.

Customizing JumpStart Framework for Installation and Recovery
-by John S. Howard and Alex Noordergraaf
Techniques to augment a CDROM-based installation with the services and behaviors provided by a JumpStart server are detailed in this article. These techniques are suitable to situations when a hands-free Solaris Operating Environment (Solaris OE) installation is necessary but when a JumpStart server cannot be used. This article is a chapter from the Sun BluePrints book, "JumpStart Technology: Effective Use in the Solaris Operating Environment", ISBN# 0-13-062154-4.

Using Live Upgrade 2.0 With JumpStart Technology and Web Start Flash
-by John S. Howard
In this final installment of his three-part series on Solaris Live Upgrade 2.0 (LU) technology, John S. Howard provides recommendations and techniques for integrating LU with the JumpStart software framework and the Solaris Web Start Flash software. The first two articles in this series can be found at: http://www.sun.combrowsesubject.html.

WebStart Flash
-by John S. Howard and Alex Noordergraaf
The Solaris Operating Environment Flash installation component extends JumpStart technology by adding a mechanism to create a system archive, a snapshot of an installed system, and installation of the Solaris Operating Environment from that archive. This article introduces the concepts and best practices for a Flash archive, describes the master machine, and suggested storage strategies, and provides a complete example of creating a Flash archive and installing a Web server with Flash.

Building a JumpStart Infrastructure
-by Alex Noordergraaf
This article discussed how the core JumpStart components interract. Recommendations on how to structure the JumpStart server are provided in addition to step by step instructions on how to get a basic automated JumpStart environment up and running as quickly as possible.

MR System for Rapid Recovery
-by John S. Howard
This article is an introduction to the MR system for rapid recovery. As the system uptime requirements have become more exacting, the length of time it takes to boot these larger and more complex systems has grown. By implementing MR on your JumpStart servers it may be possible to reduce the number of reboots required during a system recovery or service event. This minimization of reboots will speed recovery and service time as well as enable the system administrator to use datacenter tools during system recovery procedures.

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 1

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 2

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 3

Presentations

Introduction to Solaris JumpStart

[PDF] Solaris Jumpstart Basics Hal's jumpstart info page:. www.deer-run.com/hal/jumpstart/. View as HTML

JumpStart Disks

JumpStart Disk Implementation

System recovery using Jumpstart

[DOC] Restoring a Sun system using JumpStart technology

File Format: Microsoft Word 97 - View as HTML
I have found that using Sun's JumpStart technology together with customised installation scripts, enables me to restore a system over the network, ...
supportforum.sun.com/network/ index.php?t=getfile&id=21&rid=0 - Similar pages

Linux-based Jumpstart Server

linux-jumpstart

Tips

Solaris Tips - Jumpstart

Random Findings

Solaris jumpstart installation @ DESY -- http://www.desy.de/~dirkw/jumpstart.html

http://www.cuug.ab.ca/~leblancj/labs/index.html
http://www.tcsa.org/auto_install/
http://www.netsys.com/sunmgr/1995-11/msg00045.html
http://www.sunmanagers.org/pipermail/sunmanagers/2001-January/000736.html
http://docs.ns.gatech.edu/admin/installation/install_jumpstart.html
http://www.rootprompt.org/article.php3?article=2276

www.sun.com/blueprints/0500/jsmech1.pdf JumpStartTM Mechanics: Using JumpStart Application for Hands-Free Installation of Unbundled Software By John S. Howard

www.sun.com/blueprints/0600/jsmech2.pdf -- JumpStartTM Mechanics: Using JumpStart Application for Hands-Free Installation of Unbundled Software - Part 2 Automatic Encapsulation of the Root Disk

JumpStart Architecture and Security Scripts for the Solaris Operating Environment - Part 1-3: Updated for Toolkit
version 0.2" by Alex Noordergraaf and Glenn Brunette [3].

Installing Solaris with Jumpstart

Automating UNIX installations with HP Ignite and Solaris JumpStart -- slides

Linux as a Jumpstart Server (C) Copyright Scott Howard, 2002 scott ...

Etc

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotes :  Somerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce :  Bernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOS :  Programming Languages History : PL/1 : Simula 67 : C : History of GCC development :  Scripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-Month :  How to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D

Copyright © 1996-2021 by Softpanorama Society. www.softpanorama.org was initially created as a service to the (now defunct) UN Sustainable Development Networking Programme (SDNP) without any remuneration. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.

FAIR USE NOTICE This site contains copyrighted material the use of which has not always been specifically authorized by the copyright owner. We are making such material available to advance understanding of computer science, IT technology, economic, scientific, and social issues. We believe this constitutes a 'fair use' of any such copyrighted material as provided by section 107 of the US Copyright Law according to which such material can be distributed without profit exclusively for research and educational purposes.

This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

 You can use PayPal to to buy a cup of coffee for authors of this site

Disclaimer:

The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the Softpanorama society. We do not warrant the correctness of the information provided or its fitness for any purpose. The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.

Last modified: March 12, 2019