Como posso usar meu cliente Emacs local como o $ EDITOR para máquinas remotas que eu acesso através do TRAMP?

Costumo usar o TRAMP para gerenciar vários servidores remotos, tanto para editar arquivos quanto para executar shells remotos shell-mode. No entanto, isso não funciona quando um comando usa a EDITORvariável para editar um arquivo, crontab -eespecialmente porque shell-modeé um terminal "burro" que não suporta a execução de outro editor dentro dele.

Localmente, faço isso com uma chamada apropriada, emacsclientque abre um novo buffer e facilita a vida. Infelizmente, isso não funciona na máquina remota.

Eu acho que eu poderia usar ed. (Hah!)

Como posso configurar um controle remoto EDITORque permita editar arquivos com minha instância local do Emacs?

[NOTA] esta resposta foi fortemente editada para acompanhar as atualizações dos with-editordesenvolvimentos. A maioria dos comentários provavelmente não fará mais sentido. Existem alguns novos comentários que fazem sentido.

O Magit contém uma biblioteca chamada with-editordisponível em https://github.com/magit/with-editor, que permite usar o Emacs local como um $ EDITOR em máquinas remotas através do TRAMP.

Outra alternativa é https://github.com/habnabit/remote-emacsclient , mas parece mais complicado e menos genérico.

A maneira mais simples de instalar with-editoré através do MELPA:

M-x package-install with-editor

Caso contrário, basta pegar https://github.com/magit/with-editor/blob/master/with-editor.el em algum lugar do seu caminho de carregamento e require(também depende do traço).

Em seguida, basta começar shell, eshellou ansi-terme faça o seguinte:

M-x with-editor-export-editor

Ele perguntará em qual $ EDITOR você está interessado, basta pressionar Enter para a EDITORvariável padrão . Depois, dentro do shell, você pode digitar crontab -ee editar seu crontab no emacs. Pressione C-c C-cpara salvar o crontab ou C-c C-kpara cancelar a edição.

Se você deseja uma configuração mais permanente:

(add-hook 'shell-mode-hook  'with-editor-export-editor)
(add-hook 'term-mode-hook   'with-editor-export-editor)
(add-hook 'eshell-mode-hook 'with-editor-export-editor)

Como alternativa, você pode usar M-x with-editor-async-shell-command crontab -e RETpara comandos rápidos.

Disclaimer: Eu não tentei isso.

Você pode obter parte do caminho com uma saída de comando de observação de função para um comando para abrir o arquivo usando TRAMP. Falha de segurança? Sim. Funcional? Provavelmente.

Use um shell-modegancho para adicionar um gancho para after-change-hooknos shell-mode. Este gancho observa uma sequência específica. Exemplo:

;; RemoteTRAMP token: <authentication token maybe?>
;; RemoteTRAMP edit: /path/to/my/file

Em seguida, ele usa tramp-find-filepara abrir o arquivo. Isso é relativamente seguro porque a ÚNICA COISA que o controle remoto pode fazer é acionar a tramp-find-file. Uma confirmação primeiro seria boa, mas opcional.

Quando a edição termina, outro gancho pode acionar a saída do programa fictício (por exemplo, enviando C-c).

O pior caso (por segurança) é que eles encontram uma maneira de executar código arbitrário. Se você tiver variáveis ​​de buffer definidas para sempre avaliar, um invasor mal-intencionado poderá substituir configurações importantes sem o seu conhecimento. Eles também podem iniciar um ataque de negação de serviço fazendo com que muitos buffers sejam abertos. As confirmações provavelmente podem impedir todas as opções acima.

O programa no controle remoto pode ser implementado trivialmente em C (ou em qualquer outro idioma).

https://stackoverflow.com/questions/2231902/originate-edit-of-remote-file-using-emacs-tramp-from-ssh-session tem uma resposta aceita bastante simples que equivale a

(setq server-use-tcp t)
(setq server-host "name_of_local_machine")
(server-start)
;; Maybe also muck with `server-auth-dir`

e depois use

emacsclient -f ~/.emacs.d/server/server /`hostname`:/path/to/local/file

Também há https://stackoverflow.com/questions/12546722/using-emacs-server-and-emacsclient-on-other-machines-as-other-users que é mais complexo, mas onde as respostas também (aproximadamente) são similares bases.

Eu tenho um pequeno script no meu caminho no host remoto em ~/bin/ec, abreviação de emacsclient.

#!/bin/bash

params=()
for p in "$@"; do
  if [ "$p" == "-n" ]; then
    params+=( "$p" )
  elif [ "${p:0:1}" == "+" ]; then
    params+=( "$p" )
  else
    params+=( "/ssh:z:"$(readlink -f $p) )
  fi
done
emacsclient --server-file=$HOME/.emacs.d/server/server "${params[@]}"

Este script passa -ne +args inalterados para o emacsclient, caso contrário, os args são tratados como arquivos para o seu Emacs local abrir. Cada arquivo é prefixado com o protocolo TRAMP e o host para que o Emacs saiba como abri-lo. Você pode mudar ssh:para um protocolo TRAMP diferente, se preferir.

Você deve substituir zpelo nome do host da sua máquina remota. Isso é usado pelo Emacs local para se conectar via TRAMP. (Você pode usar hostnameaqui por generalidade. Prefiro usar pequenas entradas como zno meu local ssh_configpor questões de brevidade, e o controle remoto não faz ideia de que estou fazendo isso. Experimente!)

Uso:

• ec file no shell remoto abre o arquivo no Emacs local e aguarda
• ec -n file no shell remoto abre o arquivo no Emacs local e retorna
• export EDITOR=~/bin/ecno controle remoto .bashrcfaz a mágica acontecer

Para garantir que meu serverarquivo seja bom, eu tenho isso no meu local .emacs, novamente usando o pequeno nome de host z:

(setq server-use-tcp t
      server-port    9999)
(defun server-start-and-copy ()
  "Start server and copy server file to remote box."
  (interactive)
  (server-start)
  (copy-file "~/.emacs.d/server/server" "/z:.emacs.d/server/server" t)
  (chmod "/z:.emacs.d/server/server" (string-to-number "644" 8))
  )
(add-hook 'emacs-startup-hook 'server-start-and-copy)

A porta 9999 é um RemoteForward. Coloquei isso no meu local ~/.ssh/ssh_configpara automatizar o encaminhamento, além do material do ControlMaster para obter velocidade.

Host z
HostName dev.example.com
User dev
ControlMaster auto
ControlPath ~/.ssh/z.sock
RemoteForward 9999 localhost:9999

Por fim, verifique se o TRAMP conhece o seu ssh_configse você o usar:

(require 'tramp)
(tramp-set-completion-function "ssh"
  '((tramp-parse-sconfig "~/.ssh/config")))

Pode exigir alguns ajustes, mas aqui está a idéia:

EDITOR="ssh artagnon@luneth \"emacsclient -n /`hostname`:$1\""

Harold Abnabit veio com essa abordagem ¹ :

http://blog.habnab.it/blog/2013/06/25/emacsclient-and-tramp/

¹ baseado em um artigo anterior de Ryan Barrett (ao qual ele vincula).

FWIW, também há https://stackoverflow.com/q/5154224/324105 no qual Petri Lehtinen criou https://gist.github.com/akheron/850795 . Imagino que as soluções mais complexas sejam melhores, mas uma abordagem muito simples ainda pode ser interessante.

Realmente surpreso, ninguém mencionou sshfsainda. Isto é o que eu costumo fazer quando for remoto:

1) multi-term; sshfs user@host:/dir/i/want/ /mnt/point/on/my/machine
2) open whatever I want to edit in my local emacs
3) get-term; ssh user@host to launch executables etc

Embora multi-termnão sincronize o diretório de trabalho local com o diretório remoto, ele supera todas as outras soluções que tentei de longe. Embora o rastreamento de diretórios seja um recurso bem-vindo, com certeza.