AOLserver Wiki - User contributions [en]

Writing Your First ADP

2008-11-20T00:34:09Z

Jcr:

ADPs are the simplest way to create a dynamic page in AOLserver. They support the use of all Tcl commands - including AOLserver ones and those you create in Tcl libraries - mixed with HTML to create a complete web page. Unlike Tcl libraries, any changes you make to the ADP take effect immediately without having to restart the server.

'''Configuration'''

Before you start trying, make sure you have configured AOLserver correctly to parse ADP pages.

In the configuration file (usually nsd.tcl), make sure that below:

ns_section "ns/server/${servername}/adp"

but before the next "ns_section", you have the line:

ns_param map "/*.adp"

uncommented.

When you start AOLserver, do so by using the "-ft" option; this runs the server in the foreground and shows any Tcl errors on the console.

If you are running AOLserver in the more usual background mode, errors in ADP pages are written to the server log, by default SERVERHOME/log/server.log, or locate it from the value (path and filename) returned by [[ns_info log]].

'''Writing an ADP'''

In the server's pageroot, create a file called ''test.adp'' using your favourite editor and enter the following code:

<%
set title "Hello, AOLserver!"
ns_adp_puts $title
%>

Now request that page in a web browser.

Another way to display the value of "title" would be:

<%= $title %>

Using that syntax, you can also display the results of a Tcl command:

<%= [ns_httptime [ns_time]] %>

'''Mixing HTML and Tcl'''

You can mix HTML and Tcl code to make a complete page:

<pre>
<%
set title "Welcome to my homepage"
set body "This is the main text part of the homepage"
%>

<html>
<head>
<title><%= $title %></title>
</head>
<body>
<%= $body %>

<p>Now let's count to 10!</p>
<br/>

<%
for {set i 1} {$i <= 10} {incr i} {
ns_adp_puts "$i "
}
%>

</body>
</html>
</pre>

Setting ''title'' and ''body'' as variables was pretty pointless in this case. In your real website, however, these values could be taken from the database by one ADP, which in turn uses [[ns_adp_include]] to include another ADP to format the page and which can be re-used by many pages on your site.

----

[[Category Documentation]] - [[Category Tutorial]]

Ns return

2008-08-18T23:54:51Z

Jcr:

<manpage>ns_return</manpage>

== NAME ==

ns_connsendfp, ns_respond, ns_return, ns_returnadminnotice, ns_returnbadrequest, ns_returnerror, ns_returnfile, ns_returnforbidden, ns_returnfp, ns_returnnotfound, ns_returnnotice, ns_returnredirect, ns_returnunauthorized, ns_write - commands

== SYNOPSIS ==

: '''[[ns_connsendfp]]''' ''fp len''
: '''[[ns_respond]]'''
: '''ns_return''' ''status type string''
: '''[[ns_returnadminnotice]]''' ''status msg ?longmsg?''
: '''[[ns_returnbadrequest]]''' ''reason''
: '''[[ns_returnerror]]''' ''status msg''
: '''[[ns_returnfile]]''' ''status type filename''
: '''[[ns_returnforbidden]]'''
: '''[[ns_returnfp]]''' ''status type fileid len''
: '''[[ns_returnnotfound]]'''
: '''[[ns_returnnotice]]''' ''status msg ?longmsg?''
: '''[[ns_returnredirect]]''' ''location''
: '''[[ns_returnunauthorized]]'''
: '''[[ns_write]]''' ''string''

== DESCRIPTION ==

These procedures provide a simple interface for returning information to the client. They build HTTP/1.0 headers and send the appropriate data out the socket to the client. The script does not end at the time ns_return* is invoked so you can continue processing data after the client has gotten the data and closed the socket.

''type'' should be a MIME type (see [[ns_guesstype]] for a list). ''status'' is a three-digit number fitting the pattern below:

: 1xx Informational - Not used, but reserved for future use.
: 2xx Success - The action was successfully received, understood, and accepted.
: 3xx Redirection - Further action must be taken in order to complete the request.
: 4xx Client Error - The request contains bad syntax or cannot be fulfilled.
: 5xx Server Error - The server failed to fulfill an apparently valid request.

Some common status values and their meanings are:

: 201 Created
: 202 Accepted
: 203 Provisional Information
: 204 No Content
: 300 Multiple Choices
: 301 Moved Permanently
: 302 Moved Temporarily
: 303 Method
: 304 Not Modified
: 401 Unauthorized
: 402 Payment Required
: 403 Forbidden
: 404 Not Found
: 405 Method Not Allowed
: 406 None Acceptable
: 407 Proxy Authentication Required
: 408 Request Time-out
: 409 Conflict
: 410 Gone
: 501 Not Implemented
: 502 Bad Gateway
: 503 Service Unavailable
: 504 Gateway Time-out

; ns_connsendfp
: This function writes len bytes of the specified channel or file to the conn.

; ns_return
: Sends back both the headers and the string.

; ns_returnadminnotice
: Wraps the text msg and longmsg in some html, appends a line with a link to "mailto:serveradministrator" based on the virtual server parameter "WebMaster".

; ns_returnbadrequest
: Returns a 400 status code and a formatted HTML message containing the reason text.

; ns_returnerror
: Wraps the text msg in some html and returns that to the client.

; ns_returnfile
: Sends back the headers and the contents of the file. ns_returnfile uses fastpath internally, so care should be taken when using it to return dynamically generated files.

; ns_returnforbidden
: Returns a 403 status code.

; ns_returnfp
: First sends the appropriate headers. Next, it writes out the contents of file from the current file position until the end of the file.

; ns_returnnotfound
: Returns a 404 status code.

; ns_returnnotice
: Wraps the text msg and longmsg in some html and returns that to the client.

; ns_returnredirect
: Returns a redirect to the passed in location

; ns_returnunauthorized
: Returns a 401 status code

; ns_write
: Writes the string out the connection. You can use it instead of the ns_return or ns_respond functions to build HTTP responses. AOLserver will not include the usual headers on the output data. The script does not end at the time ns_write* is invoked so you can continue processing data after the client has gotten the data and closed the socket.

== SEE ALSO ==

: [[ns_connsendfp]], [[ns_respond]], [[ns_returnadminnotice]], [[ns_returnbadrequest]], [[ns_returnerror]], [[ns_returnfile]], [[ns_returnforbidden]], [[ns_returnfp]], [[ns_returnnotfound]], [[ns_returnnotice]], [[ns_returnredirect]], [[ns_returnunauthorized]], [[ns_write]]

__NOTOC__
[[Category:Documentation]]
[[Category:Core Tcl API]]

Ns returnfile

2008-08-18T23:53:57Z

Jcr:

ns_returnfile 200 "application/zip" $filepath
ns_returnfile 200 [ns_guesstype $file] $filepath

ns_returnfile uses fastpath internally, so care should be taken when using it to return dynamically generated files.

For now, see [[ns_return]]

Want to name the file?

ns_set update [ns_conn outputheaders] content-disposition "attachment; filename=1.abc"

AOLserver Cookbook

2007-09-29T21:59:54Z

Jcr:

A collection of questions, and code examples to answer them.

Add your questions here. Answers should be placed below the question. Place a horizontal line ("----") between questions. Please keep this text before the first question.

__TOC__

----

== Limiting bandwidth ==

Is there a simple way to limit bandwidth per connection/ip???

: There's no simple way of doing it, i.e., no configuration option you can set. If I had to implement this, I'd use NSV's and [[ns_register_filter]] to keep track of bandwidth consumed by each client IP which can act as an all-or-nothing mechanism. However, what might be interesting to implement in the socket driver is a setting to control the rate at which bytes are written back to the socket, perhaps configurable per request, so that large HTTP responses don't soak up your upstream bandwidth. We should keep this in mind for a future version of AOLserver. ''-- [[User:Dossy|Dossy]] 20:06, 4 November 2005 (EST)''

One more question... How can I read output buffer inside function registered as postauth filter?
And how can I stream it? ns_adp_puts cannot be used inside filters... ns_return would return all data at once. I assume that per connection limit would look like this:
<pre>
proc ..... {
ns_adp_stream
set data [get output content buffer]
set data_length [output buffer size]
set block_size 4096
for {set i 0} {$i < $data_length} {incr i $block_size} {
send_to_client [string range $data [expr $block_size*$i] [expr $block_size*[expr$i+1]]]
sleep 1
}
ns_returnok
return filter_return
}
</pre>
I want to limit only one vhost so nssock limit would be too much;)

: First, you don't want to turn [[ns_adp_stream]]'ing on. Getting the size of the ADP output buffer can be done using [[ns_adp_tell]] and getting the contents with [[ns_adp_dump]]. I guess you could [[ns_adp_trunc]] the output buffer to clear it, then slowly write the contents back using [[ns_write]]. You'd also then need to look at [[ns_conn]] '''outputheaders''' to make sure that you wrote the proper HTTP response ... ah, but I don't know if you can get the HTTP response status code somehow. I still think doing it in nssock is probably the best place, even with vhosts -- I'd make it a preauth or postauth filter that sets the configuration for the response and then have nssock be responsible for ensuring the response is written at that rate. ''-- [[User:Dossy|Dossy]] 07:24, 8 November 2005 (EST)''

ns_adp_tell inside postauth filter:
Error: This function cannot be used outside of an ADP
what's more, i use ns_returnfile inside some adp code and if i use ns_adp_tell after it, it returns 0 (this adp only returns file, no adp_puts or write).
Unfortunetly i think there is no other solution then implement it inside nssock or implement some tcl code to manipulate all output buffer.

I use this code for big files... some time I'll add per ip limit, now it's for connection.
<pre>
proc returnfile { file } {
set filefp [open $file r]
fconfigure $filefp -translation binary
set data_length [file size $file]
set block_size 4096

ns_write "HTTP/1.0 200 OK
MIME-Version: 1.0
Content-Type: [ns_guesstype $file]
Content-Length: $data_length

"
while { ! [eof $filefp] } {
ns_writefp $filefp $block_size
ns_sleep 1
}

ns_conn close
}
</pre>
Paul Bukowski
----

== Virtual server configuration ==

Is it possible to use wildcard '*' in domain name inside "ns/module/nssock/servers" section of aolserver4 config file? I would like to map all requests to *.somedomain.org to one virtual host...
Something like this doesn't work:

ns_section "ns/module/nssock/servers"
ns_param forum somedomain.org
ns_param forum somedomain.org:80
ns_param forum *.somedomain.org
ns_param forum *.somedomain.org:80
ns_param forum "*.somedomain.org"
ns_param forum "*.somedomain.org:80"

-Paul Bukowski

: ''2005aug15 [[Dossy]]: Unfortunately, no -- you currently can't use wildcards the way you want. Not yet, at least.''

Why won't you get some code for mass virtual hosts from http://naviserver.sourceforge.net/ ??
-PB

: Right now, to map a request to its (virtual) server, there's an O(n) search being done, but it's a "cheap" exact string comparison. To implement glob-style wildcard support, it'll become a more expensive (but possibly still "cheap" by most people's standards) glob-match comparison. When you're serving "n" requests per second (where "n" is small) the difference in cost is probably immeasurable, but when "n" is large, the cost is additive and possibly significant. It might be good if someone could benchmark the two and see what the real cost is. ''-- [[User:Dossy|Dossy]] 20:12, 4 November 2005 (EST)''

----

== Server-side Includes ==

Does anyone have some code to implement apache-compatible SSI (Server-side includes)? I have some old pages that use SSI that I'd like to move to my aolserver install but I don't have the time to rewrite them as ADPs.

: ''[[User:Dossy|Dossy]] 20:20, 4 November 2005 (EST)'': I make no representations or warranties about the safety (!) or correctness of the code I'm about to share, but it might get folks started on a proper implementation in the future. In particular, I didn't implement any commands other than "include" and I even implemented it "wrong" (not according to [http://hoohoo.ncsa.uiuc.edu/docs/tutorials/includes.html the specification]). If there's real interest in having a complete SSI implementation for AOLserver, I'd be willing to improve this code.

<pre>
ns_log Notice "ssi: registering SSI ADP tags"

proc ssi_include_tag {params} {
set param_count [ns_set size $params]
for {set i 0} {$i < $param_count} {incr i} {
set ssi_var_[ns_set key $params $i] [ns_set value $params $i]
}

if [info exists ssi_var_file] {
if {[ns_adp_argc] > 1} {
set basedir [lindex [ns_adp_argv] 1]
} else {
set basedir [ns_adp_dir]
}
if [regexp {^/} $ssi_var_file] {
set filename $ssi_var_file
} else {
set filename $basedir/$ssi_var_file
}
return [ns_adp_parse -file $filename $basedir]
}
}

ns_register_adptag {!--#include} ssi_include_tag

ns_log Notice "ssi: registering SSI ADP tags done"
</pre>

----

Is there a way to see only the errors (for example - 'variable' xxx not found? I seem to remember 2 logs - servername.log and servername-error.log? The version I have now - aolserver 3.2/ad1.2 only seems to give us servername.log - and all the error messages are mixed with the normal msgs - its very hard to debug!
[[dannyl50]]

The default/example config file did not have entries for both logs. The two sections you need look like (in old style notation):

[ns/parameters]
User=nsadmin
Group=nsadmin
ServerLog=/var/log/aolserver/servername-error.log
PidFile=/var/log/aolserver/nspid.servername
Home=/usr/bin/aolserver-3.3ad13

and

[ns/server/servername/module/nslog]
File=/var/log/aolserver/emp.log
LogCombined=On
MaxBackup=3
RollFmt=%Y-%m-%d-%H:%M
RollHour=0
RollOnSignal=On
RollLog=On

----

Howdy! Can someone tell me, in general terms, how they have implemented [[nsperm]]? It looks cool, but I am using a plain old database with names and passwords, and it is very easy. I would like the allow/deny functionality, can I have that without the username/password part? -- [[Ian Harding]]

''I've implemented [[nsperm]] to restrict access to specific URLs using HTTP authentication (the username/password dialog) and cookie-based (if they have the correct cookie, otherwise URL redirect them to a login page that may set the cookie).''
''The latter is done using a registered preauth filter. I chose to use [[nsperm]] over a database since [[nsperm]] (presumably) manages the authentication information in memory better than repeatedly hitting the database with authentication requests, but there's no reason''
''I couldn't have used a database to store username/password information. Does this answer your question?'' -- [[Dossy]]

Pretty much, although I started writing my app before I understood AOLServer, so I have a rather strange design that is good in some ways, bad in others. Keep in mind that this is a low activity app, no more than 20 concurrent users right now.

What I did was to create an [[ADP]] that has a big case statement. It calls functions to generate pages based on the 'task' value it is passed through POST. I have created a pretty complex app this way, not using [[ns_register_proc]] at all. I know now I should have. As I understand it, ns_register_proc lets you create a 'virtual' directory structure that actually just calls certain procedures based on the GET or POST requested URL. This is far more graceful than hitting my main adp which opens up the form data, looks at the 'task' value, and decides which procedures to call.

Given this lame structure, each time someone requests the main adp, I just check for a valid cookie and generate a login page if it's not there. After that, I have to set another cookie that is their 'access rights' which is then checked from within the procs that generate the pages. If I was doing it right, I could have registered a proc that would fire for all URLs in my virtual tree, checking your rights to the particular URL you reqested, and redirecting you if you are not allowed, right?

Thanks!!! -- [[Ian Harding]]

''I probably would've created an ADP per task, and then registered a preauth filter that checked for the cookie and redirected the user to the login page (outside the directory that the preauth filter covers''
''-- avoid funny redirection loops) if the cookie wasn't set properly.''
''If you don't want to create a separate ADP per task, you could have used ns_register_proc to create what you describe as "virtual pages" and still have the preauth filter kind of "sit in front" and handle the autehntication, keeping that logic seperate from your actual page generation code.'' -- [[Dossy]]

I started with a separate adp for each task, but I thought it would get out of hand quickly. I do think I will re-work the thing to use ns_register_proc and even do away with the few adp I do have. It seems far easier to maintain. In the meantime, I have to re-write all my SQL Server procedures in PostgreSQL PL/Tcl. That's why I want the [[nsfreetds]] module so badly, it buys me a little time!

Thanks for all your work! -- [[Ian Harding]]

----

''Speaking of [[nsfreetds]], did you try nsfreetds-0.1pre? Any luck? Any problems?'' -- [[Dossy]]

I just now tried it. I installed freetds with no trouble, compiled nsfreetds, modified my nsd.tcl [[config file]], added the datasource to interfaces, and all seems fine, except for that I always get "no access to pool "mypool" while executing "ns_db gethandle mypool" ..."

I must have missed something. I saw something in the README about setting $env(SYBASE) before starting nsd. Is this the same as the SYBASE=/usr/pkg/freetds I had to do even before the build of nsfreetds?

Thanks again... I feel like I am close.. -- [[Ian Harding]]

''Yes, the $env(SYBASE) means setting the SYBASE environment variable. To be safe, you can try this:''

$ cd /path/to/aolserver/install
$ SYBASE=/usr/pkg/freetds; export SYBASE
$ bin/nsd ...args...

''Check log/server.log to make sure that the nsfreetds driver is actually loading. You should see a lines like this at start-up:''

[30/May/2001:13:42:37][11838.1024][-main-] Notice: modload: loading '/home/aolserver-dev/bin/nsfreetds.so'
[30/May/2001:13:42:37][11838.1024][-main-] Notice: Ns_FreeTDS_DriverInit(freetds): Loaded Panoptic FreeTDS Driver v0.1-pre, built on May 21 2001 at 22:23:01.

''Are you getting an error in the [[server log]] instead?'' -- [[Dossy]]

I don't get an error, it seems to load nicely. I can post or give you access to whatever files or output you would like to see, or an ssh login... -- [[Ian Harding]]

----

Another question: Global variables ([[nsv]]*). I am re-writing my app to use the [[ns_register_proc]] functionality versus my kludge where everything goes through an [[ADP]] that acts as a filter and traffic cop. I have figured out register filter and register proc, but seem not to be able to use [[ns_puts]] from within the procs. Is this right? Anyway, I had been using [[ns_adp_include]] in my filter/traffic cop page to put consistent headers/footers on my pages. I gather the more correct way (and only possible way with registered procs?) is to use global variables.

When do I initialize them? How do I use them? What are the caveats? W

Thanks, -- [[Ian Harding]]

''Have you started by reading the NSV documentation?'' -- [[Dossy]]

Of course not 8^0 That would be too easy! I will... -- [[Ian Harding]]

OK, I read it. It's too easy. I use it for header, footer, and client side script html, which I stuff into html variable before returning it. I would like the filter option we talked about in the chat which would prepend or append html automatically, but this will do. -- [[Ian Harding]]

----

How hard would it be to add an HTTPS equivalent of Ns_FetchURL?

''If you can build shared libraries on your target platform with OpenSSL, it probably wouldn't be too hard. The trick would be writing enough stub code that can be loaded via the Tcl "load" proc so that you could access the OpenSSL-based https client from your Tcl code. Is there a lot of demand for this? I could probably bang something out as an initial attempt.'' -- [[Dossy]]

[[Scott Goodwin]]'s [[nsopenssl]] now contains client side https functionality.

----

Am I a brick, or does ns_register_proc just plain not work with more than one argument for the proc? I have tried the following code on both aolserver 3.2 running on NT4 and aolserver 3.4 on NetBSD 1.5. It fails to register the proc even once, if I try to register it with more than one argument anywhere else.

ns_register_proc GET /foo1 foo 1
ns_register_proc GET /foo2 foo 1 2
ns_register_proc GET /foo3 foo 1 2 3

proc foo { conn one {two 22} {three 333}} {
ns_return 200 text/html "one is $one, two is $two, three is $three"
}

This must be something simple. I have already posted to the aolserver list but the listserv seems to have gone mad.

[[Ian Harding]]

''What are you trying to do? It appears you want to pass constant parameters to your procedures. If they are constants, why pass them? Since ns_register_proc calls are generally in the global scope (and sourced when nsd starts) even a parameter that appears to be a variable probably can/will not vary.''

''Presumably you need to get information from one page to another. That means formvalues unless your page is stateful (usually a bad idea). Check out the '''[[ns_conn]] form''' command to get yourself started.'' -- [[Jason Kane]]

----

OK, I'm using Windows 2000 SP2 and 3.4.1, and trying in vain to get Perl CGIs (legacy) to work. The scripts work outside of Aolserver, and work on AOLserver on Linux, but when I try inside the script to GET from myself (eg, GET http://localhost:8000/foo?bar=bas), I'm told "unknown protocol TCP", which is quite aggravating.

Does anyone have any experience administering AOLServer on Windows?

Thanks in advance!

-Bill

----

This is interesting, wy do you let me change your page?
I'm trying to find an example of how to get my data using:
set formdata [ns_conn form $conn]

-Jason

Because it's a wiki! A proc that gets posted variables includes the line you wrote there... then when you want to actually get the values, you can use something like

set myvar [ns_set get $formdata myvar]

where myvar is the name of the variable. There is also ns_queryget which looks like

set myvar [ns_queryget myvar defaultval]

This is handy because if there is no value, it will assign a default value.

Check out aolserver.com, they have extensive (although sometimes misleading) docs. If something the docs says should work doesn't, ask. It may be out of date.

[[Ian Harding]]

----

I don't know where else to share my code fragments, so here seems like as good a place as any. This one implements user public_html directories. It's based on someone else's stuff (I forget whose tho). It should really do something with unknown mime types, and should do a better job with errors like unknown users. It does honor directoryFile and adp maps in the config file.

It works by registering a procedure to /users that interprets the username and finds their directory. ns_register_proc doesn't allow wildcards other than in the last path element, so /~* wouldn't work. However that's not a problem for a filter, so there's a filter to take your /~user url and redirect it to /users/user

-JR

proc homedir { conn ctx } {
set url [ns_conn url $conn]
set user {}
set file {}
regexp {^/users/([^/]*)(/.*)?$} $url dummy user file
# ns_returnnotice 200 "url is $url user is $user, file is $file"
set userfile [getUserFile $user $file]
set type [ns_guesstype $userfile]
if {[string match "*[ns_config ns/server/[ns_info server]]/adp map]" $userfile]} {
# ns_log notice "adp parsing $userfile"
set cwd [pwd]
cd [file dirname $userfile]
# ns_return 200 text/html [ns_adp_parse -file $userfile]
set result [catch {ns_adp_parse -file $userfile} error]
if {$result} {
ns_return 200 text/html $error
} else {
ns_return 200 text/html $error
}
cd $cwd
} else {
switch $type {
"*/*" {
}
default {
ns_returnfile 200 $type $userfile
}
}
}

if {[catch {set fp [open $userfile]}]} {
ns_returnnotfound
return
}
}

proc getUserFile {user path} {
foreach tail [split ,[ns_config ns/server/[ns_info server] directoryfile] ,] {
set userfile "[glob ~$user]/public_html$path$tail"
if {[file exists $userfile] && ![file isdirectory $userfile]} {
return $userfile
}
}
ns_returnnotfound
# break
}

ns_register_proc GET /users/ homedir
ns_register_proc POST /users/ homedir
ns_register_proc HEAD /users/ homedir

proc userRedir {conn arg why} {
set url [ns_conn url]
regsub {^/~(.*)} $url {/users/\1} redir
ns_log notice "url is $url, redir is $redir"
ns_returnredirect $redir
return filter_break
}

ns_register_filter preauth GET /~* userRedir

----

Hi!

Does anybody know a graphing module for Aolserver/TCL, with e.g. bargraphs, linegraphs,... ?

-[[wiwo]]

''Yes: [[nsgds]], [[nschartdir]].''

----

Can I detect if the user pushes the Stop button in their browser in my TCL/ADP page?

Yes, although it's a kludge. ns_write will return zero if it cannot write because the connection has been lost. However, ns_write is not stupid enough to try writing when you give it nothing to write, and so you must send something to the client. To prevent this being rendered use HTML comments, e.g.

if {[ns_write "<nowiki></nowiki>"] == 0} {
# user hit the stop button, browser page was closed, or connection to client was lost.
}

[[Ximon Eighteen]]

----

== Generating random passwords ==

The following method can be useful to generate random passwords and/or password salts.

<pre>
# desired length of random string
set iStringLength 8

# characters allowed to appear in the string
set sAllowableCharacters "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

# get length one time
set iAllowableCharacters [string length $sAllowableCharacters]

# begin random string as empty
set sRandomString ""

# loop until desired length is achieved
for {set ii 0} {$ii < $iStringLength} {incr ii} {

# get next random between 0 and length of allowed characters
set iRandomInt [ns_rand $iAllowableCharacters]

# retrieve this random character
set sRandomCharacter [string index $sAllowableCharacters $iRandomInt]

# append the character to our random string
append sRandomString $sRandomCharacter

}

ns_adp_puts "sRandomString: $sRandomString"
</pre>

---

== Customizing error pages ==

Edit your AOLServer's config file, and add the paths to the error pages as follows:

<pre>
#
# Internal redirects
#
ns_section "ns/server/${servername}/redirects"
ns_param 404 "/notfound.html" ;# Not Found error page
ns_param 500 "/servererror.html" ;# Server Error page
</pre>

---

== Fast caching of generated pages ==

You can use an adp page to handle a 404 (not found) error that generated exactly the page it was looking for. Conceptually this is similar to how tcl's autoloading using unknown works. From Bas Sheffers, via John Buckman.

from config.tcl:
<pre>
ns_section "ns/server/$server1/redirects"
ns_param 404 /404.adp
</pre>

404.adp:
<pre>
<% handle_404 %>
</pre>

Support procs:
<pre>
proc handle_404 {} {
set myurl [myurl]
set parts [split $myurl /]
set root [lindex $parts 1]

if {$root == "photo"} {
return [404_photo $parts]
} else {
ns_returnredirect "[myhost]/"
return
}

}

proc 404_photo {parts} {

set userid [file rootname [lindex $parts 2]]
set d [user_photo_data $userid]
if {$d == ""} {
set fn "/b/photo/unknown.jpg"
} else {
set fn "/b/photo/${userid}.jpg"
write_binary_file $fn $d
}
ns_returnfile 200 "image/jpeg" $fn
}

proc myurl {} {
return [lindex [split [ns_conn request]] 1]
}

proc photo_cache_dirty {userid} {
set fn "/b/photo/${userid}.jpg"
file delete $fn
}
</pre>

Ns adp safeeval

2007-09-24T19:33:45Z

Jcr:

'''NAME'''

: ns_adp_safeeval - Safely evaluate an ADP block

'''SYNOPSIS'''

: '''ns_adp_safeeval''' ''page ?args ...?''

'''DESCRIPTION'''

: This function evaluates the ADP specified by ''page'' just as [[ns_adp_eval]] does, except that it ignores inline scripts "<% ... %>"; only adp registered tags are executed. This is useful for providing a limited execution environment for untrusted code (such as user-created templates) without allowing potentially damaging code to run on the server.

'''EXAMPLES'''

'''SEE ALSO'''

: [[ns_adp_abort]], [[ns_adp_append]], [[ns_adp_argc]], [[ns_adp_argv]], [[ns_adp_bind_args]], [[ns_adp_break]], [[ns_adp_debug]], [[ns_adp_debuginit]], [[ns_adp_dir]], [[ns_adp_dump]], [[ns_adp_exception]], [[ns_adp_include]], [[ns_adp_mime]], [[ns_adp_mimetype]], [[ns_adp_parse]], [[ns_adp_puts]], [[ns_adp_registeradp]], [[ns_adp_registerproc]], [[ns_adp_registertag]], [[ns_adp_return]], [[ns_adp_safeeval]], [[ns_adp_stats]], [[ns_adp_stream]], [[ns_adp_tell]], [[ns_adp_trunc]]

----

[[Category Documentation]] - [[Category Core Tcl API]]

Ns adp parse

2007-09-24T19:28:18Z

Jcr:

Man page: http://aolserver.com/docs/tcl/ns_adp_parse.html

----

'''NAME'''

: ns_adp_parse - Parse an ADP file or string and return its output

'''SYNOPSIS'''

: '''ns_adp_parse''' ''?-file|-string? ?-safe? arg ?arg ...?''

'''DESCRIPTION'''

: This command processes an ADP from either a file or a string, returning the output. The first ''arg'' specifies the filename or contains the string to parse, depending on ''-file'' or ''-string''.

: If you need to process a second ADP from inside an ADP, it is usually better to use [[ns_adp_include]], because that command resolves relative pathnames passed to it. Also note that '''ns_adp_parse''' will ignore any directives to turn on streaming. Tcl_Eval() is used to evaluate the Tcl commands in the ADP.

: If you use the ''-string'' syntax, then ''arg'' is a string containing ADP syntax to be parsed. Note that when you call this command with the ''-string'' syntax from inside an ADP, the string cannot contain the "<% ... %>" syntax. The ''-string'' syntax is the default.

: If you use the ''-file'' syntax, then ''arg'' is the absolute path to the file containing the ADP to be parsed.

: If you specify the ''-safe'' flag, then only registered tags are executed; inline scripts using "<% ... %>" or "<%= ... %>" are ignored.

: You can pass optional arguments to the ADP. The arguments can be accessed within the ADP using the [[ns_adp_argc]], [[ns_adp_argv]] and [[ns_adp_bind_args]] commands.

: If this call is a nested ADP evaluation (where one ADP calls another), an error will be thrown if the depth exceeds 256, the maximum number of nested ADP evaluations.

'''EXAMPLES'''

% ns_adp_parse -string {<% return [[expr 2 + 2]] %>}
4

% ns_adp_parse -file [[ns_info pageroot]]/index.adp
... output of index.adp ...

'''SEE ALSO'''

: [[ns_adp_abort]], [[ns_adp_append]], [[ns_adp_argc]], [[ns_adp_argv]], [[ns_adp_bind_args]], [[ns_adp_break]], [[ns_adp_debug]], [[ns_adp_debuginit]], [[ns_adp_dir]], [[ns_adp_dump]], [[ns_adp_eval]], [[ns_adp_exception]], [[ns_adp_include]], [[ns_adp_mime]], [[ns_adp_mimetype]], [[ns_adp_puts]], [[ns_adp_registeradp]], [[ns_adp_registerproc]], [[ns_adp_registertag]], [[ns_adp_return]], [[ns_adp_safeeval]], [[ns_adp_stats]], [[ns_adp_stream]], [[ns_adp_tell]], [[ns_adp_trunc]]

----

[[Category Documentation]] - [[Category Core Tcl API]]

TDOM

2007-03-20T01:45:08Z

Jcr:

Documentation is available at http://www.tdom.org/doc-index.html

A very helpful tutorial is available at http://wiki.tcl.tk/8984

----

[[Dossy]]: [http://www.mail-archive.com/aolserver@listserv.aol.com/msg06871.html Assigning a prefix to the default namespace when using XPath in tDOM]

I don't know how many folks are using tDOM but I'm sure more and more
are. I keep stumbling into this problem of trying to access child nodes
which are in the default namespace but the parent is in a named
namespace ... and trying to write XPath expressions start to look really
dog-awful, like:

$root selectNodes {/*[local-name()='foo']/*[local-name()='bar']/...}

So, I sat down for a few minutes and thought about the problem, and
after some head-scratching, it hit me: name the default namespace. Duh.
So, here's some sample code:

### IMPORTANT: This code lets us get at nodes with a null prefix.
if {[$root hasAttribute xmlns]} {
$root setAttributeNS "" xmlns:default [$root getAttribute xmlns]
}

So, now, I can rewrite that XPath expression above:

$root selectNodes /default:foo/default:bar/...

Man. Life just couldn't get any better.

If any of you are wondering why this matters, here's a sample XML doc
and some sample code illustrating the beauty:

set xml {
<aaa:duh xmlns="booboo" xmlns:aaa="blort">
<foo>
<bar>some text</bar>
</foo>
</aaa:duh>
}

$doc [dom parse $xml]
set root [$doc documentElement]

Suppose you want to get the text node inside <bar> with an absolute
XPath expression. You might think you could write:

[$root selectNodes /aaa:duh/foo/bar] text

Ah, but XPath *SPANKS* us and tells us we're naughty, that <foo> and
<bar> have a null prefix and live in the unnamed namespace. That line
of code returns an empty string, not "some text" as we might have
expected. So, we tell XPath "well, how about you do me a favor and
pretend like any node in the unnamed namespace really has a name of my
choosing ..." by doing this:

$root setAttributeNS "" xmlns:default [$root getAttribute xmlns]

We're telling the processor to name all nodes in the default namespace
as though they were in the namespace named "default". N.B.: If your
XML document really *HAS* a namespace named "default", this code will
likely CLOBBER it and give you really weird behavior. Change
"xmlns:default" in the above line to a namespace that won't ever exist
in your document, then.

Now that we've done this, lets rewrite that XPath expression and try
again:

[$root selectNodes /aaa:duh/default:foo/default:bar] text

Ahh! It returned the string "some text" -- exactly what we wanted.
Notice the injection of "default:" above before "foo" and "bar" -- since
we just told the processor that nodes in the unnamed namespace (i.e.,
<foo> and <bar>) now live in the namespace named "default", in order to
specify them in an XPath expression, we need to say "default:foo" and
"default:bar". But this is a hell of a lot easier to read than
"*[local-name()='foo']" and "*[local-name()='bar']", at least on my
eyes.

If this is all old news, feel free to ignore this email. I hadn't seen
it documented anywhere and I know I've puzzled over this for at least an
hour or two over the past few months, so maybe this write-up might save
a few people the same agony.

----
While the above code generally works, the explanation is slightly incorrect.
It is not naming the the default namespace, is is binding a known
prefix to the uri of the default namespace, which it looks up. An xml namespace
is not the (possibly null) prefix; is is the uri to which the prefix is bound.
In particular, to match nodes, the prefixes need not match, but the namespace uris
must. Plain xml obscures this to a certain extent, but xpath makes it painfully
clear.

The right thing to do is to always know what namespace uris are being used
in the document, and assign known prefixes to all of them rather than to rely on
the context node having all the needed (and convenient) bindings.

Note too that the above code will be of no help if the null prefix is assigned
or changed in a child of the context node.

----
[[Category:Modules]]