daily pastebin goal
60%
SHARE
TWEET

taller aur

a guest Apr 9th, 2011 136 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. [20:17:13] <madek>      temas de hoy, introduccion a aur, uso basico de aur, incluido yaourt, reglas basicas de empaquetado, subir y mantener paquetes
  2. [20:19:22] <madek>      ya, para comenzar vamos a hablar de aur, AUR (Arch User Repository) es como su nombre lo dice, un repositorio, creado por los usuarios de arch linux, para que los mismos usuarios, en un momento compartieran sus pkgbuilds
  3. [20:20:35] <madek>      estos estaban originalmente en un directorio en www.archlinux.org, esto se creo porque al arch ser una comunidad de pocos desarrolladores, los mismos no podian mantener todos los paquetes que existen, y asi fue mas facil que los usuarios crearan paquetes que no estaban en los repos oficiales
  4. [20:21:08] <madek>      luego de unos años, se creo la  interfaz web que nosotros vemos en aur.archlinux.org
  5. [20:21:55] <madek>      la idea basica de AUR, es que los mismos usuarios suban sus src.tar.gz, y se encarguen de la mantencion de ellos
  6. [20:22:39] <madek>      a raiz de eso nacieron distintas herramientas, como yaourt, que se encargan de descargar el src.tar.gz y lanzar makepkg para construir el paquete
  7. [20:23:25] <Deckon>     entonces los paquetes de aur no usan el mismo sistema de empaquetado que los de los repos oficiales?
  8. [20:23:36] <madek>      si usan el mismo sistema la unica diferencias radica en que los paquetes son creados por usuarios comunes y corrientes como tu o yo
  9. [20:24:46] <madek>      y la otra diferencia, es que cuando uno baja un paquete de aur, lo que en realidad esta descargando son las instrucciones para construir el paquete, y cuando lo baja de los repos oficiales lo baja el paquete ya compilado
  10. [20:25:30] <mcun>       baja los paquetes de los repos y los construlle con las reglas de aur?
  11. [20:26:07] <madek>      cuando uno baja un paquete de los repos, baja un paqute ya compilado, que lo baja y lo instala,cuando uno baja un paquete de AUR, en  realidad baja un PKGBUILD mas un par de cosas mas, que en el fondo le dicen a makepkg como compilar el paquete para luego instalarlo
  12. [20:27:06] <madek>      cuando lleguemos al apartado del empaquetado veremos un pkgbuild de ejemplo
  13. [20:29:45] <madek>      ahora hablaremos un poquito de un AUR HELPER, que es yaourt
  14. [20:30:20] <madek>      yaourt es una utilidad que hace de puente entre el repositorio AUR y el usuario, facilitando la tarea de instalar un paqute de AUR
  15. [20:30:58] <madek>      esta escrito en un lenguaje scrip, por lo que lamentablemente su ejecucion puede ser algo lenta en determinados equipos
  16. [20:31:22] <madek>      basicamente lo que yaourt hace cuando nosotros le pedimos que instale un paquete es lo siguiente
  17. [20:33:45] <madek>      yaourt primero busca si el paquete esta disponible en los repos oficiales, si no esta, busca en aur, si no esta lanza error
  18. [20:34:19] <madek>      si encuentra un paquete en los repos oficiales directamente llama a pacman para que instale el paquete y el trabajo de yaourt termina
  19. [20:35:37] <ultimceltic>        y que paso con las versiones de dicho programa? o tanto yaourt como pacman manejan las mismas versiones de algunos programas? por ejemplo que pacman maneje la version x.xxx de vlc yaourt maneja la misma? o maneja alguna mas reciente
  20.  
  21. [20:40:23] <madek>      como dije, yaourt es un puente entre AUR y el usuario, el que finalmente se encarga de instalar el paquete en el sistema siempre es pacman
  22. [20:40:39] <madek>      yaourt ayuda a construir el paquete, no lo instala el mismo,primero yaourt busca en los repos oficiales el paquete, si no lo encuentra lo busca en aur
  23. [20:42:48] <madek>      entonces si tratas de instalar vlc, como esta en los repos oficiales, lo instalara desde ahi, este o no en aur, porque revisa primero los oficiales
  24. [20:43:40] <madek>      miren el siguiente pkgbuild, es el de pacman
  25. [20:43:49] <madek>      http://projects.archlinux.org/svntogit/packages.git/tree/pacman/repos/core-i686/PKGBUILD
  26.  
  27. [20:58:26] <madek>      pongamonos en el caso que queremos instalar el paquete pacman-color con yaourt
  28. [20:58:59] <madek>      al indicarle a yaourt la orden para instalarlo, este buscara primero en los repos oficiales, como pacman-color no es de los oficiales, se saltara a aur
  29. [20:59:38] <madek>      al encontrarlo, ira a la pagina web de ese paquete, y descargara el src.tar.gz y los ultimos 5 comentarios del paquete
  30. [21:00:07] <madek>      luego, descomprimira el src.tar.gz en un directorio especial en /tmp/yaourtbuild/
  31. [21:00:15] <madek>      y en pantalla presentara lo siguiente
  32. [21:00:38] <madek>      los 5 ultimos comentarios, y ofrecera la opcion de editar el pkgbuild (cosa que veremos mas tarde)
  33. [21:01:18] <madek>      a continuacion, suponiendo que no editaremos el pkgbuild, preguntara si deseamos editar el archivo .install si es que existe
  34. [21:02:16] <madek>      luego verificara las dependencias del paquete, si estas estan instaladas las marca como tal y si no lo estan, verifica si dicho paquete esta en los repos oficiales o en aur
  35. [21:03:18] <madek>      en el caso que esten en los repos oficiales, lanzara pacman para instalarlas. si estan en aur, volvera al principio pero con este nuevo paquete
  36. [21:03:40] <madek>      una vez que haya instalado todas las dependencias, lanzara makepkg, para que este construya el paquete que necesitamos
  37. [21:04:03] <madek>      makepkg lo construira, y es lo que vemos cuando se baja la fuente y comienza a compilar
  38. [21:04:35] <madek>      una vez que makepkg termine su trabajo y entregue el pkg.tar.xz, yaourt llamara a pacman para que instale dicho paquete
  39. [21:04:48] <madek>      y listo, yaourt ha terminado de instalar lo que necesitabamos
  40. [21:04:53] <madek>      alguna duda respecto a esto
  41. [21:05:48] <mcun>       en caso de que las dependencias no se correspondan con la versió necesaria que pasa?
  42. [21:06:15] <madek>      osea de que requiera una version especifica de un paquete
  43. [21:06:48] <madek>      si esta disponible, la buscara y instalara, si no esta lanzara error y probablemente debas instalar la dependencia a mano
  44. [21:07:37] <mcun>       tocaria construirla entonces ?
  45. [21:07:58] <madek>      tambien existe la solucion de editar el pkgbuild de la dependencia en cuestion, para que instale una version especifica
  46. [21:08:21] <madek>      pero habria que instalar la dependencia primero, y luego tratar de instalar el resto, para no generar conflictos
  47. [21:08:48] <mcun>       importane aclaración
  48.  
  49. [21:16:09] <madek>      ya, ahora seguimos con el siguiente tema el bendito empaquetado
  50. [21:16:28] <madek>      primero quiero que vean el siguiente pkgbuild
  51. [21:18:29] <madek>      http://projects.archlinux.org/svntogit/packages.git/tree/scrot/repos/extra-i686/PKGBUILD
  52. [21:18:44] <madek>      revisen por un momento ese pkgbuild
  53. [21:18:49] <madek>      luego lo iremos actualizando
  54. [21:22:32] <madek>      ya, el pkgbuild cuenta de dos partes principales la descripcion del paquete y las instrucciones para compilarlo
  55. [21:22:54] <madek>      pkgname el nombre
  56. [21:22:59] <madek>      pkgver la version
  57. [21:23:04] <madek>      pkgrel el release
  58. [21:23:13] <madek>      pkgdesc descripcion
  59. [21:23:35] <madek>      arch la arquitectura en la cual puede ser construido el paquete
  60. [21:23:41] <madek>      url la web del paquete
  61. [21:23:50] <madek>      depends, las dependencias
  62. [21:24:01] <madek>      optdepend, las dependencias opcionales
  63. [21:24:15] <madek>      makedepend, las dependencias de compilacion
  64. [21:24:26] <madek>      source, desde donde descargara los archivos fuente
  65. [21:24:38] <madek>      md5sum la suma de comprobacion de integridad del paquete
  66. [21:25:00] <madek>      con eso basicamente le decimos a makepkg que vamos a compilar
  67. [21:25:08] <madek>      y de donde sacar los archivos para hacerlo
  68. [21:25:19] <madek>      y que necesita previamente para hacerlo
  69. [21:26:40] <madek>      a continuacion viene la parte interesante, la funcion build
  70. [21:26:56] <madek>      esta parte, reune los comandos que hay que ejecutar para compilar correctamente el programa
  71. [21:27:06] <madek>      como vieron en el ejemplo que les puse
  72. [21:27:08] <madek>      http://projects.archlinux.org/svntogit/packages.git/tree/scrot/repos/extra-i686/PKGBUILD
  73. [21:27:10] <madek>      con scrot
  74. [21:27:26] <madek>      es un basico configure make make install
  75. [21:27:45] <madek>      donde primero se indica que ingrese al directorio donde fue descomprimida la fuente
  76. [21:28:00] <madek>      luego que haga un ./configure con ciertas variables
  77. [21:28:25] <madek>      luego que compile con el comando make
  78. [21:28:34] <madek>      y finalmente un make install para que instale
  79. [21:29:05] <madek>      la gracia de esto, es que makepkg lo hace en un ambiente fakeroot, de modo que no tocamos ningun archivo de sistema, y hacemos todo en un arbol de directorios independiente
  80. [21:29:21] <madek>      asi evitamos incompatibilidades con otra cosa
  81.  
  82. [21:29:49] <Deckon>     es por eso que cuando se ejecuta yaourt dice que no se ejecute en modo root?
  83. [21:30:11] <madek>      exacto
  84. [21:30:42] <madek>      lo que pasa es que es riesgoso ejecutar yaourt como root, ya que yaourt llama solito a root cuando lo necesita, que es para instalar
  85. [21:30:52] <madek>      makepkg tampoco debe ser usado como root
  86. [21:31:39] <madek>      la idea deckon, es que se usa root solo para instalar o desinstalar, el resto se hace como usuario normal
  87. [21:32:09] <mcun>       pero en el proceso te pide el pass?
  88. [21:32:21] <madek>      depende como tengas configurado sudo
  89. [21:32:39] <mcun>       y si no tiene sudo ?
  90. [21:33:41] <madek>      yaourt tiene un script propio para pasar a root cuando no existe sudo y luego volver a user normal
  91.  
  92. [21:34:09] <madek>      vamos a compilar manualmente el paquete scrot con la ayuda de makepkg
  93. [21:34:31] <madek>      entonces copiamos el contenido del pkgbuild que les comparti anteriormente
  94. [21:34:38] <madek>      http://projects.archlinux.org/svntogit/packages.git/tree/scrot/repos/extra-i686/PKGBUILD
  95. [21:34:50] <madek>      desde la linea que dice pkgname hasta la }
  96. [21:35:14] <madek>      eso lo copiamos en un archivo de texto que llamaremos PKGBUILD (mayusculas)
  97. [21:35:30] <madek>      y lo guardaremos en un directorio nuevo que ocuparemos para trabajar
  98. [21:47:29] <madek>      ahora lancen makepkg en el directorio donde esta el PKGBUILD
  99.  
  100. [21:50:21] <madremelian>        Dependencias que faltan:
  101. [21:50:22] <madremelian>          -> giblib
  102. [21:50:22] <madremelian>         <<<< me falta esta dependencia
  103. [21:50:27] <madek>      sabia que pasaria esto
  104. [21:50:46] <madremelian>        ==> ERROR: No se pudieron resolver todas las dependencias <<<< respuegta
  105. [21:50:51] <madek>      miren, es muy simple, como no estamos usando yaourt, no tenemos como verificar dependencias
  106. [21:50:55] <madek>      pero podemos instalarlas
  107. [21:51:01] <madek>      instalemos giblib entonces
  108. [21:51:10] <madek>      y luego lancemos nuevamente makepkg
  109. [21:52:39] <madek>      ya, el paquete scrot ha sido compilado, pero no instalado
  110. [21:52:45] <madek>      para instalarlo debemos llamar a pacman
  111. [21:53:13] <madek>      hagan un pacman -U scrot-0.8-4-i686.pkg.tar.gz como root
  112. [21:53:29] <madek>      si estan en x64 cambien la arquitectura de i686 a x86_64
  113.  
  114. [21:55:09] <helq>       el [tab] les ayuda a completar las palabras en bash ;)
  115. [21:55:22] <helq>       nota por si no quieren escribirlo todo
  116.  
  117. [21:55:26] <madek>      cuando terminen, habran creado el paquete scrot y lo habran instalado sin usar yaourt
  118.  
  119. [21:57:01] <helq>       otra nota, pueden usar makepkg -i para compilar he instalar si todo sale bien ;) [espero no interrumpir el flujo normal del taller, me avisas @madek :D]
  120. [21:57:34] <madek>      si se que -i es mas rapido, pero paso por paso se entiende mejor
  121. [21:58:25] <madek>      alguna duda con el como crear un paquete e instalarlo, o alguna duda con la estructura basica del PKGBUILD
  122.  
  123. [22:04:55] <madremelian>        madek pero.... Arch tiene otra herramienta para instalar el paquete que no sea pacman o el propio makepkg  ??
  124. [22:05:19] <madek>      no, pacman es la unica utilidad para instalar paquetes todos los otros programas al final usan pacman para instalar el paquete
  125. [22:06:27] <madek>      en el fondo todos los AUR helper hacen -- bajar src.tar.gz -- revisar e instalar dependencias -- llamar makepkg -- instalar con pacman
  126. [22:07:45] <madremelian>        madek vale, mejor así. Por lo que acabo de ver, tanto giblib como el scrot pueden ser desinstalados desde pacman o yaour. Toda la información centralizada=orden
  127. [22:08:04] <madek>      es que al final yaourt llama a pacman
  128. [22:08:16] <madek>      yaourt en si no desinstala ni instala nada, lo hace a expensas de pacman
  129.  
  130. [22:08:52] <madek>      bueno, vimos el ejemplo de un paquete que estaba disponible, pero que pasa si queremos un paquete que no esta en ningun lado
  131. [22:09:04] <madek>      debemos crear nuestro PKGBUILD nosotros mismos
  132. [22:09:19] <madek>      ahora veremos de donde sacar la info para que nuestro paquete se construya bien
  133.  
  134. [22:10:00] <madek>      supongamos que el mismo scrot no esta en los repos oficiales ni aur, pero hemos visto su web entonces, nos vamos a la web de scrot http://scrot.sourcearchive.com/
  135. [22:12:49] <madek>      donde veremos diferentes links para descargarlo, por una cosa practica haremos la descarga desde otro sitio
  136. [22:13:22] <madek>      wget ftp://ftp.archlinux.org/other/scrot/scrot-0.8.tar.bz2
  137. [22:13:30] <madek>      ahi descargaremos la fuente para descargarlo
  138. [22:15:05] <madek>      ya, una vez descargado, tenemos el source, ahora veremos que hacer con el
  139. [22:16:43] <madek>      a continuacion presento un PKGBUILD vacio
  140. [22:16:46] <madek>      pkgname=
  141. [22:16:46] <madek>      pkgver=
  142. [22:16:46] <madek>      pkgrel=
  143. [22:16:46] <madek>      pkgdesc=""
  144. [22:16:46] <madek>      arch=('')
  145. [22:16:46] <madek>      url=""
  146. [22:16:46] <madek>      license=('')
  147. [22:16:46] <madek>      depends=('')
  148. [22:16:46] <madek>      source=()
  149. [22:16:46] <madek>      md5sums=('')
  150. [22:16:46] <madek>      build() {
  151. [22:16:46] <madek>      }
  152. [22:17:15] <madek>      el cual deben llenar con la informacion correspondiente iremos llenando paso a paso
  153. [22:19:41] <madek>      pkgname va el nombre, que en este caso es scrot
  154. [22:19:52] <madek>      pkgver es la version, que en nuestro caso es la 0.8
  155. [22:20:11] <madek>      en pkgrel va el release, como acabamos de crear el paquete corresponde la 1
  156. [22:20:25] <madek>      en pkgdesc va la descripcion, en ingles
  157. [22:20:54] <madek>      seria algo como "a utility for take screenshot in X"
  158. [22:22:03] <madek>      en arch, van las arquitecturas, como scrot puede ser para ambas, colocamos ambas 'i686' 'x86_64'
  159. [22:24:06] <madek>      sigamos, en url va la web del proyecto, que en este caso es http://scrot.sourcearchive.com/
  160. [22:24:09] <phrik>      Title: SourceArchive.com (at scrot.sourcearchive.com)
  161. [22:29:34] <madek>      en licence va la licencia
  162. [22:30:41] <madek>      ahora necesitamos descomprimir la fuente que bajamos anteriormente
  163. [22:30:48] <madek>      en otra consola, en el mismo directorio
  164. [22:34:40] <madek>      descompriman el archivo scrot-0.8.tar.bz2 con su programa favorito
  165. [23:32:37] <madek>      lamentable, el archivo README de scrot no provee info sobre las dependencias
  166. [23:32:43] <madek>      asi que tendremos que hacerlo a la mala
  167. [23:33:00] <madek>      hacemos como que no tiene dependencias y seguimos llenando nuestro pkgbuild
  168. [23:33:51] <madek>      luego viene la seccion source, que son las fuentes desde donde se descargara la fuente, en nuestro caso es desde donde descargamos originalmente el archivo que es ftp://ftp.archlinux.org/other/scrot/scrot-0.8.tar.bz2
  169. [23:34:12] <madek>      para el md5sum, podemos sacarla facilmente
  170. [23:34:41] <madek>      corremos md5sum scrot-0.8.tar.bz2
  171. [23:34:58] <madek>      colocan el  numero que les de en el apartado md5sum
  172. [23:42:24] <madek>      entonces generamos el md5sum y tenemos "lista la primera parte"
  173. [23:42:51] <madek>      ahora iremos a la funcion build, para construir el paquete
  174. [23:43:08] <madek>      si nos fijamos en el README si teniamos instrucciones de como compilar
  175. [23:43:38] <madek>      entonces creamos nuestra seccion build con lo siguiente
  176. [23:44:23] <madek>      primero le indicamos que entre en el directorio necesario para compilar, makepkg automaticamente descomprime las fuentes en el directorio src, asi que no es necesario hacerlo a mano
  177. [23:44:31] <madek>      colocamos la linea
  178. [23:44:43] <madek>      cd src/scrot-0.8
  179. [23:44:52] <madek>      src por el directorio que makepkg crea automaticamente
  180. [23:45:06] <madek>      y scrot-0.8 que es el directorio que se descomprime scrot
  181. [23:48:05] <madek>      entonces ya colocamos esa linea, con lo que entramos en el directorio correspondiente
  182. [23:48:21] <madek>      ahora aprovecharemos que el README provee informacion, y la copiaremos descaradamente
  183. [23:49:47] <madek>      ./configure
  184. [23:49:48] <madek>      make
  185. [23:49:50] <madek>      make install
  186. [23:50:15] <madek>      porque no copiamos la ultima linea su -c "make install" tal cual
  187. [23:50:22] <madek>      porque makepkg usa fakeroot
  188. [23:50:48] <madek>      por lo que el su -c no es necesario, ya que esa linea hace es convertirse en root, pero como usamos fakeroot ya somos root
  189. [23:52:12] <madremelian>        pkgname=scrot
  190. [23:52:13] <madremelian>        pkgver=0.8
  191. [23:52:13] <madremelian>        pkgrel=1
  192. [23:52:13] <madremelian>        pkgdesc="A simple command-line screenshot utility for X"
  193. [23:52:13] <madremelian>        arch=('i686' 'x86_64')
  194. [23:52:13] <madremelian>        url="http://scrot.sourcearchive.com/"
  195. [23:52:15] <madremelian>        license=('MIT')
  196. [23:52:17] <madremelian>        ##depends=('giblib')
  197. [23:52:19] <madremelian>        depends)('')
  198. [23:52:21] <madremelian>        ## optdepend, las dependencias opcionales
  199. [23:52:25] <madremelian>        ## makedepend,  las dependencias de compilacion
  200. [23:52:27] <madremelian>        source=(ftp://ftp.archlinux.org/other/scrot/scrot-0.8.tar.bz2)
  201. [23:52:29] <madremelian>        md5sums=('6a02df0e3bb26ec578dfeb8f56a7b30d')
  202. [23:52:31] <madremelian>        build() {
  203. [23:52:33] <madremelian>          cd src/scrot-0.8
  204. [23:52:35] <madremelian>          ./configure
  205. [23:52:37] <madremelian>          make
  206. [23:52:39] <madremelian>          make install
  207. [23:52:41] <madremelian>           
  208. [23:52:43] <madremelian>        }
  209. [23:55:18] <angvp>      es depends=('') y tenes depends)('')
  210. [23:56:23] <madek>      bueno, luego de esa correccion estas en condiciones de correr el pkgbuild con makepkg
  211. [23:56:43] <madek>      pd: madremelian, desisntala giblib, para que resulte el ejemplo de las dependencias
  212. [23:57:26] <madek>      ahora guarda el PKGBUILD
  213. [23:57:35] <madek>      y en el directorio donde esta corre makepkg
  214.  
  215. [00:33:17] <madremelian>        configure: error: Cannot find giblib: Is giblib-config in the path?
  216. [00:33:22] <madek>      exacto
  217. [00:33:27] <madek>      ese error queria
  218. [00:33:34] <madek>      si se fijan un par de lineas mas arriba
  219. [00:33:38] <madek>      aparece lo siguiente
  220.  
  221. [00:34:56] <madek>      checking for giblib - version >= 1.2.3... no
  222. [00:35:06] <madek>      busquenla, esta un poco mas arriba
  223. [00:35:12] <madek>      esa linea indica el paquete que falta
  224. [00:35:49] <madek>      a veces pasa que un comando es parte de un paquete, como giblib-config que es parte de giblib
  225. [00:36:22] <madek>      si ponemos giblib-config como depend tambien dara error, ya que ese no existe
  226. [00:36:37] <madek>      entonces nos vamos al paquete padre que es giblib, ya que provee giblib-config
  227. [00:36:55] <madek>      ahora modificaremos el pkgbuild agregando a depends lo que falta
  228. [00:37:05] <madek>      haganlo y corran nuevamente el pkgbuild con makepkg
  229. [00:38:31] <madek>      avisen como les va
  230. [00:39:36] <madek>      se suponia que debian instalar giblib antes
  231.  
  232. [00:51:08] <madek>      falta una ultima cosa
  233. [00:51:54] <madek>      que pasa si por ejemplo se nos paso una dependencia que no conocemos, y que no es necesaria para compilar pero si para ejecutar
  234. [00:52:02] <madek>      como sabemos cual es
  235. [00:52:08] <madek>      para eso existe namcap
  236. [00:52:30] <madek>      esa utilidad revisa el pkg.tar.xz en busca de muchas cosas, entre ellas dependencias fallidas
  237. [00:52:48] <madek>      por favor procedan a instalar namcap
  238. [00:55:43] <madek>      namcap lo que hace es revisar el paquete en busca de errores
  239. [00:56:04] <madek>      vamos a ejecutar lo siguiente en consola
  240. [00:56:26] <madek>      namcap namcap scrot-0.8-1-i686.pkg.tar.xz
  241. [00:56:40] <madek>      la idea es namcap NOMBREPAQUETE
  242. [00:57:15] <madek>      y vean que les sale
  243. [00:58:15] <madremelian>        scrot W: Dependency included and not needed ('giblib')
  244. [00:58:27] <madremelian>        scrot W: No ELF files and not an "any" package
  245. [00:58:30] <madek>      ya
  246. [00:58:33] <madek>      ahora
  247. [00:58:38] <madek>      desinstalen giblib
  248. [00:58:43] <madek>      y corran nuevamente namcap
  249. [00:58:47] <madek>      y comparen las salidas
  250. [01:03:55] <madek>      les debiera aparecer una linea como esta
  251. [01:03:56] <madek>      scrot W: Referenced library 'libgiblib.so.1' is an uninstalled dependency
  252. [01:04:52] <madremelian>        madek pero entonces no habría que leer el paquete construido.... porque las dependencias las necesitamos antes.
  253. [01:05:14] <madek>      depende
  254. [01:05:35] <madek>      estoy poniendo el caso de que sea una dependencia que no sea necesaria para compilar, pero si para ejecutar el programa
  255. [01:06:00] <madek>      en dichos casos al compilar no saldria el error, saldria el error solo al tratar de ejecutar el programa
  256. [01:06:32] <madek>      en nuestro caso la unica dependencia es esa, pero para otros paquetes tienen dependencias que solo se ocupan al ejecutar cierta funcion dentro del programa
  257. [01:06:45] <madek>      para eso sirve namcap, entre otras cosas
  258. [01:07:03] <madek>      va revisando el paquete, para comprobar que no olvidamos algo importante
  259. [01:08:06] <madek>      ademas puede que el mismo configure venga con un erro y no pregunte por x dependencia
  260. [01:08:39] <madek>      recuerda que la idea de esto es que el paquete que estas creando se comparta en aur, entonces es importante entregar algo bueno y no a medias
  261.  
  262. [01:11:30] <madek>      ahora vamos a  lo ultimo y mas facil
  263. [01:11:39] <madek>      como subimos a AUR nuestro nuevo paquete creado
  264. [01:11:43] <madek>      es muy simple
  265. [01:11:52] <madek>      primero debemos generar el src.tar.gz
  266. [01:12:00] <madek>      en el directorio donde esta el pkgbuild
  267. [01:12:05] <madek>      hacemos
  268. [01:12:09] <madek>      makepkg --source
  269. [01:12:39] <madek>      eso nos generara el archivo scrot-0.8-1.src.tar.gz
  270. [01:13:11] <madek>      ese archivo contiene todo lo necesario para crear paquetes y puede ser subido
  271. [01:13:15] <madek>      nos vamos a la web http://aur.archlinux.org/pkgsubmit.php
  272. [01:13:57] <madek>      deben tener una cuenta de aur
  273. [01:14:45] <madek>      que elejir categoria, en nuestro caso seria x11
  274. [01:15:08] <madek>      y elijen el archivo a subir, que seria nuestro scrot-0.8-1.src.tar.gz
  275. [01:15:26] <madek>      luego, en el caso que queramos subirlo, le damos a subir y el nuevo paquete se creara al subir un paquete nuevo, automaticamente se hacen mantenedor del paquete
  276. [01:16:04] <madek>      con lo que tienen que mantenerlo y actualizarlo
  277. [01:16:10] <madek>      como actualizarlo es facil
  278. [01:16:17] <madek>      supongamos que salio la version 0.9 de scrot
  279. [01:16:39] <madek>      entonces nos vamos al PKGBUILD y editamos
  280. [01:16:43] <madek>      el pkgver
  281. [01:17:02] <madek>      y el md5sum lo actualizamos segun nuestra nueva version
  282. [01:17:43] <madek>      luego compilamos nuevamente, si todo funciona bien, podemos nuevamente crear con makepkg --source, el archivo que debemos subir nuevamente
  283. [01:17:45] <|AhIoRoS|>  makepkg -g te da el checksum y lo compruebas con el de la web para estar seguro
  284. [01:17:57] <madek>      claro, esa es otra opcion
  285.  
  286. --------------------final--------------------------------------------------
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top