მოდულის ქეში
- გენერირებული პროექტი. მოდულის ქეში კითხულობს პროექტის გრაფს, რომელსაც Tuist ინახავს
Project.swift-ის უკან, რათა დაჰეშოს მიზნები და ჩაანაცვლოს მათი ბინარები.
Tuist Module Cache გთავაზობთ ეფექტურ გზას აწყობის დროების ოპტიმიზაციისთვის თქვენი მოდულების ბინარებად (.xcframeworks) შენახვით და სხვადასხვა გარემოებში გაზიარებით. ეს შესაძლებლობა საშუალებას გაძლევთ გამოიყენოთ ადრე გენერირებული ბინარები, შეამციროთ განმეორებითი კომპილაციის საჭიროება და დააჩქაროთ განვითარების პროცესი. იმის გასარკვევად, თუ ნელი აწყობის რომელ ნაწილს აშორებს ქეში, იხილეთ ნელი აწყობები.
მოდულის ქეში და Xcode ქეში ერთმანეთს ავსებენ, რადგან ისინი სხვადასხვა დეტალიზაციის დონეზე მუშაობენ. მოდულის ქეში აწყობის დაწყებამდე მთლიან მოდულებს ცვლის წინასწარ აწყობილი .xcframework-ებით, ხოლო Xcode ქეში აწყობის დროს იყენებს კომპილაციის შედეგებს ხელახლა.
კომპილაციის ქეშის პარამეტრები არ შედის მოდულის ქეშის ჰეშებში, ამიტომ Xcode ქეშის ჩართვა ან გამორთვა ინარჩუნებს უკვე „გათბილ“ ბინარებს. Xcode 27-ზე და ზემოთ, მასთან ერთად მომავალი პრეფიქსის ასახვის პარამეტრები ჰეშდება. იხილეთ მოდულის ქეშის ჰეშები.
გათბობა#
Tuist ეფექტურად იყენებს ჰეშებს დამოკიდებულების გრაფში თითოეული მიზნისთვის ცვლილებების აღმოსაჩენად. ამ მონაცემების გამოყენებით, ის აწყობს და ანიჭებს უნიკალურ იდენტიფიკატორებს ამ მიზნებიდან მიღებულ ბინარებს. გრაფის გენერაციის დროს, Tuist შემდეგ უმტკივნეულოდ ცვლის საწყის მიზნებს მათ შესაბამისი ბინარული ვერსიებით.
ეს ოპერაცია, ცნობილი როგორც „გათბობა“, ქმნის ბინარებს ადგილობრივი გამოყენებისთვის ან Tuist-ის მეშვეობით გუნდის წევრებთან და CI გარემოებთან გასაზიარებლად. ქეშის გათბობის პროცესი მარტივია და შეიძლება დაიწყოს მარტივი ბრძანებით:
tuist cache
ბრძანება ხელახლა იყენებს ბინარებს პროცესის დასაჩქარებლად.
თუ ბინარის ატვირთვა ვერ მოხერხდა, ბრძანება მაინც ატვირთავს დანარჩენებს, შემდეგ კი სრულდება არანულოვანი სტატუსით და ჩამოთვლის მიზნებს, რომლებიც არ აიტვირთა. მანქანის ადგილობრივ ქეშში არსებული ბინარები ითვლება ქეშირებულად, ამიტომ იმავე მანქანიდან მათ ხელახლა ატვირთვისთვის, გათბობამდე გაუშვით tuist clean binaries. გადაეცით --no-upload ბინარების მხოლოდ ადგილობრივ ქეშში შესანახად.
დანიშნულების შერჩევა#
გამოიყენეთ --destination simulator ან --destination device ერთი დანიშნულებისთვის ქეშირების, გენერაციის და ტესტირებისთვის:
tuist cache --destination simulator
tuist generate --destination simulator
tuist test --destination simulator
tuist cache --destination device
tuist generate --destination device
tuist test --destination device -- -destination 'platform=iOS,id=DEVICE_IDENTIFIER'
ნაგულისხმევი მნიშვნელობაა all, რომელიც ინარჩუნებს თქვენი მიზნების მიერ მხარდაჭერილ ყველა დანიშნულებას, Mac Catalyst-ის ჩათვლით. მოგვიანებით tuist cache ხელახლა იყენებს ქეშირებულ ნაწილებს და აწყობს მხოლოდ დაკარგულ SDK-ებს. ჩვეულებრივი გენერაცია ინარჩუნებს მოდულის საწყის ფაილებს, თუ რაიმე საჭირო ნაწილი აკლია.
შეზღუდული გენერაცია საწყის მიზნებს აკავშირებს შერჩეულ დანიშნულებასთან და ინარჩუნებს macOS-ის ნატიურ მიზნებს, მაკროსების ჩათვლით. არცერთი შეზღუდული რეჟიმი არ მოიცავს Mac Catalyst-ს. ხელახლა გაუშვით გენერაცია --destination all-ით ყველა დანიშნულების აღდგენისთვის.
tuist test --destination იყენებს და გადმოწერს მხოლოდ შერჩეული დანიშნულების ნაწილებს, ამიტომ სიმულატორის ტესტების გაშვებამ შეიძლება გამოიყენოს ბინარები მხოლოდ სიმულატორისთვის ან სრული გათბობიდან. ის ვერ ხერხდება, როდესაც ---ის შემდეგ xcodebuild-ისთვის გადაცემული დანიშნულება არ ემთხვევა, და --destination device საჭიროებს მოწყობილობის -destination-ს. შერჩევითი ტესტირების ჰეშები არ არის დამოკიდებული დანიშნულებაზე, ამიტომ სხვადასხვა --destination მნიშვნელობების მქონე გაშვებები იზიარებენ ტესტების შედეგებს.
ნაწილ-ნაწილად ქეშირება მხარდაჭერილია iOS-ისა და macOS-ისთვის სტანდარტული არქიტექტურებით. სხვა პლატფორმები, მორგებული არქიტექტურები და არამხარდაჭერილი პროდუქტები ინარჩუნებენ სრული არტეფაქტის ქეშირებას. ძველი მოდულის ქეშირება ყოველთვის გადმოწერს სრულ არტეფაქტებს და გათბობისას საჭიროებს --destination all-ს.
დაშორებული ატვირთვის დაშვება#
თანამედროვე მოდულის ქეშირება იყენებს REAPI-ს. როდესაც დატვირთული ქეში დროებით უარყოფს ატვირთვას RESOURCE_EXHAUSTED-ით, Tuist ამცირებს სიხშირეს jitter-ით, პატივს სცემს სტანდარტულ google.rpc.RetryInfo მინიმალურ დაყოვნებებს და ცდილობს ხელახლა შეზღუდული ლოდინის ბიუჯეტის ფარგლებში. ატვირთვის დაშვება საშუალებას აძლევს მაქსიმუმ ექვს ხელახლა ცდას თითოეული გამოძახებისთვის. თითოეული blob-ატვირთვის ოპერაცია იზიარებს ერთ 60-წამიან კუმულაციურ backoff ბიუჯეტს თავისი არსებობის შემოწმებებში, ბატჩური ატვირთვებსა და streaming ჩაწერებში; პარალელური ლოდინები თითოეული მოიხმარს ბიუჯეტს, ამიტომ განმეორებითი უარები არ ანიჭებენ ყოველ რიგში მყოფ blob-ს კიდევ ერთ წუთს ხელახლა ცდებისთვის. წარმატებული გადაცემები არ მოიხმარენ ამ ბიუჯეტს და არ ჩერდებიან, როდესაც ის ამოიწურება. Action-result-ის გამოქვეყნებას აქვს საკუთარი შეზღუდული ბიუჯეტი. ექსპონენციალური დაყოვნება იწყება ერთი წამიდან და იზრდება 30 წამისკენ პროპორციული jitter-ის წინ. თუ სერვერის საჭირო დაყოვნება აღემატება დარჩენილ ბიუჯეტს, Tuist ვერ ხერხდება, ვიდრე ცდილობდეს ინსტრუქციაზე ადრე. გაუქმება წყვეტს backoff-ს, ხოლო ქეშის წაკითხვები ინარჩუნებენ მოკლე ხელახლა ცდებს, რათა გადატვირთვამ არ შეაჩეროს გენერაცია.
ეს ნაგულისხმევი პარამეტრები ასევე ეხმარება Kura-ს ძველ ვერსიებს retry მითითებების გარეშე. უფრო ხანგრძლივი ხელახლა ცდები შთანთქავენ დროებით კონკურენციას, არა მდგრად გადატვირთვას: შეამცირეთ ქეშის კონკურენტულობის ლიმიტი გათბობის სამუშაოებზე ან გაზარდეთ სერვერის სიმძლავრე, თუ უარები გრძელდება. იხილეთ Kura ატვირთვის ზომები pod-მეხსიერების შეფასებებისა და დაშვების მეტრიკებისთვის.
კონფიგურაციის შერჩევა#
როდესაც ქეშს ათბობთ --configuration-ის გადაცემის გარეშე, Tuist ირჩევს გამოყენებისთვის აწყობის კონფიგურაციას შემდეგი თანმიმდევრობით:
defaultConfiguration, რომელიც დაყენებულია თქვენს მანიფესტშიProject.Options.generationOptions-ში, თუ არსებობს.- წინააღმდეგ შემთხვევაში, პირველი აწყობის კონფიგურაცია ვარიანტის
debug-ისთვის, დალაგებული ანბანური თანმიმდევრობით სახელის მიხედვით.
კონკრეტული კონფიგურაციისთვის ქეშის გასათბობად, გადაეცით ის ცალსახად:
tuist cache --configuration Release
გამოყენება#
ნაგულისხმევად, როდესაც Tuist-ის ბრძანებებს სჭირდებათ პროექტის გენერაცია, ისინი ავტომატურად ცვლიან დამოკიდებულებებს მათი ბინარული ეკვივალენტებით ქეშიდან, თუ ხელმისაწვდომია. დამატებით, თუ მიუთითებთ მიზნების სიას ფოკუსირებისთვის, Tuist ასევე ჩაანაცვლებს ნებისმიერ დამოკიდებულ მიზნებს მათი ქეშირებული ბინარებით, იმ პირობით, რომ ისინი ხელმისაწვდომია. მათთვის, ვინც სხვა მიდგომას ამჯობინებს, არსებობს ამ ქცევის სრულად გამორთვის შესაძლებლობა კონკრეტული ფლაგის გამოყენებით:
tuist generate # Only dependencies
tuist generate Search # Dependencies + Search dependencies
tuist generate Search Settings # Dependencies, and Search and Settings dependencies
tuist generate --cache-profile none # No cache at all
tuist test
ბინარული ქეშირება არის ფუნქცია, შექმნილი განვითარების სამუშაო ნაკადებისთვის, როგორიცაა აპლიკაციის გაშვება სიმულატორზე ან მოწყობილობაზე, ან ტესტების გაშვება. ის არ არის განკუთვნილი რელიზის აწყობებისთვის. აპლიკაციის არქივირებისას, გაუშვით პროექტი საწყისი ფაილებით --cache-profile none-ის გამოყენებით.
ქეშის პროფილები#
Tuist მხარდაჭერს ქეშის პროფილებს, რათა აკონტროლოს, თუ რამდენად აგრესიულად ჩანაცვლდება მიზნები ქეშირებული ბინარებით პროექტების გენერაციისას.
- ჩაშენებული:
only-external: ჩაანაცვლოს მხოლოდ გარე დამოკიდებულებები (სისტემის ნაგულისხმევი)all-possible: ჩაანაცვლოს რაც შეიძლება მეტი მიზანი (შიდა მიზნების ჩათვლით)none: არასდროს ჩაანაცვლოს ქეშირებული ბინარებით
აირჩიეთ პროფილი --cache-profile-ით tuist generate-ზე:
# Built-in profiles
tuist generate --cache-profile all-possible
# Custom profiles (defined in Tuist Config)
tuist generate --cache-profile development
# Use config default (no flag)
tuist generate
# Focus on specific targets (implies all-possible)
tuist generate MyModule AnotherTarget
# Disable binary replacement entirely
tuist generate --cache-profile none
--no-binary-cache ფლაგი მოძველებულია. გამოიყენეთ --cache-profile none მის ნაცვლად. მოძველებული ფლაგი კვლავ მუშაობს უკუთავსებადობისთვის.
პრიორიტეტები ეფექტური ქცევის განსაზღვრისას (უმაღლესიდან დაბალამდე):
--cache-profile none- მიზნების ფოკუსირება (მიზნების გადაცემა
generate-ში) → პროფილიall-possible --cache-profile <value>- კონფიგურაციის ნაგულისხმევი (თუ დაყენებულია)
- სისტემის ნაგულისხმევი (
only-external)
მხარდაჭერილი პროდუქტები#
Tuist-ის მიერ ქეშირებადია მხოლოდ შემდეგი მიზნის პროდუქტები:
- ფრეიმვორკები (სტატიკური და დინამიური), ტესტების მხარდამჭერი ფრეიმვორკების ჩათვლით, რომლებიც დამოკიდებულნი არიან XCTest-ზე ან Swift Testing-ზე
- ბიბლიოთეკები (სტატიკური და დინამიური), ტესტების მხარდამჭერი ბიბლიოთეკების ჩათვლით, რომლებიც დამოკიდებულნი არიან XCTest-ზე ან Swift Testing-ზე
- ბანდლები
- Swift Macros
ტესტების ბანდლები გამორჩენილი რჩება მოდულის ქეშიდან. ეს ნიშნავს, რომ unitTests და uiTests მიზნები არ ქეშირდება როგორც ბინარები, მაგრამ ჩვეულებრივი ფრეიმვორკისა და ბიბლიოთეკის მიზნები, რომლებზეც ტესტებია დამოკიდებული, შეიძლება იყოს ქეშირებული, მაშინაც კი, თუ ისინი აკავშირებენ XCTest-ს ან Swift Testing-ს.
ქეშირებული ბიბლიოთეკის .xcframework-ები ინარჩუნებენ მეტამონაცემებს, რომლებიც საჭიროა გენერირებული პროექტებისთვის მათ იმპორტისთვის, Swift მოდულებისა და საჯარო C/Objective-C ჰედერების ჩათვლით, როდესაც საწყისი მიზანი აცხადებს საჯარო ჰედერებს.
როდესაც მიზანი არ არის ქეშირებადი, ის ზედა დინების მიზნებსაც არაქეშირებადს ხდის. მაგალითად, თუ გაქვთ დამოკიდებულების გრაფი A > B, სადაც A დამოკიდებულია B-ზე, თუ B არ არის ქეშირებადი, A ასევე არ იქნება ქეშირებადი.
ანალიტიკა#
გახსენით Module Cache → Modules თქვენი პროექტის დაშბორდზე, რათა იპოვოთ მოდულები ხშირი გამოტოვებებით. აირჩიეთ გარემო, რომლის გაუმჯობესებაც გსურთ, მაგალითად CI, და თარიღების დიაპაზონი. მიმოხილვა აჩვენებს ქეშის მოხვედრებს, გამოტოვებებსა და მოდულებს გამოტოვებებით; მოდულის გახსნა აჩვენებს მის ისტორიას და თითოეული დაკვირვებისთვის მინიჭებულ მიზეზს.
ჩამოსაშლელი მენიუ Misses ირჩევს რაოდენობასა და ახსნას ერთი მიზეზისთვის. დიაგრამა აჩვენებს ოთხივე მიზეზის განაწილებას. მოდულის გვერდზე გამოიყენეთ ისტორიის ფილტრი Reason ცალკეული შემთხვევების შესასწავლად. გადაიტანეთ მაუსი მიზეზის ნიშანზე ან ფოკუსირება მოახდინეთ მასზე კლავიატურით მისი განმარტების სანახავად.
გამოტოვების მიზეზები#
| მიზეზი | რას ნიშნავს |
|---|---|
| შეცვლილი | მოდულის საკუთარი შედარებული შეყვანები შეიცვალა. ეს მოიცავს ფაილის ჰეშებს, აწყობის პარამეტრებს, ამოხსნილ კონფიგურაციასა და კომპილატორის იდენტიფიკატორს. წყაროს რედაქტირება მხოლოდ ერთ-ერთი შესაძლო მიზეზია. |
| ზედა დინება | მოდულის საკუთარი შედარებული შეყვანები უცვლელი დარჩა, მაგრამ მისი დამოკიდებულების ან გარე პაკეტის ჰეში შეიცვალა. მოდულის საწყისი ფაილები შეიძლება უცვლელი იყოს. |
| ცივი | არ არსებობს ადრეული მოდულის დაკვირვება შედარებისთვის, ან მოხსენებული შეყვანები ვერ ხსნიან გამოტოვებას და არ არსებობს შესაბამისი მტკიცებულება ადრეული დისტანციური ხელმისაწვდომობის შესახებ. „ცივი“ არ ამტკიცებს, რომ მოდული არასდროს ყოფილა ქეშირებული. |
| გაძევებული | ზუსტ ქეშის გასაღებს ადრე ჰქონდა დისტანციური მოხვედრა იმავე პროექტში იმავე ჩაწერილ ქეშის ბოლოწერტილზე, მაგრამ ახლა აკლია. |
Evicted-ით მონიშნული გამოტოვებებისთვის, არტეფაქტი ადრე ჩამოტვირთული იყო დისტანციური ქეშიდან, მაგრამ ამჯერად ხელახლა გამოყენება ვერ მოხერხდა. გაძევება სავარაუდო მიზეზია, თუმცა წვდომის ან ჩამოტვირთვის შეცდომებმაც შეიძლება ახსნან გამოტოვება. Tuist ამ ნიშანს მხოლოდ მაშინ ანიჭებს, როდესაც პოულობს ადრეულ დისტანციურ მოხვედრას; წინა გამოტოვებები და ლოკალური მოხვედრები საკმარისი არ არის.
მაგალითად:
| სცენარი | კლასიფიკაცია |
|---|---|
| მოდულს აკლია ადრეული დაკვირვება ან შესაბამისი დისტანციური მოხვედრა | ცივი |
| A იცვლება; B დამოკიდებულია A-ზე, ხოლო C დამოკიდებულია B-ზე; სამივე გასაღები იცვლება | A არის Changed; B და C არიან Upstream |
| კომპილატორის ვერსია იცვლება გათბობის შემდეგ, წყაროებისა და პარამეტრების უცვლელობის პირობებში | შეცვლილად კლასიფიცირდება ის გამოტოვებები, როდესაც ორივე დაკვირვება აფიქსირებს კომპილატორის შეყვანებს |
| ზუსტი გასაღები დისტანციურად ჩამოიტვირთა, შემდეგ კი მისი არტეფაქტის გაძევების გამო გამოტოვება მოხდა | გაძევებული, როდესაც ადრეული მოხვედრა მტკიცებულებად ითვლება |
| გასაღები განმეორებით იკარგება და არასდროს ყოფილა წარმატებით გაცხელებული | ის ცივად შეიძლება დარჩეს |
მიზეზები აღწერენ დაკვირვებებს; ისინი არ არიან გასაღებზე მიბმული მუდმივი ნიშნები. მაგალითად, კომპილატორის განახლების შემდეგ პირველი გამოტოვება შეიძლება იყოს Changed, ხოლო ამ ახალი გასაღებისთვის მოგვიანებითი გამოტოვება შეიძლება იყოს Cold, თუ ის არასდროს დაფიქსირებულა როგორც დისტანციურად ხელმისაწვდომი.
ქეშში მოხვედრის მაჩვენებლის გაუმჯობესება#
- აირჩიეთ თანმიმდევრული საწყისი წერტილი. დაიწყეთ CI-ით და რეპრეზენტატიული თარიღების დიაპაზონით. დაალაგეთ მოდულები გამოტოვებების მიხედვით, შემდეგ გაითვალისწინეთ მათი მოხვედრის მაჩვენებლები, დამოკიდებულებები და აგების ღირებულება. ხშირად გამომტოვანი, ძვირადღირებული დამოკიდებულების გამოსწორებამ შეიძლება უფრო მეტი დრო დაგიზოგოთ, ვიდრე პატარა მოდულის მოხვედრის მაჩვენებლის გაუმჯობესებამ. ცვლილების შეტანის შემდეგ შეადარეთ ერთი და იგივე გარემო და მსგავსი დატვირთვები.
- გამოიკვლიეთ Changed ტიპის გამოტოვებები. გახსენით შესაბამისი გაშვებები და შეადარეთ მათი სრული გასაღებები და მოხსენებული შეყვანები. დაალაგეთ გათბობისა და მომხმარებელი სამუშაოები სასურველ Xcode/კომპილატორის ვერსიაზე, კონფიგურაციასა და სამიზნე დანიშნულებებზე. განზრახული ცვლილებების შემდეგ კვლავ გააცხელეთ. თუ არასტაბილური გენერირებული ფაილები ან გარემოზე დამოკიდებული პარამეტრები არაიმედებს ხდიან წინააღმდეგ შემთხვევაში სტაბილურ მოდულებს, გამოიკვლიეთ ეს შეყვანები. ჰეშში შეინახეთ შეყვანები, რომლებიც გავლენას ახდენენ ბინარულ თავსებადობაზე.
- Upstream გამოტოვებები მიჰყევით შეცვლილ დამოკიდებულებამდე. შეამოწმეთ მისი ისტორია პირდაპირი ცვლილების საპოვნელად. მიღებული გასაღებების გაცხელებამ შეიძლება აღადგინოს ხელახლა გამოყენება. თუ ხშირად ცვალებადი იმპლემენტაცია არაიმედებს ხდის ბევრ ძვირადღირებულ დამოკიდებულს, განიხილეთ უფრო მცირე მოდულები ან სტაბილური ინტერფეისები, როგორც აღწერილია Efficiency-ში.
- შეამოწმეთ გაცხელების დაფარვა Cold გამოტოვებებისთვის. დარწმუნდით, რომ გაცხელება ირჩევს საჭირო მოდულებს, იყენებს მომხმარებელი სამუშაოს კონფიგურაციასა და გარემოს და წარმატებით ტვირთავს არტეფაქტებს. შეამოწმეთ სრული გასაღებები, რომლებსაც იყენებენ რეალური CI სამუშაოები. თუ გაცხელება და მოხმარება სხვადასხვა გასაღებებს ითხოვენ, შეამოწმეთ ჰეშის შეყვანები, სანამ ვარაუდობთ, რომ ქეში გაძევდა. განმეორებითი გამოტოვებები ადრეული წარმატებული ატვირთვის გარეშე შესაძლებელია მაშინაც, როცა მოდულის წყაროები არ შეცვლილა.
- გამოიყენეთ მტკიცებულებები Evicted გამოტოვებებისთვის. დაადასტურეთ მომხმარებელი გაშვების გასაღები და ბოლოწერტილი, შემდეგ შეამოწმეთ მომხმარებელი გაშვების ქეშის გაფრთხილებები და გაცხელების სამუშაოს ატვირთვის შედეგი. საჭიროების შემთხვევაში შეამოწმეთ შენარჩუნება ან გაძევება. ხელახლა გააცხელეთ საჭირო არტეფაქტები და დაადასტურეთ მომდევნო მოხვედრა. თუ ისინი კვლავ იკარგებიან, გაუზიარეთ შესაბამისი გაშვების ბმულები და ჟურნალები მხარდაჭერას.
ჰეშის შესადარებლად, გაუშვით ეს თითოეულ შესაბამის გარემოში, იმ კონფიგურაციის გამოყენებით, რომლის გაცხელებასა და მოხმარებასაც გეგმავთ:
tuist hash cache --configuration Debug --verbose
შეადარეთ მოდულის სრული ჰეში და კომპონენტის ბლოკი. იგივე უცვლელ მანქანაზე ბრძანების განმეორებამ ჩვეულებრივ უნდა მოგვცეს იგივე შედეგი; შეუსაბამობის გამოსაკვლევად შეადარეთ რეალური გაცხელებისა და მოხმარების გარემოები. არცერთ ბრძანებას არ სჭირდება ქეშში მოხვედრა. დამატებითი შემოწმებებისთვის იხილეთ hashing diagnostics.
ეფექტურობა#
ბინარული ქეშირებით მიღწევადი ეფექტურობის დონე ძლიერ არის დამოკიდებული გრაფის სტრუქტურაზე. საუკეთესო შედეგების მისაღწევად, გირჩევთ შემდეგს:
- არიდეთ ძლიერ ჩაბუდებული დამოკიდებულების გრაფები. რაც უფრო ბრტყელია გრაფი, მით უკეთესი.
- განსაზღვრეთ დამოკიდებულებები პროტოკოლის/ინტერფეისის სამიზნეებით იმპლემენტაციის ნაცვლად და ინექციურად ჩადეთ იმპლემენტაციები ზედა დონის სამიზნეებიდან.
- ხშირად ცვალებადი სამიზნეები დაყავით უფრო მცირეებად, რომელთა ცვლილების ალბათობა დაბალია.
ზემოთ მოცემული რჩევები არის The Modular Architecture-ის ნაწილი, რომელსაც ჩვენ გთავაზობთ როგორც თქვენი პროექტების სტრუქტურირების გზას, რათა მაქსიმალურად გაზარდოთ სარგებელი არა მხოლოდ ბინარული ქეშირებისგან, არამედ Xcode-ის შესაძლებლობებისგანაც.
რეკომენდებული კონფიგურაცია#
გირჩევთ გქონდეთ CI სამუშაო, რომელიც გაეშვება main შტოში ყოველ კომიტზე ქეშის გასაცხელებლად. ეს უზრუნველყოფს, რომ ქეში ყოველთვის შეიცავდეს ბინარებს main-ში ცვლილებებისთვის, რათა ლოკალურმა და CI შტოს აგებამ მათზე ინკრემენტულად იმუშაოს.
გაუშვით tuist cache ცალკეულ CI ნაბიჯში, გენერირებულ სამუშაო სივრცეზე დამოკიდებული მომდევნო ნაბიჯების გარეშე. ვინაიდან tuist cache ცვლის სამუშაო სივრცეს ქეშის აგების მიზნებისთვის, ნებისმიერმა CI ნაბიჯმა, რომელსაც სჭირდება სამუშაო სივრცე, ჯერ უნდა გაუშვას tuist generate, რათა მიიღოს ახალი, გამოსაყენებელი სამუშაო სივრცე.
ბრძანება tuist cache ასევე იყენებს ბინარულ ქეშს გაცხელების დასაჩქარებლად.
ქვემოთ მოცემულია რამდენიმე მაგალითი ჩვეულებრივი სამუშაო ნაკადებისა:
დეველოპერი იწყებს მუშაობას ახალ ფუნქციაზე#
- ის ქმნის ახალ შტოს
main-დან. - ის უშვებს
tuist generate. - Tuist იღებს უახლეს ბინარებს
main-დან და მათი გამოყენებით აგენერირებს პროექტს.
დეველოპერი აგზავნის ცვლილებებს ზემოთ#
- CI პაიპლაინი გაუშვებს
xcodebuild buildანtuist testპროექტის აგების ან ტესტირებისთვის. - სამუშაო ნაკადი ჩამოტვირთავს უახლეს ბინარებს
main-დან და მათი გამოყენებით აგენერირებს პროექტს. - შემდეგ ის ინკრემენტულად ააგებს ან შეამოწმებს პროექტს.
კონფიგურაცია#
ქეშის კონკურენტულობის ლიმიტი#
დააყენეთ TUIST_CACHE_CONCURRENCY_LIMIT დადებით მთელ რიცხვად, რათა შეზღუდოთ როგორც ჩამოტვირთვები, ისე ატვირთვები. მაგალითად, შეამცირეთ დატვირთვა მცირე თვითმასპინძელ ქეშზე გაცხელების სამუშაოებში:
TUIST_CACHE_CONCURRENCY_LIMIT=2 tuist cache
როდესაც დაყენებული არ არის, REAPI ატვირთვები იყენებენ რვა გადაცემის ამოცანას. ჩამოტვირთვები იყენებენ რვას, როდესაც ნებისმიერი ბლობი მოითხოვს ByteStream-ს, და 32-ს მხოლოდ batch-გეგმებისთვის. ძველი HTTP ქეშის გზის ნაგულისხმები მნიშვნელობა არის 100; ეს ნაგულისხმები მნიშვნელობა არ ვრცელდება REAPI-ზე. არასწორი მნიშვნელობები, მათ შორის ადრე დოკუმენტირებული none, ინარჩუნებენ ნაგულისხმევებს ლიმიტების მოხსნის ნაცვლად. გამოიყენეთ unset TUIST_CACHE_CONCURRENCY_LIMIT ნაგულისხმევების აღსადგენად.
ლიმიტები მოქმედებს თითოეული გადაცემის ოპერაციისთვის, არა გლობალურად ყველა ოპერაციასა თუ CI სამუშაოზე. ერთდროულად სამი გაცხელება ორის ლიმიტით შეიძლება აქტიური ექვსი ატვირთვა ჰქონდეს იმავე ქეშთან. მომხმარებლის სამუშაოებს შეუძლიათ ცვლადი დაუყენებელი დატოვონ, რათა შეინარჩუნონ ჩამოტვირთვის ნაგულისხმევი პარალელიზმი.
ქეშის გაცხელების დროებითი საქაღალდე#
ნაგულისხმევად, tuist cache ქმნის დროებით საქაღალდეს აგების შუალედური ფაილებისა და შეკრებილი ქეშის არტეფაქტებისთვის, შემდეგ კი მას შლის, როდესაც ქეშის გაცხელება სრულდება. ამ ფაილების თქვენ მიერ მართულ საქაღალდეში შესანახად, დააყენეთ TUIST_CACHE_WARM_SCRATCH_DIRECTORY.
გზა შეიძლება იყოს აბსოლუტური ან მიმდინარე სამუშაო საქაღალდესთან მიმართებაში. Tuist ქმნის საქაღალდეს, თუ ის არ არსებობს. თუ ის უკვე არსებობს, ის უნდა იყოს ცარიელი საქაღალდე.
როდესაც ეს გარემოს ცვლადი დაყენებულია, Tuist ტოვებს საქაღალდეს და მის შიგთავსს ბრძანების დასრულების შემდეგ. გამომძახებელი პასუხისმგებელია მის გასუფთავებაზე შემდეგი ქეშის გაცხელებამდე. როდესაც ცვლადი დაყენებული არ არის, Tuist განაგრძობს დროებითი საქაღალდის გამოყენებასა და წაშლას.
Tuist უარყოფს გამომძახებლის მიერ მართულ დროებით საქაღალდეს, როდესაც საჭიროა უცხო აგების სამიზნის გაცხელება. უცხო აგების სკრიპტები აკონტროლებენ საკუთარ გამომავალ მდებარეობებს, ამიტომ Tuist ვერ უზრუნველყოფს, რომ ეს გამომავალი მონაცემები დარჩეს დროებით საქაღალდეში.
კოდის დაფარვა#
მოდულის ქეშიდან აღებული სამიზნე არის წინასწარ აგებული ბინარი, და ტესტების გაშვება ზომავს მის კოდს მხოლოდ მაშინ, როდესაც ეს ბინარი აგებული იყო დაფარვის მრიცხველებით. ეს სექცია აღწერს, როგორ მუშაობს ქეში დაფარვასთან; დაფარვის სრულად დასაყენებლად, იხილეთ კოდის დაფარვა. ჩართეთ დაფარვა თქვენი პროექტისთვის Tuist.swift-ში:
import ProjectDescription
let tuist = Tuist(
project: .tuist(
generationOptions: .options(
coverage: .coverage(enabled: true)
)
)
)
enabled-ით, ყოველი ბრძანება და ყოველი გარემო კითხულობს ქეშის ერთ ინსტრუმენტულ ვარიანტს თქვენი პროექტის საკუთარი სამიზნეებისთვის, ასე რომ ერთი გაცხელება CI-ზე ემსახურება როგორც CI-ს, ისე ადგილობრივ მანქანებს:
| ბრძანება | თქვენი პროექტის სამიზნეები | გარე პაკეტები |
|---|---|---|
tuist cache (Debug კონფიგურაცია) |
აცხელებს ინსტრუმენტულ ბინარებს | აცხელებს ჩვეულებრივ ბინარებს |
tuist cache (Release კონფიგურაცია) |
აცხელებს ჩვეულებრივ ბინარებს | აცხელებს ჩვეულებრივ ბინარებს |
tuist hash cache |
ბეჭდავს ინსტრუმენტულ გასაღებებს | ბეჭდავს ჩვეულებრივ გასაღებებს |
tuist generate |
კითხულობს ინსტრუმენტულ ბინარებს | კითხულობს ჩვეულებრივ ბინარებს |
tuist test |
კითხულობს ინსტრუმენტულ ბინარებს | კითხულობს ჩვეულებრივ ბინარებს |
პარამეტრი ვრცელდება ყოველ კონფიგურაციაზე, რომელსაც Xcode Debug-ად მიიჩნევს. Release აგებები არასდროს არის ინსტრუმენტული. Tuist ასევე აკავშირებს პროფილის runtime-ს ამ კონფიგურაციებში (CLANG_COVERAGE_MAPPING_LINKER_ARGS), ასე რომ აგებები, რომლებიც არ აგროვებენ დაფარვას, მაინც აკავშირებენ ინსტრუმენტულ ბინარებს, და რთავს დაფარვას სქემების ტესტის მოქმედებაში, რომლებსაც ის ავტომატურად აგენერირებს და სქემებში, რომლებსაც თქვენ განსაზღვრავთ და ტოვებთ coverage დაუყენებელს.
თქვენ მიერ განსაზღვრული სქემა მიჰყვება პარამეტრს, თუ ის თავად არ აყენებს დაფარვას: .options(coverage: false) ტოვებს მას გამორთულს და .options(coverage: true) ტოვებს მას ჩართულს, რაც არ უნდა ეწეროს პარამეტრში. ტესტის გეგმები თავად წყვეტენ დაფარვას, და -enableCodeCoverage მაინც გადაფარავს გაშვებას, როგორც Xcode-ში. გაშვება, რომელიც კითხულობს ინსტრუმენტულ ბინარებს დაფარვის შეგროვების გარეშე, ჩვეულებრივად აგებს და ამოწმებს. როდესაც გაშვება აგროვებს დაფარვას, მაგრამ თქვენი პროექტის სამიზნეები მოვიდნენ ქეშიდან ჩვეულებრივი ბინარების სახით, Tuist აფრთხილებს, რომ მათი დაფარვა არ იზომება.
TUIST_COVERAGE_ENABLED გარემოს ცვლადი (1 ან 0) აქვს უპირატესობა coverage: .coverage(enabled:)-ზე. დააყენეთ ის მთლიანი გარემოსთვის, მაგალითად CI სამუშაო ნაკადისთვის, და არა ერთი ბრძანებისთვის, რათა ბრძანებები, რომლებიც აცხელებენ ქეშს და ისინი, რომლებიც კითხულობენ მას, შეთანხმდნენ.
prefixMapping (იხილეთ Xcode ქეში) აქვს საკუთარი გადაფარვა: TUIST_COVERAGE_PREFIX_MAPPING გარემოს ცვლადი (1 ან 0) აქვს უპირატესობა coverage: .coverage(prefixMapping:)-ზე.
გამორთვაზე გადაფარვა კითხულობს ჩვეულებრივ ვარიანტს, რომელსაც ქეში, რომელიც გაცხელებულია ჩართული დაფარვით, არ ავსებს, ასე რომ ეს სამიზნეები იგება წყაროდან. Release გაცხელება ყოველთვის აცხელებს ჩვეულებრივ ბინარებს.
enabled და prefixMapping ცვლიან თქვენი პროექტის სამიზნეების აგების პარამეტრებსა და ქეშის გასაღებებს, და მისი ტესტის სამიზნეების შერჩევითი ტესტირების ჰეშებს. დააყენეთ ისინი იგივე მნიშვნელობაზე ყოველ მანქანაზე, რომელიც იზიარებს ქეშს, და არ მიიღოთ ისინი გარემოდან (მაგალითად Environment.isCI-დან): მნიშვნელობა, რომელიც განსხვავდება CI-სა და ადგილობრივ მანქანებს შორის, აძლევს მათ სხვადასხვა გასაღებებს. იგივე ეხება გარემოს ცვლადებს: გაშვება TUIST_COVERAGE_ENABLED=0-ით არ იყენებს ხელახლა ბინარებს ან შერჩევითი ტესტირების შედეგებს გაშვებებიდან ჩართული დაფარვით.
გაითვალისწინეთ:
- ინსტრუმენტული ბინარები უფრო დიდია: დაახლოებით 20–30%-ით სტატიკური არქივებისა და დინამიური ბიბლიოთეკებისთვის. Debug აგებები მუშაობენ იგივე სიჩქარით.
- Xcode-ის დაფარვის ანგარიში არასდროს აჩვენებს კოდს, რომელიც მოვიდა ქეშიდან, ამ პარამეტრით თუ მის გარეშე. Tuist-ის დაფარვის ატვირთვა ზომავს მას. იმისთვის, რომ ნახოთ სამიზნის დაფარვა Xcode-ში, ფოკუსირება გააკეთეთ მასზე
tuist generate <target>-ით, რათა ის აიგოს წყაროდან.
პრობლემების გადაჭრა#
ის არ იყენებს ბინარებს ჩემი სამიზნეებისთვის#
დარწმუნდით, რომ ჰეშები დეტერმინისტულია გარემოებსა და გაშვებებს შორის. ეს შეიძლება მოხდეს, თუ პროექტს აქვს მითითებები გარემოზე, მაგალითად აბსოლუტური გზების მეშვეობით. შეგიძლიათ გამოიყენოთ diff ბრძანება, რათა შეადაროთ პროექტები, რომლებიც გენერირებულია tuist generate-ის ორი თანმიმდევრული გამოძახებით ან გარემოებსა თუ გაშვებებს შორის.
ასევე დარწმუნდით, რომ სამიზნე არ არის დამოკიდებული პირდაპირ ან ირიბად არაქეშირებად სამიზნეზე.
აკლია სიმბოლოები#
წყაროების გამოყენებისას, Xcode-ის აგების სისტემას, Derived Data-ს მეშვეობით, შეუძლია გადაწყვიტოს დამოკიდებულებები, რომლებიც ცალსახად არ არის გამოცხადებული. თუმცა, როდესაც ეყრდნობით ბინარულ ქეშს, დამოკიდებულებები უნდა იყოს ცალსახად გამოცხადებული; წინააღმდეგ შემთხვევაში, სავარაუდოდ, ნახავთ კომპილაციის შეცდომებს, როდესაც სიმბოლოებს ვერ იპოვით. ამის დასადიაგნოსტიკებლად, გირჩევთ გამოიყენოთ tuist inspect dependencies --only implicit ბრძანება და დააყენოთ ის CI-ში, რათა თავიდან აიცილოთ რეგრესიები არაცხად ბმებში.