.. _40: 40 Usar Emacs Como Servidor =========================== Varios programas pueden invocar su elección de editor para modificar una parte concreta del texto. Por ejemplo, los programas de control de versiones invocan a un editor para introducir registros de control de versiones (ver :ref:`29.1`), y la utilidad de correo de Unix invoca a un editor para introducir un mensaje a enviar. Por convención, su elección de editor se especifica mediante la variable de entorno ``EDITOR``. Si establece ``EDITOR`` a ``emacs``, el editor Emacs será invocado, pero de una manera poco práctica, iniciando un nuevo proceso Emacs. Esto es inconveniente porque el nuevo proceso Emacs no comparte búferes, historial de comandos u otro tipo de información con ningún proceso Emacs existente. Puede resolver este problema configurando Emacs como *servidor de edición*, de forma que "escuche" las peticiones de edición externas y actúe en consecuencia. Hay varias formas de iniciar un servidor Emacs: * Ejecute el comando ``server-start`` en un proceso Emacs existente: escriba :kbd:`Alt`-:kbd:`x` ``server-start`` (``M-x server-start``), o ponga la expresión (``server-start``) en su fichero init (vea :ref:`50.4`). El proceso Emacs existente es el servidor; cuando salga de Emacs, el servidor morirá con el proceso Emacs. * Ejecute Emacs como *demonio*, usando una de las opciones de línea de comandos ``--daemon``. Ver :ref:`C.2`. Cuando Emacs se inicia de esta forma, llama a ``server-start`` después de la inicialización y no abre un marco inicial. Entonces espera las peticiones de edición de los clientes. * Ejecute el comando ``emacsclient`` con la opción de línea de comandos ``--alternate-editor=""``. Esto inicia un demonio Emacs sólo si no hay ningún demonio Emacs en ejecución. * Si su sistema operativo utiliza systemd para gestionar el arranque, puede iniciar automáticamente Emacs en modo demonio cuando inicie sesión utilizando el archivo de *unidad de proceso systemd* suministrado. Para activarlo: :: systemctl --user enable emacs (Si su Emacs se instaló en una ubicación no estándar, puede que tenga que copiar el archivo ``emacs.service`` a un directorio estándar como ``~/.config/systemd/user/``). * Un proceso externo puede invocar al servidor Emacs cuando se produce un evento de conexión sobre un socket especificado y pasar el socket al nuevo proceso del servidor Emacs. Un ejemplo de esto es la funcionalidad de socket de ``systemd``: el servicio ``systemd`` crea un socket y escucha conexiones en él; cuando ``emacsclient`` se conecta a él por primera vez, ``systemd`` puede lanzar el servidor Emacs y pasarle el socket para que atienda las conexiones de ``emacsclient``. Una configuración para usar esta funcionalidad podría ser: ``~/.config/systemd/user/emacs.socket:`` :: [Socket] ListenStream=/path/to/.emacs.socket DirectoryMode=0700 [Install] WantedBy=sockets.target (El fichero ``emacs.service`` descrito anteriormente también debe estar instalado). La ruta ``ListenStream`` será la ruta en la que Emacs escucha las conexiones desde ``emacsclient``; es un archivo de su elección. Una vez iniciado un servidor Emacs, puedes usar un comando de shell llamado ``emacsclient`` para conectar con el proceso Emacs y decirle que visite un archivo. A continuación, puede establecer la variable de entorno ``EDITOR`` en ``emacsclient``, de modo que los programas externos utilicen el proceso Emacs existente para la edición. [23]_ Puede ejecutar múltiples servidores Emacs en la misma máquina dando a cada uno un nombre de servidor único, usando la variable *nombre-servidor*. Por ejemplo, ``M-x set-variable RET`` *nombre-servidor* ``RET`` *foo* ``RET`` establece el nombre del servidor a *foo*. El programa ``emacsclient`` puede especificar un servidor por nombre, usando la opción ``-s`` o ``-f`` (ver :ref:`40.3`), dependiendo de si el servidor usa o no un socket TCP (ver :ref:`40.1`). Si quiere ejecutar múltiples demonios Emacs (vea :ref:`C.2`), puede dar a cada demonio su propio nombre de servidor de esta forma: :: emacs --daemon=foo Opcionalmente, el servidor Emacs puede detenerse automáticamente cuando se cumplen ciertas condiciones. Para hacer esto, llama a la función ``server-stop-automatically`` en su archivo init (ver :ref:`50.4`), con uno de los siguientes argumentos: * Con el argumento ``empty``, el servidor se detiene cuando ya no tiene clientes, ni búferes de visita de archivos sin guardar, ni procesos en ejecución. * Con el argumento ``delete-frame``, cuando se está cerrando la última trama de cliente, se pregunta si se debe guardar cada búfer de visita de archivo no guardado y si se puede detener cada proceso no finalizado, y en caso afirmativo, se detiene el servidor. * Con el argumento ``kill-terminal``, cuando se cierra la última trama de cliente con ``C-x C-c`` (``save-buffers-kill-terminal``), se pregunta si se debe guardar cada búfer visitante de fichero no guardado y si se puede detener cada proceso no finalizado, y en caso afirmativo, se detiene el servidor. Si ha definido un servidor con un nombre de servidor único, es posible conectarse al servidor desde otra instancia de Emacs y evaluar expresiones Lisp en él, usando la función ``server-eval-at``. Por ejemplo, (``server-eval-at`` *foo* ``'(+ 1 2)``) evalúa la expresión ``(+ 1 2)`` en el servidor *foo*, y devuelve ``3``. (Si no hay ningún servidor con ese nombre, se indica un error.) Actualmente, esta función es útil sobre todo para desarrolladores. Si el entorno de escritorio de su sistema operativo es compatible con `freedesktop.org `_ (que es el caso de la mayoría de GNU/Linux y otras GUIs recientes tipo Unix), puede usar la entrada de menú ``Emacs (Cliente)`` para conectarse a un servidor Emacs con ``emacsclient``. El demonio se inicia si no se está ejecutando ya. .. [23] Algunos programas utilizan una variable de entorno diferente; por ejemplo, para que TeX utilice ``emacsclient``, establezca la variable de entorno ``TEXEDIT`` en ``emacsclient +%d %s``. .. _40.1: 40.1 Servidor TCP Emacs ----------------------- Un servidor Emacs normalmente escucha conexiones en un socket local de dominio Unix. Algunos sistemas operativos, como MS-Windows, no soportan sockets locales; en ese caso, el servidor usa sockets TCP en su lugar. En algunos casos es útil que el servidor escuche en un socket TCP incluso si soporta sockets locales, por ejemplo, si necesita contactar con el servidor Emacs desde una máquina remota. Puede establecer ``server-use-tcp`` a no ``nil`` para que Emacs escuche en un socket TCP en lugar de un socket local. Este es el valor por defecto si su sistema operativo no soporta sockets locales. Si el servidor Emacs está configurado para usar TCP, escuchará por defecto en un puerto aleatorio de la interfaz localhost. Esto puede cambiarse a otra interfaz y/o a un puerto fijo usando las variables ``server-host`` y ``server-port``. Un socket TCP no está sujeto a los permisos del sistema de archivos. Para mantener cierto control sobre qué Usuarios pueden hablar con un servidor Emacs a través de sockets TCP, el programa ``emacsclient`` debe enviar una clave de autorización al servidor. Esta clave es normalmente generada aleatoriamente por el servidor Emacs. Este es el modo de operación recomendado. Si es necesario, puede establecer la clave de autorización a un valor estático estableciendo la variable ``server-auth-key``. La clave debe consistir en 64 caracteres ASCII imprimibles excepto el espacio (esto significa caracteres desde ``!`` hasta ``~``, o desde el código decimal 33 hasta el 126). Puede utilizar ``M-x server-generate-key`` para obtener una clave aleatoria. Cuando se inicia un servidor TCP Emacs, éste crea un *fichero de servidor* que contiene la información TCP que usará ``emacsclient`` para conectarse al servidor. La variable ``server-auth-dir`` especifica el directorio por defecto que contiene el archivo del servidor; por defecto, es ``~/.emacs.d/server/``. En ausencia de un socket local con permisos de archivo, los permisos de este directorio determinan qué Usuarios pueden hacer que sus procesos ``emacsclient`` hablen con el servidor Emacs. Si *nombre-servidor* es un nombre de fichero absoluto, este se creara donde especifique dicho nombre de archivo. Para decirle a ``emacsclient`` que se conecte al servidor sobre TCP con un fichero servidor específico, use la opción ``-f`` o ``--server-file``, o establezca la variable de entorno ``EMACS_SERVER_FILE`` (vea :ref:`40.3`). Si ``server-auth-dir`` se establece a un valor no estándar, o si ``server-name`` se establece a un nombre de archivo absoluto, ``emacsclient`` necesita un nombre de archivo absoluto para el archivo del servidor, ya que el ``server-auth-dir`` por defecto está codificado en ``emacsclient`` para ser usado como el directorio para resolver nombres de archivo relativos. 40.2 Ejecutar emacsclient ------------------------- La forma más sencilla de usar el programa ``emacsclient`` es ejecutar el comando de shell ``emacsclient archivo``, donde *archivo* es un nombre de archivo. Esto se conecta a un servidor Emacs, y le dice a ese proceso Emacs que visite *archivo* en uno de sus marcos existentes, ya sea un marco gráfico, o uno en un terminal de texto (ver :ref:`22`). Entonces puede seleccionar ese marco para empezar a editar. Si no hay servidor Emacs, el programa ``emacsclient`` se detiene con un mensaje de error ( puede evitar que esto ocurra usando la opción ``--alternate-editor=""`` de ``emacsclient``, vea :ref:`40.3`). Si el proceso Emacs no tiene ningún marco existente, lo que puede ocurrir si se inició como demonio (ver :ref:`40`) entonces Emacs abre un marco en el terminal en el que llamó a ``emacsclient``. También puede forzar a ``emacsclient`` a abrir un nuevo marco en una pantalla gráfica usando la opción ``-c``, o en una terminal de texto usando la opción ``-t``. Ver :ref:`40.3`. Si está ejecutando en un único terminal de texto, puede cambiar entre el shell de ``emacsclient`` y el servidor Emacs usando uno de dos métodos: (i) ejecuta el servidor Emacs y ``emacsclient`` en diferentes terminales virtuales, y cambia al terminal virtual del servidor Emacs después de llamar a ``emacsclient``; o (ii) llama a ``emacsclient`` desde dentro del propio servidor Emacs, usando el modo Shell (ver :ref:`39.2`) o el modo Term (ver Modo Term); ``emacsclient`` bloquea sólo el subshell bajo Emacs, y puede seguir usando Emacs para editar el archivo. Cuando termine de editar el archivo en el servidor Emacs, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`#` (``C-x #``, ``server-edit``) en su buffer. Esto guarda el archivo y envía un mensaje de vuelta al programa ``emacsclient``, diciéndole que salga. Los programas que usan ``EDITOR`` normalmente esperan a que el editor -en este caso ``emacsclient``- salga antes de hacer otra cosa. Si desea abandonar la edición, utilice el comando ``M-x server-edit-abort``. Esto envía un mensaje de vuelta al programa ``emacsclient``, diciéndole que salga con un estado de salida anormal, y no guarda ningún búfer. También puede llamar a ``emacsclient`` con múltiples argumentos de nombre de archivo: ``emacsclient archivo1 archivo2 ...`` le dice al servidor Emacs que visite *archivo1*, *archivo2*, y así sucesivamente. Emacs selecciona el búfer que visita *archivo1*, y entierra los otros búferes al final de la lista de búferes (ver :ref:`20`). El programa ``emacsclient`` sale una vez que todos los ficheros especificados han terminado (es decir, una vez que se haya tecleado :kbd:`Ctrl`-:kbd:`x` :kbd:`#` (``C-x #``) en cada búfer del servidor). Terminar con un buffer del servidor también mata el buffer, a menos que ya existiera en la sesión de Emacs antes de que se pidiera al servidor que lo creara. Sin embargo, si establece ``server-kill-new-buffers`` a ``nil``, entonces se usa un criterio diferente: terminar con un búfer del servidor lo mata si el nombre del fichero coincide con la expresión regular ``server-temp-file-regexp``. Esto se hace para distinguir ciertos archivos temporales. Cada ``C-x #`` comprueba si hay otras peticiones externas pendientes para editar varios archivos, y selecciona el siguiente archivo de este tipo. Puede cambiar a un buffer de servidor manualmente si lo desea; no tiene que llegar a él con ``C-x #``. Pero ``C-x #`` es la forma de decirle a ``emacsclient`` que ha terminado. Si establece el valor de la variable ``server-window`` a una ventana o a un marco, ``C-x #`` siempre muestra el siguiente búfer del servidor en esa ventana o en ese marco. Cuando ``emacsclient`` se conecta, el servidor normalmente mostrará un mensaje que dice como salir del frame cliente. Si ``server-client-instructions`` se establece a ``nil``, este kmensaje se inhibe. .. _40.3: 40.3 Opciones de emacsclient ---------------------------- Puede pasar algunos argumentos opcionales al programa ``emacsclient``, como: :: emacsclient -c +12 arhivo1 +4:3 arhivo2 Los argumentos ``+línea`` o ``+línea:columna`` especifican números de línea, o números de línea y columna, para el siguiente argumento de archivo. Se comportan como los argumentos de línea de comandos del propio Emacs. Ver :ref:`C.4.1`. Los otros argumentos opcionales reconocidos por ``emacsclient`` se listan a continuación: | ``-a comando`` | ``--alternate-editor=comando`` Especifica un comando shell a ejecutar si ``emacsclient`` falla al contactar con Emacs. Esto es útil cuando se ejecuta ``emacsclient`` en un script. El comando puede incluir argumentos, que pueden ser entrecomillados "así". Actualmente, no es posible escapar las comillas. Como excepción especial, si *comando* es la cadena vacía, entonces *emacsclient* inicia Emacs en modo demonio (como ``emacs --daemon``) y luego intenta conectarse de nuevo. La variable de entorno ``ALTERNATE_EDITOR (EDITOR_ALTERNO)`` tiene el mismo efecto que la opción ``-a``. Si ambas están presentes, la segunda tiene prioridad. | ``-c`` | ``--create-frame`` Crea un nuevo *marco gráfico cliente*, en lugar de usar un marco Emacs existente. Ver más abajo el comportamiento especial de ``C-x C-c`` en un marco cliente. Si Emacs no puede crear un nuevo marco gráfico (por ejemplo, si no puede conectarse al servidor X), intenta crear un marco de cliente de terminal de texto, como si hubiera especificado la opción ``-t`` en su lugar. En MS-Windows, una única sesión de Emacs no puede mostrar marcos tanto en terminales gráficos como de texto, ni en múltiples terminales de texto. Por lo tanto, si el servidor Emacs se está ejecutando en un terminal de texto, la opción ``-c``, al igual que la opción ``-t``, crea un nuevo marco en el terminal de texto actual del servidor. Ver `Cómo Arrancar Emacs en MS-Windows `_. Si omite un argumento de nombre de archivo al suministrar la opción ``-c``, el nuevo marco muestra el buffer ``*scratch*`` por defecto. Puede personalizar este comportamiento con la variable ``initial-buffer-choice`` (vea :ref:`6`). | ``-r`` | ``--reuse-frame`` Crea un nuevo marco gráfico de cliente si no existe, en caso contrario utiliza un marco Emacs existente. | ``-F alist`` | ``--frame-parameters=alist`` Configura los parámetros de un marco gráfico recién creado (véase :ref:`22.11`). | ``-d display`` | ``--display=pantalla`` Indica a Emacs que abra los archivos dados en la pantalla X (suponiendo que haya más de una pantalla X disponible). | ``-e`` | ``--eval`` Le dice a Emacs que evalúe algún código Emacs Lisp, en lugar de visitar algunos archivos. Cuando se da esta opción, los argumentos a ``emacsclient`` se interpretan como una lista de expresiones a evaluar, no como una lista de archivos a visitar. | ``-f servidor-arhivo`` | ``--server-file=servidor-arhivo`` Especifica un archivo de servidor (ver :ref:`40.1`) para conectarse a un servidor Emacs vía TCP. Alternativamente, puede establecer la variable de entorno ``EMACS_SERVER_FILE`` para que apunte al fichero del servidor. (La opción de la línea de comandos anula la variable de entorno). Un servidor Emacs normalmente usa un socket local para escuchar conexiones, pero también soporta conexiones sobre TCP. Para conectarse a un servidor Emacs TCP, ``emacsclient`` necesita leer un *archivo de servidor* que contenga los detalles de conexión del servidor Emacs. El nombre de este fichero se especifica con esta opción, bien como un nombre de archivo relativo a ``~/.emacs.d/servidor`` o como un nombre de archivo absoluto. Véase :ref:`40.1`. | ``-n`` | ``--no-wait`` Deja que ``emacsclient`` salga inmediatamente, en lugar de esperar hasta que todos los búferes del servidor hayan terminado. Puede tomarse todo el tiempo que quiera para editar los búferes del servidor dentro de Emacs, y no son matados cuando escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`#` (``C-x #``) en ellos. | ``-w`` | ``--timeout=N`` Espera una respuesta de Emacs durante *N* segundos antes de abandonar. Si no hay respuesta en ese tiempo, ``emacsclient`` mostrará una advertencia y saldrá. El valor por defecto es ``0``, que significa esperar indefinidamente. ``--parent-id=id`` Permite abrir un marco ``emacsclient`` como marco cliente en la ventana X padre con número de identificador *id*, a través del protocolo XEmbed. Actualmente, esta opción es útil principalmente para desarrolladores. | ``-q`` | ``--quiet`` No permite que emacsclient muestre mensajes sobre la espera de Emacs o la conexión a sockets de servidores remotos. | ``-u`` | ``--suppress-output`` No permite que ``emacsclient`` muestre los resultados devueltos por el servidor. Muy útil en combinación con ``-e`` cuando la evaluación realizada es de efecto secundario en lugar de resultado. | ``-s nombre-servidor`` | ``--socket-name=nombre-servidor`` Conecta con el servidor Emacs llamado *nombre-servidor*. (Esta opción no está soportada en MS-Windows.) El nombre del servidor viene dado por la variable nombre-servidor en el servidor Emacs. Si se omite esta opción, emacsclient se conecta al socket por defecto. Si establece *nombre-servidor* del servidor Emacs a un nombre de fichero absoluto, dé el mismo nombre de archivo absoluto que *nombre-servidor* a esta opción para indicar a emacsclient que se conecte a ese servidor. Necesita usar esta opción si inició Emacs como demonio (vea :ref:`C.2`) y especificó el nombre para el servidor iniciado por el demonio. Alternativamente, puede establecer la variable de entorno ``EMACS_SOCKET_NAME`` para que apunte al socket del servidor. (La opción de línea de comandos anula la variable de entorno). | ``-t`` | ``--tty`` | ``-nw`` Crea un nuevo marco de cliente en el terminal de texto actual, en lugar de utilizar un marco Emacs existente. Esto se comporta igual que la opción ``-c``, descrita anteriormente, excepto que crea un marco de terminal de texto (ver :ref:`22.21`). En MS-Windows, ``-t`` se comporta igual que ``-c`` si el servidor Emacs está usando la pantalla gráfica, pero si el servidor Emacs se está ejecutando en un terminal de texto, crea un nuevo marco en el terminal de texto actual. | ``-T tramp-prefix`` | ``--tramp-prefix=tramp-prefix`` Establece el prefijo a añadir a los nombres de fichero para que Emacs localice ficheros en máquinas remotas (ver :ref:`19.5`) usando TRAMP (ver `El Manual de Tramp `_). Esto es sobre todo útil en combinación con el uso del servidor Emacs sobre TCP (ver :ref:`40.1`). Reenviando por ssh el puerto de escucha y haciendo que *archivo-servidor* esté disponible en una máquina remota, los programas en la máquina remota pueden usar emacsclient como valor para las variables de entorno EDITOR y similares, pero en lugar de hablar con un servidor Emacs en la máquina remota, los archivos serán visitados en la sesión Emacs local usando TRAMP. Establecer la variable de entorno ``EMACSCLIENT_TRAMP`` tiene el mismo efecto que usar la opción ``-T``. Si se especifican ambas, la opción de la línea de comandos tiene preferencia. Por ejemplo, asume dos hosts, ``local`` y ``remoto``, y que el Emacs local escucha en el puerto tcp 12345. Supongamos además que ``/home`` está en un sistema de ficheros compartido, de modo que el fichero del servidor ``~/.emacs.d/server/server`` es legible en ambos hosts. :: local$ ssh -R12345:localhost:12345 remot0 remote$ export EDITOR="emacsclient \ --server-file=servidor \ --tramp=/ssh:remoto:" remote$ $EDITOR /tmp/foo.txt #Debería abrirse en emacs local. Los nuevos marcos de terminal gráficos o de texto creados por las opciones ``-c`` o ``-t`` se consideran marcos de cliente. Cualquier nuevo marco que cree a partir de un marco de cliente también se considera un marco de cliente. Si escribe :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`c` (``C-x C-c``, ``save-buffers-kill-terminal``) en un marco de cliente, ese comando no mata la sesión de Emacs como hace normalmente (ver :ref:`7`). En su lugar, Emacs borra el marco del cliente; además, si el marco del cliente tiene un ``emacsclient`` esperando para recuperar el control (es decir, si no proporcionó la opción ``-n``), Emacs borra todos los demás marcos del mismo cliente, y marca los buffers del servidor del cliente como terminados, como si hubiera tecleado :kbd:`Ctrl`-:kbd:`x` :kbd:`#` (``C-x #``) en todos ellos. Si resulta que no quedan marcos después de borrar el marco o marcos del cliente, la sesión de Emacs finaliza. Como excepción, cuando Emacs se inicia como demonio, todos los marcos se consideran marcos cliente, y ``C-x C-c`` nunca mata Emacs. Para matar un demonio de sesión, teclee :kbd:`Alt`-:kbd:`x` ``kill-emacs`` (``M-x kill-emacs``). Tenga en cuenta que las opciones ``-t`` y ``-n`` son contradictorias: ``-t`` dice que tome el control del terminal de texto actual para crear una nueva trama cliente, mientras que ``-n`` dice que no tome el control del terminal de texto. Si proporciona ambas opciones, Emacs visita los archivos especificados en un marco existente en lugar de un nuevo marco de cliente, anulando el efecto de ``-t``.