Lane — ano ito, paggawa at paggamit sa Fastlane

Ano ang Lane sa Fastlane

Lane ay ang pangunahing building block ng Fastlane na tumutukoy sa isang pinangalanang automation scenario. Bawat lane ay naglalarawan ng isang serye ng mga aksyon (actions) na isinasagawa upang maabot ang isang tiyak na layunin: bumuo ng app, magpatakbo ng mga pagsubok, mag-upload ng build sa store, o mag-configure ng kapaligiran. Lane ay idineklara sa Fastfile at pinapatakbo gamit ang command na fastlane [pangalan_lane] mula sa root ng proyekto.

Ang konsepto ng lane ay nagmula sa Ruby DSL at nagbibigay ng kakayahang mabasa ng scenario. Nakikita ng developer ang buong proseso ng CI/CD bilang isang serye ng mga tawag sa actions na may malinaw na pangalan at parameter. Maaaring simple ang lane (isang command) o kumplikado (mga branching, loops, pagtawag ng iba pang lanes).

Bawat lane pagkatapos ng pagpapatupad ay nagbabalik ng resulta — isang bagay na naglalaman ng status ng pagpapatupad at data mula sa actions. Ang resulta ay maaaring gamitin sa iba pang lanes o ipasa sa CI/CD system para sa paggawa ng desisyon. Kung ang anumang action sa lane ay nabigo, ang pagpapatupad ng lane ay hihinto at ang bloke ng error ay tatawagin.

Syntax ng lane: deklarasyon at pagpapatakbo

Ang syntax ng deklarasyon ng lane ay sumusunod sa simpleng pattern ng Ruby DSL: ang keyword na lane, ang pangalan ng scenario bilang Ruby symbol (symbol), at isang bloke na do ... end na may nilalaman ng scenario. Ang pangalan ng lane ay dapat na natatangi sa loob ng platform at binubuo ng mga titik, numero, at underscore.

Ang pagpapatakbo ng lane ay ginagawa sa pamamagitan ng command line: fastlane build (para sa lane na may pangalang :build) o bundle exec fastlane build (kung ang Fastlane ay naka-install sa pamamagitan ng Bundler). Para sa platform-specific lanes gamitin ang fastlane ios build o fastlane android build.

# Deklarasyon ng simpleng lane
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

# Pagpapatakbo: fastlane build_and_deploy

Maaaring maglaman ang Lane ng conditional logic batay sa mga parameter o environment variable. Gamitin ang if/unless para laktawan ang mga hakbang sa ilalim ng tiyak na kondisyon. Available din ang each loops para sa pagproseso ng arrays, na kapaki-pakinabang para sa pagbuo ng maraming target o scheme ng app sa isang lane.

Pagbabalik ng halaga mula sa lane

Lane ay maaaring magbalik ng halaga na magagamit ng tumatawag na code. Para sa pagbabalik, gamitin ang normal na Ruby return o ang huling expression sa bloke ng lane. Ang ibinalik na halaga ay maaaring string, numero, hash, o resulta ng action. Pinapayagan nito ang resulta ng isang lane na magamit sa ibang lane para sa paggawa ng desisyon.

Halimbawa, ang lane :get_version ay maaaring magbalik ng kasalukuyang bersyon ng app mula sa Info.plist, at ang lane :deploy ay maaaring gamitin ito para sa pagbuo ng mensahe sa Slack. Ang mga ibinalik na halaga ay lalong kapaki-pakinabang sa private lanes, kung saan ang resulta ay kinakailangan para sa karagdagang pagproseso sa tumatawag na lane.

Parameter ng lanes: pagpasa at pagproseso

Parameter ng lane ay ginagawang flexible at reusable ang mga scenario. Ang Lane ay tumatanggap ng mga parameter sa pamamagitan ng options hash na ipinapasa kapag pinatakbo mula sa command line: fastlane deploy scheme:AppStore version:2.1.0. Sa loob ng lane, ang mga parameter ay available bilang options[:scheme] at options[:version].

Para sa kinakailangang parameter, suriin ang pagkakaroon ng halaga sa simula ng lane at tawagan ang UI.user_error! na may malinaw na mensahe. Para sa opsyonal na parameter, magtakda ng default na halaga gamit ang || operator. Sinusuportahan din ng Fastlane ang mga naka-type na parameter sa pamamagitan ng options na paraan na may uri, default na halaga, at paglalarawan.

# Lane na may parameter processing
lane :deploy do |options|
  scheme = options[:scheme]
  version = options[:version] || '1.0.0'
  beta = options[:beta] || false

  UI.user_error!("Hindi tinukoy ang 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

# Pagpapatakbo: fastlane deploy scheme:MyApp beta:true version:2.1.0

Para sa pagtatrabaho sa environment variable sa loob ng lane, gamitin ang ENV['VARIABLE_NAME']. Awtomatikong nilo-load ng Fastlane ang mga .env file mula sa direktoryo ng fastlane. Ito ang karaniwang paraan ng pagpasa ng sensitibong data — mga API key, password, at token — sa CI/CD environment nang hindi iniimbak ang mga ito sa Fastfile.

Pag-validate ng parameter

Para sa maaasahang lane, kailangan ang pag-validate ng parameter sa pagpasok. Gamitin ang UI.user_error! na may paglalarawan ng problema kung ang kinakailangang parameter ay wala o may maling uri. Nagbibigay ang Fastlane ng options na paraan na nagpapahintulot sa pagtatakda ng uri (String, Boolean, Integer, Array), default na halaga, at paglalarawan para sa bawat parameter — awtomatikong ginagawa ang pag-validate kapag pinatakbo ang lane.

Dagdag pa, maaari kang magsagawa ng mga pagsusuri sa pamamagitan ng verify bloke: verify do |value| value.length > 0 end para sa mga string parameter. Kapag maling format, nagpapakita ang Fastlane ng malinaw na mensahe na may inaasahang format at ibinigay na halaga, na pinapasimple ang debugging sa CI/CD environment.

Pagsasama ng lanes: before_all, after_all at paghawak ng error

Nagbibigay ang Fastlane ng lifecycle hooks para sa pagpapatupad ng code bago at pagkatapos ng bawat lane. Ang before_all bloke ay isinasagawa bago ang bawat lane sa platform o globally. Ang after_all bloke ay isinasagawa pagkatapos ng matagumpay na pagkumpleto ng lane. Ang error bloke ay isinasagawa sa anumang error sa loob ng lane.

Pinapayagan ng Hooks ang pagsentralisa ng paulit-ulit na lohika: pag-install ng dependencies sa before_all, pagpapadala ng mga notification sa after_all, paglilinis ng mga pansamantalang file at pag-notify tungkol sa mga error sa error bloke. Binabawasan nito ang pagdoble ng code at ginagawang mas malinis ang lanes.

# Lifecycle hooks ng lanes
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} ay nagtagumpay")
end

error do |lane, exception|
  slack(
    message: "Lane #{lane} ay nabigo sa error: #{exception}",
    success: false
  )
end

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

Ang error bloke ay tumatanggap ng dalawang argumento: pangalan ng lane (symbol) at ang exception object. Sa loob ng bloke, maaari kang magpadala ng notification sa Slack, magsulat ng log sa file, o magpatakbo ng alternatibong recovery scenario. Kung ang error bloke ay matagumpay na natapos, hindi itinuturing ng Fastlane na nabigo ang build sa antas ng CI/CD.

Private lanes at muling paggamit

Private lane ay isang lane na idineklara gamit ang private_lane sa halip na lane, hindi lumalabas sa listahan ng mga available na command at hindi maaaring direktang patakbuhin mula sa terminal. Ang Private lanes ay idinisenyo para sa encapsulation ng paulit-ulit na hakbang na tinatawag mula sa maraming pampublikong lanes.

Ang Private lanes ay lalong kapaki-pakinabang para sa kumplikadong pagkakasunod-sunod ng mga aksyon na dapat isagawa sa mahigpit na tinukoy na pagkakasunud-sunod. Halimbawa, ang private lane :setup_signing ay maaaring tawagin mula sa lanes :build_dev, :build_staging at :build_production na may iba’t ibang parameter, ngunit hindi makabuluhan bilang isang hiwalay na command.

# Private lanes para sa muling paggamit
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

Ang Private lanes ay maaaring tumawag ng iba pang private lanes, na bumubuo ng hierarchy ng abstraction. Inirerekomenda na limitahan ang lalim ng nesting sa 2–3 level upang mapanatili ang pagiging nababasa ng Fastfile. Dokumentuhan ang bawat private lane ng komentaryo na may paglalarawan ng layunin nito at inaasahang parameter.

Halimbawa ng lanes para sa iOS at Android

Tingnan natin ang praktikal na halimbawa ng lanes para sa iOS at Android projects. Ang iOS lanes ay karaniwang gumagamit ng scan para sa pagsubok, match para sa mga sertipiko, gym para sa pagbuo, at pilot o deliver para sa paghahatid. Ang Android lanes ay gumagamit ng gradle para sa pagbuo, supply para sa publikasyon, at firebase_test_lab para sa cloud testing.

// Lane para sa buong CI/CD ng iOS app
lane :ci_full_ios do
  scan(scheme: 'App', code_coverage: true)
  gym(scheme: 'App', export_method: 'app-store')
  pilot(distribute_external: true)
  slack(message: 'Matagumpay na natapos ang iOS CI/CD')
end

/* Lane para sa buong CI/CD ng Android app */
lane :ci_full_android do
  gradle(task: 'testReleaseUnitTest')
  gradle(task: 'bundleRelease')
  supply(track: 'internal')
end

Sa pamamagitan ng pagsasama ng lanes para sa iOS at Android, maaari kang lumikha ng pinag-isang proseso ng CI/CD para sa cross-platform na app. Gamitin ang platform blocks na platform :ios at platform :android para sa pagpapangkat ng platform-specific lanes, at tawagan ang mga ito mula sa isang pangkalahatang orchestrator lane na namamahala sa pagkakasunud-sunod ng pagpapatupad.

Pinakamahusay na kasanayan sa pagsulat ng lanes

Sa pagsulat ng lanes, inirerekomenda na sundin ang isang hanay ng mga kasanayan na nagsisiguro ng pagiging nababasa, pagiging mapanatili, at pagiging maaasahan ng mga scenario. Unang panuntunan — bawat lane ay dapat magsagawa ng isang gawain. Kung ang lane ay gumagawa ng sobra, hatiin ito sa maraming lanes at private lanes.

Ikalawang panuntunan — pagpapangalan ng lanes ay dapat na pandiwa o pariralang pandiwa: build, deploy, test, upload_screenshots. Iwasan ang mga abstract na pangalan tulad ng process o do_all. Gumamit ng underscore para sa paghihiwalay ng mga salita sa pangalan ng lane.

Ikatlong panuntunan — hawakan ang mga error nang tahasan. Gamitin ang UI.user_error! para sa malinaw na mensahe tungkol sa mga problema. Huwag umasa sa karaniwang mga mensahe ng error ng Fastlane — bigyan ang developer ng konteksto: “Hindi natagpuan ang file na GoogleService-Info.plist — idagdag ito sa proyekto” sa halip na “File not found”.

Ikaapat na panuntunan — subukan ang lanes nang lokal bago patakbuhin sa CI/CD. Sinusuportahan ng Fastlane ang dry-run mode sa pamamagitan ng --dry-run flag, na nagpapakita kung aling actions ang isasagawa nang hindi aktwal na pinapatakbo ang mga ito. Gamitin ang fastlane run_test para sa isolated na pagsubok ng mga indibidwal na lanes bago ang integrasyon.

Pagdodokumento ng lanes

Ang pagdodokumento ng bawat lane ay isang mahalagang kasanayan para sa pag-unlad ng koponan. Sinusuportahan ng Fastlane ang awtomatikong pagbuo ng dokumentasyon mula sa desc bloke na inilalagay bago ang deklarasyon ng lane. Ang teksto ng desc ay ipinapakita kapag pinatakbo ang fastlane lanes at fastlane list, na tumutulong sa mga developer na maunawaan ang layunin ng bawat scenario nang hindi binabasa ang source code ng Fastfile.

Para sa pagdodokumento ng mga parameter, gamitin ang Ruby comments na may paglalarawan ng inaasahang halaga. Fastlane ay maaaring bumuo ng README.md na may kumpletong listahan ng lanes at kanilang paglalarawan sa pamamagitan ng command na fastlane generate_docs, na kapaki-pakinabang para sa pag-adapt ng mga bagong miyembro ng koponan sa mga proseso ng CI/CD ng proyekto.