Coldfusion Web Hosting - Tomcat, Jsp, J2Ee, Servlets, Struts Blog

Inside Linux The last example is a little extreme. I suspect most people will not specify a path this way. First, you have to know how many levels deep you are, and then specify the complete path. Why not specify the fully qualified name, as shown in the fourth example? The beginning of this section mentioned that the directory structure is a method of organizing files. Let’s examine some of the standard Linux directories. The root directory (/), as was discussed previously, is primarily used to hold all other directories. It is bad karma to store any file in the root (other than what Linux stores there). The /bin directory stores binary executable files (programs). The name bin is derived from binary. Only Linux system binaries should be stored in this directory. Software (user binaries) that you install is normally stored in another directory. The /dev directory holds the files that refer to devices. If you recall from the previous section, everything in Linux is a file, and devices (such as a printer) are no exception. The /etc directory holds Linux-specific configuration files. If you ever have to reconfigure parts of Linux, you may find yourself editing some of these files. The /home directory contains the home directories for users known to the system. When you log in to the system, you are taken to your home directory, which is found under /home. The /lib directory is used to hold shared library files. These shared library files contain common function routines used by programs. Library files are referred to as shared because more than one program can access routines found within them. This fact keeps most programs small (and the system smaller) because each program does not have to store those routines. The /proc directory holds process and kernel runtime information. The information is actually in memory but is accessed through /proc. The /tmp directory, as you may have guessed, stores temporary files. Most of these temporary files are created by running processes. It is a good idea to visit this directory from time to time to see if any (large) files are left lingering around. The best time to do this is just after logging in to the system. The /usr directory is used to contain most of the software packages that you install. This directory contains other directories, such as /usr/bin, /usr/etc, /usr/lib, /usr/local, /usr/man, and /usr/src. Let’s take a look at these directories. Executables are stored in /usr/bin (the same as /bin does). Various configuration files not found in /etc are stored in /usr/etc -mainly configuration files used by the installed software packages. The /usr/lib directory stores shared library files for the software packages. The man pages (help files) are stored in /usr/man. The /usr/man directory will also contain a number of directories. Source code for software can be found in /usr/src. The size of this directory can be quite large if you opt to install source code for all the software packages. The /usr/local directory is used for nonessential files and programs. The structure of /usr/local will normally be different between UNIX systems. As a rule, however, it will contain /usr/local/bin, /usr/local/etc, and /usr/local/lib. Files that fluctuate in size can be found in /var. The /var directory typically contains two directories: /var/adm and /var/spool. The /var/adm directory contains system error messages and log files. These files are reviewed and maintained by the system administrator. The /var/spool directory contains files that are used by programs such as news and mail. page 54
Note: If you are looking for high quality webhost to host and run your jsp application check Vision christian web host services

Inside Linux Figure 3.2. Typical directory tree. The root directory is also known as a parent directory. More accurately, the root is the parent of all directories. Each directory has a parent directory. Even root has a parent directory - itself. We use the / character to designate the root directory. All pathnames begin with the slash character, affectionately referred to as whack. We also use / to separate the parent and child directories when specifying a path. In the example /usr/local/bin, the directory local is a child of usr and bin is a child of local. We can see the relationship because each name is separated by /. Each directory contains two special directory entries: . and … The . entry represents the current directory (see the next section) and the .. entry denotes the parent directory. Let’s assume that you are in a directory named /development/components and there is a file named Goofy.java. You can refer to that file in a number of ways. For example, suppose that you want to run the head command on Goofy.java. The head command is used to print the first few lines of one or more files. The default number of lines is 10, but you can specify more or less. The following dialog demonstrates some ways we can refer to Goofy.java: stimpy $ head Goofy.java stimpy $ head ./Goofy.java stimpy $ head ../components/Goofy.java stimpy $ head /development/components/Goofy.java stimpy $ head ../../development/components/Goofy.java stimpy $ page 53
Note: In case you are looking for affordable and reliable webhost to host and run your business application check Vision php5 hosting services

Inside Linux The execute bit is part of the file access permissions. A number of permission bits are associated with each file. The permission categories are user, group, and other. Permission bits can be set for each category, to include read, write, and execute. Linux maintains these permission bits for each file, yielding a total of nine permission bits. For example, if we want to examine a file, we must have execute and read permissions for the file. The read permission flag designates that we can open a file for read-only. The write bit for a file says that you can open an existing file for write. To create a file, you must have write and execute permission for the directory. To delete a file, you must have write and execute permission for the directory. Special files fall into two subcategories. The first subcategory is block-special and the second is character-special. Believe it or not, all physical devices are associated with the file system. The keyboard that you use, the console that you look at, and the printer that you print to are all associated with a file in the Linux file system. Most of these special files are found in the /dev directory. Character-special devices are named as such because they process a stream of bytes, one character at a time. This is in contrast to block-special devices. Block-special devices process a block of data at a time. When I say process, I am referring to the reading or writing of data. Hard disks and magnetic drum and tape drives are all block-special devices. It would be very inefficient for these devices to process data one character at a time. There are other special-device files. One is named /dev/null and the other is a named pipe. For /dev/null, anything that is sent to it disappears. If you want to ignore the output of a command, you can redirect output to /dev/null. You can use /dev/null to create or (completely) truncate a file. To truncate a file to zero (or create one), use the cp (copy file) command, as shown in the following: stimpy $ cp /dev/null ./myfile.txt stimpy $ Because /dev/null has no contents, copying it to another file will set it to zero bytes. Or if the file does not exist, it will be created. A named pipe is a FIFO (first-in-first-out) buffer. Named pipes are used in special programming situations. A simple example is a server program that accepts requests for service and performs the appropriate action. A named pipe is useful in this type of situation. The server is at the receiving end of the pipe. Any processes that want to send requests attach at the input end of the pipe. More than one process can attach at the input end. As data is fed at the input end, the pipe grows. As the server process reads data, the pipe decreases in size. A link is a very special directory entry. A link is similar to an alias. You can specify that one file is a link to (or points to) another file. Whenever some action is performed on the link, the actual file is operated on. To be sure we are clear on this - a link is not a file; it is a special directory entry that contains the inode number of the linked-to file. So, you ask, what is an inode number? An inode number is a unique identifier that is applied to every file. Think of an inode number as a file’s social security number - each file gets a unique number. There are two types of links: symbolic and hard. Symbolic links allow you to link to file without linking to the inode number. A symbolic link can even link to a nonexistent file. Symbolic links can span disks and computers. In other words, a symbolic link can link to a file that exists on another computer. Hard links are not as flexible as symbolic links. Hard links can work only on files that are on the same file system. Hard links are direct links to a file’s inode number. The Directory Tree The directory tree is a way to organize files within directories. The term directory tree (or simply tree) is used because the directory structure, when depicted graphically, appears to have a root and branches. A directory tree can be depicted with the root at the top, and the branches growing downward. Alternatively, the root can be at the bottom, with the branches growing upward. A tree can also be shown with the root on the left and the branches growing to the right. Figure 3.2 shows a typical directory tree. It is important to note that all directory branches start from the root directory. The root directory is the main file folder, holding all other directories (folders). If you look at Figure 3.2 again, you will see some important directories, such as /bin, /dev, /etc, /usr, and /var. As you can see, some of these first level directories contain other directories. Moreover, those directories contain other directories, and so on. page 52
Note: In case you are looking for affordable and reliable webhost to host and run your business application check Vision ftp web hosting services

Inside Linux During the installation process, the directory structure is created and all required files are placed in their proper location. After the installation is done, it is up to you to maintain the file systems. The important thing to remember about a file system is to think twice before you act on it. Understanding Files and Directories Before a file can be stored, a Linux file system with one or more directories must exist. Without a directory, a file would not exist. Following the chicken-and-egg concept, some people will argue that a file is the basic building block, not the directory. After all, a directory is nothing more than a special file that contains filenames and their attributes. Still, directories maintain a logical structure and can be depicted graphically. Think of the Linux file system as one massive file folder. This single file folder holds many other file folders. A directory can be thought of as file folder. A directory can contain one or more directories and so on. Files are very specialized because they contain information. Each type of file has its own unique layout. Some files hold structured content - one example is a fixed record length file. With other files, the information contained is random. A word processing file is a good example. The information contained is in no specific order or structure. All files within a file system must be uniquely identified. This is accomplished by giving a file a name and its location in the file system. The location refers to a directory path where the file is contained. If you have two files with the same name, but they are in different directory paths, they are considered unique. The term fully qualified filename refers to a file’s name, with its directory path prepended to the name. For example, if a file is named sample.cpp and is in the path /development/projects/billing (actually stored in the billing subdirectory), the fully qualified filename is: /development/projects/billing/sample.cpp. Different types of files are found on a Linux system. The various types of files fall under one of these major categories: ordinary and special files, links, or directories. Ordinary files consist of executable files (programs), word processing files, shell scripts, database files, and other data files. A majority of your time is spent with ordinary files. If you are a developer, much of your time is spent editing source code files, executing the compiler to produce object files, and running the linker to generate an executable file. All these files - source code, compiler, object, linker, and executable - are ordinary files. If you work in sales, much of your time is spent manipulating spreadsheet files, word processing files, database files, and so on. How does Linux know the type of a file? What keeps Linux from executing a word processing file? What keeps you from loading an executable file into the Emacs editor? Let’s look at a Linux command that will tell us the type of a file. Ironically enough, the name of the command is file. The file command can be quite useful to help us determine the type of a file. For example, it can tell us if a file is, among others, a (binary) executable, a text file, or a shell script. If the file command reports a filename as a binary file, we probably don’t want to view it in Emacs. The syntax for the file command is as follows: file [switches] file-list Refer to the man page for the file command to view the available switches. The argument file-list is a space-delimited list of files. Okay, we know how to discover the type of a file. How does Linux know? Well, Linux really knows only two types of files. Either the file is an executable or it isn’t. If the execute bit is set for a file, Linux can execute it. If the execute bit is not set, Linux will not attempt to run it. Linux might use the file for some purpose; for instance, the password file is read to verify a user’s password. page 51
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision make web site services

Inside Linux Another method used to print the contents of an environment variable is to use the echo command. The echo command is used to print the supplied argument to the standard output, followed by a newline character. If you do not supply an argument, a newline is output. The following dialog shows how not to display the value of a variable: stimpy $ REN=a happy cat stimpy $ echo REN REN stimpy $ What happened? The echo command did as it was told: to print the argument REN. So how do we print the value for REN? We prepend the $ character to the variable’s name. Let’s try again and see what happens: stimpy $ echo $REN a happy cat stimpy $ That’s better! We have one last question to answer: How are they used? We have seen one example and that was the MAILCHECK environment variable. Another example is the PAGER environment variable. This variable is used by the man command. Some man pages can be very long, often beyond the number of lines that a screen can display. The PAGER variable holds the command that the man command will use to display a screenful of data at a time. The default command man uses is the more command. You could specify the less command as an option. This command allows you to scroll the text up or down -more only displays text from beginning to end. We’ve discussed the fact that an environment variable can be either local or exported. Therefore, how do we export a variable that is local? We use the export command, as is shown in the following dialog: stimpy $ REN=a friend of Stimpy stimpy $ export REN stimpy $ env SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler TZ=CST6CDT PS1=$ REN=a friend of Stimpy As you can see, REN is now a part of the exported environment. The variable REN is now available to all processes under this session. Alternatively, we can use the command separator character to collapse two separate command lines onto one. The following shows how: stimpy $ REN=a happy cat; export REN stimpy $ env SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler TZ=CST6CDT PS1=$ REN=a happy cat The command separator can be useful to string two or more commands onto the same command line. Be sure to type your commands carefully when using the command separator, or you may get undefined results. The most important environment variable is the PATH variable. The PATH variable is used whenever the system needs to find a command file. The variable is a colon-separated list of directory paths. For example, your PATH variable may be set as follows: stimpy $ echo $PATH /usr/bin:/bin:/usr/local/bin stimpy $ If you enter the finger command, Linux examines each directory entry in the PATH. If the command is not found in the first entry, it continues to the next entry, and so on and so forth. If the command is found, it is executed. If the command is not found, an error message is displayed. Using Files and Directories In this section, we delve into the world of Linux files and directories. An understanding of Linux file systems is very important because everything you do in Linux involves a file system. If you are coming from the DOS or Windows world, some of what you see here will look familiar. This is because the DOS, Windows, and Linux file systems are borne from the UNIX file system. Linux uses a file system to store program files, user email, system files, and library files, among others. It also uses a file system for specialized programming tasks as shared memory. page 50
Note: If you are looking for high quality webhost to host and run your jsp application check Vision florida web design services

Inside Linux To verify that the variables exist, use the set command to see the results: stimpy $ set SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler MAILCHECK=300 TZ=CST6CDT IFS= PS2=> OPTIND=1 PS1=$ REN=cat So, is this environment variable local to the shell’s environment, or is it global? Well, we have not exported the variable yet, so it must be local. We can verify this by using the env command, as shown in the following: stimpy $ env SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler TZ=CST6CDT PS1=$ Sure enough, the variable REN does not exist in this list, so it must be local to the shell. Can we change the value of REN? Absolutely! We simply type the name REN again and supply a new value, as shown in the following example: stimpy $ REN=”a happy cat” stimpy $ And now, let’s see if the value of REN has changed. Remember, we have to use the set command: stimpy $ set SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler MAILCHECK=300 TZ=CST6CDT IFS= PS2=> OPTIND=1 PS1=$ REN=a happy cat You can also set the value of an environment variable to the empty string (no value). The variable will continue to exist, but no value is associated. The following dialog demonstrates this: stimpy $ REN= stimpy $ set SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler MAILCHECK=300 TZ=CST6CDT IFS= PS2=> OPTIND=1 PS1=$ REN= Changing the value of an environment variable allows you to change the behavior of a program. Take notice of the variable MAILCHECK in the previous listing. This variable is used to designate how often to check for new mail. The value shown is in seconds. If we want to increase the value of the mail check from 5 minutes to 10 minutes, we do so as shown in the following example: stimpy $ MAILCHECK=600 stimpy $ set SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler MAILCHECK=600 TZ=CST6CDT IFS= PS2=> OPTIND=1 PS1=$ REN= We can see from the output of set that the variable is now set to the new value. page 49
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision mysql5 web hosting services

Inside Linux And the following is output: stimpy $ cp /prod/java/components/distrib.jar /prod/java/components/distrib.jar Finally, we alter the second argument and submit the following command: stimpy $ cp /prod/java/components/distrib.jar /prod/java/components/distrib2.jar You will begin to appreciate this feature the more you use it. Environment Variables After you log in, Linux creates a number of environment variables for your session. An environment variable is a variable (or alias) that represents some value. These variables may be retained within the shell’s or session’s environment. Some environment variables are predefined by the system, some are created by you, and others are created by various processes that execute. Some environment variables exist throughout the life of the current session. Some variables exist only during the execution of a process. Environment variables that are globally visible are referred to as exported. A globally visible variable is one that is seen by all processes within the session. Some variables that are defined by a process are local to the defining process only. So, what do these environment variables look like? How are they defined? How are they used? Let’s begin by answering the first question. We can display the existing environment variables a couple of ways. One way is to use the env command, as in the following abbreviated example: stimpy $ env SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler TZ=CST6CDT PS1=$ An environment variable consists of two parts. One is the name of the variable, and the second part is the value. Environment variables are comparable to variables found in most programming languages. The name variable suggests that its value can change - and indeed, the value can change. A second method of displaying environment variables is to use the set command. The set command, however, prints all available environment variables. The env command lists only the variables that are exported. The set command lists all environment variables, exported and local to the shell process. The following is an abbreviated list of variables and their contents using the set command: stimpy $ set SHELL=/bin/bash HOME=/home/mtobler LOGNAME=mtobler MAIL=/usr/mail/mtobler MAILCHECK=300 TZ=CST6CDT IFS= PS2=> OPTIND=1 PS1=$ This list differs from the list on your system. In addition, this list is not a comprehensive one; most listings from a set command scroll off the screen. Let’s move on to the second question: How are they defined? Environment variables are defined by specifying a variable name, followed by the assignment operator (=), and then the value of the variable. You need to be cautious, however; if you specify the name of an existing variable, the variable’s contents will be overwritten with the new value. As mentioned previously, some variables are predefined by the system when you log in. You can define new environment variables at the command line. We can create a variable named REN to hold the value cat, as shown in the following example: stimpy $ REN=cat stimpy $ page 48
Note: If you are looking for best quality webspace to host and run your tomcat application check Vision virtual web hosting services

Inside Linux The optional argument is the number of lines to display from the history list, starting from the most current entry. The following displays the complete list of command entries from the history list: stimpy $ history 1 cd /development/java 2 ls -al 3 cd components 4 ls 5 cd utility 6 make package 7 cp util.jar /production/java/components 8 ls 9 slickedit fill.java 10 javac fill.java The first line is the shell prompt and the history command we typed. The lines that follow are the contents of the history list. The following dialog shows the last three entries from the history list (most current last): stimpy $ history 3 9 slickedit fill.java 10 javac fill.java 11 history You may have noticed a slight difference between the entries displayed to the command line and the output of the history list. Each entry within the history list has an associated line number. You can recall a command by using its associated line number. The following dialog demonstrates recalling the make package command: stimpy $ !6 stimpy $ make package The exclamation point is called the bang character. The bang, when immediately followed by a number, instructs the bash shell to retrieve the command associated with the supplied number. Notice that the command is retrieved and placed on the command line, allowing you to edit the command string. Another nice feature for some of the shells is called command completion. The next section discusses this useful feature. Command Completion The command completion feature can be useful when typing filenames. When you type one or more characters and press the Tab key, the shell attempts to complete the filename based on the characters you supply. Linux will do one of three things concerning the template you supply. If multiple files are found matching the template, Linux will supply characters up to the last matching character (of all files found). For example, if we enter sw and press the Tab key: stimpy $ sw The following is displayed: stimpy $ swap On this system, the files that are found are swapdev, swapon, and swapoff. Your system may find more or less, depending on what was installed. If Linux finds a unique filename matching the template, it fully completes the filename. To modify the previous example, if we supply the following template: stimpy $ swapd Then the following is displayed: stimpy $ swapdev The completion feature becomes quite useful when typing long filenames and directories, especially when typing fully qualified names. The following dialog demonstrates this: stimpy $ cp /prod/java/components/dis The command line is updated, as shown in the following: stimpy $ cp /prod/java/components/distrib.jar /pro page 47
Note: If you are looking for cheap and reliable webhost to host and run your mysql application check Vision mysql hosting services

Inside Linux The first example uses the write to redirection symbol (>). The ls command is executed and its output is redirected to the file named files.txt (the listing does not appear on the screen). The second example uses the pipe symbol to connect the programs. The output of one program (left side) is received as input to the second program (right side). Using our previous example, the following will accomplish the same task, but it takes more steps: stimpy $ ls -al > list.tmp stimpy $ more list.tmp stimpy # rm list.tmp Now that you know the basics of command execution, let’s take a look at recalling previous commands. Command History Linux provides a feature that enables you to recall previous commands. More accurately, this is a function of the command shell. The bash shell saves a history of commands in the history list. The number of commands stored is governed by the shell variable named HISTSIZE (under bash). For a more complete discussion of environment variables, see the later section “Environment Variables.” NOTE Many shells are available for Linux. Some of these shells do not provide command history functionality - refer to the appropriate documentation for details. The history list also persists across login sessions, so commands entered in the previous login are available to the current login session. How is this list retained across sessions? Quite simply -in a history file. This history file is normally stored in your home directory. The name of the history file is dependent on the shell that you are using. The filename usually begins with a period, thus hiding the file from directory listings (unless you use the -a or -A switch). For example, if you are using the bash shell, the name of the history file is .bash_history. You can control the name of the history file by using the HISTFILE environment variable under bash. Commands are recalled from history by using the up and down arrow keys on your keyboard. As you press the up arrow key, previous commands, one by one, are retrieved and displayed at the shell prompt. As you continue to touch the up arrow key, previous commands are displayed until the last command is encountered. Conversely, you can use the down arrow key to move down the history list, retrieving more current commands. So, if you accidentally scoot past a command entry, you can come back to it with the down arrow key. When the command that you desire is displayed at the shell prompt, simply press Enter to execute it. Or, if required, you can edit the command line. By using the left and right arrow keys, you can maneuver the cursor along the command string. You can use the Backspace and Delete keys to rub out characters, and you can insert new characters into the command string. NOTE Among other shells, bash provides powerful editing of the command-line string. You can use many of the editing features of vi and Emacs. Refer to the bash documentation for details. You can also see the complete history list at once, using the history command. If the number of history entries is beyond the number of screen lines, the list scrolls and you will be unable to see some of the entries. The syntax for the history command is as follows: history [#] page 46
Note: In case you are looking for affordable webhost to host and run your web application check Vision http web server services

Inside Linux When you enter a command, the shell performs several tasks. First, it checks to see if the command is a built-in command. The shell checks to see if the command is an alias for another command. An alias is a substitute command that you specify to represent another command. If the command is neither a built-in nor an alias, the shell then looks for a program having the specified name. If the shell finds the program, it executes the program, passing any arguments supplied on the command line. One final note about shells and commands. If the command given is not a built-in command and cannot be found anywhere within the system, an error message will be displayed, as shown in the following sample dialog: stimpy $ thrilling thrilling: command not found Remember that Linux is a case-sensitive operating system. If you get the preceding error message, be sure to check the spelling and the case. Executing Commands Executing a command in Linux, as with other operating systems, requires you to specify a command (and any arguments) and to submit the command. Commands are carried out a number of ways. When you type a command and press the Enter key, the shell reads and then parses the command line. The shell checks to see if the command is known internally. All shells have a built-in command that it can execute directly. If the command is not an internal command, it checks its alias list for the command. An alias is an assumed name for another command. For example, if you are from the DOS world, you might want to create a command dir that is an alias for ls -al. If the shell finds an alias, it executes the real command. If the command is not an alias, the shell searches the system for an external program file. Remember that Linux is case sensitive, so the name must match exactly. If the command is found, the shell executes it, passing any arguments that are specified. So, you ask, what is an argument? An argument is an option to the specified command. An argument can be many things: a filename, a symbol, another command, a person’s name. There can be multiple arguments to a command. Some arguments are optional and some are mandatory. Some arguments, if given, must have arguments of their own. An argument is text given after the command, separated by field separator tokens (space, tab, and so on). The IFS environment variable is used to identify the list of separators. Some examples are discussed next. The following example demonstrates the cp (copy) command. The syntax for cp is as follows: cp source-filename destination-filename The cp command requires two arguments. If you execute the following: cp myfile.txt cp will print its usage and will not fulfill the request. Here is an example that shows an argument requiring an argument: mount /dev/hda1 /dos -t msdos The mount command is used to attach a filesystem onto a directory. In the previous example, a DOS FAT drive is attached to the /dos directory on the Linux filesystem. The third argument, -t (type of filesystem) requires a filesystem type name. Order of arguments can be important. Using the mount command as an example, the source filesystem must be given before the mount point. The -t is referred to as a flag or option. Flags are preceded by the dash (-) and are used to modify the command. The ls command has many options. None of the options are mandatory (that’s why they are called options). Options can be appended onto one another or combined. The following is an example using the ls command: stimpy $ ls -AlntF This ls command lists all files (except . and .. ), in long format, showing the user and group ID number instead of name, sorting by time modified instead of name, and marks each file entry with a symbol representing its type. Special symbols can exist within the command line string. Here are a couple of examples: stimpy $ ls -al > files.txt stimpy # ls -al | more page 45
Note: If you are looking for cheap webhost to host and run your apache application check Vision jboss web hosting services