ffcpl URI Address Scheme

NetKernel uses the ffcpl URI address scheme throughout to provide a unified approach to addressing resources. ffcpl addresses are always logical and can be easily mapped to other ffcpl addresses or other schemes. Because of this flexibility, the ffcpl scheme can be used as a mechanism for building layers of addresses and address spaces supporting an architectural design.

For example, a resource for an application might be ffcpl:/customer-list, a concept that would be used in the upper layers of an application. During early development, a stub module might use the following mapping

to return a static representation for each request. Later, when the database design is finished and implemented, the following mapping could be used:

to map the resource to a database query.

ffcpl present a unified approach to addressing because address resolution will automatically span imported models or use the super-stack resolution algorithm. All of these capabilities provides a powerful architectural design and application complexity control tool

Next we will explore specific mappings from ffcpl.

ffcpl to Module File System

As discussed in the section on the module file system, the ffcpl scheme will map to physical files stored within a module when a mapping entry using a this element is defined. For example, the following mapping entry will link the physical directory src and all of its contents to the address space starting with ffcpl:/src/...

ffcpl to ffcpl

Any ffcpl address can be rewritten to another ffcpl address using regular expression patterns. For example, to map ffcpl:/customer-list to ffcpl:/mymodule-customer-list use the following rewrite rule:

This rewrite rule changes one logical address into another. At some place in the application the address ffcpl:/mymodule-customer-list must be mapped to a physical resource or code that will return the resource.

Note: it is a best practices technique to match against any possible parameters attached to a resource address, such as ffcpl:/customer-list+id@44. This approach will increase system resilience to future change.

ffcpl to file

The module file system, accessed with the ffcpl scheme, provides independence from specific locations on the host operating system file system. Sometime it is important to use a reference to a specific physical location. In this case map an ffcpl address to a file: address such as with:

ffcpl to active

The active scheme is used to specify library functions and transformations. A common mapping is from a resource identifier to the code that will return a representation. One example was given above when the customer list was mapped to active:sqlQuery. Frequently, a DPML script is used to create a representation, in this case, the following mapping uses the script customer-list.idoc.

ffcpl to Relational Database

A common mapping is from a ffcpl identified resource to a database. An extensive library of database mapping accessors makes this easy.

The general pattern is to map a resource either directly to active:sqlQuery or to a script that will call active:sqlQuery along with other setup code.

ffcpl to http

A local resource identifier can be mapped to a remote resource using, for example, the HTTP protocol. The following mapping will return a resource served by a remote web server.

In this example, a request for the customer-list will retrieve the representation from a web server.

Scratch

The ffcpl provides a mechanism in which a SINK operation to a physical file will not delete the original file - instead it stores the update in a scratch directory. Subsequence SOURCE operations will return the overwritten information from scratch instead of from the module. A DELETE operation on a physical resource will remove the entry in the scratch directory, but will not remove the original file.

This capability is particularly useful for storing temporary state in a module and for overriding configuration information.

Summary

The ffcpl URI address scheme is very flexible and powerful. All of the capabilities of the active: scheme are available along with the ability to map to module file systems.

While is may be tempting to invent new URI schemes, it is best practice tip to instead us the ffcpl scheme along with arguments to encode a full resource model.