→ ინსტრუქციები დებ პაკეტის შესაქმნელად

ქსელში საკმაოდ ბევრი სტატიაა იმის შესახებ, თუ როგორ უნდა ავაშენოთ deb პაკეტი, მაგრამ სამწუხაროდ ყველა მათგანი არ იქნება ნათელი დეველოპერისთვის, რომელმაც გადაწყვიტა შექმნა პირველად. ასე რომ, თქვენ გაქვთ თქვენი კოდი. ეს არის სასარგებლო, კარგი, მაგრამ მოითხოვს გარკვეულ უნარს და ძალისხმევას სერვერზე ან დესკტოპზე ინსტალაციისთვის. Თავის არიდება თვითნაკეთიფაილების კოპირებასთან, მონაცემთა ბაზის მანიპულირებასთან, start-stop სკრიპტების დაყენებასთან (დემონებისთვის) და კონფიგურაციის დაყენებასთან დაკავშირებით, თქვენ გადაწყვიტეთ ყველაფერი შეაგროვოთ deb პაკეტში.

იდეალურ შემთხვევაში, სწორი deb პაკეტი უნდა იყოს ხელმოწერილი gpg გასაღებით. წინააღმდეგ შემთხვევაში, apt ჩათვლის პაკეტს არასანდო და გასცემს გაფრთხილებას შესაბამისად. მაგრამ ჩვენ გამოვტოვებთ ამ ნაწილს ახლა. სახელმძღვანელო, თუ როგორ უნდა შექმნათ gpg გასაღები და როგორ მოვაწეროთ deb პაკეტი gpg გასაღებით, მოგვიანებით განიხილება.

ნაბიჯი 1. დააინსტალირეთ კომუნალური პროგრამები, რომლებიც საჭიროა თქვენი პაკეტის შესაქმნელად:

Sudo apt-get install autoconf automake libtool autotools-dev dpkg-dev fakeroot

ნაბიჯი 2. შექმენით root დირექტორია მომავალი პაკეტისთვის და დააკოპირეთ თქვენი კომუნალური პროგრამის ყველა ფაილი ამ დირექტორიაში, რომელიც საჭირო იქნება ოპერაციისა და ინსტალაციისთვის. Მაგალითად:

Mkdir -p / მთავარი / მომხმარებლის სახელი / deb / my_package cp / some_source_files / მთავარი / მომხმარებლის სახელი / deb / my_package

თუ თქვენი უტილიტა იქნება საქაღალდეში:

/ usr / local / share / my_project

/ მთავარი / მომხმარებლის სახელი / deb / my_package / usr / local / share / my_project

ნაბიჯი 3. შექმენით DEBIAN დირექტორია პაკეტის root-ში.

დირექტორიას სახელი აუცილებლად უნდა შედგებოდეს დიდი ასოები... ეს დირექტორია შეიცავს მეტა ინფორმაციას, რომელიც გამოიყენება ინსტალაციის დროს.

Cd / მთავარი / მომხმარებლის სახელი / deb / my_package mkdir DEBIAN

გარდა ამისა, კატალოგში DEBIANშექმენით სავალდებულო ტექსტური ფაილი - კონტროლი... ვ ამ ფაილსშეიცავს ძირითად ინფორმაციას პაკეტის შესახებ. ფაილში თითოეული სტრიქონი შეიცავს გასაღები-მნიშვნელობის წყვილებს, გამოყოფილი ორწერტილებით.

Cd ./DEBIAN სენსორული კონტროლი

მაგალითი ფაილი:

პაკეტი: my-package ვერსია: 1.0.0 გთავაზობთ: my-package შემნახველი: Vasiliy Batareikin არქიტექტურა: ყველა სექცია: ვებ პრიორიტეტი: სურვილისამებრ წინასწარ დამოკიდებულია: gcc, make, perl (> = 5.10), mysql-სერვერი დამოკიდებულია: gcc, make, perl (> = 5.10), perlmagick, mysql-სერვერი, unzip, rar აღწერა : ჩემი პირველი Debian პაკეტი

პაკეტი- პაკეტის სახელი. მოქმედი პერსონაჟები. საჭირო პარამეტრი.

ვერსია- პაკეტის ვერსია. საჭირო პარამეტრი.

უზრუნველყოფს- სისტემაში რეგისტრირებული განაცხადის სახელი.

შემნახველი- პაკეტის შემნახველის სახელი და ფოსტა. საჭირო პარამეტრი.

არქიტექტურა- პროცესორის არქიტექტურა, რომლისთვისაც განკუთვნილია პაკეტი. საჭირო პარამეტრი.

განყოფილება- განსაზღვრავს აპლიკაციების ჯგუფს. საჭირო პარამეტრი.

პრიორიტეტი- პაკეტის პრიორიტეტი. პარამეტრი განსაზღვრავს რამდენად მნიშვნელოვანია თქვენი პაკეტი სისტემისთვის.

წინასწარ დამოკიდებულია- მძიმით გამოყოფილი პაკეტების სია, რომლებიც საჭიროა თქვენი პაკეტის ინსტალაციის დროს. პაკეტის მენეჯერი ავტომატურად დააინსტალირებს მითითებულ პაკეტებს.

დამოკიდებულია- მძიმით გამოყოფილი პაკეტების სია, რომლებიც საჭიროა ამ პაკეტის მუშაობისთვის. პაკეტის მენეჯერი ავტომატურად დააინსტალირებს მითითებულ პაკეტებს.

აღწერა- პაკეტის აღწერა. საჭირო პარამეტრი.

თუ პაკეტის ინსტალაციის ან დეინსტალაციისას გარკვეული მოქმედებების შესრულება გჭირდებათ, შეგიძლიათ გამოიყენოთ სპეციალური სკრიპტები. ჩვენ ვქმნით მათ და ვაყენებთ აღსრულების უფლებებს:

Cd ./DEBIAN touch preinst postinst prerm postrm chmod 775 preinst postinst prerm postrm

პრეინსტ- მუშაობს პაკეტის დაყენებამდე.

პოსტინსტი- შესრულებულია პაკეტის დაყენებისთანავე.

წინამორბედი- შესრულებულია პაკეტის დეინსტალაციამდე.

პოსტრმ- შესრულებულია პაკეტის ამოღებისთანავე.

ნაბიჯი 4. პაკეტის აგება.

პაკეტის root ფოლდერით ავდივართ ერთ დონეზე და ვაშენებთ.

ავტორი: მაიკლ რიდი
გამოქვეყნების თარიღი: 2014 წლის 4 იანვარი
თარგმანი: ნ.რომოდანოვი
გადაცემის თარიღი: 2014 წლის ივნისი

ჩვენ გაჩვენებთ, თუ როგორ უნდა შექმნათ ორი ყველაზე გავრცელებული ტიპი Linux პაკეტებიგანაწილებისთვის პროგრამული უზრუნველყოფადა თქვენ თავად შეგიძლიათ გაავრცელოთ თქვენი საკუთარი პაკეტები.

ჩვენ ვაპირებთ გაგაცნობთ შეფუთვის პროგრამული უზრუნველყოფის პროცესს ორი ყველაზე პოპულარული შეფუთვის სისტემებისთვის DEB და RPM. თქვენ შეგიძლიათ გამოიყენოთ ეს ტექნიკა საკუთარი პროგრამული უზრუნველყოფის პაკეტების შესაქმნელად, ან თუნდაც შეინახოთ პროგრამული უზრუნველყოფის პაკეტები, რომლებიც, თქვენი აზრით, შეუმჩნეველი რჩება.

ჩვენ დავიწყებთ გაკვეთილით, თუ როგორ შევქმნათ DEB ფაილები ((.deb) Debian-დან მიღებული დისტრიბუციებისთვის - ჩვენ ვიყენებთ Xubuntu-ს, როგორც ჩვენს საფუძველს ამისათვის, შემდეგ დეტალურად განვიხილავთ მეთოდებს, რომლებიც საჭიროა RPM პაკეტების შესაქმნელად Red Hat-ში გამოსაყენებლად. -წარმოებული დისტრიბუციები და ჩვენ ამისთვის გამოვიყენებთ Fedora-ს. ხშირად შეგიძლიათ შექმნათ პაკეტი ერთ დისტრიბუციაზე და შემდეგ დააინსტალიროთ დაკავშირებულ დისტრიბუციაზე (მაგ. Ubuntu> Debian), მაგრამ თუ ეს მნიშვნელოვანია, შეგიძლიათ თავად სცადოთ.

პროგრამისთვის ჩვენ ვაპირებთ გამოვიყენოთ მსუბუქი Dillo ბრაუზერი, როგორც წყაროდან აგებული პაკეტის მაგალითი. როდესაც მშენებლობა კეთდება წყაროდან, იმ შემთხვევაში, თუ მშენებლობა არ წავა ისე, როგორც უნდა, შეგიძლიათ, ჩვეულებისამებრ, მოძებნოთ გადაწყვეტილებები ინტერნეტში. მაგალითად, Dillo 3.0.3-ის შემთხვევაში, წყაროს კოდის არქივში დაკვირვების გამო, ჩვენ უნდა დაგვემატებინა "LIBS = -lX11" build ბრძანებების წინ, რათა ბრძანებები იმუშაოს.

აშენება ხდება ბრძანების ხაზზე

რესურსები

ინსტალაცია (ან ვირტუალური ხელსაწყო) Ubuntu და Fedora

ეტაპობრივად აღწერა

ნაბიჯი 01:ვირტუალური მანქანის გამოყენებით

ვირტუალიზაციის ხელსაწყოების გამოყენება, როგორიცაა VirtualBox ან Vmware, ხშირად საუკეთესო მიდგომაა სხვა სისტემების შესაფუთად. ერთის მხრივ, ეს მიდგომა საშუალებას გაძლევთ შეინარჩუნოთ შედარებით სუფთა ბაზის ინსტალაცია, შედარებული იმ პარამეტრებთან, რომლებთანაც სავარაუდოდ იმუშავებენ სხვები. ეს ასევე ნიშნავს, რომ თქვენ შეგიძლიათ მიიღოთ სამიზნე სისტემების კოლექცია სხვადასხვა განაწილების გამოყენებით. გარდა ამისა, ვირტუალიზაციის ინსტრუმენტების უმეტესობა საშუალებას გაძლევთ მიბაძოთ სხვადასხვა არქიტექტურას და, შესაბამისად, შესაძლებელია 64-ბიტიანი ოპერაციული სისტემების გაშვება 32-ბიტიან პლატფორმაზე, თუმცა შესრულება დაზარალდება.

ნაბიჯი 02:ნულიდან დაწყებული

თუ რამე არასწორია Ubuntu-ში ან Fedora-ში, სრულიად უსაფრთხოა უბრალოდ წაშალოთ ორიგინალური დირექტორია და დაიწყოთ თავიდან. გაითვალისწინეთ, რომ Debian ინსტრუმენტები ცვლის ორიგინალურ არქივს, ასე რომ თქვენ უნდა დაიწყოთ ახალი ასლი.

ნაწილი 1: Debian

ნაბიჯი 03:დააინსტალირეთ build გარემო

ჩვენ დავიწყებთ უმეტესობის დაყენებით ხელსაწყოებირომელიც უნდა შევქმნათ პროგრამები საწყისი კოდებიდან. აკრიფეთ:

$ sudo apt-get install build-essential autoconf automake autotools-dev

ახლა ჩვენ უნდა დავაყენოთ ინსტრუმენტები, რომლებიც გამოიყენება DEB პაკეტებთან მუშაობისთვის. გააკეთეთ ეს შემდეგი ბრძანებით ...

$ sudo apt-get install dh-make debhelper devscripts fakeroot xutils lintian pbuilder

ნაბიჯი 04:შექმენით GPG გასაღები

თუ წარსულში არ შეგიქმნიათ საჯარო GPG გასაღები, ახლავე უნდა შექმნათ, რათა შეძლოთ პაკეტების ხელმოწერა. ჯერ შეიყვანეთ ტექსტი gpg –gen-key. აირჩიეთ ნაგულისხმევი პარამეტრები და მოთხოვნისას შეიყვანეთ თქვენი ნამდვილი სახელი და საკონტაქტო ინფორმაცია. დარწმუნდით, რომ ყურადღებით ჩაწერეთ ყველა მონაცემი, რადგან მოგვიანებით დაგვჭირდება ზუსტად დავამთხვიოთ ისინი კონფიგურაციის ფაილში. შემდეგ გაუშვით ls ~ / .gnupg ბრძანება, რათა დარწმუნდეთ, რომ ახალი გასაღები არსებობს (ეს არის ფაილის სახელი_lastname.gpg). შექმენით მისგან საჯარო გასაღები:

Gpg -a --გამომავალი ~ / .gnupg / .gpg --ექსპორტი "[თქვენი სახელი]"

შემოიტანეთ იგი:

Gpg --იმპორტი ~ / .gnupg / .gpg

ნაბიჯი 05:ჩამოტვირთეთ პაკეტი

ამ მაგალითში ჩვენ ვაპირებთ ჩამოტვირთოთ და შევქმნათ Dillo ვებ ბრაუზერის უახლესი ვერსია. გადადით Dillo-ს ვებსაიტზე (www.dillo.org) და ჩამოტვირთეთ უახლესი .tar.bz არქივი. გამოიყენეთ mkdir ~ / srcand ბრძანება, რომ შექმნათ წყარო დირექტორია და გადაიტანოთ არქივი მასში.

ნაბიჯი 06:ამოალაგეთ არქივი

ამოალაგეთ არქივი tar ბრძანებებს-xjvf [არქივის სახელი] .tar.bz2. გაითვალისწინეთ, რომ კატალოგის დასახელების კონვენციების დაცვა (პაკეტ-ვერსია) მნიშვნელოვანია ჩვენი მიზნებისთვის და საბედნიეროდ Dillo-ს პაკეტი ასეა. ასევე მნიშვნელოვანია, რომ წყაროს არქივი მდებარეობდეს წყაროს დირექტორიადან ერთი დონის ზემოთ.

ნაბიჯი 07:კონფიგურაცია Debian-ისთვის

გადაიტანეთ dh_make სკრიპტი თქვენს მიერ ახლახან გახსნილ დირექტორიაში, რომელიც იზრუნებს სამუშაოს უმეტეს ნაწილზე - დაამატეთ კონფიგურაციის ფაილი და შექმენით დირექტორია სტრუქტურა, რომელიც არის დეველოპერების ინსტრუმენტარიუმის ნაწილი, რომელიც ჩვენ ადრე დავამატეთ.

Dh_make -e -c ლიცენზია -f ../

ჩვენს მაგალითში, ბრძანების ხაზი ასე გამოიყურება:

Dh_make -c gpl3 -e [ელფოსტა დაცულია]-f ../dillo-3.0.3.tar.bz2

მოთხოვნისას აირჩიეთ ერთი ორობითი. დამხმარე სკრიპტის სკრიპტმა უნდა შექმნას დირექტორია სახელწოდებით Debian წყაროს დირექტორიაში.

ნაბიჯი 08:გახსენით საკონტროლო ფაილი

გახსენით ტექსტის რედაქტორისაკონტროლო ფაილი Debian ქვედირექტორიაში. შეავსეთ "მთავარი" განყოფილება (გამოიყენეთ Google Debian პროგრამების სიის შესავსებად) და ამ ფაილის აღწერილობის ველები.

ნაბიჯი 09:გამოიკვლიეთ არსებული დამოკიდებულებები

შეგიძლიათ შეისწავლოთ რა დამოკიდებულებებია საჭირო შეფუთული პროგრამის გასაშვებად. შეცვალეთ თქვენი წყაროს დირექტორიაში და ჩაწერეთ dpkg-depcheck -d ./configure ტერმინალში. თუ ამას გააკეთებთ, მიიღებთ შეცდომებს, რომლებიც მიუთითებს, თუ რომელი პაკეტი აკლია, რომელიც საჭიროა პროგრამის შესაქმნელად (მოწოდებულია ცალკე). თქვენ შეგიძლიათ გახსნათ ეს პაკეტი sudo apt-get build-dep [პაკეტის სახელი] აკრეფით და ეს დაგეხმარებათ, თუ პაკეტი მხარდაჭერილია განაწილების საცავში. თუ ის არ არის მხარდაჭერილი, მოგიწევთ dpkg-depcheck -d ./configur განმეორებით გაშვება და პაკეტების ხელით დამატება psudo apt-get install [package name] აკრეფით.

ნაბიჯი 10:დაამატეთ დამოკიდებულებები საკონტროლო ფაილში

როდესაც წინა საფეხურიდან ყველა ნაბიჯი დასრულდება, თქვენ უნდა გქონდეთ ყველა საჭირო პაკეტის სია. დაამატეთ დამოკიდებულებების ეს სია საკონტროლო ფაილის განყოფილებაში დამოკიდებული. სიაში პუნქტი გამოყოფილი უნდა იყოს მძიმით და ინტერვალით.

სცადეთ ეს ნაბიჯი მაქსიმალურად სრულად და არ გამოტოვოთ იგი. წყარო: ჩვეულებრივ მთავარი გვერდიპროექტი. ფაილები: * განყოფილებაში შეცვალეთ საავტორო უფლებების ინფორმაცია პროექტის ავტორების სახელებით. შეგიძლიათ ნახოთ Files: debian / * განყოფილების შევსების მაგალითი, რომელშიც უნდა შეიყვანოთ შესაბამისი ინფორმაცია. შეიძლება დაგჭირდეთ იყოთ ცოტა დეტექტივი, რომ იპოვოთ თქვენთვის საჭირო ინფორმაცია. შეხედეთ წყაროს დირექტორიაში ისეთი ფაილებისთვის, როგორიცაა AUTHORS და COPYING.

ნაბიჯი 12:ცვლილებების ჟურნალის ფაილის რედაქტირება

გახსენით ცვლილებების ჟურნალის ფაილი და დარწმუნდით, რომ სახელი და მისამართი ფოსტაიგივეა რაც თქვენ შეიტანეთ GPG კლავიშის შექმნისას. როგორც წესი, დამხმარე სკრიპტს შეუძლია დაამატოთ მომხმარებლის სახელი ფაილში და არა თქვენი ნამდვილი სახელი. როგორც საავტორო უფლებების ფაილთან დაკავშირებით, არ გამოტოვოთ ეს განყოფილება, რადგან ამან შეიძლება შეაჩეროს პაკეტის შექმნის პროცესი ან შექმნას არასწორი პაკეტი.

ნაბიჯი 13:შექმენით პაკეტი

თუ ყველაფერი სწორად არის კონფიგურირებული, ჩვენ საბოლოოდ შეგვიძლია შევქმნათ DEB პაკეტი. შეცვალეთ წყაროს კოდის დირექტორიაში და პაკეტის ასაგებად, რომელიც განთავსდება ~ / src / დირექტორიაში, ჩაწერეთ dpkg-buildpackage -b. მაგალითად, შექმენით პაკეტი dpkg -I [package] ბრძანების გამოყენებით. Debian-ის პოლიტიკის შესაბამისობის შესამოწმებლად, გამოიყენეთ lintian [package] ბრძანება Lintian პროგრამის გასაშვებად. გაითვალისწინეთ, რომ ცნობილია, რომ ეს ინსტრუმენტი მკაცრია და თქვენი გადასაწყვეტია, მისაღებია თუ არა თქვენთვის რაიმე უმნიშვნელო გაფრთხილება. ბოლოს დააინსტალირეთ პაკეტი sudo dpgk -i [package] ბრძანების გამოყენებით.

ნაწილი 2: RPM-ების შექმნა Fedora-ში

ნაბიჯი 14:გახსენით საკონტროლო ფაილი

გადაერთეთ root მომხმარებლის რეჟიმში აკრეფით su. დაიწყეთ განვითარების ინსტრუმენტების ინსტალაციის ჯგუფით yum-ში და შემდეგ გამოიყენეთ yum gcc-c ++ fedora- bundler-ის დასაყენებლად. გაუშვით ბრძანება usermod -a -G mock, რომ დაამატოთ თქვენი მომხმარებელი იმიტირებულ ჯგუფში. ეს საშუალებას გვაძლევს დავასრულოთ build-ის პროცედურა root მომხმარებლის როლზე გადასვლის გარეშე.

ნაბიჯი 15:შექმენით სამშენებლო გარემო

დააჭირეთ Ctrl + D ძირეული როლიდან გამოსასვლელად. შეიყვანეთ rpmdev-setuptree, რათა შევქმნათ დირექტორია ხე (~ / rpmbuild-ში), რომელიც გვჭირდება.

ნაბიჯი 16:ჩამოტვირთეთ არქივი და გადაიტანეთ სასურველ ადგილას

ჩამოტვირთეთ Dillo პაკეტი Dillo-ს ვებსაიტიდან და გადაიტანეთ არქივი შესაბამის დირექტორიაში - ჩაწერეთ mv [არქივის სახელი] ~ / rpmbuild / SOURCES.

ნაბიჯი 17შექმენით .spec ფაილი

Red Hat-ზე დაფუძნებული დისტრიბუციები, როგორიცაა Fedora, იყენებს .spec ფაილებს მშენებლობის პროცესის დასაზუსტებლად. შეცვალეთ დირექტორიაში, სადაც ეს ფაილები მდებარეობს cd ~ / rpmbuild / SPECS / andcreateablank.spec ბრძანების გამოყენებით და შექმენით ცარიელი .spec ფაილი rpmdev-newspec dillo ბრძანების გამოყენებით.

ნაბიჯი 18შეცვალეთ .spec ფაილი

გაუშვით ბრძანება gedit dillo.spec. შეავსეთ ველები Version, Summary License (in ამ შემთხვევაში- GPLv3 +). URL მიუთითებს საწყისი გვერდიპროექტი; Source0 განსაზღვრავს წყაროს კოდის მისამართს. მიუთითეთ კომენტარები BuildRequires და Requires ველებში. დამატება სრული აღწერა% აღწერის ზონამდე.

ნაბიჯი 19შექმენით საწყისი კოდი

თუ პაკეტი საერთოდ არის მხარდაჭერილი სისტემაში, გაუშვით ბრძანება yum-builddep [პაკეტის სახელი]. წინააღმდეგ შემთხვევაში, თქვენ უნდა გაიმეოროთ build ბრძანება, რათა მიიღოთ შეცდომის შეტყობინებები, ან მოძებნოთ დოკუმენტაცია წყაროს არქივში. SPEC დირექტორიაში აკრიფეთ rpmbuild -ba [პაკეტის სახელი] .spec. თუ ეს build ვერ მოხერხდა და მიიღებთ შეტყობინებებს დამატებითი ფაილების შესახებ, რომლებიც არ არის გახსნილი, აირჩიეთ და დააკოპირეთ ფაილების ეს სია % files განყოფილებაში.spec ფაილის და ხელახლა გაგზავნეთ build ბრძანება. პაკეტი ახლა იქნება RPMS დირექტორიაში. ჩაწერეთ rpm -ivh [package] მის დასაყენებლად. ტიპი rpm -qa | grep [პაკეტი], რათა დარწმუნდეთ, რომ დაინსტალირებულია.

ვეცდები ავხსნა deb პაკეტების შექმნის პროცესი რაც შეიძლება მარტივად, მაგალითად Ruby-zookeper-ის გამოყენებით. დაუყოვნებლივ გაფრთხილებთ, რომ ჩემს მიერ აღწერილი ლალის თვლების შეფუთვის მეთოდი არასწორია, უმჯობესია გამოიყენოთ gem2deb ამისათვის, მაგრამ რადგან შექმენით Ruby-zookeper წყაროებიდან gem2deb-ის გამოყენებით უახლესი ვერსიამე არ გამომივიდა, მაშინ აქ არის უმარტივესი შეკრების მეთოდი.

თუ თქვენ აპირებთ რუბის პაკეტების აშენებას, როგორც რეკომენდებულია, gem2deb-ის საშუალებით, მაშინ უმჯობესია დაამატოთ ხაზი

ექსპორტი DH_RUBY_IGNORE_TESTS = ყველა / ექსპორტი DH_RUBY_IGNORE_TESTS = ყველა

დებიანში / წესებში.

იმიტომ რომ ჩვენ ავაშენებთ რუბის კოდს, შემდეგ გვჭირდება რუბი და ინსტრუმენტების ნაკრები დებ პაკეტების შესაქმნელად.

Sudo apt-get დააინსტალირე ruby ​​dpkg-dev

Თუ თქვენ გაქვთ ძველი ვერსია ruby, მაშინ მასში არ არის Gem ბრძანება, ასევე მოგიწევთ rubygems პაკეტის დაყენება ან რუბის განახლება.

ახლა მოდით დავაყენოთ ძვირფასი ქვა fpmრომელიც შეგვიქმნის დებ პაკეტს.

Sudo gem დააინსტალირე fpm fpm -s gem -t deb zookeeper

მიმდინარე დირექტორიაში გვაქვს პაკეტი rubygem-zookeeper_1.4.11_amd64.deb, როგორც ჩანს, ეს უკვე ჩანთაშია, მაგრამ რადგან ჩვენ გვჭირდება წყაროს პაკეტი, რათა შევძლოთ მისგან დებ-ის შედგენა, მაგალითად OBS-ში, შემდეგ გავაგრძელებთ.

მოდით შევქმნათ build დირექტორია

Cp rubygem-zookeeper_1.4.11_amd64.deb ~ / cd mkdir -p ruby-zookeeper / fakeroot cd ruby-zookeeper / fakeroot

მოდით ამოვიღოთ მასში ახლად აწყობილი პაკეტის შინაარსი.

Dpkg-deb -R ~ / rubygem-zookeeper_1.4.11_amd64.deb ruby-zookeeper_1.4.11-1

ახლა ჩვენ შევქმნით ფაილებს, რომლებიც საჭიროა პაკეტის ასაშენებლად. ისინი უნდა იყოს debian დირექტორიაში. ჩვენ შეგვიძლია დავაკოპიროთ ზოგიერთი ფაილი შეუფუთავი პაკეტიდან.

Mkdir debian cp rubygem-zookeeper_1.4.11-1 / DEBIAN / control debian / control

მოდით დაარედაქტიროთ ის შემდეგ მდგომარეობაში. არ დაგავიწყდეთ შეცვალოთ Maintainer

წყარო: Ruby-zookeeper Maintainer: განყოფილება: ruby ​​Build-Depends: debhelper (> = 7.0.50 ~) პრიორიტეტი: დამატებითი საწყისი გვერდი: https://github.com/slyphon/zookeeper პაკეტი: ruby-zookeeper არქიტექტურა: amd64 დამოკიდებულია: $ (shlibs: დამოკიდებულია) , $ (სხვადასხვა: დამოკიდებულია), ლალის აღწერა: დაბალი დონის მულტი-რუბი შეფუთვა ZooKeeper API-ის შესაკრავების გარშემო. უფრო მეგობრული ინტერფეისისთვის იხილეთ http://github.com/slyphon/zk. ამჟამად მხარდაჭერილი: MRI: (1.8.7, 1.9.2, 1.9.3), JRuby: ~> 1.6.7, Rubinius: 2.0. ტესტირება, REE 1.8.7. ... ეს ბიბლიოთეკა იყენებს ზოოპარკის საკინძების 3.4.5 ვერსიას.

ჩვენ ასევე გვჭირდება debian / წესები. მოდით შევქმნათ იგი. override_dh_shlibdeps საჭიროა იმისათვის, რომ არ შევამოწმოთ ზოოპარკის ბიბლიოთეკების კავშირი, რადგან არ გადის.

#! / usr / bin / make -f # - * - makefile - * -%: dh [ელფოსტა დაცულია] override_dh_shlibdeps: მართალია

Debian / წესების ჩანართები აუცილებელია და არ შეიძლება შეიცვალოს სივრცეებით. მოდით გავხადოთ ის შესრულებადი.

Chmod + x debian / წესები

Usr / * var / *

ახლა შევქმნათ debian/changelog და დავწეროთ იქ:

Ruby-zookeeper (1.4.11-1) გამოუქვეყნებელი; სასწრაფო = საშუალო * საწყისი გამოშვება - root ოთხშაბათი, 25 ნოე 2015 20:01:55 +0300

ჩვენ ასევე გვჭირდება debian / compat

Echo 7> debian / compat

დავაკოპიროთ დასაინსტალირებელი ფაილები ლოკალურ დირექტორიაში და წავშალოთ საქაღალდე შეუფუთავი პაკეტით, ის აღარ გამოგვადგება.

Mv ruby-zookeeper_1.4.11-1 / (usr, var). rm -r Ruby-zookeeper_1.4.11-1

მოდით ავაშენოთ ახალი პაკეტი, ისევე როგორც წყაროს პაკეტი.

Dpkg-buildpackage -rfakeroot -uc -F

ზემოთ მოცემულ დირექტორიაში ჩვენ გვექნება ყველა საჭირო ფაილი.

Ll .. სულ 5528 drwxr-xr-x 3 root root 4096 Dec 20 13:32 ./ drwx ------ 12 root root 4096 Dec 20 13:31 ../ drwxr-xr-x 5 root 4096 Dec 20 13:28 fakeroot / -rw-r - r-- 1 root root 1261 Dec 20 13:32 ruby-zookeeper_1.4.11-1_amd64.ცვლის -rw-r - r-- 1 root root 2375044 Dec 3: 20 ruby -zookeeper_1.4.11-1_amd64.deb -rw-r - r-- 1 root root 565 Dec 20 13:32 ruby-zookeeper_1.4.11-1.dsc -rw-r - r-- 1 root root 3263381 Dec 20 32 Ruby-zookeeper_1.4.11-1.tar.gz

თქვენ შეგიძლიათ შეამოწმოთ მიღებული დებ პაკეტის შინაარსი

deb ფაილი არის არქივი ფორმატში არშეიცავს პროგრამის საინსტალაციო ფაილებს, ინფორმაციას პროგრამის შესახებ, აგრეთვე სკრიპტებს (სამყარო ფაილებს) შესრულებული პროგრამის ინსტალაციამდე და დეინსტალაციამდე და შემდეგ (სკრიპტების არსებობა არჩევითია - ისინი შეიძლება არ იყოს შეტანილი პაკეტში).

deb ფაილის ფორმატი აღწერილია deb (5) man გვერდებზე - ეს დახმარება გამოჩნდება, როდესაც ტერმინალში აკრიფებთ man deb-ს. ინტერნეტში ასევე არის საკმაოდ ბევრი გვერდი, რომელიც შეიცავს ამ ინფორმაციას - უბრალოდ ჩაწერეთ deb (5) საძიებო ზოლში, რომ იპოვოთ ისინი. ეს სახელმძღვანელო აქ არ შედის, როგორც ოფიციალური Debian Developers Guide, პაკეტის ფორმატის მითითება (რომელიც ამ წერის დროს განთავსებულია http://www.debian.org/doc/manuals/debian-faq/ch- pkg_basics .en.html) წერია, რომ პაკეტების ფორმატი შეიძლება შეიცვალოს და ამიტომ რეკომენდებულია მათთან მუშაობისთვის გამოიყენოთ dpkg-deb პროგრამა. შეგიძლიათ მიიღოთ დახმარება dpkg-deb უტილიტის გამოყენებასთან დაკავშირებით ტერმინალიდან man dpkg-deb აკრეფით.

GUI-deb პროგრამის მუშაობა მხოლოდ საჭირო მონაცემების შემცველი დირექტორიას შექმნაა და dpkg-deb პროგრამის დაწყება ამ დირექტორიასა და სხვა საჭირო პარამეტრების მითითებით.

საინსტალაციო პაკეტის შესაქმნელად dpkg-deb-ის სწორი დირექტორია, ჯერ უნდა შეიცავდეს "DEBIAN" ქვედირექტორიას. ეს დირექტორია უნდა შეიცავდეს ყველა მონაცემს, რომელიც არ არის დაკოპირებული სისტემაში, მაგრამ გამოიყენება უშუალოდ პროგრამების მიერ პაკეტებთან მუშაობისთვის - ინფორმაცია პაკეტის შესახებ, შესრულებული ინსტალაციამდე და შემდეგ, სკრიპტები და ა.შ. პაკეტის ინსტალაციისას DEBIAN დირექტორიაში შემავალი არცერთი ფაილი არ გადაეცემა იმ კომპიუტერის ფაილურ სისტემას, რომელზეც დაინსტალირებულია პაკეტი.

"DEBIAN" დირექტორიას გარეთ არის ფაილები, რომლებიც დაკოპირდება კომპიუტერის ფაილურ სისტემაში, რომელზეც დაინსტალირდება პაკეტი. ფაილები უნდა განთავსდეს დირექტორიაში, სადაც ისინი განთავსდება პაკეტის დაყენებისას. ანუ, dpkg-deb-სთვის შექმნილი დირექტორიაში უნდა შეიქმნას ფაილური სისტემის ჩვენთვის საჭირო ნაწილების ასლი - თითქოს ეს დირექტორია მისი ფესვი ("/"). ანუ, მაგალითად, თუ დირექტორიას სახელი, რომლის საფუძველზეც შეიქმნება პაკეტი, არის "~ / TMP_DEBS / MyProgram", და თქვენ გჭირდებათ ფაილების სისტემაფაილი "MyProgram.png" დაიწერა დირექტორიაში "/ usr / share / pixmaps" - თქვენ უნდა შექმნათ დირექტორია "usr" დირექტორიაში "~ / TMP_DEBS / MyProgram", მასში - დირექტორია "share", შიგნით "share" - დირექტორია "pixmaps" და ჩადეთ ფაილი" MyProgram.png "pixmaps" დირექტორიაში. შედეგად, ფაილის სრული გზა იქნება "~ / TMP_DEBS / MyProgram / usr / share / pixmaps / MyProgram.png". პაკეტის შექმნისას, დირექტორია "~ / TMP_DEBS / MyProgram" ნაწილი გაითიშება, ხოლო ინსტალაციის დროს, ფაილი "MyProgram.png" უბრალოდ გადავა სწორი მისამართი"/ usr / share / pixmaps". ამრიგად, საჭირო დირექტორიები უნდა შეიქმნას თითოეული ფაილისთვის.

დირექტორიას შექმნის შემდეგ, რჩება მხოლოდ dpkg-deb გაშვება სასურველი პარამეტრები... dpkg-deb ოფციები, რომლებიც ყველაზე მეტად საჭიროა პაკეტების შესაქმნელად, აღწერილია განყოფილებაში "ბრძანების ხაზის პარამეტრები dpkg-deb Utility". თუ საკონტროლო ფაილში არ არის შეცდომები, შეიქმნება ინსტალაციის პაკეტი.

პროგრამების დაყენების რამდენიმე გზა არსებობს. თითქმის ყველას აქვს საერთო ნაწილი - წყაროების ამოხსნა:

Tar xvfj mega_app.tar.bz2

Tar xvfz mega_app.tar.gz

შეასრულეთ ბრძანება ./კონფიგურაცია, მაშინ გააკეთოს... ეს ბრძანებები გამოიყენება საწყისი კოდებიდან შესრულებადი ფაილების, ბიბლიოთეკების და ა.შ.
ცალკე, აღსანიშნავია პირველი ბრძანება - ./კონფიგურაცია
თუ აღასრულებ ./კონფიგურაცია --დახმარებაშემდეგ თქვენ მიიღებთ იმ პარამეტრების ჩამონათვალს, რომელთა გადაცემაც შესაძლებელია ./კონფიგურაცია
მაგალითად, შემდეგი ბრძანება ხშირად შესაძლებელია:

./configure --prefix = / opt / mega_app

ან მიუთითეთ ბიბლიოთეკისკენ მიმავალი გზა, რომელიც რატომღაც თავისთავად ვერ მოიძებნა:

./კონფიგურაცია --kerberos-lib = / opt / kerberos / lib

კლასიკური.
ასე რომ, ჩვენ ვასრულებთ თანმიმდევრობას:

./configure make

და ბრძანება, რომელიც რეალურად აყენებს პროგრამის ყველა კომპონენტს სისტემაში:

დააინსტალირეთ

გაფრთხილება!!!ამ მეთოდის გამოყენებით ადვილია მოგვიანებით სერიოზული პრობლემების მოგვარება. პირველი, დიდი ალბათობით, თქვენ ვერ შეძლებთ პროგრამის დეინსტალაციას (გააკეთეთ დეინსტალაცია).

ჩვენ ვიყენებთ Checkinstall პროგრამას.
სწორი გზა. ზოგადი ნაწილის დასრულების შემდეგ გაუშვით:

თავად პროგრამა გკითხავთ ყველაფერზე, ან შეგიძლიათ უბრალოდ დააჭირეთ ENTER ყველგან.
კაცი checkinstall ძალიან კარგი გზაა :))

პაკეტის აგება წყაროდან Debian-ისთვის.
ცალკეა და რთული გზა- თქვენ უნდა გესმოდეთ deb პაკეტების შექმნის მრავალი ასპექტი (ან სხვა). ეს გზა სრულად არ იქნება აღწერილი აქ, მხოლოდ მაგალითია იმისა, თუ როგორ უნდა ავაწყოთ პაკეტი უკვე მომზადებული მასალებისგან.
ასე რომ, აქ არის მაგალითი. მივდივართ packages.ubuntu.com-ზე, ვპოულობთ საჭირო პაკეტს (მაგალითად, განსხვავება) და ვტვირთავთ ორ ფაილს - წყაროს (http: //archive.ubuntu.com/ubuntu/pool/main/d/diffutils/diffutils_2.8.1). o ... ) და მასზე პატჩი, რომელიც გამოასწორებს წყაროებს და შექმნის დებიიან საქაღალდეს ჯადოსნური წესების ფაილით (http: //archive.ubuntu.com/ubuntu/pool/main/d/diffutils/diffutils_2. 8.1-1 ...).
დააკოპირეთ ისინი ~ / ტესტის საქაღალდეში და ჯერ ამოალაგეთ წყაროები:

Tar xvfz diffutils_2.8.1.orig.tar.gz

და შემდეგ წაისვით პაჩი:

Cd diffutils-2.8.1 / gzip -cd ../diffutils_2.8.1-11ubuntu4.diff.gz | პატჩი -p1

ახლა ჩვენ უნდა გავაკეთოთ debian / წესებიშესრულებადი:

Chmod + x debian / წესები

და შეაგროვეთ პაკეტი:

Fakeroot Debian / წესები ორობითი

Fakeroot საჭიროა რეგულარული მომხმარებლის მიერ პაკეტის ასაშენებლად (ჩვეულებრივ, ბევრი საჭირო ოპერაცია არ მოგცემთ საშუალებას შექმნათ პაკეტი).

Ls ../ diff_2.8.1-11ubuntu4_i386.deb diffutils-2.8.1 diffutils_2.8.1-11ubuntu4.diff.gz diffutils_2.8.1.orig.tar.gz

როგორც ხედავთ, პაკეტი მზად არის.

ან Debian:

wget package_name.dsc, package_name.diff.gz, package_name.orig.tar.gz dpkg-source -x package_name.dsc cd ./package_name/ dpkg-buildpackage -rfakeroot

დასკვნა
ასევე არსებობს მეთოდები - შეფუთვა თავიდან ბოლომდე. აუცილებელია აიღოთ პაკეტების შექმნის სახელმძღვანელო თქვენი სადისტრიბუციო ნაკრებიდან და შეისწავლოთ ეს პროცესი იქიდან და მისკენ. გააკეთეთ ბევრი პაკეტი, კარგი და საჭირო. თუ თქვენ გააკეთეთ კარგი კონსტრუქცია, გაუგზავნეთ იგი სადისტრიბუციო ნაკრების დეველოპერებს, განაახლეთ იგი. გახსოვდეთ, რომ თქვენ მიერ შენახული ერთი პაკეტიც კი შეიძლება სასარგებლო იყოს ასობით ადამიანისთვის მთელს მსოფლიოში.

მოდით, მოკლედ შეისვენოთ და ვუყუროთ ვიდეოს SEO საიტის ოპტიმიზაციის შესახებ: