import repository from arizona
[raven.git] / webpage / tut.html
1 <html>
2 <head>
3 <title> Stork Project </title>
4 <LINK href="stork.css" rel="stylesheet" type="text/css">
5
6 </head>
7
8 <body>
9
10
11 <div class="display" align="center">
12         <table border="0">
13         <tr>
14                 <td width="170" valign="top">
15
16                                 <br/>
17                                 <table cellpadding="3" width="170" id="links" class="links">
18                                         <tr>
19                                                 <td align="right">
20
21                                                         <ul class="links">
22
23                                                                 <a href = "index.html"><h3>Stork</h3></a>
24                                                                 <li class="links"><a href="tutmain.html">Stork Tutorial</a></li>
25
26                                                                 <li class="links"><a href="advanced.html">Advanced Usage</a></li>
27                                                                 <li class="links"><a href="arch.html">Stork Architecture</a></li>
28                                                                 <li class="links"><a href="filelist.html">Stork File List</a></li>
29                                                                 <li class="links"><a href="about.html">About Us</a></li>
30                                                                 <li class="links"><a href="apps.html">Related Links</a></li>
31                                                                 <li class="links"><a href="contact.html">Contact Stork</a></li>
32                                                                 <h4>Links</h4>
33                                                                 <li class="links"><a href="http://appmanager.berkeley.intel-research.net/plcontrol/apps.php?appid=1029">
34                                                                 Slice Status</a></li>
35                                                                 <li class="links"><a href="https://stork-repository.cs.arizona.edu">Stork Repository</a></li>
36                                                         </ul>
37
38                                                  </td>
39                                         </tr>
40                                 </table>
41                                 <br/>
42                 </td>
43
44                 <td valign="top">
45                 <table class="info" cellpadding="0" width="700" >
46                 <tr  height="75"><td colspan="3"><img style="margin-left: -0px;" src="images/stork-header.png" alt="stork logo"/></td></tr>
47                 <tr  bgcolor="#444444" class="headerrow" width="100%" height="2">
48
49                         <th colspan="2"> Stork Tutorial </th>
50
51                 </tr>
52                 <tr valign="top" align="left">
53
54                         <td>
55                                 <table cellpadding="8" id="content" class="content">
56                                         <tr>
57                                                 <td>
58
59                                                         <h1><a name = "top"></a>Stork Tutorial</h1>
60                                                         For a simple walkthrough of using Stork to manage package installation on a PlanetLab
61                                                         system, use the following instructions:
62                                                         <p><a href = "#install">1. Install Stork and Storkutil</a>
63                                                         <br><a href = "#tarball">2. Create a package</a>
64                                                         <br><a href = "#genpair">3. Create an identity</a>
65                                                         <br><a href = "#config">4. Modify the Stork configuration</a>
66                                                         <br><a href = "#tpfile">5. Modify your Trusted Packages File</a>
67                                                         <br><a href = "#maninstall">6. Set packages for installation using Pacman, or install manually</a>
68                                                         <br><a href = "#upload">7. Upload files to the Stork repository</a>
69                                                                 <p>To access a print-version of this tutorial, hit the following link: <a href="cleantut.html">
70                                                         www.cs.arizona.edu/stork/cleantut.html</a>.
71                                                         <p><img src="blkfade.gif" width="100%"></img>
72
73
74                                                         <br>
75
76                                                         <a name = "#install"><h3>1. Installing Stork and Storkutil</h3></a>
77                                                         To use Stork on your slice, you must run the Stork initscript from PlanetLab. Log into
78                                                         PlanetLab, choose a slice, and select <b>Add New Attribute</b>. Select
79                                                         <b>pl_initscript</b>, and then select <b>arizona_stork2</b>.
80                                                         <p>After finishing installation, download the <a href="downloads/stork-enduser-tar-latest.tar.gz">Stork Enduser tarball</a> and
81                                                         unpack it to obtain the Stork enduser utilities. This tarball also includes a sample stork
82                                                         configuration file, named sample-stork.conf which will need to be <a href="
83                                                         #config">modified</a> in order
84                                                         to successfully use the stork utilities.
85                                                         <p><img src="blkfade.gif" width="100%"></img>
86                                                         <br>
87
88                                                         <a name = "tarball"><h3>2. Creating a Package</h3></a>
89                                                         <p>Stork currently supports two types of packages: RPMs and tarballs.
90                                                         Stork will install RPM packages according to the package scripts. RPMs
91                                                         are generally suggested for complex installations, or where the package needs
92                                                         to be installed outside of /root. However, for simple packages, it can be more
93                                                         efficient to use a simple tarball package.
94
95                                                         <p>Creating a tarball package can be a great way to distribute your own
96                                                         applications. With Stork, you can easily distribute your software to every
97                                                         node that needs it. Stork also allows you to execute scripts before and
98                                                         after you install or uninstall, making tarballs even more powerful.
99                                                         Including scripts in your tarball is very simple. Just package
100                                                         '.preinstall', '.postinstall', '.preremove', and/or '.postremove' scripts
101                                                         along with your own files. Stork will automatically execute the script when
102                                                         the user decides to install or uninstall your package. The scripts will run
103                                                         from the same directory the tarball is unpacked (typically '/root/' or what
104                                                         ever is defined to be the home directory). Note that these scripts are
105                                                         completely optional.
106                                                         <p>For example, consider a simple directory called <i>directory</i> full
107                                                         of dummy files, and also four scripts, <i>.preinstall,
108                                                         .postinstall, .preremove, .postremove</i>. We can create a
109                                                         simple zipped tarball by running the command:
110
111                                                         <br><code><b>  tar -czf <i>mypackage.tar.gz</i> directory ... </b></code>
112
113                                                         <br>Where "mypackage" is the name of the tarball to be created, and the
114                                                         directory is the directory we wish to make into a package. Instead
115                                                         directories, files can also be used.
116                                                         <p>Upon installing this package with
117                                                         Stork, Stork will automatically run .preinstall, and will run
118                                                         .postinstall after installation. This allows the package creator to
119                                                         include scripts to confirm that installation is going to occur, and confirm
120                                                         that it worked. Likewise, when the package is uninstalled, the preremove and
121                                                         postremove scripts work in the same way.
122                                                         <p><img src="blkfade.gif" width="100%"></img>
123                                                         <br>
124
125                                                         <a name="genpair"><h3>3. Creating an Identity</h3></a>
126                                                         <p>To start using Stork's enduser utilities, you will first need to
127                                                         create an identity. You can do this using the 'genpair' function. This
128                                                         will create a private key and a public key, which will identify you and the
129                                                         software you wish to distribute. The privatekey is used to sign the files
130                                                         that Stork uses to install your software, so be sure to keep it safe. The
131                                                         public key is distributed to all your nodes (and all others that wish to use
132                                                         your software). Note that Stork will generate an error if you attempt to use
133                                                         it before creating a pair of keys and setting it as your default identity.
134                                                         <p>To create your keys, just run the command:
135
136                                                         <br><code><b>./storkutil.py genpair USERNAME</b></code>
137                                                         <br>where USERNAME is any username you desire. The username exsits
138                                                         so that users can recognize each other without having to base interaction
139                                                         solely on public and private keys. After running the genpair command,
140                                                         Stork will ask you if you want this to be your default identity; if this is
141                                                         your first time using Stork, it is best to set this key as your default. If
142                                                         you've already created keys and would like to use those, you can use the
143                                                         'storkutil.py setdefault USERNAME' command.
144
145 <p><table width=400 height=150 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
146 <td width="100%" align="left" valign="top" bgcolor="teal">
147 <span style="color: white">
148 <code><b>./storkutil.py genpair foo</b>
149 <br>Generated foo.privatekey...
150 <br>Extracted foo.publickey...
151 <br>Would you like to make 'foo' your default identity? (y/n) > <b>y</b>
152 <br>'foo' is now your default identity
153 <br>
154 <br><b>./storkutil.py genpair foo</b>
155 <br>Error: Key files for 'foo' already exist
156 </code>
157 </span></td></tr></table>
158
159 <p>or, if you have already created foo.privatekey and foo.publickey:
160
161 <p><table width=400 height=60 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
162 <td width="100%" align="left" valign="top" bgcolor="teal">
163 <span style="color: white">
164 <code><b>./storkutil.py setdefault foo</b>
165 <br>Previous Identity: someguy
166 <br>'foo' is now your default identity</code>
167 </span></td></tr></table>
168                                                         <p>Be sure that the privatekey and publickey are in your current directory
169                                                         while using storkutil. The publickey can be distributed to all your nodes
170                                                         through the <a href="https://stork-repository.cs.arizona.edu">upload website</a>.
171                                                         Also, note that your public key is embedded in your TPFile filename, such that
172                                                         the filename should be <i>*publickey*Username.tpfile</i>, without the *.
173                                                         <p><img src="blkfade.gif" width="100%"></img>
174                                                         <br>
175                                                         <a name = "config"><h3>4. Configuration File</h3></a>
176                                                         You will need to change the stork configuration file included in the
177                                                         Storkutil tarball to match the
178                                                         identity you created. Simply open up the file which should be named
179                                                         <i>sample-stork.conf</i> and change the 'username = ' line
180                                                         to match the username you chose for your keys. You will also need to modify the
181                                                         'publickeyfile = ' line, to match the location of your publickey. By default, this should be
182                                                         "publickeyfile = /usr/local/stork/var/keys/<username>.publickey", where <username> is the
183                                                         name you generated your keys for.
184                                                         You will need to distribute this
185                                                         configuration file to all your
186                                                         nodes through the <a href="https://stork-repository.cs.arizona.edu">upload website</a>.
187                                                         <i><p>Note!</i> The stork configuration file is different from the storkutil
188                                                         configuration file. The <code>setdefault</code> command will appropriately change
189                                                         the storkutil configuration file, but you will still need to change and distribute
190                                                         the Stork configuration file manually.
191                                                         <p><img src="blkfade.gif" width="100%"></img>
192                                                         <br>
193                                                         <a name = "tpfile"><h3>5. Trusted Packages File</h3></a>
194                                                         The Trusted Packages File (TPFILE) defines which files you trust to be autmoatically
195                                                         downloaded and install. This helps your nodes stay secure and autonomous, as files will be
196                                                         verified through a set of hash codes. Even if
197                                                         two files share the same name, your nodes will only recieve the one that
198                                                         matches the hash obtained when the Trusted Packages File was created
199                                                         (preventing your nodes from downloading maliciously modified packages in the
200                                                         repository). You are also allowed to trust other users, allowing your nodes
201                                                         to accept packages from those users exclusively. This will let your nodes
202                                                         download and install applications created by other users. Note that adding packages to
203                                                         your TPFILE will not download the packages; it just notifies Stork which packages
204                                                         you trust to be downloaded.
205
206                                                         <p><b>Adding a package to your tpfile:</b>
207                                                         <br>To add a package to your tpfile, use the command
208                                                         <br><b><code>./storkutil.py
209                                                         addfile FILE [FILE]...</b></code>
210                                                         <br>where FILE is the location of the package you would
211                                                         like to trust. If the tpfile does not exist, storkutil will create one for
212                                                         you. Storkutil will look at the file, create a hash, and write it to your
213                                                         tpfile. If you <a href="https://stork-repository.cs.arizona.edu">upload</a>
214                                                         the package to the repository and run
215                                                         stork to install the package, your node will select your specific file and
216                                                         install it.
217                                                                 <p>For example, we will add packages 'package1' and 'package2'.
218 <p><table width=400 height=60 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
219 <td width="100%" align="left" valign="top" bgcolor="teal">
220 <span style="color: white">
221                                                                 <code><b>./storkutil.py addfile package1.tar.gz package2.tar.gz</b>
222                                                                 <br>No tpfile found for foo. Generating new tpfile.
223                                                                 <br>File 'foo.tpfile' successfully signed
224                                                                 <br>File 'foo.tpfile' has been copied to 'foo.~~~.tpfile'
225                                                                 <br>Unembeded trusted packages file 'foo.tpfile' removed.</code>
226 </span></td></tr></table>
227
228
229                                                                 <br>This script will run whenever Stork fails to find a trusted package
230                                                                 file for the default user. It will then continue to the regular package adding script:
231
232 <p><table width=400 height=60 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
233 <td width="100%" align="left" valign="top" bgcolor="teal">
234 <span style="color: white">
235                                                                 <code>Using trustedpackages file '~~~~.tpfile'
236                                                                 <br>Successfully added file 'package1.tar.gz'.
237                                                                 <br>Successfully added file 'package2.tar.gz'.
238                                                                 <br>File '~~~.tpfile' successfully signed</code>
239
240 </span></td></tr></table>
241                                                                 <br>Storkutil will automatically sign your trusted packages file using
242                                                                 your key. Also note that your TPFile will be named as your public key followed by
243                                                                 your username, with the .tpfile extension.
244
245
246                                                         <p><b>Viewing your tpfile:</b>
247                                                                 <br>Afterwards, we can look at the trusted packages file by running:
248 <p><table width=400 height=60 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
249 <td width="100%" align="left" valign="top" bgcolor="teal">
250 <span style="color: white">
251                                                                 <code><b>./storkutil.py view tpfile</b>
252                                                                 <br>Viewing: foo.~~.tpfile
253                                                                 <br><br>TRUSTED PACKAGES FILE
254                                                                 <br>    ALLOW package1.tar.gz
255                                                                 <br>    ALLOW package2.tar.gz</code>
256
257 </span></td></tr></table>
258
259
260                                                                 <br>We can confirm that the packages were added to our trusted packages
261                                                                 file in this way.
262
263                                                         <p><b>Removing a package from the tpfile:</b>
264                                                         <br>You can remove a file from your TPFile, just use the 'removefile' command.
265                                                         <p><code><b> ./storkutil.py removefile package1.tar.gz</b>
266
267                                                         <p><b>Adding and removing trusted users:</b>
268                                                         <br>Before adding a user to your TPFile, you will need to obtain their
269                                                         publickey.
270                                                         <br>To trust users, you can use the <code>adduser</code> command:
271                                                         <br><code><b>storkutil adduser USER USER.publickey (allow|deny|any) AFFECTEDPACKAGES</b></code>
272                                                         <br>Where USER is the name of the user you want to trust, followed by the
273                                                         public key that user has made available. AFFECTEDPACKAGES is a pattern
274                                                         that defines the packages you want to accept. If the tpfile does not exist,
275                                                         storkutil will create one for you.
276                                                         <p>Examples:
277                                                         <br><b><code>storkutil.py adduser USER1 USER1.publickey allow user-4-2.tar.gz
278                                                         <br>storkutil.py adduser USER2 USER2.publickey deny java\*
279                                                         <br>storkutil.py adduser PlanetLab PlanetLab.publickey allow \*
280                                                         <br>storkutil.py adduser USER3</b></code>
281
282                                                         <p>The first example shows how to accept a single package from the user
283                                                         USER1. The second example will deny all files from USER2 that have the
284                                                         pattern java*. The third example shows how to accept all packages from the
285                                                         user PlanetLab (be sure to shell escape the * character instead of using * by itself).
286                                                         Note that this is not necessary; the PlanetLab node is <b>trusted by default</b> when
287                                                         a tpfile is created to allow default PlanetLab files to be installed,
288                                                         and the PlanetLab publickey is included in the enduser tarball.
289                                                         You can again use the <code>view tpfile</code>
290                                                         command to see the contents of your TPFILE. You can also remove users using
291                                                         the <code>removeuser</code> command.
292
293                                                                 <p><b><code>./storkutil.py removeuser USER2</code></b>
294
295                                                         <p>When you are done, you can upload the trusted packages file to your nodes
296                                                         through the <a href="https://stork-repository.cs.arizona.edu">upload
297                                                         website.</a>
298                                                         <p><img src="blkfade.gif" width="100%"></img>
299                                                         <br>
300                                                         <a name = "pacman"><h3>6b. Pacman</h3></a>
301                                                         Stork's package manager (pacman) can help you manage your packages
302                                                         across all your nodes. Rather than installing or uninstalling packages on
303                                                         each of your nodes individually, you can assign your nodes to groups and
304                                                         instruct stork to install or remove packages on those groups. Pacman
305                                                         is therefore efficient to use when a package needs to be installed on
306                                                         a large number of nodes. Pacman also allows packages to be automatically
307                                                         updated when the package creator updates them in the repository; this
308                                                         allows Stork to work near autonomously when set up for use.
309                                                         Pacman uses two files; groups and packages. Using storkutil, you can create these two
310                                                         files and upload them. Stork will then distribute these files to your nodes
311                                                         and perform the tasks you assigned.
312
313                                                         <p><b>Pacman Groups</b>
314                                                         <br>Your groups.pacman file allows you organize your nodes into separate
315                                                         groups. You are allowed to include a node into a group or exclude a node
316                                                         from a group. You can also include, exclude, or intersect groups with each
317                                                         other. To define our groups, we can use:
318                                                         <p><code><b>./storkutil pacgroups (include|exclude|intersect|remove) group NAME [NAME...]</b></code>
319                                                         <br>where <code>group</code> is the name of the group to be affected, and
320                                                         <code>NAME</code> are the names of the nodes or groups to be included/excluded/removed.
321                                                         <p>We start by adding a node to a group. If a pacman group file for your
322                                                         username does not exist, then storkutil will create a new one.
323
324
325 <p><table width=400 height=200 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
326 <td width="100%" align="left" valign="top" bgcolor="teal">
327 <span style="color: white">
328 <code><b>./storkutil.py pacgroups include myGroup foo1.node foo2.node</b>
329 <br>Using groups file: ./foo.~~~.groups.pacman
330 <br>File Not Found, Creating New File
331 <br>File './foo.~~~.groups.pacman' successfully signed</code>
332 <p><code><b>./storkutil.py view groups</b>
333 <br>Viewing: foo.~~~.groups.pacman
334 <br>
335 <br>PACMAN GROUP FILE
336     <br>    GROUP:  myGroup
337          <br>       INCLUDE:        foo1.node
338              <br>   INCLUDE:        foo2.node
339 </code></span></td></tr></table>
340
341
342
343                                                         <p>Storkutil will automatically sign the file using your default private key
344                                                         file, which you created when you <a href="#genpair">generated your first key pairs</a>. If
345                                                         you want to use a username that is not your default, you can use the <code>--username</code>
346                                                         option to work on a different file.
347                                                         <br>We can continue adding more data
348                                                         into our group definitions. For instance, if we want myGroup to include all the
349                                                         nodes in the group oldGroup, except for the node badNode which is a member of oldGroup,
350                                                         we can run the following commands:
351                                                         <p><b><code>./storkutil.py pacgroups include myGroup oldGroup
352                                                         <br>./storkutil.py pacgroups exclude myGroup badNode</b></code>
353                                                         <br>This means that installing a package to myGroup will install it to every node
354                                                         included in oldGroup except for badNode.
355                                                         <p>We can remove groups or nodes from a group by simply using the <code>remove</code>
356                                                         command, as such:
357                                                         <p><code><b>./storkutil.py pacgroups remove myGroup</b>
358
359
360                                                         <p>If you want to
361                                                         view the contents of the group file, you can use the <code>view groups</code> command in
362                                                         storkutil, but you will first need to add a node to a group to generate a group file.
363                                                         <br>When you are done, you will need to upload the groups.pacman file to the Stork repository.
364
365                                                         <b><p>Pacman Packages</b>
366                                                         <br>The packages.pacman file allows you to manage which packages to
367                                                         install on which nodes. With the pacman packages file, you can tell a node
368                                                         or group (as defined by your <a href = "#pacman">groups.pacman file</a>) to install or
369                                                         uninstall a package. To create and modify our packages file, we will use:
370
371                                                         <p><table width=400 height=50 cellspacing=0 cellpadding=5 border=5 bordercolor="orange"><tr>
372                                                         <td width="100%" align="left" valign="top" bgcolor="teal">
373                                                         <span style="color: white">
374                                                         <code><b><code><b>./storkutil.py pacpackages (node|group|all) NAME (install|remove|upgrade) PACKAGE</b></code>
375 </span></td></tr></table>
376
377
378                                                         <p>We can start by assigning a node to install a package. Be sure your
379                                                         filename follows the pattern <name>.packages.pacman, where the name is the
380                                                         one your configured in your <a href="#config">Stork configuration file</a>. This will aid
381                                                         your nodes in finding the correct group file to use. If the file you
382                                                         specified does not exist, then storkutil will create a new one.
383
384                                                         <p><b><code>./storkutil.py pacpackages node planetlab.foo.edu install gnuchess</code></b>
385                                                         <br>This will assign the planetlab.foo.edu node to install gnuchess.
386                                                         <p>We can also assign groups to install or remove packages:
387
388                                                         <br><b><code>./storkutil.py pacpackages group myGroup install lynx man gnuchess</b></code>
389                                                         <br>This command will tell myGroup to install the <i>lynx, man, and gnuchess</i> packages
390                                                         in all the nodes in the group.
391
392                                                         <p>We can also instruct Pacman to install packages on multiple nodes without grouping them,
393                                                         using the <code>all</code> command:
394                                                         <br><b><code>./storkutil.py pacpackages all install gnuchess</b></code>
395                                                         <br>Note that in this example, the <code>group</code> and <code>node</code> commands are replaced
396                                                         with <code>all</code> command, and also that there is no group or node name required. This command
397                                                         will instruct Stork to install gnuchess on every node to which the packages.pacman file is distributed.
398
399                                                         <p>Using the <code>upgrade</code> command, Stork will also instruct all nodes in a group
400                                                         to update a preexisting package:
401                                                         <br><code><b>./storkutil.py pacpackages group myGroup upgrade gnuchess</b></code>
402                                                         <br>This will instruct all myGroup nodes to upgrade gnuchess when necessary.
403
404                                                         <p>Storkutil will automatically sign the file using your default private key
405                                                         file, which you created when you <a href = "#genpair">generated</a> your first key pairs.
406                                                         If you want to work using a different set of keys and files, you can use the
407                                                         <code>--username</code> option.
408                                                         You can view the contents of your package file using the <code>view packages</code>
409                                                         command. When you are done,
410                                                         <a href="https://stork-repository.cs.arizona.edu">
411                                                         upload your Pacman config file to the Stork repository.</a>
412                                                         <p><img src="blkfade.gif" width="100%"></img>
413                                                         <br>
414                                                         <a name = "maninstall"><h3>6a. Manual Install</h3></a>
415                                                         To manually install a package on a node, simply run the command <code>Stork</code>
416                                                         followed by the package name, from root. For instance:
417                                                         <br><b><code>./stork.py gnuchess</b></code>
418                                                         <br>will install gnuchess on the node on which it is run. To install gnuchess
419                                                         on three separate nodes, then, the user would need to log into each node
420                                                         separately and run <code>Stork gnuchess</code> on that node. This is an efficient way
421                                                         to install packages when the package only needs to be installed on a single or small
422                                                         number of nodes.
423                                                         <p><img src="blkfade.gif" width="100%"></img>
424                                                         <br>
425                                                         <a name="upload"><h3>7. Uploading to the Repository</h3></a>
426                                                         The Stork repository upload site is located at:
427                                                         <a href="https://stork-repository.cs.arizona.edu">https://stork-repository.cs.arizona.edu</a> .
428                                                         From this site, you can upload <a href="#tarball">packages</a>,
429                                                          your <a href="#genpair">public keys</a>, your
430                                                         <a href="#config">Stork configuration file</a>,
431                                                         <a href="#tpfile">trusted packages files</a>, and <a href="#pacman">pacman files
432                                                         (both groups.pacman and packages.pacman files)</a>. All of these files will need
433                                                         to be uploaded to the repository in order for Stork to work correctly with your
434                                                         nodes.
435
436                                                         <center><a href = "index.html">Home</a>     <a href = "#top">Top</a></center>
437
438
439                                                 </td>
440                                         </tr>
441                                 </table>
442                         </td>
443                 </tr>
444
445        </table>
446        </td>
447
448      </tr>
449      <tr>
450         <td></td>
451         <td>
452                 <a href="http://www.planet-lab.org"><img style="border: 0px; border-style: none;" src="images/powered_by_pl_grey.png" alt="powered by planetlab"></a>
453
454                                         <a href="http://www.cs.arizona.edu"><img style="position:relative; left: 20px; border: 0px; border-style: none;" src="images/template_logo_small_grey.png" alt="University of Arizona, Computer Science logo"></a>
455
456
457
458
459
460         </td>
461      </tr>
462
463 </table>
464
465 </div>
466
467
468 <script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
469 </script>
470 <script type="text/javascript">
471 _uacct = "UA-1868232-1";
472 urchinTracker();
473 </script>
474 </body>
475 </html>