Lane — bu nima, Fastlane-da yaratish va foydalanish

Fastlane-da Lane nima

Lane — bu Fastlane-ning asosiy qurilish bloki bo'lib, nomlangan avtomatlashtirish ssenariysini belgilaydi. Har bir lane ma'lum bir maqsadga erishish uchun bajariladigan harakatlar (actions) ketma-ketligini tavsiflaydi: ilovani qurish, testlarni ishga tushirish, build-ni do'konga yuklash yoki muhitni sozlash. Lane Fastfile-da e'lon qilinadi va loyihaning ildiz katalogidan fastlane [lane_nomi] buyrug'i bilan ishga tushiriladi.

Lane kontseptsiyasi Ruby DSL-dan olingan va ssenariylarning o'qiluvchanligini ta'minlaydi. Dasturchi butun CI/CD jarayonini tushunarli nomlar va parametrlar bilan actions chaqiruvlari ketma-ketligi sifatida ko'radi. Lane oddiy (bitta buyruq) yoki murakkab (tarmoqlanish, sikllar, boshqa lanes-larni chaqirish) bo'lishi mumkin.

Har bir lane bajarilgandan so'ng natija qaytaradi — bajarish holati va actions-dan ma'lumotlarni o'z ichiga olgan obyekt. Natija boshqa lanes-larda ishlatilishi yoki qaror qabul qilish uchun CI/CD tizimiga uzatilishi mumkin. Agar lane-dagi biron bir action xato bilan tugasa, lane bajarilishi to'xtatiladi va error bloki chaqiriladi.

Lane sintaksisi: e'lon qilish va ishga tushirish

Lane e'lon qilish sintaksisi oddiy Ruby DSL namunasiga asoslanadi: lane kalit so'zi, Ruby simvoli (symbol) shaklidagi ssenariy nomi, do ... end bloki ssenariy tanasi bilan. Lane nomi platforma ichida noyob bo'lishi va harflar, raqamlar va pastki chiziqlardan iborat bo'lishi kerak.

Lane-ni ishga tushirish buyruq satri orqali amalga oshiriladi: fastlane build (:build nomli lane uchun) yoki bundle exec fastlane build (agar Fastlane Bundler orqali o'rnatilgan bo'lsa). Platforma lanes-lari uchun fastlane ios build yoki fastlane android build dan foydalaning.

# Oddiy lane e’lon qilish
lane :test do
  scan(scheme: 'App', devices: ['iPhone 15'])
end

lane :build_and_deploy do
  cocoapods
  test
  gym(scheme: 'App', export_method: 'app-store')
  pilot(skip_waiting_for_build_processing: true)
end

# Ishga tushirish: fastlane build_and_deploy

Lane parametrlar yoki muhit o'zgaruvchilariga asoslangan shartli mantiq ni o'z ichiga olishi mumkin. Muayyan shartlarda qadamlarni o'tkazib yuborish uchun if/unless dan foydalaning. Bir lane-da bir nechta target yoki ilova sxemalarini qurish uchun qulay bo'lgan massivlarni qayta ishlash uchun each sikllari ham mavjud.

Lane-dan qiymat qaytarish

Lane chaqiruvchi kod uchun mavjud bo'ladigan qiymatni qaytarishi mumkin. Qaytarish uchun oddiy Ruby return yoki lane blokidagi oxirgi ifoda ishlatiladi. Qaytarilgan qiymat satr, raqam, hash yoki action natijasi bo'lishi mumkin. Bu bir lane natijasini qaror qabul qilish uchun boshqa lane-da ishlatish imkonini beradi.

Masalan, :get_version lane-i Info.plist-dan ilovaning joriy versiyasini qaytarishi mumkin, :deploy lane-i esa Slack-da xabar yaratish uchun undan foydalanishi mumkin. Qaytarilgan qiymatlar ayniqsa private lanes-larda foydali bo'lib, bu erda natija chaqiruvchi lane-da keyingi qayta ishlash uchun kerak bo'ladi.

Lanes parametrlari: uzatish va boshqarish

Lane parametrlari ssenariylarni moslashuvchan va qayta foydalanish mumkin qiladi. Lane buyruq satridan ishga tushirilganda uzatiladigan options hash orqali parametrlarni qabul qiladi: fastlane deploy scheme:AppStore version:2.1.0. Lane ichida parametrlar options[:scheme] va options[:version] sifatida mavjud.

Majburiy parametrlar uchun lane boshida qiymat mavjudligini tekshiring va aniq xabar bilan UI.user_error! chaqiring. Ixtiyoriy parametrlar uchun || operatori orqali standart qiymatlarni o'rnating. Fastlane shuningdek options metodi orqali turni, standart qiymatni va tavsifni ko'rsatish bilan tiplangan parametrlarni qo'llab-quvvatlaydi.

# Parametrlarni boshqarish bilan Lane
lane :deploy do |options|
  scheme = options[:scheme]
  version = options[:version] || '1.0.0'
  beta = options[:beta] || false

  UI.user_error!("scheme ko‘rsatilmagan") unless scheme

  match(type: beta ? 'adhoc' : 'appstore')
  gym(scheme: scheme, export_method: beta ? 'ad-hoc' : 'app-store')

  if beta
    pilot(distribute_external: true)
  else
    deliver(submit_for_review: true)
  end
end

# Ishga tushirish: fastlane deploy scheme:MyApp beta:true version:2.1.0

Lane ichida muhit o'zgaruvchilari bilan ishlash uchun ENV['VARIABLE_NAME'] dan foydalaning. Fastlane avtomatik ravishda fastlane katalogidan .env fayllarini yuklaydi. Bu maxfiy ma'lumotlarni — API kalitlari, parollar va tokenlar — Fastfile-da saqlamasdan CI/CD muhitida uzatishning standart usulidir.

Parametrlarni validatsiya qilish

Lane ishonchli ishlashi uchun kirishda parametrlarni validatsiya qilish zarur. Majburiy parametr yo'q bo'lsa yoki noto'g'ri turda bo'lsa, muammo tavsifi bilan UI.user_error! dan foydalaning. Fastlane har bir parametr uchun turni (String, Boolean, Integer, Array), standart qiymatni va tavsifni belgilash imkonini beruvchi options metodini taqdim etadi — validatsiya lane ishga tushirilganda avtomatik ravishda amalga oshiriladi.

Qo'shimcha ravishda, matn parametrlari uchun verify bloki orqali tekshirishlardan foydalanish mumkin: verify do |value| value.length > 0 end. Noto'g'ri formatda Fastlane kutilgan format va uzatilgan qiymatni ko'rsatadigan o'qiladigan xabarni chiqaradi, bu CI/CD muhitida disk raskadrovka jarayonini osonlashtiradi.

Lanes-larni birlashtirish: before_all, after_all va xatolarni boshqarish

Fastlane har bir lane-dan oldin va keyin kodni bajarish uchun hayotiy tsikl hooklari ni taqdim etadi. before_all bloki ma'lum platformada yoki global ravishda har bir lane-dan oldin bajariladi. after_all bloki lane muvaffaqiyatli tugagandan so'ng bajariladi. error bloki lane ichidagi har qanday xato paytida bajariladi.

Hooklar takrorlanadigan mantiqni markazlashtirishga imkon beradi: before_all-da bog'liqliklarni o'rnatish, after_all-da bildirishnomalar yuborish, error blokida vaqtinchalik fayllarni tozalash va xato haqida xabar berish. Bu kod takrorlanishini kamaytiradi va lanes-larni toza qiladi.

# Lanes hayotiy tsikli hooklari
default_platform(:ios)

before_all do
  cocoapods(try_repo_update_on_error: true)
  ensure_git_status_clean
end

after_all do |lane|
  slack(message: "Lane #{lane} muvaffaqiyatli bajarildi")
end

error do |lane, exception|
  slack(
    message: "Lane #{lane} xato bilan tugadi: #{exception}",
    success: false
  )
end

lane :deploy do
  match(type: 'appstore')
  gym(export_method: 'app-store')
  deliver
end

Error bloki ikkita argument qabul qiladi: lane nomi (symbol) va istisno obyekti. Blok ichida Slack-ga bildirishnoma yuborishingiz, faylga log yozishingiz yoki muqobil tiklash ssenariysini ishga tushirishingiz mumkin. Agar error bloki muvaffaqiyatli tugasa, Fastlane qurilishni CI/CD darajasida muvaffaqiyatsiz deb hisoblamaydi.

Private lanes va qayta foydalanish

Private lane — lane o'rniga private_lane orqali e'lon qilingan, mavjud buyruqlar ro'yxatida ko'rinmaydigan va to'g'ridan-to'g'ri terminaldan ishga tushirilmaydigan lane-dir. Private lanes bir nechta public lanes-lardan chaqiriladigan takrorlanadigan qadamlarni inkapsulyatsiya qilish uchun mo'ljallangan.

Private lanes ayniqsa qat'iy belgilangan tartibda bajarilishi kerak bo'lgan murakkab ketma-ketliklar uchun foydalidir. Masalan, private lane :setup_signing :build_dev, :build_staging va :build_production lanes-laridan turli parametrlar bilan chaqirilishi mumkin, lekin o'z-o'zidan alohida buyruq sifatida ma'noga ega emas.

# Qayta foydalanish uchun Private lanes
private_lane :setup_environment do |options|
  cocoapods(try_repo_update_on_error: true)
  match(type: options[:type], readonly: true)
  increment_build_number
end

lane :dev_build do
  setup_environment(type: 'development')
  gym(export_method: 'development')
end

lane :appstore_build do
  setup_environment(type: 'appstore')
  gym(export_method: 'app-store')
  deliver
end

Private lanes boshqa private lanes-larni chaqirib, abstraksiya iyerarxiyasini yaratishi mumkin. Fastfile o'qiluvchanligini saqlash uchun ichki joylashish chuqurligini 2-3 daraja bilan cheklash tavsiya etiladi. Har bir private lane-ni maqsadi va kutilgan parametrlari tavsifi bilan sharhlar bilan hujjatlashtiring.

iOS va Android uchun lanes misollari

iOS va Android loyihalari uchun amaliy misollarni ko'rib chiqamiz. iOS lanes odatda testlar uchun scan, sertifikatlar uchun match, qurish uchun gym va yetkazib berish uchun pilot yoki deliver dan foydalanadi. Android lanes qurish uchun gradle, nashr qilish uchun supply va bulutli test uchun firebase_test_lab dan foydalanadi.

// iOS ilovasi uchun to‘liq CI/CD Lane
lane :ci_full_ios do
  scan(scheme: 'App', code_coverage: true)
  gym(scheme: 'App', export_method: 'app-store')
  pilot(distribute_external: true)
  slack(message: 'iOS CI/CD muvaffaqiyatli yakunlandi')
end

/* Android ilovasi uchun to‘liq CI/CD Lane */
lane :ci_full_android do
  gradle(task: 'testReleaseUnitTest')
  gradle(task: 'bundleRelease')
  supply(track: 'internal')
end

iOS va Android uchun lanes-larni birlashtirib, kross-platforma ilovasi uchun yagona CI/CD jarayonini yaratishingiz mumkin. Platforma-spesifik lanes-larni guruhlash uchun platform :ios va platform :android platforma bloklaridan foydalaning va ularni bajarish tartibini boshqaradigan umumiy orchestrator lane-dan chaqiring.

Lanes yozishning eng yaxshi amaliyotlari

Lanes yozishda ssenariylarning o'qiluvchanligi, davomiyligi va ishonchliligini ta'minlaydigan bir qator amaliyotlarga rioya qilish tavsiya etiladi. Birinchi qoida — har bir lane bitta vazifani bajarishi kerak. Agar lane juda ko'p ish qilsa, uni bir nechta lanes va private lanes-ga bo'ling.

Ikkinchi qoida — lanes-ni nomlash fe'l yoki fe'l iborasi bo'lishi kerak: build, deploy, test, upload_screenshots. process yoki do_all kabi mavhum nomlardan saqlaning. Lane nomida so'zlarni ajratish uchun pastki chiziqlardan foydalaning.

Uchinchi qoida — xatolarni aniq boshqaring. Muammolar haqida aniq xabarlar uchun UI.user_error! dan foydalaning. Fastline-ning standart xato xabarlariga tayanmang — dasturchiga kontekst bering: “GoogleService-Info.plist fayli topilmadi — uni loyihaga qo‘shing” “File not found” o‘rniga.

To'rtinchi qoida — lanes-ni CI/CD da ishga tushirishdan oldin lokal ravishda sinab ko'ring. Fastlane --dry-run flagi orqali dry-run rejimini qo'llab-quvvatlaydi, bu qaysi actions haqiqiy bajarilmasdan bajarilishini ko'rsatadi. Integratsiyadan oldin alohida lanes-larni izolyatsiya qilingan holda sinab ko'rish uchun fastlane run_test dan foydalaning.

Lanes-ni hujjatlashtirish

Har bir lane-ni hujjatlashtirish jamoa ishi uchun muhim amaliyotdir. Fastlane lane e'lon qilishdan oldin joylashtirilgan desc blokidan avtomatik hujjat generatsiyasini qo'llab-quvvatlaydi. Desc matni fastlane lanes va fastlane list ishga tushirilganda ko'rsatiladi, dasturchilarga Fastfile manba kodini o'qimasdan har bir ssenariyning maqsadini tushunishga yordam beradi.

Parametrlarni hujjatlashtirish uchun kutilgan qiymatlar tavsifi bilan Ruby sharhlaridan foydalaning. Fastlane fastlane generate_docs buyrug'i orqali lanes-larning to'liq ro'yxati va tavsifi bilan README.md faylini yaratishi mumkin, bu yangi jamoa a'zolarining loyihaning CI/CD jarayonlariga moslashishi uchun qulaydir.