retroryan

import zhttp.service.{ChannelFactory, Client, EventLoopGroup}
import zio.{Tag, ZEnvironment, ZIO, ZLayer}

trait NumService:
  val get: ZIO[Any, Throwable, Int]

final case class NumServiceLive(c: ChannelFactory, e: EventLoopGroup) extends NumService:
  val url = "https://random-num-x5ht4amjia-uc.a.run.app/"
  val get: ZIO[Any, Throwable, Int] =
    val request =

retroryan

#create class
CreateClass({ name: "ledger" })

#create index
CreateIndex(
    {
      name: "UNIQUE_ENTRY_CONSTRAINT",
      source: Class("ledger"),
      terms: [{ field: ["data", "clientId"] }],
      values: [{ field: ["data", "counter"] }],

retroryan

#Create a Class
CreateClass({ name: "orders" })

#Create an Index
CreateIndex(
    {
      name: "orders_index",
      source: Class("orders"),
      values: [{ field: ["data", "orderId"], reverse:true }, { field: ["ref"] }],
      serialized: true

retroryan

15kX9REWJS9v3NmT1JeeUN6NnovQk9WnWz

retroryan

Keybase proof

I hereby claim:

• I am retroryan on github.
• I am binaryknight (https://keybase.io/binaryknight) on keybase.
• I have a public key ASD4qP7q58L0A88jrHOloskDr5ixa3CT77MWpbiEtxO5Cwo

To claim this, I am signing this object:

retroryan

override val supervisorStrategy: SupervisorStrategy = {
    val decider: SupervisorStrategy.Decider = {
      case Guest.CaffeineException =>
        SupervisorStrategy.Stop
      case Waiter.FrustratedException(coffee, guest) =>
        barista.tell(Barista.PrepareCoffee(coffee, guest), sender())
        SupervisorStrategy.Restart
    }
    OneForOneStrategy()(decider orElse super.supervisorStrategy.decider)
  }

retroryan

sealed abstract class QueryType[T] {
  val data: T
}

case class IntQueryType(data: Int) extends QueryType[Int] with Ordered[IntQueryType] {
  def compare(that: IntQueryType): Int = this.data - that.data
}

case class StringQueryType(data: String) extends QueryType[String] with Ordered[StringQueryType]  {
  def compare(that:StringQueryType):Int = this.data.compareTo(that.data)

retroryan

import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.Time
import kafka.serializer.StringDecoder
import org.joda.time.DateTime
import org.apache.spark.sql.SaveMode
import sqlContext.implicits._

 val ratingsStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)

   val msgs = ratingsStream.transform {

retroryan

import scala.annotation.tailrec
def atoi(chList:List[String]):Int = {

  @tailrec
  def atoiAccumulator(chList: List[String], accumulator: Int): Int = chList match {
    case Nil => accumulator

    case head :: tail =>
      val tensMult = scala.math.pow(10, tail.length).toInt
      val nxtAccumulator = (head.toInt * tensMult) + accumulator

retroryan

class DseSparkContextFactory extends SparkContextFactory {
  import SparkJobUtils._

  type C = SparkContext with ContextLike

  def makeContext(config: Config, contextConfig: Config, contextName: String): C = {
    val conf = configToSparkConf(config, contextConfig, contextName)

    val sparkMaster = "dsetool sparkmaster".!!.trim
    conf.set("spark.master",sparkMaster)