Lane — mi ez, létrehozás és használat a Fastlane-ben

Mi az a Lane a Fastlane-ben

Lane a Fastlane alapvető építőeleme, amely egy elnevezett automatizálási forgatókönyvet határoz meg. Minden lane leírja a műveletek (actions) sorozatát, amelyek egy adott cél eléréséhez végrehajtódnak: alkalmazás építése, tesztek futtatása, build feltöltése az áruházba vagy környezet beállítása. A lane deklarálása a Fastfile-ban történik, és a fastlane [lane_név] paranccsal indítható a projekt gyökérből.

A lane koncepciója a Ruby DSL-ből származik, és olvasható forgatókönyveket biztosít. A fejlesztő az egész CI/CD folyamatot action-hívások sorozataként látja átlátható nevekkel és paraméterekkel. A lane lehet egyszerű (egy parancs) vagy összetett (elágazások, ciklusok, más lane-ek hívása).

Minden lane a végrehajtás után egy eredményt ad vissza — egy objektumot, amely tartalmazza a végrehajtás állapotát és az action-ok adatait. Az eredmény felhasználható más lane-ekben vagy továbbadható a CI/CD rendszernek döntéshozatalhoz. Ha bármelyik action meghiúsul a lane-ben, a lane végrehajtása leáll, és az error blokk kerül meghívásra.

Lane szintaxis: deklarálás és indítás

A lane deklarációs szintaxisa egyszerű Ruby DSL mintát követ: a lane kulcsszó, a forgatókönyv neve Ruby szimbólumként (symbol), és egy do ... end blokk a forgatókönyv törzsével. A lane neve egyedinek kell lennie a platformon belül, és betűkből, számokból és aláhúzásokból állhat.

A lane indítása parancssorból történik: fastlane build (:build nevű lane esetén) vagy bundle exec fastlane build (ha a Fastlane Bundleren keresztül van telepítve). Platform-specifikus lane-ekhez használja a fastlane ios build vagy fastlane android build parancsot.

# Egyszerű lane deklarálása
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

# Futtatás: fastlane build_and_deploy

A lane tartalmazhat feltételes logikát paraméterek vagy környezeti változók alapján. Használjon if/unless utasításokat a lépések kihagyásához bizonyos feltételek mellett. Az each ciklusok is elérhetők tömbök feldolgozásához, ami hasznos több célplatform vagy alkalmazásséma egy lane-ben történő építéséhez.

Érték visszaadása lane-ből

A Lane visszaadhat egy értéket, amely elérhető lesz a hívó kód számára. A visszaadáshoz használja a szokásos Ruby return utasítást vagy az utolsó kifejezést a lane blokkban. A visszaadott érték lehet string, szám, hash vagy egy action eredménye. Ez lehetővé teszi, hogy az egyik lane eredményét egy másik lane döntéshozatalhoz használja.

Például a :get_version lane visszaadhatja az alkalmazás aktuális verzióját az Info.plist-ből, és a :deploy lane felhasználhatja azt egy Slack üzenet összeállításához. A visszaadott értékek különösen hasznosak private lane-ekben, ahol az eredményre szükség van a további feldolgozáshoz a hívó lane-ben.

Lane-ek paraméterei: átadás és feldolgozás

A lane paraméterei rugalmas és újrafelhasználható forgatókönyveket tesznek lehetővé. A lane paramétereket az options hash-en keresztül fogadja, amely a parancssorból történő indításkor kerül átadásra: fastlane deploy scheme:AppStore version:2.1.0. A lane-en belül a paraméterek options[:scheme] és options[:version] formában érhetők el.

Kötelező paraméterek esetén ellenőrizze az érték meglétét a lane elején, és hívja meg a UI.user_error!-t egyértelmű üzenettel. Opcionális paraméterekhez adjon meg alapértelmezett értékeket a || operátorral. A Fastlane típusos paramétereket is támogat az options metódussal, amely típust, alapértelmezett értéket és leírást ad meg.

# Lane paraméterfeldolgozással
lane :deploy do |options|
  scheme = options[:scheme]
  version = options[:version] || '1.0.0'
  beta = options[:beta] || false

  UI.user_error!("Nincs megadva scheme") 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

# Futtatás: fastlane deploy scheme:MyApp beta:true version:2.1.0

Környezeti változókkal való munkához a lane-en belül használja az ENV['VARIABLE_NAME'] utasítást. A Fastlane automatikusan betölti a .env fájlokat a fastlane könyvtárból. Ez a szabványos módszer érzékeny adatok — API-kulcsok, jelszavak és tokenek — átadására CI/CD környezetben anélkül, hogy a Fastfile-ban tárolná őket.

Paraméterek érvényesítése

A megbízható lane működéshez elengedhetetlen a paraméterek érkezéskor történő érvényesítése. Használja a UI.user_error! utasítást a probléma leírásával, ha egy kötelező paraméter hiányzik vagy hibás típusú. A Fastlane options metódusa lehetővé teszi a típus (String, Boolean, Integer, Array), alapértelmezett érték és leírás megadását minden paraméterhez — az érvényesítés automatikusan megtörténik a lane indításakor.

További ellenőrzések végezhetők a verify blokkal: verify do |value| value.length > 0 end string paraméterekhez. Hibás formátum esetén a Fastlane egyértelmű üzenetet jelenít meg a várt formátummal és a megadott értékkel, ami megkönnyíti a hibakeresést CI/CD környezetben.

Lane-ek egyesítése: before_all, after_all és error kezelés

A Fastlane életciklus hookokat biztosít a kód futtatásához minden lane előtt és után. A before_all blokk minden lane előtt lefut a platformon vagy globálisan. Az after_all blokk a lane sikeres befejezése után fut le. Az error blokk bármilyen hiba esetén lefut a lane-en belül.

A hookok lehetővé teszik az ismétlődő logika központosítását: függőségek telepítése a before_all-ban, értesítések küldése az after_all-ban, ideiglenes fájlok törlése és hibákról értesítés az error blokkban. Ez csökkenti a kódismétlést és tisztábbá teszi a lane-eket.

# Lane-ek életciklus hookjai
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} sikeresen lefutott")
end

error do |lane, exception|
  slack(
    message: "Lane #{lane} hiba miatt leállt: #{exception}",
    success: false
  )
end

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

Az error blokk két argumentumot kap: a lane nevét (symbol) és a kivétel objektumot. A blokkon belül küldhet értesítést Slackbe, írhat naplót fájlba, vagy indíthat alternatív helyreállítási forgatókönyvet. Ha az error blokk sikeresen befejeződik, a Fastlane nem tekinti a buildet sikertelennek CI/CD szinten.

Private lane-ek és újrafelhasználás

A Private lane egy private_lane kulcsszóval deklarált lane (nem lane), amely nem jelenik meg az elérhető parancsok listájában és nem indítható közvetlenül a terminálból. A private lane-ek az ismétlődő lépések egységbezárására szolgálnak, amelyeket több nyilvános lane hív meg.

A private lane-ek különösen hasznosak összetett műveletsorozatokhoz, amelyeket szigorúban meghatározott sorrendben kell végrehajtani. Például a :setup_signing private lane meghívható a :build_dev, :build_staging és :build_production lane-ekből különböző paraméterekkel, de önmagában nem értelmes külön parancsként.

# Private lane-ek újrafelhasználáshoz
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

A private lane-ek más private lane-eket is meghívhatnak, absztrakciós hierarchiát alkotva. Ajánlott a beágyazási mélységet 2–3 szintre korlátozni a Fastfile olvashatóságának megőrzése érdekében. Dokumentáljon minden private lane-t megjegyzéssel, leírva célját és a várt paramétereket.

Példák lane-ekre iOS-hez és Androidhoz

Nézzünk gyakorlati példákat iOS és Android projektekhez. Az iOS lane-ek általában a scan-t használják tesztekhez, a match-et tanúsítványokhoz, a gym-et építéshez, és a pilot vagy deliver-t szállításhoz. Az Android lane-ek a gradle-t használják építéshez, a supply-t publikáláshoz és a firebase_test_lab-ot felhőteszteléshez.

// Lane teljes iOS CI/CD-hez
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 sikeresen befejeződött')
end

/* Lane teljes Android CI/CD-hez */
lane :ci_full_android do
  gradle(task: 'testReleaseUnitTest')
  gradle(task: 'bundleRelease')
  supply(track: 'internal')
end

Az iOS és Android lane-ek kombinálásával egységes CI/CD folyamatot hozhat létre keresztplatformos alkalmazásokhoz. Használja a platform :ios és platform :android blokkokat a platform-specifikus lane-ek csoportosításához, és hívja meg őket egy általános orchestrator lane-ből, amely a végrehajtási sorrendet kezeli.

Legjobb gyakorlatok lane-ek írásához

A lane-ek írásakor ajánlott egy sor gyakorlatot követni, amelyek biztosítják a forgatókönyvek olvashatóságát, karbantarthatóságát és megbízhatóságát. Az első szabály — minden lane egyetlen feladatot végezzen. Ha egy lane túl sokat csinál, bontsa fel több lane-re és private lane-re.

A második szabály — a lane-ek elnevezése igei vagy igés kifejezés legyen: build, deploy, test, upload_screenshots. Kerülje az absztrakt neveket, mint process vagy do_all. Használjon aláhúzást a szavak elválasztásához a lane nevében.

A harmadik szabály — kezelje a hibákat explicit módon. Használja a UI.user_error! utasítást egyértelmű problémaleírásokhoz. Ne támaszkodjon a Fastlane alapértelmezett hibüzeneteire — adjon kontextust a fejlesztőnek: „Nem található a GoogleService-Info.plist fájl — adja hozzá a projekthez” a „File not found” helyett.

A negyedik szabály — tesztelje a lane-eket lokálisan, mielőtt CI/CD-n futtatná őket. A Fastlane támogatja a dry-run módot a --dry-run kapcsolóval, amely megmutatja, hogy mely action-ok fognak lefutni a tényleges futtatás nélkül. Használja a fastlane run_test parancsot az egyes lane-ek elkülönített teszteléséhez az integráció előtt.

Lane-ek dokumentálása

Minden lane dokumentálása fontos gyakorlat a csapatfejlesztésben. A Fastlane támogatja a dokumentáció automatikus generálását a lane deklarációja elé helyezett desc blokkból. A desc szövege megjelenik a fastlane lanes és fastlane list parancsok futtatásakor, segítve a fejlesztőket az egyes forgatókönyvek céljának megértésében a Fastfile forráskódjának olvasása nélkül.

A paraméterek dokumentálásához használjon Ruby megjegyzéseket a várt értékek leírásával. A Fastlane README.md fájlt generálhat a lane-ek teljes listájával és leírásával a fastlane generate_docs parancs segítségével, ami hasznos az új csapattagok projekt CI/CD folyamataiba történő bevezetéséhez.