# Rust ქეში {#rust-cache}

Tuist აქაშებს მხარდაჭერილ Rust-ის კომპილაციის შედეგებს, რათა Cargo-მ შეძლოს მათი ხელახლა გამოყენება ბილდის შედეგების წაშლის შემდეგ. ქეში ჩაშენებულია Tuist CLI-ში. არ არსებობს ცალკეული ქეშის შესრულებადი ფაილი ან Cargo პლაგინი, რომელიც საჭირო იქნებოდა დასაყენებლად.

> [!WARNING]
> **ექსპერიმენტული კომპილაციის ქეში**
>
> ქეში ექსპერიმენტულია და ვალიდირებული მხოლოდ Apple Silicon-ზე დაფუძნებულ Mac-ებზე. ბიბლიოთეკები ინახება იმ წყაროების მიხედვით, რომლებიც კომპილატორმა წაიკითხა, ყველა პლატფორმაზე, თუმცა Linux-ზე ბიბლიოთეკების ქეშირება ჯერ არ არის ვალიდირებული. ბილდის სკრიპტები, პროცედურული მაკროები, შესრულებადი ფაილები და ნატიური კოდი ინახება მხოლოდ Apple Silicon-ზე დაფუძნებულ Mac-ებზე. ქეშის გასაღებები ანაცვლებენ checkout-ისა და toolchain-ის გზებს placeholder-ებით, ამიტომ ხელახლა გამოყენება მუშაობს ერთსა და იმავე მანქანაზე სხვადასხვა გზაზე განთავსებული checkout-ებისთვის, მაგრამ არა სხვადასხვა მანქანებს შორის.


## ქეშირების ჩართვა {#enable-caching}

მიჰყევით <.localized_link href="/guides/get-started/rust-project">Rust პროექტის დაყენებას</.localized_link> თქვენი პროექტის დასაკავშირებლად და ავთენტიფიკაციისთვის. შემდეგ გაუშვით თქვენი ბილდი Tuist-ის მეშვეობით:

```sh
tuist cargo build --release
```

ქეშირება ავტომატურია შესაბამისი კომპილაციებისთვის. არ არსებობს დამატებითი ქეშის კონფიგურაცია ან ჩართვის ფლაგი. Tuist აღმოაჩენს თქვენი ანგარიშის ქეშის endpoint-ს და იღებს ქეშის სერთიფიკატებს თქვენი არსებული პროექტისა და სერვერის კონფიგურაციის გამოყენებით.

თუ იყენებთ mise-ს, <.localized_link href="/guides/get-started/rust-project#keep-typing-cargo">განაწყეთ Cargo wrapper</.localized_link>, რათა განაგრძოთ ჩვეულებრივი `cargo` ბრძანებების შეყვანა.

## როგორ მუშაობს {#how-it-works}

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

1. ამოწმებს თავის ლოკალურ ქეშს შესაბამისი შედეგებისთვის.
2. ლოკალური ქეშში არყოფნის შემთხვევაში, უკავშირდება Kura-ს Remote Execution API (REAPI)-ს მეშვეობით, ჩამოტვირთავს ნაკლულ შინაარსს და ამოწმებს შედეგებს მათ აღდგენამდე.
3. ქეშში არყოფნის შემთხვევაში, ჩვეულებრივად უშვებს კომპილატორს. წარმატებული კომპილაციის შემდეგ, ინახავს შედეგებს ლოკალურად და ტვირთავს მათ Kura-ზე REAPI-ს მეშვეობით, როცა ეს ნებადართულია. დაშორებული ქეშის ჩანაწერი ქვეყნდება მხოლოდ მას შემდეგ, რაც მისი ყველა მითითებული შინაარსი ხელმისაწვდომი ხდება.

ლოკალური და CI ბილდები იყენებენ ერთსა და იმავე დაშორებული ქეშის პროტოკოლს. წაკითხვისა და ჩაწერის წვდომა მოდის Tuist-ის სერვერის მიერ გაცემული ქეშის სერთიფიკატებიდან და თქვენი ანგარიშის <.localized_link href="/guides/features/cache#restrict-uploads-to-ci">ქეშის ატვირთვის პოლიტიკიდან</.localized_link>. ანგარიშს შეუძლია ნება დართოს დეველოპერებს ჩამოტვირთვაზე, ხოლო ატვირთვა შეზღუდოს CI-სა და ანგარიშის ტოკენებზე. ქეშის ჩამწერები არიან სანდო კოდის მწარმოებლები: ქეშირებული კომპილატორის შედეგები არის შესრულებადი კოდი, ამიტომ ჩაწერის წვდომა მიანიჭეთ მხოლოდ იმ მანქანებსა და ტოკენებს, რომლებსაც ენდობით.

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

## რა შეიძლება დაქეშდეს {#what-can-be-cached}

ქეში მხარს უჭერს:

- ბიბლიოთეკის კრეიტებს, სამუშაო სივრცისა და გზის კრეიტების ჩათვლით, დამოკიდებულებების მქონე კრეიტებსა და გენერირებული წყაროების მქონე კრეიტებს. Tuist აკეთებს მათ გასაღებას იმ წყაროების მიხედვით, რომლებიც კომპილატორმა წაიკითხა.
- Apple silicon Mac-ებზე, კომპილაციებს, რომელთა გასაღებას წყაროს ინსპექციით წინასწარ ვერ ხერხდება, მაგალითად, კრეიტებს, რომლებიც იყენებენ პროცედურულ მაკროსებს, inline assembly-ს ან native ბიბლიოთეკებს, თავად პროცედურულ მაკროსებსა და დაკავშირებულ შესრულებად ფაილებს. Tuist იწერს ფაილებს, გარემოს ცვლადებსა და მხოლოდ წაკითხვის ბრძანებებს, რომელთაც თითოეული კითხულობს, მაგალითად `git describe`, და აკეთებს მათ გასაღებას.
- Apple silicon Mac-ებზე, build-script გაშვებებს, C კომპილაციების ჩათვლით, რომლებსაც ისინი ასრულებენ Apple-ის ნაგულისხმები კომპილატორით. გაშვება აღდგება მხოლოდ მაშინ, როცა ფაილები, გარემო და ბრძანებები, რომლებიც მან წაიკითხა, უცვლელია.
- გაფრთხილებებსა და სხვა დიაგნოსტიკას, რომელსაც დაქეშილი კრეიტი კვლავ აჩვენებს.

შემდეგი მაინც ჩვეულებრივად ბილდება:

- Build scripts და ჩაწერილი კომპილაციები Linux-ზე.
- Build scripts, რომლებიც უკავშირდებიან ქსელს, უშვებენ პროგრამებს, რომელთა დაკვირვებაც Tuist-ს არ შეუძლია, ან წერენ თავიანთი გამომავალი დირექტორიის გარეთ.
- ინკრემენტული კომპილაციები, მორგებული targets და მხარდაუჭერელი კომპილატორის არგუმენტები ან წყაროს შეყვანები.
- მხოლოდ მეტამონაცემების `cargo check` გამოძახებები.
- კომპილაციები, რომლებიც ასხივებენ მოულოდნელ კომპილატორის გამომავალს.

წინასწარ არსებული გლობალური კომპილატორის wrapper აუქმებს Tuist-ის კომპილაციის ქეშსა და კომპილატორის დამკვირვებელს. მორგებული workspace wrappers ასევე უვლიან გვერდს ქეშირებას. იხილეთ <.localized_link href="/guides/features/build-insights/rust#other-compiler-tools">კომპილატორის ინსტრუმენტების თავსებადობა</.localized_link>.

ქეშის გასაღებები მოიცავს პაკეტის შინაარსს, კომპილატორსა და toolchain-ს, არგუმენტებსა და ბილდის გარემოს. Checkout, target დირექტორია, Cargo home და toolchain-ის მდებარეობები იცვლება placeholder-ებით, რათა სხვა გზაზე checkout-მა ხელახლა გამოიყენოს იგივე ჩანაწერები. კრეიტი, რომლის გამომავალიც აერთიანებს საკუთარ გზას, მაგალითად `env!("CARGO_MANIFEST_DIR")`-ის მეშვეობით, ხელახლა გამოიყენება მხოლოდ იმ გზაზე. სერთიფიკატები, Tuist-ის ანგარიშგების პარამეტრები და აღიარებული CI გაშვების მეტამონაცემები არ აუქმებენ ჩანაწერებს. კრეიტები, რომლებიც კომპილაციის დროს კითხულობენ ამ გამორიცხულ ცვლადებს, არ ქეშირდება.

## ხელახლა გამოყენების შემოწმება {#verify-reuse}

Cargo უკვე თავიდან იცილებს აქტუალური შედეგების ხელახლა ბილდვას. იმისათვის, რომ გამოიყენოთ Tuist-ის ქეში Cargo-ს არსებული შედეგების ნაცვლად, ააწყეთ ერთხელ, წაშალეთ Cargo-ს შედეგები, შემდეგ კი გაიმეორეთ იგივე ბილდი:

```sh
tuist cargo build --release
cargo clean
tuist cargo build --release
```

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

## ქეშის აქტივობის ინსპექცია {#inspect-cache-activity}

გახსენით **Cargo Cache** თქვენი პროექტის dashboard-ზე, რათა შეამოწმოთ ქეშში მოხვედრის მაჩვენებლები, ჩაწერილი გადაცემები, ლატენტობა, გამტარუნარიანობა და ბოლო ბილდები. გახსენით ბილდის **Cache** ჩანართი ინდივიდუალური ამოცანების გადაწყვეტილებებისა და CAS შედეგებისთვის.

ნაკლული გაზომვები არ ითვლება ნულად, და ქეშში მოხვედრა არ ნიშნავს აუცილებლად დაშორებულ ჩამოტვირთვას. დეტალებისთვის იხილეთ <.localized_link href="/guides/features/build-insights/rust#cache-measurements">Rust ქეშის გაზომვები</.localized_link>.

## პრობლემების გადაჭრა {#troubleshooting}

ჩართეთ debug გამომავალი ქეშის გადაცემისა და ანგარიშგების შეცდომების შესასწავლად:

```sh
TUIST_DEBUG=1 tuist cargo build --release
```

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