¿Cómo traer .vimrc cuando hago SSH?

Mi trabajo tiende a involucrar el uso de SSH para conectarse a varias máquinas, y luego usar vim para editar archivos en esas máquinas. El problema es que tengo que copiar constantemente mi archivo .vimrc. Es muy molesto abrir vim y no tener ninguna configuración. ¿Es posible llevar mi configuración de vim conmigo de máquina a máquina sin copiarla manualmente en todas partes?

Siento tu dolor. Tengo todos mis archivos ~ /.* rc bajo control de versiones (Subversion), ha funcionado muy bien desde que comencé en 1998, usando CVS. Una forma de hacerlo es revisar todos sus archivos rc como este cuando se encuentre en su directorio de inicio:

svn co svn+ssh://user@host/path/to/repo/trunk/home/user .
A    .signature
A    .vimrc
A    .bashrc
A    .screenrc
A    .psqlrc
[...]
Checked out revision 7645.

De esta forma, los archivos de configuración también se sincronizarán y actualizarán en las distintas computadoras cuando ejecute svn update.

En lugar de llevar .vimrc a cada servidor en el que necesita trabajar, ¿por qué no editar los archivos remotos desde su vim local?

En vim / gvim, ejecute:

:e scp://[email protected]//path/to/document

o comienza vim así:

vim scp://[email protected]//path/to/document

Esto abre el archivo en su lugar (en realidad copia el archivo localmente), y cuando guarda, envía el archivo editado de vuelta al servidor por usted.

Solicita una contraseña ssh, pero esta puede simplificarse mediante las teclas ssh.

Como otros han mencionado, el único inconveniente de este método es que no obtienes competencia de ruta / archivo como lo harías al trabajar directamente en la máquina.

Para obtener más información, consulte el siguiente tutorial .

Podrías hacer un script bash para copiarlo automáticamente cada vez que inicies sesión, así:

#!/usr/bin/env bash

scp ~/.vimrc $1:
ssh $1

Puede llamarlo ssh_vim, por ejemplo. No es una solución ideal, pero resolverá su problema.

Puede mejorarlo para verificar primero si ya existe. Si no siempre está ejecutando ssh desde la misma máquina, puede cambiar el script para obtener el archivo de scp desde otra máquina.

EDITAR1

En una nota relacionada, también puede montar el sistema de archivos de la máquina remota con sshfs. De esa manera, se beneficia de su entorno y herramientas (no solo .vimrc) y tiene finalización de shell (que no tiene usando scp: //).

EDIT2

Me acabo de enterar de que puedes obtener tu archivo .vimrc usando scp: //, así:

:source scp://you@your_computer//yourpath/.vimrc

Esto funciona desde la línea de comando vim pero por el momento no sé cómo automatizarlo. No parece funcionar ni con el modificador '-u' ni en el .vimrc ni con $ VIMINIT.

EDITAR3

¡Lo encontré! Puede hacer esto para iniciar vim con un .vimrc tomado de su host de referencia:

vim -c ':source scp://you@your_computer//yourpath/.vimrc'

La opción '-c' ejecuta el comando justo después de iniciar vim.

Puede crear un alias en su shell de elección para evitar escribir. En bash sería así:

alias vim="vim -c ':source scp://you@your_computer//yourpath/.vimrc'"

Si está utilizando la autenticación de clave pública, puede usar esto en su ~/.ssh/config:

Host *
   PermitLocalCommand yes
   LocalCommand bash -c 'scp -P %p %d/.vimrc %u@%n: &>/dev/null &'

Me gusta más que el truco de script sugerido anteriormente, ya que no interfiere con la invocación del sshcomando (al especificar parámetros adicionales, etc.)

Un par de soluciones:

1) Cree un recurso compartido NFS para su carpeta de inicio y asígnelo en varias ubicaciones.

2) Cree un pequeño script para empujar su .vimrc al servidor al que se está conectando con un archivo de identidad / clave. Podría verse más o menos así (pseudocódigo):

connectString = arg0  #username@ipaddress

scp -i ~/.ssh/indentity connectString:~/ ~/.vimrc
ssh -i ~/.ssh/indentity connectString

Exactamente la misma respuesta que sunny256, pero usa git en lugar de SubVersion.

Mantenga una rama principal con los archivos que es común para todas las computadoras, y tenga una rama para cada computadora nueva.

De esa manera, puede tener casi los mismos archivos en la mayoría de las computadoras, y aún no confundirse.

Sé que este es un hilo antiguo, pero una forma de hacerlo es usar sshfs que monta el sistema de archivos sobre el fusible. El vim local hace toda la edición, por lo que no hay razón para copiar .vimrc.

Esto tiene el inconveniente de que tendrá que abrir otro terminal para cualquier comando que deba ejecutarse en el servidor remoto, pero para la edición, encuentro lo mejor.

También tiene la ventaja adicional de poder usar el portapapeles del sistema.

Estoy usando https://github.com/andsens/homeshick para administrar mis archivos de puntos y almacenarlos en github.

Homeshick está escrito en 100% bash y te ayuda a administrar "castillos" que son solo repositorios git que contienen un directorio / home /. Tiene comandos para mover archivos de puntos existentes al repositorio y reemplazarlos con enlaces simbólicos. Y para vincular todos los archivos en el repositorio a su directorio de inicio en una nueva máquina.

Entonces, la idea general es mantener sus archivos de puntos en un sistema de control de versiones y vincularlos desde la ruta real. De esta manera, su repositorio no necesita comenzar desde su directorio de inicio y contener una tonelada de archivos que nunca desea agregar.

Si es como yo y tiene muchas máquinas de desarrollo (máquinas virtuales también) por varias razones, puede combinar claves ssh, un bash_profile inteligente y un RCS de su elección.

En segundo lugar, usaría nfs / samaba / sshfs. Una desventaja es que si no tiene acceso a la red todo el tiempo, entonces no puede acceder a lo que necesita (volar, sin wifi, firewalls, problemas de enrutamiento, etc.). No todas las máquinas que mantengo sincronizadas son accesibles al mismo tiempo, pero quiero compartir información entre ellas.

Lo siguiente es cómo lo hice tomando prestadas muchas ideas de Internet.

.bash_profile podría tener algo como esto

$HOME/bin/shell_ssh_agent

Obtuve esto de un par de lugares, pero ahora no puedo encontrar un enlace. El archivo shell_ssh_agent:

#!/bin/bash

SSH_ENV=$HOME/.ssh/environment

#echo "starting"

function start_agent {
    #echo "reaping agents"
    killall ssh-agent
    #echo "Initialising new SSH agent..."
    /usr/bin/ssh-agent | sed 's/^echo/#echo/' > ${SSH_ENV}
    #echo succeeded
    chmod 600 ${SSH_ENV}
    . ${SSH_ENV}
    /usr/bin/ssh-add;
}

# Source SSH settings, if applicable

if [ -f "${SSH_ENV}" ]; then
    . ${SSH_ENV}
    #echo "sourced ssh env"
    ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent > /dev/null || { start_agent; }
else
    start_agent;
fi

Ahora, en el primer inicio de sesión, configura sus claves. Salga y entre y simplemente le hizo la vida más fácil.

Ponga todos sus scripts en un RCS, esto hace que mantener las máquinas de desarrollo sincronizadas sea más fácil. Yo uso git. La autenticación con git es a través de ssh, por lo que las teclas ssh también ayudan aquí. Tenga en cuenta en este punto que podría haber usado algo como nfs. Todavía sería fanático de un RCS por una razón que menciono a continuación.

El caso de uso es

1. iniciar sesión por primera vez, las teclas se configuran
2. si RCS no está configurado, revise sus scripts personales (y actualice / combine cuando sea necesario, esto incluso podría ser parte de su .bash_profile si lo desea)
3. editar vimrc, scripts especiales, etc. y confirmarlos
4. cuando inicie sesión en otras máquinas, realice una actualización / fusión / pago. Esto mantiene todo sincronizado; es decir, no más copias de archivos que a veces pisoteas y no quieres.
5. como beneficio adicional obtienes el poder de un RCS. A veces hago cambios desfavorables en los scripts o configuraciones y necesito retroceder y cosas similares.

Algo que quiero probar a continuación es envolver el inicio de sesión / configuración inicial en un archivo MAKE que copio a la nueva máquina. El archivo MAKE puede hacer el trabajo de configurar sus claves, RCS, etc. Obviamente, hay algunos gastos generales aquí, pero si termina configurando muchas máquinas, esto es:

1. un ahorro de tiempo
2. es más fácil mantener sincronizadas las configuraciones y los scripts personales de las máquinas de desarrollo
3. gestión de cambios en scripts y configuraciones.

Utilizo un archivo MAKE que tiene una lista de todos los servidores en los que inicio sesión y cuando hago un cambio en mi máquina local, 'make' se ejecuta usando el archivo MAKE automáticamente, que actualiza todos los servidores con cualquier cambio o complemento

sshrc resuelve este problema. Pones tu .vimrc en ~ / .sshrc.d / y luego lo agregas export VIMINIT="let \$MYVIMRC='$SSHHOME/.sshrc.d/.vimrc' | source \$MYVIMRC"a `/.sshrc.

Escribí una herramienta simple para esto que le permitirá transportar de forma nativa su archivo .vimrc cada vez que ssh , utilizando las opciones de configuración incorporadas SSHd de una manera no estándar.

Sin adicional svn, scp, copy/paste, etc necesaria.

Es simple, liviano y funciona de manera predeterminada en todas las configuraciones de servidor que he probado hasta ahora.

https://github.com/gWOLF3/viSSHous

Usando la variable VIMINIT:

export VIMINIT='set number'

y reenviarlo al servidor remoto:

ssh remoteuser@remoteserver -o SendEnv=LC_VIMINIT -t 'export VIMINIT=$LC_VIMINIT && bash'

es fácil usar .bash_profiles o .bashrc

export VIMINIT='
set number
'

export LC_VIMINIT=$VIMINIT

sshh (){
ssh -o SendEnv=LC_VIMINIT $1 -t 'export VIMINIT=$LC_VIMINIT && bash'

Ahora intente ejecutar vim en el servidor remoto usando sshh para la conexión:

sshh remoteuser@remoteserver

Si lo desea, también puede llevar sus complementos al servidor remoto:

export LC_VIMINIT="
set number
set nocompatible
filetype off
set rtp+=~/.[USER]_vim/bundle/Vundle.vim
call vundle#begin()
Plugin 'VundleVim/Vundle.vim'


set shell=/bin/bash
call vundle#end()
filetype plugin indent on
"

export VIMINIT=$LC_VIMINIT

sshh (){
        if [[ $1 ]]; then
                ssh-copy-id $1 &>/dev/null &&
                rsync -lzr --partial --del ~/.[USER]_vim ${1}: &&
                ssh -o SendEnv=LC_VIMINIT $1 -t 'export VIMINIT=$LC_VIMINIT && bash';
        else
                echo "Provide remote user@host";
        fi
}

Tengo la misma situación, pero no es solo " .vimrc". También tengo cosas como

• configuración de bash, avisos y funciones,
• configuración ssh y archivos de autorización,
• guiones de shell que me gusta tener a mano.
• por supuesto mi vimrc, pero también algunas funciones vim y archivos de resaltado de sintaxis.

Mi solución (¡comencé hace 30 años con "dist" originalmente!) Es configurar un cron nocturno para rsync una configuración doméstica mínima para todas las máquinas en las que trabajo, para que se actualice todas las noches.

De esa manera, todas las otras máquinas con las que trabajo se mantienen actualizadas. Simplemente puedo agregar una nueva máquina a la lista de 'cuentas' y hacer una distribución de una sola máquina para comenzar.

No necesita ser mucho, y puede comenzar con poco y hacerlo más complejo a medida que avanza. Como puede imaginar después de 30 años, mi distribución ahora es bastante compleja, por lo que no la pondré aquí. Huelga decir que también hace cosas como cambiar algunas configuraciones por otras para algunas redes, limpieza del hogar (por ejemplo, basura, archivos de caché), garantizar que los permisos del hogar sean correctos, etc.

NOTA: Solo permito el inicio de sesión ssh sin contraseña desde una máquina 'doméstica' al resto, ¡nunca más vuelvo! Cualquier cross ssh está protegido por contraseña.

Puede considerar un script EXPECT que le permita establecer su ruta y entorno (como las variables EXRC) al presionar una determinada tecla. No debería pasar mucho tiempo antes de que alguien publique un script similar.

Cuando las granjas de servidores suman más de unas pocas docenas (piense en miles), tener algo fácilmente configurado su entorno en una caja 'virgen' es un verdadero salvavidas

A menudo, cuando inicio sesión en un cuadro, ¡crea mi homedir por primera vez!

Se realizó con el siguiente golpe de línea. Como se hace con la sustitución de procesos, no se crean archivos temporales.

ssh -t user@host '
bash --rcfile <(
    echo -e ' $(cat <(echo "function lvim() { vim -u <(echo "$(cat ~/.vimrc|base64)"|base64 -d) \$@ ; }") \
                    ~/dotfiles/{.bashrc,sh_function,sh_alias,bash_prompt} \
                    <(echo -e alias vim=lvim) | \
                    base64 
               ) ' \
    |base64 -d)'

https://gist.github.com/blacknon/a47083f3bbbd0374998bdf7e3b3396cc