Come spostare / rinominare un file usando un'attività Ansible su un sistema remoto

Come è possibile spostare / rinominare un file / directory usando un modulo Ansible su un sistema remoto? Non voglio usare il comando / le attività della shell e non voglio copiare il file dal sistema locale al sistema remoto.

Il modulo file non copia i file sul sistema remoto. Il parametro src viene utilizzato solo dal modulo file durante la creazione di un collegamento simbolico a un file.

Se si desidera spostare / rinominare un file interamente su un sistema remoto, la soluzione migliore è utilizzare il modulo comandi per invocare il comando appropriato:

- name: Move foo to bar
  command: mv /path/to/foo /path/to/bar

Se vuoi essere sofisticato, puoi prima utilizzare il modulo stat per verificare che il foo esista effettivamente:

- name: stat foo
  stat: path=/path/to/foo
  register: foo_stat

- name: Move foo to bar
  command: mv /path/to/foo /path/to/bar
  when: foo_stat.stat.exists

Dalla versione 2.0 , nel modulo di copia è possibile utilizzare il remote_srcparametro.

Se Trueandrà al computer remoto / target per l'src.

- name: Copy files from foo to bar
  copy: remote_src=True src=/path/to/foo dest=/path/to/bar

Se si desidera spostare il file, è necessario eliminare il vecchio file con il modulo file

- name: Remove old files foo
  file: path=/path/to/foo state=absent

Dalla versione 2.8 il modulo di copia remote_src supporta la copia ricorsiva.

Ho trovato utile l'opzione di creazione nel modulo di comando. Cosa ne pensi di questo:

- name: Move foo to bar
  command: creates="path/to/bar" mv /path/to/foo /path/to/bar

Ho usato un approccio a 2 attività usando stat come suggerisce Bruce P. Ora faccio questo come un compito con crea. Penso che questo sia molto più chiaro.

Un'altra opzione che ha funzionato bene per me è l'utilizzo del modulo di sincronizzazione . Quindi rimuovere la directory originale utilizzando il modulo file.

Ecco un esempio dai documenti:

- synchronize:
    src: /first/absolute/path
    dest: /second/absolute/path
    archive: yes
  delegate_to: "{{ inventory_hostname }}"

Un altro modo per raggiungere questo obiettivo è l'utilizzo filedi state: hard.

Questo è un esempio che ho avuto modo di lavorare:

- name: Link source file to another destination
  file:
    src: /path/to/source/file
    path: /target/path/of/file
    state: hard

Testato solo su localhost (OSX), ma dovrebbe funzionare anche su Linux. Non posso dirlo per Windows.

Si noti che sono necessari percorsi assoluti. Altrimenti non mi permetterebbe di creare il collegamento. Inoltre, non è possibile attraversare i filesystem, quindi il funzionamento con qualsiasi supporto montato potrebbe non riuscire.

Il collegamento fisico è molto simile allo spostamento, se successivamente si rimuove il file di origine:

- name: Remove old file
  file:
    path: /path/to/source/file
    state: absent

Un altro vantaggio è che i cambiamenti persistono quando sei nel bel mezzo di una commedia. Quindi, se qualcuno cambia l'origine, qualsiasi modifica si riflette nel file di destinazione.

È possibile verificare il numero di collegamenti a un file tramite ls -l. Il numero di hardlink è mostrato accanto alla modalità (es. Rwxr-xr-x 2, quando un file ha 2 collegamenti).

Bruce non stava tentando di impostare la destinazione per verificare se spostare o meno il file se era già lì; si stava assicurando che il file da spostare esistesse effettivamente prima di tentare il mv.

Se il tuo interesse, come quello di Tom, è spostare solo se il file non esiste già, penso che dovremmo ancora integrare il controllo di Bruce nel mix:

- name: stat foo
  stat: path=/path/to/foo
  register: foo_stat

- name: Move foo to bar
  command: creates="path/to/bar" mv /path/to/foo /path/to/bar
  when: foo_stat.stat.exists

Questo è il modo in cui l'ho fatto funzionare per me:

  Tasks:
  - name: checking if the file 1 exists
     stat:      
      path: /path/to/foo abc.xts
     register: stat_result

  - name: moving file 1
    command: mv /path/to/foo abc.xts /tmp
    when: stat_result.stat.exists == True

il playbook sopra, controllerà se esiste il file abc.xts prima di spostare il file nella cartella tmp.

Questo può sembrare eccessivo, ma se vuoi evitare di usare il modulo di comando (cosa che faccio, perché usare il comando non è idempotente) puoi usare una combinazione di copia e non archivistica.

1. Utilizzare tar per archiviare i file necessari. Se pensi al futuro, questo ha davvero senso. È possibile che si desideri una serie di file in una determinata directory. Crea quella directory con tutti i file e archiviali in un tar.
2. Utilizzare il modulo unarchive. Quando lo fai, insieme alla destinazione: e remote_src: parola chiave, puoi posizionare tutti i tuoi file in una cartella temporanea per iniziare e quindi decomprimerli esattamente dove vuoi.

Puoi farlo da -

Utilizzo del comando ad hoc

ansible all -m command -a" mv /path/to/foo /path/to/bar"

Oppure tu se vuoi farlo usando il playbook

- name: Move File foo to destination bar
  command: mv /path/to/foo /path/to/bar

So che è un vecchio argomento ANNI , ma mi sono frustrato e ho creato un ruolo per me stesso fare esattamente questo per un elenco arbitrario di file. Estendi come ritieni opportuno:

main.yml

- name: created destination directory
  file:
    path: /path/to/directory
    state: directory
    mode: '0750'
- include_tasks: move.yml
  loop:
    - file1
    - file2
    - file3

move.yml

- name: stat the file
  stat:
    path: {{ item }}
  register: my_file

- name: hard link the file into directory
  file:
    src: /original/path/to/{{ item }}
    dest: /path/to/directory/{{ item }}
    state: hard
  when: my_file.stat.exists

- name: Delete the original file
  file:
    path: /original/path/to/{{ item }}
    state: absent
  when: my_file.stat.exists

Si noti che il collegamento reale è preferibile alla copia qui, poiché preserva intrinsecamente la proprietà e le autorizzazioni (oltre a non consumare più spazio su disco per una seconda copia del file).

Su Windows: - name: Move old folder to backup win_command: "cmd.exe /c move /Y {{ sourcePath }} {{ destinationFolderPath }}"

Per rinominare utilizzare invece il comando rename o ren