Chcę tylko utworzyć plik RPM, który będzie dystrybuował mój plik binarny „foobar” dla systemu Linux, zawierający tylko kilka zależności. Ma plik konfiguracyjny /etc/foobar.conf i powinien być zainstalowany w / usr / bin / foobar.

Niestety dokumentacja RPM ma 27 rozdziałów i naprawdę nie mam dnia, aby usiąść i przeczytać to, ponieważ jestem również zajęty tworzeniem instalatorów .deb i EXE dla innych platform.

Jakie jest absolutne minimum, które muszę zrobić, aby utworzyć RPM? Załóżmy, że plik binarny foobar i foobar.conf znajdują się w bieżącym katalogu roboczym.

Często robię binarne rpm na pakiety własnościowe aplikacje - również najczęściej jako websphere - na Linuksie. Więc moje doświadczenie może być przydatne również dla ciebie, poza tym lepiej byłoby zrobić PRAWDZIWE RPM, jeśli możesz. Ale błądzę.

Tak więc podstawowy krok pakowania twojego (binarnego) programu jest następujący - w którym, jak przypuszczam, jest to toybinprog z wersją 1.0, zainstaluj conf w /etc/toybinprog/toybinprog.conf i miej bin do zainstalowania w / usr / bin o nazwie tobinprog:

1. utwórz środowisko kompilacji rpm dla 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. Stwórz archiwum swojego projektu

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. Skopiuj do źródeł reż

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 <[email protected]> 1.0-1
- First Build

EOF

4. zbudować źródło i binarne rpm

rpmbuild -ba SPECS/toybinprog.spec

I to wszystko.

Mam nadzieję, że to pomoże

Jako dystrybutor aplikacji, fpm brzmi idealnie dla Twoich potrzeb . Jest przykładem tutaj który pokazuje jak spakować aplikację ze źródła. FPM może tworzyć zarówno pliki deb, jak i pliki RPM.

Aby szybko zbudować RPM, sprawdź Togo:

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

Projekt ma przewodnik Szybki start i udało mi się stworzyć podstawowe RPM w mniej niż 3 minuty.

Przykład z wykorzystaniem danych podanych w pierwotnym pytaniu:

1) Utwórz katalog projektu za pomocą skryptu:

$ togo project create foobar; cd foobar

2) Utwórz żądaną strukturę katalogów w ./root i skopiuj do niej swoje pliki:

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

3) Wyklucz katalogi należące do systemu z własności RPM:

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

4) (OPCJONALNIE) Zmodyfikuj wygenerowaną specyfikację, aby zmienić opis pakietu / zależności / wersję / cokolwiek itp .:

$ vi spec/header

5) Zbuduj RPM:

$ togo build package

-i twój RPM jest wypluty do katalogu ./rpms.

Podobnie musiałem stworzyć rpm z kilkoma plikami. Ponieważ te pliki były kontrolowane przez źródła i wydawało się to głupie, nie chciałem ich tarować tylko po to, aby rozpakować je na rpm. Wymyśliłem co następuje:

1. Skonfiguruj swoje środowisko:

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

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

2. Utwórz plik specyfikacji foobar.spec z następującą zawartością:

   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. Zbuduj swój rpm: rpmbuild -bb foobar.spec

Jest tam mały haker określający `` źródło '' jako bieżący katalog, ale wydawało się to o wiele bardziej eleganckie niż alternatywa, którą było, w moim przypadku, napisanie oddzielnego skryptu do utworzenia tarballa itp., Itd.

Uwaga: w mojej konkretnej sytuacji moje pliki zostały uporządkowane w folderach według miejsca, w którym powinny się znaleźć, na przykład:

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

tak więc sekcja przygotowawcza stała się:

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

Który jest trochę czystszy.

Poza tym jestem na RHEL5.6 z wersjami 4.4.2.3 rpm, więc twój przebieg może się różnić.

Jeśli make configdziała dla twojego programu lub masz skrypt powłoki, który kopiuje twoje dwa pliki w odpowiednie miejsce, możesz użyć checkinstall . Po prostu przejdź do katalogu, w którym znajduje się plik makefile i wywołaj go z parametrem -R(dla RPM ) i opcjonalnie ze skryptem instalacyjnym.

Łatwy sposób na zbudowanie pakietu rpm z pliku binarnego (te kroki zostały przetestowane w Fedorze 18):

1) Najpierw musisz zainstalować rpmdevtools, więc uruchom te polecenia (uwaga: uruchom jako zwykły użytkownik)

$ sudo yum install rpmdevtools rpmlint
$ rpmdev-setuptree

2) W folderze ~ / rpmbuild / SPECS utwórz nowy plik: nazwa_pakietu.spec

3) Otwórz go w edytorze (takim jak gedit) i napisz:

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) Utwórz ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-wydanie.i386 i odtwórz ścieżki, w których zostaną umieszczone pliki, więc w tym przypadku na przykład utwórz:

• ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-wydanie.i386 / usr / bin /
• ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-wydanie.i386 / usr / share / applications /
• ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-release.i386 / usr / share / pixmaps /

5) Umieść w tych folderach pliki, które chcesz wstawić do pakietu:

• ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-wydanie.i386 / usr / bin / plik_binarny.bin
• ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-wydanie.i386 / usr / share / applications / nazwa_pakietu.desktop
• ~ / rpmbuild / BUILDROOT / nazwa_pakietu-wersja-wydanie.i386 / usr / share / pixmaps / nazwa_pakietu.png

usr / share / pixmaps / nazwa_pakietu.png to ikona binarnego usr / share / applications / nazwa_pakietu. desktop to zasady wstawiania programu do pozycji menu

6) nazwa_pakietu.desktop musi wyglądać następująco:

[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;

Kategorie to: standards.freedesktop.org/menu-spec/latest/apa.html

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

8) Twój pakiet został wbudowany w folder ~ / rpmbuild / RPMS

jeśli zainstalujesz ten pakiet, zostanie on zainstalowany:

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

Podziękowania dla: losurs.org/docs/tips/redhat/binary-rpms

Aby uzyskać więcej informacji na temat tworzenia RPM, spójrz na ten link .

Oprogramowanie GUI java do budowania rpm: https://sourceforge.net/projects/javarpmbuilder/

Jeśli znasz Mavena, również to rpm-maven-pluginupraszcza tworzenie RPM: musisz napisać tylko to, pom.xmlktóre zostanie następnie użyte do zbudowania RPM. Środowisko kompilacji RPM jest tworzone niejawnie przez wtyczkę.

Proces generowania RPM z pliku źródłowego:

1. pobierz plik źródłowy z rozszerzeniem.gz.
2. zainstaluj rpm-build i rpmdevtools z yum install. (folder rpmbuild zostanie wygenerowany ... foldery SPECS, SOURCES, RPMS .. zostaną wygenerowane w folderze rpmbuild).
3. skopiuj kod źródłowy.gz do folderu SOURCES. (rpmbuild / SOURCES)
4. Rozpakuj kulkę smołową za pomocą następującego polecenia. przejdź do folderu SOURCES: rpmbuild / SOURCES, w którym znajduje się plik tar. polecenie: np. tar -xvzf httpd-2.22.tar.gz folder httpd-2.22 zostanie wygenerowany w tej samej ścieżce.
5. przejdź do wyodrębnionego folderu, a następnie wpisz poniższe polecenie: ./configure --prefix = / usr / local / apache2 --with-included-apr --enable-proxy --enable-proxy-balancer --with-mpm = worker - -enable-mods-static = all (.configure może się różnić w zależności od źródła, dla którego RPM ma zbudować - zrobiłem dla apache HTTPD, który wymaga pakietu zależności apr i apr-util).
6. uruchom poniższe polecenie po pomyślnym skonfigurowaniu: make
7. po pomyślnym wykonaniu polecenia make uruchom: checkinstall w tym samym folderze. (jeśli nie masz oprogramowania checkinstall, pobierz najnowszą wersję ze strony) Również oprogramowanie checkinstall ma błąd, który można rozwiązać w następujący sposób ::::: zlokalizuj checkinstallrc, a następnie zamień TRANSLATE = 1 na TRANSLATE = 0 za pomocą polecenia vim. Sprawdź także pakiet wykluczeń: EXCLUDE = "/ selinux"
8. checkinstall zapyta o opcję (wpisz R, jeśli chcesz tp zbudować rpm dla pliku źródłowego)
9. Gotowy plik .rpm zostanie wbudowany w folder RPMS wewnątrz pliku rpmbuild / RPMS ... WSZYSTKO NAJLEPSZE ...

Pliki RPM są zwykle budowane ze źródła, a nie z plików binarnych.

Musisz napisać plik specyfikacji, który opisuje, jak skonfigurować i skompilować aplikację; także, które pliki dołączyć do RPM.

Szybkie spojrzenie na podręcznik pokazuje, że większość tego, czego potrzebujesz, jest omówiona w rozdziale 8 - również, ponieważ większość dystrybucji opartych na RPM ma dostępne źródła, istnieje dosłownie zillion przykładów różnych podejść, na które możesz spojrzeć.