Watch Folder JSON configuration file reference

Watch Folders are configured by using a JSON configuration file. This article describes all the available configuration options. For simple push and pull configuration examples that contain only the required options.

For more information, see: Creating a push Watch Folder with aswatchfolderadmin and Creating a pull Watch Folder with aswatchfolderadmin.

To get a complete JSON schema that provides the default values, value options, and a description of each parameter, run the following command:

> curl -i -u nodeuser:nodepassword https://{domain}:9092/schemas/watchfolders/configuration

Sample JSON configuration file (pull Watch Folder with Node authentication)

{
  "source": {
    "path": "/projectA",
    "location": {
      "type": "REMOTE",
      "host": "10.0.111.124",
      "port": 9092,
      "authentication": {
        "type": "NODE_BASIC",
        "user": "nodeuser1",
        "pass": "watchfoldersaregreat",
      }
    }
  },
  "target": {
    "path": "\projectA"
  },
   "id":"b394d0ee-1cda-4f0d-b785-efdc6496c585",
   "cool_off":"30s",
   "snapshot_creation_period":"10s",
   "meta":{  
      "version":0,
      "name":"aspera_watchfolder"
   },
   "drop":{  
      "detection_strategy":"COOL_OFF_ONLY",
      "cool_off":"5s"
   },
   "post_processing":{  
      "source":{  
         "type":"TRANSFER_NONE",
         "archive_dir":"\watchfolder_sessions\{$UUID}_{$DATETIME}"
      }
   },
   "filters":[
      {
         "type":"GLOB",
         "pattern":"*.txt",
         "rule":"INCLUDE"
      },
      {
         "type":"GLOB",
         "pattern":"/**",
         "rule":"EXCLUDE"
      }
   ],
   "packages":{
      "timeout":"10s",
      "parsers":[
         {
            "final_transfer":"LIST",
            "filters":[
               {
                  "type":"REGEX",
                  "rule":"INCLUDE",
                  "pattern":".*\\.txt"
               },
               {
                  "type":"REGEX",
                  "rule":"EXCLUDE",
                  "pattern":".*"
               }
            ]
         }
      ]
   },
   "transport":{  
      "host":"",
      "user":"aspx2",
      "pass":"",
      "proxy":"dnat://aspx1:passwordsarecool@localhost:9001",
      "keypath":"",
      "fingerprint":"",
      "cookie":"",
      "tags":{  
      },
      "error_handling":{  
         "file":{  
            "max_retries":3,
            "retry_timeout":"3s"
         },
         "drop":{  
            "retry_period":"1m"
         }
      },
      "regular":{  
         "max_parallel":10,
         "connect_timeout":"10s",
         "policy":"FAIR",
         "min_rate":"0B",
         "target_rate":"10M",
         "tcp_port":22,
         "udp_port":33001,
         "read_blk_size":"",
         "write_blk_size":"",
         "datagram_size":"",
         "rexmsg_size":"",
         "cipher":"AES128",
         "overwrite":"DIFF",
         "resume":"NONE",
         "preserve_uid":false,
         "preserve_gid":false,
         "preserve_time":false,
         "preserve_creation_time":false,
         "preserve_modification_time":false,
         "preserve_access_time":false,
         "queue_threshold":"5s",
         "sample_period":"2s"
      },
      "growing_file": {  
         "max_parallel":8,
         "policy":"FAIR",
         "min_rate":"",
         "target_rate":"10M",
         "tcp_port":22,
         "udp_port":33001,
         "datagram_size":"",
         "cipher":"AES128",
         "completion_timeout":"5s",
         "memory":"2M",
         "chunk_size":"128K",
         "force_send_after":"2s",
         "filters":[  
            {
              "type":"REGEX",
              "rule":"INCLUDE",
              "pattern":".*\\.growing"
            },
            {
              "type":"REGEX",
              "rule":"EXCLUDE",
              "pattern":".*"
            }
         ]
      },
      "watchd" : {
         "scan_period":"30m",
         "identifier" : "root"
   }
}

Top-level configuration

Watch Folders supports transfers between a local server and a remote server. For the local server, Watch Folders requires only the local path, whether it is the source or target. For the remote server, Watch Folders requires the host address, port for authentication, and authentication credentials. In the following example, the source is remote and the target is local.

Note: The header "X-aspera-WF-version:2017_10_23" is required when submitting POST, PUT, and GET requests to /v3/watchfolders on servers. These enables Watch Folders to parse the JSON "source" and "target" objects in the format that was introduced.

{
   "source": {
      "path": "path",
      "location": {
         "type": "REMOTE",
         "host": "host",
         "port": port,
         "authentication": {
            "type": "SSH|NODE_BASIC",
            "user": "username",
            "pass": "password",
            "keypath": "key_file",
            "fingerprint: "ssh_fingerprint"
         }
      }
   },
   "order": "START",
   "target": {
      "path": "path"
   },
   "id":"watchfolder_id",
   "cool_off":"30s",
   "snapshot_creation_period":"10s",
   ...
}

Field	Description	Default
`path`	The source or target directory. Required. Local path: The path is relative to the docroot of the transfer user associated with the node username. If the transfer user is configured with a restriction, the path is the absolute or UNC path. Remote path: For access key authentication, the path is relative to the storage specified in the access key. For SSH and Node API user authentication, the path is relative to the user's doc root that is configured, or the absolute or UNC path if the user is configured with a restriction. For IBM Aspera Shares authentication, the path is the share name and optionally, a path within the share. When the Aspera Watch service detects a new file in the source directory, the Aspera Watch Folders service starts an ascp session to transfer the file to target directory. The target directory must be within the docroot or restriction set for the user by running the Aspera Watch service.	N/A
`location type`	Set `"type"` to `"REMOTE"` for the remote server. For push Watch Folders the remote server is the `"target"`, for pull Watch Folders the remote server is the `"source"`. One endpoint must be remote and one must be local. Local to local and remote to remote Watch Folders are not supported.	`"REMOTE"` is assumed if `"host"` is specified. `"LOCAL"` is assumed if `"REMOTE"` or `"host"` is not specified.
`host`	The host IP address, DNS, hostname, or URL of the remote file system. Required. The host can be specified with an IPv4 or IPv6 address. The preferred format for IPv6 addresses is `x:x:x:x:x:x:x:x`, where each of the eight x is a hexadecimal number of up to 4 hex digits. Zone IDs (for example, %eth0) can be appended to the IPv6 address.	N/A
`port`	The port to use for authentication to the remote file system. By default, if the authentication type is `SSH`, then the SSH port for the ascp process (the value for `tcp_port` in the `"transport"` section) is used. If the authentication type is `NODE_BASIC`, 9092 is used. For Shares, IBM Aspera Transfer Cluster Manager, or IBM Aspera on Cloud endpoints, enter `443`.	If authentication type is `SSH`, then default is the value for `tcp_port` in the `"transport"` section (default: 22). If authentication type is `NODE_BASIC`, then default is 9092.
`authentication type`	How Watch Folders authenticates to the remote server. Valid values are `SSH` or `NODE_BASIC`. For `SSH`, authenticate with a transfer user's username and password, or specify the username and the path to their SSH private key file. For `NODE_BASIC`, authenticate with a Node API username and password, Shares credentials, or an access key ID and secret. Sample JSON syntax for each authentication type is provided following this table.	`NODE_BASIC`
`user`	The username for authentication. Required. Depending on the type of authentication, it is the transfer user's username, Node API username, Shares username, or access key ID.	N/A
`pass`	The password for authentication. Depending on the type of authentication, it is the transfer user's password, the Node API user's password, the Shares user's password, or the access key secret. Required for SSH authentication if `"keypath"` is not specified.	N/A
`keypath`	For SSH authentication with an SSH key, the path to the transfer user's SSH private key file. Required for SSH authentication if `"pass"` is not specified.	N/A
`fingerprint`	The SSH fingerprint of the remote server. Use a SSH fingerprint for security. If the fingerprint does not match that of the server, the transfer fails with the error "`Remote host is not who we expected`". For more information, see Installing and configuring the SSH Server (`Configuring Transfer Server Authentication`).	N/A
`id`	Value used to identify a Watch Folder. If this field is not configured at creation, a UUID is automatically generated for and assigned to the Watch Folder.	N/A
`order`	To start, stop or pause a particular Watch Folder is required to add `"order"` with a particular value to the configuration. Available values: `START`: Run the Watch Folder as normal. `PAUSE`: No transfers but `watchd` updates Redis with changes to the watched source. `STOP`: No transfers and no updates to Redis.	N/A
`cool_off`	How long the Watch Folder service waits for the files in the watched folder to stop changing (stabilize) before it takes a directory snapshot and creates a drop. Default: 5 s.	5 s
`snapshot_creation_period`	The interval during which Watch Folders groups new files in the source directory into a drop. All files in a drop are transferred in the same transfer session, post-processed together, and reported as a unit. Watch Folders uses the Aspera Watch service to detect file system modifications, and continuously creates snapshots to compute the snapshot differential. A small value results in high-temporal resolution for detecting file system modifications, whereas a large value improves the Aspera Watch service performance. Default: 3s.	3 s

Authentication JSON syntax

SSH with password:

"authentication": {
    "type": "SSH",
    "user": "username",
    "pass": "password",
    "fingerprint": "server_fingerprint"
}

SSH with SSH key:

"authentication": {
    "type": "SSH",
    "user": "username",
    "keypath": "key_path",
    "fingerprint": "server_fingerprint"
}

NODE_BASIC with Node API username and password:

"authentication": {
    "type": "NODE_BASIC",
    "user": "node_username",
    "pass": "node_password",
}

NODE_BASIC with Shares credentials:

"authentication": {
    "type": "NODE_BASIC",
    "user": "shares_username",
    "pass": "shares_password",
}

NODE_BASIC with access key ID and secret:

"authentication": {
    "type": "NODE_BASIC",
    "user": "access_key_id",
    "pass": "access_key_secret",
}

Meta fields

{
   ...
   "meta":{  
      "version":0,
      "name":"aspera_watchfolder"
   },
   ...
}

Field	Description	Default
`version`	Specifies the current version of the configuration. When the configuration is updated, this value must match the version that is stored by the server. Otherwise, the update is rejected.	0
`name`	The value that is specified in this field is added to the cookie reported by ascp. Optional.	N/A

Drop fields

Watch Folders groups new or updated files that it detects in its source folder into "drops". A drop is defined by the duration set by the snapshot_creation_period. All files in a drop are transferred in the same transfer session, post-processed together, and reported as a unit.

{
   ...
   "drop":{  
      "detection_strategy":"COOL_OFF_ONLY",
      "cool_off":"5s"
   },
   ...
}

Field	Description	Default
`detection_strategy`	The strategy that Watch Folders uses to create drops when new files are added to the source folder: `COOL_OFF_ONLY`: The drop includes new files that are added to the source folder within the duration of the `cool_off` field. `TOP_LEVEL_FILES`: Create a drop for each file placed in the top level of the source folder. `TOP_LEVEL_DIRS`: Create a drop for each directory added to the top level of the source folder. This drop also includes the subdirectories and files in the top-level directory.	`COOL_OFF_ONLY`
`cool_off`	The time after the first new file is added to the source file during which any other new files are included in the same drop. This setting is only relevant for the `COOL_OFF_ONLY` detection strategy. Choose a multiple of the specified `snapshot_creation_period` for predictable results.	5 s

Post processing fields

Optionally, specify post-processing to do after a drop or file is successfully transferred.

{
   ...
   "post_processing":{  
      "source":{  
         "type":"TRANSFER_NONE",
         "archive_dir":"\watchfolder_sessions\{$UUID}_{$DATETIME}"
      }
   },
   ...
}

Field	Description	Default
`type`	The type of post-transfer processing. Files can be archived, deleted, or retained after transfer of a drop. When files are archived or deleted, source subdirectories are also deleted from the source, unless the subdirectories were empty to start. File structure is preserved in the archive. `TRANSFER_NONE`: Files stay in the source directory. `TRANSFER_ARCHIVE`: Files in the source directory are moved to a final archive after successful transfer. This option is not supported for sources in object storage. `TRANSFER_DELETE`: Files in the source directory are deleted after successful transfer once the session completes. `FILE_TRANSFER_DELETE`: Files in the source directory are deleted after each successful transfer, rather than waiting for the session to complete.	`TRANSFER_NONE`
`archive_dir`	The destination of archived files, if the archive type is `TRANSFER_ARCHIVE`. The path can be determined by using the following variables: `{$TIMESTAMP}` (Drop creation time in seconds since epoch) `{$DAY_OF_MONTH}` (Time format for drop's creation time) `{$MONTH}` `{$YEAR}` `{$HOUR}` `{$MINUTE}` `{$SECOND}` `{$DATETIME}` (alias for `{$YEAR}{$MONTH}{$DAY_OF_MONTH}-{$HOUR}{$MINUTE}{$SECOND}`) `{$UUID}` `{$NAME}` `{$STATE}` `{$FILE::STATE}` (such as `SUCCEEDED`, `FAILED`)	N/A

Filter fields

Each filter object must include values for type, pattern, and rule. Filters are applied in order. Watch Folders supports glob and Regex filters. The glob filter system is the same as Ascp; see Using filters to include and exclude files.

{
   ...
   "filters":[
      {
         "type":"GLOB",
         "pattern":"*.txt",
         "rule":"INCLUDE"
      },
      {
         "type":"GLOB",
         "pattern":"/**",
         "rule":"EXCLUDE"  
      }
   ],
   ...
}

Field	Description	Default
`type`	The type of filter. Supported filters are `GLOB` and `REGEX`.	N/A
`pattern`	The filter pattern.	N/A
`rule`	The rule for the filter. Supported rules are `INCLUDE` and `EXCLUDE`. Note: An include rule must be followed by at least one exclude rule, otherwise all files are transferred because none are excluded. To exclude all files that do not match the include rule, use `/*` for glob or `.` for Regex.	N/A

Packages fields

Packages values are used to define an order for the transfer queue. For example, if file B depends on file A, file A must be transferred before File B. Dependencies are defined by package files, where the package file contains the set of files on which it depends. The package file (by default) is transferred after successfully transferring all the files defined in the package file.

{
   ...
   "packages":{
      "timeout":"10s",
      "parsers":[
         {
            "final_transfer":"LIST",
            "filters":[
               {
                  "type":"REGEX",
                  "rule":"INCLUDE",
                  "pattern":".*\\.txt"
               },
               {
                  "type":"REGEX",
                  "rule":"EXCLUDE",
                  "pattern":".*"
               }
            ],
            ...
         }
      ]
   },
   ...
}

Field	Description	Default
`timeout`	How long to wait for file dependencies to be satisfied (files that must be transferred before the last file are transferred) before you consider the dependency as unsatisfied.	10 s
`final_transfer`	Define the file to transfer last. `LIST`: The package file is transferred last after all files in the package file successfully transfer. `LAST_FILE_IN_LIST`: The last file in the package file is transferred last.	`LIST`
`filters`	Select files to include in the package as the ones that match the specified filters. Use the same syntax as in the `"filters"` object.	N/A

The `transport` object

Use to configure authentication to the remote host.

}
   ...
   "transport":{  
      "host":"198.51.100.22",
      "user":"aspx2",
      "pass":"XF324cd28",
      "token":"fiewle535etn23TEIW234n5sEWTnseonts",
      "proxy":"dnat://aspx1:XF324cd28@localhost:9001",
      "keypath":"~/.ssh/id_rsa",
      "fingerprint":"stringalsdjkfad",
      "tags":{
           "aspera": {
               "cloud-metadata": [
                    {"location":"tarawera"}
               ] 
           }   
      },
   ...
   }
}

Option	Description	Default
`host`	The host IP address, DNS, hostname, or URL.	N/A
`user`	The username for authentication. Required. Depending on the type of authentication, it is the transfer user's username, Node API username, Shares username, or access key ID.	N/A
`pass`	The password for authentication. Depending on the type of authentication, it is the SSH user's password, the Node API user's password, the Shares user's password, or the access key secret. This value is not required for SSH authentication that specifies a value for `"keypath"`.	N/A
`token`	If required, the token string. Not valid for use with growing files.	N/A
`proxy`	When using the address of an IBM Aspera Proxy server. The proxy syntax is: `dnat(s)://user:password@server:port`	N/A
`keypath`	If authenticating by SSH user and key, the path to the SSH user's private key file. Note: If a relative path is provided, the file at the relative path is checked for existence. If the relative path is not found, $HOME/.ssh/ is prepended to the relative path.	N/A
`fingerprint`	The SSH fingerprint of the remote server. Use a SSH fingerprint for security. If the fingerprint does not match that of the server, the transfer fails with the error "`Remote host is not who we expected`". For more information, see Installing and configuring the SSH Server (`Configuring Transfer Server Authentication`).	N/A
`tags`	Specify custom metadata in JSON format. The tags object is passed directly to the ascp session. For more information about writing custom metadata for uploads to object storage (as in the example), see Writing custom metadata for objects in object storage.	N/A

Error handling fields

Watch folder error handling distinguishes between two different error categories:

File-Specific Errors: These errors increase the file retry count every time that a failure occurs. When the max_retries count is reached, the file is marked as failed and the session attempts to transfer the next file in the drop queue. File-specific error includes all errors except the following:

License error.
Authentication error.
Any other error in establishing an ascp session.

Other Errors: These errors do not increase the file retry count. If an error reoccurs again and again, the same file is retried until the drop’s retry_period is exceeded. Then, the drop is marked as failed.

}
   ...
   "transport":{  
      ...
      "error_handling":{  
         "file":{  
            "max_retries":3,
            "retry_timeout":"3s"
         },
         "drop":{  
            "retry_period":"1m"
         }
      },
   ...
   }
}

Option	Description	Default
`max_retries`	How many times to try transferring a file before the file is marked as failed.	3
`retry_timeout`	How frequently to retry file transfers.	3 s
`retry_period`	If no bytes are transferred during the specified period and no file is completed, the drop and all remaining incomplete files in the drop are marked as failed.	1 m

The regular object

Use to configure Ascp transfer session options.

{
   ...
   "transport":{
      ...
      "regular":{  
         "max_parallel":10,
         "connect_timeout":"10s",
         "policy":"FAIR",
         "min_rate":"0B",
         "target_rate":"10M",
         "tcp_port":22,
         "udp_port":33001,
         "read_blk_size":"",
         "write_blk_size":"",
         "datagram_size":"",
         "rexmsg_size":"",
         "cipher":"AES128",
         "overwrite":"DIFF",
         "resume":"NONE",
         "preserve_uid":false,
         "preserve_gid":false,
         "preserve_time":false,
         "preserve_creation_time":false,
         "preserve_modification_time":false,
         "preserve_access_time":false,
         "queue_threshold":"5s",
         "sample_period":"2s",
         "content_protect_password":"ear_password"
         "raw_options":["-L","/tmp/log"],
         "symbolic_links":"follow"
      },
      ...  
   }
}

Field Description Default

max_parallel The maximum number of concurrent ascp sessions that Watch Folders can start. 10

connect_timeout How long Watch Folders waits before reporting that ascp as failed. 10s

policy

Specify how ascp manages the bandwidth. The policy can be set to the following values:

FIXED
FAIR
HIGH
LOW

FAIR

min_rate Attempt to transfer no slower than the specified minimum transfer rate. 0 B

target_rate The target transfer rate. Transfer at rates up to the specified target rate. This option accepts suffixes T for terabits/s, G for gigabits/s, M for megabits/s, K for kilobits/s, or B for bits/s. Decimals are allowed. If this option is not set by the client, the setting in the server's aspera.conf is used. If a rate cap is set in the local or server aspera.conf, the rate does not exceed the cap. 10 M

tcp_port The port to use for SSH connections. 22

udp_port The port to use for UDP connections. 33001

read_blk_size The read block size. Default determined by settings in aspera.conf

write_blk_size The write block size. Default determined by settings in aspera.conf

datagram_size The datagram size (MTU) for FASP®. Uses the detected path MTU.

rexmsg_size The maximum size of a retransmission request. Maximum: 1440. Determined by ascp

cipher

The encryption cipher that is used to encrypt data in transit. Aspera supports three sizes of AES cipher keys (128, 192, and 256 bits) and supports two encryption modes, Cipher Feedback mode (CFB) and Galois Counter Mode (GCM). The GCM mode encrypts data faster and increases transfer speeds compared to the CFB mode, but the server must support and permit it.

Cipher rules

The encryption cipher that you are allowed to use depends on the server configuration and the version of the client and server:

When you request a cipher key that is shorter than the cipher key that is configured on the server, the transfer is automatically upgraded to the server configuration. For example, when the server setting is AES-192 and you request AES-128, the server enforces AES-192.
When the server requires GCM, you must use GCM or the transfer fails.
When you request GCM and the server is older than 3.8.1 or explicitly requires CFB, the transfer fails.
When the server setting is any, you can use any encryption cipher. The only exception is when the server is 3.8.1 or older and does not support GCM mode; in this case, you cannot request GCM mode encryption.
When the server setting is none, you must use none. Transfer requests that specify an encryption cipher are refused by the server.

Cipher Values

Value	Description	Support
`AES128` `AES192` `AES256`	Use the GCM or CFB encryption mode, depending on the server configuration and version (see cipher negotiation matrix).	All client and server versions.
`AES128CFB` `AES192CFB` `AES256CFB`	Use the CFB encryption mode.	Client and all server versions.
`AES128GCM` `AES192GCM` `AES256GCM`	Use the GCM encryption mode.	Client and all server versions.
`NONE`	Do not encrypt data in transit. For security, avoid the use of this setting.	All client and server versions.

Client/Server Cipher negotiation

The following table shows which encryption mode is used depending on the server and client versions and settings:

	Server AES-XXX-GCM	Server AES-XXX-CFB	Server AES-XXX	Server AES-XXX
Client AES-XXX-GCM	GCM	Server refuses transfer	GCM	Server refuses transfer
Client AES-XXX-CFB	Server refuses transfer	CFB	CFB	CFB
Client AES-XXX	GCM	CFB	CFB	CFB
Client AES-XXX	Server refuses transfer	CFB	CFB	CFB

AES128

overwrite

Specify whether a file is overwritten if it exists at the destination. Valid options are:

NEVER
ALWAYS
DIFF
OLDER
DIFF+OLDER

DIFF

resume

Specify if and how partial transfers are resumed.

NONE: Always transfer the entire file.
FILE_ATTRIBUTES: Resume if file attributes match.
SPARSE_CHECKSUM: Resume if file attributes and sparse checksum match.
FULL_CHECKSUM: Resume if file attributes and full checksum match.

NONE

preserve_uid Preserve the file owner user ID. false

preserve_gid Preserve the file owner group ID. false

preserve_time This option is equivalent to configuring preserve_creation_time, preserve_modification_time, and preserve_access_time. false

preserve_creation_time Set creation time of the destination be set to that of the source. If the destination is a non-Windows™ host, this option is ignored. false

preserve_modification_time Set the modification time of the destination file to that of the source. false

preserve_access_time Set the access time of the destination to that of the source. The destination file has the access time of the source file before the transfer. false

queue_threshold Watch Folders controls the amount of data that is pushed to ascp for transferring. When the capacity is reached, Watch Folders waits before pushing new data. This capacity is based on the effective bandwidth that is reported by ascp. 5s

sample_period Period used to compute the current bandwidth. Used with queue_threshold to compute the amount of data that is pushed to ascp. 2s

content_protect_password Enter a password to enable client-side encryption at rest. Files that are uploaded to the server are appended with a .aspera-env extension. To download and decrypt .aspera-env files from the server, the client must provide the password. For more information about client-side encryption at rest, see Client-Side Encryption-at-Rest (EAR). N/A

raw_options

Specify ascp options and their arguments that are not yet available in Watch Folders to apply to Watch Folder transfers. To use raw options, they must be enabled in the client's aspera.conf by running the following command:

> asconfigurator -x "set_central_server_data;raw_options,enable"

disabled

symbolic_links Set the symbolic link-handling policy, as allowed by the server. Value can be FOLLOW, COPY, or SKIP. On Windows, the only method is SKIP. For more information about symbolic link handling, see Symbolic link handling. FOLLOW

The `growing` Object

Use to stream growing files from the Watch Folder. If a file does not match the growing file filter, it is transferred by Ascp.

Note: Growing files are only supported for local sources (push Watch Folders) and must be authenticated by a transfer user (password or SSH key file). The transfer user cannot be restricted to aspshell and the source cannot be in object storage. Growing files are only supported for local sources and nonobject storage-based destinations.

{
   ...
   "transport":{
      ...
      "growing_file":{  
         "max_parallel":8,
         "policy":"FAIR",
         "min_rate":"",
         "target_rate":"10M",
         "tcp_port":22,
         "udp_port":33001,
         "datagram_size":"",
         "cipher":"AES128",
         "completion_timeout":"5s",
         "memory":"2M",
         "chunk_size":"128K",
         "force_send_after":"2s",
         "filters":[  
            {
              "type":"REGEX",
              "rule":"INCLUDE",
              "pattern":".*\\.growing"
            },
            {
              "type":"REGEX",
              "rule":"EXCLUDE",
              "pattern":".*"
            }
         ]
      }
   }
}

Option	Description	Default
`max_parallel`	The maximum number of concurrent ascp4 sessions the Watch Folder can initiate.	8
`policy`	Defines how FASPStream manages the bandwidth. The policy can be set to the following values: `FIXED` `FAIR` `HIGH` `LOW`	`FAIR`
`min_rate`	Attempt to transfer no slower than the specified minimum transfer rate.	0 B
`target_rate`	The target transfer rate. Transfer at rates up to the specified target rate. This option accepts suffixes T for terabits/s, G for gigabits/s, M for megabits/s, K for kilobits/s, or B for bits/s. Decimals are allowed. If this option is not set by the client, the setting in the server's aspera.conf is used. If a rate cap is set in the local or server aspera.conf, the rate does not exceed the cap.	10 M
`tcp_port`	The port to use for SSH connections.	22
`udp_port`	The port to use for UDP connections.	33001
`datagram_size`	The datagram size (MTU) for FASP.	The detected path MTU.
cipher	The encryption cipher that is used to encrypt streamed data in transit, either `NONE` and `AES128`.	`AES128`
`completion_timeout`	How long to wait before the session is considered complete. A growing file is considered complete when no new data arrives within the timeout period.	5 s
`force_send_after`	Force ascp4 stream to send data after the given time, even if the chunk is not full.	2 s
`memory`	The maximum amount of memory FASPStream is allowed to use.	2 M
`chunk_size`	Packet size for transfers over the network.	128 K
`filters`	Select growing files to include in the package as the ones that match the specified filters. Use the same syntax as in the `"filters"` object.	N/A

The `watchd` Object

Use to manage watchd services for pull Watch Folders when the Aspera Watch service is run on a different node than the Aspera Watch Folders service.

{
    ...
    "watchd": {
        "scan_period": "30m",
        "identifier": "daemon",
        "connection":{
            "type": "NONE|REDIS|NODE",
            "host": "ip_address",
            "port": port,
            "authentication": {
                "type":"NODE_BASIC",
                "user": "node_username",
                "pass": "node_password"
            }
        }
    }
}

Option	Description	Default
`scan_period`	The time between file system scans of the watches (from end of one to start of the next). These scans are independent of the snapshot minimum interval and snapshot minimum changes to ensure that changes are identified. To never scan (the Aspera Watch service relies entirely on file notifications), set to `"infinite"`. On file systems without file notifications, such as object storage, mounted storage (NFS), and AIX® file system scans triggered by the scan period are used to detect file changes. In this case, set the scan period to frequently scan for changes. On operating systems that support file notifications (Linux®, Windows, macOS), the Aspera Watch service uses the file notifications as the primary means for detecting changes, and the scan period serves as a backup. In this case, the default value of 30 minutes is usually acceptable and no change is necessary. To never scan, and rely entirely on file notifications, set to `"infinite"`. For pull Watch Folders, file systems scans that are triggered by scan_period are the sole means for detecting changes in the source directory. The lower scan periods detect changes faster but can result in greater resource consumption, particularly for object storage. Note: The value for scan period cannot be empty, otherwise the configuration is rejected.	30 m
`identifier`	The daemon associated with the Watch Service that is used to monitor the file system. Optional. Required only when you want to use a Watch Service that is run by a user who is not associated with the Node API user or access key.	The system user that is associated with the Node API user or access key.
`connection type`	The method for connecting to the Aspera Watch service. Value can be `NONE`, `NODE`, or `REDIS`. If `NODE` or `REDIS` is specified, then host and port must also be specified. If `NODE` is specified, then Node API credentials must be specified in the authorization object.	`NONE`
`host`	The IP address or the URL of the host of the Aspera Node Service or the Redis database.	`localhost`
`port`	The port for the Aspera Node Service or the Redis database. By default, Node uses 9092 and Redis uses 31415.	31415
`authentication type`	The method for authentication. Only option is `NODE_BASIC`. This value is used only if connection type is `NODE`.	`NODE_BASIC`
`user`	The Node API username. This value is used only if connection type is `NODE`.	N/A
`pass`	The Node API password. This value is used only if connection type is `NODE`.	N/A