Εισαγωγή στο Ubuntu Pagkaging

Στον οδηγό «Ubuntu Packaging» που ακολουθεί, θα μάθουμε ότι χρειάζεται για να φτιάξουμε πακέτα εγκατάστασης .deb για το Ubuntu αλλά και πως να τα ανεβάσουμε σε προσωπικό αποθετήριο PPA για να μοιράσουμε το λογισμικό μας και να μπορεί όποιος θέλει να το εγκαθιστά αλλά και να λαμβάνει τις αναβαθμίσεις που θα ανεβάζουμε.

introduction-to-ubuntu-pagkaging

Παρότι το Ubuntu 16.04 παρουσίασε μια πρόσθετη μορφή πακέτων, τα λεγόμενα Snap packages όπως είδαμε και σε προηγούμενο άρθρο, αυτό δεν σημαίνει ότι σύντομα θα δούμε το πακετάρισμα εφαρμογών σε .deb να είναι παρελθόν. Το αντίθετο μάλιστα, αφού το Ubuntu βασίζεται στο Debian θα συνεχίσει να χρησιμοποιεί πακέτα deb αλλά και τα αποθετήρια PPA για πολλά … μα πάρα πολλά χρόνια!

Packaging; Μα, καλά, που θα μου χρειαστεί;

Καλή ερώτηση (αφού την έκανα εγώ στον εαυτό μου)! Η απάντηση είναι «ίσως πουθενά», όμως, ίσως κάποιος ενδιαφέρεται να μάθει πως γίνεται για διάφορους λόγους. Είτε για την συνεισφορά στο Ubuntu Project υπό τη μορφή προσθήκης πακέτων στα επίσημα αποθετήρια (ή σε προσωπικό αποθετήριο τρίτων), είτε για να έχει ο ίδιος στο σύστημά του τελευταίες εκδόσεις εφαρμογών των που χρησιμοποιεί, χωρίς να περιμένει κάποια άλλη ομάδα να τις αναβαθμίσει, αλλά και για άλλους λόγους που ισχύουν για τον εκάστοτε packager.

Η αλήθεια είναι, πως, δεν έχει σημασία ο λόγος, ίσως με την εκμάθηση της διαδικασίας οι λόγοι να δημιουργηθούν αυτόματα. Οπότε, ας αρχίσουμε να εξετάζουμε πως μπορούμε να πακετάρουμε λογισμικό μέσω μίας ακολουθίας βημάτων, να δούμε τι θα χρειαστούμε και να εφαρμόσουμε την διαδικασία σε κάποια εφαρμογή, ώστε να την κατανοήσουμε στην πράξη.

Στόχος αυτού του οδηγού είναι να βοηθήσει τον αναγνώστη, είτε αυτός είναι αρχάριος χρήστης στο Ubuntu, είτε έμπειρος, να κατανοήσει τα βασικά βήματα της διαδικασίας του packaging και μέσω μίας ακολουθίας βημάτων να δοκιμάσει ο ίδιος να δημιουργήσει ένα πακέτο, ώστε να δει στην πράξη τα βήματα και την λογική τους.

Πληροφορίες

Προκειμένου κάποιος να κάνει τα πρώτα του βήματα στο πακετάρισμα λογισμικού για το Ubuntu, είναι απαραίτητη η εξοικείωση με κάποιους όρους και η κατανόηση κάποιων πληροφοριών που το αφορούν. Σε αυτή την ενότητα, θα αναφερθούν κάποιες από αυτές τις βασικές πληροφορίες που αφορούν το packaging.

Τί είναι το Packaging;

Όλα (ή τουλάχιστον τα περισσότερα) τα έργα Ελεύθερου Λογισμικού / Λογισμικού Ανοιχτού Κώδικα δημιουργούνται αυτόνομα από προγραμματιστές ή ομάδες προγραμματιστών για να καλύψουν μία συγκεκριμένη ανάγκη του τελικού χρήστη. Και όταν λέμε «αυτόνομα», αυτό σημαίνει πως τα έργα ΕΛ/ΛΑΚ δεν δημιουργούνται με προδιαγραφές ώστε να χρησιμοποιηθούν σε μία συγκεκριμένη διανομή Linux, αλλά από όλες τις διανομές (αυτό που λέμε «Upstream») ή ακόμη και από άλλα συστήματα. Κάθε διανομή, όμως, έχει τις δικές της ιδιαιτερότητες και ανάγκες, ενώ συγκριτικά με οποιαδήποτε άλλη, μπορούν να παρατηρηθούν μικρές διαφορές ή και εξαιρετικά σημαντικές και ουσιαστικές διαφορές. Άρα, πως μπορεί μία εφαρμογή, η οποία έχει δημιουργηθεί αγνοώντας τις ανάγκες της εκάστοτε διανομής, να λειτουργήσει σωστά σε αυτή; Εδώ μπαίνει η διαδικασία του packaging.

cycle-branching

Με το πακετάρισμα ενός έργου ΕΛ/ΛΑΚ, το οποίο έχει δημιουργηθεί ανεξάρτητα από κάποιους developers, ουσιαστικά φέρνουμε το λογισμικό στα μέτρα της διανομής που αυτό θα εγκατασταθεί και θα χρησιμοποιηθεί, ώστε να μην υπάρχουν προβλήματα σχετικά με την λειτουργία του στην εκάστοτε διανομή και να ενεργεί όπως αυτή προορίστηκε από τους προγραμματιστές που το δημιούργησαν. Με την ολοκλήρωση της διαδικασίας, δημιουργείται ένα πακέτο (pagkage – εξού και ο όρος «pagkaging») για την εγκατάσταση του λογισμικού στην διανομή μας.

Σκοπός αυτού του οδηγού, είναι να εξηγήσει πως ακριβώς μπορούμε να κάνουμε κάτι τέτοιο στο Ubuntu.

Δομή ενός έργου ΕΛ/ΛΑΚ – Πηγαίος κώδικας

Προτού μπούμε αναλυτικά στις οδηγίες για το πακετάρισμα λογισμικού, πρέπει να γνωρίζουμε κάποιες βασικές πληροφορίες για την δομή ενός έργου ΕΛ/ΛΑΚ, δηλαδή κάποια βασικά στοιχεία που κάποιος βρίσκει μέσα στον αρχικό φάκελο ενός λογισμικού – έργου ΕΛ/ΛΑΚ, στοιχεία τα οποία καλό θα είναι να γνωρίζει κάποιος, εφόσον αποφασίσει να εμβαθύνει τις γνώσεις του στην διαδικασία του packaging. Τα περισσότερα αρχεία που βρίσκονται εκεί μέσα αποτελούν κώδικα, αυτό που λέμε «πηγαίος κώδικας» του λογισμικού, τον οποίο έχουμε την δυνατότητα να δούμε, ακριβώς επειδή το λογισμικό είναι ΕΛ/ΛΑΚ.

Ένα από αυτά τα αρχεία μέσα στον αρχικό φάκελο του λογισμικού είναι το «configure.ac». Μέσα σε αυτό το αρχείο υπάρχει μία σειρά κανονισμών που ορίζουν την εγκατάσταση του λογισμικού σε ένα σύστημα. Βλέποντας ένα log των αλλαγών σε αυτό το αρχείο από έκδοση σε έκδοση, ουσιαστικά μπορούμε να δούμε μία αναλυτική καταγραφή των αλλαγών στις οποίες υπόκειται το λογισμικό. Ακόμη, υπάρχουν αρχεία όπως το «COPYING» που αφορά την άδεια του λογισμικού, το «AUTHORS» στο οποίο αναγράφονται τα στοιχεία των προγραμματιστών του λογισμικού και γενικότερα διάφορα αρχεία με τα οποία εν καιρώ εξοικειώνεται ένας packager.

Για τις ανάγκες του οδηγού και στο συγκεκριμένο σημείο, δεν χρειάζεται να αναφερθούμε σε περισσότερα αρχεία που περιέχει ένας κατάλογος του πηγαίου κώδικα ενός ελέυθερου λογισμικού, όμως θα επεκταθουμε σε αυτά σε επόμενη ενότητα.

Ο κατάλογος «debian»

Στην περίπτωση (την οποία θα εξετάσουμε αρχικά) που το λογισμικό έχει ήδη πακεταριστεί για το Ubuntu ή το Debian, μέσα στον αρχικό του φάκελο θα υπάρχει και ο κατάλογος «debian». Μέσα σε αυτόν εμπεριέχονται διάφορα αρχεία που καθορίζουν την λειτουργία του λογισμικού στο Ubuntu. Για παράδειγμα, αν το λογισμικό αντιμετωπίζει κάποιο bug το οποίο είναι σχετικό με το Ubuntu, τότε το patch που το διορθώνει βρίσκεται στο «debian/patches», για τον απλούστατο λόγο πως πρέπει να εφαρμοστεί το patch μόνο για το Ubuntu και όχι γενικά στο λογισμικό, αφού δεν επηρεάζει το ίδιο το λογισμικό, αλλά την λειτουργία του στο Ubuntu.

Εκεί, υπάρχουν επίσης και διάφορα άλλα scripts τα οποία καθορίζουν τους κανόνες της εγκατάστασης αποκλειστικά για το Ubuntu (dpkg), στα οποία δεν θα αναφερθούμε σε αυτό το στάδιο. Δύο, επίσης, σημαντικά αρχεία, είναι τα «debian/rules» και «debian/watch», όπου στο πρώτο καταγράφονται οδηγίες για την εγκατάσταση του λογισμικού στο Ubuntu και το δεύτερο ο σύνδεσμος upstream όπου βρίσκεται το λογισμικό. Σε πιο προχωρημένη ενότητα που θα ακολουθήσει, θα υπάρχει μία λεπτομερής ανάλυση για το αρχείο «debian/rules», το οποίο είναι το σημαντικότερο στη δημιουργία πακέτου για το Ubuntu από το μηδέν.

Τα αρχεία που θα μας απασχολήσουν αρχικά είναι τα «debian/changelog» και «debian/control.in», όπου στο πρώτο (changelog) καταγράφονται όλες οι αλλαγές που γίνονται στο λογισμικό εντός του καταλόγου «debian» (ουσιαστικά πρόκειται για ένα log), δηλαδή αφορούν αποκλειστικά τη λειτουργία του λογισμικού στο Ubuntu, ενώ το δεύτερο (control.in) αφορά μεταξύ άλλων σημαντικών για το πακέτο πληροφοριών την καταγραφή των εξαρτήσεων (dependencies) του λογισμικού ώστε αυτές να εγκαθίστανται σωστά όταν εγκαθιστούμε το λογισμικό. Τα δύο αυτά αρχεία, λοιπόν, θα μας απασχολήσουν, διότι θα τα επεξεργαστούμε όταν ξεκινήσουμε με την διαδικασία του packaging.

Προετοιμασία

Θα χρειαστούμε κάποια εργαλεία, καθώς και την δημιουργία ενός κλειδιού κρυπτογράφησης GPG (το οποίο καλό θα ήταν να ανεβάσουμε και στο Launchpad), αλλά και την παραμετροποίηση κάποιων αρχείων, προκειμένου να ξεκινήσουμε με το πακετάρισμα.

Η προετοιμασία αυτή έχει ως σκοπό την διευκόλυνσή μας στην ομαλή εξέλιξη της διαδικασίας του packaging, και την σωστή ρύθμιση κάποιων στοιχείων που θα βοηθήσουν στην διαθεσιμότητα αναλυτικών πληροφοριών, οι οποίες θα είναι προσβάσιμες μέσω των πακέτων που θα δημιουργούνται.

Εγκατάσταση εργαλείων

Χωρίς να επεκταθούμε στο τι ακριβώς είναι το καθένα από αυτά, αμέσως παρακάτω αναγράφεται η εντολή που πραγματοποιεί την εγκατάσταση αυτών των εργαλείων, με την εκτέλεσή της στο τερματικό του Ubuntu μας:

sudo apt-get install bzr bzr-builddeb pbuilder fakeroot build-essential gnupg sbuild debhelper ubuntu-dev-tools devscripts quilt

Να σημειωθεί, πως σε αυτή τη σειρά πακέτων παραπάνω, εγκαθίστανται και δύο εργαλεία (bzr-builddeb και pbuilder) τα οποία δεν θα χρειαστούν για την διαδικασία που θα ακολουθήσει στο αρχικό στάδιο. Όμως, ίσως χρειαστούν αργότερα αν αποφασίσετε να ασχοληθείτε περαιτέρω με το pagkaging και την ανάπτυξη λογισμικού.

Δημιουργία κλειδιού κρυπτογράφησης (GPG)

Ένα κλειδί κρυπτογράφησης μπορεί να χρησιμοποιηθεί σε διάφορες περιπτώσεις. Κυρίως στην επικοινωνία και στην υπογραφή πακέτων, για την επιβεβαίωση της πηγής του πακέτου ή ενός μηνύματος. Για την συγκεκριμένη περίπτωση, η χρήση του αφορά την υπογραφή πακέτων ώστε να θεωρούνται ως αξιόπιστη πηγή από τα συστήματα που θα χρησιμοποιήσουμε.

Θα δούμε, εν συντομία, πως δημιουργεί κάποιος ένα κλειδί GPG:

  1. Στο τερματικό, εκτελούμε:
    gpg --gen-key
  2. Θα εμφανιστεί το παρακάτω:
    Please select what kind of key you want:
    (1) RSA and RSA (default)
    (2) DSA and Elgamal
    (3) DSA (sign only)
    (4) RSA (sign only)

    Όπου πατάμε ENTER για να πάρει την default (1) ρύθμιση.

  3. Στην συνέχεια, θα δούμε αυτό:
    RSA keys may be between 1024 and 4096 bits long.
    
    What keysize do you want? (2048)

    Και εδώ πάλι πατάμε ENTER.

  4. Στο επόμενο βήμα:
    Requested keysize is 2048 bits
    Please specify how long the key should be valid.
    0 = key does not expire
    <n> = key expires in n days
    <n>w = key expires in n weeks
    <n>m = key expires in n months
    <n>y = key expires in n years
    Key is valid for? (0)
    Key does not expire at all
    Is this correct? (y/N)

    Και εδώ πάλι πατάμε ENTER και μετά το πλήκτρο Y (ναι) για επιβεβαίωση.

  5. Στη συνέχεια, θα εμφανιστεί το εξής:
    You need a user ID to identify your key; the software constructs the user ID
    from the Real Name, Comment and Email Address in this form:
    "Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"
    Real name: Όνομα Επίθετο
    Email address: e-mail
    Comment: Sign Package key
    You selected this USER-ID:
    "Όνομα Επίθετο (Sign Package key)"

    Πληκτρολογούμε το ονοματεπώνυμό μας (πρέπει να είναι το κανονικό μας ονοματεπώνυμο), την διεύθυνση e-mail μας και πατάμε το πλήκτρο «O» για να δημιουργηθεί το κλειδί.

  6. Εν συνεχεία, θα μας ζητηθεί να δημιουργήσουμε έναν κωδικό για αυτό:
    You need a Passphrase to protect your secret key.

    Πληκτρολογούμε τον κωδικό μας προσεκτικά (δύο φορές για επαλήθευση) και το κλειδί GPG θα δημιουργηθεί επιτυχώς όταν εμφανιστεί το παρακάτω μήνυμα:

    gpg: key ΑΡΙΘΜΟΣ (ΧΧΧΧΧΧΧΧ) marked as ultimately trusted
    public and secret key created and signed.
    pub ΧΧΧΧΑ/ΧΧΧΧΧΧΧΧ Ημερομηνία
    Key fingerprint = ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ
    uid Όνομα Επίθετο (Sign Package key)
    sub ΥΥΥΥΒ/ΥΥΥΥΥΥΥΥ Ημερομηνία

Αφού κάνουμε τα έξι βήματα παραπάνω, βλέπουμε στο τελευταίο μήνυμα πως το κλειδί δημιουργήθηκε. Σε αυτό το σημείο θα μας χρειαστεί αυτός ο οκταψήφιος συνδυασμός αριθμών-γραμμάτων που φαίνεται στην γραμμή «pub» ως ΧΧΧΧΧΧΧΧ στο τελευταίο μήνυμα στο βήμα 6, καθώς και αυτό το Key fingerprint που εδώ αναγράφεται ως ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ ΧΧΧΧ.

Ακόμη, πρέπει να δηλώσουμε το κλειδί στους servers του Ubuntu, ώστε να είναι δημόσιο. Αυτό το κάνουμε ακολουθώντας τα βήματα παρακάτω:

  1. Στον υπολογιστή μας, ανοίγουμε το «Passwords and Encryption keys».
  2. Πηγαίνουμε στην καρτέλα «GnuPG Keys» και βλέπουμε στη λίστα το κλειδί που δημιουργήθηκε προηγουμένως. Κάνουμε ένα κλικ επάνω του (δεν θα γίνει τίποτα).
  3. Στο μενού, επιλέγουμε «Remote» και «Sync and Publish Keys…».
  4. Στο παράθυρο που θα ανοίξει, πατάμε το κουμπί «Key Servers» και στο επόμενο παράθυρο το κουμπί «Add» και στο πλαίσιο «Host» βάζουμε τον σύνδεσμο: keyserver.ubuntu.com και πατάμε «OK».
  5. Μετά, θα έχουμε επιστρέψει στο προηγούμενο παράθυρο όπου στη λίστα του «Publish keys to:» θα υπάρχει ο παραπάνω σύνδεσμος. Τον επιλέγουμε με το ποντίκι (ένα κλικ) και πατάμε το κουμπί «Close».
  6. Tέλος, στο προηγούμενο παράθυρο πατάμε το κουμπί «Sync» προκειμένου να ανεβάσουμε το κλειδί μας στους servers του Ubuntu, κάτι που μπορεί να διαρκέσει έως και 30 λεπτά.

Αφού όλη αυτή η διαδικασία γίνεται για πακετάρισμα λογισμικού, καλό θα είναι να δηλώσουμε το κλειδί που δημιουργήθηκε προηγουμένως στο Launchpad, σε περίπτωση που θέλουμε να ανεβάσουμε τα πακέτα που παράγουμε εκεί, σε δικό μας αποθετήριο. Οπότε, ας δούμε πως δηλώνουμε το κλειδί μας στο Launchpad:

  1. Δημιουργία λογαριασμού στο Launchpad (φαίνεται πως γίνεται αυτό στον σύνδεσμο παραπάνω). Εννοείται παραλείπουμε αυτό το βήμα αν έχουμε ήδη λογαριασμό.
  2. Στον υπολογιστή μας, ανοίγουμε το «Passwords and Encryption keys».
  3. Πηγαίνουμε στην καρτέλα «GnuPG Keys» και βλέπουμε στη λίστα το κλειδί μας όπως και προηγουμένως.
  4. Πατάμε δεξί κλικ στο κλειδί και στη συνέχεια «Properties».
  5. Στο παράθυρο που θα ανοίξει, πηγαίνουμε στην καρτέλα «Details» και αντιγράφουμε το fingerprint του κλειδιού.
  6. Ανοίγουμε τον browser και πηγαίνουμε στον λογαριασμό μας στο Launchpad και πατάμε το κίτρινο κουμπί με το μολύβι δίπλα από το «OpenPGP keys».
  7. Αφού μας ζητηθεί να ξανακάνουμε login για επαλήθευση, στη σελίδα που θα ανοίξει πάμε κάτω κάτω, κάνουμε επικόλληση το fingerprint στο αντίστοιχο πλαίσιο και πατάμε το κουμπί «Import».

Αφού ολοκληρωθεί και αυτό, θα λάβουμε ένα e-mail στο οποίο θα εμπεριέχεται ένα κείμενο κρυπτογραφημένο με το κλειδί που ανεβάσαμε στο Launchpad. Το αποκρυπτογραφούμε ακολουθώντας τα εξής βήματα:

  1. Αντιγράφουμε το κρυπτογραφημένο κείμενο (μόνο αυτό) από το e-mail και το κάνουμε επικόλληση σε ένα αρχείο με όνομα «file.txt».
  2. Στην συνέχεια, ανοίγουμε το τερματικό μας και εκτελούμε την εντολή:
    gpg --decrypt file.txt

    Αφού προηγουμένως, έχουμε πλοηγηθεί στον φάκελο όπου είναι αποθηκευμένο το αρχείο.

  3. Θα μας ζητηθεί να πληκτρολογήσουμε τον κωδικό του κλειδιού.
  4. Μετά την πληκτρολόγηση του κωδικού, το μήνυμα θα αποκρυπτογραφηθεί και θα περιέχει έναν σύνδεσμο τον οποίο ακολουθούμε για να επιβεβαιώσουμε την εισαγωγή του κλειδιού μας στο Launchpad.

Ρύθμιση παραμέτρων περιβάλλοντος

Πρέπει να γίνουν κάποιες ρυθμίσεις στο σύστημα προκειμένου να υπογράφονται τα πακέτα που πρόκειται να δημιουργηθούν ακολουθώντας την διαδικασία του packaging. Επειδή θα δουλεύουμε από το τερματικό, οι ρυθμίσεις αυτές αφορούν παραμέτρους στην λειτουργία του τερματικού στο οποίο δουλεύουμε. Θα τις κάνουμε στο αρχείο «.bashrc», το οποίο είναι ένα κρυφό αρχείο στον προσωπικό κατάλογο (Home), που εκτελείται ως script κάθε φορά που ανοίγει μία νέα συνεδρία (session) στο τερματικό. Σε αυτό το αρχείο θα προσθέσουμε τις παραμέτρους που αφορούν την υπογραφή των πακέτων.

  1. Ανοίγουμε το αρχείο «.bashrc», εκτελώντας στο τερματικό:
    bash gedit .bashrc
  2. Κάτω κάτω, στο περιεχόμενο του αρχείου, αφήνουμε μία κενή γραμμή και προσθέτουμε τα εξής:
    export DEBFULLNAME="Όνομα Επίθετο"
    export DEBEMAIL="e-mail"
    export GPGKEY=Αριθμός δημόσιου GPG κλειδιού
    export QUILT_PATCHES=debian/patches
    export QUILT_REFRESH_ARGS="-p ab --no-timestamps --no-index"

    Οι δύο πρώτες παράμετροι είναι ο ορισμός του ονοματεπώνυμου του packager και της διεύθυνσης e-mail του. Η τρίτη, πρόκειται για τον αριθμό κλειδιού που προηγουμένως συμβολίσαμε ως XXXXXXXX. Οι δύο εναπομείνασες αφορούν το πρόγραμμα «quilt» (για την διαχείριση patches), στο οποίο θα αναφερθούμε παρακάτω. Οπότε βάζουμε αυτά τα στοιχεία και αποθηκεύουμε το αρχείο. Σε αυτό το σημείο, κάνουμε επανεκκίνηση του υπολογιστή.

Ρύθμιση εργαλείων

Ήρθε η στιγμή να ρυθμίσουμε, για τις ανάγκες μας, το βασικό εργαλείο που θα χρησιμοποιούμε για τη δημιουργία και τον έλεγχο πακέτων λογισμικού. Πρόκειται για το «sbuild», το οποίο εγκαταστήσαμε προηγουμένως μαζί με άλλα χρήσιμα εργαλεία. Δεν είναι τίποτε άλλο, παρά ένα περιβάλλον προσομοίωσης του συστήματος χτισίματος πακέτων του Launchpad. Ουσιαστικά, ένα Ubuntu μέσα στο Ubuntu μας, όπου τα πακέτα που θα φτιάχνουμε θα ελέγχονται και θα δημιουργούνται μέσα σε αυτό. Προκειμένου να ρυθμίσουμε σωστά το «sbuild», ακολουθούμε τα εξής βήματα:

  1. Με την εγκατάσταση του sbuild, δημιουργήθηκε και αντίστοιχο group, στο οποίο προσθέτουμε τον χρήστη μας, εκτελώντας στο τερματικό την εντολή:
    sudo adduser $USER sbuild
  2. Δημιουργούμε ένα κατάλογο ο οποίος θα χρησιμοποιηθεί ως mount point για το sbuild, εκτελώντας:
    mkdir -p $HOME/ubuntu/scratch
    mkdir $HOME/ubuntu/logs

    Εδώ, δημιουργείται ένας κατάλογος με όνομα «ubuntu» και μέσα σε αυτόν, ένας άλλος με όνομα «scratch» και ένας με το όνομα «logs». Αυτός ο φάκελος (ubuntu) είναι ένα ενδεικτικό παράδειγμα. Μπορείτε να δημιουργήσετε τον φάκελο όπου και με όποιο όνομα επιθυμείτε, αρκεί μέσα να φτιάξετε και τους άλλους δύο.

  3. Ανοίγουμε το αρχείο «/etc/schroot/sbuild/fstab», εκτελώντας την εντολή:
    gedit /etc/schroot/sbuild/fstab

    Και τοποθετούμε σε αυτό την γραμμή:

    /home/USERNAME/ubuntu/scratch /scratch none rw,bind 0 0

    Κάντε τις ανάλογες αλλαγές εάν χρησιμοποιήσατε άλλο φάκελο και αποθηκεύστε το αρχείο.

  4. Δημιουργούμε το αρχείο «.sbuildrc» στον προσωπικό μας φάκελο, εκτελώντας την ακόλουθη εντολή:
    gedit ~/.sbuildrc

    Και μέσα σε αυτό, προσθέτουμε το ακόλουθο κείμενο:

    # Mail address where logs are sent to (mandatory, no default!)
    $mailto = $ENV{USER};
    # Name to use as override in .changes files for the Maintainer: field
    # (mandatory, no default!).
    $maintainer_name='ΟΝΟΜΑ ΕΠΙΘΕΤΟ <E-MAIL>';
    # Default distribution to build.
    $distribution = "xenial";
    # Build arch-all by default.
    $build_arch_all = 1;
    # When to purge the build directory afterwards; possible values are"never",
    #"successful", and "always"."always" is the default. It can be helpful
    # to preserve failing builds for debugging purposes. Switch these comments
    # if you want to preserve even successful builds, and then use
    #"schroot -e --all-sessions" to clean them up manually.
    $purge_build_directory = 'successful';
    $purge_session = 'successful';
    $purge_build_deps = 'successful';
    # $purge_build_directory = 'never';
    # $purge_session = 'never';
    # $purge_build_deps = 'never';
    # Directory for writing build logs to
    $log_dir=$ENV{HOME}."/ubuntu/logs";
    # don't remove this, Perl needs it:
    1;

    Αποθηκεύουμε το αρχείο.

Εδώ, παρατηρήστε πως υπάρχει η γραμμή «$distribution = «xenial»;». Σε αυτό το σημείο, δηλώνουμε για ποια έκδοση του Ubuntu θα δημιουργήσουμε πακέτα. Στην προκειμένη περίπτωση, το xenial αντιστοιχεί στην έκδοση Ubuntu 16.04 LTS. Ακόμα, στην τελευταία γραμμή βλέπουμε αναφορά στον φάκελο «ubuntu/logs», που δημιουργήθηκε σε προηγούμενο βήμα. Αν έχετε φτιάξει φάκελο με άλλο όνομα και σε άλλη θέση, κάντε τις ανάλογες αλλαγές στην τελευταία γραμμή (το $ENV{HOME}. αντιστοιχεί στον προσωπικό φάκελο, οπότε κάντε τις αλλαγές μετά από αυτό).Ακόμα, προσέξτε τη γραμμή όπου θα πρέπει να προσθέσετε το ονοματεπώνυμό σας και το e-mail σας, ως maintainer του πακέτου.

  • Δημιουργούμε το αρχείο «.mk-sbuild.rc» στον προσωπικό μας φάκελο, εκτελώντας την εντολή:
    gedit ~/.mk-sbuild.rc

    Και μέσα σε αυτό, προσθέτουμε το ακόλουθο κείμενο:

    SCHROOT_CONF_SUFFIX="source-root-users=root,sbuild,admin
    source-root-groups=root,sbuild,admin
    preserve-environment=true"
    # you might want to undo the below for stable releases, read `man mk-sbuild` for details
    SKIP_UPDATES="1"
    SKIP_PROPOSED="1"
    # if you have e.g. apt-cacher-ng around
    # DEBOOTSTRAP_PROXY=http://127.0.0.1:3142/

    Αποθηκεύουμε το αρχείο.

  • Μπαίνουμε στο group όπου προσθέσαμε τον χρήστη νωρίτερα, με την εντολή:
    sg sbuild
  • Παράγουμε ένα κλειδί GPG εντός του group, με την εντολή:
    sudo sbuild-update --keygen
  • Και τέλος, δημιουργούμε το περιβάλλον χτισίματος, με την εντολή:
    mk-sbuild xenial

    Οι ονομασίες του περιβάλλοντος καλό θα είναι να έχουν την κωδική ονομασία της έκδοσης του Ubuntu για την οποία θα δημιουργούμε πακέτα, για να μην υπάρξει σύγχυση. Πάλι, εδώ ως παράδειγμα χρησιμοποιείται το xenial.

  • Τέλος, για να είναι συγχρονισμένο το περιβάλλον με τις αλλαγές που κάναμε, εκτελούμε στο τερματικό:
    sudo sbuild-launchpad-chroot create -n xenial-amd64-sbuild -s xenial -a amd64
    sudo sbuild-update --keygen

    Εδώ, πάλι, προσέξτε στην πρώτη εντολή τα «xenial». Επαναλαμβάνομαι, αλλά είναι σημαντικό να μην γίνουν τέτοια λάθη. Βάζετε την κωδική ονομασία της έκδοσης για την οποία επιθυμείτε να φτιάξετε πακέτα. Επίσης έχω αφήσει εξ’ ορισμού την αρχιτεκτονική των 64 bit, αλλά αν θέλετε το αλλάζετε και αυτό. Ούτως ή άλλως, στο αρχείο .sbuildrc που δημιουργήσαμε στο βήμα 4 ορίσαμε τα πακέτα που χτίζουμε να δημιουργούνται και για τις δύο αρχιτεκτονικές (32 και 64bit).

Στο σημείο αυτό, τελειώνει και η απαραίτητη προετοιμασία, οπότε, είμαστε έτοιμοι να συνεχίσουμε με την εισαγωγή στο πακετάρισμα λογισμικού για το Ubuntu.

Packaging

Δεδομένου πως η προετοιμασία της προηγούμενης ενότητας έχει πραγματοποιηθεί σωστά, ακολουθώντας όλες τις οδηγίες στην προηγούμενη ενότητα, είμαστε έτοιμοι να ξεκινήσουμε με την ουσία αυτών, το packaging.

Το πακετάρισμα λογισμικού είναι μία μεγάλη ενότητα, η οποία χρειάζεται αναλυτική περιγραφή και προσοχή σε διάφορες λεπτομέρειες. Επειδή, όμως, σκοπός αυτού του οδηγού είναι να απευθυνθεί σε αρχάριους χρήστες όσον αφορά το packaging, θα ακολουθήσουν ως παραδείγματα δύο απλές περιπτώσεις πακεταρίσματος λογισμικού, οι οποίες δεν θα εμφανίσουν επιπλοκές και σφάλματα, προκειμένου να γίνει κατανοητή η διαδικασία και να μην υπάρξει σύγχυσγ με λεπτομέρειες που μπορούν να παραληφθούν στην εισαγωγή μας στην διαδικασία.

Στην συνέχεια του οδηγού, θα προστίθενται πράγματα και λεπτομέρειες ώστε να εμβαθύνουμε τις γνώσεις μας στο packaging και να προσέχουμε όποιες λεπτομέρειες υπάρχουν ώστε να είμαστε απόλυτα τυπικοί, βάσει των προδιαγραφών των Ubuntu και Debian που αφορούν το packaging. Αλλά, όπως αναφέρθηκε, προς το παρόν δεν θα είμαστε τόσο τυπικοί.

Αναβάθμιση έκδοσης υπάρχοντος λογισμικού για το Ubuntu

Όπως αναφέρθηκε νωρίτερα, σχετικά με την αναβάθμιση υπάρχοντος για το Ubuntu πακέτου, πρόκειται για την απλούστερη περίπτωση στο packaging. Επειδή η διαδικασία θα απαιτήσει την λήψη και επεξεργασία αρχείων, καλό θα είναι να γίνει σε έναν φάκελο αποκλειστικά για αυτό το σκοπό, για να έχουμε τα αρχεία μας συμμαζεμένα. Δημιουργήστε, λοιπόν, ένα φάκελο όπου σας διευκολύνει (μέσα στο «Home» ή στους υποφακέλους του), ανοίξτε το τερματικό σας και κάντε «cd» σε αυτόν τον φάκελο.

Την στιγμή που συντάσσεται το παρόν κείμενο, η τρέχουσα έκδοση του Ubuntu είναι η 16.04 LTS (Xenial Xerus), η οποία περιέχει στα επίσημα αποθετήρια της τα συστατικά του περιβάλλοντος εργασίας GNOME, έκδοσης 3.18 ή παλαιότερης. Το GNOME Project, όμως, την ίδια στιγμή, έχει τα συστατικά του στην έκδοση 3.20. Επειδή οι οδηγίες που ακολουθούν για την διαδικασία του packaging είναι γενικές και εμπλέκονται πολλά αρχεία, παράλληλα, σε κάθε βήμα θα υπάρχουν screenshots με την εφαρμογή της διαδικασίας στο πακέτο-πειραματόζωο «gnome-disk-utility», το οποίο είναι ένα από τα συστατικά του GNOME και αυτή τη στιγμή βρίσκεται στην έκδοση 3.18.1. Θα χρησιμοποιηθεί επίσης και η εντολή «ls» για να βλέπουμε τα αρχεία που δημιουργούνται σε κάθε βήμα. Ας δοκιμάσουμε, λοιπόν, να αναβαθμίσουμε το «gnome-disk-utility» στην τελευταία του upstream έκδοση.

gdu3.18

• Βήμα 1: Λήψη πακέτου

Για να αναβαθμίσουμε ένα λογισμικό το οποίο υπάρχει ήδη στο Ubuntu, πρέπει πρώτα να κατεβάσουμε την υπάρχουσα έκδοση. Ο λόγος δεν είναι άλλος από την διατήρηση του φακέλου «debian», ο οποίος περιέχει ήδη Ubuntu-specific παραμέτρους στο λογισμικό (patches για διορθωμένα bugs και άλλα), οι οποίες πρέπει να διατηρηθούν ώστε να μην χρειαστεί να ξανακάνουμε δουλειά ή οποία έχει ήδη γίνει από άλλους packagers.

Για να κατεβάσουμε την υπάρχουσα έκδοση ενός λογισμικού, εκτελούμε στο τερματικό:

pull-lp-source ΟΝΟΜΑ_ΠΑΚΕΤΟΥ

Με την εκτέλεση της παραπάνω εντολής, στον φάκελό μας θα κατέβουν τα εξής στοιχεία:

  1. Ο φάκελος «όνομα_πακέτου-‘έκδοση(Upstream)’», ο οποίος περιέχει τον πηγαίο κώδικα του λογισμικού της υπάρχουσας έκδοσης, μαζί με τον κατάλογο «debian».
  2. Το tarball «όνομα_πακέτου-‘έκδοση(Upstream)’.orig.tar», το οποίο περιέχει τον πηγαίο κώδικα του λογισμικού της υπάρχουσας έκδοσης όπως αυτός είναι upstream.
  3. Το tarball «όνομα_πακέτου-‘έκδοση(Upstream)-έκδοση(Ubuntu)’.tar», το οποίο περιέχει τον πηγαίο κώδικα του λογισμικού της υπάρχουσας έκδοσης, μαζί με τον κατάλογο «debian».
  4. Η εικόνα «όνομα_πακέτου-‘έκδοση(Upstream)-έκδοση(Ubuntu)’.dsc».

Και με τη λήψη του φακέλου «όνομα_πακέτου-‘έκδοση(Upstream)’» αυτόματα εφαρμόζονται στον πηγαίο κώδικα τα τυχόντα υπάρχοντα patches και οι Ubuntu-specific αλλαγές, όπως αυτές ισχύουν στο υπάρχον πακέτο.

pulllpsource

• Βήμα 2: Έλεγχος και λήψη νεότερης έκδοσης

Στην συνέχεια, πρέπει να ελέγξουμε αν έχει βγει νεότερη έκδοση του λογισμικού από την ομάδα ανάπτυξής του (upstream) και να την κατεβάσουμε. Μπαίνουμε πρώτα στον φάκελο με τον πηγαίο κώδικα που κατεβάσαμε πριν:

cd όνομα_πακέτου-'έκδοση(Upstream)'

Και ελέγχουμε αν υπάρχει νεότερη έκδοση εκτελώντας την ακόλουθη εντολή, η οποία εφόσον υπάρχει νεότερη έκδοση, θα την κατεβάσει κιόλας:

uscan

Όπου μετά την εκτέλεσή της, στον αρχικό φάκελό μας, εκτός των τεσσάρων στοιχείων που κατέβηκαν στο βήμα 1, θα έχουμε επιπλέον δύο αρχεία:

  1. Το tarball «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)’.orig.tar», το οποίο περιέχει τον πηγαίο κώδικα της τελευταίας upstream έκδοσης, και αμέσως μετά, θα του προσθέσουμε και τον κατάλογο «debian».
  2. Το tarball «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)’.tar».

Πληροφοριακά, ο τρόπος που η παραπάνω εντολή βρίσκει την τελευταία έκδοση του λογισμικού, είναι μέσω του αρχείου «debian/watch».

uscan

• Βήμα 3: Ενημέρωση της νεότερης έκδοσης με τον κατάλογο «debian»

Αυτό που θέλουμε να κάνουμε τώρα, είναι στην τελευταία έκδοση του λογισμικού που κατέβηκε εκτελώντας την εντολή στο προηγούμενο βήμα, να προσθέσουμε τον κατάλογο «debian» από την υπάρχουσα έκδοση, ώστε να περάσουμε τις Ubuntu-specific αλλαγές στην νεότερη έκδοση. Αυτό γίνεται εκτελώντας:

uupdate ../ΟΝΟΜΑ_ΠΑΚΕΤΟΥ-'ΤΕΛΕΥΤΑΙΑ_ΕΚΔΟΣΗ(Upstream)'.orig.tar

Έτσι, ο κατάλογος «debian» από την προηγούμενη έκδοση θα περάσει στην νεότερη. Εδώ, προσοχή, θα πρέπει να βάλετε ακριβώς το όνομα του αρχείο μαζί με την κατάληξή του (tar.xz ή οτιδήποτε). Μετά από αυτή την ενέργεια θα έχουν δημιουργηθεί:

  1. Ο φάκελος «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)’» με την νεότερη έκδοση του λογισμικού, όπου θα περιέχει τον κατάλογο «debian»
  2. Ο φάκελος «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)’.orig» με την νεότερη έκδοση του λογισμικού, όπως αυτή είναι upstream.

uupdate

• Βήμα 4: Έλεγχος εξαρτήσεων

Συνεχίζουμε ελέγχοντας τις εξαρτήσεις του λογισμικού. Οι εξαρτήσεις είναι άλλα λογισμικά στα οποία βασίζεται το λογισμικό που αναβαθμίζουμε, ώστε να λειτουργεί σωστά. Συνήθως, όταν δημιουργηθεί μία νέα έκδοση ενός λογισμικού, οι εξαρτήσεις αυτού (άλλα λογισμικά) έχουν αλλάξει. Συγκεκριμένα, ή προστέθηκαν νέες εξαρτήσεις, ή αφαιρέθηκαν, ή όπως πιο συχνά συμβαίνει, οι υπάρχουσες εξαρτήσεις χρειάζεται να είναι σε νεότερη έκδοσή τους. Γενικότερα, για να δούμε τι αλλαγές έχουν γίνει στις εξαρτήσεις του πακέτου που αναβαθμίζουμε θα πρέπει να ελέγξουμε το αρχείο «configure.ac», το οποίο βρίσκεται στον βασικό φάκελο του λογισμικού upstream. Συνεπώς, προκειμένου να το κάνουμε αυτό, πρέπει να κατεβάσουμε τον φάκελο του λογισμικού στον υπολογιστή. Αυτό το κάνουμε με το εργαλείο «git» (αφού πρώτα πλοηγηθούμε ξανά, πίσω στον αρχικό φάκελο όπου δουλεύουμε), εκτελώντας:

cd .. && git clone ΣΥΝΔΕΣΜΟΣ_ΛΟΓΙΣΜΙΚΟΥ

Για παράδειγμα, τα εργαλεία του GNOME Project βρίσκονται σε σύνδεσμο του τύπου:

http://git.gnome.org/browse/PACKAGE

Αφού εκτελέσουμε την εντολή, στον αρχικό φάκελο θα έχει προστεθεί ακόμα ένας φάκελος:

  1. Ο φάκελος «ΟΝΟΜΑ_ΛΟΓΙΣΜΙΚΟΥ», ο οποίος θα έχει το όνομα του λογισμικού για το οποίο δουλεύουμε (χωρίς κάποιον αριθμό έκδοσης).

Μπαίνουμε, λοιπόν, σε αυτό το φάκελο και ανοίγουμε το αρχείο «configure.ac», εκτελώντας:

cd ΦΑΚΕΛΟΣ_ΛΟΓΙΣΜΙΚΟΥ(ΧΩΡΙΣ ΕΚΔΟΣΗ) git log -p configure.ac

Εδώ, στο τερματικό μας θα δούμε το log, δηλαδή τις αλλαγές που έχουν γίνει στο λογισμικό, κυρίως αλλαγές στις εξαρτήσεις, που έχουν γίνει από έκδοση σε έκδοση. Θα υπάρχουν γραμμές τονισμένες με τον εξής τρόπο:

-ΚΑΤΙ ΠΟΥ ΑΦΑΙΡΕΘΗΚΕ
+ΚΑΤΙ ΠΟΥ ΠΡΟΣΤΕΘΗΚΕ

Οπότε, όταν έχει γίνει προσθήκη κάποιας εξάρτησης, θα δούμε στο log του αρχείου κάτι τέτοιο:

+ΟΝΟΜΑ-ΕΞΑΡΤΗΣΗΣ_REQUIRED="όνομα_πακέτου >= αριθμός_έκδοσης_εξάρτησης"

Αντίστοιχα, αν κάποια εξάρτηση έχει αφαιρεθεί:

-ΟΝΟΜΑ-ΕΞΑΡΤΗΣΗΣ_REQUIRED="όνομα_πακέτου >= αριθμός_έκδοσης_εξάρτησης"

Ενώ, αν απλά έχει αναβαθμιστεί η έκδοση υπάρχουσας εξάρτησης (η συνηθέστερη περίπτωση):

-ΟΝΟΜΑ-ΕΞΑΡΤΗΣΗΣ_REQUIRED="όνομα_πακέτου >= αριθμός_έκδοσης_εξάρτησης"
+ΟΝΟΜΑ-ΕΞΑΡΤΗΣΗΣ_REQUIRED="όνομα_πακέτου >= αριθμός_νέας_έκδοσης_εξάρτησης"

Οπτικά, αυτή η δομή της επισήμανσης των αλλαγών αποτελεί διευκόλυνση για έναν packager, διότι βλέπουμε με κόκκινο χρώμα και το σύμβολο «» στην αρχή, τις γραμμές που έχουν αφαιρεθεί, ενώ με πράσινο χρώμα και το σύμβολο «+», τις γραμμές που προστέθηκαν. Αφού δούμε τι αλλαγές έχουν γίνει (scrollάρουμε στο log στο τερματικό με τα βελάκια του πληκτρολογίου), αν έχουν γίνει (διότι στο παράδειγμα δεν έχει γίνει καμία αλλαγή στις εξαρτήσεις. Τυχαίνει.), κλείνουμε το log (με το πλήκτρο q).

• Βήμα 5: Ενημέρωση εξαρτήσεων

Αφού, λοιπόν, δούμε τις εν λόγω αλλαγές στις εξαρτήσεις του λογισμικού, πρέπει να πάμε να τις ορίσουμε στο πακέτο που θα δημιουργηθεί για το Ubuntu. Αυτό, γίνεται με επεξεργασία του αρχείου «debian/control.in», το οποίο βρίσκεται στον φάκελο της νεότερης έκδοσης του λογισμικού (ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)’). Είτε μέσω κάποιου κειμενογράφου στο τερματικό, είτε με οποιονδήποτε κειμενογράφο, ανοίγουμε το αρχείο «debian/control.in» και εκτός διαφόρων πληροφοριών που υπάρχουν σε αυτό, θα δούμε και την κατηγορία «Build-Depends:», στην οποία θα υπάρχει η λίστα των εξαρτήσεων του λογισμικού και η έκδοση αυτών. Η λίστα αυτή θα έχει τη μορφή:

Build-Depends: εξάρτηση_1 (>= έκδοση),
εξάρτηση_2 (>= έκδοση),
εξάρτηση_3 (>= έκδοση),
εξάρτηση_4 (>= έκδοση),
...
εξάρτηση_ν (>= έκδοση)

Σε αυτή τη λίστα θα κάνουμε τις κατάλληλες αλλαγές στις εξαρτήσεις του λογισμικού, είτε πρόκειται για αλλαγή στον αριθμό έκδοσης της εξάρτησης, είτε προσθήκη νέας εξάρτησης, είτε αφαίρεση παλιάς. Απλώς, προσθαφαιρούμε στη λίστα τις αλλαγές που παρατηρήσαμε στο προηγούμενο βήμα με την ανάγνωση του αρχείου «configure.ac». Αποθηκεύουμε το αρχείο, αφού κάνουμε όλες τις απαραίτητες αλλαγές.

Σε αυτό το σημείο, να τονιστεί κάτι σημαντικό που αφορά τον εκάστοτε packager: Οι εξαρτήσεις ενός πακέτου εγκαθίστανται αυτόματα αφού πρώτα ληφθούν από τα αποθετήρια της διανομής. Το γεγονός πως η νέα έκδοση του λογισμικού που θέλουμε να αναβαθμίσουμε μπορεί να χρησιμοποιεί νεότερες εκδόσεις εξαρτήσεων, δεν σημαίνει πως αυτές οι εκδόσεις των εξαρτήσεων υπάρχουν στα αποθετήρια (μπορεί αυτές στα αποθετήρια να είναι παλιότερες), πράγμα που αν ισχύει, θα αφήσει τις εν λόγω εξαρτήσεις ανικανοποίητες και δεν θα γίνει η εγκατάσταση της νέας έκδοσης του λογισμικού. Σε αυτή την περίπτωση, πρέπει να πακετάρουμε και την ίδια την εξάρτηση, με τον ίδιο ακριβώς τρόπο που αναγράφεται στην παρούσα ενότητα. Όπως καταλαβαίνετε, η ίδια η εξάρτηση μπορεί να έχει δικές τις εξαρτήσεις, και η νέα έκδοσή της να απαιτεί νεότερες εκδόσεις των εξαρτήσεων της οι οποίες μπορεί να μην βρίσκονται στα αποθετήρια. Βλέπουμε πως μία απλή αναβάθμιση ενός πακέτου, μπορεί να δημιουργήσει μία αλυσίδα ελέγχου και αναβαθμίσεων άλλων πακέτων-εξαρτήσεων προκειμένου να επιτευχθεί, πράγμα που μας καλωσορίζει στην σκοτεινή πλευρά του packaging. Ελέγχουμε ποια πακέτα (και ποιες εκδόσεις αυτών) υπάρχουν στα επίσημα αποθετήρια του Ubuntu είτε μέσω του τερματικού μας, είτε μέσω αυτού του συνδέσμου. Επίσης, ενδέχεται να υπάρχουν δύο αρχεία, το «control» και το «control.in», ή μόνο ένα από τα δύο. Αν υπάρχουν και τα δύο, τότε αυτό που επεξεργαζόμαστε για να κάνουμε τις αναγκαίες αλλαγές, είναι το «control.in».

control

• Βήμα 6: Εφαρμογή patches

Στο βήμα 3, περάσαμε τον κατάλογο «debian» από την προηγούμενη έκδοση στην νεότερη. Θα πρέπει όμως να εφαρμόσουμε όποια patches υπάρχουν από την παλιότερη έκδοση, στη νέα. Έτσι, γυρνάμε στον αρχικό μας φάκελο (όπου δουλεύουμε) και στην συνέχεια μπαίνουμε σε αυτόν της νεότερης έκδοσης:

cd ../ΟΝΟΜΑ_ΠΑΚΕΤΟΥ-'ΤΕΛΕΥΤΑΙΑ_ΕΚΔΟΣΗ(Upstream)'

Και εφαρμόζουμε τα patches εκτελώντας:

quilt push -a

Το «quilt» είναι ένα εργαλείο διαχείρισης και διόρθωσης patches. Με την παραπάνω εντολή, ουσιαστικά, εφαρμόζουμε στην νεότερη έκδοση όλα τα patches που βρίσκονται στον κατάλογο «debian/patches». Εδώ, αν όλα πάνε καλά δεν θα μας εμφανιστεί κάποιο σφάλμα. Αν εμφανιστεί σφάλμα, τότε, αυτό σημαίνει πως κάποιο patch δεν εφαρμόστηκε σωστά στο λογισμικό. Αυτό, συνήθως, σημαίνει πως ο κώδικας του λογισμικού έχει αλλάξει στο σημείο όπου κάνει αλλαγές το εν λόγω patch και θα πρέπει να το επεξεργαστούμε κατάλληλα ώστε να εφαρμόζεται σωστά. Δεν θα ελέγξουμε αυτή την περίπτωση προς το παρόν, διότι θα χρειαστεί να επεκταθούμε σε πιο προχωρημένες διαδικασίες που αφορούν το packaging, δηλαδή την επεξεργασία ή την διαγραφή patches, αναλόγως με τις ανάγκες του πηγαίου κώδικα του λογισμικού. Αρκετές φορές, ειδικότερα σε αναβαθμίσεις που δεν απέχουν πολύ μεταξύ τους οι εκδόσεις, δεν εμφανίζονται τέτοια σφάλματα. Άλλες φορές εμφανίζονται.

quilt

• Βήμα 7: Καταγραφή αλλαγών

Προτού προχωρήσουμε με τη δημιουργία και τον έλεγχο του νέου πακέτου, πρέπει να καταγράψουμε τις αλλαγές που κάναμε. Όπως αναφέρθηκε σε προηγούμενη ενότητα, αυτό γίνεται στο αρχείο «debian/changelog». Τώρα, όμως, το αρχείο «debian/changelog» αυτή τη φορά δεν θα ανοίξουμε με κάποιο κειμενογράφο χειροκίνητα, αλλά με την εξής εντολή:

dch -r

Βλέπουμε πως θα ανοίξει το αρχείο changelog με το nano και πως ήδη σε αυτό έχουν εισαχθεί τα στοιχεία μας (επειδή προηγουμένως τα είχαμε ορίσει στο αρχείο .bashrc) και οι πληροφορίες για το πακέτο, την έκδοσή του και την έκδοση του Ubuntu για την οποία θα δημιουργηθεί. Δηλαδή, θα δούμε το εξής:

πακέτο (έκδοση.upstream-έκδοση.στο.ubuntu) διανομή; urgency=low/medium/high

* New upstream release

-- Όνομα Επίθετο <e-mail> Ημερομηνία

Όπως είπαμε, πρόκειται για αρχείο καταγραφής των αλλαγών, όπως αυτές που είδαμε στο προηγούμενο βήμα που αφορούν την ενημέρωση των εξαρτήσεων για τη νέα έκδοση. Βλέπουμε στο περιεχόμενο του αρχείου πως αρχικά αναγράφεται το όνομα του πακέτου, ή έκδοση Upstream (πχ. 3.20.0) του λογισμικού και η έκδοση του στο Ubuntu (πχ. 0ubuntu1) και η προτεραιότητά του. Ακριβώς από κάτω, με αστερίσκους βάζουμε σχόλια (εν συντομία) που αφορούν τις αλλαγές που κάναμε (που προς το παρόν αφορούν μόνο αλλαγές στις εξαρτήσεις του λογισμικού). Τέλος, φαίνεται η υπογραφή μας, δηλαδή τα στοιχεία μας τα οποία μπαίνουν αυτόματα σε αυτό το σημείο (δεν τα πειράζουμε χειροκίνητα), επειδή τα ορίσαμε στο .bashrc προηγουμένως. Κάτω από όλα αυτά, θα υπάρχει στο ίδιο μοτίβο η καταγραφή αλλαγών σε παλιότερες εκδόσεις του πακέτου από άλλους packagers (εννοείται πως δεν τα πειράζουμε). Σε αυτό το σημείο, εμείς θα χρειαστεί να κάνουμε δύο αλλαγές:

  1. Προσθήκη σχολίου για καταγραφή των αλλαγών που κάναμε στις εξαρτήσεις.
  2. Προσθήκη κάποιου tag (ό,τι θέλουμε) στην έκδοση του πακέτου για να γνωρίζουμε όταν το δούμε στο σύστημα πως είναι δικό μας (προαιρετικά για προσωπική χρήση, αλλά ακολουθούμε τους κανόνες του εκάστοτε αποθετηρίου αν λειτουργούμε εντός ομάδας packaging).

Για παράδειγμα, μετά τις αλλαγές, η αρχική καταχώρηση στο αρχείο θα είναι κάπως έτσι:

πακέτο (έκδοση.upstream-έκδοση.στο.ubuntu~myusername) xenial; urgency=high/medium/low

* New upstream release
* debian/control.in: Bump build-dep on εξάρτηση_χ

-- Όνομα Επίθετο <e-mail> Ημερομηνία

Έγινε δηλαδή προσθήκη σχολίου πως στο αρχείο «debian/control.in» ενημερώσαμε την εξάρτηση_χ (πράγμα που έγινε στο προηγούμενο βήμα) και η προσθήκη ενός tag (πχ. το username μας) στην έκδοση του πακέτου. Αποθηκεύουμε, στην συνέχεια, το αρχείο ως «changelog» και όχι ως changelog.dch όπως θα προτείνει το nano (διότι εκτελέσαμε την εντολή dch) και κλείνουμε τον nano.

• Βήμα 8: Χτίσιμο πακέτου

Με την περαίωση όλων των παραπάνω, ότι αλλαγές χρειάζονταν να γίνουν για την σωστή αναβάθμιση του λογισμικού, ολοκληρώθηκαν. Τώρα μπορούμε να χτίσουμε το πακέτο μας.

Βρισκόμαστε στον φάκελο με την νέα έκδοση του λογισμικού, δηλαδή αυτόν που εδώ αναγράφουμε ως «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)’». Προκειμένου να χτίσουμε το πακέτο έτσι όπως το διαμορφώσαμε, απλά εκτελούμε στο τερματικό:

debuild -S

Και το πρόγραμμα θα ξεκινήσει και θα ολοκληρώσει την διαδικασία. Αν δεν έχουμε παραλείψει κάτι και έγιναν όλα σωστά, μετά από μερικά δευτερόλεπτα θα δούμε αυτό:

Successfully signed dsc and change files

Ίσως μας ζητηθεί να πληκτρολογήσουμε και τον κωδικό του κλειδιού GPG που έχουμε δημιουργήσει προηγουμένως.

Αφού ολοκληρωθεί το χτίσιμο του πακέτου, πίσω στον αρχικό μας φάκελο (αυτόν που έχουμε δημιουργήσει για να δουλεύουμε) θα έχουν δημιουργηθεί τα εξής αρχεία:

  1. Tο tarball «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag.debian.tar», το οποίο περιέχει την νεότερη έκδοση του λογισμικού, μαζί με τον κατάλογο «debian» ενημερωμένο, δηλαδή, με όλες τις αλλαγές που εφαρμόσαμε στα προηγούμενα βήματα.
  2. Η εικόνα «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag.dsc», δηλαδή η εικόνα του νέου πακέτου για το Ubuntu από το παραπάνω tarball πάνω στην οποία θα γίνει έλεγχος.
  3. Το αρχείο «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag_source.build».
  4. Το αρχείο «ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag_source.changes».

• Βήμα 9: Έλεγχος πακέτου

Το πακέτο μας ουσιαστικά έχει δημιουργηθεί. Θεωρητικά (και πρακτικά) μπορούμε να το ανεβάσουμε στο Launchpad (θα δούμε σε επόμενη ενότητα πως), όμως, πριν γίνει αυτό, πρέπει πρώτα να κάνουμε έναν έλεγχο για να δούμε αν το πακέτο μπορεί να χτιστεί σωστά σε ένα σύστημα Ubuntu. Αυτό είναι το τελευταίο βήμα, ίσως το πιο σημαντικό, καθώς αν έχει γίνει κάποιο λάθος, θα φανεί εδώ.

Αφού επιστρέψουμε στον αρχικό μας φάκελο:

cd ..

Eκτελούμε στο τερματικό:

sbuild --dist=xenial --arch=amd64 -A -c xenial-amd64 ΟΝΟΜΑ_ΠΑΚΕΤΟΥ-'ΤΕΛΕΥΤΑΙΑ_ΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU'~tag.dsc

Παρατήρηση: Όπως και προηγουμένως, στην ενότητα για την κατάλληλη ρύθμιση του sbuild χρειάστηκε προσοχή στο όνομα που θα δώσουμε στο περιβάλλον ελέγχου καθώς και στον ορισμό της έκδοσης του Ubuntu για την οποία δημιουργούμε το πακέτο. Βλέπουμε πως η ονομασία του περιβάλλοντος και η κωδική ονομασία της έκδοσης χρησιμοποιούνται στην παραπάνω εντολή. Αναλόγως, λοιπόν, τις ονομασίες που ορίσαμε τότε και την διανομή για την οποία πακετάρουμε το λογισμικό, κάνουμε τις κατάλληλες αλλαγές στην εντολή παραπάνω.

Επεξήγηση: Η διαδικασία που εφαρμόζεται με την εκτέλεση της παραπάνω εντολής, δεν είναι άλλη από την δημιουργία και την ενημέρωση ενός συστήματος Ubuntu (αυτή άλλωστε είναι η δουλειά του sbuild), στην default κατάστασή του, προκειμένου να εκτελεστεί εκεί η προσπάθεια εγκατάστασης του πακέτου που δημιουργήσαμε και να γίνει ένας εκτεταμένος έλεγχος για την σωστή πρόοδο της διαδικασίας. Η διαδικασία αυτή θα αργήσει, σχετικά, να ολοκληρωθεί. Οπότε, περιμένουμε.

Αφού ολοκληρωθεί η διαδικασία, στο τέλος θα δούμε μία περίληψη (Summary) του ελέγχου που πραγματοποιήθηκε με την εκτέλεση της τελευταίας εντολής. Στο summary, λοιπόν, θα υπάρχει η γραμμή όπου θα αναγράφεται το αποτέλεσμα του ελέγχου (Status), το οποίο θα είναι είτε «Successful» εφόσον ο έλεγχος ολοκληρώθηκε επιτυχώς, είτε «Failed» αν υπήρξαν σφάλματα.

Αν ο έλεγχος ολοκληρωθεί με επιτυχία, στον αρχικό μας φάκελο θα έχουμε επιπλέον τα εξής αρχεία:

  1. ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag_amd64.build
  2. ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag_amd64.changes
  3. ΟΝΟΜΑΠΑΚΕΤΟΥ-‘ΤΕΛΕΥΤΑΙΑΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag_amd64.deb
  4. ΟΝΟΜΑΠΑΚΕΤΟΥ-dbgsym’ΤΕΛΕΥΤΑΙΑ_ΕΚΔΟΣΗ(Upstream)-ΕΚΔΟΣΗ_UBUNTU’~tag_amd64.ddeb

Η διαδικασία ολοκληρώθηκε. Αλλά, λειτουργεί το λογισμικό;

Ναι, λειτουργεί. Μάλιστα, στην συγκεκριμένη περίπτωση του παραδείγματος, αν δεν είχαμε χρησιμοποιήσει το tag «~cerebrux» για το πακέτο, αλλά το «~xenial0», θα μπορούσαμε να στείλουμε το πακέτο μας στην ομάδα «GNOME3 Team» η οποία συντηρεί το αποθετήριο «gnome3-staging», το οποίο περιέχει πάντα την τελευταία έκδοση των συστατικών του GNOME, ώστε να το προσθέσουν στο αποθετήριο.

Δημιουργία πακέτου από το μηδέν (αναφορικά)

Χωρίς να μπούμε σε λεπτομέρειες στην παρούσα στιγμή, διότι η διαδικασία της δημιουργίας από το μηδέν ενός πακέτου στο Ubuntu για ένα λογισμικό, είναι περίπλοκη αρχικά, ας εξετάσουμε εν συντομία και εδώ την απλούστερη περίπτωση. Η διαδικασία είναι παρόμοια. Αυτό που αλλάζει, ουσιαστικά, είναι η «χειροκίνητη» δημιουργία του καταλόγου «debian», σε αντίθεση με την προηγούμενη περίπτωση όπου πρακτικά το πήραμε από προηγούμενη έκδοση λογισμικού και το εφαρμόσαμε στη νεότερη.

Και εδώ, θα χρησιμοποιήσουμε ως παράδειγμα το λογισμικό «fldigi», το οποίο είναι λογισμικό για ραδιοερασιτέχνες (HAM Radio) και δεν υπάρχει στα αποθετήρια του Ubuntu.

• Βήμα 1: Λήψη λογισμικού

Στην προηγούμενη περίπτωση της αναβάθμισης, κατεβάσαμε τον πηγαίο κώδικα με τον κατάλογο «debian» ενσωματωμένο από το Launchpad. Εδώ, δεν έχουμε έτοιμο πακέτο για να δουλέψουμε πάνω σε αυτό, οπότε πρέπει να κατεβάσουμε τον πηγαίο κώδικα από την ιστοσελίδα του upstream.

Ανοίγουμε το τερματικό μας, πηγαίνουμε στον φάκελο στον οποίο δουλεύουμε (όπως και στην προηγούμενη περίπτωση) και κατεβάζουμε τον πηγαίο κώδικα:

wget ΣΥΝΔΕΣΜΟΣ_TARBALL

Και στη συνέχεια, το αποσυμπιέζουμε:

tar [options] TARBALL

Και μετά την αποσυμπίεση θα έχουμε στον φάκελο όπου δουλεύουμε:

  1. Το tarball «ΛΟΓΙΣΜΙΚΟ-ΕΚΔΟΣΗ(Upstream).tar» το οποίο κατεβάσαμε.
  2. Τον φάκελο «ΛΟΓΙΣΜΙΚΟ-ΕΚΔΟΣΗ(Upstream)» τον οποίο αποσυμπιέσαμε από το tarball.

• Βήμα 2: Μεταγλώττιση πηγαίου κώδικα

Προτού προχωρήσουμε με την δημιουργία του πακέτου, θα πρέπει να εγκαταστήσουμε το λογισμικό στο σύστημά μας προκειμένου να δούμε αν γίνεται σωστά. Ο μόνος τρόπος να γίνει κάτι τέτοιο είναι η μεταγλώττιση (compiling) του πηγαίου κώδικα. Αυτό γίνεται ως εξής:

cd ΛΟΓΙΣΜΙΚΟ-ΕΚΔΟΣΗ(Upstream)
./configure
make
sudo make install

Εδώ, είναι σημαντικό να καταγράψουμε προσεκτικά τυχόντα λάθη τα οποία αφορούν ελλείψεις πακέτων απαραιτήτων για την σωστή λειτουργία του λογισμικού. Αυτά τα πακέτα θα είναι οι εξαρτήσεις του λογισμικού που λείπουν από το σύστημά μας. Οπότε, για το ενδεχόμενο εμφάνισης τέτοιων σφαλμάτων, σταματάμε την διαδικασία και εγκαθιστούμε το πακέτο που λείπει (με τον γνωστό τρόπο με το apt-get) και ξεκινάμε εκ νέου την διαδικασία της μεταγλώττισης. Επαναλαμβάνουμε έως ότου δεν υπάρχουν πλέον πακέτα που λείπουν.

• Βήμα 3: Έλεγχος λειτουργίας

Αφού, όπως φαίνεται, η εγκατάσταση ολοκληρώθηκε χωρίς σφάλματα, πρέπει να ελέγξουμε αν το λογισμικό λειτουργεί σωστά. Οπότε το τρέχουμε:

εντολή-εκτέλεσης

Και αφού διαπιστώσουμε πως λειτουργεί σωστά, είμαστε έτοιμοι να συνεχίσουμε.

• Βήμα 4: Δημιουργία του καταλόγου «debian»

Αυτό που διαφέρει στον πηγαίο κώδικα ενός καταλόγου upstream λογισμικού, από αυτόν ενός λογισμικού για Ubuntu είναι η ύπαρξη του καταλόγου «debian». Αυτός ο κατάλογος ουσιαστικά καθορίζει την εγκατάσταση και την λειτουργία του λογισμικού στο Ubuntu. Στην προηγούμενη περίπτωση της αναβάθμισης από παλαιότερο πακέτο, ουσιαστικά πήραμε τον κατάλογο «debian» έτοιμο από την παλιά, και τον μεταφέραμε στην νέα έκδοση. Εδώ, αφού ξεκινάμε από το μηδέν, δεν έχουμε κάτι έτοιμο, οπότε πρέπει να δημιουργήσουμε μόνοι μας τον κατάλογο «debian».

Αρχικά, όμως, θα πρέπει να μετονομάσουμε το tarball με τον πηγαίο κώδικα, ώστε αυτός να ακολουθεί το μοτίβο των κανονισμών του Debian (και Ubuntu) packaging. Στο τερματικό, αφού μεταβούμε ξανά στον αρχικό μας φάκελο, εκτελούμε:

cd .. && mv ΛΟΓΙΣΜΙΚΟ-ΕΚΔΟΣΗ(Upstream).tar ΛΟΓΙΣΜΙΚΟ_ΕΚΔΟΣΗ(Upstream).orig.tar 

Η διαφορά είναι πως αντί για παύλα, το όνομα του λογισμικού από την έκδοση χωρίζεται με underscore, καθώς και η προσθήκη του «orig».

Τώρα μπορούμε να δημιουργήσουμε τον κατάλογο «debian», εκτελώντας:

bzr dh-make ΛΟΓΙΣΜΙΚΟ ΕΚΔΟΣΗ ΛΟΓΙΣΜΙΚΟ_ΕΚΔΟΣΗ(Upstream).orig.tar

Δηλαδή, ορίζουμε το όνομα του λογισμικού, την έκδοσή του με είσοδο από το αρχείο tarball. Εκτελώντας, λοιπόν, την παραπάνω εντολή, θα κληθούμε να απαντήσουμε για τον τύπο του πακέτου που χρησιμοποιούμε:

Please respond with one of the following: s,i,l,p
Type of package: (single, indep, library, python)
[s/i/l/p]?

Επιλέγουμε τον τύπο του πακέτου πατώντας το αντίστοιχο πλήκτρο (στο παράδειγμά μας, είναι «s»). Και στη συνέχεια, θα κληθούμε να επιβεβαιώσουμε άλλα στοιχεία:

Email-Address : ΤΟ E-MAIL ΜΑΣ
License : blank
Package Name :ΟΝΟΜΑ ΠΑΚΕΤΟΥ
Maintainer Name : ΟΝΟΜΑ ΕΠΙΘΕΤΟ
Version : ΑΡΙΘΜΟΣ ΕΚΔΟΣΗΣ
Package Type : ΤΥΠΟΣ
Date : ΗΜΕΡΟΜΗΝΙΑ
Are the details correct? [Y/n/q]

Τα προσωπικά μας στοιχεία θα έχουν εισαχθεί αυτόματα λόγω των παραμέτρων που προσθέσαμε στο .bashrc σε προηγούμενη ενότητα, στην προετοιμασία. Επίσης, το όνομα του πακέτου και η έκδοσή του έχουν εισαχθεί αυτόματα, το ίδιο και η ημερομηνία. Η άδεια (σημαντική μη-λεπτομέρεια) δεν έχει μπει αυτόματα. Παρόλα αυτά, εμείς πατάμε το πλήκτρο «Y» για να επιβεβαιώσουμε τις πληροφορίες και θα κάνουμε όποιες αλλαγές είναι απαραίτητες αργότερα. Έτσι, ολοκληρώνεται η δημιουργία του καταλόγου «debian» στο λογισμικό, σε έναν νέο φάκελο που δημιουργήθηκε:

  1. Ο φάκελος «ΟΝΟΜΑ_ΛΟΓΙΣΜΙΚΟΥ».

• Βήμα 5: Ρύθμιση αρχείων του καταλόγου «debian»

Ο κατάλογος «debian» δημιουργήθηκε. Όμως, τα αρχεία που περιέχει περιέχουν απλά ένα template που επεξηγεί πως θα είναι η μορφή τους. Πρέπει να τα ρυθμίσουμε σωστά. Αυτό είναι και το βήμα που απαιτεί την μεγαλύτερη προσοχή και μπορεί να γίνει αρκετά περίπλοκο, αναλόγως το λογισμικό και τις ανάγκες του. Τα αρχεία που θα πρέπει να επεξεργαστούμε, προκειμένου να λειτουργήσει σωστά το πακέτο που θα παραχθεί από το λογισμικό, είναι τα εξής:

  • debian/changelog
  • debian/compat
  • debian/control
  • debian/copyright
  • debian/ΛΟΓΙΣΜΙΚΟ-docs.docs
  • debian/rules
  • debian/watch
  • debian/source/format

Ας συμμαζέψουμε, αρχικά, τον κατάλογο «debian»:

  1. Θα μεταβούμε στον κατάλογο «debian», ώστε αρχικά, να συμμαζέψουμε λίγο τον φάκελο:
    cd ΟΝΟΜΑ_ΛΟΓΙΣΜΙΚΟΥ/debian
  2. Διαγράφουμε όλα τα αρχεία με κατάληξη «.ex» και «.EX» και τα αρχεία «outfile» και «README»:
    rm -r *.ex *.EX outfile README*
  3. Από την λίστα των αρχείων παραπάνω, λείπουν τα δύο τελευταία. Τα δημιουργούμε:
    touch watch source/format
  4. Μετονομάζουμε το αρχείο «ΛΟΓΙΣΜΙΚΟ-docs.docs» σε «ΛΟΓΙΣΜΙΚΟ.docs»:
    mv ΛΟΓΙΣΜΙΚΟ-docs.docs ΛΟΓΙΣΜΙΚΟ.docs

debian1

Τώρα, ήρθε η στιγμή που θα πρέπει να επεξεργαστούμε κάποια αρχεία.

Το αρχείο «debian/watch» πρέπει να περιέχει τον σύνδεσμο του λογισμικού upstream, ώστε να ανιχνεύεται από την εντολή «uscan» σε μελλοντική αναβάθμιση του πακέτου. Ο σύνδεσμος πρέπει να έχει τη μορφή:

http://ΙΣΤΟΤΟΠΟΣ/ΛΟΓΙΣΜΙΚΟ/TARBALL-(.*).tar.

Τοποθετούμε τον σύνδεσμο κατάλληλα:

version=3

http://ΙΣΤΟΤΟΠΟΣ/ΛΟΓΙΣΜΙΚΟ/ΛΟΓΙΣΜΙΚΟ-(.*).tar.gz

Ο σύνδεσμος πρέπει να γραφτεί προσεκτικά ώστε να λειτουργεί σωστά η εντολή «uscan».

Το αρχείο «debian/copyright» πρέπει να περιέχει λεπτομέρειες για την άδεια του λογισμικού. Αυτό το αρχείο θα έχει τη μορφή:

Name: ΟΝΟΜΑ ΠΑΚΕΤΟΥ
Maintainer: ΟΝΟΜΑ ΕΠΙΘΕΤΟ <E-MAIL>
Source: ΙΣΤΟΤΟΠΟΣ ΚΩΔΙΚΑ

Files: *
Copyright: ΙΔΙΟΚΤΗΤΗΣ
License: ΑΔΕΙΑ

License: ΑΔΕΙΑ
ΑΔΕΙΑ ΠΕΡΙΓΡΑΦΗ ΑΔΕΙΑΣ.

Η άδεια μπορεί να βρεθεί στον κατάλογο του λογισμικού (τον πατρικό του «debian») στο αρχείο «COPYING» (το εκάστοτε λογισμικό μπορεί να έχει άλλο όνομα σχετικό με άδεια).

Το αρχείο «debian/control» μας είναι ήδη οικείο από την προηγούμενη περίπτωση. Περιέχει τις πληροφορίες του πακέτου καθώς και την λίστα των εξαρτήσεων:

Source: ΟΝΟΜΑ ΠΑΚΕΤΟΥ
Section: ΚΑΤΗΓΟΡΙΑ
Priority: ΠΡΟΤΕΡΑΙΟΤΗΤΑ
Maintainer: ΟΝΟΜΑ ΕΠΙΘΕΤΟ <E-MAIL>
XSBC-Original-Maintainer: ΑΡΧΙΚΟΣ ΣΥΓΓΡΑΦΕΑΣ <ΤΟ E-MAIL ΤΟΥ>
Build-Depends: ΛΙΣΤΑ ΕΞΑΡΤΗΣΕΩΝ
Standards-Version: 3.9.6
Homepage: <ΙΣΤΟΣΕΛΙΔΑ UPSTREAM>
Vcs-Git: GIT
Vcs-Browser: ΣΥΝΔΕΣΜΟΣ GIT

nPackage: ΟΝΟΜΑ ΠΑΚΕΤΟΥ
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: <ΜΙΚΡΗ ΠΕΡΙΓΡΑΦΗ>
<ΜΕΓΑΛΗ ΠΕΡΙΓΡΑΦΗ>

Σε αυτό το αρχείο, το ΟΝΟΜΑ ΠΑΚΕΤΟΥ είναι το όνομα του λογισμικού. Η κατηγορία είναι μία από αυτές, αναλόγως σε ποια ταιριάζει περισσότερο το λογισμικό. Οι σύνδεσμοι που πρέπει να τοποθετηθούν στο αρχείο αναγράφονται στο αρχείο «README» του πηγαίου κώδικα. Η προτεραιότητα είναι συνήθως «optional», αλλά δεν θα επεκταθούμε σε αυτό, προς το παρόν. Μπορούμε να βρούμε τον αρχικό συγγραφέα του λογισμικού στο αρχείο «AUTHORS» του πηγαίου κώδικα. Η λίστα των εξαρτήσεων αναγράφεται στο αρχείο «configure.ac» του πηγαίου κώδικα. Οπότε, βάσει αυτών, επεξεργαζόμαστε το περιεχόμενο του αρχείου «debian/control».

Το αρχείο «debian/source/format» πρέπει να έχει συγκεκριμένο περιεχόμενο, αναλόγως αν το λογισμικό έχει φτιαχτεί αποκλειστικά για το Debian ή είναι κάποιο λογισμικό upstream γενικότερα. Επειδή η συντριπτική πλειοψηφία των λογισμικών εμπίπτουν στην δεύτερη περίπτωση, το περιεχόμενο του αρχείο πρέπει να είναι το εξής:

3.0 (quilt)

Η άλλη περίπτωση είναι να είναι «native», αποκλειστικά για το Debian. Περίπτωση σχετικά σπάνια, αλλά ούτως ή άλλως, δεν επηρεάζει ιδιαίτερα την διαδικασία του packaging.

Το αρχείο «ΛΟΓΙΣΜΙΚΟ.docs» θα έχει το εξής περιεχόμενο (που παραπέμπει σε αρχεία του πηγαίου κώδικα upstream):

AUTHORS
NEWS
README

Πρόκειται για διάφορες χρήσιμες πληροφορίες που περιέχουν αρχεία στον πηγαίο κώδικα, που αφορούν το λογισμικό. Αφού τροποποιήσουμε τα αρχεία κατάλληλα, τα αποθηκεύουμε. Αυτό είναι και το κλειδί στην δημιουργία πακέτου από το μηδέν, η σωστή δομή και το περιεχόμενο των αρχείων του καταλόγου «debian».

Παρατήτηση: Σε αυτό το παράδειγμα, δεν χρειάστηκε να επεξεργαστούμε το αρχείο «debian/rules», περίπτωση που σχεδόν ποτέ δεν ισχύει. Στην δημιουργία ενός πακέτου, αυτό το αρχείο θα μας απασχολήσει ιδιαιτέρως. Όμως, δεν θα γίνει αναφορά στην λειτουργία του στο παρόν άρθρο.

• Βήμα 6: Καταγραφή αλλαγών

Δεν πρέπει να ξεχάσουμε να ενημερώσουμε το αρχείο «debian/changelog», το οποίο είδαμε στην προηγούμενη ενότητα σχετικά με την αναβάθμιση των πακέτων. Πλέον, βρισκόμαστε στο σημείο όπου από εδώ και μπρος, τα βήματα που θα κάνουμε είναι ίδια με αυτά της προηγούμενης περίπτωσης.

Εκτελούμε:

cd .. && dch -r

Προσθέτουμε ένα tag στην έκδοση, αλλάζουμε την κωδική ονομασία της διανομής σε αυτή που αντιστοιχεί στην έκδοση του Ubuntu για την οποία φτιάχνουμε το πακέτο, διότι θα έχει κάποια ονομασία από έκδοση του Debian και τέλος, αποθηκεύουμε το αρχείο ως «changelog».

• Βήμα 7: Χτίσιμο πακέτου

Ξανά, συνεχίζουμε ακριβώς όπως και στην περίπτωση της αναβάθμισης. Βρισκόμαστε στον φάκελο του λογισμικού. Προκειμένου να χτίσουμε το πακέτο έτσι όπως το διαμορφώσαμε, απλά εκτελούμε στο τερματικό:

debuild -S

Και το πρόγραμμα θα ξεκινήσει και θα ολοκληρώσει την διαδικασία. Αν δεν έχουμε παραλείψει κάτι και έγιναν όλα σωστά, μετά από μερικά δευτερόλεπτα θα δούμε αυτό:

Successfully signed dsc and change filesdebuild -S

Ίσως μας ζητηθεί να πληκτρολογήσουμε και τον κωδικό του κλειδιού GPG που έχουμε δημιουργήσει προηγουμένως.

Αφού ολοκληρωθεί το χτίσιμο του πακέτου, πίσω στον αρχικό μας φάκελο (αυτόν που έχουμε δημιουργήσει για να δουλεύουμε) θα έχουν δημιουργηθεί τα εξής αρχεία:

  1. Tο tarball «ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag.debian.tar», το οποίο περιέχει την νεότερη έκδοση του λογισμικού, μαζί με τον κατάλογο «debian» ενημερωμένο, δηλαδή, με όλες τις αλλαγές που εφαρμόσαμε στα προηγούμενα βήματα.
  2. Η εικόνα «ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag.dsc», δηλαδή η εικόνα του νέου πακέτου για το Ubuntu από το παραπάνω tarball πάνω στην οποία θα γίνει έλεγχος.
  3. Το αρχείο «ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag_source.build».
  4. Το αρχείο «ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag_source.changes».

• Βήμα 8: Έλεγχος πακέτου

Το πακέτο μας έχει δημιουργηθεί, όπως και στην περίπτωση της αναβάθμισης, απομένει ο έλεγχος.

Αφού επιστρέψουμε στον αρχικό μας φάκελο:

cd ..

Eκτελούμε στο τερματικό:

sbuild --dist=xenial --arch=amd64 -A -c xenial-amd64 ΟΝΟΜΑ_ΠΑΚΕΤΟΥ_ΕΚΔΟΣΗ~tag.dsc

Παρατήρηση: Όπως και προηγουμένως, στην ενότητα για την κατάλληλη ρύθμιση του sbuild χρειάστηκε προσοχή στο όνομα που θα δώσουμε στο περιβάλλον ελέγχου καθώς και στον ορισμό της έκδοσης του Ubuntu για την οποία δημιουργούμε το πακέτο. Βλέπουμε πως η ονομασία του περιβάλλοντος και η κωδική ονομασία της έκδοσης χρησιμοποιούνται στην παραπάνω εντολή. Αναλόγως, λοιπόν, τις ονομασίες που ορίσαμε τότε και την διανομή για την οποία πακετάρουμε το λογισμικό, κάνουμε τις κατάλληλες αλλαγές στην εντολή παραπάνω.

Επεξήγηση: Η διαδικασία που εφαρμόζεται με την εκτέλεση της παραπάνω εντολής, δεν είναι άλλη από την δημιουργία και την ενημέρωση ενός συστήματος Ubuntu (αυτή άλλωστε είναι η δουλειά του sbuild), στην default κατάστασή του, προκειμένου να εκτελεστεί εκεί η προσπάθεια εγκατάστασης του πακέτου που δημιουργήσαμε και να γίνει ένας εκτεταμένος έλεγχος για την σωστή πρόοδο της διαδικασίας. Η διαδικασία αυτή θα αργήσει, σχετικά, να ολοκληρωθεί. Οπότε, περιμένουμε.

Αφού ολοκληρωθεί η διαδικασία, στο τέλος θα δούμε μία περίληψη (Summary) του ελέγχου που πραγματοποιήθηκε με την εκτέλεση της τελευταίας εντολής. Στο summary, λοιπόν, θα υπάρχει η γραμμή όπου θα αναγράφεται το αποτέλεσμα του ελέγχου (Status), το οποίο θα είναι είτε «Successful» εφόσον ο έλεγχος ολοκληρώθηκε επιτυχώς, είτε «Failed» αν υπήρξαν σφάλματα.

Αν ο έλεγχος ολοκληρωθεί με επιτυχία, στον αρχικό μας φάκελο θα έχουμε επιπλέον τα εξής αρχεία:

  1. ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag_amd64.build
  2. ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag_amd64.changes
  3. ΟΝΟΜΑΠΑΚΕΤΟΥΕΚΔΟΣΗ~tag_amd64.deb
  4. ΟΝΟΜΑΠΑΚΕΤΟΥ-dbgsymΕΚΔΟΣΗ~tag_amd64.ddeb

Και σε αυτή την περίπτωση, το πείραμα φαίνεται να ολοκληρώθηκε επιτυχώς. Ας κάνουμε μία επαλήθευση.

run

Δημιουργία αποθετηρίου για τη φιλοξενία πακέτων

Η όλη φιλοσοφία του Ελεύθερου Λογισμικού βασίζεται στον διαμοιρασμό της γνώσης, στη διαφάνεια, στην συνεργασία και σε πολλά άλλα ιδανικά που κάνουν πολλούς χρήστες να το προτιμήσουν. Οπότε, γιατί να έχω μόνο εγώ το νέο πακέτο που έφτιαξα και όχι άλλοι χρήστες; Ας δούμε πως μπορούμε να το μοιραστούμε με τον κόσμο.

Δημιουργία PPA στο Launchpad

Αν και γίνεται με διάφορους τρόπους, το Launchpad είναι η καλύτερη επιλογή για την διατήρηση προσωπικού αποθετηρίου, εφόσον τα πακέτα τα οποία θα φιλοξενούνται σε αυτό αφορούν το Ubuntu. Για να δημιουργήσουμε αποθετήριο στο Launchpad:

  1. Πηγαίνουμε στον σύνδεσμο με το προφίλ μας και πατάμε «Create a new PPA».
  2. Πληκτρολογούμε στα αντίστοιχα πεδία το URL του αποθετηρίου, το όνομά του και την περιγραφή του (η οποία θα φαίνεται όταν κάποιος το προσθέτει στις πηγές λογισμικού από το τερματικό του) και πατάμε το κουμπί «Activate».

Αμέσως μετά, αυτόματα, θα μεταβούμε στον σύνδεσμο του αποθετηρίου όπου θα δούμε το όνομα και την περιγραφή που ορίσαμε πριν (πράγματα που μπορούν να αλλάξουν), καθώς και μία σύντομη οδηγία για το πως να ανεβάσουμε πακέτα στο αποθετήριο.

Πληροφοριακά, υπάρχει η επιλογή να ορίσουμε άλλο (υπάρχον, δικό μας ή μη) PPA ως εξάρτηση του δικού μας PPA. Ο λόγος που ίσως να θέλαμε να κάνουμε κάτι τέτοιο είναι η απουσία εξαρτήσεων από τα αποθετήρια του Ubuntu, ενός πακέτου που ανεβάζουμε στο PPA μας, αλλά η ύπαρξη αυτών των εξαρτήσεων σε κάποιο άλλο αποθετήριο. Οπότε, χρησιμοποιούμε αυτή την επιλογή ώστε να λαμβάνονται η εξαρτήσεις από εκεί, αντί να τις δημιουργούμε από την αρχή.

Ανέβασμα πακέτου σε αποθετήριο

Το uploading ενός πακέτου σε αποθετήριο είναι απλή υπόθεση, εφόσον το έχουμε χτίσει σύμφωνα με τις οδηγίες παραπάνω. Όπως είδαμε, στην αναβάθμιση αλλά και στην δημιουργία ενός πακέτου από το μηδέν, μετά την εκτέλεση της εντολής «debuild -S», μεταξύ άλλων, δημιουργείται και ένα αρχείο «ΠΑΚΕΤΟ_source.changes», το οποίο θα χρειαστεί για το ανέβασμα του πακέτου στο αποθετήριο που δημιουργήσαμε στο Launchad.

Πηγαίνουμε στον φάκελο όπου βρίσκεται αυτό το αρχείο (είπαμε πως έχουμε έναν φάκελο που δουλεύουμε μέσα σε αυτόν) και εκτελούμε την εντολή:

dput ppa:<lp username>/<ppa url> ΠΑΚΕΤΟ_source.changes

Εφόσον όλα έχουν πάει καλά, θα δούμε στο αποτέλεσμα της εντολής πως τα πακέτα στάλθηκαν με επιτυχία στο Launchpad. Στα επόμενα λεπτά, θα λάβουμε ένα e-mail από το Launchpad που θα μας ενημερώνει πως το πακέτο που στείλαμε είτε απορρίφθηκε για κάποιο λόγο, είτε έγινε δεκτό. Αν έχουμε ακολουθήσει σωστά τη διαδικασία του packaging, θα πρέπει να γίνει δεκτό.

Αφού γίνει δεκτό το πακέτο, θα αρχίσει να χτίζεται το πακέτο στο Launchpad και μόλις ολοκληρωθεί, θα είναι διαθέσιμο στο αποθετήριο μας! Εδώ είναι τα πειραματόζωα για τις ανάγκες του οδηγού.

Λειτουργεί;

Ναι!

Σχόλια

Για να γίνει κάποιος packager, από κάπου πρέπει να ξεκινήσει. Επειδή ότι σχετικό documentation υπάρχει σχετικά με το πακετάρισμα είναι στα Αγγλικά και προϋποθέτει προχωρημένες γνώσεις από τον αναγνώστη προκειμένου να κατανοήσει τις οδηγίες, θεώρησα πως θα είχε χρησιμότητα ένας σχετικός οδηγός που απευθύνεται σε όλους τους χρήστες όλων των επιπέδων γνώσης στο Linux.

Ο οδηγός είναι μακροσκελής. Αλλά περιέχει ούτε περισσότερα, ούτε λιγότερα από αυτά που χρειάζεται να γνωρίζει κάποιος για να κάνει τα πρώτα του βήματα στο Ubuntu packaging. Πολλές λεπτομέρειες, σημαντικές και μη, έχουν παραληφθεί για να αποφευχθεί επιπλέον περιπλοκότητα και άλλες εκτενείς επεξηγήσεις.

Για να γίνει κάποιος έμπειρος packager, πρέπει να γνωρίζει πολλές διαδικασίες που εδώ παραλήφθηκαν. Διαδικασίες όπως:

  • Διορθώσεις σφαλμάτων στη μεταγλώττιση λογισμικού.
  • Επεξεργασία και σωστή διαχείριση patches με την χρήση του quilt.
  • Σωστή δόμηση του καταλόγου «debian» και τον αρχείων του, ιδιαιτέρως του «rules» το οποίο είναι μία κατηγορία από μόνο του.
  • Ανάγνωση των logs και κατανόηση των σφαλμάτων προκειμένου να διορθωθούν. Δημιουργία extra αρχείων για τις ανάγκες του λογισμικού.
  • Γνώση λειτουργίας πακέτων ώστε να γνωρίζει με ποια σειρά να χτίσει πακέτα ώστε να αποφύγει αλυσίδες αναβαθμίσεων των εξαρτήσεων.
  • Πολλά άλλα.

Για να ξεκινήσει κανείς με τα βασικά και να εμβαθύνει σε πιο προχωρημένες γνώσεις, φαίνεται χρονοβόρο, αλλά, κάπως έτσι δεν ξεκινήσαμε όλοι και με το Linux;

Ο παραπάνω οδηγός είναι διαθέσιμος και σε μορφή βιβλίου:

Ο οδηγός στο GitBook

 

13 thoughts on “Εισαγωγή στο Ubuntu Pagkaging

    • Μακάρι με τον καιρό να μας πουν και άλλοι χρήστες τις εμπειρίες τους στο packaging, ώστε να μαθαίνουμε περισσότερα!

  1. Νταξ έχω πάθει πλάκα!!!
    Τι οδηγός είναι αυτός;;;
    Και gitbook;;; Shut up and take my money!!!
    Τα συγχαρητήρια μου στον αρθρογράφο!!!

  2. Καταρχήν πρώτα μα πρώτα από όλα σου χρωστάμε ένα ΤΕΡΆΣΤΙΟ –> ΕΥΧΑΡΙΣΤΏ <– για τον σπουδαίο αυτό οδηγό! Είσαι καταπληκτικός!! Δεν υπάρχουν λόγια για τον πραγματικά μοναδικό αυτό οδηγό στα Ελληνικά!!

    Αν θέλεις, θέλω να σου προτείνω το εξής : Όλα όσα έχεις γράψει είναι πάρα μα πάρα πολύ καλά!
    Αλλά κάνε το και λίγο ακόμη πιο εύκολο. Τι εννοώ ; Να προσθέσεις αν μπορείς σε παρακαλώ πολύ, και την διαδικασία δημιουργίας .deb αρχείου ( πακεταρίσματος ), ενός απλού, μα πάρα πολύ απλού προγράμματος αρχείου.
    Θα μπορούσες κιόλας να το έκανες και για ένα απλό πρόγραμμα σε C και ένα άλλο εξίσου απλό σε python. Όταν λέω απλό, εννοώ κάτι και σαν αυτό : http://pastebin.com/SMDkgVUD

    Ναι τόσο γελοία απλό.. πως αυτό, ένα τόσο απλό πρόγραμμα μας, θα μπορέσουμε να το πακετάρουμε και να το διανέμουμε μέσω του launchpad και να το ενημερώνουμε σε όλους τους χρήστες ubuntu που το έχουν προσθέσει στο σύστημα τους;
    ( και ας λέει στο επόμενο update απλά "hello world!" αντί για το προηγούμενο μήνυμα😛 ).

    Δε ξέρω αν με καταλαβαίνεις, αλλά σίγουρα με όλα αυτά που έχεις πει, ήδη λες και εξηγείς πάρα πολλά πράγματα πολύ ωραία και καταλαβαίνομε πολλά.. να είσαι καλά!
    Αλλά μπορείς να μας δείξεις πως μπορούμε να το κάνουμε ακόμη πιο απλά; Πως μπορούμε ακόμη και τα μικρά και χαζά μας προγράμματα να τα πακετάρουμε ;
    Νομίζω πως αυτό θα είναι το πιο απλό πακετάρισμα μας, το οποίο θα μας δώσει όρεξη να ασχοληθούμε και ακόμη περισσότερο..

    Προσωπικά πιστεύω πως αν προσθέσεις και αυτό που σου προτείνω.. την τόσο απλή διαδικασία πακεταρίσματος, ενός *πολύ* απλού δικού μας προγράμματος, ο καθένας αμέσως θα τρέξει να το κάνει για το πρόγραμμα του.. ε μετά θα πάρουμε φωτιά.. σε συνδυασμό με όσα μας έχεις γράψει από πάνω.
    Θα μπορούσε αυτό να ήταν το πρώτο πολύ απλό πακετάρισμα… ( κατά βαθμίδα δυσκολίας ), διότι εγώ αυτό π.χ. θέλω να προσπαθήσω τώρα και κάπως μπερδεύομαι, διότι δε μας έχεις ένα τόσο απλό παράδειγμα..

    Τέλος μονάχα να σε ευχαριστήσω έχω.. και αυτό που σου προτείνω είναι μια εντελώς φιλική και φανατική μη σου πω, προτροπή για να γίνει ακόμη πιο ενδιαφέρον και δυνατός ο οδηγός σου!
    Σε ευχαριστώ πάρα πολύ!

  3. Σε ευχαριστώ πολύ για τα καλά σου λόγια και ιδιαιτέρως για τις προτάσεις (τις οποίες εκτιμώ και χαίρομαι όταν γίνονται, γιατί μόνο βελτίωση μπορούν να φέρουν)! Έχεις δίκαιο, ακόμα και ένα απλό πρόγραμμα σε C, ή ακόμη και ένα script της μίας γραμμής $ echo ‘Hello, World!’ σε bash μπορεί να πακεταριστεί σε αρχείο .deb. Με την πρώτη ευκαιρία θα το προσθέσω στον οδηγό.

  4. Και εγώ εκτιμώ και χαίρομαι πρώτα από όλα που σε γνωρίζω εν μέρη σαν προσωπικότητα χάρης όλου αυτού του πολύ ωραίου site που έχεις στίσει. Μου αρέσουν τα άτομα σαν και του λόγου σου.

    Είμαι ιδιαίτερα χαρούμενος και σε ευχαριστώ πάρα πολύ που πρώτα από όλα, έλαβες υπόψιν σου την πρόταση μου, και ακόμη πιο χαρούμενος που θα την υλοποιήσεις, θα περιμένω πως και πως!!😀
    Και είμαι σίγουρος πως έπειτα ο οδηγός αυτός θα εκτοξευθεί στα ύψη!

    Σε ευχαριστώ και πάλι, *πάρα* πολύ!!

    • Μία διευκρίνιση μόνο. Το εν λόγω site δημιουργήθηκε και συντηρείται από τον Salih Emin. Εγώ απλά όταν υπάρξει κάτι ενδιαφέρον κατά τη γνώμη μου, απλά γράφω αρθράκι εδώ.

Απορίες, παρατηρήσεις, ιδέες... Ελεύθερα ! Πες την άποψή σου... έστω και Ανώνυμα:

Εισάγετε τα παρακάτω στοιχεία ή επιλέξτε ένα εικονίδιο για να συνδεθείτε:

Λογότυπο WordPress.com

Σχολιάζετε χρησιμοποιώντας τον λογαριασμό WordPress.com. Αποσύνδεση / Αλλαγή )

Φωτογραφία Twitter

Σχολιάζετε χρησιμοποιώντας τον λογαριασμό Twitter. Αποσύνδεση / Αλλαγή )

Φωτογραφία Facebook

Σχολιάζετε χρησιμοποιώντας τον λογαριασμό Facebook. Αποσύνδεση / Αλλαγή )

Φωτογραφία Google+

Σχολιάζετε χρησιμοποιώντας τον λογαριασμό Google+. Αποσύνδεση / Αλλαγή )

Σύνδεση με %s