CODEWITHSUNDEEP
scalaprocessio
Robin Adams
Robin Adams

Reputation: 181

How do I work with a Scala process interactively?

I'm writing a bot in Scala for a game that uses text input and output. So I want to work with a process interactively - that is, my code receives output from the process, works with it, and only then sends its next input to the process. So I want to give a function access to the inputStreams and the outputStream simultaneously.

This doesn't seem to fit into any of the factories in scala.sys.process.BasicIO or the constructor for scala.sys.process.ProcessIO (three functions, each of which has access to only one stream).

Here's how I'm doing it at the moment.

private var rogue_input: OutputStream = _
private var rogue_output: InputStream = _
private var rogue_error: InputStream = _

Process("python3 /home/robin/IdeaProjects/Rogomatic/python/rogue.py --rogomatic").run(
  new ProcessIO(rogue_input = _, rogue_output = _, rogue_error = _)
)

try {
  private val rogue_scanner = new Scanner(rogue_output)
  private val rogue_writer = new PrintWriter(rogue_input, true)

  // Play the game
} finally {
  rogue_input.close()
  rogue_output.close()
  rogue_error.close()
}

This works, but it doesn't feel very Scala-like. Is there a more idiomatic way to do this?

Upvotes: 3

Views: 185

Answers (1)

m01
m01

Reputation: 9385

So I want to work with a process interactively - that is, my code receives output from the process, works with it, and only then sends its next input to the process.

In general, this is traditionally solved by expect. There exist libraries and tools inspired by expect for various languages, including for Scala: https://github.com/Lasering/scala-expect.

The README of the project gives various examples. While I don't know exactly what your rouge.py expects in terms of stdin/stdout interactions, here's a quick "hello world" example showing how you could interact with a Python interpreter (using the Ammonite REPL, which has conveniently library importing capabilities):

import $ivy.`work.martins.simon::scala-expect:6.0.0`

import work.martins.simon.expect.core._
import work.martins.simon.expect.core.actions._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

val timeout = 5 seconds

val e = new Expect("python3 -i -", defaultValue = "?")(
    new ExpectBlock(
      new StringWhen(">>> ")(
        Sendln("""print("hello, world")""")
      )
    ),
    new ExpectBlock(
      new RegexWhen("""(.*)\n>>> """.r)(
        ReturningWithRegex(_.group(1).toString)
      )
    )
  )

e.run(timeout).onComplete(println)

What the code above does is it "expects" >>> to be sent to stdout, and when it finds that, it will send print("hello, world"), followed by a newline. From then, it reads and returns everything until the next prompt (>>>) using a regex.

Amongst other debug information, the above should result in Success(hello, world) being printed to your console.

The library has various other styles, and there may also exist other similar libraries out there. My main point is that an expect-inspired library is likely what you're looking for.

Upvotes: 1

Related Questions