Trabaja en un proyecto remoto con Eclipse a través de SSH

Tengo los siguientes cuadros:

1. Un cuadro de Windows con Eclipse CDT,
2. Una caja de Linux, accesible solo para mí a través de SSH.

Tanto el compilador como el hardware necesarios para compilar y ejecutar mi proyecto solo se encuentran en la máquina B.

Me gustaría trabajar "transparentemente" desde un cuadro de Windows en ese proyecto usando Eclipse CDT y poder construir, ejecutar y depurar el proyecto de forma remota desde el IDE.

¿Cómo configuro eso?

• El edificio funcionará? ¿Alguna solución más simple que escribir un archivo MAKE local que haría rsyncel proyecto y luego llamar a un archivo MAKE remoto para iniciar la compilación real? ¿Eclipse gestionó la compilación tiene una característica para eso?
• ¿La depuración funcionará?
• Preferiblemente, ¿funcionará la indexación del código CDT de Eclipse? ¿Tengo que copiar todos los archivos de encabezado necesarios de la máquina B a la máquina A y agregarlos para incluir la ruta manualmente?

Pruebe el Explorador de sistema remoto (RSE). Es un conjunto de complementos para hacer exactamente lo que quieres.

Es posible que RSE ya esté incluido en su instalación actual de Eclipse. Para registrarse en Eclipse Indigo, vaya a Ventana > Abrir perspectiva > Otro ... y elija Explorador de sistema remoto en el cuadro de diálogo Abrir perspectiva para abrir la perspectiva RSE.

Para crear un proyecto remoto SSH desde la perspectiva RSE en Eclipse:

1. Defina una nueva conexión y elija SSH solo en la pantalla Seleccionar tipo de sistema remoto en el cuadro de diálogo Nueva conexión.
2. Ingrese la información de conexión y luego elija Finalizar.
3. Conéctese al nuevo host. (Asume que las claves SSH ya están configuradas).
4. Una vez conectado, profundice en los archivos Sftp del host , elija una carpeta y seleccione Crear proyecto remoto en el menú contextual del elemento. (Espere mientras se crea el proyecto remoto).

Si se hace correctamente, ahora debería haber un nuevo proyecto remoto accesible desde el Explorador de proyectos y otras perspectivas dentro de eclipse. Con la configuración de la conexión SSH correctamente, las contraseñas pueden convertirse en una parte opcional del proceso normal de autenticación SSH. Ahora se crea un proyecto remoto con Eclipse a través de SSH.

La forma más sencilla sería ejecutar Eclipse CDT en Linux Box y usar X11-Forwarding o software de escritorio remoto como VNC.

Esto, por supuesto, solo es posible cuando Eclipse está presente en la caja de Linux y su conexión de red a la caja es lo suficientemente rápida.

La ventaja es que, debido a que todo es local, no tendrá problemas de sincronización y no tendrá problemas incómodos entre plataformas.

Si no tiene eclipse en la caja, podría pensar en compartir su directorio de trabajo de Linux a través de SMB (o SSHFS) y acceder a él desde su máquina Windows, pero eso requeriría bastante configuración.

Ambos serían mejores que tener dos copias, especialmente cuando es multiplataforma.

Estoy en el mismo lugar (o estaba), FWIW Terminé revisando un recurso compartido de samba en el host Linux y editando ese recurso compartido localmente en la máquina Windows con notepad ++, luego compilé en la caja de Linux a través de PuTTY. (No se nos permitió actualizar las versiones de diez años de los editores en el host de Linux y no tenía Java, así que renuncié al reenvío X11)

Ahora ... ejecuto Linux moderno en una VM en mi host de Windows, agrego todas las herramientas que quiero (por ejemplo, CDT) a la VM y luego pago y construyo en una cárcel chroot que se parece mucho al RTE.

Es una solución torpe, pero pensé en incluirla en la mezcla.

Mi solución es similar a la de SAMBA excepto que uso sshfs. Montar mi servidor remoto con sshfs, abrir mi proyecto de archivo MAKE en la máquina remota. Ve desde allí.

Parece que también puedo ejecutar una interfaz gráfica de usuario para mercurial de esta manera.

Construir mi código remoto es tan simple como: ssh address remote_make_command

Sin embargo, estoy buscando una forma decente de depurar. Posiblemente a través de gdbserver?

Tuve el mismo problema hace 2 años y lo resolví de la siguiente manera:

1) Construyo mis proyectos con archivos MAKE, no administrados por eclipse 2) Uso una conexión SAMBA para editar los archivos dentro de Eclipse 3) Construyendo el proyecto: Eclipse presenta una marca "local" con un archivo MAKE que abre una conexión SSH a Linux Anfitrión. En la línea de comando SSH puede proporcionar parámetros que se ejecutan en el host Linux. Utilizo para ese parámetro un script de shell makeit.sh que llama a la marca "real" en el host de Linux. Los diferentes objetivos para la construcción que puede proporcionar también mediante parámetros del archivo MAKE local -> makeit.sh -> makefile en el host de Linux.

Lo intenté ssh -Xpero fue insoportablemente lento.

También probé RSE, pero ni siquiera era compatible con la construcción del proyecto con un Makefile ( me han dicho que esto ha cambiado desde que publiqué mi respuesta , pero no lo he probado)

Leí que NX es más rápido que el reenvío X11, pero no pude hacerlo funcionar.

Finalmente, descubrí que mi servidor es compatible con X2Go (el enlace tiene instrucciones de instalación si el suyo no lo hace). Ahora solo tenía que:

• descargue y descomprima Eclipse en el servidor,
• instalar X2Go en mi máquina local ( sudo apt-get install x2goclienten Ubuntu),
• configure la conexión (host, inicio de sesión automático con clave ssh, elija ejecutar Eclipse).

Todo es como si estuviera trabajando en una máquina local, incluida la construcción, la depuración y la indexación de código. Y no hay retrasos notables.

Para este caso, puede usar ptp eclipse https://eclipse.org/ptp/ para buscar y construir fuentes.

Puede usar este complemento para depurar su aplicación

http://marketplace.eclipse.org/content/direct-remote-c-debugging

Esta respuesta actualmente solo se aplica al uso de dos computadoras con Linux [¿o tal vez también funciona en Mac? - ¿No se ha probado en Mac] (sincronización de una a la otra) porque escribí este script de sincronización en bash. Sin gitembargo, es simplemente una envoltura , así que siéntase libre de tomarlo y convertirlo en una solución Python multiplataforma o algo así si lo desea

Esto no responde directamente a la pregunta del OP, pero está tan cerca que garantizo que responderá a la pregunta de muchas otras personas que llegan a esta página (la mía incluida, en realidad, ya que vine aquí antes de escribir mi propia solución), así que Lo estoy publicando aquí de todos modos.

Quiero:

1. desarrollar código usando un IDE potente como Eclipse en una computadora Linux liviana, luego
2. construya ese código a través de ssh en una computadora Linux más potente y diferente (desde la línea de comandos, NO desde dentro de Eclipse)

Llamemos a la primera computadora donde escribo el código "PC1" (Computadora personal 1) y a la segunda computadora donde construyo el código "PC2". Necesito una herramienta para sincronizar fácilmente de PC1 a PC2. Lo intenté rsync, pero fue increíblemente lento para grandes repositorios y tomó toneladas de ancho de banda y datos.

Entonces, ¿cómo lo hago? ¿Qué flujo de trabajo debo usar? Si también tiene esta pregunta, aquí está el flujo de trabajo que decidí. Escribí un script bash para automatizar el proceso mediante el uso gitpara impulsar automáticamente los cambios de PC1 a PC2 a través de un repositorio remoto, como github. Hasta ahora funciona muy bien y estoy muy satisfecho con eso. Es mucho más rápido que rsync, más confiable en mi opinión, porque cada PC mantiene un repositorio git funcional y usa mucho menos ancho de banda para realizar la sincronización completa, por lo que es fácilmente factible en un punto de acceso de teléfono celular sin usar toneladas de sus datos.

Preparar:

1. Instale el script en PC1 (esta solución asume que ~ / bin está en su $ PATH):

   git clone https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles.git
   cd eRCaGuy_dotfiles/useful_scripts
   mkdir -p ~/bin
   ln -s "${PWD}/sync_git_repo_from_pc1_to_pc2.sh" ~/bin/sync_git_repo_from_pc1_to_pc2
   cd ..
   cp -i .sync_git_repo ~/.sync_git_repo

2. Ahora edite el archivo "~ / .sync_git_repo" que acaba de copiar arriba y actualice sus parámetros para que se ajusten a su caso. Aquí están los parámetros que contiene:

   # The git repo root directory on PC2 where you are syncing your files TO; this dir must *already exist* 
   # and you must have *already `git clone`d* a copy of your git repo into it!
   # - Do NOT use variables such as `$HOME`. Be explicit instead. This is because the variable expansion will 
   #   happen on the local machine when what we need is the variable expansion from the remote machine. Being 
   #   explicit instead just avoids this problem.
   PC2_GIT_REPO_TARGET_DIR="/home/gabriel/dev/eRCaGuy_dotfiles" # explicitly type this out; don't use variables
   
   PC2_SSH_USERNAME="my_username" # explicitly type this out; don't use variables
   PC2_SSH_HOST="my_hostname"     # explicitly type this out; don't use variables

3. Git clone su repositorio que desea sincronizar en PC1 y PC2.

4. Asegúrese de que sus teclas ssh estén configuradas para poder empujar y tirar al repositorio remoto desde PC1 y PC2. Aquí hay algunos enlaces útiles:
   1. https://help.github.com/en/github/authenticating-to-github/connecting-to-github-with-ssh
   2. https://help.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent
5. Asegúrese de que sus claves ssh estén configuradas para ssh desde PC1 a PC2.

6. Ahora cden cualquier directorio dentro del repositorio de git en PC1, y ejecute:

   sync_git_repo_from_pc1_to_pc2

7. ¡Eso es! Aproximadamente 30 segundos después, todo se sincronizará mágicamente de PC1 a PC2, e imprimirá resultados todo el tiempo para decirle qué está haciendo y dónde lo está haciendo en su disco y en qué computadora. También es seguro, porque no sobrescribe ni elimina nada que no se haya confirmado. ¡Lo respalda primero! Lea más abajo para saber cómo funciona.

Aquí está el proceso que usa este script (es decir: lo que realmente está haciendo)

1. Desde la PC1: Verifica si hay cambios no confirmados en la PC1. Si es así, los compromete a un compromiso temporal en la rama actual. Luego, la fuerza los empuja a una rama SYNC remota. Luego, confirma su confirmación temporal que acaba de hacer en la rama local, luego vuelve a colocar el repositorio local de git exactamente como estaba al organizar los archivos que se organizaron previamente en el momento en que llamó al script. Luego, rsynces una copia del script para PC2, y hace una sshllamada para decirle a PC2 que ejecute el script con una opción especial para hacer cosas de PC2.
2. Esto es lo que hace PC2: cdestá en el repositorio y verifica si existen cambios locales no confirmados. Si es así, crea una nueva bifurcación de respaldo bifurcada de la bifurcación actual (nombre de muestra: my_branch_SYNC_BAK_20200220-0028hrs-15sec<- observe que es AAAAMMDD-HHMMhrs - SSsec), y confirma cualquier cambio no confirmado a esa bifurcación con un mensaje de confirmación como HACER UNA COPIA DE SEGURIDAD CAMBIOS NO COMPROMETIDOS EN PC2 (PC OBJETIVO / MÁQUINA DE CONSTRUCCIÓN). Ahora, comprueba la rama SYNC, extrayéndola del repositorio remoto si aún no está en la máquina local. Luego, recupera los últimos cambios en el repositorio remoto y realiza un restablecimiento completo para forzar que el repositorio SYNC local coincida con el repositorio SYNC remoto. Podría llamar a esto un "tirón duro". Sin embargo, es seguro porque ya hicimos una copia de seguridad de los cambios no confirmados que teníamos localmente en PC2, ¡así que no se pierde nada!
3. ¡Eso es! ¡Ahora ha producido una copia perfecta de PC1 a PC2 sin siquiera tener que garantizar directorios de trabajo limpios, ya que el script manejó todo el compromiso automático y todo eso para usted! Es rápido y funciona muy bien en grandes repositorios. Ahora tiene un mecanismo fácil para usar cualquier IDE de su elección en una máquina mientras construye o prueba en otra máquina, fácilmente, a través de un punto de acceso wifi desde su teléfono celular si es necesario, incluso si el repositorio es decenas de gigabytes y ya es hora y con recursos limitados.

Recursos:

1. Todo el proyecto: https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles
   1. Vea toneladas más de enlaces y referencias en el propio código fuente dentro de este proyecto.
2. Cómo hacer un "tirón duro", como lo llamo: ¿Cómo forzo al "git pull" a sobrescribir los archivos locales?

Relacionado:

1. sincronización de repositorio git entre computadoras, cuando se mueve?