CMSC 341 – Data Structures Spring 2012 University of Maryland, Baltimore County ANT, CVS and CVS Utilities Slides prepared by Prajit Kumar Das – Summarized

CMSC 341 – Data Structures

Spring 2012

University of Maryland, Baltimore County

ANT, CVS and CVS ANT, CVS and CVS UtilitiesUtilities

Slides prepared by Prajit Kumar Das – Summarized from older CMSC 341 slides provided by Dr. Yun Peng

July 2011 CMSC 341 CVS/Ant 2

PackagesPackages• A file may belong to only one

package.• Packages serve as a namespace

in Java and create a directory hierarchy when compiled.

• Classes are placed in a package using the following syntax in the first line that is not a comment.

package packagename;

package packagename.subpackagename;


Packages (cont.)Packages (cont.)• It is common practice to duplicate the package

directory hierarchy in a directory named src and to compile to a directory named bin.

• Create this directory manually in your GL account– Eclipse creates this directory structure for you

Project1

proj1

proj1

src

bin

Example.java

Example.class

Package name

Root of project directory tree

Package name


Compiling with packagesCompiling with packages• When using the Unix command line, classes in a

package are compiled using the –d option.• Given the directory structure on the previous slide,

run the command below from the src directory to compile the code from the Project1/src directory to the Project1/bin directory.

• The -d switch tells the compiler where to place the .class file

• The bin directory must exist before compiling. The compiler will create the proj1 directory under bin.

javac –d ../bin proj1/Example.java


Packages and EclipsePackages and Eclipse• By default Eclipse automatically

creates a src/ directory when you create a new Java Project

• Eclipse will then automatically create a bin/ directory and associated package directory hierarchy when it compiles your Java classes– Note: the bin/ directory tree is hidden by

Eclipse when in the Java perspective, but you can see it if viewing the file system.


What is Ant?What is Ant?

Ant is a Java based tool for automating the build process

Platform independent commands (works on Windows, Mac & Unix)

XML based format Easily extendable using Java classes Ant is an open source (free) Apache project

Ant files used in this course require the Ant files used in this course require the package directory structure described package directory structure described earlierearlier


Anatomy of a Build FileAnatomy of a Build File

Ant’s build files are written in XML Convention is to call file build.xml

Each build file contains A project At least 1 target

Targets are composed of some number of tasks

Build files may also contain properties Like macros in a make file

Comments are within  blocks


ProjectsProjects

The project tag is used to define the project to which the ANT file applies

Projects tags typically contain 3 attributes name – a logical name for the project default – the default target to execute basedir – the base directory relative to

which all operations are performed Additionally, a description for the

project can be specified from within the project tag


Project tagProject tag<project name="Sample Project" default="compile" basedir=".">

<description> A sample build file for this project Recall that “.” (dot) refers to the current directory </description> </project>


PropertiesProperties

Build files may contain constants (known as properties) to assign a value to a variable which can then be used throughout the project Makes maintaining large build files more

manageable and easily changeable

Projects can have a set of properties• Property tags consist of a name/value pair

Use the property names throughout the build file The value is substituted for the name when the

build file is “executed”


Build File with PropertiesBuild File with Properties

<project name="Sample Project" default="compile" basedir=".">

<description> A sample build file for this project </description>  <property name="source.dir" location="src"/> <property name="build.dir" location="bin"/> <property name="doc.dir" location="doc"/> </project>


TasksTasks A task represents an action that needs

execution Tasks have a variable number of attributes

which are task dependant There are a number of built-in tasks, most

of which are things which you would typically do as part of a build process mkdir - create a directory javac - compile java source code java - execute a Java .class file javadoc - run the javadoc tool over some files And many, many others…

For a full list see: http://ant.apache.org/manual/tasksoverview.html


TargetsTargets The target tag has the following required attribute

name – the logical name for a target Targets may also have optional attributes such as

depends – a list of other target names for which this task is dependant upon, the specified task(s) get executed first

description – a description of what a target does Targets in Ant can depend on some number of other

targets For example, we might have a target to create a jarfile,

which first depends upon another target to compile the code

Targets contain a list of tasks to be executed


Build File with TargetsBuild File with Targets<project name="Sample Project" default="compile" basedir=".">  <target name="init" description="setup project directories">

 </target>  <target name="compile" depends="init" description="compile java sources">

 </target>

 <target name="doc" depends="init" description="generate documentation">


 <target name=”run" depends=“compile” description=”run the application">


 <target name="clean" description="tidy up the workspace">

 </target></project>


Initialization Target & TasksInitialization Target & Tasks Our initialization target creates the build and

documentation directories The mkdir task creates a directory


...

 <target name="init" description="setup project directories">

<mkdir dir="${build.dir}"/> <mkdir dir="${doc.dir}"/> </target> ...

</project>


Compilation Target & TasksCompilation Target & Tasks Our compilation target will compile all java files in the

source directory The javac task compiles sources into classes Note the dependence on the init task


...

 <target name="compile" depends="init" description="compile java sources"> <javac srcdir="${source.dir}" destdir="${build.dir}"/> </target>

...

</project>


Run Target & TasksRun Target & Tasks Our run target will execute main in the fully specified class

Typically dependent on the compile task


...

 <target name=”run" depends=”compile" description=“run the application"> <java directory=“${build.dir}” classname=“${main.class}” fork=“yes”>

<arg line=“${args}” /></java>

</target>

...

</project>


Running Ant – Command Running Ant – Command LineLine Move into the directory which contains the

build.xml file Type ant followed by the name of a target

unix> ant run

unix> ant compile

Type ant at the unix prompt to run the project’s default target -- see screen shot on next pageunix> ant

CVS CommandCVS Command• The general form of CVS commands is:

– All CVS commands start out with “cvs”– Commands may also have flags and/or

arguments which modify their behavior

• For a more help…– General help: cvs --help– List of commands: cvs --help-commands

04/19/23 UMBC CMSC 341 19

cvs [cvs-options] command [command-options-and-arguments]

Basic commandsBasic commandscheckout : Pull resources from the

repository and create a working copy

add : place a resource under version control

update : Pull down changes from the repository into your working copy

commit: Check files into the repository

04/19/23 UMBC CMSC 341 20

Command-line using Putty

Steps to be followed◦ Log in using Putty◦ Edit the .cshrc file : Add alias javac

usr/local/bin/javac

04/19/23 UMBC CMSC 341 21

Command-line using PuttyCommand-line using PuttyStep 1: cd changes your working directory

to home directoryStep 2: cvs -d

/afs/umbc.edu/users/f/r/frey/pub/cs341s12/Proj0 checkout -d MyProj0 your_username

04/19/23 22UMBC CMSC 341

Command-line using PuttyCommand-line using Putty Step 3: cd MyProj0 Change to your project

directory Step 4 : mkdir src Step 5: cd src Step 6: Create a java file called Proj0.java and type in

a simple java code. Let the package name be ‘firstproject’. Save the file in the src folder.

04/19/23 UMBC CMSC 341 23

Step 9: Edit build.xmlStep 9: Edit build.xml

04/19/23 24UMBC CMSC 341

Command-line using PuttyCommand-line using Putty Step 10: Compile the code using

ant compile Step 11: Run the code using

ant run

04/19/23 UMBC CMSC 341 25

Command-line using PuttyCommand-line using Putty Step 12 : Add files to the repository:

◦ Step 12.1 cvs add build.xml

◦ Step 12.2 cvs add src/

◦ Step 12.3 cd src

◦ Step 12.4 cvs add Proj0.java

◦ Step 12.5 cvs commit –m ‘some text’

04/19/23 UMBC CMSC 341 26

Command-line using PuttyCommand-line using PuttyStep 13: Check if Proj0.java is added to the

repository◦ Go to src folder in MyProj0◦ Remove Proj0.java◦ Run ‘cvs update’◦ You should get back Proj0.java from the

repository

04/19/23 UMBC CMSC 341 27

EclipseEclipseEclipse has a built-in perspective

for CVS◦All of the developer downloads come

with it pre-installed

(The following directions are for the Eclipse Ganymede Eclipse IDE for Java Developer

release)

Eclipse – CVS PerspectiveEclipse – CVS PerspectiveTo open the CVS repository

perspective select Window Open Perspective Other…

Eclipse – CVS PerspectiveEclipse – CVS PerspectiveSelect CVS Repository Exploring

Eclipse – Adding a Eclipse – Adding a RepositoryRepositoryTo add a repository, right click on the CVS

Repositories pane and select New Repository Location…

Eclipse – Connection Eclipse – Connection SettingsSettingsType in the parameters to

connect to the remote repositoryFor example…

◦ Host: linux.gl.umbc.edu◦ Repository Path:

/afs/umbc.edu/users/f/r/frey/pub/cs341s12/Proj0/◦ User: Your GL/myUMBC username◦ Password: Your GL/myUMBC password◦ Connection type: extssh

Save the password if you wish

Eclipse – Connection Eclipse – Connection SettingsSettings

Eclipse – Viewing Eclipse – Viewing RepositoriesRepositoriesYou should now see the repository

under the CVS Repositories Pane

Eclipse – Checking OutEclipse – Checking OutExpand the repository, expand HEAD, select

your module (username) then right click and choose Check Out As…

Eclipse – Checking Out Eclipse – Checking Out (continued)(continued)Be sure to use the New Project Wizard,

click Finish…

Eclipse – Checking Out Eclipse – Checking Out (continued)(continued)Select to check out the module

as a Java Project

Eclipse – Checking Out Eclipse – Checking Out (continued)(continued)Name the project and click

Finish…

Eclipse – Checked Out Eclipse – Checked Out CodeCodeSwitch back to the Java Perspective

and you will see the module checked out as a project◦ Note the little orange cylinders – that

indicates that it’s under version control

Eclipse – New ResourcesEclipse – New Resources• Just like with the command line, items

that are not know to be under CVS control are marked with a “?” symbol– Such as the Eclipse generated src folder

Eclipse – SynchronizingEclipse – SynchronizingTo commit to or update from the repository,

right click on the project and choose Team Synchronize with Repository

Eclipse – Committing Eclipse – Committing ResourcesResourcesHere we see an outgoing arrow indicating

that this needs to be pushed to the repository◦ Commits and updates can be performed by right

clicking

Eclipse – SynchronizedEclipse – SynchronizedIf all is in sync, you should see the “No

Changes” dialog as shown below…

CVS Utilities - SetupCVS Utilities - Setup The CVS utilities are located in the directory:

/afs/umbc.edu/users/f/r/frey/pub/341/bin/ To use the commands you may specify the complete pathname. linux1[4]% /afs/umbc.edu/users/f/r/frey/pub/341/bin/the-command Or, you may change your Unix PATH to include that directory by editing

your .cshrc file found in your home directory (notice the leading "dot".) In your favorite editor, add the following line somewhere near the bottom of your file.

set path = ( $path /afs/umbc.edu/users/f/r/frey/pub/341/bin ) The next time you login, the directory which contain the utilities will be

searched when these commands are executed. You can verify the change to your PATH using the following command. You should see the directory at the end of the your path.

linux1[5]% echo $PATH

If you choose to edit your .cshrc file, do so with If you choose to edit your .cshrc file, do so with extreme care. extreme care.

The smallest mistake can have dire consequences.The smallest mistake can have dire consequences.

04/19/23 UMBC CMSC 341 44

cvsbuild utility allows you to checkout and build your submission thus verifying your submission.

Run this command from the same directory you originally ran cvs checkout from

cvsbuild command has one argument: path to the CVS repository for the project

linux2[2]% cvsbuild /afs/umbc.edu/users/f/r/frey/pub/cs341s12/Proj0/

CVS Utilities - cvsbuildCVS Utilities - cvsbuild

04/19/23 UMBC CMSC 341 45

CVS Utilities - cvsbuildCVS Utilities - cvsbuild Running this script will attempt to checkout your code into a

directory called <username>-cvs-checkout. If submission is done correctly, you should see the BUILD SUCCESSFUL message as shown above.

If the message does not come up, something is either missing from your submission or files are not submitted correctly.

Every change in the repository should be followed by a to re-run of this command.

Re-running the script, will notify you that it needs to remove the contents of the exiting folder if it does exist, in order to perform the checkout/build.

If you wish to avoid the prompt on subsequent runs of the cvsbuild command, simply add a -y flag on the command line (e.g. cvsbuild -y /path/to/repository).

04/19/23 UMBC CMSC 341 46

CVS Utilities - cvsrunCVS Utilities - cvsrun The cvsrun utility allows you to test your program like the graders do. First check-out and build your code using cvsbuild. The cvsrun command can take command line arguments for your main For example…linux2[3]% cvsrun arg1 arg2 arg3Buildfile: build.xmlrun: [java] Hello World! [java] args: [java] arg1 [java] arg2 [java] arg3BUILD SUCCESSFULTotal time: 0 secondslinux2[4]%

If all goes well, you should see your project run with the arguments you've provided.

If you get an “Exception in thread "main" java.lang.NoClassDefFoundError” error the likely cause is that your main.class property value doesn't point to a valid class (either the name is wrong, or its location doesn't match its package hierarchy).

Once you're satisfied you can safely remove the <username>-cvs-checkout directory created by cvsbuild and used by cvsrun.

04/19/23 UMBC CMSC 341 47

CVS Utilities - cvsresetCVS Utilities - cvsreset Sometimes you might experience issues with your CVS repository. If you're running into problems that you believe to be an issue with

your repository you may reset it to the initial state for a given project.

The effects of the cvsreset are irreversible! Running this The effects of the cvsreset are irreversible! Running this command will delete everything you've submitted via CVS command will delete everything you've submitted via CVS for a given project. Ensure that you have a local copy of for a given project. Ensure that you have a local copy of your source code before running this command.your source code before running this command.

Once ensured you may reset the repository like shown below:-

linux2[4]% cvsreset /afs/umbc.edu/users/f/r/frey/pub/cs341f11/Proj0This script will reset your CVS repository to its original condition.This operation is irreversible - anything submitted will be removed.Ensure that you have a local copy of your code before continuing. Enter "y" to continue or "n" to exit: y Resetting CVS repository------------------------Donelinux2[5]%

04/19/23 UMBC CMSC 341 48

CVS Utilities - cvsresetCVS Utilities - cvsreset Complete the process with the following steps:-

1. From the parent directory of your project directory, check out your project into a new project directory.

2. Recreate your directory structure and copy your saved files to the new project directory.

3. Rerun the cvs add and cvs commit commands for your directories and files in your new project.

04/19/23 UMBC CMSC 341 49

Thank you!Thank you!

04/19/23 UMBC CMSC 341 50

Documents

CMSC 341 – Data Structures Spring 2012 University of Maryland, Baltimore County ANT, CVS and CVS Utilities Slides prepared by Prajit Kumar Das – Summarized