I am working on a side project that is meant to be deployable on CF servers residing on both windows and unix systems. Is there a way that I can manage absolute pathing in directory structures in a way that would be universal? In other words, I don't want have to have a bunch of conditional statements littering the code to manage if you are windows versus unix servers.
I've been working exclusively in unix-based OS for the past 8 years, so it's been a long time since I had to worry about Windows.
I am working in CF 9.01 FWIW.
Thanks!
Check out the ColdFusion System Functions. You can use some of those functions to dynamically retrieve pathing information from the server, regardless of the platform.
Just create a test.cfm file and start outputting those values to get familiar with them. I think these will be of particular interest.
Sample test.cfm:
<html>
<head></head>
<body>
<cfoutput>
<p>GetBaseTemplatePath() = #GetBaseTemplatePath()#</p>
<p>GetDirectoryFromPath(GetBaseTemplatePath()) = #GetDirectoryFromPath(GetBaseTemplatePath())#</p>
<p>GetCurrentTemplatePath() = #GetCurrentTemplatePath()#</p>
<p>ExpandPath("*.*") = #ExpandPath("*.*")#</p>
</cfoutput>
</body>
</html>
Related
Good day -
My work group upgraded from CF10 to CF2016. We have finished 2 of the 3 servers that run the application behind a load balancer.
Since the two servers have been upgraded, we get an occasional (<<1%) error on <cfinclude> statements:
The process cannot access the file because it is being used by another process
The included files are different each time, but they have the same characteristic: the names are dynamically generated in the cfinclude tag. For example:
<cfinclude template="#fileManager.getFile('appl1')#">
where #fileManager.getFile('appl1')# simply returns a string path to a CFM file. The file definitely exists, and it is not e.g. being modified by a programmer or any other (known) process. The files themselves are generally just simple index.cfm files in directories that haven't been touched in a year.
This only happens on dynamically named templates in <cfinclude>, never static template names.
Here are the cache settings on the server. Please note that the settings are the same on the server that doesn't experience this problem (the CF10 server)
Any ideas what can cause this random, fleeting error? I can not establish any pattern other than CF2016.
I've spent over a day now trying to resolve an issue where two applications use the same relative paths but are under a different "root", and this causes the wrong code base to be accessed for one of the applications.
These are my roots to the two Applications:
\www\Clients\
\www\Other\Clients\
Structure
..www
....Clients
......Application.cfc
....Other
......Clients
........Application.cfc
In both Applications there is code that references the relative path (e.g., /clients/content/login.cfm)
I noticed that the ColdFusion Administrator has a Mappings section where the first mapping has a logical path / mapped to the directory path D:/www/.
This works well for the first application since the clients folder is found directly under the www folder, however the second application doesn't work correctly as it too adheres to the same mapping. Therefore instead of searching for /clients/content/login.cfm under the Others folder, it searches yet again under the www folder.
Note: Both applications have a different Application.Name so they are indeed segregated.
The biggest red flag is that we don't experience this issue on our older ColdFusion 9 server, however we are experiencing this on the newer ColdFusion 2016 server.
Sifting through ColdFusion Administrator, I can't seem to find any other settings which could affect the underlying root per Application which could take precedence over the Mappings.
Is there a setting I missed? Was there a drastic change regarding relative paths or mappings between ColdFusion 9 and ColdFusion 2016?
Sifting through ColdFusion Administrator, I can't seem to find any
other settings which could affect the underlying root per Application
which could take precedence over the Mappings.
Solution: Use application specific mappings.
<cfset this.mappings["/Clients"] = GetDirectoryFromPath(GetCurrentTemplatePath())>
Source
So I've began working with .cfm files recently at work, currently my assignment is to modify and update webpages to be more suited to mobile devices and tablets. Now, being relatively new to ColdFusion, I've been having a bit of trouble with how multiple .cfm files are used within a server to create a single webpage. Because of this, I've had issues with finding where specific sections of HTML are located, be it something as where a simple tag is, or where a call to another .cfm, javascript, or .css file may be. Is there anyway to find the origin of certain code without having to skim through hundreds of different files?
If you are working on your code on a local webserver on your computer (i.e. not a production site) then you can enable ColdFusion's debugging output.
Documentation for the ColdFusion Administrator debugging options are here: ColdFusion Administrator Debugging
You will want to enable Enable Request Debugging Output and turn on Report Execution Times. When you browse to the page, ColdFusion will give you a list of all files that ColdFusion used to render that page (with how long each file took) appended to the bottom of the page.
Otherwise, any good IDE/Editor (CFBuilder, SublimeText, NotePad++ etc) will be able to search across files.
I would suggest downloading the code from your server to a local drive. From there you can search using an IDE (ColdFusion Builder, Dreamweaver, etc) or a good text editor that can search multiple files at once. I personally use ColdFusion Builder 3 and Notepad++.
Multiple cfm files are put together into a single page usually by using the cfinclude tag, so that would be a good starting point for your search. There are other methods to include different pages into a single page but cfinclude is probably the most common one. BUT, if the programmer used cfscript instead of cfml, look for the include function instead.
Adobe documentation on the cfinclude tag can be found at https://wikidocs.adobe.com/wiki/display/coldfusionen/cfinclude.
Advanced performance question here. Here's my scenario:
I have a database that contains thousands of XSLT documents. One for each page of a website so these translate XML into HTML. An ASP.NET web server (farm) loads the XSLT documents from the database and uses them to render HTML for each web request.
I've implemented the optimization of using XslCompiledTransform and caching it between database refreshes (every 30 minutes). I'm looking to notch performance up further by pre-compiling the XSLT to DLLs with xsltc.exe. This is supposed to eliminate all the Dynamic Method Invocations that XslCompiledTransform creates.
So, I have a separate server writing the XSLTs to files and running through them with xsltc.exe. Takes about 20 minutes but that's OK. I then drop the DLLs onto each webserver. Now I can just have the webserver dynamically load the DLLs on an as-needed basis. Here's the code I'm using to load the assembly into XslCompiledTransform:
byte[] bytes = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "XsltDlls\\" + fileName + ".dll"));
Assembly assembly = Assembly.Load(bytes);
Type type = assembly.GetType(fileName);
XslCompiledTransform compiledTransform = new XslCompiledTransform();
compiledTransform.Load(type);
Shoud I ReBase.exe the DLLs in the directory and/or NGEN.exe them? ReBase takes about 5 minutes and NGEN.exe with /queue will take about 10 minutes during which CPU is hit hard - likely causing an impact to the traffic serving function of the webserver. Given how I'm loading the assembly by reading bytes from the assembly will the native NGEN image even be referenced or will the JIT fire up anyway?
Any/all insight into this will be MUCHLY appreciated!
malcolm
Wow!
Assembly.Load(string) does permit native images to be loaded. However, I suspect that the overload that takes a byte array may not use it. I can't find a reference for that, but perhaps some experimentation using the Assembly Binding Log Viewer on a test project might prove either way.
You also have to make sure that your assemblies are strongly named for the native image to be used.
As for rebasing, this blog suggests that it's not required on Vista generation OSes or later.
I'm starting some work on an existing ColdFusion application with no version control and what look like unused cfm files (test.cfm, test2.cfm etc.). I'd like to get a picture of what files are actually part of the application so I can get it into git or subversion in a manageable state.
How would you go about this? A regex and some methods to find and map cfinclude and cfcomponent tags? Is there some existing tool that does this?
Ben Nadel has a method to examine the live stack trace from a running template. It seems to me that you could easily plop this into your application and log the results to a database. Once you've done that, you've got a good idea of what's in use and what's not.
I think the easiest way, however, is to enable debugging (standard caveat here about development server, etc). The standard ColdFusion debugger will give you a complete list of every file used during the execution of a single page. ColdFire will do the same thing in a handy Firebug extension (click ColdFusion then click Exec Times).
It should be pointed out that the built-in debugger even shows you the files included from CFC calls, and the files included from within those calls as well. It is all inclusive.
Ben Nadel on Stack Traces
Ray Camden's ColdFire
Sample of CF Debugging from a live page:
Put it into git first! Then, if you screw up, you can easily roll back.
(If you're concerned about having a 'clean' repository, when you're finished and fully tested, you have the option to just remove the single .git folder and create a new one.)
Then, as Tomalak suggests, use cflog on every file. Infact I'd say maybe even log twice, at the top and bottom of each script, could potentially help you to map out how the application runs.
A regex is not advisable. Since ColdFusion is quite flexible in the way files can be included or referenced, there will be no way to determine the definitive list of dependencies from the source code alone.
You could insert a <cflog> into each file and build a log from the running application. Examine the log after the application was active for a while and all functionality had been accessed at least once.
Don't bother instrumenting each file, just cflog the page name in OnRequest inside application.cfc - the target page is an argument.
Of course then the issue becomes code coverage and the ability to fully excercise the app.
<cffunction name="onRequest" returnType="void">
<cfargument name="targetPage" type="String" required=true/>
<cflog file="Usedpage" text="#Arguments.targetPage#">
<cfinclude template="#Arguments.targetPage#">
...
</cffunction>
cfinclude won't tell you if a url is supposed to load the file directly. I've seen system where some files are not included via an index.cfm even when the framework expects it. I have it in my own work where index.cfm loads most code but reset.cfm bypasses the framework to reset configs and session data.
Download a trial of Dreamweaver and define a ColdFusion site. DW can create a site map and tell you which files are not included, linked, cfmoduled and so forth. I don't know if it can figure out unused CFCs, but CFMs should be easy. Note that I haven't used DW for years, but it had this functionality around CF 4/5.