############
Type de Task
############
Format général d'une tâche
--------------------------
.. versionadded:: 3.6.0
Ajout de l'option ``#COMPRESS#`` qui, avec la configuration du serveur ``compression`` à Vrai,
permet de compresser un transfert en accord avec le partenaire (qui peut ne pas supporter la
compression et donc celle-ci sera non activée pour ce transfert).
Une tâche est définie selon un format unifié XML :
.. code-block:: xml
NAME
path
x
n
- ``Type`` est l'identifiant du type de tâche à exécuter (les types sont présentés ci-après.
- ``Path`` est un argument fixé par la règle et dont des remplacements de mots clefs sont opérés :
- ``#TRUEFULLPATH#`` : Chemin complet du fichier courant
- ``#TRUEFILENAME#`` : Nom du fichier courant (hors chemin) (différent côté réception)
- ``#ORIGINALFULLPATH#`` : Chemin complet du fichier d'origine (avant changement côté réception)
- ``#ORIGINALFILENAME#`` : Nom du fichier d'origine (avant changement côté réception)
- ``#FILESIZE#`` : Taille du fichier s'il existe
- ``#INPATH#`` : Chemin du dossier de réception
- ``#OUTPATH#`` : Chemin du dossier d'émission
- ``#WORKPATH#`` : Chemin du dossier de travail
- ``#ARCHPATH#`` : Chemin du dossier d'archive
- ``#HOMEPATH#`` : Chemin du dossier du répertoire "racine" de Waarp
- ``#RULE#`` : Règle utilisé pour le transfert
- ``#DATE#`` : Date courante au format yyyyMMdd
- ``#HOUR#`` : Heure courante au format HHmmss
- ``#REMOTEHOST#`` : Nom DNS du partenaire
- ``#REMOTEHOSTIP#`` : IP du partenaire
- ``#LOCALHOST#`` : Nom DNS local du serveur Waarp
- ``#LOCALHOSTIP#`` : IP du serveur Waarp
- ``#TRANSFERID#`` : Identifiant de transfert
- ``#REQUESTERHOST#`` : Nom du partenaire initiateur du transfert
- ``#REQUESTEDHOST#`` : Nom du partenaire recevant la demande de transfert
- ``#FULLTRANSFERID#`` : Identifiant complet du transfert comme ``TRANSFERID_REQUESTERHOST_REQUESTEDHOST``
- ``#RANKTRANSFER#`` : Rang du bloc courant ou final du fichier transféré
- ``#BLOCKSIZE#`` : Taille du bloc utilisé
- ``#ERRORMSG#`` : Le message d'erreur courant ou "NoError" si aucune erreur n'a été levée jusqu'à cet
appel
- ``#ERRORCODE#`` : Le code erreur courant ou ``-`` (``Unknown``) si aucune erreur n'a été levée jusqu'à
cet appel
- ``#ERRORSTRCODE#`` : Le message lié au code d'erreur courant ou ``Unknown`` si aucune erreur n'a été
levée jusqu'à cet appel
- ``#NOWAIT#`` : Utilisé par la tâche EXEC pour spécifier que la commande est à exécuter en mode asynchrone,
sans en attendre le résultat
- ``#LOCALEXEC#`` : Utilisé par la tâche EXEC pour spécifier que la commande est à exécuter de manière
distante (pas dans la JVM courante) mais au travers d'un démon ``LocalExec`` (spécifié dans la
configuration globale
- ``#COMPRESS#`` : Utilisé en complément de l'option ``compression`` dans la configuration du serveur
pour indiquer la demande de pouvoire compresser par bloc un transfert (si le partenaire ne dispose
pas de l'option de compression, cela sera refusé).
Par exemple, un ``Path`` défini comme :
``some #DATE# some2 #TRANSFERID# some3 #REMOTEHOST# some4``
donnera
``some 20130529 some2 123456789123 some3 remotehostid some4``
- ``Delay`` est généralement le délai (si précisé) maximum pour l'exécution d'une tâche avant qu'elle tombe
en erreur pour dépassement de délai.
- ``Rank`` est optionnel et permet d'indiquer un rang d'exécution des tâches, laissant une souplesse sur
l'ordre d'écriture en période de tests. Il n'est pas conseillé de l'utiliser par défaut hormis pour les
tests et validation de plusieurs tâches.
De plus, une tâche utilisera les arguments de transfert eux-même (``Transfer Information``) pour déduire
les paramètres finaux en utilisant la fonction
``String.format(path règle, info transfert.éclaté en sous chaînes via le séparateur " ")``
L'argument de transfert (spécifié par ``-info`` dans les commandes de transferts) ou le ``path`` peuvent
contenir une MAP au format JSON qui intègre des éléments utiles aux tâches ou au fonctionnement de Waarp
(comme le ``DIGEST``, le ``RESCHDEDULE``, l'option ``follow``).
Ceci permet de rendre les arguments très adaptatifs.
Par exemple :
- si la règle définie ``Path`` comme ``some %s some2 %d some3 %s some4``
- et si les informations de transferts sont ``info1 1 info2``
- Le résultat sera pour cette tâche : ``some info1 some2 1 some3 info2 some4``
Tâches informatives
-------------------
LOG
"""
Cette tâche loggue ou écrit dans un fichier externe des informations :
- si ``delay`` est 0, aucune sortie ne sera effectuée
- si ``delay`` est 1, les informations seront envoyées vers un log
- si ``delay`` est 2, les informations seront envoyées dans un fichier (le dernier argument sera le chemin
complet du fichier de sortie)
- si ``delay`` est 3, les informations seront envoyées dans le log et dans un fichier (le dernier argument
sera le chemin complet du fichier de sortie)
Si le premier mot de ce log est un parmi ``debug``, ``info``, ``warn`` ou ``error``, ce sera le niveau du
log utilisé.
Exemple:
.. code-block:: xml
LOG
warn information /path/logfile
2
Ceci logguera un log "WARN" dans le fichier ``/path/logfile`` sans trace dans les logs usuels.
SNMP
""""
Cette tâche émet un trap SNMP :
- si ``delay`` est 0, un trap SNMP warning/info est envoyé avec le champ info et le transfer ID
- si ``delay`` est 1, un trap SNMP/info avec toutes les informations de transfert sont envoyées
Si le premier mot de ce log est un parmi ``debug``, ``info``, ``warn`` ou ``error``, ce sera le niveau du
log utilisé.
Exemple:
.. code-block:: xml
SNMP
information
0
Ceci enverra un trap SNMP/info contenant ``information`` et le TransferID.
Tâches agissant sur l'emplacement du fichier
--------------------------------------------
COPY
""""
Copie le fichier au chemin désigné comme argument sans renommer le fichier (même nom de base). Le chemin
obtenu sera un chemin absolu (et non un chemin relatif).
- ``Delay`` et Transfer Information sont ignorés.
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
COPY
/newpath/
Cela copiera le fichier courant vers ``/newpath/`` en tant que ``/newpath/currentfilename``. Le fichier
courant reste le même (inchangé).
COPYRENAME
""""""""""
Copie le fichier au chemin désigné comme argument en renommant le fichier. Le chemin
obtenu sera un chemin absolu (et non un chemin relatif).
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
Le chemin obtenu doit être un chemin absolu.
- ``Delay`` est ignoré.
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
COPYRENAME
/newpath/newfilename_%s_#TRANSFERID#
Si le ``Transfer Information`` est ``myinfoFromTransfer``, cela copiera le fichier dans un nouveau
fichier nommé ``/newpath/newfilename_myinfoFromTransfer_transferid`` où ``transferid`` sera remplacé par
un identifiant unique (comme 123456789). Le fichier courant reste le même (inchangé).
MOVE
""""
Déplace le fichier au chemin désigné comme argument sans renommer le fichier (même nom de base). Le chemin
obtenu sera un chemin absolu (et non un chemin relatif).
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
Le chemin obtenu doit être un chemin absolu.
- ``Delay`` est ignoré.
- Le fichier est marqué comme déplacé.
Exemple:
.. code-block:: xml
MOVE
/newpath/
Le fichier sera déplacé (non copié) dans le répertoire ``/newpath/``. Le fichier courant est maintenant
celui déplacé.
MOVERENAME
""""""""""
Déplace le fichier au chemin désigné comme argument en renommant le fichier. Le chemin
obtenu sera un chemin absolu (et non un chemin relatif).
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
Le chemin obtenu doit être un chemin absolu.
- ``Delay`` est ignoré.
- Le fichier est marqué comme déplacé.
Exemple:
.. code-block:: xml
MOVERENAME
/newpath/newfilename
Le fichier sera déplacé (non copié) dans le répertoire ``/newpath/`` avec comme nouveau nom
``/newpath/newfilename``. Le fichier courant est maintenant celui déplacé.
LINKRENAME
""""""""""
Crée un lien vers le fichier courant et pointe dessus.
- Le lien est d'abord tenté en mode "hard link", puis "soft link" et si ce n'est pas possible (non
supporté par le système de fichiers), il crée une copie avec le nouveau nom.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
Le chemin obtenu doit être un chemin absolu.
- ``Delay`` est ignoré.
- Le fichier est marqué comme déplacé.
Exemple:
.. code-block:: xml
LINKRENAME
/newpath/filenamelink
Le fichier sera un lien dans le répertoire ``/newpath/`` avec pour nom ``filenamelink`` (ou une copie si ce
n'est pas possible).
RENAME
""""""
Renomme le fichier au chemin désigné comme argument. Le chemin
obtenu sera un chemin absolu (et non un chemin relatif).
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
Le chemin obtenu doit être un chemin absolu.
- ``Delay`` est ignoré.
- Le fichier est marqué comme déplacé.
Exemple:
.. code-block:: xml
RENAME
/newpath/newfilename
Le fichier sera déplacé avec le nouveau nom spécifié. Le fichier est marqué comme déplacé.
DELETE
""""""
Cette tâche efface le fichier courant.
- Le fichier courant n'est plus valide.
- Aucun autre argument n'est pris en compte.
Exemple:
.. code-block:: xml
DELETE
Le fichier courant est effacé. En conséquence, plus aucune action ne peut être opérée sur le
fichier. Note : si le fichier ne peut pas être effacé, un Warning sera levé.
VALIDFILEPATH
"""""""""""""
Teste si le fichier courant est sous l'un des dossiers obtenus depuis le ``Path`` ou les ``Transfer
Information``.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Le résultat devra être : ``path1 path2 ...`` où chaque chemin est séparé par un "blanc".
- Si ``Delay`` n'est pas 0, un log sera produit.
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
VALIDFILEPATH
/path1/ /path2/
1
Ceci vérifiera si le fichier courant est dans un des dossiers spécifiés, ici ``/path1`` ou ``/path2``.
Et il fera une sortie log pour enregistrer le résultat de cette vérification.
Tâches agissant sur le fichier
------------------------------
TAR
"""
Crée un TAR depuis les arguments comme source et destination ou un UNTAR des fichiers depuis une archive TAR.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Si ``delay`` est ``1``, l'archive tar indiquée en premier argument est
**extraite** dans le dossier indiqué en second argument (le ``path``
``archiveFile destDir`` équivaut à la commande
``tar xf archiveFile -C destDir``)
- Si ``delay`` est ``2``, l'archive tar indiquée en premier argument est
**crée** avec le contenu du dossier indiqué en second argument (le ``path``
``archiveFile sourceDir`` équivaut à la commande
``tar cf archiveFile sourceDir``)
- Si ``delay`` est ``3``, l'archive tar indiquée en premier argument est
**crée** avec les fichiers indiqués dans les arguments suivants (le
``path`` ``archiveFile sourceFile1 sourceFile2`` équivaut à la commande
``tar cf archiveFile sourceFile1 sourceFile2``)
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
TAR
/path/sourcetarfile /path/targetdirectory/
1
Ceci déclenchera un ``UNTAR`` depuis l'archive TAR ``/path/sourcetarfile``
vers le dossier ``/path/targetdirectory``. Le fichier n'est pas marqué comme
déplacé.
ZIP
"""
Crée un ZIP depuis les arguments comme source et destination ou un UNZIP des fichiers depuis une archive ZIP.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme ``String
Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Si ``delay`` est ``1``, l'archive zip indiquée en premier argument est
**extraite** dans le dossier indiqué en second argument (le ``path``
``archiveFile destDir`` équivaut à la commande
``unzip archiveFile -d destDir``)
- Si ``delay`` est ``2``, l'archive zip indiquée en premier argument est
**crée** avec le contenu du dossier indiqué en second argument (le ``path``
``archiveFile sourceDir`` équivaut à la commande
``zip -r archiveFile sourceDir``)
- Si ``delay`` est ``3``, l'archive zip indiquée en premier argument est
**crée** avec les fichiers indiqués dans les arguments suivants (le
``path`` ``archiveFile sourceFile1 sourceFile2`` équivaut à la commande
``zip archiveFile sourceFile1 sourceFile2``)
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
ZIP
/path/sourcetarfile /path/targetdirectory/
1
Ceci déclenchera un ``UNZIP`` depuis l'archive ZIP ``/path/sourcetarfile``
vers le dossier ``/path/targetdirectory``. Le fichier n'est pas marqué comme
déplacé.
COMPRESS
""""""""
.. versionadded:: 3.6.0
La tâche de compression unitaire efficace et performante est ajoutée.
Crée un fichier compressé au format ZSTD depuis le fichier courant comme source et comme destination
si spécifié le nom du fichier, sinon le nom du fichier existant avec l'extension ``.zstd``, ou inversement
décompresse le fichier courant vers le om du fichier spécifié, et si non spécifié le nom du fichier courant
existant avec l'extension ``.unzstd``.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme ``String
Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Si ``delay`` est ``1``, il s'agit d'une décompression
- Si ``delay`` est ``0``, il s'agit d'une compression
- Le fichier est marqué comme déplacé et modifié pour la nouvelle cible.
Exemple:
.. code-block:: xml
COMPRESS
/path/targetdirectory/newFile.zstd
0
Ceci déclenchera une compression au format ZSTD du fichier courant vers
vers le fichier ``/path/targetdirectory/newFile.zstd``.
Le fichier est marqué comme déplacé avec ce nouveau fichier.
TRANSCODE
"""""""""
Permet de transcoder un fichier d'un ensemble de codage vers un autre.
Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- ``-from fromCharset``
- ``-to toCharset``
- ``-newfile filename`` argument optionnel : si non utilisé, ce sera le nom du fichier courant plus
``.extension`` (usuellement ``transcode``) ; si utilisé, aucune extension ne sera ajoutée
- ``-extension extension`` argument optionnel : si non utilisé, le fichier produit sera
``filename.transcode``
- ``-dos2unix`` or ``-unix2dos`` argument optionnel, mais si présent, ``-from`` et ``-to`` peuvent être
ignorés ; ceci autorise des actions ``dos2unix``/``unix2dos`` à la fin du transcodage. Cette opération peut
être réalisée même sans les options ``-from`` ou ``-to``, ce qui signifie que seule cette transformation
sera appliquée, sans transcodage.
``fromCharset`` et ``toCharset`` sont des chaînes représentant les codages officiels disponibles en Java
dont.
Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
TRANSCODE
-from fromCharset -to toCharset -newfile /path/file
Ceci transcodera le fichier courant depuis ``fromCharset`` vers ``toCharset`` et le résultat sera placé
dans le fichier ``/path/file``.
Le fichier n'est pas marqué comme déplacé.
Une méthode en ligne de commande (depuis Waarp Common) permet d'obtenir une liste en html (``-html``), csv
(``-csv``) ou au format texte (``-text``) de tous les codages supportés par votre JVM. Pour l'utiliser,
exécuter la commande suivante :
.. code-block::
java -cp WaarpCommon-1.2.7.jar \
org.waarp.common.transcode.CharsetsUtil \
[-csv | -html | -text ]
Elle peut également être utilisé pour transcoder des fichiers en dehors de R66.
.. code-block::
java -cp WaarpCommon-1.2.7.jar \
org.waarp.common.transcode.CharsetsUtil \
-from fromFilename fromCharset -to toFilename toCharset
Codages supportés
'''''''''''''''''
Parmi les ensembles de codages, les plus connus sont :
- France: IBM297 or IBM01147
- Italy: IBM280 or IBM01144
- UK: IBM285 or IBM01146
- International (Switzerland, Belgium): IBM500 or IBM01148
- Austria/Germany: IBM273 or IBM01141
- Spain and Latin America: IBM284 or IBM01145
- Portugal, Brazil, USA, Canada, Netherlands: IBM037 or IBM01140
- Central and Eastern Europe: IBM870
- Cyrillic: x-IBM1025 (x-IBM1381?)
- Turkey: IBM1026
- Cyrillic Ukraine: x-IBM1123
- Denmark, Norway: IBM277 or IBM01142
- Finland or Sweden: IBM278 or IBM01143
- Greece: x-IBM875 or x-IBM1124
.. seealso::
* `référence IBM des code pages `__
UNZEROED
""""""""
Cette tâche ajoute un octet à un fichier si celui-ci est vide (de taille 0).
Cette tâche sera en erreur si le fichier est de taille 0 mais ne peut pas être "unzeroed". Si le chemin est
non vide, le contenu sera utilisé comme remplissage du le fichier vide. S'il est vide, le caractère "blanc"
sera utilisé.
Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Si ``Delay`` est 1, la tâche produira un log de niveau info
- Si ``Delay`` est 2, la tâche produira un log de niveau warn
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
UNZEROED
optional
1
Ceci remplira le fichier courant s'il est vide avec le contenu "optional" et produiera un log de niveau
INFO en l'absence d'erreur, de niveau ERROR en cas d'erreur.
CHKFILE
"""""""
Cette tâche vérifie différentes propriétés relatives au fichier courant en fonction des arguments.
Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- ``SIZE LT/GT/LTE/GTE/EQ number``
- vérifie la taille du fichier en fonction d'une limite (plus petit, plus grand, plus petit ou égal, plus
grand ou égal, égal)
- ``DFCHECK``
- vérifie que la taille du fichier à recevoir est compatible avec l'espace disponible restant tant sur
l'espace de travail que sur l'espace final de réception (depuis le contexte)
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
CHKFILE
SIZE LT 1000000 SIZE GT 1000 DFCHECK
Ceci testera si le fichier est plus petit que 10 MO (base 10), plus grand que 1000 octets et si les
répertoires de travail et de réceptions ont assez d'espace pour y écrire le fichier (taille annoncée par
l'émetteur).
CHMOD
"""""
Cette tâche permet de modifier les droits du fichier (comme la commande ``CHMOD`` sous Unix) avec les
arguments suivants :
- le chemin complet est celui du fichier courant
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- les arguments in fine seront de la forme ``[ua][+-=][rwx]`` où de multiples répétitions peuvent être
spécifiées, séparées par un caractère ``blanc``
- ``u/a`` signifiant l'utilisateur (Utilisateur système Waarp)/all (tous) (groupe et autre n'existent pas
en Java),
- ``+/-/=`` signifiant l'ajout, le retrait ou l'affectation (l'affectation signifie que tous les autres
droits sont retirés),
- ``r/w/x`` signifiant Read/Write/Execute (Lecture/Ecriture/Exécution)
- Le fichier n'est pas marqué comme déplacé.
Par exemple :
- ``u=rwx a=r``
- ``ua+rw``
- ``u=rw a-wx``
- ``a+rw``
Si plusieurs modes sont indiqués, ils seront exécutés en séquence. Ainsi ``a=r a+w a-r`` donnera ``a=w``.
Exemple:
.. code-block:: xml
CHMOD
a=r a+w a-r
.. _task-icap:
ICAP
""""
.. versionadded:: 3.4.0
.. seealso::
Une documentation complète d'installation au regard des interactions avec un serveur ICAP est disponible
:any:`ici `
Cette tâche permet l'échange avec un serveur répondant à la norme RFC 3507 dite `ICAP`.
Elle permet de transférer le contenu du fichier vers un service ICAP via une commande
`RESPMOD` et d'obtenir la validation de ce fichier par le service (status `204`).
La liste des arguments est la suivante :
* ``-file filename`` spécifie le chemin du fichier sur lequel opérer (si le nom
est ``EICARTEST``, un faux virus de test basé sur EICAR test sera envoyé).
* ``-to hostname`` spécifie l'adresse (via DNS ou IP) du serveur ICAP
* [``-port port``, défaut 1344] spécifie le port à utiliser (défaut 1344)
* ``-service name`` | ``-model name`` spécifie le service ou modèle ICAP à
utiliser
* [``-previewSize size``, défaut aucun] spécifie la taille de Preview à
utiliser (défaut négociée)
* [``-blockSize size``, défaut 8192] spécifie la taille en émission à utiliser
(défaut 8192)
* [``-receiveSize size``, défaut 65536] spécifie la taille en réception à
utiliser (défaut 65536)
* [``-maxSize size``, défaut MAX_INTEGER] spécifie la taille maxmale d'un
fichier à utiliser (défaut MAX_INTEGER)
* [``-timeout in_ms``, défaut equiv à 10 min] spécifie la limite de temps à
utiliser (défaut equiv à 10 min)
* [``-keyPreview key -stringPreview string``, défaut aucun] spécifie la clef et
la chaîne associée pour Options à valider (défaut aucun)
* [``-key204 key -string204 string``, défaut aucun] spécifie la clef et la
chaîne associée pour 204 ICAP à valider (défaut aucun)
* [``-key200 key -string200 string``, défaut aucun] spécifie la clef et la
chaîne associée pour 200 ICAP à valider (défaut aucun)
* [``-stringHttp string``, défaut aucun] spécifie la chaîne pour HTTP 200 ICAP
à valider (défaut aucun)
* [``-logger DEBUG|INFO|WARN|ERROR``, défaut aucun] spécifie le niveau de log
entre ``DEBUG`` | ``INFO`` | ``WARN`` | ``ERROR`` (défaut ``WARN``)
* [``-errorMove path`` | ``-errorDelete`` | ``-sendOnError``] spécifie l'action
en cas de scan erronné : un répertoire de quarantaine, l'effacement du
fichier, la retransmission (R66) vers un autre partenaire (mutuellement
exclusif) (défaut aucun)
* [``-ignoreNetworkError``] spécifie que sur une erreur réseau, le fichier sera
considéré comme OK
* [``-ignoreTooBigFileError``] spécifie que sur une erreur de fichier trop
grand, le fichier sera considéré comme OK
Si une commande R66 de retransfert est demandée (``-sendOnError``), la dernière option pour ICAP devra être
suivie de ``--`` avant de poursuivre sur les options usuelles pour la commande ``TRANSFER``.
Exemple 1:
.. code-block:: xml
ICAP
-file #TRUEFULLPATH# -to hostname -service name
-previewSize size -blockSize size -receiveSize size
-maxSize size -timeout in_ms
-keyPreview key -stringPreview string
-key204 key -string204 string
-key200 key -string200 string
-stringHttp string -logger WARN -errorDelete
-ignoreNetworkError
10000
Ici, en cas de scan en erreur, le fichier sera effacé.
Exemple 2:
.. code-block:: xml
ICAP
-file #TRUEFULLPATH# -to hostname -model name
-previewSize size -blockSize size -receiveSize size
-maxSize size -timeout in_ms
-keyPreview key -stringPreview string
-key204 key -string204 string
-key200 key -string200 string
-stringHttp string -logger WARN -errorMove path
-ignoreNetworkError
10000
Ici, en cas de scan en erreur, le fichier sera déplacé dans un autre répertoire.
Exemple 3:
.. code-block:: xml
ICAP
-file #TRUEFULLPATH# -to hostname -model name
-previewSize size -blockSize size -receiveSize size
-maxSize size -timeout in_ms
-keyPreview key -stringPreview string
-key204 key -string204 string
-key200 key -string200 string
-stringHttp string -logger WARN -sendOnError
-ignoreNetworkError -- -file #TRUEFULLPATH# -to
requestedHost -rule rule [-copyinfo]
[-info information]
10000
Ici, en cas de scan en erreur, le fichier sera envoyé vers un autre serveur (l'effacement sera alors pris
en charge par la règle utilisée pour l'envoyer).
Exemple 4:
.. code-block:: xml
ICAP
-file #TRUEFULLPATH# -to hostname -model ICAP_AVSCAN
-sendOnError -ignoreNetworkError -ignoreTooBigFileError --
-file #TRUEFULLPATH# -to requestedHost -rule rule -copyinfo
-info FILE INFECTED
10000
Même cas que l'exemple 3 plus minimaliste et réaliste.
Tâches exécutant un sous-traitement
-----------------------------------
EXEC
""""
Exécute une commande externe en fonction des arguments ``Path`` et ``Transfer Information``.
- Le ``Delay`` est le temps maximum autorisé en millisecondes avant que la tâche ne soit considérée comme
en time out et donc en erreur.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Le fichier n'est pas marqué comme déplacé.
La commande externe est supposée se comporter comme suit pour ses valeurs de retour :
- exit 0, pour une exécution correcte
- exit 1, pour une exécution correcte mais avec avertissement
- toute autre valeur pour une exécution en erreur
Exemple:
.. code-block:: xml
EXEC
/path/command arguments #TRANSFERID# #TRUEFULLPATH# %s
10000
En prenant en compte les transformations dynamiques, la commande ``/path/command`` sera exécutée avec les
arguments suivants :
``arguments transferId /path/currentFilename transferInformation``.
EXECMOVE
""""""""
Exécute une commande externe en fonction des arguments ``Path`` et ``Transfer Information``.
- Le ``Delay`` est le temps maximum autorisé en millisecondes avant que la tâche ne soit considérée comme
en time out et donc en erreur.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- La dernière ligne retournée par la commande externe est interprétée comme le nouveau chemin absolu du
fichier courant. La commande externe est responsable d'avoir réellement déplacer le fichier vers ce nouvel
emplacement.
- Le fichier est marqué comme déplacé.
La commande externe est supposée se comporter comme suit pour ses valeurs de retour :
- exit 0, pour une exécution correcte
- exit 1, pour une exécution correcte mais avec avertissement
- toute autre valeur pour une exécution en erreur
Exemple:
.. code-block:: xml
EXECMOVE
/path/command arguments #TRANSFERID# #TRUEFULLPATH# %s
10000
En prenant en compte les transformations dynamiques, la commande ``/path/command`` sera exécutée avec les
arguments suivants :
``arguments transferId /path/currentFilename transferInformation``.
La dernière ligne retournée par la commande externe est interprétée comme le nouveau chemin absolu du
fichier courant.
EXECOUTPUT
""""""""""
Exécute une commande externe en fonction des arguments ``Path`` et ``Transfer Information``.
- Le ``Delay`` est le temps maximum autorisé en millisecondes avant que la tâche ne soit considérée comme
en time out et donc en erreur.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Toutes les lignes retournées par la commande externe (sortie standard) sont interprétées comme un
possible message d'erreur.
- Le fichier n'est pas marqué comme déplacé, sauf en cas d'erreur et si ``NEWFILENAME`` est utilisé comme
préfixe au nom du fichier).
La commande externe est supposée se comporter comme suit pour ses valeurs de retour :
- exit 0, pour une exécution correcte
- exit 1, pour une exécution correcte mais avec avertissement
- toute autre valeur pour une exécution en erreur et seulement dans ce cas, la sortie standard est
utilisée comme message d'erreur. Des informations peuvent être retournées au serveur distant avec les
balises ``#ERRORMSG#`` et ``#ERRORCODE#`` ou ``#ERRORSTRCODE#``, et ``NEWFINALNAME`` si le fichier a
changé.
Exemple:
.. code-block:: xml
EXECOUTPUT
/path/command arguments #TRANSFERID# #TRUEFULLPATH# %s
10000
En prenant en compte les transformations dynamiques, la commande ``/path/command`` sera exécutée avec les
arguments suivants :
``arguments transferId /path/currentFilename transferInformation``.
La dernière ligne retournée par la commande externe est interprétée comme le nouveau chemin absolu du
fichier courant. Des informations peuvent être retournées au serveur distant avec les
balises ``#ERRORMSG#`` et ``#ERRORCODE#`` ou ``#ERRORSTRCODE#``, et ``NEWFINALNAME`` si le fichier a changé.
EXECJAVA
""""""""
Exécute une classe Java externe en fonction des arguments ``Path`` et ``Transfer Information``.
- Le ``Delay`` est le temps maximum autorisé en millisecondes avant que la tâche ne soit considérée comme
en time out et donc en erreur.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Le nom de la classe Java (qui doit implémenter ``R66Runnable`` ou étendre ``AbstractExecJavaTask``, en
ignorant les méthodes ``validate/finalValidate/invalid`` utilisées uniquement pour les tâches ``Business``)
est obtenu comme le premier argument. L'allocation est réalisée sous la forme ``new MyClass()``,
c'est-à-dire un constructeur sans argument.
- Le fichier n'est pas marqué comme déplacé.
Exemple:
.. code-block:: xml
EXECJAVA
java.class.name #TRANSFERID# #TRUEFULLPATH#
10000
Ceci va déclencher l'exécution de la commande nommée ``java.class.name`` avec les arguments suivants :
``arguments transferId /path/currentFilename``.
Eléments additionnels : Usage de la classe ExecJava
Afin de faciliter l'intégration dans des modules applicatifs, Waarp R66
supporte la possibilité de déclencher des classes Java spécifiques de 3
manières (depuis la version 2.3) :
- L'une est au travers de tâches de traitement pré- ou post-transfert, ou en
cas d'erreur en utilisant le mot clef EXECJAVA, suivi du nom complet de la
classe Java qui doit implémenter l'interface ``R66Runnable``.
- Une autre est d'exécuter des commandes spécifiques ``R66Business``, qui sont
également des implémentations de l'interface ``R66Runnable`` au travers de
l'extension de ``AbstractExecJavaTask``.
- Enfin, il y a la possibilité d'associer une classe ``Business`` (voir
``R66BusinessInterface``) au travers
d'une "factory" Business (voir ``R66BusinessFactoryInterface``) pour chacun des
transfer et qui déclenche différentes méthodes lors des étapes de chaque transfert :
- ``void checkAtStartup(R66Session session)``: lancé au démarrage avant les tâches de pré-tâches
- ``void checkAfterPreCommand(R66Session session)``: lancé après les pré-tâches mais avant le transfert
- ``void checkAfterTransfer(R66Session session)``: lancé après le transfer mais avant les
post-tâches
- ``void checkAfterPost(R66Session session)``: lancé après les post-tâches et avant la fin de la requête
- ``void checkAtError(R66Session session)``: lancé si une erreur intervient
- ``void checkAtChangeFilename(R66Session session)``: lancé si le nom du fichier change durant des
tâches
- ``void releaseResources()``: lancé à la toute fin pour nettoyer les possibles ressources utilisées
- ``String getInfo()`` and ``void setInfo(String info)``: lancés de manière programmatique (code
métier) pour permettre de positionner une information spéciale (chaîne de caractères) et de la récupérer
à n'importe quel moment
Notez que la ``R66BusinessFactory`` peut être déclarée dans le fichier XML de configuration du moniteur
dans la balise ``businessfactory`` dans les parties ``server`` ou ``client``, mais est limitée à un
constructeur sans argument.
Notez enfin que pour autoriser des requêtes Business, le droit doit avoir été accordé au partenaire comme
suit dans le fichier de configuration XML :
.. code-block:: xml
hostname...
Si non positionné, le partenaire ne sera pas autorisé. Pour ``EXECJAVA``, la sécurité est assurée par le
fait que la règle est locale au serveur qui l'ecécute et que la règle peut elle aussi limiter les
partenaires qui peuvent l'utiliser.
RESTART
"""""""
Cette tâche permet de redémarrer un serveur Waarp. Il n'y a aucun argument.
Exemple:
.. code-block:: xml
RESTART
0
L'exemple d'usage le plus fréquent est la mise à jour des binaires ou de la configuration XML du serveur
via un transfert, suivi d'un ``UNTAR`` ou ``UNZIP`` et enfin d'un ``RESTART``.
Tâches exécutant un transfert
-----------------------------
TRANSFER
""""""""
.. versionadded:: 3.4.0
option ``-nofollow``
Soumet un nouveau transfert basé sur des arguments ``Path`` et ``Transfer Information``.
- Une fois le ``Path`` transformé selon les remplacements dynamiques, il est utilisé comme
``String Format`` avec le ``Transfer Information`` utilisé en entrée (``String.format(Path,Info)``).
- Les arguments de transferts sont obtenus à partir du ``Path`` transformé.
- Le résultat est considéré comme un ``r66send`` sauf ``-info`` qui doit être le dernier item, et
``-copyinfo`` copiera en première position les informations de transferts originales dans les nouvelles, en
ayant toujours la possibilité d'en ajouter d'autres via ``-info``
- ``Delay`` est ignoré
- Le fichier n'est pas marqué comme déplacé.
Arguments du transfert :
::
-to Spécifie le partenaire distant
(-id | Spécifie l'identifiant du transfert
(-file Spécifie le fichier à opérer
-rule )) Spécifie la règle de transfert
[-block ] Spécifie la taille du bloc
[-nofollow] Spécifie que le trasfert ne devra pas intégrer un "follow" id
[-md5] Spécifie qu'un calcul d'empreinte doit être réalisé pour
valider le transfert
[-delay | Spécifie le délai comme un temps epoch ou un délai (+arg) en ms
-start ] Spécifie la date de démarrage yyyyMMddHHmmss
[-nolog] Spécifie de ne rien conserver de ce transfert (en base)
[-notlogWarn | Spécifie que le log final est en mode Info si OK
-logWarn] Spécifie que le log final est en mode Warn si OK (défaut)
[-copyinfo] Spécifie que les informations de transfert seront recopiées
intégralement en préposition des nouvelles valeurs
[-info ) Spécifie les informations de transfert (en dernière position)
Exemple:
.. code-block:: xml
TRANSFER
-file #TRUEFULLPATH# -to remotehost
-rule ruletouse -info transfer Information
Ceci créera une nouvelle requête de transfert (asynchrone) en utilisant le fichier courant
(``#TRUEFULLPATH#``), pour envoyer (ou recevoir selon la règle utilisée)
vers (ou depuis) le partenaire, en utilisant ``transfer Information`` comme argument de transfert.
RESCHEDULE
""""""""""
Replanifie une tâche de transfert en cas d'erreur avec un délai spécifié en millisecondes, si le code
d'erreur est un de
ceux spécifiés et si les intervalles optionnels de dates sont compatibles avec la nouvelle planification.
La balise ``path`` accepte les arguments suivants (les deux premiers sont
obligatoires) :
- ``-delay ms`` spécifie le délai en millisecondes après lequel retenter ce
transfert
- ``-case errorCode,errorCode,...`` où les "errorCode" sont une liste de codes
d'erreur pour lesquels la tâche est exécutée. Les codes suivants sont
disponibles (e nom de l'erreur et le code d'une lettre peuvent petre
utilisés) :
- ``ConnectionImpossible(C)``,
- ``ServerOverloaded(l)``
- ``BadAuthent(A)``,
- ``ExternalOp(E)``
- ``TransferError(T)``
- ``MD5Error(M)``
- ``Disconnection(D)``
- ``RemoteShutdown(r)``
- ``FinalOp(F)``
- ``Unimplemented(U)``
- ``Shutdown(S)``
- ``RemoteError(R)``
- ``Internal(I)``
- ``StoppedTransfer(H)``
- ``CanceledTransfer(K)``
- ``Warning(W)``
- ``Unknown(-)``
- ``QueryAlreadyFinished(Q)``
- ``QueryStillRunning(s)``
- ``NotKnownHost(N)``,
- ``QueryRemotelyUnknown(u)``
- ``FileNotFound(f)``
- ``CommandNotFound(c)``
- ``PassThroughMode(p)``
- ``-between starttime;endtime``, ``-notbetween starttime;endtime`` permettent
de définir des plages horaires durant lesquelles les tentatives de transferts
peuvent ou, respectivement, ne peuvent pas être retentés. Les règles
suivantes sont utilisées :
- Ces arguments peuvent être utilisés plusieurs fois et peuvent être mixés ;
- Ils ont le format suivant : ``Yn:Mn:Dn:Hn:mn:Sn`` où n
spécifie un nombre pour chaque partie d'une date (optionnelle) comme ``Y``
= Année, ``M`` = Mois, ``D`` = Jour, ``H`` = Heure, ``m`` = minute, ``s`` =
seconde ;
- Le format peut être ``X+n``, ``X-n``, ``X=n`` ou ``Xn`` où ``X+-n``
signifie ajouter/soustraire n à la date courante, tandis que ``X=n`` ou
``Xn`` signifie une valeur exacte ;
- Si aucune spécification de temps n'est présente, ce sera la date actuelle ;
- La date planifiée ne doit pas être dans un des intervalles définis par
les arguments ``-notbetween`` ;
- La date planifiée doit être dans un des intervalles définis par les
arguments ``-between`` ;
- Si aucun de ces arguments n'est spécifié, la date planifiée sera toujours
valide.
- Si ``starttime`` est plus grand que ``endtime``, ``endtime`` prendra la valeur ``starttime`` + 1 jour ;
- Si ``starttime`` et ``endtime`` sont inférieurs à la date planifiée, ils auront également un décalage d'un
jour.
- ``-count limit`` sera la limite de retentatives. La valeur limite est prise des
``information de transfert`` et non de la règle.
- Chaque fois que cette fonction est appelée, la valeur limite est remplacée
par ``newlimit = limit - 1`` dans l'``information de transfert``.
- Pour assurer la cohérence, la valeur doit être dans ce champ puisque elle
sera changée statiquement. Cependant, une valeur doit être positionnée dans
la règle afin de réinitialiser la valeur lorsque le décompte tombe à 0.
- Ainsi, dans la règle, ``-count resetlimit`` doit être présent, où
``resetlimit`` sera la nouvelle valeur lorsque celle-ci atteindra 0. Si elle
est manquante la condition ne peut pas être appliquée.
.. important::
* Notez que si un précédent appel à ``RESCHEDULE`` a été réalisé et courroné
de succès, les appels suivants seront ignorés.
* Toutes tâches qui suivent celle-ci seront ignorées et non exécutées si la
replanification est acceptée. Au contraire, si la replanification est
refusée, les tâches suivantes seront exécutées normalement.
Exemple:
.. code-block:: xml
RESCHEDULE
-delay 3600000
-case ConnectionImpossible,ServerOverloaded,Shutdown
-notbetween H7:m0:S0;H19:m0:S0
-notbetween H1:m0:S0;H=3:m0:S0 -count 1
Cet exemple illustre le cas d'une nouvelle tentative d'un transfert tombé en
erreur à cause d'une connexion impossible. La nouvelle tentative sera faite
dans une heure, si l'heure résultante n'est pas comprise 7H du matin et 7H du
soir, ni entre 1H du matin et 3H du matin avec une limite de 3 tentatives
(la valeur ``retry`` sera réinitialisée à 1 en cas de 3 tentatives).
Pour chaque tentative, le compteur sera décrémenté.
FTP
"""
Cette tâche permet de réaliser un transfert synchrone en utilisant FTP. Elle utilise les paramètres suivants :
- ``-file filepath``
- ``-to requestedHost``
- ``-port port``
- ``-user user``
- ``-pwd pwd``
- [``-account account``]
- [``-mode active/passive``]
- [``-ssl no/implicit/explicit``]
- [``-cwd remotepath``]
- [``-digest (crc,md5,sha1)``]
- [``-pre extraCommand1`` avec ',' comme séparateur d'arguments]
- ``-command command`` où ``commande`` est un parmi (``get``, ``put``, ``append``)
- [``-post extraCommand2`` avec ',' comme séparateur d'arguments]
L'orde des commandes sera alors :
1. Connexion au requestHost avec le port.
Si ``-ssl`` vaut ``implicit``, une
liaison liaison TLS native est utilisée et l'étape 5 n'est pas exécutée
2. ``USER user``
3. ``PASS pwd``
4. ``ACCT account``, si ``-account`` est renseigné
5. ``AUTH TLS``, ``PBSZ 0`` et ``PROT P``, si ``-ssl`` vaut ``explicit``
6. ``PASV``, si ``-mode`` vaut ``passive``
7. ``CWD remotepath``
En cas d'erreur, le dossier est créé: ``MKD remotepath`` puis ``CWD
remotepath`` (en ignorant les erreurs)
8. Si ``-pre`` est renseigné, ``extraCommand1`` avec ',' remplacés par ' '
**note** : n'utilisez pas des commande standards FTP comme ``ACCT``,
``PASS``, ``REIN``, ``USER``, ``APPE``, ``STOR``, ``STOU``, ``RETR``,
``RMD``, ``RNFR``, ``RNTO``, ``ABOR``, ``CWD``, ``CDUP``, ``MODE``,
``PASV``, ``PORT``, ``STRU``, ``TYPE``, ``MDTM``, ``MLSD``, ``MLST``,
``SIZE``, ``AUTH``
9. ``BINARY`` (binary format)
10. Transfert des données :
* Si ``-command`` vaut ``get``, ``RETR filepath.basename``
* Si ``-command`` vaut ``put`, ``STOR filepath``
* Si ``-command`` vaut ``append``, ``APPE filepath.basename``
11. Si l'argument ``-digest`` est donné et que le serveur FTP distant est
compatible avec les commandes ``XCRC``, ``XMD5``, ``XSHA1``, ``FEAT`` (le
résultat vérifie la présente des options disponibles) ; puis
``XCRC``/``XMD5``/``XSHA1`` ``filepath.basename`` ; puis localement il y
aura la comparaison de ce hash avec le fichier local
12. Si ``-post`` est renseigné, ``extraCommand2`` avec ',' remplacés by ' '
**note** : n'utilisez pas des commande standards FTP comme ``ACCT``, ``PASS``,
``REIN``, ``USER``, ``APPE``, ``STOR``, ``STOU``, ``RETR``, ``RMD``,
``RNFR``, ``RNTO``, ``ABOR``, ``CWD``, ``CDUP``, ``MODE``, ``PASV``,
``PORT``, ``STRU``, ``TYPE``, ``MDTM``, ``MLSD``, ``MLST``, ``SIZE``,
``AUTH``
13. ``QUIT``
Le fichier courant est inchangé et non marqué comme déplacé.
Exemple:
.. code-block:: xml
FTP
-file /path/file -to remotehost -port port
-user username -pwd password -command put
Ceci enverra (``put``) le fichier ``/path/file`` au serveur FTP ``remotehost`` sur le port ``port`` en
utilisant les ``username`` et ``password``.
Tâches agissant sur l'emplacement du fichier via un stockage S3
---------------------------------------------------------------
.. versionadded:: 3.6.0
Les tâches ci-dessous sont nouvelles et supportées avec le module WaarpR66-S3.
S3GET
"""""
Copie le fichier depuis un stockage S3 Objet comme argument et remplace le fichier
actuel avec ce fichier comme source.
- ``Delay`` est ignoré.
- La commande finale est fonction des arguments ``Path`` et ``Transfer Information``.
- Le fichier est marqué comme déplacé.
La règle à utiliser doit être en mode THROUGHMODE, soit
``SENDMD5THROUGHMODE`` ou ``SENDTHROUGHMODE`` (respectivement ``7`` ou ``5``) en mode ``SEND``,
soit ``RECVMD5THROUGHMODE`` ou ``RECVTHROUGHMODE`` (respectivement ``8`` ou ``6``) en mdoe ``RECV``,
car le fichier n'existe pas au démarrage.
Le format est le suivant :
- ``-URL url`` du service S3
- ``-accessKey access Key`` du service S3
- ``-secretKey secret Key`` du service S3
- ``-bucketName bucket Name`` où est stocké l'objet
- ``-sourceName source Name`` dans le bucket pour sélectionner l'objet final
- ``-file final File path`` absolue ou relatif depuis le chemin IN
- [``-getTags`` [``*`` or ``liste`` de noms de tag séparés par des virgules sans espace]]
Les actions seront dans l'ordre :
1) connexion au service S3 en utilisant la clef d'accès et la clef de secret
2) Récupère depuis le bucket l'objet source et le stocke dans le fichier spécifié
3) Si getTags is positionné, les informations sont ajoutées au transferInfo et fileInfo
4) le fichier courrant est positionné sur ce nouveau fichier reçu (équivalent à la tâche R66 ``RENAME``)
5) l'émetteur envoie une mise à jour (nom et taille)
Exemple:
.. code-block:: xml
S3GET
-URL %s -accessKey %s -secretKey %s -bucketName %s -sourceName %s -file #TRUEFULLPATH# -getTags key1,key2
0
S3GETDELETE
"""""""""""
Copie le fichier depuis un stockage S3 Objet comme argument et remplace le fichier
actuel avec ce fichier comme source et efface l'objet source.
- ``Delay`` est ignoré.
- La commande finale est fonction des arguments ``Path`` et ``Transfer Information``.
- Le fichier est marqué comme déplacé.
La règle à utiliser doit être en mode THROUGHMODE, soit
``SENDMD5THROUGHMODE`` ou ``SENDTHROUGHMODE`` (respectivement ``7`` ou ``5``) en mode ``SEND``,
soit ``RECVMD5THROUGHMODE`` ou ``RECVTHROUGHMODE`` (respectivement ``8`` ou ``6``) en mdoe ``RECV``,
car le fichier n'existe pas au démarrage.
Le format est le suivant :
- ``-URL url`` du service S3
- ``-accessKey access Key`` du service S3
- ``-secretKey secret Key`` du service S3
- ``-bucketName bucket Name`` où est stocké l'objet
- ``-sourceName source Name`` dans le bucket pour sélectionner l'objet final
- ``-file final File path`` absolue ou relatif depuis le chemin IN
- [``-getTags`` [``*`` or ``liste`` de noms de tag séparés par des virgules sans espace]]
Les actions seront dans l'ordre :
1) connexion au service S3 en utilisant la clef d'accès et la clef de secret
2) Récupère depuis le bucket l'objet source et le stocke dans le fichier spécifié
3) Si getTags is positionné, les informations sont ajoutées au transferInfo et fileInfo
4) le fichier courrant est positionné sur ce nouveau fichier reçu (équivalent à la tâche R66 ``RENAME``)
5) l'émetteur envoie une mise à jour (nom et taille)
6) l'objet S3 est effacé
Exemple:
.. code-block:: xml
S3GETDELETE
-URL %s -accessKey %s -secretKey %s -bucketName %s -sourceName %s -file #TRUEFULLPATH# -getTags key1,key2
0
S3DELETE
""""""""
Efface l'objet S3.
- ``Delay`` est ignoré.
- La commande finale est fonction des arguments ``Path`` et ``Transfer Information``.
- Le fichier courant n'est pas modifié.
Le format est le suivant :
- ``-URL url`` du service S3
- ``-accessKey access Key`` du service S3
- ``-secretKey secret Key`` du service S3
- ``-bucketName bucket Name`` où est stocké l'objet
- ``-sourceName source Name`` dans le bucket pour sélectionner l'objet final
Les actions seront dans l'ordre :
1) connexion au service S3 en utilisant la clef d'accès et la clef de secret
2) l'objet S3 est effacé
Exemple:
.. code-block:: xml
S3DELETE
-URL %s -accessKey %s -secretKey %s -bucketName %s -sourceName %s
0
S3PUT
"""""
Copie le fichier courant ver un stockage S3 Objet.
- ``Delay`` est ignoré.
- La commande finale est fonction des arguments ``Path`` et ``Transfer Information``.
- Le fichier courant est inchangé.
Le format est le suivant :
- ``-URL url`` du service S3
- ``-accessKey access Key`` du service S3
- ``-secretKey secret Key`` du service S3
- ``-bucketName bucket Name`` où est stocké l'objet
- ``-targetName target Name`` dans le bucket pour sélectionner l'objet final
- [``-setTags`` [``clef:valeur,clef:valeur`` de ``clef:valeur`` séparés par des virgules sans espace]]
Les actions seront dans l'ordre :
1) connexion au service S3 en utilisant la clef d'accès et la clef de secret
2) Stocke le fichier courant dans le bucket l'objet destination
3) Si setTags is positionné, les informations sont ajoutées à l'objet S3
Exemple:
.. code-block:: xml
S3PUT
-URL %s -accessKey %s -secretKey %s -bucketName %s -targetName %s -setTags key1:value1,key2:value2
0
S3PUTR66DELETE
""""""""""""""
Copie le fichier courant ver un stockage S3 Objet et efface le fichier courant.
- ``Delay`` est ignoré.
- La commande finale est fonction des arguments ``Path`` et ``Transfer Information``.
- Le fichier courant est inchangé.
Le format est le suivant :
- ``-URL url`` du service S3
- ``-accessKey access Key`` du service S3
- ``-secretKey secret Key`` du service S3
- ``-bucketName bucket Name`` où est stocké l'objet
- ``-targetName target Name`` dans le bucket pour sélectionner l'objet final
- [``-setTags`` [``clef:valeur,clef:valeur`` de ``clef:valeur`` séparés par des virgules sans espace]]
Les actions seront dans l'ordre :
1) connexion au service S3 en utilisant la clef d'accès et la clef de secret
2) Stocke le fichier courant dans le bucket l'objet destination
3) Si setTags is positionné, les informations sont ajoutées à l'objet S3
4) le fichier courrant est supprimé (équivalent à la tâche ``DELETE``)
Exemple:
.. code-block:: xml
S3PUTDELETE
-URL %s -accessKey %s -secretKey %s -bucketName %s -targetName %s -setTags key1:value1,key2:value2
0