Difference between preview and run #453
Replies: 2 comments 4 replies
-
|
Yes, this is, unfortunately, a part of the internal protocol that Besom has to implement like all other SDKs. The difference is that - being purely functional - Besom has to return resources wrapped in I have improved our docs to better explain this logic but I feel that this is probably not clear enough. We are working on something that would allow us to detect when user does this and issue a compile-time warning about the dynamicity. There's also the open question whether we should have two types of Output monad or expose the internal Result monad to the public. Two types of Output could not only detect a call that incurs dynamicity for the deployment plan but also prevent mistakes by clearly separating local/static outputs from remote/computed property outputs and having flatMap implementations that properly propagate the infective nature of remote/computed property outputs. This however may make things more complex. We are open for suggestions, it's not to late to introduce such a change if it improves the usability. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for the answer! All clear I think, and the addition to the docs also helps. I grasp the challenge now. I'm not familiar at all with pulumi internals, but it feels that the culprit is a certain weakness from the dry run feature? In an ideal world, the dry-run should be able to simulate dynamicity as well, maybe with mocked APIs or some concept for typical return values for certain calls (that providers would have to fill-in). Intuitively I would say complicating besom's design due to a pulumi weakness would be sad. |
Beta Was this translation helpful? Give feedback.
-
|
Yeah, this is only a problem in dry run, actual application of the infrastructure never uses |
Beta Was this translation helpful? Give feedback.
-
|
Here's a small prototype of compile-time warning about resource constructor being used in //> using scala 3.3.3
//> using dep com.lihaoyi::sourcecode::0.3.1
package besom.experimental
import scala.compiletime.summonFrom
import sourcecode.*
trait Warn
case object Warn extends Warn
sealed trait CheckWarn:
def warnIfNecessary(using Enclosing, Line): Unit =
this match
case LetsWarn => LetsWarn.warn
case NoWarn =>
case object LetsWarn extends CheckWarn:
def warn(using Enclosing, Line): Unit = println(s"warned at runtime: ${summon[Enclosing].value}:${summon[Line].value}")
case object NoWarn extends CheckWarn
object CheckWarn:
inline given CheckWarn = summonFrom:
case _: Warn =>
Macro.warning("You'd better not do this")
LetsWarn
case _ =>
NoWarn
case class Output[+A](run: () => A):
given Warn = Warn
def map[B](f: A => B): Output[B] = Output(() => f(run()))
def flatMap[B](f: Warn ?=> A => Output[B]): Output[B] = Output(() => f(run()).run())
object Output:
def apply[A](a: A): Output[A] = Output(() => a)
object aws:
object s3:
case class Bucket(str: String)
// this resource constructor detects whether it's being called in an Output#flatMap scope
def Bucket(something: Int, somethingElse: String)(using CheckWarn, Enclosing, Line): Output[Bucket] =
summon[CheckWarn].warnIfNecessary
Output(Bucket(s"$something $somethingElse"))
// this function does not do detection
def normalFunction(something: Int, somethingElse: String): Output[String] =
Output(s"$something $somethingElse")
// this function obfuscates the resource constructor, hides the scope information from it
// and therefore does not trigger the warning
def obfuscatedResourceConstructor(something: Int, somethingElse: String): Output[aws.s3.Bucket] =
aws.s3.Bucket(something, somethingElse)
@main def main =
val resOutput = aws.s3.Bucket(1, "fgsfds")
val out = for
x <- Output(1)
y <- Output("fgsfds")
res <- aws.s3.Bucket(x, y).flatMap(b => Output(b.str)) // proves no given collision
res2 <- normalFunction(x, y)
ohNo <- obfuscatedResourceConstructor(x, y)
yield
println(res)
println(res2)
resOutput.run()
out.run()package besom.experimental
import scala.quoted.*
object Macro:
inline def warning(inline message: String): Unit = ${ warningImpl('message) }
def warningImpl(message: Expr[String])(using Quotes): Expr[Unit] =
val msg = message.valueOrAbort
quotes.reflect.report.warning(msg)
'{}
|
Beta Was this translation helpful? Give feedback.
-
|
ah, no, maybe that's good enough? |
Beta Was this translation helpful? Give feedback.
-
|
looks cool. Maybe such warnings coud be easily turned off with a different |
Beta Was this translation helpful? Give feedback.
-
Somehow I ended up with a non-deterministic situation where the preview is sometimes different than what happens when running, is this expected? trace below.
(Note that I use for comprehensions and I don't list all outputs in the Stack constructor, I can paste the program if it helps, or try to find a simpler repro)
🙏
Beta Was this translation helpful? Give feedback.
All reactions