You are on page 1of 47


This VirtualOperatingSystem application is a interface that is related with the operating system and the end user. The role of the interface plays is that of a virtual OS that comes up with commandline where a tree defined set of commands are allowed to be executed .the commandline is similar to that of a DOS command line where the users are allowed to type the commands.

When compared to training a end user on a package that is available across various operating systems. The end user is initially trained in the area of the OS , and then on the package.commands that are pertaining to the trainee are available in each OS. But has either the parameters differing are the command itself different. For example a command like Doskey that is available& functionally in the windows ,is unavailable on UNIX. This problem has made the enduser to learn different commands for each OS. The Virtual OS addresses this problem and creates a set of common commands that are requires for the company to trained their endusers using a single or common commands facility for providing online help and user guide is also provided.

Salient Features of Virtual Operating System

Environment & UserInterface The module deals with providing security to the application and creating the user interface. The security section identifies a valid user who is allowed to work on the application. The user has a facility to change his password.The user interface section is responsible to provide the required screens to allow the end user to work on the application.It provides a shell from where the end user executes the commands. .

File System maintenance Module This module provides and organizes commands that are pertaining to the maintenance of the files and directories. The user is allowed to execute commands that can create, change and remove directories. A user can identify and kill the files. A facility to rename and copy the file from the shell is also provided. Information about the OS is also retrieved.

Command Line editor an file handler module This module provides a facility to provide an editor from the command line that can be able to create, edit and delete files. A sort filter is created to sort the parameters specified. You can locate files using the file command, change the prompt when required and retrieve date & time. A facility to display the memory settings are also specified.

The analysis is the process of understanding the system at a greater depth, identifying the missing functions with an intention to improve it through better methods and procedures. The Requirement analysis is done in order to understand the problem, the Software system is to solve. Requirements analysis is on identifying what is needed from the system, not how the system will achieve its goals. The goal of requirements specification phase is to produce the software requirements specification document. The person responsible for the requirements analysis is often called the analyst. this phase we study the system and observe the problem of existing system and think how to cover the problems (problem analysis). There are three major activities in this phase are Problem analysis, Feasibility study and Software requirement specifications. The requirement document must specify all the functional and Performance requirements, the formats of inputs and outputs and all design constraints that exist due to political, economic, environment and security reasons. The phase ends with validation of the requirements specified in the document. Validation is often done through requirement review , in which a group of people including representatives of the client critically reviews the requirement specifications. PROBLEM ANALYSIS System analysis is the process of gathering and interpreting facts, diagnosing problems and using the information to recommend improvements to the system. Only after the systems analysis we can begin to determine how and where a computer information system can benefit all the users of the system. This accumulation of the system is called a system study. In this phase we analyze the problem to get a clear understanding of the problem. We study the existing system and observe the problems present in it, and then try to recover from them. The system that we are developing should overcome all the problems. FEASIBILITY STUDY The feasibility study is to determine whether the system requested is feasible or not. This is to identify the objectives of a new system. Before solving a problem one must know what the problem is. This phase starts as soon as a user or a member of a particular department recognizes a problem and initiates a request to computerize the existing manual system or to modify the current computerized system. The study is carried out by a small group of people who are familiar with systems analysis and design process. Fact-finding techniques are used to gather the required information. The major purposes of this study are given below: a) Identify the responsible user and to develop an initial scope of the system. This may involve conducting a series of interviews to see which users are involved in and which users are affected by the proposed project. b) Identify the current deficiencies in the users environment. This involves preparing a list of functions that are missing or operating unacceptably in the existing system. c) Determine objectives for the new system. This involves preparing a list of existing functions, which are to be reimplemented and new functions that are to be added. d) Determine whether it is feasible to automate the system. This will involves some approximate estimates of the schedule and cost to build a new system.

Three key considerations are involved in the feasibility analysis: Economic Feasibility Economic analysis is the most frequently used method for evaluating the effectiveness of a candidate system. More commonly known as cost/benefit analysis, the procedure is to determine the benefits and savings that are expected from a candidate system and compare them with costs. If it benefits out weigh costs, then the decision is made to design and implement the system. Otherwise, further justification or alterations in the proposed system will have to be made if it is to have a chance of being approved. This is an ongoing effort that improves in accuracy at each phase of the system life cycle. The current project is economically feasible because the organization, which is sponsoring to develop this system, has enough funds and they are ready to release the funds required by the development team and also the developers could be economically justified for their work. Technical Feasibility Technical feasibility centers on the existing computer system (hardware, software, etc.) and to what extent it can support the proposed addition. This involves financial considerations to accommodate technical enhancements. If the budget is a serious constraint, then the project is judged not feasible. The present project is considered to the technically feasible as the technical requirements, which could be satisfied very easily. We have the enough technological aspects to implement the above problem. Hence the project is technically feasible. Operational Feasibility Proposed projects are beneficial only if they can be tuned into information systems that will meet the organizations operating requirements. Simply stated, this test of feasibility asks if the system will work when it is developed and installed. Are there major barriers to implementation? Here are questions that will help test the operational feasibility of a project: a) Is there sufficient support for the project from management? From users? If the current system is well liked and used to the extent that persons will not be able to see reasons for change, there may be resistance. b) Are the current business methods acceptable to the users? If they are not, users may welcome a change that will bring about a more operational and useful systems. c) Have the users been involved in the planning and development of the project? Early involvement reduces the chances of resistance to the system and in general and increases the likelihood of successful projects. d) Will the proposed system cause harm? Will it produce poorer results in any respect or area? Will loss of control results in any area? Will accessibility of information be lost? Will individual performance be poorer after implementation than before? Will customers be affected in an undesirable way? Will the system slow performance in any area? Issues that appear to be relatively minor in the beginning have ways of growing into major problems after implementation. Therefore, all operational aspects must be considered carefully.

We can say after studying the proposed system that the project looks operationally feasible, as there is good support from management and the users involvement in planning and development is appreciable.

Software Requirement Specification

Software requirement specification (SRS) is the starting point of the software development activity.The SRS means translating the ideas in the minds of the clients (the input), into a formal document (the output of the requirements phase). Thus the output of the phase is a set of formally specified requirements, which hopefully are complete and consistent, while the input has none of these properties. A procedure for identifying requirements can there for be at best set of guidelines. The requirements specification phase consists of two basic activities. 1. Problem or requirement analysis 2. Requirement specification The requirement specification phase terminates with the production of the validation software requirement specification document. Role of SRS Thus there are three major parties interested in a new system the client, the users, the developer. There is a communication gap between these people. A basic purpose of SRS is to bridge this communication gap. SRS is the medium through which the client and user needs are accurately specified; indeed SRS forms the basis of software development. An important purpose of the process of developing an SRS is helping the clients to understand their own needs. A good SRS provides many benefits. Some of the goals it accomplishes are: a. Establishing the basis for agreement between the client and supplier on what the software product will be reducing the development cost. b. The preparation of the SRS forces rigorous specification of the requirements before the design begins. Careful development of an SRS can reveal omissions, inconsistencies and misunderstanding early in the development cycle, which can considerably reduce cost. c. Providing a reference for validation of the final product .The SRS assists in determining if the software meets the requirements.

Software Requirements 1. Operating System: Windows 98 or above 2. Front end : HTML & JAVA SCRIPT,J2EE(JSP,servlets,Ajax), 3. Back end : Oracle 8i 4. Web Server: Tomcat 5.5.9 Software specification 1. Operating system : Windows 2000/XP 2. Front end : HTML & XML 3. Middleware : J2EE(JSP) 4. Back end : Oracle 8i 5. Application server : Web logic 7.0

Software Profile
A Brief History of Java Java was conceived by James Gosling, Patrick Naughton, Chris Wrath, and Ed Frank Sheridan at Sun Microsystems, Inc. in 1991. It took 18 months to develop the first working version. James Gosling wanted to develop a software that is platform independent (that is architecture neutral) to communicate between two electronic devices for which be has started the work in January 1991 and completed in September 1992. The communication between two electronic devices was named as set top boxes. The project was success but there was no market. James Gosling wanted to modify the specification of set top boxes to meet the requirements of network programming, started the work to write a browser and completed in September 1994. The browser was named as Hot Java. It is the first commercial product from Sun Micro systems. James Gosling wanted to register the software by the name OAK, a name under a coffee tree. As he found that OAK was already registered, he changed it to Java. Features of Java Object Oriented Programming (OOP) is way to write software that is reusable, extensible and maintainable. Java is an Object Oriented language; i.e., it has facilities for OOP incorporated into the language. The core API is actually a collection of prefabricated OOP components, known to object orient programmers as a class library. Class libraries give programmers a bit head start when it comes to developing new projects. All object oriented programming languages provide mechanisms that help you implement the object orient model. They are encapsulation. Inheritance and polymorphism in addition to the essential element of object oriented programming i.e., abstraction. Abstraction: Grouping together related data and relevant functionality and identifying the group by a name, called the abstract name, is called abstraction. Encapsulation Encapsulation is the mechanism that binds together code and the data it manipulates and keeps both safe from outside interference and misuse. Inheritance: Inheritance is the process by which one object acquires the properties of another object. It is a means to achieve the features of a parent class to the child classes. Polymorphism: Polymorphism is feature that allows one interface to be used for a general class of actions. The specific action is determined by the exact nature of the situation. Multi-Threaded: Java was designed to meet the real-world requirement of creating interactive, networked programs. To accomplish this, Java supports multithreaded programming, which allows you to write programs that do many things simultaneously. Secure: When you use a Java compatible web browser, you can safely download Java applets without fear of viral infection or malicious intent. Java achieves this protection by confining a Java program to the Java execution environment and not allowing it access to other parts of the computer. Portability: Java programs can be written and can be executed anywhere without recompilation. When a Java file is compiled, it creates a class file. Class file consists of byte codes. A byte code is an instruction.

Introducation to JDBC Database constitutes the primary data resource in enterprise application.The JDBC API provides cross-vendor connectivity and data access across relational database from different vendors.A database vendor such as oracle, Oracle is the most widely used database in the world. It runs on virtually every kind of computer, from PCs and Macintoshes, to minicomputers and Giant mainframes. It functions virtually identical on all these machines, so when you learn it on one, you can use it on any other. This fact makes knowledgeable Oracle users and developers very much in demand and makes your Oracle knowledge and skills very portable. Because it is not cloaked in arcane language that only system Professionals can comprehend, Oracle fundamentally changes the nature of the relationship between system people. Since its first release Oracle has been based on the easily understood model, so nonprogrammers readily understood what Oracle did and how it did it. This model is approachable and unimposing. Connectivity The connectivity between the database and the front-end has been established using JDBC (Java Data Base Connectivity). JDBC is a powerful database implementation tool in Java. It is providing an easiest way to connect any DBMS and RDBMS software and allows implementing database operations. Java is using SQL for database operations. To connect a backend database with Java we must use Drivers. The driver indicates that we are connecting specific backend database. The JDBC-ODBC Bridge Driver has been used in this project. Connecting To Databases With JDBC It has been estimated that half of all software development involves client/server operations. A great promise of Java has been the ability to build platform independent client/server database applications. In Java 1.1 this has come to fruition with Java Database Connectivity (JDBC). One of the major problems with databases has been the feature war between the database companies. There is a "standard" database language, STRUCTURED QUERY LANGUAGE (SQL-92), but usually you must know which database vendor you're working with despite these Standard. JDBC is a Java API for executing Java SQL statements. It consists of set of classes and interfaces written in Java Programming Language. JDBC provides a standard API for tool/database developers and make them it possible to write database application using a pure Java API. Using JDBC, it is easy send SQL statements to any relational database. In other words ,It isn't necessary to write one program in Sybase database ,Other program to access the Oracle Database and so on. One can write single program using the JDBC API, and the program will be able to send the SQL statements to appropriate database. And, one doesn't have to worry to about writing different application to run on different platform. The combination of Java and JDBC lets programmer write once and run anywhere.Java being robust, secure, easy to understand and automatically downloadable on a network, is an excellent language basis for database applications. JDBC is designed to be platform-independent, so you don't need to worry about the database youre using while you're programming. However, its still possible to make vendor-specific calls from JDBC so you aren't restricted from doing what you must. JDBC,

like many of the APIs in Java, is designed for simplicity. The method calls you make correspond to the logical operations you'd think of doing when gathering data from a database: connect to the database, create a statement and execute the query, and look at the result set. To allow this platform independence, JDBC provides a driver manager that dynamically maintains all the driver objects that your database queries will need. So if you have three different kinds of vendor databases to connect to, you'll need three different driver objects. The driver objects register themselves with the driver manager at the time of loading, and you can force the loading using Class.forName (). To open a database, you must create a "database URL" that specifies: That you're using JDBC with "jdbc" 1) The "sub protocol" the name of the driver or the name of a database connectivity mechanism. Since the design of JDBC was inspired by ODBC, the first sub-protocol available is the "jdbc-odbc bridge", specified by "ODBC" 2) The database identifier This varies with the database driver used, but it generally provides a logical name that is mapped by the database administration software to a physical directory where the database tables are located. For your database identifier to have any meaning, you must register the name using your database administration software. (The process of registration varies from platform to platform.) All this information is combined into one string, the "database URL." For example, to connect through the ODBC sub-protocol to a database identified as "people", the database URL could be: String dbUrl = "jdbc: odbc: people"; If you're connecting across a network, the database URL will also contain the information identifying the remote machine. When you're ready to connect to the database, you call the STATIC method DriverManager.getConnection(), passing it the database URL, the user name, and a password to get into the database. You get back a Connection object that you can then use to query and manipulate the database. What does JDBC do? JDBC makes it possible to do three things : 1. Establish a connection with a database 2. Send SQL statements 3. Process the results Microsoft 's OBDC (Open DataBase Connectivity) is the most popularly used programming Interface for accessing relational database. It offers the ability to connect to almost all databases on almost all platforms.

Two-tier and three-tier Models The JDBC API supports both two-tier and three tier models for database access. In two-tier architecture, a Java applet or application talks directly to the database. This requires a JDBC driver that communicates with the particular database management system being accessed. A User's SQL statements are delivered to the database and results of those are sent back to the user. The database may be located on the other machine to with the user is connected via a network. This is referred to as client/server configuration, with the user machine as client and the machine housing the database as the server.

Java Application JDBC

DBMS In the three-tier model, commands are send to "middle tier" of services, which then send statements to the database. The databases process the SQL statements and send the results back to the middle tier, which send to the user. The middle tier has typically written in languages such as c, c++, which offers fast performance. However, with the introduction of optimized compiler that translates Java Byte code into efficient machine-Specific code, it is becoming practical to implement middle-tier in Java.

Java Applet or Browser

Application Server (Java) JDBC


Features Of Software Windows 2000 Advantages The computing world was presented with the first release of the totally new and revolutionary operating system. Microsoft windows performance and features that previously has been accessible only on $20,000 annotations became instantly available to anyone with a high-end personal computer. Windows is now Microsoft Corporations premier operating system. Designed around powerful and well-thought software architecture, the primary features that allow Windows to use the full power of todays processors are Scalability: The ability to run on a single pc chip with a single user up to a multi-user microprocessor and network installation. The Windows GUI The familiar graphical user interfaces it presents to the world.

Technologies used Web Components They are server side components generally used to provide the presentation layer to be returned to a client. 2 types of web components exist: Java Server Pages (JSP)
Java Server Page (JSP)

Java Server Pages technology is the Java technology in the J2EE platform for building applications containing dynamic Web content such as HTML, DHTML, XHTML and XML. The Java Server Pages technology enables the authoring of Web pages that create dynamic content easily but with maximum power and flexibility. The Java Server Pages technology provides a textual description for the creation of a response from a request. The technology builds on the following concepts: Template Data Substantial portions of dynamic content are actually fixed. The JSP technology allow for the natural manipulation of this data. Addition of Dynamic Data The JSP technology allows the addition of dynamic data to the template data in a way that is simple yet powerful. Encapsulation of Functionality The JSP technology provides two related mechanisms for the encapsulation of functionality: the standard Java Beans component architecture and the tag library mechanism. Good Tool Support The JSP technology has features that enable the creation of good authoring tools. The result is a flexible and powerful server-side technology. Benefits of the Java Server Pages Technology The Java Server Pages technology offers a number of benefits: Write Once, Run Anywhere properties The Java Server Pages technology is platform independent, both in its dynamic Web pages, Web servers, and its underlying server components. You can author JSP pages on any platform, run them on any Web server or Web enabled application server, and access them from any Web browser. High quality tool support The Write Once, Run Anywhere properties of JSP allows the user to choose best-of-breed tools. Additionally, an explicit goal of the Java Server Pages design is to enable the creation of high quality portable tools. Reuse of components and tag libraries The Java Server Pages technology emphasizes the use of reusable components such as Java Beans components, Enterprise Java Beans components and tag libraries. Separation of dynamic and static content The Java Server Pages technology enables the separation of static content from dynamic content that is inserted into the static template. Support for scripting and actions

The Java Server Pages technology supports scripting elements as well as actions. Actions permit the encapsulation of useful functionality in a convenient form that can also be manipulated by tools; scripts provide a mechanism to glue together this functionality in a per-page manner. Web access layer for N-tier enterprise application architecture(s) The Java Server Pages technology is an integral part of the Java 2 Platform Enterprise Edition (J2EE), which brings Java technology to enterprise computing.

It is true that both servlets and JSP pages have many features in common and can be used for serving up dynamic web content. Naturally, this may cause some confusion as to when to opt for one of the technologies over the other. Java Server Pages provide a much cleaner separation of presentation from logic, and are simpler to write. Together, JSP technology and servlets provide an attractive alternative to other types of dynamic web scripting/programming that offers platform independence, enhanced performance, separation of logic from display, ease of administration, extensibility into the enterprise and most importantly, ease of use. Server Components Server components can be in form of EJBs (Enterprise Java beans). EJBs executes within a container that manages the runtime behavior of EJBs. Working with the Model View Controller Typically entity beans are used to provide the model logic, while a mix of entity beans and session beans are used to provide the control logic and web components are used to Implement both control and presentation logic. The Java Beans specification allows software components to be written in java, which encapsulates the logic behind the web application and remove the bulk of the script let code that would otherwise clutter up the jsp. The result JSP code that is simpler, easier to maintain, and which is more readily accessible to non-programmers. Java uses the beans specification to allow the creation of software components that can be used by other developers and designers to build specialist applications. Javas cross platform nature means that the same Java bean should be reusable across any machine. This really frees us from dependence on any particular platform Database used

Database is a major concern in a customer support tool application. Hence, made a detailed study to find the most suitable databases for the project. The result was Oracle. ORACLE Oracle is a trademark of Oracle Corporation and in common usage refers to the database engine (which actually looks for the data) and the range of front-end products. Oracle 8i is the largest selling SQL-based RDBMS and a most commercially useful product. Advantage of Oracle 8i About Oracle 8i Oracle is an RDBMS as it stores and manages data using relational model. Oracle server receives SQL data commands from users and executes them on the database users of oracle database use logical view of the data. Users view the total data as a collection of tables when each table contains rows and columns that means physical structure of database is hidden from users. Database is a major concern in a customer support tool application. Hence, made a detailed study to find the most suitable databases for the project. The result was Oracle. Oracle is a trademark of Oracle Corporation and in common usage refers to the database engine (which actually looks for the data) and the range of front-end products. Oracle 8i is the largest selling SQL-based RDBMS and a most commercially useful product. Advantage of Oracle 8i Portability Oracle is ported for more platforms than any of its competitors running on more than 100 hardware platforms and 20 Networking protocols. This makes writing an Oracle application fairly safe from changes of direction in hardware and operating system and therefore a safe bet. Oracle 8i provides support for online backup and recovery and good software fault tolerance to disk failure. You can also do point-in-time recovery. Performance Speed of Oracle 8i database is quite well managed. Even with large database oracle 8i refers to more than 100GB databases and the performance is only raw. But includes consideration of performance with locking and transaction control. Multiple Database Support Oracle 8i has superior ability to manage multiple databases within the same transaction using a two-phase commit protocol. You can easily move were the data is actually stored from node-to-node in a network and have a data mirror, making it easy to optimize the location of the data from time to time. Compatibility Oracle 8i software is compatible with industry standard and industry standard operating systems. The applications developed can be used on any systems with little or no modification. Connect ability Oracle 8i software allows different computers and operating systems to share information across networks

Security Oracle 8i provides powerful security features to limit and monitor data access. These features make it easy to manage even the most complex design of data access. Products of Oracle 8i The following are some of the products of Oracle: 1. SQL * PLUS 2. SQL * DBA 3. SQL * FORMS Server Specification Every inspection tool application needs an application server that provides a runtime environment for them. We also needed an application server for the successful working of our application. One reason for using J2EE as a web development tool is that various application servers support it. Hence, we have a choice to select servers such as BEA Weblogic, ATG dynamic and IBM Web Sphere. Among all these, our choice was BEA WebLogic. WebLogic is an industry-leading product that gives maximum choice and flexibility in building robust inspection tool applications that extend from web to the enterprise. It is high performance Java application server, which incorporates the most comprehensive implementation of the Java 2 Enterprise Edition (J2EE) standards. WebLogic server provides the foundation for the rapid development of web applications and the performance and reliability required for mission-critical inspection tool sites. The reasons for choosing WebLogic in our application are, 1. Java Server Pages (JSPs), Java Message Services (JMS), Java Database Connectivity (JDBC) as specified by the J2EE standard. 2. Support for Oracle database. 3. Multitiered JDBC which allows a Java application to access and update database from anywhere on the network. The server includes its native JDBC driver fro leading database product and works. BEA Web Logic 1. Fully implements 10 of the 12Enterprise Java APIs, including JDBC, EJB, RMI, event management, and JNDI 2. Provides the most comprehensive implementation of the Enterprise Java Beans 1.0 specification, including optional services such as session and entity beans 3. Provides tools to aid in the creation and management of Enterprise Java Beans, permitting the hosting of both custom and off-the-shelf business components 4. Provides support for persistency to multiple databases 5. Deploys and manages applications to ensure scalability, availability, and security 6. Works easily with industry-leading databases, as well as Microsoft Visual Basic, Visual C++, Active Server Pages, and COM 7. Works easily with industry-leading development tools, including Visual Cafe, JBuilder, Supercede, J++, and Visual Age

BEA Server Scalability A BEA WebLogic server scales to support many clients by carefully managing threads and connections. With BEA WebLogic, a single client/server connection is shared across all bi-directional communications, regardless of the request type and the number of remote objects being accessed. Database connections are also shared so that the maximum number of simultaneous clients can be supported. BEA WebLogic caches database query results and can automatically update cached data in real-time as changes are made to the backing DBMS. Standard Internet Protocols Web browsers can access the BEA WebLogic application server via normal HTTP requests. Forwarding capabilities, such as HTTP proxying, enable dispatching to servers other than the original web server. For higher performance, HTTP connections are maintained across requests.All BEA WebLogic services are also accessible via CORBA IIOP and TCP/sockets. Management BEA WebLogic provides centralized management for a potentially large distributed configuration of clients and servers through a ingle cohesive view of the overall system. Zero Administration Client (ZAC). The BEA WebLogic application server supports the automatic distribution of Java applets, applications, or systems. With ZAC, program librarieseven a new BEA Web Logic releasecan be installed entirely by an administrator. BEA Web Logic pushes each updated component to all appropriate clients. The ZAC client itself has a very small footprint. Dynamic Application Partitioning The EA Web Logic application server permits online application components to be dynamically allocated across machines. Graphical Management Console The BEA Web Logic application ever offers a comprehensive pure-Java console for remotely monitoring and updating the state of your WebLogic application and WebLogic server cluster. Multiple clients and servers can be securely and easily managed from a single remote console. Integrated Logging The BEA WebLogic application server automatically logs diagnostic and security audit information and provides interfaces for applications to log their own exception conditions. Optionally, HTTP traffic can be logged in common log format. Logs can be viewed remotely from a web browser r from the BEA WebLogic management console.

Hardware specifications 1. 2. 3. 4. 5. 6. 7. Processor RAM Hard disk Monitor Keyboard Mouse Floppy drive : Pentium - IV : 128 MB : 10 GB : SVGA Monitor (800 * 600 resolutions) : 101 keys : Scroll mouse : 1.44 MB

DESIGN System design goes through two phases of development: 1) Logical design 2) physical design. The design covers the following: 1.Review the current physical system: - its data flows, file content, volumes, frequencies etc. 2.Prepares output specifications: - that is, determines the format content and frequency of reports, including terminal specifications and locations.

3. Prepares input specifications- format, content and most of the input functions. This includes determining the flow of the document from the input data source to the actual input location. y Prepares edit, security and control specifications. This includes specifying the rules for edit correction, backup procedures and the controls that ensure processing and file integrity. y Specifies the implementation plan. y Prepares a logical design walkthrough of the information flow, output, input, c ontrols and implementation plan. y Review benefits, costs, target dates and system constraints



VirtualOperating System

User Commands performed System

Overall Usecase Diagram For VOS:

Authentication Checking


FileManipulation User System NetWork Mgmt

Commandline Surfing

Commandline Editing

LowlevelClass Diagram of VOS:

UserInterfa ce ta : JTextArea tf : JTextField tz : StringTokenizer prompt : JLabel commandenter : String: String token currentpath : String UserInterface() actionPerformed() keyPressed()

JFram e Inherit s <<Interface >> UrlConnecti on

invoke s

implemen ts :UrlInfo::NetWorkm gmt token : String getData() openConnection()

High Level Class Diagram:

FileManip Dir


UserInterface Invokes

NetWork Mgm





CommandlineEdit Editor

StateChart Diagram For VOS:

Start Request User Request For Access VOS Login


nvalid Connected to The UserInterface


CommandsSurfing Commands Surfed By the User Termination Termination by the User

Activity Diagrams For Find & Run Commands



Find Command Surfing

Run Command Surfing

Information About the File

First Process

Second Process

And other


OverallSequenceDiagram of VOS:


:Dir::FileMani p

1: Dir

:IP::NetWor k Mgm t

n dLineSur f

3: info to UI

2 :

:Edit::Comma n dlineedi t

:Syste m

4: IP or UrlInfo

6: Information to UI

5 :

7: VosKey

9: Information to I

8 :

10: 12: Quit on Editor Editor

11 :

Activity Diagram for VOS:



Authentication Checking

Cm ds FileManipulationCmds Cm ds NetWorkMgmtCmds Cm ds Commandline Surfing Cm ds CommandlineEditing


Data Flow Diagram (DFD)

The first step is to draw a data flow diagram (DFD). The DFD first developed by Larry Constantine as a way of expressing system requirements in a graphical form; this led to a modular form. A DFD, also known as a bubble chart has the purpose of clarifying system requirements and identifying major transformations that will become programs in system design. So it is starting point of the design phase that functionally decomposes the requirements specifications down to the lowest level of detail. A DFD consists of a series of bubbles joined by lines. The bubbles represent data transformations and the lines represent data flows in the system. 1. In the DFD there are four symbols: 2. A square defines a source (originator) or destination of system data 3. An arrow identifies data flow- data in motion. It is a pipeline through which information flows. 4. A circle or a bubble (some use an oval bubble) represents a process that transforms incoming data flows into outgoing data flows 5. An open rectangle is a data store- data at rest or a temporary repository of data A DFD uses four basic elements: 1. 2. 3. 4. Process: Process shows what the system does. Each process has one or more inputs and produces one or more outputs. Circles in DFD represent processes. Each process has a unique name and number. This name and number appear inside the circle that represents the process in a DFD. Files or data stores: A file or data store is a repository of data. They contain data that is retained in the system. Process can either enter data into a data store or retrieve data from the data store. A thin line in the DFD represents each data store and each data store has a unique name. External entities: External entities are outside the system, but they supply input data into the system or use the system output. External entities are represented by a square or a rectangle. External entities that supply data into a system are sometimes called source.External entities that use the system data are sometimes called sinks. Data flows: Data flows model passage of data in the system and are represented by lines joining system components. An arrow indicates the direction of the flow and the line is labeled by the name of the data flow, flows of the data in the system can take place 1. Between a data store to a process 2. From a process to a data store Processes Files or data stores External entities Data flows

3. From a process to a process; and 4. From a process to a sink We have no control flows between external entities, so we do not model them. Similarly, stores are passive and cannot have data flows between themselves. Data Flow Diagrams A Collection of components that work together to realize some objective is called a System. An information system is nothing but a system that provides information to people in an organization. A new system may be built afresh or by changing the existing system. Systems analysis is an important activity that takes place when new information systems are being built or existing ones are changed. A set of steps that define how things are done is called as a Process. A process followed to determine what the system does and what is required of it is systems analysis. This is central to the whole of system development. It includes gathering the necessary data and developing plans for new systems. The data flow diagram (DFD) is one of the most important modeling tools used by the systems analysts. DFDs use a number of symbols to represent systems. There are four kinds of symbols and are used to represent four kinds of system components namely processes, data stores, data flows and external entities. DFDs are used to illustrate how data flows in a system.

Process Name

OSProcess.javacode block simulates the command prompt in a real time Operating System. importjava.lang.*; importjava.util.*; import*; importjava.awt.*; importjava.awt.event.*; importjava.applet.*; importjavax.swing.*; import*;

public class OSProces extends JFrame { publicJTextArea ta; publicTextFieldtf; StringTokenizertz=null; Container cp=null; booleanfindFile; JLabel prompt; intloc=0,j; String commandenter,token,str,currentpath,pt; String []keys=new String[50]; publicOSProces() { File f=new File("\\"); currentpath=f.getAbsolutePath(); pt=currentpath; prompt=new JLabel(currentpath); // File f=new File(arg) ; cp=getContentPane(); cp.setLayout(null); tf=new TextField(500); ta=new JTextArea(); Font k=new Font("Sans Serif",Font.PLAIN,14); ta.setFont(k); JScrollPanejsp=new JScrollPane(ta,ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,ScrollPaneC onstants.HORIZONTAL_SCROLLBAR_AS_NEEDED); jsp.setBounds(30,30,700,400); tf.setBounds(30,450,700,30); prompt.setBounds(30,435,150,20);

ta.setBackground(; tf.setBackground(; ta.setForeground(Color.lightGray); tf.setForeground(Color.lightGray); ta.setEditable(false); //tf.setFocus(); cp.add(tf); cp.add(jsp); cp.add(prompt); tf.addKeyListener(new KeyAdapter() { public void keyPressed(KeyEventke) { int c=ke.getKeyCode(); if(c==ke.VK_ENTER) { commandenter=tf.getText(); tz=new StringTokenizer(commandenter); token=tz.nextToken(); keys[loc]=commandenter; System.out.println(keys[loc]); loc=loc+1; j=loc; //ta.append(currentpath+commandenter+"\n"); if(token.equalsIgnoreCase("find")) { Find1 ff=new Find1(); str= ff.getData(commandenter); str+="\n"; System.out.println(str); ta.append(str); tf.setText(""); } else if(token.equalsIgnoreCase("date")) { date1 d=new date1(); str=d.getDate(); str+="\n"; ta.append(str); tf.setText(""); } else if(token.equalsIgnoreCase("cls")||token.equalsIgnoreCase("clear")) {




ta.setText(" "); tf.setText(""); } else if(token.equalsIgnoreCase("exit")||token.equalsIgnoreCase("quit")) { Object[] options={"yes","cancel"};


intext =JOptionPane.showOptionDialog(null,"Do you Want to Exit","Warning",JOptionPane.OK_OPTION,JOptionPane.WARNING_MESSAGE,null,optio ns,options[0]); if(ext==0) System.exit(0); else tf.setText(""); } else if(token.equalsIgnoreCase("run")) //||token.equalsIgnoreCase("start")) //RUN { Run r=new Run(); str=r.getData(commandenter,currentpath); str+="\n"; ta.append(str); tf.setText(""); } else if(token.equalsIgnoreCase("start")) { Start r=new Start(); str=r.getData(commandenter,currentpath); str+="\n"; ta.append(str); tf.setText(""); } else if(token.equalsIgnoreCase("del")) { Del d1=new Del(); str=d1.getData(commandenter,currentpath); str+="\n"; ta.append(str); tf.setText(""); } /* else if(token.equalsIgnoreCase("whois")) //WHOIS { Whois w=new Whois(); str=w.getData(commandenter); str+="\n"; ta.append(str); tf.setText(""); } */


else if(token.equalsIgnoreCase("memcheck")) { MemCheck mc=new MemCheck(); str= mc.getData(commandenter); str+="\n"; ta.append(str); tf.setText(""); } else if(token.equalsIgnoreCase("dir")) { String filelength,info,s1; int d=0,fn=0; long bytes=0,k=0,tm=0; File f=new File(currentpath); info=" Directory of "+f.getPath()+"\n"; ta.append(info); String filenames[]=f.list(); Runtime r=Runtime.getRuntime(); tm= r.totalMemory(); for(inti=0;i<filenames.length;i++) { File f1=new File(currentpath+"/"+filenames[i]);



str= String.valueOf(new java.util.Date(f1.lastModified())); StringTokenizerdd=new StringTokenizer(str); dd.nextToken(); String mon=dd.nextToken(); String day=dd.nextToken(); dd.nextToken();dd.nextToken(); String year=dd.nextToken(); String str1=mon+"/"+day+"/"+year;

if(f1.isDirectory()) { ta.append(str1); ta.append(" ta.append("+filenames[i]); ta.append("\n"); /*//ta.append(str); s1=str+"<<DIR>> ta.append(s1);*/



d++; } else { filelength=String.valueOf(f1.length()); ta.append(str1); ta.append(""+filelength); // ta.append(filelength); ta.append("+filenames[i]); // ta.append(filenames[i]); ta.append("\n"); tf.setText(""); fn++; bytes+=f1.length(); }} k=tm-bytes; str=" "+fn+"File(s)"+""+bytes+" bytes"+"\n"; str+=" d+"Dir(s)" + ""+k+" bytes are free"+"\n"; ta.append(str); } else if(token.equalsIgnoreCase("md")) { while(tz.hasMoreTokens()) { try { token=tz.nextToken(); System.out.println(token); //currentpath=currentpath+"\\"+token; File md=new File(currentpath+"/"+token); if(md.isDirectory()) { ta.append("A subdirectory or file" +md.getPath()+"already exists."+"\n"); tf.setText(""); // break; } else { md.mkdir(); prompt.setText(currentpath); ta.append("A Directory "+md.getPath()+" Created"); tf.setText(""); } } catch(Exception e){System.out.println("Exception:md");} } }


else if(commandenter.endsWith(":")) { File f=new File(tf.getText()+"\\"); if(f.isDirectory()) { Object o=(Object) f; currentpath=o.toString(); pt=currentpath; prompt.setText(currentpath); tf.setText(""); } else { ta.append(currentpath+"\\"+f.getPath()+"\n"+"The system cannot find the drive specified."+"\n"); tf.setText(""); } } /*else if(token.equalsIgnoreCase("e:")) //PATH E:D:.... { currentpath="e:\\"; pt=currentpath; prompt.setText(currentpath); tf.setText(""); } else if(token.equalsIgnoreCase("c:")) { currentpath="c:\\"; pt=currentpath; prompt.setText(currentpath); tf.setText(""); } else if(token.equalsIgnoreCase("d:")) { currentpath="d:\\"; pt=currentpath; prompt.setText(currentpath); tf.setText(""); } else if(token.equalsIgnoreCase("f:")) { currentpath="f:\\"; pt=currentpath; prompt.setText(currentpath); tf.setText(""); } */

else if(token.equalsIgnoreCase("cd")) { while(tz.hasMoreTokens()) { try { token=tz.nextToken(); if(token.equalsIgnoreCase("\\")) { currentpath=pt; prompt.setText(currentpath); tf.setText(""); } else { File cd=new File(currentpath+"\\"+token); if(cd.isDirectory()) { currentpath=currentpath+"\\"+token; prompt.setText(currentpath); tf.setText(""); } else { ta.append("The system cannot find the path specified."+"\n"); tf.setText(""); } } } catch(Exception e){ ta.append("Exception Raised:"); } } } else if(token.equalsIgnoreCase("manual")) { String s; //intch; try { File man=new File("d:\\ramu\\helpfile.txt"); FileReaderfr=new FileReader(man); BufferedReaderbr=new BufferedReader(fr); while((s=br.readLine())!=null) ta.append(s+"\n"); tf.setText(""); } catch(Exception e){ System.out.println(e.getMessage()); } }



else if(token.equalsIgnoreCase("help")) { Help h1=new Help(); str=h1.getData(commandenter); str+="\n"; ta.append(str); tf.setText(""); } else if(token.equalsIgnoreCase("cd\\")) { currentpath=pt; prompt.setText(currentpath); tf.setText(""); } else if(token.equalsIgnoreCase("ip")) { intservererror=0; while(tz.hasMoreTokens()) { token=tz.nextToken(); try { InetAddresssw[]=InetAddress.getAllByName(token); for(inti=0;i<sw.length;i++) ta.append(sw[i]+"\n"); } catch(Exception e) { servererror=1; System.out.println(e.getMessage()); ta.append(e.getMessage()); tf.setText(""); } if(servererror==1) tf.setText(""); } } else { ta.append("illegal command!"+"\n"); tf.setText(""); } } if(c==ke.VK_UP) { System.out.println(loc); String a1; if(loc>0) //CD\


loc--; a1=keys[loc]; tf.setText(a1); // ta.append("Arrow key UP"); } if(c==ke.VK_DOWN) { String a1; if(loc<j-1) loc++; a1=keys[loc]; System.out.println(j); System.out.println(loc); tf.setText(a1); } } }); tf.addKeyListener(new KeyAdapter() { public void keyReleased(KeyEventke) { } }); tf.addKeyListener(new KeyAdapter() { public void keyTyped(KeyEventke) { } }); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent we) { System.exit(0); } }); } public static void main(String args[]) { OSProcesosp=new OSProces(); osp.setTitle("Virtual Operating System"); osp.setSize(400,400); osp.setVisible(true); System.out.println("helo"); } }


Run.javacode block takes the programs name as input and opens the corresponding process just as similar as RUN command in WINDOWS. import*; importjava.util.*; importjava.awt.*; public class Run { String token,exception,info="",ta_Run=""; StringTokenizertokenizer=null; public Run() {} public String getData(String tz) { System.out.println("is Working?"); tokenizer=new StringTokenizer(tz); token=tokenizer.nextToken();

while(tokenizer.hasMoreTokens()) { token=tokenizer.nextToken(); Runtime r=Runtime.getRuntime(); Process p=null; try { p=r.exec(token); info+=token+","+"in Process"+"\n"; } catch(Exception e) { info="can not file"; } System.out.println(info); }//while return info; }//method public static void main(String args[]) { Run r1=new Run(); System.out.println(r1.getData("run pbrushcalc")); } }//class

Types Of Testing After a test plan has been developed, system testing begins by testing program modules separately, followed by testing bundled modules as a unit. A program module may function perfectly in isolation but fail when interfaced with other modules. The approach is to test each entity with successively larger ones, up to the system test level. System testing consists of the following steps 1. Program(s) testing. 2. String testing. 3. System testing. 4. System documentation. 5. User acceptance testing. Program testing A program represents the logical elements of system. For a program to run satisfactorily, it must compile and test data correctly and tie in properly with other programs. Achieving an error-free program is the responsibility of the programmer. Program testing checks for two types of errors: syntax and logic. A syntax error is a program statement that violates one or more rules of the language in which it is written. An improperly defined field dimension or omitted key words are common syntax errors. These errors are shown through error messages generated by syntax errors. These errors are shown through error messages generated by the computer. A logic error, on the other hand, deals with incorrect data fields, out-of range items, and invalid combinations. Since diagnostics do not detect logic errors, the programmer must examine the output carefully for them. When a program is tested, the actual output is compared with the expected output. When there is a discrepancy, the sequence of instructions must be traced to determine the problem. The process is facilitated by breaking the program down into self-contained portions, each of which can be checked at certain key points. The idea is to compare program values against desk-calculated values to isolate the problem. String Testing Programs are invariably related to one another and interact in a total system. Each program is tested to see whether it conforms to related programs in the system. Each portion of the system is tested against the entire module with both test and live data before the entire system is ready to be tested. System Testing System testing is designed to uncover weaknesses that were not found in earlier tests. This includes forced system failure and validation of the total system as it will be implemented by its user(s) in the operational environment. Generally, it begins with low volumes of transactions based on live data. The volume is increased until the maximum level for each transaction type is reached. The total system is also tested for recovery and fallback after various major failures to ensure that no data are lost during the emergency. All this is done with the old system still in operation. After the candidate system passes the test, the old system is discontinued.

System Documentation All design and test documentation should be finalized and entered in the library for future reference. The library is the central location for maintenance of the new system. The format, organization, and language of each documentation should be in line with system standards. User Acceptance Testing An acceptance test has the objective of selling the user on the validity and reliability of the system. It verifies that the systems procedures operate to system specifications and that the integrity of vital data is maintained. Performance of an acceptance test is actually the users show. User motivation and knowledge are critical for the successful performance of the system. Then a comprehensive test report is prepared. The report indicates the systems tolerance, performance range, error rate, and accuracy. Tests Performed In The Virtual Operating System Application String testing All inputs to the applications are in the form of string. The strings were tested for nulls, it was tested for length as well as in data types conversions.Exceptions were handled to check if the above validations were performed and errors handled. Unit testing Every module was individually tested where each command output was checked to receive appropriate inputs and if it generated appropriate outputs. Every command was individually checked to output correct data. The alignment of the data, scrolling, visibility of text output were all checked for appropriateness. Integrated Testing All the modules 1. 2. 3. 4. 5. Environment and user interface module. File system maintenance module. Network management module. Command-line surfing module. Command-line editing and fille handling modulle.

were combined and then executed as a single unit . It was found to be executing in a synchronized manner. The user interface module interacted with the commands module to provide the input, to the command module and receive the output back on the interface module. Similarly handshaking visible between other modules. Top down Testing The control of flow in the application was tested with that of design phase. The application was top down tested to check if the sequence windows/frames that open every time an event was executed was in sequence or not. The results obtained were found to be that of design phase

Black box Testing: In the module that handled networking commands sockets are created and queried upon based on the commands .The inputs to the sockets ,the expected outputs visible and known. The functional logic that was part of the data being retrieved as well as any error resulting were not known as it was a result of incoming data from a remote machine. The user interface module was black box tested to check the control flow .In the other modules in file system related commands this testing was done to check if the output returned were appropriate. White box Testing As the application contains code that was mostly in the form of loops and conditions checking every statement was necessary most often only positive conditions are checked using few inputs .This resulted in bypassing almost of statement which were never being checked. In order to verify that every statement was executed at least once inputs that were vary was executed at least once. In the five modules 1. 2. 3. 4. 5. Environment & User Interface Module File System Maintenance Module Network Management Module Command-Line Surfing Module Command-line Editor & File Handlers

Were White box tested to remove any unexpected errors /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////// import filemanip.*; import networkmgmt.*; iImport commandsurf.*; import commandedit.*; import java.lang.*; import java.util.*; import*; import java.awt.*; import java.awt.event.*; import java.applet.*; import javax.swing.*; import*;

public class UserInterface extends JFrame { public JTextArea ta; public TextField tf;

StringTokenizer tz=null; Container cp=null; boolean findFile; JLabel prompt; int loc=0,j; String commandenter,token,str,currentpath,pt; String []keys=new String[50]; public UserInterface() { File f=new File("\\"); currentpath=f.getAbsolutePath(); pt=currentpath; prompt=new JLabel(currentpath); // File f=new File(arg) ; cp=getContentPane(); cp.setLayout(null); tf=new TextField(500); ta=new JTextArea(); Font k=new Font("Sans Serif",Font.PLAIN,14); ta.setFont(k); JScrollPane jsp=new JScrollPane(ta,ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,ScrollPaneC onstants.HORIZONTAL_SCROLLBAR_AS_NEEDED); jsp.setBounds(30,30,700,400); tf.setBounds(30,450,700,30); prompt.setBounds(30,435,150,20); ta.setBackground(; tf.setBackground(; ta.setForeground(Color.lightGray); tf.setForeground(Color.lightGray); ta.setEditable(false); //tf.setFocus(); cp.add(tf); cp.add(jsp); cp.add(prompt); tf.addKeyListener(new KeyAdapter() { public void keyPressed(KeyEvent ke) { int c=ke.getKeyCode(); if(c==ke.VK_ENTER) { commandenter=tf.getText();

tz=new StringTokenizer(commandenter); token=tz.nextToken(); keys[loc]=commandenter; System.out.println(keys[loc]); loc=loc+1; j=loc; //ta.append(currentpath+commandenter+"\n"); if(token.equalsIgnoreCase("find")) Find1 ff=new Find1(); ta= ff.getData(commandenter, ta); tf.setText(""); }

else if(token.equalsIgnoreCase("open")||token.equalsIgnoreCase("show")) { Open o=new Open(); ta=o.getData(commandenter,currentpath, ta); tf.setText(""); }

Output Screens

1) Starting the VOS.

2) Help Manual showing various commands in VOS.

3) Screen showing the execution of "dir" command.

4) Run process opens "paint", "calculator", "notepad".

5) Changing the color of console from black to blue.

6) Memory check command. shows the memory status of the machine.

1. New modules can be added to the existing modules without effecting the applications exists in performance.

2. A graphical output can be made available rather than text output. 3. You can implements windows explorer style navigation.