Let's begin our page-by-page tour of the ColdFusion Administrator with the Server Settings section, which makes up the first part of the left navigation column. The pages in this section pertain mostly to tweaking the server's performance. Aside from the Data Sources page in the next section, this is the most important portion of the ColdFusion Administrator, and the part you will probably become most familiar with.
The Settings Page
The Settings page contains various options related to tweaking the server's performance and responsiveness to page requests from your users. It also contains options for controlling what happens when errors occur.
Timeout Requests After (Seconds)
If you want to make sure that ColdFusion spends no more than 20 or 30 seconds working on a particular page request, go ahead and check the Timeout Requests After checkbox, and provide the appropriate value for the number of seconds. If a page takes longer than the number of seconds you specify, the page will simply halt and display an error message.
I strongly suggest that you enable this option, and set it to a relatively low number to start off with, perhaps 20 or 30. A long-running page can be terminated, so the server can move on to other page requests that should be easier for it to generate quickly.
You can override the request timeout you provide for this setting on a page-by-page basis. Just use the <cfsetting> tag, specifying the maximum number of seconds that you would like the page to be allowed to execute as the requesttimeout attribute. For instance, if you wanted a particular page to run for up to five minutes (perhaps it performs a large file transfer operation with <cfftp>), you would use the following code, near the top of the page:
<!--- Allow this page to execute for up to five minutes ---> <cfsetting requesttimeout="300">
Keep in mind, however, that a long-running page could block other pages from executing. You might, therefore, want to use the <cflock> tag to make sure that only one instance of the long-running page is able to execute at the same time. You would use the <cflock> attribute with a name attribute that was unique to that particular ColdFusion file, like this:
<cftry> <cflock name="MyLongRunningFTPTransferPage" type="EXCLUSIVE" timeout="30"> <!--- Allow this page to execute for up to five minutes ---> <cfsetting requesttimeout="300"> <!--- ...long running code would go here... ---> </cflock> <!--- If the lock can't be obtained, display a message and stop ---> <cfcatch type="Lock"> Sorry, but another user is currently using this page. Please try again in a few minutes. <cfabort> </cfcatch> </cftry>
Alternatively, you could use a name value that was the same for all long-running pages; this would ensure that only one of the long-running pages was allowed to execute at one time.
For more information about <cflock>, see Chapter 18, "Introducing the Web Application Framework," in Volume 1.
Enable per-App Settings
Settings defined in the ColdFusion Administrator apply to all applications running on the server. ColdFusion allows specific settings to be overridden at the application level. For example, the Custom Tags folder is shared by all applications. If two applications create custom tags with the same name, there is a real risk that the wrong tag will be invoked inadvertently. The capability to define a different Custom Tag folder for each application (overriding the default location that is specified) solves this problem.
Per-application settings are not defined in the ColdFusion Administrator. Rather, they are defined programmatically in the application's Application.cfc file.
Application.cfc was introduced in Chapter 18.
To enable support for per-application settings, check the Enable per App Settings box (this is enabled by default).
Use UUID for cftoken
As you learned in Chapter 19, "Working with Sessions," in Volume 1, Cold-Fusion uses values called CFID and CFTOKEN to identify each browser machine. The CFTOKEN value is used as a kind of password that allows users to be connected to their client variables on the server. In addition, this value is used (in concert with the notion of a session timeout) to connect users with their session variables on the server.
I recommend that you go ahead and enable this option unless you have an existing application that uses the CFTOKEN internally in some manner and depends on it being a number.
Enable HTTP Status Codes
This setting allows ColdFusion to return true HTTP status codes in the header of its response if an unexpected error occurs. For instance, if a user requests a ColdFusion page that doesn't exist on the server, ColdFusion will be able to return a true error message (HTTP status code number 404) that other machines can understand to mean "not found." If this option is unchecked, ColdFusion would simply display a page that contained a message saying the page could not be found (not so helpful for proxy servers, search engines, or machines trying to access Web Services on your server).
Similarly, if ColdFusion needs to report an error message, the HTTP status code of the server's response will be set to 500 if this option is checked. If left unchecked, the error message is displayed, but the status code remains set to the normal HTTP status code, 200, which means that other automated systems on the network can't really tell that anything has gone wrong.
As a general rule, never keep this option checked on development servers. If desired, keep it checked (it is enabled by default) on production servers only.
Enable Whitespace Management
When enabled, this option makes sure that extraneous white space (such as the various hard returns, spaces, and tabs that you use to indent your ColdFusion code) is removed from any generated HTML code before it's sent back to browsers.
I recommend that this option be enabled (it is enabled by default) in nearly all cases. There are a few special situations in which you would not want white space to be removed (for instance, if you are using <pre> blocks in your pages), but you can always turn off the white-space management on a case-by-case basis with the <cfprocessingdirective> tag.
For more information about white-space management, see Chapter 27, "Improving Performance."
Disable CFC Type Check
Arguments for ColdFusion Components methods (and user-defined functions) are validated by ColdFusion. This means that if the argument expects a specific data type to be passed to it, ColdFusion checks that the correct type was indeed passed.
Arguments can accept lots of types, including ColdFusion Components. By default, when an argument accepts a ColdFusion Component, ColdFusion checks that the component passed is of the right type. This check can be time consuming (milliseconds, but still slower than other argument type checks). To improve performance, you can disable CFC type checking.
See Chapter 22, "Building User-Defined Functions," and Chapter 24, "Creating Advanced ColdFusion Components," for more information about UDFs and CFCs.
Disable Access to Internal ColdFusion Java Components
ColdFusion features internal Java objects that can be used to perform all sorts of server administration. Indeed, the ColdFusion Administrator itself (and the Administrator APIs) use these Java objects extensively.
Because ColdFusion code can invoke Java objects, these internal objects can also be invoked and used. On shared servers, this can be a potential security problem, so you can block access to ColdFusion's internal Java components if needed.
See Chapter 68, "Extending ColdFusion with Java," in Adobe ColdFusion 9 Web Application Construction Kit, Volume 3: Advanced Application Development, for more information about ColdFusion Java integration.
Prefix Serialized JSON With
See Chapter 15, "Beyond HTML Forms: ColdFusion-Powered Ajax," in Volume 1, and Chapter 30, "Advanced ColdFusion-Powered Ajax," to learn about ColdFusion and Ajax integration.
Enable in-Memory File System
A virtual file system (VFS) has been added to ColdFusion 9. It is a RAM-based file system that can be manipulated similarly to the local file system, but because it is in memory, it has better performance and execution time. Any file and directory operations and manipulations performed in ColdFusion can be performed with the VFS: that is, you can create runtime CFCs and CFMs in RAM and execute them, and any tag that uses a local disk file as input and output can also use a VFS file as the same input and output. There is also the option to set a memory limit for the in-memory VSS.
Watch Configuration Files for Changes
ColdFusion configuration settings are stored in external XML files. These files are typically never modified directly; they are updated as needed by ColdFusion itself (when changes are made using the ColdFusion Administrator or the Administrator API). If changes are made to the files directly, these changes will not be seen by ColdFusion until the server has been restarted.
However, if needed, ColdFusion can watch its own configuration files and reload their contents (the settings) if file changes have occurred. If this capability is needed, check this option.
Enable Global Script Protection
Check this box to have ColdFusion check URL, FORM, CGI, and COOKIE variables for potential cross-site scripting attacks.
This option is explained in Chapter 21, "Securing Your Applications," in Volume 1.
Default ScriptSrc Directory
Allow Extra Attributes in Attribute Collection
ColdFusion tags can pass nonstandard attributes in the attribute collection structure.
Google Maps API Key
A valid googleMap API key is required to use ColdFusion's built-in googleMaps capabilities in your application. You can specify this key in this ColdFusion Administrator section, which is available globally, per server instance, or define it in your code before you use this functionality.
The CFMAP key can be defined at three levels, or scopes. Thus, the accessibility of the key depends on where you have defined it.
- Server scope: Shared for all applications running within the server instance.
- Application scope: Available from within the application scope.
- Template scope: Accessible only within that template.
Missing Template Handler
You can create a ColdFusion page that will be executed and displayed whenever a user requests a ColdFusion page that doesn't actually exist on the server. This page will take the place of the default Not Found message that would ordinarily appear. The missing template handler can contain whatever ColdFusion code you like. Just specify its location here, in the ColdFusion Administrator. Be sure to include the complete file path to the file (including the c: or whatever is appropriate), not just its name.
Site-wide Error Handler
You can also create a ColdFusion page that will be executed and displayed whenever an uncaught error (exception) is displayed. This page will take the place of the standard error message that would ordinarily appear. Again, just specify its location here, in the ColdFusion Administrator. Be sure to include the complete file path to the file (including the c: or whatever is appropriate), not just its name.
You can still specify customized error handling pages on a page-by-page or application-by-application basis with the <cferror> tag, as explained in Chapter 44, "Error Handling," online.
Maximum Size of Post Data
One type of server attack overloads the server by making it process requests with massive amounts of data attached. This type of attack uses POST submission, and so ColdFusion can be instructed to ignore (and terminate) any requests with POST data greater than a specified size. To implement this option, specify a size.
Request Throttle Threshold
ColdFusion can throttle (forcefully slow down) incoming requests if needed. However, really small requests (those with a small payload) can be allowed through regardless of the throttle state. To allow small requests to be processed, specify the maximum allowed size (the default is a maximum of 4 MB).
Request Throttle Memory
To throttle requests, specify the maximum amount of memory allocated for the throttle. If not enough total memory is available, ColdFusion queues requests until enough memory is free (the default is 200 MB).
The Request Tuning Page
The Request Tuning page is used to manage and control how ColdFusion handles the processing of concurrent requests.
Maximum Number of Simultaneous Template Requests
ColdFusion is fast and efficient, but it obviously can't handle an unlimited amount of page requests at once. At some point, any server will become overwhelmed if it tries to serve too many users at once. This setting allows you to tweak your server's performance by adjusting the maximum number of page requests that it can process at the same time.
Because this setting can have a big impact on an application's performance, it would be nice if there were a hard-and-fast rule that you could use to determine the best value to provide. Unfortunately, there is no such rule. The more powerful your hardware—a greater amount of RAM, faster processors, quicker hard drives, and faster network connections to your databases—the more requests it can handle at one time.
Therefore, depending on your hardware specifications, reducing the number of requests allows ColdFusion to devote its resources to a small number of tasks, thus executing all tasks more quickly. If you think your server can handle more requests, try your ColdFusion applications with the increased setting under load in a staging environment.
Here are some rules of thumb:
- Start with a value of 10, which is a pretty reasonable starting point.
- If your server has more than one processor, or if your server is extremely powerful in other ways, increase the number of simultaneous requests per processor. If the server is starting to show its age, decrease the number.
- If pages take more than a second or two in development, you may wish to consider reducing this number.
- To assist fast pages not being blocked by slow pages you should probably increase the number of simultaneous requests. In addition, you could use the <cflock> tag to make sure that a large number of the slow pages aren't allowed to execute all at once. For instance, you could place a <cflock> tag with name="VerySlowProcess" and type="Exclusive" attributes around code that you know will be time consuming or generally hard on the server. See Chapter 18 for more information about locking.
- If your application uses shared variables, especially APPLICATION variables, in such a way that you often need to request an exclusive lock to protect against race conditions, you will probably want to decrease the number of simultaneous requests (so that fewer locks actually block one another at runtime). See Chapter 18 for more information about race conditions.
Maximum Number of Simultaneous Flash Remoting Requests
Most inbound requests to ColdFusion originate from Web browsers, but ColdFusion also accepts requests from Flash (and Flex) applications via Flash Remoting. Thus, it is possible (if your site has lots of Flash applications) that Web browser requests may be queued waiting for Flash Remoting requests to complete.
ColdFusion allows you to specify how many requests to allow for Flash Remoting.
Maximum Number of Simultaneous Web Service Requests
ColdFusion requests can also be Web Services (SOAP) requests. As with Flash Remoting requests, ColdFusion allows Web Services requests to be restricted.
See Chapter 59, "Creating and Consuming Web Services," in Volume 3, to learn how to create and publish Web Services.
Maximum Number of Simultaneous CFC Function Requests
ColdFusion Components are usually invoked directly (from within other ColdFusion files and templates). CFCs can also be invoked via Flash Remoting and Web Services, and as already seen, this type of access can be capped if needed. ColdFusion Components can also be invoked via direct HTTP request. To cap this type of access, set the maximum here.
Maximum Number of Running JRun Threads
When ColdFusion runs using the integrated JRun server, it must share the total available threads with JRun. In addition to the threads that ColdFusion needs for processing, the underlying JRun requires threads itself. Thus, this value should always be greater than the sum of the previous four values (20 higher is a good starting point).
Maximum Number of Queued JRun Threads
The underlying JRun server can accept Java and J2EE requests in addition to ColdFusion requests (which are processed by ColdFusion running within JRun). JRun queues requests until they can be processed (by their destination, wherever it is), and that queue size is specified here.
Maximum Number of Simultaneous Report Threads
ColdFusion has an integrated reporting engine (used by <CFREPORT>). As report processing can be very resource intensive (especially the concurrent processing of very large reports), there is a risk that ColdFusion will be so busy creating reports that all other requests suffer from poor performance.
Thus, ColdFusion allows you to specify the maximum number of threads that can be allocated to report generation. Any requests greater than the specified maximum will be queued until they can be processed.
See Chapter 16, "Graphing, Printing, and Reporting," in Volume 1, to learn about ColdFusion reporting.
Maximum Number of Threads Available for CFTHREAD
ColdFusion requests are single threaded, but, using <cfthread>, ColdFusion applications can spawn additional threads to perform asynchronous processing. Although this feature can boost performance tremendously, it also introduces a risk that so many threads will be spawned that total system performance suffers.
Thus, ColdFusion allows you to specify the maximum number of threads that can be allocated for spawned thread processing. Any requests greater than the specified maximum will be queued until they can be processed.
See Chapter 26, "Managing Threads," to learn how to use threading and the <cfthread> tag.
Timeout Requests Waiting in Queue After n Seconds
If ColdFusion is busy processing as many requests as have been specified, any additional inbound requests will be queued until there is a free thread to process them. In theory, requests can be queued indefinitely, but in practice, you'll probably want to timeout the requests and display a custom error message.
The maximum request queue time can be specified in this option.
Request Queue Timeout Page
If queued requests time out, users will see a generic 500 message in their browser. To provide a custom error page, specify the path to a static HTML file (relative to the Web root) here.
The Caching Page
The word cache is a general term that refers to the use of a temporary area of a computer's memory or disk drive to store information that can be time-consuming to retrieve or calculate normally. The idea is to perform the action or calculation once, store it in the cache, and then use the information in the cache (the cached version) for subsequent requests, rather than performing the action or calculation over and over again. There always needs to be some limit placed on the amount of information in the cache; otherwise the size of the cache would become unwieldy and inefficient.
The Caching page of the ColdFusion Administrator is used to control the cache that ColdFusion uses to cache your ColdFusion code files, and the database cache that ColdFusion uses whenever you use the cachedwithin or cachedafter attributes in a <cfquery> tag.
Maximum Number of Cached Templates
ColdFusion converts your ColdFusion templates to compiled Java classes in the background. Whenever someone visits one of your ColdFusion pages, ColdFusion checks to see if the page has been converted to a Java class, and whether the Java class is up to date (that is, whether the .cfm file has been changed since the Java class was compiled). The same goes for any included pages, custom tags, and components. Certain aspects of this decision-making process, as well as the compiled Java classes themselves, are cached in memory to improve performance.
This setting lets you tweak the size of this template cache to improve performance. Ideally, you would want the cache to be big enough to hold all your templates.
Normally, when a user requests one of your ColdFusion pages, the server needs to check to see if the .cfm file has been changed since the last time the page was executed. If so, it recompiles the .cfm file into an updated version of the corresponding Java class; if not, the existing version of the Java class can be used. The same goes for any included files, custom tags, or ColdFusion components. It doesn't take much time for the server to check whether each file has changed, but even that little bit of time is for naught if you know that your ColdFusion files won't be changing over time.
Checking this option tells ColdFusion not to bother checking whether each ColdFusion file has changed. This can improve performance quite a bit, especially if the server is receiving a lot of page requests.
Cache Template in Request
If the Cache Template in Request option is not checked, every time a template is accessed (within the same request), it is inspected to see whether there are any changes. If this option is checked, then the template is inspected only the first time it is accessed within the request.
When the Component Cache option is checked, the components path is cached and not resolved again.
Save Class Files
The class files generated by ColdFusion .cfm source code may be cached in server memory or written to disk. To save class files to disk, check this option. This can improve performance on high-volume sites.
Cache Web Server Paths
ColdFusion can cache the paths to files and how these paths map to URLs to improve performance. Check this option to cache paths, but never check this option if you host multiple Web sites on the same server (as this could cause paths to get mixed up resulting in the wrong pages being served).
Maximum Number of Cached Queries
As you learned in Chapter 27, you can use the cachedwithin or cachedafter attributes of the <cfquery> tag to reuse query results so they don't have to be retrieved from the database with each and every page request. Of course, it's not possible for the server to cache an unlimited number of query result sets in memory; there's only so much memory to go around.
By default, ColdFusion will allow up to 100 cached result sets to reside in its memory; when the 101st query needs to be cached, the query that was cached first will be removed from the cache. Increasing the number will allow more cached result sets to remain in memory at once; decreasing the number will reduce the amount of RAM that the cached queries will use up.
Like some of the options discussed earlier (particularly the number of simultaneous requests), this setting is a matter of balance, and there is no hard and fast rule about what the best value is.
In general, if you use cached queries extensively in your code, and you find that your server still has plenty of available RAM after your applications have been running for a while, you can increase the value. On the other hand, if you find that your server tends to run out of available RAM, you should try decreasing this value.
Chapter 47, "Monitoring System Performance," in Volume 3, explains how to use the System Monitor.
The Client Variables Page
In Chapter 19, you learned about the CLIENT variable scope, which allows you to create variables that become associated with a particular Web browser. You can use CLIENT variables to create pages that show personalized information or that otherwise maintain state between each user's visits and page requests.
Choosing a Client Variable Storage Mechanism
In general, the idea behind CLIENT variables is to store the actual variables on the server, so that the burden (and responsibility) for remembering the values isn't placed on each browser machine. There are two methods for storing values on the server: in a database, or in the registry. (For Windows servers, registry refers to the Windows Registry, which is a special information store that is built into the operating system; for other servers, registry refers to a special text file that Adobe ships with ColdFusion.) Because the values are stored on the server side, the total size of all the accumulated client variables can become quite large over time. Either the database or the registry will have to become large enough to store the total size of all client variables for all users.
You can also choose to have your client variables stored as a cookie on the browser machine. This takes care of the problem of your servers having to store every client variable for every user, but has some significant trade-offs. Conceptually, you are trusting the browser to store the values for you (dependent on its local settings). Adobe recommends that you only use the default registry option for development, and that you create a database storage mechanism for your staging or production machines (even if it's just a lowly Access database). You can set the database to be the default storage mechanism (as discussed in the next section) so that your code doesn't have to change as you move your applications out of development.
Choosing the Default Storage Mechanism
To choose the default storage mechanism used for client variables, make the appropriate selection under the heading Select Default Storage Mechanism for Client Sessions; then click Apply.
CLIENT variables persist over time, and are purged (deleted) at a predetermined interval. The default interval is 1 hour 7 minutes, and this can be changed if needed.
The Memory Variables Page
In Chapter 18, you learned about application variables, which allow you to maintain counters, flags, and other variables on an application-wide basis. In Chapter 19, you learned about session variables, which provide a way to track variables for your users on a per-session basis.
This page of the Administrator allows you to change how these variables are tracked, and for how long. Either type of variable can be disabled by unchecking the Enable Application Variables or Enable Session Variables checkbox.
Use J2EE Session Variables
ColdFusion can manage session variables, or it can rely on the underlying J2EE server to perform this task. To have the J2EE server manage the session, check this box.
Enable Application Variables
To enable the use of application variables, check this box (checked by default).
Enable Session Variables
If any applications on your server will need to use session variables, check this box (it is checked by default).
You can adjust the Maximum Timeout value for each type of variable, which gives you a way to make sure that no individual <cfapplication> tag specifies a sessiontimeout or applicationtimeout value that is unreasonably long. If the <cfapplication> tag specifies a timeout value that exceeds the maximum value you supply here, the maximum value is used instead.
You can also edit the Default Timeout value for each type of variable by typing in the desired number of days, minutes, hours, and seconds. This default value will be used whenever you don't specify a sessiontimeout or applicationtimeout attribute in your <cfapplication> tags. For instance, you can set a longer timeout session timeout if users are complaining that their session variables disappear while they're filling out long forms or making complex decisions. You can use a shorter timeout if you suspect that too much memory is being used to store your session variables.
The Mappings Page
The Mappings Page is used to define path mappings, aliases that are used in CFML code to refer to specific folders.
By default two mappings are created (cfide and gateway) and these should not be removed. To add your own mappings, enter the alias and path in the form displayed, and click Add.
The Mail Page
In Chapter 20, "Interacting with Email," in Volume 1, you learned to create ColdFusion pages that send dynamic, personalized email messages with the <cfmail> tag. ColdFusion can also send automatically generated reports to server administrators in case of problems, as you will learn in the section "The System Probes Page," later in this chapter. Use the Mail Server page to establish an SMTP email server connection for ColdFusion to use for these purposes.
Enter either the Internet domain name or the IP address for your company's outgoing mail server (also known as an SMTP server) in the Mail Server text box.
The Sign option enables ColdFusion to digitally sign its mail.
The Keystore option specifies the location of the keystore containing the certificate and private key. The Java keystore (JKS) and pkcs12 keystore are supported.
The first entry in the keystore is used as an alias unless this option is not blank.
Verify Mail Server Connection
When defining your mail server, check this box to have ColdFusion Administrator attempt to connect to the mail server to verify the connection.
Enter your email server's port number. This is almost always 25, so you can usually leave the port number alone.
Backup Mail Servers
If you have access to backup SMTP servers (which can be used if the primary SMTP server is unavailable), list these here.
This setting lets you specify the number of seconds ColdFusion should wait for a response from the email server. In general, the default value of 60 seconds is sensible. If your mail server is far away or available only via a slow network connection, you may need to increase this value.
Enable SSL Socket Connections to Mail Server
Select this checkbox to enable SSL encryption on the connections to the mail server.
Enable TLS Connection to Mail Server
Select this checkbox to enable transport level security (TLS) on the connection to the mail server.
This setting lets you specify the number of seconds ColdFusion waits before checking to see if new email messages are waiting to be sent out. You can decrease this value if it's critical that your messages be sent out very soon after they are created; you can increase the value to conserve server resources. Note this value is ignored whenever you use the spoolenable="No" attribute in your <cfmail> tags.
Mail Delivery Threads
You can specify the maximum number of threads that the ColdFusion mail spooler can use. The higher this number, the greater the number of messages that will be deliverable at any given time.
Spool Mail Messages for Delivery
Mail is spooled by ColdFusion and then delivered by the spooler. Messages can be spooled to disk or to memory.
As a general rule, messages should be spooled to disk. While spooling to memory can be faster, it does increase memory load and also prevents delivery of mail after a system failure.
Maximum Number of Messages Spooled to Memory
Disk spooling of messages will occur after the ColdFusion server reaches the threshold specified here.
View Undelivered Mail
This option opens a window that allows the deletion and respooling of undelivered mail.
Error Log Severity
Mail delivered by ColdFusion can be logged for future analysis. The logs are saved in the /ColdFusion9/Log folder and can be viewed using the log viewer pages within the ColdFusion Administrator (see the section "The Log Files Page" later in this chapter). You can specify the log level here.
Log All Messages Sent by ColdFusion
To aid in troubleshooting, ColdFusion can log all messages (including all contents) if needed (this option is not enabled by default).
Mail Charset Setting
To change the default character set used in generated email messages, specify the value here.
The Charting Page
In Chapter 16, you learned how to use the ColdFusion <cfchart> tag to create dynamic charts and graphs that create visual representations of your application's data. ColdFusion automatically caches charts for later use. Conceptually, the chart cache is the charting equivalent of the query caching feature you learned about in Chapter 27. Its purpose is to improve performance by automatically reusing the results of a <cfchart> tag if all of its data and attributes are the same, rather than having to re-render each chart for every page request.
The Charting page of the ColdFusion Administrator contains a number of options that you can use to tweak the way the chart cache behaves.
You can set this to Disk Cache (the default value) or Memory Cache. The Memory Cache setting will perform better under high load, but will require more of the server's memory to do so. The Disk Cache setting may not perform quite as quickly, but it won't have much of an impact on the server's RAM. We recommend leaving this value alone unless you are specifically experiencing performance problems with <cfchart> under heavy load.
Maximum Number of Cached Images
You can increase this number to allow ColdFusion to store more charts in its cache, thereby improving performance if your application is serving up lots of different charts. If you are using the Memory Cache option, keep in mind that this will cause even more of the server's memory to be used for chart caching.
Maximum Number of Charting Threads
The maximum number of <cfchart> tags that you want ColdFusion to be willing to process at the same moment in time. Under high load, a higher number here may improve responsiveness for individual chart requests, but it will put more overall strain on your server.
Disk Cache Location
If you are using the Disk Cache option, you may adjust this value, which is the location where ColdFusion stores charts for later reuse.
The Font Management Page
Fonts are used by the ColdFusion printing and reporting features. When generating printed output, ColdFusion must know what fonts are available, what output type they support, and whether to embed fonts in generated output.
The Font Management page lists available fonts and allows you to specify a folder containing additional fonts to be installed.
See Chapter 16 to learn about ColdFusion printing and reporting.
The Document Page
This page enables you to edit the OpenOffice configuration. The configuration lets you specify the location of OpenOffice and whether it can be configured remotely. For further information about using OpenOffice, see Chapter 67, "Integrating with Microsoft Office," in Volume 3.
The Java and JVM Page
ColdFusion runs on top of the Java platform. Your ColdFusion pages are translated into Java classes, and those classes are executed within the context of a Java Virtual Machine (JVM). The Java and JVM page of the Administrator allows you to adjust which JVM is used to execute your pages. You can also make other JVM-related adjustments, such as the amount of memory that the JVM is allowed to use while executing your pages.
Java Virtual Machine Path
In theory, ColdFusion should be able to use any up-to-date JVM. To use an alternate JVM, install it, change the Java Virtual Machine Path setting in the ColdFusion Administrator, and then restart the ColdFusion Application Server.
Minimum JVM Heap Size
This setting allows you to provide an initial amount of your server's memory that the JVM should claim when ColdFusion is started. By default, this setting is left blank, which means that the JVM will make its own decisions about how much memory it should claim at startup. If your server encounters a lot of traffic, the JVM will generally need to claim more memory. You may be able to save the JVM some time by telling it to claim a larger amount of memory at start-up. In general, this could make the whole start-up process (which includes the initial processing of your pages) more efficient.
If you provide a value for this setting, it's strongly recommended that you specify a size of at least 32 MB.
Maximum JVM Heap Size
In a default ColdFusion installation, the JVM is instructed to use no more than 512 MB of memory for the ColdFusion runtime and your ColdFusion pages. If your server has considerably more than 512 MB of RAM installed, you may want to allow the JVM to use more of it, which would generally improve performance. Simply specify the maximum amount of memory that you wish the JVM (and thus the ColdFusion server, and thus your ColdFusion pages) to be able to use, in megabytes.
ColdFusion Class Path
If your applications use any external Java objects that in turn refer to other Java classes (that is, any Java classes that aren't provided by the JVM itself), you can tell ColdFusion where to find the class files by adjusting the Class Path setting in the ColdFusion Administrator. By Java objects, I mean any Java classes that you are accessing via <cfobject> or CreateObject(), any servlets or JSP tag libraries that you are using via <cfimport>, CFX tags that have been written in Java, and so on.
In general, you will either be specifying the path to a directory or the path to a Java Archive (.jar) file. If you need to specify multiple directories or archives, separate them with commas.
If you want any additional arguments to be passed to the JVM when the ColdFusion server is started, you can specify them here. Separate multiple arguments with spaces. Presumably, you would provide such arguments if they were required by an external Java object that you wanted to use, or if the argument was suggested by the JVM vendor to improve performance or stability. The exact purpose and effect of the arguments will depend on the JVM and classes you are using.
The Settings Summary page provides a quick overview of all ColdFusion Administrator settings. Detailed information about all data sources, CFX tags, mappings, Verity full-text archives, and nearly all other settings discussed in this chapter are displayed. Most of the information from the Version Information page is included in the report as well. You can print this page to get a hard-copy record of all ColdFusion settings on the server.