Գնահատել նախագիծը
← Բոլոր հրապարակումները

Առաջին քայլերը ZIO-ի հետ, մաս 1

Ծանոթացեք ZIO-ին՝ հզոր Scala գրադարանին, որը հեշտացնում է ասինխրոն և համաժամանակյա (concurrent) հավելվածների ստեղծումը։

15 րոպե
ScalaApache KafkaZioԿախվածություններ

Բարև։ Այս գրառմամբ սկսվում է ZIO-ին նվիրված շարք. ZIO-ն հզոր Scala գրադարան է, որը հեշտացնում է ասինխրոն և concurrent հավելվածների մշակումը։ Շարքի ընթացքում քայլ առ քայլ ցույց կտամ, թե ինչպես օգտագործել ZIO ֆրեյմվորքի տարբեր շինանյութերը՝ լիարժեք աշխատող հավելված ստեղծելու համար, որպեսզի դուք ստանաք ZIO-ի հնարավորությունների ամուր պատկերացում։ Շարքի ողջ ընթացքում մենք կաշխատենք ZIO-ի 2-րդ տարբերակի հետ։

Օգտագործելով այս հավելվածը որպես օրինակ՝ ես ցույց կտամ, թե ինչպես գրել ZIO սերվիսներ, կառուցել արդյունավետ streaming աշխատանքային հոսքեր, գործարկել HTTP սերվեր web socket-ներով, լուծել concurrency խնդիրները Software Transactional Memory-ով (STM) և համապատասխան տվյալների կառուցվածքներով, կարգավորել ZIO հավելվածը և, իհարկե, թեստավորել այն։

Ի՞նչ ենք կառուցելու

Համատեքստ

Դուք, ամենայն հավանականությամբ, լսել եք Kafka-ի մասին, այնպես չէ՞։ Եթե ոչ, խորհուրդ եմ տալիս այս շարքին անցնելուց առաջ կարդալ մի փոքր հիմնական տեղեկություն։ Մի խոսքով, դա streaming պլատֆորմ է, որը թույլ է տալիս հրապարակել (գրել), պահել և բաժանորդագրվել (կարդալ) իրադարձություններին։

Kafka օգտագործող հավելվածների ճարտարապետություններում այն սովորաբար ներքին բաղադրիչ է, որը գտնվում է ինչ-որ VPC-ի ներսում և թաքնված է արտաքին աշխարհից։ Դա, իհարկե, հենց այն կառուցվածքն է, որ մենք ուզում ենք. այն արգելափակում է չարտոնված մուտքը Kafka Broker-ներին և պաշտպանում է մեր տվյալները չարամիտ կամ պարզապես պատահական գործողություններից։ Այդուհանդերձ, հեշտ է պատկերացնել իրավիճակ, երբ կցանկանայինք, որ հաճախորդները կարողանան կարդալ տվյալների մի մասը։

Ենթադրենք՝ մենք կառուցում ենք պլատֆորմ, որտեղ հաճախորդները (այսինքն՝ արտաքին համակարգերը) վերբեռնում են տվյալներ։ Պլատֆորմի ներսում մենք այդ տվյալների վրա կատարում ենք տարբեր ասինխրոն հաշվարկներ՝ ստանալով ծանուցումներ, որոնք պահվում են պլատֆորմի ներքին Kafka topic-ներում։ Ասենք՝ այդ ծանուցումները պետք է կիսենք մեր հաճախորդների հետ, քանի որ նրանք այդ տեղեկատվության վրա են հենվում սեփական աշխատանքային հոսքը սկսելու կամ շարունակելու համար։ Մենք պետք է փոխանցենք մեր ենթակառուցվածքում փակ topic-ներում պահվող ներքին ծանուցումները, ընդ որում՝ իրական ժամանակում. յուրաքանչյուր նոր ծանուցում պետք է անմիջապես հասնի բաժանորդագրված հաճախորդներին։

Սա պահանջում է միջանկյալ բաղադրիչ (middleware), և հենց այն էլ մենք կկառուցենք։ Նպատակն է ներքին topic-ներից իրադարձությունները հոսքով փոխանցել բաժանորդագրված արտաքին հաճախորդներին։ Նկատի ունեցեք, որ քանի որ հավելվածը կրթական նպատակ ունի, այն պարունակում է բազմաթիվ պարզեցումներ, բայց դրանից բացի կոդը production մակարդակի է։

Ընդհանուր նկարագիր

Նախքան համակարգի ակնարկին անցնելը՝ սահմանենք պահանջները։ Ենթադրենք՝ հիմնականում ուզում ենք հաճախորդին թույլ տալ «tail» անել ընտրված Kafka topic-ները։ Այլ կերպ ասած՝ հաճախորդը, որը հեռանում է և 10 րոպե անց նորից բաժանորդագրվում, չի ստանա իր բացակայության ընթացքում հրապարակված հաղորդագրությունները։ Սա պարզեցնում է իրականացումը և կոդը պահում է բավականին կարճ ու հասկանալի։ Մեր սերվիսը կանվանենք k-tail։ Այժմ պարզ դիագրամով գծենք մեր նպատակը։

k tail overview

Հավելվածը կաշխատեցնի երկու հիմնական պրոցես. առաջինը հաղորդագրություններ է կարդում Kafka-ից, երկրորդը՝ փոխանցում է դրանք բաժանորդագրված հաճախորդներին։ Անցնենք ներգրավված բաղադրիչներով՝ սկսելով աջից։

Նախ՝ մեզ պետք է consumer օրինակ, որը շարունակաբար կարդում է նոր հաղորդագրություններ նախապես կարգավորված topic-ների բազմությունից։ Այդ հաղորդագրությունները ժամանակավորապես պահվում են buffer-ում։ Buffer-ի շնորհիվ հաղորդագրությունների կարդալը և փոխանցելը կարող են կատարվել իրարից անկախ, ինչը մեզ ճկունություն է տալիս արագության և սխալների մշակման առումով։ Վերջում մեզ պետք է բաղադրիչ, որի խնդիրն է հաղորդագրությունները փոխանցել հաճախորդներին։ Այն կանվանենք broadcast։

Միասին վերցրած՝ այս բաղադրիչները կազմում են web socket սերվեր, որը թույլ է տալիս հաճախորդներին միանալ և իրական ժամանակում ստանալ նոր տվյալներ։

Պլան

Getting started with ZIO շարքը բաղկացած է երեք մասից, որոնցում մենք ուսումնասիրում ենք ZIO-ի հասկացությունները՝ իրականացնելով մեր հավելվածը։

Առաջին մասը (այն գրառումը, որը կարդում եք) կենտրոնանում է buffer և consumer բաղադրիչների իրականացման վրա. հիմնական նպատակն է ընտելանալ ZIO-ի տիպերին և սովորել, թե ինչպես ստեղծել սերվիսներ ու կառավարել կախվածությունները։

Երկրորդ մասը ներառում է broadcast և server բաղադրիչների իրականացումը։ Մենք կանդրադառնանք concurrency-ի որոշ մարտահրավերների՝ ZIO-ի շինանյութերով, և կսովորենք, թե ինչպես գործարկել web socket սերվեր։

Երրորդ մասն ամբողջությամբ թեստավորման մասին է։ Մենք կօգտագործենք ZIO-ի թեստավորման գրադարանը՝ test container-ների հետ միասին։

Էֆեկտներ

Եթե նախկինում Scala կոդ եք գրել, ապա հավանաբար հանդիպել եք էֆեկտներ եզրույթին։ Դրանք սովորաբար նկարագրվում են որպես զուգահեռ հաշվարկների, concurrency-ի կամ I/O-ի մշակման եղանակ մեր հավելվածներում։ Էֆեկտը սովորաբար ունենում է ելքային տիպի պարամետր, օրինակ՝ Future[String] կամ IO[Int], կարող է ձախողվել և կարող է կախված լինել ռեսուրսներից կամ սերվիսներից՝ աշխատելու համար։

Հաճախ այս հատկությունները պարզելու համար պետք է խորանալ և վերլուծել նման տիպերի մեթոդների կամ արժեքների իրականացման մանրամասները։ Սակայն լավ գրված ZIO կոդի դեպքում միայն տիպի ստորագրությունը երբեմն կարող է մեզ շատ ավելի շատ կարևոր տեղեկություն տալ տվյալ էֆեկտի մասին։

ZIO ֆրեյմվորքում էֆեկտը սահմանվում է որպես ZIO[-R, +E, +A] 3 տիպի պարամետրերով։ Սկզբում դա կարող է շփոթեցնող թվալ, բայց մեկ-երկու վայրկյանում պարզվում է, որ բավականին պարզ է, քանի որ այն նշանակում է ZIO[Require, Error, Output]։ Տիպը նկարագրում է հաշվարկ, որը պահանջում է R տիպի բաներ, կարող է ձախողվել E տիպի սխալով կամ կարող է տալ A տիպի հաջող արդյունք։

Ի հակադրություն՝ առանց պահանջների էֆեկտն ունի ZIO[Any, _, _] տիպը և կարող է աշխատել «ցանկացած» պայմաններում։ Նույն կերպ՝ էֆեկտը, որը երաշխավորված երբեք չի ձախողվում, ունի ZIO[_, Nothing, _] տիպը։

ZIO-ն էֆեկտները գնահատում է lazy կերպով, ուստի ZIO տիպի արժեք ստեղծելը անմիջապես չի աշխատեցնում հիմքում ընկած կոդը։ Էֆեկտները աշխատեցնելու և ծրագիրը կատարելու համար պետք է բեռնավորենք (bootstrap) մեր բաղադրիչները և կարգավորենք runtime միջավայրը։ ZIO-ն տրամադրում է compile-time ուժեղ երաշխիքներ, որոնք օգնում են ճիշտ կառուցվածքավորել և կազմակերպել կախվածությունները։ Նման հնարավորությունների օրինակներին կանդրադառնանք ավելի ուշ։

Գրադարանը առաջարկում է բազմաթիվ type alias-ներ ZIO տիպի համար։ Օրինակ՝ առանց պահանջների և ձախողվել չկարողացող էֆեկտն ունի UIO[+A] alias-ը, որը վերցնում է միայն հաջող արդյունքի տիպի պարամետրը։ Որտեղ հնարավոր է, մենք մեր հավելվածի կոդում կօգտագործենք type alias-ներ, որպեսզի դուք վարժվեք դրանց։

Սերվիսներ

ZIO տիպը ներկայացնելուց հետո անցնենք մեր առաջին սերվիսին՝ Buffer-ին։ Սերվիսներ գրելիս կան մի քանի հիմնական քայլեր և լավ պրակտիկաներ, որոնց արժե հետևել, և ես դրանք կներկայացնեմ ստորև։ Տրամաբանությունը ավելի հստակ դարձնելու համար գրառումների ողջ ընթացքում կոդի հատվածներում նաև ամբողջական տիպերը կավելացնեմ որպես մեկնաբանություններ։

Buffer-ի սահմանումը

Առաջին քայլը սերվիսի սահմանում ստեղծելն է։ Լավ պրակտիկա է, կամ նույնիսկ «օրենք»՝ դրա համար միշտ օգտագործել trait-եր և երբեք սերվիսի կախվածությունները չարտահայտել որպես միջավայրի պահանջներ հենց սահմանման մեջ։ Ի՞նչ է սա նշանակում։ Եթե մեր Buffer-ի իրականացումը կախված է մեկ այլ սերվիսից, այդ կախվածությունը չպետք է երևա որպես պահանջ սերվիսի ինտերֆեյսում։ Գրենք մեր Buffer-ի սերվիսի սահմանումը։

trait Buffer {
  def offer(message: Message): UIO[Unit] // ZIO[Any, Nothing, Unit] 
  def poll(): UIO[Option[Message]] // ZIO[Any, Nothing, Option[Message]]
}

Ո՛չ offer-ը, ո՛չ poll-ը ոչինչ չեն պահանջում, և երկուսն էլ երաշխավորված չեն ձախողվում, ուստի մենք չենք օգտագործում R (սահմանման մեջ կախվածություններ չկան) և E տիպի պարամետրերը և նշումը կարճ պահելու համար հենվում ենք type alias-ների վրա։

Ընդունված է սերվիսին տալ companion object՝ accessor մեթոդներով։ Մենք օգտագործում ենք ZIO.service[T]-ի տարբերակները՝ միջավայրից որոշակի սերվիսի օրինակներ ստանալու համար։ Սա նշանակում է, որ buffer-ի հաճախորդները պետք է սերվիսը կանչեն ZIO.service[Buffer]-ով, ապա այդ օրինակի վրա կանչեն, օրինակ, offer։ Սա կարելի է հեշտացնել՝ սահմանելով accessor մեթոդներ այսպես։

object Buffer {
  def offer(message: Message): URIO[Buffer, Unit] =
    ZIO.serviceWithZIO[Buffer](_.offer(message))

  def poll(): URIO[Buffer, Option[Message]] =
    ZIO.serviceWithZIO[Buffer](_.poll())
}

Այժմ հաճախորդները կարող են այն կանչել ավելի կարճ շարահյուսությամբ, պարզապես Buffer.offer(...), և ստացված էֆեկտի տիպը որպես միջավայրի պահանջ կկրի Buffer-ը։

Buffer-ի իրականացումը

Հաջորդը իրականացումն է։ Դիտարկենք Buffer-ի իրականացումը և խոսենք երկրորդ լավ պրակտիկայի մասին. սերվիսի կախվածությունները միշտ պետք է փոխանցվեն դասի կոնստրուկտորով։

final case class BufferImpl(queue: Queue[Message]) extends Buffer {
  override def offer(message: Message): UIO[Unit] =
    queue.offer(message).unit *> 
       ZIO.logInfo(s"buffer message ${message.id}")

  override def poll(): UIO[Option[Message]] = queue.poll
}

Buffer-ի այս իրականացումն ունի մեկ կախվածություն, որը հայտարարված է դասի կոնստրուկտորում։ Բացատրելու շատ բան չկա. այն պետք է ծանոթ թվա, քանի որ հետևում է դասական OOP ոճին։

Այդ մեկ կախվածությունը ZIO գրադարանի Queue-ն է. ասինխրոն in-memory տվյալների կառուցվածք, որի տարրեր ավելացնելու և վերցնելու գործողությունները չեն արգելափակում։ Մենք օգտագործում ենք Queue-ի անսահմանափակ տարբերակը, որը կտեսնեք, երբ Queue-ն ստեղծվի։ Հերթը ծառայում է որպես buffer, որպեսզի հաղորդագրությունները կարողանան մշակվել վերահսկվող ձևով։ Այն պահպանում է հաղորդագրությունների հերթականությունը (FIFO), ինչը սովորաբար կարևոր է Kafka-ի հետ աշխատելիս։

Երբ հաղորդագրությունը դրվում է հերթի մեջ, մենք շղթայում ենք մեկ այլ էֆեկտի կատարում՝ լոգավորման համար օգտագործելով հարմար ZIO.logInfo-ն։ Այս երկու էֆեկտները միացնելու համար օգտագործում ենք *> օպերատորը, որը flatMap-ի տարբերակ է և դեն է նետում այն էֆեկտի արդյունքը, որին կիրառվում է։

Buffer-ի կոնստրուկտորը

Երբ սերվիսի սահմանումը և իրականացումը պատրաստ են, կարող ենք անցնել կոնստրուկտորին՝ ZIO սերվիսներ ստեղծելու վերջին քայլին։ Սակայն սպասեք. Buffer-ը պարզապես case class է, ուստի արդեն ունի դասի կոնստրուկտոր։ Ճիշտ է, բայց քանի որ ուզում ենք օգտվել ZIO միջավայրի հնարավորություններից, մեր սերվիսների համար կստեղծենք այսպես կոչված layer-ներ։ Ահա թե ինչպես է դա արվում։

object BufferImpl {
  // ZLayer[Any, Nothing, Buffer]
  val live: ULayer[Buffer] = 
     ZLayer(Queue.unbounded[Message].map(BufferImpl(_)))
}

Layer-ը սովորաբար սահմանվում է իրականացման դասի companion object-ում, որն այն բարձրացնում է ZLayer-ի մեջ։ Կրկին type alias-ը արտահայտում է layer, որը լրացուցիչ պահանջներ չունի (BufferImpl-ը ոչ մի այլ սերվիսի վրա չի հենվում) և երաշխավորված չի ձախողվում ստեղծվելիս։ ZLayer.apply() մեթոդը որպես արգումենտ ընդունում է ZIO էֆեկտ, ինչը այն դարձնում է էֆեկտային կոնստրուկտոր։ Դրա շնորհիվ կարող ենք ծածկել այն դեպքերը, երբ սերվիսին ռեսուրսներ են պետք, օրինակ՝ տվյալների բազայի կապ, որի ձեռքբերումը կարող է ժամանակ պահանջել։

Layer-ները թույլ են տալիս արդյունավետ կառավարել նման սկզբնավորման գործընթացները, ինչը դժվար է ձեռք բերել սովորական դասի կոնստրուկտորներով։ Նույնիսկ Queue.unbounded կոնստրուկտորն է էֆեկտ, քանի որ այն հերթ է ստեղծում ZIO runtime-ի ներսում և վերադարձնում է UIO[Queue[Message]]։ Դրա վրա map անելը մեզ տալիս է BufferImpl օրինակ։

Consumer

Նույն կերպ, առաջին քայլը մեր Kafka consumer բաղադրիչի սերվիսի սահմանումը գրելն է։

trait KTailConsumer {
  // ZStream[Any, Throwable, Message]
  val consume: Stream[Throwable, Message]
}

Այստեղ է հանդես գալիս ZStream-ը՝ գրադարանի մեկ այլ հիմնական հասկացություն։

Կարող եք այն պատկերացնել որպես խողովակաշար (pipeline), որը տվյալներ է քաշում աղբյուրից, փոխակերպում է դրանք և արտաքսում ինչ-որ ելք։ Streams-երը կարելի է համադրել, զտել, map անել կամ reduce անել՝ ամենատարբեր խնդիրներ լուծելու համար։ Դրանք խիստ դեկլարատիվ են, ուստի հենց որ ճանաչեք, որ գործողությունը իր բնույթով «streaming» է, այն ZStream-ի իմաստաբանությամբ մոդելավորելը դառնում է հեշտ։

Kafka-ից հաղորդագրություններ կարդալը նման կիրառության հիանալի օրինակ է, քանի որ այն նկարագրում է գործընթաց, որը ստանում է մուտքային տարրեր, մշակում է դրանք, արտաքսում է որոշ արդյունքներ և շարունակում է այդպես անվերջ։

Ինչպես ZIO-ն և ZLayer-ը, ZStream-ն ունի երեք տիպի պարամետր, և դրանք նշանակում են ճիշտ նույնը։ Մեր consumer-ի սահմանումը ասում է, որ այն պետք է իրականացնի stream, որը կարող է ձախողվել exception-ով և արտաքսում է Message տիպի արժեքներ։ consume արժեքը միայն streaming pipeline-ի նկարագրություն է. դրա ստեղծումը դեռ ոչ մի մշակում չի սկսում։

Իրականացման համար մենք օգտագործում ենք zio-kafka-ն՝ ZIO ֆրեյմվորքի գրադարան, որը հեշտացնում է ZIO-ի և Kafka-ի ինտեգրումը՝ առաջարկելով պատրաստի stream սահմանումներ և տարածված օպերատորներ։ Արժե նշել, որ ZIO-ն տրամադրում է գրադարանների լայն շարք հավելվածների տիպային գործողությունների համար, ինչպիսիք են տարբեր տվյալների բազաներին հասանելիությունը, մետրիկաները և JSON-ի աջակցությունը։ Պաշտոնական էկոհամակարգի ընդլայնումների և գործիքների ամբողջական ցանկը կարող եք գտնել այստեղ։

final case class KTailConsumerImpl(topics: Set[String], consumer: Consumer)
    extends KTailConsumer {
  override val consume: Stream[Throwable, Message] =
    consumer
      .plainStream[Any, Array[Byte], Array[Byte]](
        Topics(topics),
        Serde.byteArray,
        Serde.byteArray
      )
      .map(record =>
        Message(
          record.offset.topicPartition.topic(),
          record.partition,
          record.offset.offset,
          record.key,
          record.value
        )
      )
}

Այս անգամ layer-ի տիպն արտահայտում է կոնկրետ կախվածություն KTailConfig սերվիսից, որը մեր հավելվածի կոնֆիգուրացիայի սերվիսն է։ Այն կկառուցենք շարքի հաջորդ մասերում, որտեղ նաև կտեսնենք, թե ինչպես է ZIO-ն հեշտացնում հավելվածի կոնֆիգուրացիայի ֆայլերի map-ավորումը։

Մենք կախված ենք zio-kafka գրադարանի Consumer օրինակից, որն ունի plainStream անունով մեթոդ։ Այն վերադարձնում է տրված topic-ից Kafka հաղորդագրությունների անվերջ հոսքի ZStream նկարագրություն՝ բանալիով և արժեքով, որոնք սերիալիզացված են նշված սերիալիզատորներով։

Հաղորդագրությունները մշակելու համար մենք փոխակերպում ենք դրանք map գործողությամբ՝ Kafka գրառումները վերածելով դոմենային Message օբյեկտների։ Մնում է միայն սահմանել layer մեր consumer-ի համար։

object KTailConsumerImpl {
  // ZLayer[KTailConfig, Throwable, KTailConsumer]
  val live: RLayer[KTailConfig, KTailConsumer] =
    ZLayer.scoped {
      for {
        config <- ZIO.service[KTailConfig]
        topics = config.topics.toSet
        consumer <- Consumer.make(
          ConsumerSettings(config.bootstrapServers)
            .withGroupId(config.groupId)
        )
      } yield KTailConsumerImpl(topics, consumer)
    }
}

ZIO միջավայրի միջոցով որոշակի սերվիսին հասնելու համար կանչում ենք ZIO.service[T] մեթոդներից մեկը։ Այդ պահից այդ սերվիսները հետևողականորեն հայտնվում են որպես պահանջներ մեր էֆեկտների և layer-ների տիպի պարամետրերում (R)։ Այստեղ մենք ստանում ենք config սերվիսը և նրա արժեքներով կառուցում իրական consumer օրինակը։

Scope

Նկատեցի՞ք, որ վերևի հատվածը օգտագործում է մեկ այլ կոնստրուկտոր՝ ZLayer.scoped։ Երբ Scope տիպը հայտնվում է էֆեկտի պահանջներում, դա նշանակում է, որ էֆեկտը հասանելիություն ունի ռեսուրսի, որը հետո պետք է պատշաճ կերպով մաքրվի։ Այլ կերպ ասած՝ Scope-ը ներկայացնում է ռեսուրսի կյանքի ցիկլը։

Այստեղ KTailConsumerImpl layer-ը Consumer օրինակ է կառուցում Consumer.make-ի միջոցով, որն կցում է Scope, որը պատասխանատու է այն փակելու համար։ Եթե խորանանք zio-kafka-ի կոդի մեջ, կգտնենք մի տեղ, որը պարունակում է հետևյալ (պարզեցված) կոդը։

ZIO.acquireRelease { 
    new KafkaConsumer[Array[Byte], Array[Byte]](...) 
} { consumer => consumer.close() }

ZIO.acquireRelease մեթոդը թույլ է տալիս ստեղծել scoped ռեսուրսներ և խնդրում է տրամադրել release callback, որտեղ տեղի է ունենում մաքրումը։ Այնուհետև Scope պարամետրը տարածվում է որպես պահանջ։

k-tail consumer-ի համար կառուցած layer-ում for comprehension արտահայտությունն ունի ZIO[Scope & KTailConfig, Throwable, KTailConsumerImpl] տիպը։ Սակայն, ինչպես կարող էիք նկատել, Scope-ը layer-ի պահանջների մեջ չի երևում։ Սա ZLayer.scoped-ի շնորհիվ է։

Այն վերացնում է Scope պահանջը և ձեռք բերված ռեսուրսի կյանքի տևողությունը կապում է հենց layer-ի կյանքի տևողության հետ։ Հետևաբար ռեսուրսը ազատվում է հենց այն պահին, երբ այս layer-ից կախված ցանկացած աշխատանքային հոսք ավարտում է աշխատանքը։ Մեր օրինակում դա տեղի է ունենում հավելվածի անջատման ժամանակ։

ZIO-ի այլ տիպեր ևս առաջարկում են scoped կոնստրուկտորներ։ Դիտարկենք ZStream.scoped-ը և պատկերացրեք pipeline, որը տվյալների բազայից գրառումներ է կարդում և դրանց վրա որոշ հաշվարկներ կատարում։ Մեզ պետք կլինի scoped տվյալների բազայի կապերի pool, բայց երբ դրանով stream կառուցենք, pool-ի կյանքի ցիկլը կապվում է հենց stream-ի հետ։ Դա իմաստ ունի, քանի որ կապերի pool-ը պետք է կենդանի մնա այնքան ժամանակ, որքան մենք մշակում ենք տվյալների բազայի գրառումները։

Օգտատիրոջ տեսանկյունից այս մեխանիզմը հստակ և պարզ է։ ZIO runtime-ը կատարում է ողջ ծանր աշխատանքը՝ երաշխավորելով, որ ռեսուրսը կփակվի սահուն կերպով՝ անկախ նրանից, թե մեր ծրագիրը հաջողվում է, ձախողվում է, թե ընդհատվում։

Ծրագիր

Այժմ հավաքենք մեր առաջին ZIO ծրագիրը, որը կարդում և buffer-ավորում է հաղորդագրությունները։

object Main extends ZIOAppDefault {

  private val program: RIO[Buffer & KTailConsumer, Unit] = for {
    consume <- KTailConsumer.consume
    _       <- consume.mapZIO(Buffer.offer).run(ZSink.drain)
  } yield ()

  override def run = program
}

Մեր հավելվածի մուտքի կետը ընդլայնում է ZIOAppDefault-ը, որը տալիս է runtime-ի լռելյայն կոնֆիգուրացիա։ Մենք պետք է override անենք run մեթոդը և միացնենք մեր ծրագրի տրամաբանությունը։ Ծրագրի առաջին տողը սահմանում է consumer stream։ Հաջորդը՝ mapZIO-ով, stream-ի յուրաքանչյուր հաղորդագրություն դնում ենք buffer-ի մեջ։ Stream-ի նկարագրությունը աշխատեցվող էֆեկտի վերածելու համար պետք է ZStream տիպի վրա կանչենք run-ի տարբերակներից մեկը։

Պետք է նաև նշենք sink՝ stream-ի ելքերի վերջնական նպատակակետը։ Քանի որ այստեղ արդյունքների հետ ոչինչ անելու կարիք չունենք, կարող ենք օգտագործել ZSink.drain-ը, որը դեն է նետում ելքերը և դատարկում է stream-ը մինչև ավարտը։ Սակայն դեռ չի կոմպիլյացվի։ Ուշադրություն դարձրեք մեր ծրագրի էֆեկտի տիպում Buffer & KTailConsumer պահանջին։ Այս փուլում կոդը կոմպիլյացիայի ենթարկելիս ստացվում է հետևյալի նման սխալ.

Your effect requires services that are not in the environment.
Please provide layers for the following 2 types:

    1. ktail.Buffer
    2. ktail.KTailConsumer

Կյանքը շատ ավելի հեշտ չէ՞ր լինի, եթե compile-time յուրաքանչյուր սխալ այսքան օգտակար լիներ։

Հետևենք կոմպիլյատորի խորհրդին և մեր ծրագրին տրամադրենք կախվածությունները։

override def run = program
  .provide(
    KTailConfig.live,
    BufferImpl.live,
    KTailConsumerImpl.live
  )

Միանգամայն ինտուիտիվ կերպով մենք կանչում ենք ZIO տիպի provide մեթոդը՝ բոլոր անհրաժեշտ սերվիսները layer-ների տեսքով փոխանցելու համար։ Մեր հավելվածն այժմ պատրաստ է աշխատելու։

Ամփոփում

Շարքի այս առաջին գրառումը ներկայացրեց ZIO գրադարանի մի քանի հիմնարար հասկացություններ։ Մենք տեսանք, թե ինչ են նշանակում Z տիպերի պարամետրերը, ինչպես գրել սերվիսներ, և ինչպես կազմել մեր ծրագրերը ու տրամադրել դրանց կախվածությունները։

Ցանկացած հարց ողջունելի է։ Շնորհակալություն։