Vv

18.4.0 released Sep 25, 2023

Purpose: Builds and tests Vely applications.

vv <options>

Command-line options

-q Build Vely application from source code in the current directory. vf must run first in this directory with "-i" option to create the application. The following options can be used when building:
- --db="[#]<database vendor>:<db config file> ..."
  Specify a list of databases used in your application. Each element of the list is <database vendor> (which is 'mariadb', 'postgres' or 'sqlite'), followed by a colon (:) and then <db config file>, where <db config file> is used to refer to a database in statement-APIs such as run-query.
  
  Each <database vendor>:<db config file> is separated by a space. You can list any number of databases for use in your application. A file with name <db config file> must exist and contain the connection parameters for database access, and is copied once to Vely's database configuration directory (see how-vely-works).
  
  If an optional "#" precedes <database vendor>, then database configuration file is overwritten even if already present. See database-config-file for more details on the content of this file, the defaults used, and changing them to fit your needs.
- --lflag=<linker flags>
  If you wish to add any additional linker flags (such as any non-Vely libraries), specify them quoted under this option.
- --cflag=<C flags>
  If you wish to add any additional C compiler (gcc) flags, specify them quoted under this option.
- --trace
  If specified, tracing information code will be generated (without it, tracing is not available and trace-run statement is ignored). Tracing only works when debugging mode is enabled, so --debug option must be used as well.
- --path=<application path>
  This option lets you specify the application path for your request-URLs. It is a leading path of a URL prior to request name and any parameters. If empty, the default is the application name preceded by a forward slash:
```
/<app name>
```
- --maxupload=<max upload size>
  Specify maximum upload size for a file (in bytes). The default is approximately 25MB.
- --max-errors=<max errors>
  During building of an application, emit a maxium of <max errors> diagnostic messages. The default is 5.
- --debug
  Generate debugging information when compiling your application. Debugging information is required to produce a backtrace file with the stack that contains source code line numbers, in order to pinpoint the exact location where report-error statement was used, or where the application crashed. It is also needed to use gdb for debugging purposes. Note that stack information is produced only when Vely is built in debugging mode (see "DI=1" option when making Vely from source).
- --c-lines
  Skip generating line information when compiling .vely files. By default line information is included, which allows errors to be reported with line numbers in .vely files. If you want only generated C code line numbers to be used, use this option. This output will omit certain color-coded and other details that are normally present without this option.
- --posix-regex
  Use ERE (Extended Regular Expression) POSIX regex library built into Linux instead of default PCRE2, see match-regex. While the two are largely compatibile, you can use either one depending on your needs.
- --plain-diag
  Do not use color-coded and more detailed Vely diagnostic output. While rare, you may need this option in cases when there may be a Vely or underlying compiler bug, if you need to parse this output in format prior to Vely 17.1, or for some other reason.
-i
Display both include and linking flags for an application that uses FastCGI-API to connect to Vely FastCGI server. The flags are for C compiler (gcc). If --include is used in addition, then only include flags are displayed. If --link is used in addition, then only linking flags are displayed. Use this to automate building of client applications with tools like Makefile.
-v
Display Vely version as well as the Operating System version.
-s
Trace the execution of vv utility and display all the steps in making your application.
-e <num of errors>
Show the last <num of errors> from the backtrace file, which receives error message and stack trace when program crashes or report-error is issued. Also display the path to backtrace file which contains the stack details.
-t <num of trace files>
Show the last <num of trace files> most recent trace files for the application. This is useful when tracing (see trace-run) to quickly find the trace files where Vely writes to. Also display the path to backtrace file which contains the stack details.
-o
Show documentation directory - web page documentation is located here, and examples are located under "examples" subdirectory.
-l
Show library directory - Vely's libraries and v1 code processor are located there.
-a
Display CHANGELOG (i.e. release notes) for the current release.
-r [ --req="/<request name>[<url payload>]" [ --app="application path" ] [ --server [ --remote="server:port" ] [ --socket="socket path" ] ] [ --exec ] [ --method="<request method>" ] [ --content="<input file>" --content-type="<content type>" ] [ --silent-header ]
Display or execute bash code to run a command-line program. If you are not in application's source directory (see how-vely-works), then you must specify "--app" option to supply the application path (typically "/<application name>", see request-URL). You can use "--req" option to specify the request name and an optional URL payload (see request-URL), for example it may be:
```
vv -r --req="/encrypt"
```
to execute request "encrypt", or
```
vv -r --req="/encrypt/data/somedata?method=aes256"
```
where "/encrypt" is the request name, and "/data/somedata?method=aes256" represents the URL payload. Or it could be for instance:
```
vv -r --req="/encrypt?data=somedata&method=aes256"
```
where "/encrypt" is the request name, and "?data=somedata&method=aes256" represents the URL payload.

Use --method to specify the HTTP request method, for instance:
```
vv -r --req="/encrypt/data/somedata?method=aes256" --method=POST
```
If not specified, the default method is "GET".

If "--server" is not used, then bash code will invoke a command-line program. If "--server" is used, then FastCGI-command-line-client will call a FastCGI application server; in this case if "--remote" is not specified, a local Unix socket is used to contact the server, otherwise "server:port" specified in "--remote" is the IP/name and port of the server to call, separated by a colon (":"). In case of a local Unix socket, the socket path is by default "/var/lib/vv/<app name>/sock/sock", where "/<app name>" is given by the last path segment in "--app" option, or if not specified it is derived from the name of a Vely application built in the current directory; otherwise the socket path is given by "--socket" option.

By default, the output from a command-line program is the same as from an application server, meaning it will have the HTTP headers. If you don't want those to appear, use "--silent-header" option.

If "--content" is used, then file <input file> is either piped to the standard input of a command-line program (if "--server" is not used), or sent as a content to the application server (if "--server" is used). You can also specify content type with "--content-type". For example:
```
vv -r -app="/my_app" --req="/some_request?par1=val1&par2=20&par3=4" --method=PATCH --content=something.json --content-type=application/json --exec
```
To execute the request (instead of displaying the bash code), use "--exec" together with "--req" - in this case no bash code is displayed:
```
vv -r --req="/encrypt" --exec
```
The output may look like (when --exec is not used):
```
export REQUEST_METHOD=POST
export SCRIPT_NAME="/enc"
export PATH_INFO="/encrypt/data/somedata"
export QUERY_STRING="method=aes256"
/var/lib/vv/bld/enc/enc
```
If you copy the above and paste into bash shell, it will execute the command line program which handles the request specified. Note that SCRIPT_NAME will be set to whatever application path you use (i.e. the default or if set with "--path" option when making the application; or with "--app" option here), see request-URL. If you use "--exec", then the above output will not show and that same code will automatically execute; this is useful to conveniently execute command-line programs or to call your application servers directly, for instance. It can also be used to call any FastCGI server, like PHP FPM. Examples of using "--exec":
```
#Execute current application, request "json"
vv -r --req="/json" --exec

#Execute application "app_name", request "json" by calling the application server running with a Unix socket
vv -r --req="/json" --app="/app_name" --server  --exec

#Execute application "app_name", request "json" by calling the application server running with a Unix socket (specified explicitly)
#Request has input parameter "act" with value "perf"
vv -r --req="/json?act=perf" --app="/app_name" --server --socket="/sock_path/sock"  --exec

#Execute application "app_name", request "json" by calling the application server running with a TCP socket on port 2301
#Request has input parameter "act" with value "perf"
vv -r --req="/json/act/perf" --app="/app_name" --server --remote="192.168.0.21:2301"  --exec
```
-u
Read stdin (standard input) and substitute any environment variables in the form of ${<var name>} with their values, and output to stdout (stdout). This is useful in processing configuration files that do not have parameter values hardcoded, but rather take them from the environment.
-m
Add Vely syntax and keyword highlighting rules for files with .vely extension to Vim editor for the currently logged on user. Note that you must have Vim installed; vi alone will not work.
-c,--clean
Clean all object and other intermediate files, so that consequent application build is a full recompilation. Use it prior to rebuilding the application.
-h
Display help.

Examples

Make application (-q), use three databases (--db) named mdb (MariaDB database), pdb (PostgreSQL) and sdb (SQLite), produce debugging information (--debug), produce tracing information (--trace), specify that your application is using crypto and curl libraries:
```
vv -q --db="mariadb:mdb postgres:pdb sqlite:sdb" --debug --trace
```
make application, use MariaDB database db (--db), specify linker and C compilation flags, specify maximum upload size of about 18M:
```
vv -q --db="mariadb:db" --lflag "-Wl,-z,defs" --cflag "-DXYZ123" --maxupload 18000000
```
Make application that doesn't use any databases:
```
vv -q
```