Cómo parchear un archivo (y crear parches) en Linux

Fatmawati Achmad Zaenuri / Shutterstock.com

Linux patch El comando le permite transferir cambios de un conjunto de archivos a otro conjunto de archivos de forma rápida y segura. Aprender a usar patch la manera fácil.

Los comandos patch y diff

Imagina que tienes un archivo de texto en tu computadora. Recibe una versión editada de este archivo de texto de otra persona. ¿Cómo transferir rápidamente todos los cambios del archivo editado a su archivo original? Es ahí que patch y diff entrar en el juego. patch y diff se encuentran en Linux y otros sistemas operativos similares a Unix, como macOS.

los diff orden examina dos versiones diferentes de un archivo y enumera las diferencias entre ellos. Las diferencias se pueden almacenar en un archivo llamado archivo de parche.

los patch puede leer un archivo de parche y usar el contenido como un conjunto de instrucciones. Siguiendo estas instrucciones, los cambios en el archivo modificado son reproducido en el original archivar.

Ahora imagine que este proceso ocurre en un directorio completo de archivos de texto. De golpe. Es el poder de patch.

A veces no recibe los archivos modificados. Todo lo que recibe es el archivo de parche. ¿Por qué enviar docenas de archivos cuando puede enviar un archivo o publicar un archivo para cargarlo fácilmente?

¿Qué estás haciendo con el archivo de parche para arreglar realmente tus archivos? Además de ser casi un trabalenguas, esta también es una buena pregunta. Te lo explicaremos en este artículo.

los patch El comando lo utilizan con mayor frecuencia personas que trabajan con archivos de código fuente de software, pero funciona igualmente bien con cualquier conjunto de archivos de texto, independientemente de su propósito, código fuente o no.

Nuestro escenario de ejemplo

En este escenario, estamos en un directorio llamado trabajo que contiene dos directorios más. Uno se llama trabajo y el otro se llama último. El directorio de trabajo contiene un conjunto de archivos de código fuente. El directorio más reciente contiene la versión más reciente de estos archivos de código fuente, algunos de los cuales han sido modificados.

Para mayor seguridad, el directorio de trabajo es una copia de la versión actual de los archivos de texto. No es la única copia de ellos.

Encuentra las diferencias entre dos versiones de un archivo

los diff El comando encuentra las diferencias entre dos archivos. Su acción predeterminada es listar las líneas modificadas en la ventana del terminal.

Un archivo se llama slang.c. Compararemos la versión del directorio de trabajo con la del último directorio.

los -u la opción (unificada) indica diff para enumerar también algunas de las líneas de texto sin editar antes y después de cada una de las secciones modificadas. Estas líneas se denominan líneas de contexto. Ellos ayudan al patch ubicar con precisión dónde se debe realizar un cambio en el archivo original.

Proporcionamos los nombres de los archivos para que diff sabe qué archivos comparar. Primero se enumera el archivo original, luego el archivo modificado. Este es el pedido que enviamos a diff:

diff -u working/slang.c latest/slang.c

diff produce una lista de salida que muestra las diferencias entre los archivos. Si los archivos fueran idénticos, no se incluiría ninguna salida. Ver este tipo de salida de diff confirma que existen diferencias entre las dos versiones de archivo y que es necesario corregir el archivo original.

Crea un archivo de parche

Para capturar estas diferencias en un archivo de parche, use el siguiente comando. Este es el mismo comando que el anterior, con la salida de diff redirigido a un archivo llamado slang.patch.

diff -u working/slang.c latest/slang.c > slang.patch

El nombre del archivo de parche es arbitrario. Puedes llamarlo como quieras. Darle una extensión «.patch» es una buena idea; sin embargo, porque indica claramente qué tipo de archivo es.

Hacer patch actuar sobre el archivo de parche y modificar el archivo de trabajo / slang.c, use el siguiente comando. los -u La opción (unificada) permite patch tenga en cuenta que el archivo de parche contiene líneas de contexto unificadas. En otras palabras, usamos la opción -u con diff, por lo que usamos la -u opción con patch.

parche -u working.slang.c -i slang.patch

Si todo va bien, una sola línea de salida le dice patch corrige el archivo.

Haga una copia de seguridad del archivo original

Podemos educar patch para hacer una copia de seguridad de los archivos corregidos antes de que se modifiquen utilizando el -b opción (copia de seguridad). los -i (enter) le dice a patch el nombre del archivo de parche a usar:

patch -u -b working.slang.c -i slang.patch

El archivo se corrige como antes, sin diferencias visibles en la salida. Sin embargo, si busca en la carpeta de trabajo, verá que se ha creado el archivo llamado slang.c.orig. La fecha y hora de los archivos muestran que slang.c.orig es el archivo original y slang.c es un archivo nuevo creado por patch.

Usando diff con directorios

Nosotros podemos usar diff para crear un archivo de parche que contenga todas las diferencias entre los archivos en dos directorios. Luego podemos usar este archivo de parche con patch para que estas diferencias se apliquen a los archivos de la carpeta de trabajo con un solo comando.

Las opciones que usaremos con diff son los -u (contexto unificado) que usamos anteriormente, el -r opción (recursiva) para hacer diff busque en todos los subdirectorios y el -N opción (nuevo archivo).

los -N la opción dice diff cómo manejar archivos en el último directorio que no están en el directorio de trabajo. fuerza diff poner instrucciones en el archivo de parche para quepatch crea archivos que están presentes en el último directorio pero no en el directorio de trabajo.

Puede agrupar opciones para que utilicen un solo guión (-).

Tenga en cuenta que solo proporcionamos nombres de directorio, no decimos diff para ver archivos específicos:

diff -ruN working/ latest/ > slang.patch

diff -ruN trabajando / last /> slang.patch» ancho =»646″ altura =»77″ onload =»pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (esto);» onerror =»this.onerror = null; pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (esto);»/></p>
<h2 role=Mira dentro del archivo de parche

Echemos un vistazo rápido al archivo de parche. usaremos less para ver su contenido.

La parte superior del archivo muestra las diferencias entre las dos versiones de slang.c.

A medida que nos desplazamos hacia abajo por el archivo de parche a continuación, vemos que luego describe los cambios en otro archivo llamado structs.h. Esto verifica que el archivo de parche definitivamente contiene las diferencias entre las diferentes versiones de varios archivos.

Piensa antes de actuar

Parchear una gran colección de archivos puede ser un poco molesto, así que usaremos el --dry-run capacidad para comprobar que todo está bien antes de dar el paso y comprometerse a realizar los cambios.

los --dry-run la opción dice patch para hacer todo excepto modificar los archivos. patch realizará todas sus comprobaciones previas al vuelo en los archivos y, si encuentra algún problema, lo informará. En todos los casos, no se modifica ningún archivo.

Si no se informa ningún problema, podemos repetir el pedido sin el --dry-run opción y arreglar nuestros archivos con confianza.

los -d (directorio) opción de decir patch en qué directorio trabajar.

Tenga en cuenta que no utilizamos el -i (entrada) opción para decir patch qué archivo de parche contiene las instrucciones para diff. En su lugar, redirigimos el archivo de parche a patch con <.

patch --dry-run -ruN -d working < slang.patch

En todo el repertorio, diff encontró dos archivos para corregir. Las instrucciones para modificar estos dos archivos han sido verificadas por patch y no se informaron problemas.

Los controles previos al vuelo están bien; estamos listos para despegar.

Parchear un directorio

Para aplicar realmente las correcciones a los archivos, usamos el comando anterior sin el --dry-run opción.

patch -ruN -d working < slang.patch

Esta vez, cada línea de salida no comienza con «comprobar», cada línea comienza con «corrección».

Y no se informan problemas. Podemos compilar nuestro código fuente y estaremos en la última versión del software.

Resuelva sus disputas

Es, con mucho, la forma más fácil y segura de usar patch. Copie sus archivos de destino a una carpeta y arregle esa carpeta. Cópielos de nuevo cuando esté satisfecho de que el proceso de corrección se ha completado sin errores.

Publicaciones Similares

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *