From ba2758d6f2c7e18e5d5bd3b606c60f55aa048e76 Mon Sep 17 00:00:00 2001 From: rhatto Date: Mon, 8 Dec 2008 16:10:10 +0000 Subject: documentation: keeping just tex files to prevent duplicate and non-updated documentation git-svn-id: svn+slack://slack.fluxo.info/var/svn/simplepkg@643 04377dda-e619-0410-9926-eae83683ac58 --- trunk/doc/README | 431 ------------------------------------- trunk/doc/README.pt_BR | 449 -------------------------------------- trunk/doc/README.simplaret | 326 ---------------------------- trunk/doc/README.simplaret.pt_BR | 451 --------------------------------------- 4 files changed, 1657 deletions(-) delete mode 100644 trunk/doc/README delete mode 100644 trunk/doc/README.pt_BR delete mode 100644 trunk/doc/README.simplaret delete mode 100644 trunk/doc/README.simplaret.pt_BR diff --git a/trunk/doc/README b/trunk/doc/README deleted file mode 100644 index 7c3ef17..0000000 --- a/trunk/doc/README +++ /dev/null @@ -1,431 +0,0 @@ -Simplepkg: installation manager and packaging system ----------------------------------------------------- - -Author: Silvio Rhatto -Licence: GPL - -Simplepkg is a non-intrusive management system running on top of pkgtool made of a -set of scripts which helps the sysadmin and developing cycles of an slackware system. -It can be used to create packages and repositories as long as the operational system -installation and config file change tracking. - -Documentation -------------- - - The mostly updated documentation can be found at http://slack.sarava.org/simplepkg - or at the latest source code snapshot. - -Description ------------ - -All GNU/Linux distributions comes with a well developed packaging system. The question now -is how pratical is the way to install, configure and control any changes in a system. - -As an example, suppose you should keep a list of about 200 slackware machines, some -of them used as desktops, others as mail or webservers. If you lost some hardrives -or usually need to re-install or update some of those boxes. - -Using the slackware installation cd and configuring by hand all the time you got a crash -is a time loss activity and you'll never know if something remained missconfigured. An -alternative is to keep a complete backup of a machine or some parts of the tree, but for -a large number of different boxes this procedure costs a lots of resources. - -Simplepkg offers an alternative sollution for this and other problems related to installation -management, allowing you to keep templates of each machine and install a custom slackware -system with just one or a few commands. Creating and upgrading chroot and vservers is easy -with simplepkg. - -Package and installation management is not everything simplepkg can do. It can also be used -to create vservers, create packages and store system configuration files in a subversion -repository. - -Simplepkg works with any (official or not) slackware port that follows the minimum system -guidelines. - -Architecture ------------- - -Simplepkg is a set of scripts wrote in the KISS philosophy. Its a pretty simple system, composed -by the following commands: - - - mkjail: build a slackware jail/installation in a folder - - templatepkg: create or update a package list of an installation template - - lspkg: show installed packages and its contents - - jail-commit: update all configuration files of a template - - jail-update: jail-commit counterpart - - rebuildpkg: rebuild a package based on its /var/log/packages entry - - simplaret: package retrieval tool - - createpkg: donwload, compile and package creationg script - - repos: creates and manages binary repositories - - mkbuild: app to build slackware build scripts - -Installation ------------- - -The latest version of simplepkg is locate at http://slack.sarava.org/packages/noarch/. -Install it with the usual way: - - installpkg simplepkg-VERSION-noarch-BUILD.tgz - -Simplepkg usage ---------------- - -The three main simplepkg uses are: - - - Package managemen - - Jail/installation creation and management - - Package creation - -Package management is made with simplaret app, whose behaviour is detailed in its own document. -The following sections will only show how simplepkg can be used to manage jails and template -and create packages. - -Creating templates ------------------- - -Initially, simplepkg was built to help slackware install automation. To do that, it uses installation -templates -- lists of installed packages, post-installation scripts and config files -- allowing the -creation of installation profiles that can be used for system replication in other partition or even -custom chroot building. - -Template creation is done with "templatepkg" script. To create a template called "my-slackware" containig -the installed package list of your slackware installation, just type - - templatepkg -c my-slackware - -The -c (or --create) flag tells templatepkg to create the /etc/simplepkg/templates/my-slackware folder -with the following components: - - - /etc/simplepkg/templates/my-slackware/my-slackware.d: template config files - - /etc/simplepkg/templates/my-slackware/my-slackware.s: post-installation scripts - - /etc/simplepkg/templates/my-slackware/my-slackware.perms: metadata for config files - - /etc/simplepkg/templates/my-slackware/my-slackware.template: installaed package list - -This four components are enough to store all slackware installation characteristics: the package list -controls with applications are installed, the config file folder can contain all desired configurations -for any installed application and the post-installation scripts take care of all procedures that should -be executed exactly after the system installation. The my-slackware.perms file contains metadata for the -saved config files, i.e, permission and ownership. - -If you want to build a template from a installation placed in another folder or partition thats not your -current root dir, just type something like - - templatepkg -c my-slackware /mnt/slackware - -where /mnt/slackware is the place where this alternative system is installed. After created, the template -will contain just the installed package list or that folder. As the folder /var/log/packages of your -installation doesn't keep information about the package installation order, its recommended that you -manually edit the template's package list. To do that, just type - - templatepkg -e my-slackware - -To add configuration files inside the template, type something like - - templatepkg -a my-slackware /etc/hosts - -This should add /etc/hosts file to "my-slackware" template. Beyond just automatically copy the file -when you install a new system using this template, simplepkg can also take care of every change that -/etc/hosts can suffer on your system, such as file content or permission and ownership change. If you're -also storing your templates in a subversion repository, you'll be able to track all changes it ever had. - -WARNING: avoid the storage in a template of config files that contains important security information -such as passwords or secret keys. The prefered place to put such stuff is a secured backup. - -Creating jails and replicating installations --------------------------------------------- - -As long as your template was created and populated with the package list, configuration files and -post-installation scripts (what will be treated in another section), your can replicate your slackware -installation as simpler than typing the following command: - - mkjail jail my-slackware - -This creates a fresh slackware tree at /vservers/jail with all packages listed in the template "my-slackware" -and all saved config files. The package installation is made by simplaret app, that should be properly configured. -The standard simplaret configuration should work for most situations. - -If you want to install your jail in a place other than /vservers (this standard location can be changed through -simpleokg config file), say /mnt/hda2, just use something like that: - - ROOT=/mnt mkjail hda2 my-slackware - -The above command does exactly what you think: installs slackware in /mnt/hda2 with exactly the same packages -you have on your system, replacing the need of the slackware installer! - -In case no template specified, mkjail uses the one stored /etc/simplepkg/defaults, if exists. Simplepkg already -came if some pre-built templates at /etc/simplepkg/defaults/templates. - -Post-installation scripts -------------------------- - -Optionally, its possible to keep post-installation scripts inside a template. Such scripts are executed by mkjail -exactly after a jail is installed and the template config files copied. To create or edit a post-installation -script, just type - - templatepkg -b my-slackware script-name.sh - -This adds the script-name.sh at "my-slackware" template. Mkjail passes two command line arguments to a post-install -script: the upward folder and the jail's name ("/mnt" and "hda2" from our previous example). Then, an example script -is something like that: - - #!/bin/bash - chroot $1/$2/ sbin/ldconfig - -Listing template contents -------------------------- - -To list available templates or the template content, use commands such as - - templatepkg -l - templatepkg -l my-slackware - -Removing files from a template ------------------------------- - -As you did to add files, you can easily remove then from a template, using a comand such as - - templatepkg -d my-slackware /etc/hosts - -This removes the file /etc/hosts from "my-slackware" template. - -Removing a template -------------------- - -To remove a template, just type - - templatepkg -r my-slackware - -Updating a template -------------------- - -Now that we just talked about creating templates and jails, its time to cover another application, this time -used to keep a template always updated. Jail-commit is a script that copies all config file changes (content, -permissions and ownership) from a installation to a simplepkg template. - -For instance, if one wants to copy all changes from /mnt/hda2 jail into "my-slackware" template, he or she -just needs to type the following command: - - jail-commit /mnt/hda2 my-slackware - -Not just the package list from "my-slackware" template is updated according the installed packages from -/mnt/hda2/var/log/packages: all config files from "my-slackware" template are compared it the ones from -the jail and in case of any difference they're copied from the jail back to the template. Permissions -and file ownership commit into the template works at the same way. - -Jail-commit allows that a template to being kept always updated and mirroring the actual configuration -of an installed system. But if you want just to commit into the template just the installed package -list, simply type - - templatepkg -u my-template - -To make life even easier, there's also a feature of keeping a list of all installed slackware system in -the box in the file /etc/simplepkg/jailist. This file, despite its use by simplaret (what is described -in its own text), allow jail-commit to run with no arguments. - -Suppose you have three slackware installations: the root system and two more: - - - /mnt/slackware-1 using "slackware-1" template - - /mnt/slackware-2 using "slackware-2" template - -If your /etc/simplepkg/jailist has the following lines: - - /mnt/slackware-1 - /mnt/slackware-2 - -then the command - - jail-commit - -will update both "slackware-1" and "slackware-2" templates according, respectivelly, the contents of -/mnt/slackware-1 and /mnt/slackware-2. If you also have a template called "main", then jail-commit -will sync the contents of your root system with that template. - -You can even add the following line at root's crontab - - 20 4 * * * jail-commit - -so all your templates get updated everyday. If your system is configured to send emails, then crontab's -jail-commit output you give a summary of yesterday changes your system suffered, both config file changes -and package additions and removals. - -Restoring changes in a jail ---------------------------- - -The opposite operation of jail-commit also is possible: suppose you edited some config files in your system but -suddenly wants to go back and copy all config files from a template to your jail. To do that, just use the command - - jail-update /mnt/hda2 my-slackware - -Storing templates inside a Subversion repository ------------------------------------------------- - -In order to increase once more the control and flexibility of template contents, simplepkg can also handle templates -inside a subversion repository. To do that, edit first the config file /etc/simplepkg/simplepkg.conf and set the -parameter TEMPLATES_UNDER_SVN to "yes". - -Then, create a fresh subversion repository to keep your templates with a command like that: - - svnadmin create /var/svn/simplepkg --fs-type fsfs - -Then, you just need to import your templates with - - templatepkg -e file:///var/svn/simplepkg - -From now jail-commit will commit automatically any template changes to the svn repository. If, in the other hand, -you wish to grab the changes from the svn repository to your local copy, use - - templatepkg -s - -In case you want to import a template folder from an existing repository, use - - templatepkg -i file:///var/svn/simplepkg - -where file:///var/svn/simplepkg is the repository path. - -Upgrading jails ---------------- - -Jail and installed system upgrading is done through simplaret and also supports /etc/simplepkg/jailist file. -For more info on how it works, take a look at simplaret own documentation. - -Different archs and versions ----------------------------- - -Simplepkg was idealized to permit a template to create jails from any architecture and version -of a slackware-like system. Upgrading tasks also are unified. This feature just works if you -use simplaret and not swaret as the package retrieval tool. - -As another example, to create an slack 10.1 installation (assuming your /etc/simplepkg/repos.conf with -the right configuration), just type - - VERSION=10.1 mkjail my-jail server-template - -Different archs can be used too. If you have a x86_64 system and wants to install a slack 10.2 -in a partition, try something like - - ARCH=i386 VERSION=10.2 ROOT=/mnt mkjail hda2 my-slackware - -Note that the templates are arch and version independent, as they just contain package names, -configuration files and scripts. For this reason, the commands templatepkg, metapkg, lspkg and -jail-update can be used normaly. - -Creating a package from a template ----------------------------------- - -If, for any reason, you wish to build a package from an existing template, try the command - - templatepkg -p template-name - -Although that should work smoothly, its not the recommended behaviour, as simplepkg was designed -to deal easily with templates and repositories. - -Building packages ------------------ - -Until now, we just showed simplepkg applications used to manage installations and packages. -But simplepkg can also create packages using createpkg script: it downloads, builds and -packages software that has an available script from a SlackBuild in a repository, working -like a slackware ports system. - -Createpkg works with any SlackBuild repository but works better and is well integrated if -they are compliant with the standards from - - http://slack.sarava.org/trac/wiki/SlackBuilds - -Specifically, createpkg was built to use slackbuilds from http://slack.sarava.org/slackbuilds -through a subversion repository. - -To fetch all scripts from slack.sarava.org, type - - createpkg --sync - -Then, you can list all available script using - - createpkg --list - -To search for a script, use something like - - createpkg --search latex2html - -This searches for a SlackBuild for the program "latex2html". If you want to build that package, -just type - - createpkg latex2html - -The resulting package should be available at /tmp or at the folder specified by the environment -variable $REPOS. To create and install the package, type - - createpkg --install latex2html - -If the package has dependencies listed in a slack-required file that aren't installed in the -system, then createpkg will try to process then before the desired package's SlackBuild: if -the dependencies aren't available in the SlackBuild tree, then createpkg will call simplaret -and try to install the package from a binary repository. If you want to avoid createpkg's -dependency checking, just use it with the flag --no-deps. - -For more information about createpkg, type - - createpkg --help - -or take a look at http://slack.sarava.org/trac/wiki/SlackBuilds. - -Auxiliar applications ---------------------- - -Simplepkg comes also with the following tools: - - - lspkg: show installed packages and its contents - - rebuildpkg: rebuild a package based on its /var/log/packages entry - - repos: creates and manages binary repositories - - mkbuild: app to build slackware build scripts - -The command lspkg is used to show installed packages. Also, Simplepkg comes with an additional helper -tool that recover installed packages which the original .tgz file was lost. The command rebuildpkg -rebuilds a package from their entry in /var/log/packages. As an example, - - rebuildpkg coreutils - -rebuilds the coreutils package using the files, scripts and metainformations stored in -/var/log/packages/ and /var/log/scripts/. - -For their time, scripts repos and mkbuild are used, respectivelly, to create and manage binary repositories -and to create SlackBuild scripts. - -Configuration parameters ------------------------- - -Simplepkg's default config file is /etc/simplepkg/defaults/simplepkg.conf and it keeps parameters used by all scripts. -If you want to change some of its parameters, do not edit this file. Use /etc/simplepkg/simplepkg.conf instead as it -overrides the default settings. - -In this section, we won't cover any parameter that's just used by simplaret, whose settings are covered -in its own documentation. - - - JAIL_ROOT: Where jails are placed by mkjail. Default: "/vservers". - - - ADD_TO_JAIL_LIST: Wheter mkjial should add new jails to /etc/simplepkg/jailist. Default is "1" (enabled). - - - TEMPLATES_UNDER_SVN: Set to yes if your templates will be placed in a subversion repository. Default - is "no" (disabled). - - - TEMPLATE_FOLDER: Where your templates will be located. Default is "/etc/simplepkg/templates" and - dont change it except you know what you're doing. - - - TEMPLATE_STORAGE_STYLE: This variable controls in which folder / subfolder your templates will - be stored. Default value is "own-folder" and you'll just need to change that if you're storing - your templates using an old simplepkg format and wants to keep compatibilty. - -Its important to note that all boolean parameters in the config file can be set either to "1" or "yes" -to enable and "0" or "no" to disable. - -Additional information ----------------------- - -Simplepkg was written by Silvio Rhatto (rhatto at riseup.net) and is released under GPL license. The code -can be obtained from the subversion repository: - - svn checkout http://slack.sarava.org/simplepkg - -Simplepkg's wiki is http://slack.sarava.org/trac/wiki/Simplepkg and its mailing list address is -http://listas.sarava.org/wws/info/slack. - diff --git a/trunk/doc/README.pt_BR b/trunk/doc/README.pt_BR deleted file mode 100644 index 678fe99..0000000 --- a/trunk/doc/README.pt_BR +++ /dev/null @@ -1,449 +0,0 @@ -Simplepkg: gerenciamento de instalações e pacotes -------------------------------------------------- - -Autor: Silvio Rhatto -Licença: GPL - -O simplepkg é um sistema de gerenciamento de sistemas slackware que roda sobre o pkgtool. -Ele é composto por vários scripts que desempenham funções de administração e desenvolvimento de -sistemas do tipo Slackware, procurando fechar um circuito de produção, envolvendo a construção, -a instalação de pacotes e até mesmo a instalação do sistema de forma automatizada. - -Do lado do desenvolvedor/a, ele ajuda na criação de SlackBuilds e construção de pacotes. -Do lado do administrador/a, ele possibilita a instalação automatizada de sistemas, instalação -de pacotes e a criação de "templates" de instalação -- que contém todos os arquivos de configuração, -informações de permissões e scripts de pós-instalação de uma dada máquina ou jaula. - -Documentação ------------- - -A documentação mais atualizada do simplepkg está em http://slack.sarava.org ou juntamente com a última -versão do código. - -Descrição ---------- - -Todas as distribuições de GNU/Linux já tem algum sistema de empacotamento amadurecido. A questão -agora é a praticidade de instalar e controlar o que está instalado, tanto pacotes como arquivos -de configuração de uma máquina, além da facilidade na criação de pacotes. - -Imagine por exemplo se você precisa manter uma lista de pacotes de 200 máquinas slackware, sendo -que algumas são usadas como desktop, outras como servidores web, alguma sendo o servidor de email -e assim por diante. Imagine agora que você perca o disco de algumas dessas máquinas ou que precise -cotidianamente reinstalar ou atualizar um sistema. - -Usar o cd de instalação do slackware e configurar na mão toda a vez que der um pau faria com que -você ficasse louco/a e desperdiçasse muito tempo, além do que sempre ocorre de esquecermos algum -detalhe ou pacote durante a configuração do sistema. Manter um backup completo de cada máquina, -por outro lado, pode ser muito custoso se o número delas for muito grande. - -O simplepkg permite que você mantenha um template para cada grupo de máquinas e com apenas um -comando instalar o template numa partição. Além do template, você precisa configurar o simplepkg -para obter pacotes de um repositório local ou remoto. - -Gerenciar instalações e pacotes não é tudo o que o simplepkg faz. Ele pode ser usado até na -criação de jaula e vservers, podendo manter toda a configuração das máquinas num repositório -Subversion. - -O simplepkg funciona não apenas com o Slackware mas com qualquer port (oficial ou não) que -siga minimamente os padrões oficiais. - -Arquitetura ------------ - -O simplepkg é um conjunto de scripts escritos com a filosofia KISS (Keep It Simple, Stupid) em mente. -Ele é um sistema muito simples, composto pelos seguintes comandos: - - - mkjail: constrói uma jaula/instalação de slackware numa pasta - - templatepkg: criar ou adiciona pacotes a um template - - lspkg: lista pacotes instalados - - jail-update: inverso do jail-commit - - jail-commit: atualiza o template - - rebuildpkg: reconstrói um pacote a partir de sua entrada no /var/log/packages - - simplaret: obtém pacotes de repositórios locais ou remotos - - createpkg: baixa, compila e empacota software de acordo com scripts presentes num repositório - - repos: cria e mantém repositórios - - mkbuild: cria scripts de construção de pacotes - -Instalando o simplepkg ----------------------- - -Para baixar o pacote do simplepkg, vá em http://slack.sarava.org/packages/noarch/. Depois, basta usar -o comando - - installpkg simplepkg-VERSAO-noarch-BUILD.tgz - -Usando o simplepkg ------------------- - -As três principais aplicações desse conjunto são: - - - Gerenciamento de pacotes - - Criação e manutenção de jaulas - - Criação de pacotes - -O gerencamento de pacotes é feito através do simplaret, e por ser algo bem específico está detalhado -no artigo correspondente. As seções a seguir mostrarão como o simplepkg pode ser utilizado para criar -e manter jaulas, assim como também criar pacotes. - -Criando templates de instalação -------------------------------- - -Originalmente, o simplepkg foi desenvolvido para ajudar na automatização de instalações de sistemas -slackware. Para isso, ele trabalha com templates -- listas com pacotes instalados, scripts e arquivos -de configuração -- permitindo criar perfis de instalação que podem ser então usados para instalar o -sistema numa outra partição ou criar um chroot. - -A construção de um template é feita através do programa templatepkg. Para criar um template de nome -"meu-slackware" contendo a lista de pacotes atualmente instalados no seu sistema, digite - - templatepkg -c meu-slackware - -A opção -c (ou --create) criará a pasta /etc/simplepkg/templates/meu-slackware, que conterá os -seguintes componentes: - - - /etc/simplepkg/templates/meu-slackware/meu-slackware.d: cópia de arquivos de configuração - - /etc/simplepkg/templates/meu-slackware/meu-slackware.s: scripts de pós-instalação - - /etc/simplepkg/templates/meu-slackware/meu-slackware.perms: informações sobre arquivos - - /etc/simplepkg/templates/meu-slackware/meu-slackware.template: lista de pacotes - -Esses quatro componentes são suficientes para armazenar todas as características de uma instalação -de slackware: a lista de pacotes controla o software instalado (a partir do conteúdo da pasta -/var/log/packages), a cópia dos arquivos de configuração controla as personalizações feitas para o uso -dos aplicativos e os scripts de pós-instalação cuidam de qualquer rotina que precisa ser realizada -exatamente após a instalação do sistema. Já o arquivo de informações sobre arquivos contém as permissões, -o dono/a e grupo de cada arquivo de configuração presente no template. - -Se você quiser criar um template a partir de uma instalação de slackware presente numa outra partição -do sistema que não seja a raíz, basta usar um comando do tipo - - templatepkg -c meu-slackware /mnt/slackware - -onde /mnt/slackware é o local onde o sistema alternativo está instalado. Após criado, o template possuirá -apenas a lista de pacotes contendo o nome dos aplicativos instalados no seu sistema. Como a pasta -/var/log/packages não preserva a ordem de instalação dos pacotes, então talvez você queira editar manualmente -a lista de pacotes de um template. Para isso, use o comando - - templatepkg -e meu-slackware - -Para adicionar um arquivo de configuração no seu novo template, basta dar um comando como - - templatepkg -a meu-slackware /etc/hosts - -Isso adicionará o arquivo /etc/hosts no template "meu-slackware". Além de salvar o arquivo e copiá-lo -automaticamente quando você instalar seu sistema, o simplepkg ainda pode tomar conta de qualquer alteração -que o /etc/hosts sofrer no sistema, seja mudança no conteúdo do arquivo, dono ou permissão. Se você ainda -estiver armazenando seus templates num repositório svn (o que veremos a seguir), o simplepkg pode ainda -manter um histórico completo das alterações do arquivo. - -ATENÇÂO: evite ao máximo deixar arquivos contendo senhas ou chaves privadas num template. O lugar mais -adequado para deixar esse tipo de coisa é num backup seguro. - -Criando jaulas e replicando instalações ---------------------------------------- - -Uma vez que um template foi criado com uma lista de pacotes e opcionalmente com arquivos de configuração -e scripts de pós-instalação (que serão detalhados a seguir), você pode replicar sua instalação de slackware -utilizando o comando - - mkjail jaula meu-slackware - -Isso cria uma nova árvore do slackware em /vservers/jaula contendo todos os pacotes e arquivos de configuração -do template "meu-slackware". A instalação dos pacotes será feita pelo aplicativo simplaret, que deve estar -configurado corretamente e cuja configuração padrão deve funcionar para a maioria dos casos. - -Se você quiser instalar essa jaula em outro local que não seja a pasta /vservers (esse local padrão pode ser -mudado pelo arquivo de configuração do simplepkg), basta usar um comando do tipo - - ROOT=/mnt mkjail hda2 meu-slackware - -O comando acima faz exatamente o que você está pensando: replica sua instalação slackware em /mnt/hda2, -dispensando totalmente o programa de instalação do slackware! - -Caso nenhum template for especificado, o mkjail utiliza o template /etc/simplepkg/defaults. O simplepkg já vem -com alguns templates padrões, presentes em /etc/simplepkg/defaults/templates. - -Scripts de pós-instalação -------------------------- - -Opcionalmente, é possível manter scripts de pós-instalação num template. Tais script são executados exatamente -após a instalação de uma jaula e cópia de arquivos de configuração pelo mkjail. Para criar ou editar um script -de pós-instalação, use um comando como - - templatepkg -b meu-slackware nome-do-script.sh - -Isso adicionará o script nome-do-script.sh no template "meu-slackware". O mkjail passa dois argumentos para -cada script de pós-instalação: a pasta superior e o nome da jaula ("/mnt" e "hda2" no nosso exemplo anterior). -Assim, um exemplo de script seria algo como - - #!/bin/bash - chroot $1/$2/ sbin/ldconfig - -Listando o conteúdo de um template ----------------------------------- - -Para listar os templates disponíveis ou o conteúdo de um template, use comandos como - - templatepkg -l - templatepkg -l meu-slackware - -Removendo arquivos de um template ---------------------------------- - -Analogamente à forma como se adicona arquivos num template, removê-los pode ser feito com o seguinte comando: - - templatepkg -d meu-slackware /etc/hosts - -Isso remove o arquivo /etc/hosts do template "meu-slackware". - -Apagando um template --------------------- - -Para apagar um template, basta utilizar um comando como - - templatepkg -r meu-slackware - -Atualizando um template ------------------------ - -Agora que já abordamos as opções do templatepkg, é hora de visitarmos um outro aplicativo, desta vez utilizado -para manter um template atualizado. O jail-commit é um script que copia as alterações dos arquivos (conteúdo, -propriedade e permissões) de um template a partir do conteúdo de uma jaula ou instalação. - -Por exemplo, caso se queira copiar as alterações da jaula /mnt/hda2 no template "meu-slackware", basta usar o -comando - - jail-commit /mnt/hda2 meu-slackware - -Além da lista de pacotes do template "meu-slackware" ser atualizada de acordo com a lista de pacotes presente -em /mnt/hda2/var/log/packages, todos os arquivos de configuração presentes no template "meu-slackware" serão -comparados com os correspondentes da pasta /mnt/hda2 e as diferenças são copiadas para o template. Da mesma -forma, as permissões e informação de dono/grupo dos arquivos também é atualizada no template. - -O comando jail-commit possibilita que um template sempre esteja atualizado e refletindo a configuração atual -de uma instalação de slackware. Se você quiser atualizar apenas a lista de pacotes de um template, porém, use - - templatepkg -u meu-template - -Para facilitar ainda mais o controle das alterações do sistema, existe ainda uma facilidade do arquivo -/etc/simplepkg/jailist. Esse arquivo serve, além de outros propósitos descritos na documentação do simplaret, -para que o jail-commit saiba de antemão quais são as instalações de sistema do tipo Slackware presentes numa -máquina, além da instalação principal na raíz do sistema. - -Suponha que uma máquina possua duas instalações de slackware, além da principal (raíz): - - - /mnt/slackware-1 usando o template "slackware-1" - - /mnt/slackware-2 usando o template "slackware-2" - -Se o arquivo /etc/simplepkg/jailist contiver as seguintes linhas, - - /mnt/slackware-1 - /mnt/slackware-2 - -então o comando - - jail-commit - -atualizará o template "slackware-1" de acordo com o conteúdo da jaula /mnt/slackware-1 e o template "slackware-2" -com o conteúdo da jaula /mnt/slackware-2. Se, além desses dois templates, existir um outro de nome "main", então -o jail-commit sem argumentos também copiará as atualizações da instalação raíz, deixando-as no template "main". - -Você pode inclusive colocar uma entrada no crontab do tipo - - 20 4 * * * jail-commit - -para que seus templates sejam atualizados diariamente. Se você ainda possui o envio de emails configurado na sua -máquina, então a saída do jail-commit será enviada pelo cron diariamente para seu email, contendo diffs das alterações -de arquivos de configuração a lista de pacotes adicionados ou removidos no sistema. - -Restaurando arquivos de configuração numa jaula ------------------------------------------------ - -A operação contrária ao que o jail-commit faz também é possível: suponha que você mexeu na configuração do sistema -mas se arrependeu das alterações e deseja voltar a configuração para o modo como ela se encontra no seu template, -basta usar o comando - - jail-update /mnt/hda2 meu-slackware - -Armazenando as configurações no repositório Subversion ------------------------------------------------------- - -Para aumentar ainda mais a flexibilidade e o controle do conteúdo dos templates, é possível armazená-los num -repositório Subversion. Para isso, edite o arquivo /etc/simplepkg/simplepkg.conf e deixe o parâmetro de configuração -TEMPLATES_UNDER_SVN com o valor "yes". - -Depois, crie um repositório subversion para armazenar seus templates, usando algo como - - svnadmin create /var/svn/simplepkg --fs-type fsfs - -Com o repositório criado, basta importar seus templates com o comando - - templatepkg -e file:///var/svn/simplepkg - -A partir daí, o comando jail-commit enviará automaticamente todas as alterações dos templates para o repositório -subversion. Se, por outro lado, você quiser baixar as alterações dos templates que estão no repositório remoto -para sua cópia local, use o comando - - templatepkg -s - -Caso você queira importar uma pasta de templates de um repositório já existente, use - - templatepkg -i file:///var/svn/simplepkg - -onde file:///var/svn/simplepkg é o camninho do repositório. - -Atualização de jaulas ---------------------- - -A atualização de jaulas e sistemas instalados é feita através do simplaret e também utiliza o arquivo -/etc/simplepkg/jailist. Para mais informações a respeito, consulte a documentação do simplaret para mais detalhes. - -Arquiteturas e versões diferentes ---------------------------------- - -O simplepkg foi idealizado para permitir que um mesmo template possa ser usado para criar jaulas de -arquiteturas e versões diferentes de sistemas padrão slackware. A atualização desses sistemas também -é unificada. Essa possibilidade só é permitida se você usa o simplaret e não o swaret como ferramenta -de obtenção de pacotes. - -Por exemplo, para criar uma instalação de slackware 10.1 (assumindo que suas definições de repositórios -do /etc/simplepkg/repos.conf contenham locais com slack 10.1), basta usar o comando - - VERSION=10.1 mkjail minha-jaula template-servidor - -Arquiteturas diferentes também podem ser usadas. Se você está num sistema x86_64 e quer instalar um -slack 10.2 numa partição, experimente - - ARCH=i386 VERSION=10.2 ROOT=/mnt mkjail hda2 meu-slackware - -Note que os templates independem de arquitetura e versão, já que eles só contém nomes de pacotes, -arquivos de configuração e scripts. - -Criando um pacote de um template --------------------------------- - -Se, por algum motivo, você quiser construir um pacote com o conteúdo de um template, experimente -o comando - - templatepkg -p nome-do-template - -No entanto, o simplepkg foi criado para que esse tipo de comportamento seja evitado, já que é mais -simples manter templates de configuração do que pacotes contendo a configuração de uma instalação. - -Construindo pacotes -------------------- - -Até aqui, apenas mostramos os aplicativos do simplepkg usados para a manutenção de instalações -de slackware. No entanto, uma das outras finalidades desta suíte é a construção de pacotes, o -que é feita pelo programa createpkg, Como dito anteriormente, o createpkg: baixa, compila e -empacota software de acordo com scripts presentes num repositório de scripts, funcionando com -um gerenciador de "ports" para slackware. - -O createpkg pode funcionar com qualquer tipo de script de construção de pacotes (SlackBuilds) -mas funcionará melhor se os mesmos seguirem o padrão descrito na página - - http://slack.sarava.org/trac/wiki/SlackBuilds - -Especificamente, o createpkg foi desenvolvido para utilizar os slackbuild disponíveis em -http://slack.sarava.org/slackbuilds. O createpkg trabalha com repositórios do tipo subversion. - -Para obter os scripts do repositório do slack.sarava.org, digite - - createpkg --sync - -Em seguida, você pode listas todos os scripts disponíveis: - - createpkg --list - -Para buscar por um pacote, use - - createpkg --search latex2html - -No caso, a busca é feita pelo SlackBuild do aplicativo "latex2html". Suponha agora que você queira -construir o pacote desse aplicativo: - - createpkg latex2html - -O pacote resultante estará na pasta /tmp ou no valor especificado pela variável de ambiente $REPOS. -Para criar e também instalar o pacote, basta - - createpkg --install latex2html - -Se o pacote possuir dependências listadas num arquivo slack-required e que não estiverem instaladas -no sistema, o createpkg tentará processá-las uma a uma antes de tentar construir o pacote desejado: -se as dependências não forem encontradas no repositório de scripts, então o createpkg tentará -baixá-las de um repositório binário através do simplaret. Se você não quiser que a resolução de -dependências seja seguida, use a opção --no-deps. - -Para mais detalhes de funcionamento, experimente o comando - - createpkg --help - -ou então acesse a página http://slack.sarava.org/trac/wiki/SlackBuilds. - -Aplicativos auxiliares ----------------------- - -O simplepkg acompanha ainda alguns aplicativos auxiliares: - - - lspkg: lista pacotes instalados - - rebuildpkg: reconstrói um pacote a partir de sua entrada no /var/log/packages - - repos: cria e mantém repositórios - - mkbuild: cria scripts de construção de pacotes - -O comando lspkg é um utilitário simples para a visualização de pacotes instalados no sistema. Já o -rebuildpkg ajuda a recuperar pacotes instalados cujo tgz original foi perdido. O comando rebuildpkg -reconstrói um pacote a partir de uma entrada no /var/log/packages. O comando - - rebuildpkg coreutils - -reconstrói um pacote do coreutils usando os arquivos e as metainformações listadas no arquivo -do /var/log/packages/ correspondente ao coreutils. - -Por fim, os scripts repos e mkbuild são os que se encontram na etapa de maior desenvolvimento: repos -cria um repositório de pacotes a partir de uma pasta contendo pacotes do tipo pkgtool e o mkbuild -é um aplicativo para auxiliar a criação de scripts de construção de pacotes que podem ser utilizados -sozinhos ou pelo o createpkg. - -Parâmetros de configuração --------------------------- - -O arquivo de configuração do simplepkg é o /etc/simplepkg/defaults/simplepkg.conf. Ele contém parâmetros de -configuração de todos os scripts, porém neste texto não trataremos das opções específicas ao simplaret, -as quais tem uma seção específica no artigo correspondente. - -Se você quiser alterar algum parâmetro, não edite esse arquivo: use, ao invés dele, o arquivo -/etc/simplepkg/simplepkg.conf, pois este sobrescreve qualquer opção padrão. - - - - JAIL_ROOT: pasta padrão onde as jaulas são criadas pelo mkjail. Valor padrão: "/vservers". - - - ADD_TO_JAIL_LIST: controla se uma jaula criada pelo mkjail deve ser adicionada automaticamente - no arquivo /etc/simplepkg/jailist. O valor padrão é "1" (habilitado). - - - TEMPLATES_UNDER_SVN: indica se os templates estão armazenados num repositório subversion. - O valor padrão é "no" (não). - - - TEMPLATE_FOLDER: indica qual é a pasta de templates. O valor padrão é "/etc/simplepkg/templates" - e não é recomendável alterá-lo. - - - TEMPLATE_STORAGE_STYLE: controla a forma de armazenamento de templates. O valor padrão é - "own-folder" e essa opção apenas deve ser modificada se você armazena seus templates num - formato antigo do simplepkg e deseja manter compatibilidade. - -Vale lembrar que todas as opções booleanas (isto é, que podem ser apenas habilitadas ou desabilitadas) -do simplepkg.conf tem os seguintes valores permitidos: "1" e "yes" para habilitado e "0" ou "no" para -desabilitado. - -Mais informações ----------------- - -O simplepkg foi escrito por Silvio Rhatto (rhatto at riseup.net) sob licença GPL e seu código fonte é -disponibilizado através do repositório subversion: - - svn checkout http://slack.sarava.org/simplepkg - -O wiki de desenvolvimento está em http://slack.sarava.org/trac/wiki/Simplepkg e o endereço da lista -de discussão utilizada para discussões sobre simplepkg ou mesmo distribuições e pacotes do tipo -Slackware é http://listas.sarava.org/wws/info/slack. - diff --git a/trunk/doc/README.simplaret b/trunk/doc/README.simplaret deleted file mode 100644 index 26c8916..0000000 --- a/trunk/doc/README.simplaret +++ /dev/null @@ -1,326 +0,0 @@ -simplaret: simplepkg retrieval tool ------------------------------------ - -Simplaret is a simplepkg tool used to download packages from local and remote repositories. -With simplaret, one can grab packages for all archictectures and versions of slackware-like -distributions that follows the mirror guidelines, allowing an easy management all -jails and slackware installations in a machine, no matter wich arquiteture or version -each one has. - -It was inspired in swaret behavior but don't tries to get its complexity level, but -execute package download in a different way, where the local repository is organized -by archictecture and version. It can also search for packages. It runs on top of pkgtool -and is totally non-instrusive and can search, add, remove and upgrade packages. - -Documentation -------------- - -The always updated english documentation is hosted at http://slack.sarava.org/simplaret-en - -Downloading and installing --------------------------- - -Simplaret comes with simplepkg, wich installation and configuration is detailed -at http://slack.sarava.org/simplepkg. Simplaret uses -/etc/simplepkg/simplepkg.conf for its definitions and /etc/simplepkg/repos.conf -for repository information. - -The default configuration is placed, respectively, at -/etc/simplepkg/defaults/simplepkg.conf and /etc/simplepkg/defaults/repos.conf and -should work for most people, but if you want to change something please don't -edit the default configuration files as the default setting may change in -future releases. If you have a /etc/simplepkg/repos.conf file, then simplaret -will just ignore the default repos.conf. - -Using simplaret ---------------- - -Simplaret stores its data in system wide folders. Then, some funcionality will just be available -if its run with root user capabilities. The first thing you need to do with simplaret is to fetch -repository metadata, using - - simplaret --update - -or simply - - simplaret update - -as simplepkg supports both command line behaviour (--update or just update). After that, you can -search for packages using commands like - - simplaret search ekiga - -The result should be something like - - REPOS repository sarava, arch: i386, version: 11.0: ekiga-2.0.5-i586-1rd.tgz - -As we'll see afterwards, "REPOS" means the repository type, "sarava" is the repository name, -"arch" is the package architecture (i386 in this case) and "version" is the repository version -(11.0 in this case). - -To install this package, just type - - simplaret install ekiga - -By default, if simplaret finds in the repository a slack-required file for this package (i.e, the -file ekiga.slack-required in the same folder of the binary package) then it will try to install -all unmet dependencies. This default behaviour can be disabled through config file parameters. - -If you just want to download the package, type - - simplaret get ekiga - -In the case of simplaret finds more than one package with the same name, it will get in the order -that the "search" option shows them. The search precedence can also be defined by config file -parameters. For instance, the command - - simplaret search kernel-generic - -can return something like - - ROOT repository sarava, arch: i386, version: 11.0: kernel-generic-2.6.17.13-i486-1.tgz - ROOT repository sarava, arch: i386, version: 11.0: kernel-generic-2.6.18-i486-1.tgz - -So the command - - simplaret install kernel-generic - -will attempt to install the package "kernel-generic-2.6.17.13-i486-1.tgz" and not the file -"kernel-generic-2.6.18-i486-1.tgz". If you want to force simplaret to get and specific package, -use its complete file name: - - simplaret install kernel-generic-2.6.18-i486-1.tgz - -If a package is already installed in the system, the --install option will try to upgrade it -if the version or build number between the installed package and the one in the repository -are different. So the command - - simplaret install simplepkg - -updates simplepkg in the case there's a new version. To remove a package, type - - simplaret remove nome-do-pacote - -That's just an alias for the standard removepkg command. - -Simplaret stores downloaded packages in a system folder that defaults to /var/simplaret. -As you get more and more packages, simplaret will consume more space ir your disk. To -erase your local repository folder, use the command - - simplaret purge - -This will erase just the packages from the current arch and version. Details about how to -erase the repository for different arch and version are in another session. - -You can also force simplaret to erase just old packages. The following command erases just -packages older than six weeks or more: - - simplaret purge -w 3 - -Downloading patches and upgrading the system --------------------------------------------- - -Simplaret hasn't just about package installing and removal, it has two more important -features: patches retrieval and application. Assuming that the patches repository of -your slackware flavour is correctly configured (what should work with almost everyone -with the default configuration), you can fetch the available patches using the command - - simplaret get-patches - -If you don't just donwload but also apply those patches, use - - simplaret upgrade - -Working with more than one architecture and version ---------------------------------------------------- - -Until now we just looked what is the requirement for all package management system: package -retrieval, installation, search, upgrade and dependency resolution. What makes simplaret -different from another tools is the ability to deal with different architectures and versions -and slackware installations. - -The features descibed in this section will just make sense after you read the next section, when -we'll talk about multiple slackware installations and jails in the same computer. - -Suppose you're running Slackware (arch i386) bit wants to update the package list from Slamd64 -version 11.0 (arch x86_64). To do that, just type - - ARCH=x86_64 VERSION=11.0 simplaret update - -This command grabs the Slamd64 package list without confliting in any way with the standard and -already downloaded i386 Slackware package list. This doesn't happens because simplaret stores -metadata from different archs and versions at different folders. - -Its optional to pass ARCH and VERSION environment variables to simplaret. If one or none of them -was specified, simplaret uses the standar system value, obtained from the file /etc/slackware-version, -or uses config parameters to do that. - -As an example, to search for a package in the arch powerpc (Slackintosh) version 11.0, just type - - ARCH=powerpc VERSION=11.0 simplaret search package-name - -All command previously mentioned can work that way, except those that install or remove packages as -its dangerous to mix packages from different archs and versions in the same system. - -Working with multiple installations ------------------------------------ - -The previously section mentions a feature that just makes sense in systems where there's more than -one slackware-like installation using different archs and versions. - -Say you have a x86_64 machine with three installed systems: - - - Slamd64 11.0 at the root folder - - Slackware 11.0 at /mnt/slackware-1 - - Slackware 10.2 at /mnt/slackware-2 - -In the case of package install or patch retrieval and application, simplaret supports the environment -variable ROOT to specify which folder simplaret should look for a system. - -Then, to install a package at /mnt/slackware-1, just type - - ARCH=i386 VERSION=11.0 simplaret update - ROOT=/mnt/slackware-1 simplaret install package-name - -The first command just updates the package list and the second makes simplepkg install the package with -using /mnt/slackware-1 arch and version. If you want to do the same at /mnt/slackware-2, use the analogous -command - - ARCH=i386 VERSION=10.2 simplaret update - ROOT=/mnt/slackware-2 simplaret install package-name - -There's also a feature to make patch retrieval and application with just one command, using the file -/etc/simplepkg/jailist. This file is used by simplepkg's mkjail script to store with jails you have -on your system but is also used by simplaret to upgrade all jails with just one command. - -Considering that your box has the three previously mentioned slackware installation. Then, to add -/mnt/slackware-1 and /mnt/slackware-2 in the automatic upgrade list, add the following lines in your -/etc/simplepkg/jailist (without spaces): - - /mnt/slackware-1 - /mnt/slackware-2 - -The root system doesn't need to be added in this file. Then, you can get the patches for all your three -systems with the command - - simplaret get-patches - -To get the patches and/or apply them in all jails (including the root system), use - - simplaret upgrade - -This feature makes easier to keep all your installations always upgraded. - -The repos.conf file -------------------- - -Now that we just talked about all simplaret features, its time to take a tour at its configuration -files. The first one we'll say about is the repository definition file, /etc/simplepkg/repos.conf. - -If you don't mind to make an advanced simplaret usage, then probably you can just leave this section -as the default config should work for almost all standard situations and you'll just need to edit -repos.conf to change repository priorities. - -The repos.conf file contains one repository definition per line using the following syntax: - - TYPE[-ARCH][-VERSION]="name%URL" - -The content in brackets are optional depending on the repository type as we'll see later in this -section. The repository types supported by simplaret are: - - - PATCHES: used for repositories containing patches and which file metadata is the file - FILE_LIST instead the standard FILELIST.TXT; example: - - PATCHES-i386-11.0="sarava%http://slack.sarava.org/packages/slackware/slackware-11.0/patches/" - - This defines a patches repository for arch i386 (official Slackware), version 11.0 and named - as "sarava". - - Its optional to have a PATCHES definition in order to get patches: the ROOT repository definition - just take care of that and you'll just need to use a PATCHES definition if you want to give - precedence to some patches repository over all other definition types. - - - ROOT: this type specifies the default slackware-like repository, where the content is sorted - by version. An official slackware repository then is defined as - - ROOT-i386="tds%http://slackware.mirrors.tds.net/pub/slackware/" - - ROOT repositories needs just the arch definition, a name and an URL. In the previous case, - we have a ROOT repository called "tds". It doesn't need any version information as its already - considers tha the content is sorted in folders like - - http://slackware.mirrors.tds.net/pub/slackware/slackware-10.2/ and - http://slackware.mirrors.tds.net/pub/slackware/slackware-11.0/ - - - REPOS: this repository type ir arch and version oriented, like - - REPOS-i386-11.0="sarava%http://slack.sarava.org/packages/slackware/slackware-11.0/" - - In the above case, a repository called "sarava" is defined using arch i386 and version 11.0 - with URL http://slack.sarava.org/packages/slackware/slackware-11.0/. This repository type is - recommended when using non-official repositories. - - - NOARCH: the last type is used to define repositories where packages are arch and version - independent, like - - NOARCH="sarava%http://slack.sarava.org/packages/noarch" - -In any repository type, the supperted URL schemes are http://, ftp:// or file:// (for local -repositories). - -As simplaret supports more than one repository definition for each type, arch or version, each -definition has its own name. Definitions can have the same name just if they're dont use the -same repository type and/or arch and version. - -There's also a priority rule between the repository types wich defines a precedence order. -Repositories are searched according the following order: - - - PATCHES has the highest priority: if a package from a given arch and version is not found - in the first (if existent) PATCHES definition, then the next one is searched until all - PATCHES definitions are searched. - - - Then, the package is searched in all ROOT defintions in the order they appear at repos.conf. - - - The next searched repository type is REPOS in the specified arch an version, in the order - they appear at repos.conf. - - - At last, NOARCH type is searched in the order they're defined. - -In the case you're issuing an upgrade or just geting patches, simplaret by default will just -search in PATCHES and ROOT definitions. - -At REPOS and ROOT is also possible to specify its internal search order according its subfolders. - -Configuration file simplepkg.conf ---------------------------------- - -Simplaret also stores its configurations inside simplepkg's configuration file -/etc/simplepkg/simplepkg.conf. This file is well commented and you should find there a description -of all supported options. - -But why use that? ------------------ - -You may ask why someone wishes to use such tool. - -Simplaret was written with a *x86 environment in mind, where lots of jails with different archs -and versions are installed. Suppose a x86_64 with the following chroots installed: - - - slamd64 12.0 - - slackware 12.1 - - slackware 11.0 with additional i686 packages - - uSlack (i386 uClibc) - -Keep all this stuff update manually is really a headache. Simplaret just tries to make it trivial. - -Additional information ----------------------- - -Simplaret was written by Silvio Rhatto (rhatto at riseup.net) and is released under GPL license. The code -can be obtained from the subversion repository: - - svn checkout http://slack.sarava.org/simplepkg - -Simplepkg's wiki is http://slack.sarava.org/trac/wiki/Simplepkg and its mailing list address is -http://listas.sarava.org/wws/info/slack. - diff --git a/trunk/doc/README.simplaret.pt_BR b/trunk/doc/README.simplaret.pt_BR deleted file mode 100644 index 2154cb8..0000000 --- a/trunk/doc/README.simplaret.pt_BR +++ /dev/null @@ -1,451 +0,0 @@ -simplaret: ferramenta para obtenção de pacotes ----------------------------------------------- - -O simplaret é a ferramenta do simplepkg utilizada para obter pacotes de repositórios locais -ou remotos. Com ele, você pode não só baixar pacotes do seu sistema Slackware como também pode -baixar de qualquer versão ou arquitetura cujo repositório siga os Mirror Guidelines do Slackware, -como por exemplo Slamd64 e Slackintosh, permitindo que você gerencie facilmente todas as suas -jaulas e instalações de Slackware, independentemente da arquitetura ou versão que elas utilizem. - -Além da obtenção, o simplaret ainda pode fazer a instalação, a remoção ou a atualização dos -pacotes de um sistema e também das demais jaulas existentes numa máquina. - -O simplaret é totalmente não-intrusivo no sistema e roda sobre o pkgtool. - -Documentação ------------- - -A documentação atualizada do simplaret se encontra em http://slack.sarava.org/simplaret. - -Obtendo e instalando --------------------- - -O simplaret acompanha o simplepkg e por isso sua instalação é feita baixando o pacote do simplepkg -em http://slack.sarava.org/packages/noarch/ e em seguida instalando-o com o comando - - installpkg simplepkg-VERSAO-noarch-BUILD.tgz - -A partir daí você já pode utilizar o simplaret para baixar pacotes dos repositórios padrão ou -então editar a lista de repositórios do arquivo /etc/simplepkg/repos.conf ou a configuração -do aplicativo pelo arquivo /etc/simplepkg/simplepkg.conf. - -A configuração padrão de repositórios no simplaret se encontra em -/etc/simplepkg/defaults/repos.conf, mas não recomendamos você editá-la. Use, ao -invés disso, o /etc/simplepkg/repos.conf para sua configuração personalizada: -se o simplaret encontrar esse arquivo, ele simplesmente ingorará as definições -padrão de repositório. - -Usando o simplaret ------------------- - -Em geral, como o simplaret armazena as informações em pastas do sistema, algumas funcionalidades -só estarão disponíveis quando o mesmo é rodado pelo superusuário do sistema. - -Antes de explorar todas as funcionalidades do simplaret, é necessário atualizar a lista de -pacotes para sua arquitetura e versão, o que pode ser feito com o comando - - simplaret --update - -ou simplesmente - - simplaret update - -já que o simplaret suporta que suas opções básicas de linha de comando sejam passas precedidas -por dois hífens ou não (--update ou update). - -Depois de atualizar a lista de pacotes, experimente buscar por um pacote com um comando do tipo - - simplaret search ekiga - -O resultado pode ser algo do tipo - - REPOS repository sarava, arch: i386, version: 11.0: ekiga-2.0.5-i586-1rd.tgz - -Como veremos adiante, "REPOS" significa o tipo de repositório, "sarava" é o nome do -repositório, "arch" mostra a arquitetura do pacote e do repositório (i386, no caso) -e "version" a versão do repositório (11.0, no caso). - -Para instalar esse pacote, basta o comando - - simplaret install ekiga - -Por padrão, se o simplaret encontrar no repositório um arquivo slack-required referente -ao pacote en questão (ou seja, um arquivo ekiga.slack-required na mesma pasta que o pacote -do ekiga, neste caso), então o simplaret tentará instalar todos os requisitos contidos nesse -slack-required, caso já não estejam instalados no sistema. Essa resolução de dependências -automática pode, no entanto, ser desabilitada através de um parâmetro de configuração, como -veremos a seguir. - -Se você apenas quiser baixar o pacote, digite apenas - - simplaret get ekiga - -No caso do simplaret encontrar mais de um pacote com o mesmo nome, ele baixará na ordem que -a opção "search" listá-los, sendo que essa precedência é definida de acordo com a ordem em -que os repositórios estão listados no arquivo de configuração. Por exemplo, o comando - - simplaret search kernel-generic - -pode retornar algo como - - ROOT repository sarava, arch: i386, version: 11.0: kernel-generic-2.6.17.13-i486-1.tgz - ROOT repository sarava, arch: i386, version: 11.0: kernel-generic-2.6.18-i486-1.tgz - -Assim, o comando - - simplaret install kernel-generic - -instalará o pacote "kernel-generic-2.6.17.13-i486-1.tgz" ao invés do pacote -"kernel-generic-2.6.18-i486-1.tgz". Caso você queira forçar a instalação do -segundo pacote, basta especificá-lo com o nome completo: - - simplaret install kernel-generic-2.6.18-i486-1.tgz - -Se um pacote já estiver instalado no sistema, a opção install fará o upgrade do mesmo, caso -a versão ou o build number do pacote presente no repositório for diferente da instalada no -sistema. Assim, o comando - - simplaret install simplepkg - -atualiza o simplepkg caso haja uma nova versão disponível nalgum repositório. - -Para remover um pacote, digite - - simplaret remove nome-do-pacote - -o que na verdade é apenas uma chamada indireta ao removepkg. - -O simplaret armazena pacotes baixados de repositórios numa pasta local do sistema, que -por padrão é /var/simplaret. Conforme você vai baixando e instalando pacotes, essa pasta -tende a crescer e ocupar muito espaço. Para apagar os pacotes, basta usar o comando - - simplaret purge - -Isso apagará apenas os pacotes da arquitetura e versão usadas atualmente. Detalhes de -como apagar os pacotes de todas a arquiteturas e versões serão dados numa seção seguinte. - -Você também pode forçar o simplaret a apagar apenas pacotes antigos. O comando a seguir -apaga apenas os pacotes baixados a três semanas ou mais (ou seja, os pacotes baixados a -menos de três semanas continuam armazenados): - - simplaret purge -w 3 - -Baixando patches e atualizando o sistema ----------------------------------------- - -O simplaret possui, além do básico do gerenciamento de pacotes, duas funcionalidades -adicionais: a obtenção e a aplicação de patches (pacotes contendo atualizações e -correções de segurança). - -Assumindo que os repositórios contendo patches para sua distribuição do tipo Slackware -estejam corretamente configurados, o que ocorre com a configuração padrão que acompanha -o simplepkg e que veremos a seguir como alterá-la, você pode baixar os patches disponíveis -para o seu sistema com o comando - - simplaret get-patches - -Se você quiser não só baixar mas também atualizar seu sistema, isto é, fazer um upgrade com -os patches disponíveis, use - - simplaret upgrade - -Trabalhando com múltiplas arquiteturas e versões ------------------------------------------------- - -Até aqui vimos apenas o que é a obrigação de qualquer sistema de gerenciamento de pacotes possuir: -obtenção de pacotes, instalação, busca e atualização do sistema. O que diferencia o simplaret das -outras ferramentas, além do esquema de resolução de dependências, é sua capacidade de lidar -simultaneamente com múltiplas arquiteturas, versões e até instalações de sistemas do tipo Slackware. - -O uso dos seguintes comandos só fará sentido à luz da próxima seção, onde trataremos a respeito de -múltiplas instalações e jaulas num mesmo computador, porém é um pré-requisito para entendê-la. - -Supondo que você esteja rodando Slackware (arquitetura i386) mas que queira atualizar a lista de -pacotes do sistema Slamd64 versão 11.0 (arquitetura x86_64), basta usar o comando - - ARCH=x86_64 VERSION=11.0 simplaret update - -Esse comando baixará a lista de pacotes para o Slamd64 sem conflitar de nenhuma forma com a lista -e os pacotes já baixados para o Slackware. Isso acontece porque o simplaret armazena as informações -e os pacotes de cada repositório em pastas próprias, organizadas de acordo com a arquitetura e versão. - -Passar as variaveis ARCH e VERSION para o simplaret é opcional. Se qualquer uma delas não foi especificada, -o simplaret utilizará o valor padrão do seu sistema, usualmente obtido do arquivo /etc/slackware-version -ou então especificada através do arquivo de configuração do simplepkg. - -Por exemplo, para pesquisar por um pacote da arquitetura powerpc (distribuição Slackintosh) na versão 11.0, -basta o comando - - ARCH=powerpc VERSION=11.0 simplaret search nome-do-pacote - -Todos os comandos apresentados anteriormente funcionarão dessa maneira, à exceção daqueles que instalam ou -fazer a atualização de pacotes, já que em geral é destrutivo misturar pacotes de arquiteturas e versões -diferentes num mesmo sistema. - -Trabalhando com múltiplas instalações -------------------------------------- - -A funcionalidade apresentada na seção anterior só faz sentido quando existirem sistemas, jaulas e/ou -vservers instalados num mesmo computador. - -Suponha que você possua uma máquina x86_64 com três sistemas instalados: - - - Slamd64 11.0 na raíz - - Slackware 11.0 em /mnt/slackware-1 - - Slackware 10.2 em /mnt/slackware-2 - -No caso da instalação de pacotes, da obtenção e aplicação de atualizações, o simplaret suporta a -variável de ambiente ROOT para especificar qual é a pasta na qual o simplaret deve buscar o sistema. - -Para instalar um pacote no Slackware contido em /mnt/slackware-1, basta usar os comandos - - ARCH=i386 VERSION=11.0 simplaret update - ROOT=/mnt/slackware-1 simplaret install nome-do-pacote - -O primeiro comando apenas atualiza a lista de pacotes e o segundo faz com que o simplaret baixe -o pacote da arquitetura e versão do sistema presente em /mnt/slackware-1 bem como efetue sua instalação. - -Para o caso da instalação em /mnt/slackware-2, o uso é análogo: - - ARCH=i386 VERSION=10.2 simplaret update - ROOT=/mnt/slackware-2 simplaret install nome-do-pacote - -Existe ainda uma facilidade para que a obtenção e aplicação de atualizações seja feita de forma única, -através do arquivo /etc/simplepkg/jailist. Esse arquivo serve, além de outros propósitos descritos na -documentação do simplepkg, para que o simplaret saiba de antemão quais são as instalações de sistema -do tipo Slackware presentes numa máquina, além da instalação principal na raíz do sistema. - -Considerando que a máquina possua as três instalações citadas no início deste tópico, a atualização -automática das mesmas pode ser feita quando o arquivo /etc/simplepkg/jailist contiver as seguintes -linhas (sem espaços no início de cada uma): - - /mnt/slackware-1 - /mnt/slackware-2 - -O sistema principal, contido na raíz do sistema, não precisa estar listado nesse arquivo. Se todas -as suas instalações de sistema do tipo Slackware estiverem constando corretamente no /etc/simplepkg/jailist, -o seguinte comando baixará as atualizações disponíveis para todas elas, incluindo o sistema contido na raíz: - - simplaret get-patches - -Analogamente, o seguinte comando baixará e/ou aplicará todas as atualizações disponíveis em todas as -instalações, incluindo o sistema contido na raíz: - - simplaret upgrade - -Desse modo, o gerenciamento de pacotes numa máquina que contenha mais de uma instalação do tipo Slackware -fica unificada e consequentemente simplificada. - -O arquivo repos.conf --------------------- - -Agora que o comportamento do simplaret foi delineado, é importante descrever o arquivo de definição de -repositórios, o /etc/simplepkg/repos.conf. Se você não pretende fazer um uso avançado do simplaret, -provavelmente pode deixar de ler esta e a próxima seção, já que para o uso corriqueiro do simplaret -você provavelmente não precisará alterar seu repos.conf, a não ser que queira mudar o espelho de download -dos seus pacotes ou montar um esquema avançado para a escolha e priorização de repositórios. - -O arquivo /etc/simplepkg/repos.conf contém uma definição de repositório por linha e a sintaxe de cada -uma delas é: - - TIPO[-ARQUITETURA][-VERSAO]="nome%URL" - -O conteúdo demarcado por colchetes é opcional dependendo do tipo de repositório, como veremos a seguir. -Os tipos de repositório aceitos pelo simplaret são: - - - PATCHES: definição para repositórios que contenham patches (pacotes de atualização) e cuja lista - de arquivos é FILE_LIST e não FILELIST.TXT; exemplo: - - PATCHES-i386-11.0="sarava%http://slack.sarava.org/packages/slackware/slackware-11.0/patches/" - - No caso da definição acima, temos um repositório de patches para a arquitetura i386 (distribuição - Slackware), versão 11.0 e o nome dado ao repositório é "sarava". - - Possuir uma definição do tipo PATCHES é opcional para ter acesso às atualizações: a definição - de repositório ROOT, que veremos em seguida, já lida com patches: o tipo de repositório PATCHES - serve apenas se você quiser utilizar algum repositório não-oficial como fonte de patches - prioritária, já que repositório PATCHES são pesquisados pelo simplaret antes de qualquer outro. - - Em resumo, se você não tiver um bom motivo para usar esse tipo de repositório, evite-o. - - - ROOT: são tipos de repositórios cujo conteúdo está dividido por versão. O exemplo tradicional - deste caso é o próprio repositório oficial das distribuições: - - ROOT-i386="tds%http://slackware.mirrors.tds.net/pub/slackware/" - - Repositórios ROOT necessitam apenas de uma definição de arquitetura, um nome e uma URL. No caso - acima, temos a definição de repositório ROOT de nome "tds", ou seja, não há definição de versão, - já que o simplaret considerará que a versão desejada está numa subpasta dessa URL. Ou seja, - definições ROOT implicam que as pastas contendo pacotes de cada versão estejam bem separadas, - ou seja, pastas como http://slackware.mirrors.tds.net/pub/slackware/slackware-10.2/ e - http://slackware.mirrors.tds.net/pub/slackware/slackware-11.0/. - - - REPOS: este tipo de repositório é orientado a arquitetura e versão, como por exemplo - - REPOS-i386-11.0="sarava%http://slack.sarava.org/packages/slackware/slackware-11.0/" - - No caso acima, um repositório de nome "sarava" é definido para a arquitetura i386 e versão - 11.0 com a URL http://slack.sarava.org/packages/slackware/slackware-11.0/. Esse tipo de definição - é recomendado para repositórios não-oficiais. - - - NOARCH: o último tipo de definição é usado para repositórios cujos pacotes são independentes - de arquitetura e versão da distribuição. Como exemplo temos um repositório do Projeto Slack: - - NOARCH="sarava%http://slack.sarava.org/packages/noarch" - -Em qualquer tipo de repositório, a URL pode ser do tipo http://, ftp:// ou file:// (para repositórios -locais). - -Como podem haver mais de uma definição de repositório para cada tipo, versão e/ou arquitetura, -as mesmas são diferenciadas de acordo com o nome. Definições de repositório podem ter nomes idênticos, -desde que se refiram a tipo de repositório e/ou arquitetura e versão diferentes. - -Existe ainda uma prioridade dentre tipos de repositório e ordens de precedência. Numa pesquisa, -repositórios são pesquisados de acordo com a seguinte ordem: - - - PATCHES tem prioridade mais alta: caso um pacote de uma dada arquitetura e versão não seja - encontrado no primeiro repositório PATCHES do repos.conf, o próximo repositório definido na - ordem em que ele aparece no arquivo é pesquisado, e assim por diante. - - - Em seguida, pacotes são procurados nas definições ROOT da arquitetura em questão, na ordem - em que aparecem no repos.conf. - - - Depois, são os pacotes de repositórios REPOS daquela arquitetura e versão são pesquisados, - na ordem em que aparecem no repos.conf. - - - Por fim, repositórios NOARCH são pesquisados, na ordem em que são definidos. - -Em resumo, o simplaret tem uma ordem de precedência e execução de repositórios e para busca e obtenção -de pacotes: pacotes são exibidos de acordo com a ordem e precedência descritas acima. No caso da ontenção -de pacotes, o primeiro repositório que possuí-lo será utilizado, isto é, caso o pacote não for solicitado -explicitamente com seu nome de arquivo completo mas sim apenas com seu nome. - -No caso da obtenção de patches, por padrão apenas repositórios do tipo PATCHES e ROOT são pesquisados, -a não ser que isso seja configurado como contrário. - -Em repositórios do tipo REPOS e ROOT ainda é possível, através de parâmetros de configuração, explicitar -a ordem de pastas que são pesquisadas dentro dos repositórios, algo que veremos a seguir e facilita no -caso do usuário estar interessado em dar prioridade para aplicativos em fase de testes (usualmente -armazenados na pasta testing/) ou pacotes antigos (pasture). - -Parâmetros de configuração do simplepkg.conf --------------------------------------------- - -Nesta seção os parâmetros do arquivo de configuração /etc/simplepkg/simplepkg.conf relevantes ao -simplaret estão descritos. Para uma lista completa de todos os parâmetros disponíveis, consulte o -simplepkg.conf contido no pacote do simplepkg. Aqui estão descritos apenas os principais, que são: - - - STORAGE: local de armazenameto dos pacotes baixados e das informações de repositório. - O valor padrão é /var/simplaret/packages. - - - PATCHES_DIR: local de armazenamento de pacotes que são patches (atualizações), isto é, o - local de armazenamento de pacotes de repositórios do tipo PATCHES (e eventualmente de - patches encontrados em repositórios do tipo ROOT, como veremos a seguir). O valor padrão - é /var/simplaret/patches. - - - SIMPLARET_DOWNLOAD_FROM_NEXT_REPO: indica se o simplaret deve tentar baixar um pacote do - próximo repositório (caso exista) quando o download do repositório atual tiver falhado. - Valores possíveis são "1" ou "yes" para habilitar a opção (que é o comportamento padrão) - ou "0" ou "no" para desabilitá-la. - - - SIMPLARET_PURGE_PATCHES: indica se o conteúdo da pasta de patches também deve ser apagado - quando o comando "simplaret --purge" é chamado. Use "yes" ou "1" para habilitar e "no" ou - "0" para desabilitar. O valor padrão é "1". - - - SIMPLARET_PURGE_WEEKS: controla o número de semanas a partir do qual o simplaret irá apagar - pacotes quando chamado com o comando "simplaret --purge", o que é equivalente a usar o - comando "simplaret --purge -w N". O valor padrão é "3". Para desabilitar essa opção, atribua - o valor "0". - - - PASSIVE_FTP: Indica se o simplaret deve fazer as transferências de FTP no modo passivo. - O valor padrão é "1" (habilitado). - - - HTTP_TOOL: especifica qual a ferramenta para obtenção de arquivos via protocolo HTTP. - As opções disponíveis são "curl" e "wget", sendo que a opção padrão é "curl". - - - FTP_TOOL: especifica qual a ferramenta para obtenção de arquivos via protocolo FTP. - As opções disponíveis são "curl", "wget" e "ncftpget", sendo que a opção padrão é "curl". - - - CONNECT_TIMEOUT: tempo máximo de espera para uma conexão de rede, dado em segundos. - O valor padrão é "20". - - - ROOT_PRIORITY: especifica a ordem de prioridades das pastas de repositórios do tipo - ROOT numa pesquisa. O valor padrão é "patches slackware extra testing pasture", - indicando que a pasta de patches tem precedência sobre todas as outras no repositório, - sendo seguida pela pasta slackware e depois pelas extra, testing e pasture. Como - podem existir nomes de pacotes idênticos nessas pastas, o estabelecimento de uma - ordem se faz necessária. - - - REPOS_PRIORITY: da mesma forma como repositorios ROOT necessitam de uma prioridade - de pesquisa em pastas, este parâmetro de configuração especifica a prioridade de - pastas em repositórios do tipo REPOS. O valor padrão é - "patches slackware extra testing pasture". - - - SIGNATURE_CHECKING: indica se o simplaret deve checar pela assinatura dos pacotes - baixados, caso ela esteja disponível. Você deve ter a chave pública do distribuidor - dos pacotes no seu chaveiro. O valor padrão é "0" (desabilitado). - - - DEPENDENCY_CHECKING: indica se o simplaret deve trabalhar com a resuloção de dependências - caso ele encontre, no repositório, um arquivo slack-required correspondente ao pacote que - está sendo instalado. O valor padrão é "1" (habilitado). - - - DOWNLOAD_EVEN_APPLIED_PATCHES: indica de o simplaret deve baixar todos os patches - disponíveis a uma dada instalação de sistema do tipo Slackware, mesmo que os mesmo - já se encontrem aplicados. Esta opção é útil se você quiser manter uma cópia local - das atualizações existentes para seu sistema. O valor padrão é "0" (desabilitado). - - - CONSIDER_ALL_PACKAGES_AS_PATCHES: especifica se o simplaret deve, durante a obtenção - de pacotes de atualização, procurar por atualizações também nos tipos de repositórios - REPOS e NOARCH. Com essa opção, o simplaret faz uma pesquisa pelo pacote e, se sua versão - ou buildnumber da primeira ocorrência não bater com as do pacote atualmente instalado, - ele baixa e o aplica, mesmo que seja um pacote de repositórios do tipo REPOS ou NOARCH. - O valor padrão é "0" (desabilitado). O uso dessa opção não é muito recomendado por poder - causar confusão e deixar o simplaret mais lento, mas pode ser útil caso você esteja - usando um repositório não-oficial que sempre atualiza seus pacotes. - - - STORE_ROOT_PATCHES_ON_PATCHES_DIR: controla se o simplaret deve armazenar os patches baixados - de repositórios do tipo ROOT na mesma pasta de armazenamento de patches provenientes de - repositórios do tipo PATCHES. É uma opção útil apenas se você quiser manter todos os patches - de repositórios ROOT e PATCHES num mesmo local. O valor padrão é "0" (desabilitado). - -Vale lembrar que todas as opções booleanas (isto é, que podem ser apenas habilitadas ou desabilitadas) -do simplepkg.conf tem os seguintes valores permitidos: "1" e "yes" para habilitado e "0" ou "no" para -desabilitado. - -Mas para quê serve isso? ------------------------- - -Você pode estar se perguntando: para que mais um gerenciador de pacotes para o Slackware e quem utilizaria -uma ferramenta que baixa pacotes de várias arquiteturas? - -O simplaret foi escrito tendo em mente um ambiente *86 onde várias jaulas de diferentes arquiteturas estão -instaladas. Suponha por exemplo uma máquina x86_64 que possua as seguintes jaulas: - - - Slamd64 12.0 - - Slackware 12.1 - - Slackware 11.0 com pacotes adicionais em i686 - - ucSlack (uClibc para i386) - -O condenado/a em questão que roda todas essas jaulas, pelos mais diversos motivos, pode ter uma grande dor -de cabeça para manter os pacotes em ordem de forma manual. Com o simplaret e eventualmente com o simplepkg, -a tarefa se torna trivial. - -Além disso, as inúmeras novas tecnologias de virtualização poderão necessitar de um sistema de gerenciamento -de pacotes que trabalha simultaneamente com múltiplas arquiteturas e versões. - -Mesmo que você possua apenas um único sistema do tipo Slackware em seu computador ou trabalhe apenas com uma -única arquitetura e/ou versão, o simplaret possui todas as funcionalidades necessárias para facilitar seu -dia-a-dia de gerenciamento de pacotes. - -Mais informações ----------------- - -O simplaret foi escrito por Silvio Rhatto (rhatto at riseup.net) e é disponibilizado dentro do pacote do -simplepkg e sob a licença GPL. Para obter o código fonte, digite - - svn checkout http://slack.sarava.org/simplepkg - -O wiki de desenvolvimento é http://slack.sarava.org/trac/wiki/Simplepkg e o endereço da lista de discussão -utilizada para discussões sobre simplaret, simplepkg ou mesmo distribuições e pacotes do tipo Slackware é -http://listas.sarava.org/wws/info/slack. - -- cgit v1.2.3