Rust Std::OS σε Linux

Rust Std Os Se Linux



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

Σε αυτό το παράδειγμα, θα καλύψουμε ορισμένες θεμελιώδεις λειτουργίες που μπορείτε να εκτελέσετε στο Unix χρησιμοποιώντας τη λειτουργική μονάδα Rust std::os.







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



Rust OS σε Linux

Στο Linux, μπορούμε να έχουμε πρόσβαση στις ειδικές λειτουργίες και τους τύπους Unix που παρέχονται από τη μονάδα std::os::unix, μια υπομονάδα της μονάδας std::os στο Rust.



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





Ας καλύψουμε μερικά βασικά API και λειτουργίες που μπορούμε να πραγματοποιήσουμε σε ένα σύστημα Linux από αυτήν την ενότητα.

Πρόσβαση στις μεταβλητές περιβάλλοντος

Μπορούμε να έχουμε πρόσβαση στις μεταβλητές περιβάλλοντος χρησιμοποιώντας την ενότητα std::env. Για παράδειγμα, το std::env::var('PATH') ανακτά την τιμή της μεταβλητής περιβάλλοντος PATH.



Εξετάστε το ακόλουθο παράδειγμα προγράμματος:

χρήση std::env;
χρήση std::ffi::OsString;

fn χέρι ( ) {
// Πρόσβαση σε μια συγκεκριμένη μεταβλητή περιβάλλοντος
αν αφήνω Εντάξει ( αξία ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , αξία ) ;
}

// Επανάληψη σε όλες τις μεταβλητές περιβάλλοντος
Για ( κλειδί, τιμή ) σε env::wars_us ( ) {
αφήνω key_string = κλειδί.to_string_lossy ( ) ;
αφήνω value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , συμβολοσειρά_κλειδιού, συμβολοσειρά_τιμής ) ;
}

// Πρόσβαση σε μια συγκεκριμένη μεταβλητή περιβάλλοντος όπως και ένα ` OsString `
αν αφήνω Μερικοί ( αξία ) = env::var_us ( 'HOSTTYPE' ) {
// Μετατρέπω ` OsString ` σε α ` Σειρά ` αν απαιτείται
αν αφήνω Μερικοί ( value_str ) = value.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}


Στο συγκεκριμένο παράδειγμα, ξεκινάμε εισάγοντας τις απαραίτητες ενότητες. Σε αυτήν την περίπτωση, μας ενδιαφέρει το std::env και το std::ff::OsString.

Για να αποκτήσουμε πρόσβαση σε μια συγκεκριμένη μεταβλητή περιβάλλοντος, μπορούμε να χρησιμοποιήσουμε τη συνάρτηση env::var και να δώσουμε το όνομα της τιμής που θέλουμε να ανακτήσουμε. Σε αυτήν την περίπτωση, παίρνουμε την τιμή της μεταβλητής WAYLAND_DISPLAY.

Η συνάρτηση επιστρέφει την τιμή της μεταβλητής ως τύπο αποτελέσματος.

Μπορούμε επίσης να επαναλάβουμε όλες τις μεταβλητές περιβάλλοντος χρησιμοποιώντας τη συνάρτηση env::vars_os. Αυτό επιστρέφει έναν επαναλήπτη με τα ζεύγη κλειδιού-τιμής των μεταβλητών περιβάλλοντος. Είναι καλό να σημειωθεί ότι οι τιμές επιστρέφονται ως τύπος OsString. Στη συνέχεια, μπορούμε να τις μετατρέψουμε σε τιμές συμβολοσειράς χρησιμοποιώντας τη συνάρτηση to_string_lossy.

Μπορούμε επίσης να έχουμε πρόσβαση στις συγκεκριμένες μεταβλητές περιβάλλοντος χρησιμοποιώντας τη συνάρτηση env::var_os. Αυτό θα πρέπει να επιστρέψει έναν τύπο τον οποίο μπορούμε να μετατρέψουμε σε συμβολοσειρά χρησιμοποιώντας τη συνάρτηση to_str().

Η έξοδος που προκύπτει είναι η εξής:

WAYLAND_DISPLAY =wayland- 0
HOSTTYPE =x86_64

Λειτουργίες FS με χρήση της μονάδας λειτουργικού συστήματος

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

Πάρτε το ακόλουθο πρόγραμμα που δείχνει τις διάφορες λειτουργίες που μπορούμε να εκτελέσουμε χρησιμοποιώντας την ενότητα std::os στο Linux:

χρήση std::fs;

fn χέρι ( ) {
// Διάβασε ένα αρχείο
αν αφήνω Εντάξει ( περιεχόμενα ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , περιεχόμενα ) ;
}

// Δημιουργήστε έναν νέο κατάλογο
αν αφήνω Πλανώμαι ( πλανώμαι ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Αποτυχία δημιουργίας καταλόγου: {}' , λάθος ) ;
}

// Αφαιρέστε α αρχείο
αν αφήνω Πλανώμαι ( πλανώμαι ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Απέτυχε η αφαίρεση του αρχείου: {}' , λάθος ) ;
}
}


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

Μπορούμε επίσης να δημιουργήσουμε έναν νέο κατάλογο χρησιμοποιώντας τη συνάρτηση fs::create_dir() και περνώντας ως παράμετρο τη διαδρομή προς τον κατάλογο προορισμού.

Τέλος, μπορούμε να αφαιρέσουμε ένα συγκεκριμένο αρχείο χρησιμοποιώντας τη συνάρτηση fs::remove_file() και να περάσουμε το αρχείο προορισμού ως παράμετρο.

ΣΗΜΕΙΩΣΗ: Τα παραδείγματα που παρέχονται είναι μερικά βασικά παραδείγματα για τον τρόπο εκτέλεσης των λειτουργιών του συστήματος αρχείων στο Linux χρησιμοποιώντας τη λειτουργική μονάδα std::fs. Το Rust παρέχει μια ολοκληρωμένη συλλογή μεθόδων και λειτουργιών που παρουσιάζονται εδώ. Ανατρέξτε στην τεκμηρίωση για να μάθετε περισσότερα.

Διαχείριση διεργασιών με χρήση της λειτουργικής μονάδας

Όπως μπορείτε να μαντέψετε, η λειτουργική μονάδα παρέχει υπομονάδες και δυνατότητες για εργασία με διαδικασίες στο σύστημα.

Πάρτε το ακόλουθο παράδειγμα κώδικα:

χρησιμοποιήστε το std::process:: { Εντολή, έξοδος } ;

fn χέρι ( ) {
// τρέξτε το ls εντολή
αφήνω έξοδος = Εντολή::new ( 'ls' )
.arg ( '-ο' )
.παραγωγή ( )
.αναμένω ( 'Αποτυχία εκτέλεσης εντολής' ) ;

αν έξοδος.κατάσταση.επιτυχία ( ) {
αφήνω stdout = Συμβολοσειρά::from_utf8_lossy ( & έξοδος.stdout ) ;
println ! ( 'Έξοδος εντολών: \n {}' , stdout ) ;
} αλλού {
αφήνω stderr = Συμβολοσειρά::from_utf8_lossy ( & έξοδος.stderr ) ;
eprintln ! ( 'Η εντολή απέτυχε: \n {}' , stderr ) ;
έξοδος ( 1 ) ;
}
}


Στο συγκεκριμένο παράδειγμα, ξεκινάμε εισάγοντας τις απαιτούμενες ενότητες. Σε αυτήν την περίπτωση, χρειαζόμαστε τις μεθόδους 'command' και 'exit' από την υπομονάδα std::process.

Στη συνέχεια χρησιμοποιούμε τη συνάρτηση Command::new() για να εκτελέσουμε την εντολή 'ls' και να περάσουμε τα ορίσματα στην εντολή.

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

συμπέρασμα

Εξερευνήσαμε πώς να χρησιμοποιήσουμε τις διάφορες λειτουργίες και μεθόδους που παρέχονται από τη μονάδα std::os και τις υπομονάδες για την εκτέλεση πολλαπλών λειτουργιών σε συστήματα Linux και παρόμοια με το Unix. Να θυμάστε ότι η λειτουργική μονάδα std::os είναι μια εκτεταμένη λειτουργική μονάδα που περιέχει μια ευρύτερη συλλογή λειτουργιών από αυτές που παρουσιάζονται σε αυτό το σεμινάριο.