Question

Creating a Shell Interface Using Java

This project consists of modifying a Java program so that it serves as a shell interface that accepts user commands and then executes each command in a separate process external to the Java virtual machine.

Overview

A shell interface provides the user with a prompt, after which the user enters the next command. The example below illustrates the prompt jsh> and the user’s next command: cat Prog.java. This command displays the file Prog.java on the terminal using the UNIX cat command. jsh> cat Prog.java Perhaps the easiest technique for implementing a shell interface is to have the program first read what the user enters on the command line (here, cat Prog.java) and then create a separate external process that performs the command. We create the separate process using the ProcessBuilder() object, as illustrated in Figure 3.13. In our example, this separate process is external to the JVM and begins execution when its run() method is invoked. A Java program that provides the basic operations of a command-line shell is supplied in Figure 3.37. The main() method presents the prompt jsh> (for java shell) and waits to read input from the user. The program is terminated when the user enters <Control><C> .

import java.io.*; public class SimpleShell { public static void main(String[] args) throws java.io.IOException { String commandLine; BufferedReader console = new BufferedReader (new InputStreamReader(System.in)); // we break out with while (true) { // read what the user entered System.out.print("jsh>"); commandLine = console.readLine(); // if the user entered a return, just loop again if (commandLine.equals("")) continue; /** The steps are: (1) parse the input to obtain the command and any parameters (2) create a ProcessBuilder object (3) start the process (4) obtain the output stream (5) output the contents returned by the command */ } } }

This project is organized into three parts:

(1) creating the external process

modify the main() method in the code above so that an external process is created and executes the command specified by the user. initially, the command must be parsed into separate parameters and passed to the constructor for the ProcessBuilder object.

(2) modifying the shell to allow changing directories

the cd command allows a user to change current directories. yourt shell interface must support this command. for example, if the current directory is /usr/tom and the user enters cd music, the current directory becomes /usr/tom/music . Subsequent commands relate to this current directory. Program must first check the new path being specified is a valid directory and if not, then display an error message. the following commands must be supported:

cd - return to a directory (home/user/1)

cd ~- return to the home directory

cd..- go up one level in directory tree

cd ../.. - go up 2 levels

cd/ - go to root directory

the home directory for the current user can be obtained by nvoking the static getProperty() method in the System class : System.getProperty("user.dir")

Answer 1

Program Screenshot:

SimpleShell.java

Code to copy:

/*

* Part (1) creating the external process and

* executing the command in that process

*/

import java.io.*;

import java.util.*;

public class SimpleShell

{

       public static void main(String[] args) throws java.io.IOException

       {

              String commandLine;

              BufferedReader console = new BufferedReader

                           (new InputStreamReader(System.in));

              // we break out with <control><C>

              while (true)

              {

                     // read what the user entered

                     System.out.print("jsh>");

                     commandLine = console.readLine();

                     // if the user entered a return, just loop again

                     if (commandLine.equals(""))

                           continue;

                     // (1) parse the input to obtain the command and

                     // any parameters

                     StringTokenizer token = new StringTokenizer(commandLine);

                     ArrayList<String> commandList = new ArrayList<String>();

                     //read the tokens and add to the list

                     while (token.hasMoreTokens())

                     {

                           commandList.add(token.nextToken());

                     }

                    

                     String[] commands = commandList.toArray(new String[0]);

                     // (2)create a ProcessBuilder object

                     ProcessBuilder pb = new ProcessBuilder(commands);   

                     // (3) start the process

                     Process process = pb.start();

                     // (4) Obtain the output stream

                     InputStream inStream = process.getInputStream();

                     InputStreamReader inStreamReader = new InputStreamReader(inStream);

                     // (5) output the contents returned by the command

                     BufferedReader br = new BufferedReader(inStreamReader);

                     String line;

                     while ((line = br.readLine()) != null)

                     {

                           System.out.println(line);

                     }

                     br.close();

              }

       }

}

*Part (1) creating the external process and * executing the command in that process import java.io.; import java.util.*; public class SimpleShell public static void main (String[] args) throws java.io.IOException String commandLine; BufferedReader console-new BufferedReader (new InputstreamReader (System. in) ); // we break out with while (true) // read what the user entered System.out.print ("jsh>") CommandLine = console. readLine() ; // if the user entered a return, just loop again if (commandLine.equals ("")) continue // (1) parse the input to obtain the command and // any parameters StringTokenizer token- new StringTokenizer (commandLine) ArrayList commandList new ArrayList(); //read the tokens and add to the list while (token.hasMoreTokens ()) commandList.add (token.nextToken )) String [ commandscommandList.toArray (new String [0]); // (2) create a ProcessBuilder object ProcessBuilder pb new ProcessBuilder (commands) // (3) start the process Process processpb.start)i