Voglio solo creare un file RPM per distribuire il mio "foobar" binario Linux, con solo un paio di dipendenze. Ha un file di configurazione, /etc/foobar.conf e dovrebbe essere installato in / usr / bin / foobar.

Purtroppo la documentazione per RPM è lunga 27 capitoli e non ho davvero un giorno per sedermi e leggerlo, perché sono anche impegnato a creare programmi di installazione .deb ed EXE per altre piattaforme.

Qual è il minimo assoluto che devo fare per creare un RPM? Supponiamo che il binario foobar e foobar.conf siano nella directory di lavoro corrente.

Faccio spesso rpm binari per app proprietarie di packaging - anche moster come websphere - su Linux. Quindi la mia esperienza potrebbe essere utile anche per te, oltre a ciò sarebbe meglio fare un VERO RPM se puoi. Ma sto divagando.

Quindi un passo fondamentale per impacchettare il tuo programma (binario) è il seguente - in cui suppongo che il programma sia toybinprog con la versione 1.0, abbia un conf da installare in /etc/toybinprog/toybinprog.conf e un bin da installare in / usr / bin chiamato tobinprog:

1. crea il tuo rpm build env per RPM <4.6,4.7

mkdir -p ~/rpmbuild/{RPMS,SRPMS,BUILD,SOURCES,SPECS,tmp}

cat <<EOF >~/.rpmmacros
%_topdir   %(echo $HOME)/rpmbuild
%_tmppath  %{_topdir}/tmp
EOF

cd ~/rpmbuild

2. crea il tarball del tuo progetto

mkdir toybinprog-1.0
mkdir -p toybinprog-1.0/usr/bin
mkdir -p toybinprog-1.0/etc/toybinprog
install -m 755 toybinprog toybinprog-1.0/usr/bin
install -m 644 toybinprog.conf toybinprog-1.0/etc/toybinprog/

tar -zcvf toybinprog-1.0.tar.gz toybinprog-1.0/

3. Copia nella directory delle fonti

cp toybinprog-1.0.tar.gz SOURCES/

cat <<EOF > SPECS/toybinprog.spec
# Don't try fancy stuff like debuginfo, which is useless on binary-only
# packages. Don't strip binary too
# Be sure buildpolicy set to do nothing
%define        __spec_install_post %{nil}
%define          debug_package %{nil}
%define        __os_install_post %{_dbpath}/brp-compress

Summary: A very simple toy bin rpm package
Name: toybinprog
Version: 1.0
Release: 1
License: GPL+
Group: Development/Tools
SOURCE0 : %{name}-%{version}.tar.gz
URL: http://toybinprog.company.com/

BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root

%description
%{summary}

%prep
%setup -q

%build
# Empty section.

%install
rm -rf %{buildroot}
mkdir -p  %{buildroot}

# in builddir
cp -a * %{buildroot}


%clean
rm -rf %{buildroot}


%files
%defattr(-,root,root,-)
%config(noreplace) %{_sysconfdir}/%{name}/%{name}.conf
%{_bindir}/*

%changelog
* Thu Apr 24 2009  Elia Pinto <devzero2000@rpm5.org> 1.0-1
- First Build

EOF

4. costruire il sorgente e il numero di giri binario

rpmbuild -ba SPECS/toybinprog.spec

E questo è tutto.

Spero che questo aiuto

Come distributore di applicazioni, fpm sembra perfetto per le tue esigenze . C'è un esempio qui che mostra come impacchettare un'app dalla fonte. FPM può produrre sia file deb che file RPM.

Per una rapida costruzione degli RPM, controlla Togo:

https://github.com/genereese/togo-rpm

Il progetto ha una guida di avvio rapido e sono stato in grado di creare un RPM di base in meno di 3 minuti.

Esempio di utilizzo dei dati forniti nella domanda originale:

1) Creare la directory di progetto usando lo script:

$ togo project create foobar; cd foobar

2) Crea la struttura di directory desiderata in ./root e copia i tuoi file in essa:

$ mkdir -p root/etc; cp /path/to/foobar.conf root/etc/
$ mkdir -p root/usr/bin; cp /path/to/foobar root/usr/bin/

3) Escludere le directory di proprietà del sistema dalla proprietà del tuo RPM:

$ togo file exclude root/etc root/usr/bin

4) (OPZIONALE) Modifica le specifiche generate per cambiare la descrizione del pacchetto / dipendenze / versione / qualunque cosa, ecc .:

$ vi spec/header

5) Costruisci l'RPM:

$ togo build package

-e il tuo RPM viene sputato nella directory ./rpms.

Allo stesso modo, dovevo creare un numero di giri con pochi file. Dato che questi file erano controllati dal codice sorgente e dato che sembravano sciocchi, non volevo passare a tararli solo per avere rpm a farli sparire. Ho pensato a quanto segue:

1. Configura il tuo ambiente:

   mkdir -p ~/rpm/{BUILD,RPMS}

   echo '%_topdir %(echo "$HOME")/rpm' > ~/.rpmmacros

2. Crea il tuo file delle specifiche, foobar.spec, con i seguenti contenuti:

   Summary: Foo to the Bar
   Name: foobar
   Version: 0.1
   Release: 1
   Group: Foo/Bar
   License: FooBarPL
   Source: %{expand:%%(pwd)}
   BuildRoot: %{_topdir}/BUILD/%{name}-%{version}-%{release}
   
   %description
   %{summary}
   
   %prep
   rm -rf $RPM_BUILD_ROOT
   mkdir -p $RPM_BUILD_ROOT/usr/bin
   mkdir -p $RPM_BUILD_ROOT/etc
   cd $RPM_BUILD_ROOT
   cp %{SOURCEURL0}/foobar ./usr/bin/
   cp %{SOURCEURL0}/foobar.conf ./etc/
   
   %clean
   rm -r -f "$RPM_BUILD_ROOT"
   
   %files
   %defattr(644,root,root)
   %config(noreplace) %{_sysconfdir}/foobar.conf
   %defattr(755,root,root)
   %{_bindir}/foobar
   

3. Costruisci il tuo numero di giri: rpmbuild -bb foobar.spec

C'è un po 'di pirateria informatica che specifica la' fonte 'come directory corrente, ma sembrava molto più elegante dell'alternativa, che era, nel mio caso, scrivere uno script separato per creare un tarball, ecc. Ecc.

Nota: nella mia situazione particolare, i miei file erano disposti in cartelle in base a dove dovevano andare, in questo modo:

./etc/foobar.conf
./usr/bin/foobar

e così la sezione di preparazione è diventata:

%prep
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT
cd $RPM_BUILD_ROOT
tar -cC %{SOURCEURL0} --exclude 'foobar.spec' -f - ./ | tar xf -

Che è un po 'più pulito.

Inoltre, mi capita di trovarmi su un RHEL5.6 con versioni rpm 4.4.2.3, quindi il tuo chilometraggio può variare.

Se make configfunziona per il tuo programma o hai uno script di shell che copia i tuoi due file nella posizione appropriata puoi usare checkinstall . Basta andare nella directory in cui si trova il proprio makefile e chiamarlo con il parametro -R(per RPM ) e facoltativamente con lo script di installazione.

Modo semplice per creare un pacchetto rpm da binario (questi passaggi sono stati testati con Fedora 18):

1) Per prima cosa devi installare rpmdevtools, quindi esegui questi comandi (attenzione: esegui come utente normale)

$ sudo yum install rpmdevtools rpmlint
$ rpmdev-setuptree

2) Nella cartella ~ / rpmbuild / SPECS creare un nuovo file: nome_pacchetto.spec

3) Aprilo con un editor (come gedit) e scrivi questo:

Name:           package_name
Version:        1.0
Release:        1
Summary:        Short description (first char has to be uppercase)

License:        GPL
URL:            www. your_website/

BuildRequires:  package_required >= (or ==, or <=) 1.0.3 (for example)

%description
Description with almost 79 characters (first char has to be uppercase)

#This is a comment (just as example)

%files
/usr/bin/binary_file.bin
/usr/share/applications/package_name.desktop
/usr/share/pixmaps/package_name.png

%changelog
* date Packager's Name <packager's_email> version-revision
- Summary of changes

#For more details see: docs.fedoraproject.org/en-US/Fedora_Draft_Documentation/0.1/html/Packagers_Guide/sect-Packagers_Guide-Creating_a_Basic_Spec_File.html

4) Crea ~ / rpmbuild / BUILDROOT / nome_pacchetto-versione-release-i386 e riproduci i percorsi in cui verranno posizionati i file. In questo caso, ad esempio, crea:

• ~ / Rpmbuild / buildroot / nome_pacchetto-versione-release.i386 / usr / bin /
• ~ / Rpmbuild / buildroot / nome_pacchetto-versione-release.i386 / usr / share / applications /
• ~ / Rpmbuild / buildroot / nome_pacchetto-versione-release.i386 / usr / share / pixmaps /

5) Inserisci in queste cartelle i file che vuoi inserire nel pacchetto:

• ~ / Rpmbuild / buildroot / nome_pacchetto-versione-release.i386 / usr / bin / binary_file.bin
• ~ / Rpmbuild / buildroot / nome_pacchetto-versione-release.i386 / usr / share / applications / package_name.desktop
• ~ / Rpmbuild / buildroot / nome_pacchetto-versione-release.i386 / usr / share / pixmaps / package_name.png

usr / share / pixmaps / nome_pacchetto.png è l'icona binaria usr / share / applicazioni / nome_pacchetto.desktop sono le regole per inserire il programma nelle voci di menu

6) nome_pacchetto.desktop deve essere così:

[Desktop Entry]
Encoding=UTF-8
Type=Application
Name=example
GenericName=Short description
Comment=Comment of the application
Exec=package_name
Icon=package_name
Terminal=false
Categories=System;

Le categorie sono queste: standards.freedesktop.org/menu-spec/latest/apa.html

7) Esegui $ rpmbuild -bb ~/rpmbuild/SPECS/package_name.spec

8) Il pacchetto è stato incorporato nella cartella ~ / rpmbuild / RPMS

se installi questo pacchetto è install:

• /usr/bin/binary_file.bin
• /usr/share/applications/package_name.desktop
• /usr/share/pixmaps/package_name.png

Grazie a: losurs.org/docs/tips/redhat/binary-rpms

Per maggiori dettagli per creare rpm dai un'occhiata a questo link .

Software Java GUI per creare rpm: https://sourceforge.net/projects/javarpmbuilder/

Se hai familiarità con Maven anche lì rpm-maven-pluginche semplifica la creazione di RPM: devi solo scrivere pom.xmlche verranno quindi utilizzati per costruire RPM. L'ambiente di build RPM viene creato implicitamente dal plug-in.

Processo di generazione di RPM dal file di origine:

1. scarica il file sorgente con estensione.gz.
2. installa rpm-build e rpmdevtools da yum install. (Verrà generata la cartella rpmbuild ... Le cartelle SPECS, SOURCES, RPMS .. dovrebbero essere generate all'interno della cartella rpmbuild).
3. copia il codice sorgente.gz nella cartella SOURCES. (rpmbuild / SOURCES)
4. Decomprimere la palla tar usando il seguente comando. vai alla cartella SOURCES: rpmbuild / SOURCES dove è presente il file tar. comando: ad esempio, la cartella tar -xvzf httpd-2.22.tar.gz httpd-2.22 verrà generata nello stesso percorso.
5. vai alla cartella estratta e quindi digita il comando seguente: ./configure --prefix = / usr / local / apache2 --with-incluso-apr --enable-proxy --enable-proxy-balancer --with-mpm = worker - -enable-mods-static = all (.configure può variare a seconda della fonte per la quale RPM deve essere costruito-- ho fatto per apache HTTPD che necessita del pacchetto di dipendenza apr e apr-util).
6. esegui sotto il comando una volta completata la configurazione: make
7. dopo l'esecuzione corretta del comando make run: checkinstall nella stessa cartella. (se non si dispone del software checkinstall, scaricare l'ultima versione dal sito). Inoltre, il software checkinstall ha un bug che può essere risolto nel modo seguente :::: individuare checkinstallrc e sostituire TRANSLATE = 1 in TRANSLATE = 0 usando il comando vim. Controlla anche il pacchetto di esclusione: EXCLUDE = "/ selinux"
8. checkinstall richiederà l'opzione (digitare R se si desidera tp build rpm per il file di origine)
9. Il file .rpm fatto verrà creato nella cartella RPMS all'interno del file rpmbuild / RPMS ... TUTTI I MIGLIORI ....

Gli RPM sono generalmente creati dal sorgente, non dai binari.

Devi scrivere il file delle specifiche che spiega come configurare e compilare la tua applicazione; inoltre, quali file includere nel tuo RPM.

Una rapida occhiata al manuale mostra che la maggior parte di ciò di cui hai bisogno è trattato nel Capitolo 8 - inoltre, poiché la maggior parte delle distribuzioni basate su RPM hanno fonti disponibili, ci sono letteralmente un milione di esempi di diversi approcci che potresti guardare.