Come portare .vimrc in giro quando SSH?

Il mio lavoro tende a coinvolgere l'uso di SSH per connettersi a vari computer e quindi utilizzare vim per modificare i file su tali computer. Il problema è che devo costantemente copiare il mio file .vimrc. È molto fastidioso aprire vim e non avere alcuna impostazione. È possibile portare con me le mie impostazioni vim da una macchina all'altra senza copiarle manualmente ovunque?

Condivido il tuo dolore. Ho tutti i miei file ~ /.* rc sotto controllo versione (Subversion), ha funzionato benissimo da quando ho iniziato nel 1998, usando CVS. Un modo per farlo è controllare tutti i tuoi file rc in questo modo quando ti trovi nella tua home directory:

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.

In questo modo i file di configurazione verranno anche sincronizzati e aggiornati sui vari computer quando si esegue svn update.

Invece di portare .vimrc su ogni server su cui devi lavorare, perché non modificare i file remoti dal tuo vim locale:

In vim / gvim, esegui:

:e scp://remoteuser@server.tld//path/to/document

o avvia vim in questo modo:

vim scp://remoteuser@server.tld//path/to/document

Questo apre il file in modo accattivante sul posto (in realtà copia il file localmente) e quando lo salvi, invia il file modificato al server per te.

Richiede una password SSH, ma può essere semplificata tramite i tasti SSH.

Come altri hanno già detto, l'unico inconveniente di questo metodo è che non si ottiene la competizione percorso / file come si farebbe quando si lavora direttamente sulla macchina.

Per maggiori informazioni, consulta il seguente tutorial .

Puoi creare uno script bash per copiarlo automaticamente ogni volta che accedi, in questo modo:

#!/usr/bin/env bash

scp ~/.vimrc $1:
ssh $1

Puoi chiamarlo ssh_vim, per esempio. Non è una soluzione ideale ma risolverà il tuo problema.

Puoi migliorarlo per verificare prima se c'è già. Se non si esegue sempre ssh dalla stessa macchina, è possibile modificare lo script per ottenere il file da scp da un'altra macchina.

EDIT1

In una nota correlata, è anche possibile montare il filesystem della macchina remota con sshfs. In questo modo beneficiate del vostro ambiente e dei vostri strumenti (non solo .vimrc) e ottenete il completamento della shell (che non avete usando scp: //).

EDIT2

Ho appena scoperto che puoi trovare il tuo file .vimrc usando scp: //, in questo modo:

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

Funziona dalla riga di comando di vim ma al momento non so come automatizzarlo. Non sembra funzionare né con l'opzione '-u' né con .vimrc né con $ VIMINIT.

Edit3

L'ho trovato! Puoi farlo per iniziare vim con un .vimrc preso dal tuo host di riferimento:

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

L'opzione '-c' esegue il comando subito dopo aver avviato vim.

È possibile creare un alias nella shell scelta per evitare di digitare. In bash sarebbe così:

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

Se stai utilizzando l'autenticazione con chiave pubblica, puoi utilizzarla nel tuo ~/.ssh/config:

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

Mi piace meglio del trucco di script suggerito sopra poiché non disturba l'invocazione del sshcomando (quando si specificano parametri aggiuntivi, ecc.)

Un paio di soluzioni:

1) Creare una condivisione NFS per la cartella principale e mapparla in più posizioni.

2) Crea un piccolo script per inviare il tuo .vimrc al server a cui ti stai connettendo con un file di identità / chiave. Potrebbe assomigliare a questo (pseudocodice):

connectString = arg0  #username@ipaddress

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

La stessa risposta esatta di sunny256, ma usa git invece di SubVersion.

Mantenere un ramo principale con i file comuni per tutti i computer e disporre di un ramo per ogni nuovo computer.

In questo modo puoi avere quasi gli stessi file sulla maggior parte dei computer e non diventare ancora confuso.

So che questo è un vecchio thread, ma un modo in cui lo faccio è usare sshfs che monta il file system su miccia. Il vim locale esegue tutte le modifiche, quindi non c'è motivo di copiare .vimrc.

Questo ha il rovescio della medaglia che un altro terminale dovrà essere aperto per tutti i comandi che devono essere eseguiti sul server remoto, ma per la modifica trovo in questo modo il migliore.

Ha anche l'ulteriore vantaggio di poter usare gli appunti di sistema.

Sto usando https://github.com/andsens/homeshick per gestire i miei dotfile e archiviarli su github.

Homeshick è scritto al 100% in bash e ti aiuta a gestire i "castelli" che sono solo repository git che contengono una directory / home /. Ha i comandi per spostare i file di punti esistenti nel repository e sostituirli con collegamenti simbolici. E per collegare simbolicamente tutti i file nel repository alla directory home su un nuovo computer.

Quindi l'idea generale è mantenere i tuoi dotfile in un sistema di controllo della versione e collegarli a loro dal percorso reale. In questo modo il repository non deve iniziare dalla directory principale e contenere un sacco di file che non si desidera aggiungere.

Se sei come me e hai molte macchine di sviluppo (anche macchine virtuali) per vari motivi, puoi combinare chiavi ssh, un bash_profile intelligente e un RCS di tua scelta.

Vorrei in secondo luogo usare nfs / samaba / sshfs. Uno svantaggio è se non si ha sempre accesso alla rete, quindi non è possibile accedere a ciò di cui si ha bisogno (volare, niente wifi, firewall, problemi di routing, ecc.). Le macchine che mantengo sincronizzate non sono tutte raggiungibili contemporaneamente, ma voglio condividere le informazioni tra loro.

Quello che segue è come l'ho preso in prestito molte idee da Internet.

.bash_profile potrebbe avere qualcosa del genere

$HOME/bin/shell_ssh_agent

L'ho preso da un paio di posti ma non riesco a trovare un link adesso. Il file 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

Ora al primo accesso hai impostato le tue chiavi. Disconnettersi e accedere e ha appena semplificato la vita.

Metti tutti i tuoi script in un RCS, questo rende più semplice la sincronizzazione delle macchine di sviluppo. Uso git. L'autenticazione con git avviene tramite ssh, quindi anche le chiavi ssh aiutano qui. Nota a questo punto avresti potuto usare qualcosa come nfs. Sarei ancora un fan di un RCS per un motivo che cito di seguito.

Il caso d'uso è

1. accedi la prima volta, le chiavi ottengono la configurazione
2. se RCS non è impostato, controlla i tuoi script personali (e aggiorna / unisci quando necessario, questo potrebbe anche far parte del tuo .bash_profile se lo desideri)
3. modifica vimrc, script speciali, ecc. e commettili
4. quando si accede ad altri computer, eseguire un aggiornamento / unione / checkout. Questo mantiene tutto sincronizzato; cioè non più copiando i file che a volte ti calpestano e non volevi.
5. come vantaggio laterale ottieni la potenza di un RCS. A volte apporto modifiche sfavorevoli a script o configurazioni e devo eseguire il rollback e simili.

Qualcosa che voglio provare dopo è racchiudere il login / setup iniziale in un makefile che copio sulla nuova macchina. Il makefile può quindi fare il lavoro di impostazione delle tue chiavi, RCS, ecc. Ovviamente c'è un sovraccarico qui, ma se finisci per configurare un sacco di macchine questo è:

1. un risparmio di tempo
2. più facile mantenere sincronizzate le configurazioni e gli script personali delle macchine di sviluppo
3. gestione delle modifiche a script e configurazioni.

Uso un makefile che ha un elenco di tutti i server a cui accedo e quando apporto una modifica sul mio computer locale, 'make' viene eseguito usando il makefile che aggiorna automaticamente tutti i server con eventuali modifiche o plugin

sshrc risolve questo problema. Metti il ​​tuo .vimrc in ~ / .sshrc.d / e poi aggiungi export VIMINIT="let \$MYVIMRC='$SSHHOME/.sshrc.d/.vimrc' | source \$MYVIMRC"a `/.sshrc.

Ho scritto un semplice strumento per questo che ti permetterà di trasportare in modo nativo il tuo file .vimrc ogni volta che usi SSH , usando le opzioni di configurazione incorporate di SSHd in un modo non standard.

Nessuna ulteriore svn, scp, copy/paste, ecc richiesto.

È semplice, leggero e funziona di default su tutte le configurazioni di server che ho testato finora.

https://github.com/gWOLF3/viSSHous

Utilizzando la variabile VIMINIT:

export VIMINIT='set number'

e inoltrandolo al server remoto:

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

è facile usando .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'

Ora prova a eseguire vim sul server remoto usando sshh per la connessione:

sshh remoteuser@remoteserver

Se lo desideri Puoi portare i tuoi plugin anche sul server 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
}

Ho la stessa situazione, ma non è solo " .vimrc". Ho anche cose del genere

• bash configurazione, prompt e funzioni,
• file di configurazione e autorizzazione ssh,
• script di shell che mi piace avere a portata di mano.
• ovviamente il mio vimrc, ma anche alcune funzioni di vim e file di evidenziazione della sintassi.

La mia soluzione (iniziata 30 anni fa con "dist" in origine!) È quella di impostare un cron notturno per sincronizzare una configurazione domestica minima su tutte le macchine su cui lavoro, in modo che si aggiorni di notte.

In questo modo tutte le altre macchine con cui lavoro sono aggiornate! Posso semplicemente aggiungere una nuova macchina all'elenco "account" ed eseguire una distribuzione a macchina singola per avviarla.

Non deve essere molto, e puoi iniziare in piccolo e renderlo più complesso mentre procedi. Come puoi immaginare dopo 30 anni la mia distribuzione è ora piuttosto complessa, quindi non la inserirò qui. Inutile dire che fa anche cose come scambiare alcune configurazioni con altri per alcune reti, pulizia della casa (eg: cestino, file cache), assicurarsi che i permessi di casa siano tutti corretti, e così via.

NOTA Consento l'accesso ssh senza password da una macchina "domestica" a tutto il resto, mai più indietro! Qualsiasi cross ssh è protetto da password.

È possibile prendere in considerazione uno script EXPECT che consenta di impostare il percorso e l'ambiente (come le variabili EXRC) premendo un determinato tasto. Non dovrebbe passare troppo tempo prima che qualcuno pubblichi uno script simile.

Quando le tue server farm sono più di qualche decina (pensa a migliaia), avere qualcosa di facilmente configurabile in una scatola "vergine" è un vero salvavita

Spesso quando accedo a una scatola, crea il mio homedir per la prima volta!

È stato realizzato con il seguente basel oneliner. Poiché viene eseguito con Sostituzione processo, i file temporanei non vengono creati.

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