Scala for scripting

Scala for Scripting
Implementing an OSGi enabled, JSR-223 compliant scripting engine for Scala
http://people.apache.org/~mduerig/scala4scripting/

Michael Dürig
michael.duerig@day.com

Day Software AG
http://www.day.com/

Scala Days 2010
April 15th

1

Agenda
■ Introduction
– Scripting with Scala
– Scala for Apache Sling
■ Requirements and goals
■ Challenges and solutions
■ Conclusion

2

Scripting with Scala
■ (Illusion of) executing source code
■ Concise and versatile*
var capitals = Map("Switzerland" -> "Bern", "Spain" -> "Madrid")
capitals += ("France" -> "Paris")

val c = capitals.find(_._1 == "France")
.map(_._2)
.getOrElse("NIL")

■ DSL capabilities
■ Type safe

*) Adapted from: Programming in Scala, Martin Odersky, Lex Spoon, Bill Venners. Artima, 2008. 3

Scripting with Scala (cont.)
■ XML literals: type safe templating
<html>
<head>
<link rel="stylesheet" href="/apps/forum/static/blue.css" />
</head>
<body>
<div id="Header">
Welcome to the { node("name") } forum
{ Calendar.getInstance.getTime }
</div>
<div id="Content">
{ SearchBox.render(request) }
{ ThreadOverview.render(node) }
</div>
</body>
</html>

4

Apache Sling
■ Web application framework
– Backed by a Java content repository (JSR-170/JSR-283):
Apache Jackrabbit
– Based on OSGi: Apache Felix
– http://sling.apache.org/
■ RESTful
– Content resolution for mapping request URLs to resources
(i.e. JCR nodes)
– Servlet resolution for mapping resources to request handlers
(i.e. scripts)
■ Scriptable application layer
– JSR-223: Scripting for the Java platform

5

Sling URL decomposition

GET /forum/scala4sling.html HTTP/1.1

X



Repository path

X



Repository path

Application
selection

X



Repository path Script selection

Application
selection

X

Scala for Sling
package forum

class html(args: htmlArgs) {
import args._
// further imports omitted

println {
<html>
<body>
<div id="Header">
</div>
<div id="Content">
</div>
</body>
</html>
}
}
6

Scala for Sling
package forum

import args._ Import bindings

println {
<html>
<body>
<div id="Header">
</div>
<div id="Content">
</div>
</body>
</html>
}
}
6

Scala for Sling
package forum

import args._ Import bindings

println {
<html>
<body>
<div id="Header">
</div>
Use arguments
<div id="Content">
</div>
</body>
</html>
}
}
6

Agenda
■ Introduction
– JSR-223 compliance
– OSGi tolerant
– Further design goals
■ Conclusion

7

JSR-223
■ Scripting for the Java language
– Allow scripts access to the Java Platform
– Scripting for Java server-side applications
– Executing scripts:
javax.script.{ScriptEngine, ScriptEngineFactory}
– Binding application objects into scripts:
javax.script.Bindings

8

JSR-223: usage
val factories = ServiceRegistry.lookupProviders(classOf[ScriptEngineFactory])
val factory = factories.find(_.getEngineName == "Scala Scripting Engine")

val engine = factory.map(_.getScriptEngine).getOrElse {
throw new Error("Cannot locate Scala scripting engine")
}

val bindings = engine.getBindings(ScriptContext.ENGINE_SCOPE)
bindings.put("request", servletRequest)
engine.eval(script, bindings)

9

OSGi
■ OSGi Service Platform
– Runtime environment for Java applications (bundles)
– Module system
– Life cycle management
– Service registry
■ Mostly transparent
– Bundle information in manifest file
– Relies on class loading

10

Further design goals
■ Leverage existing tools
– Compilers
– IDEs
– Test suites
– Documentation and reporting tools

■ Independent from Sling and OSGi
– Versatile
– Configurable
– Embeddable

11

Agenda
■ Introduction
– Leverage existing tools
– Passing arguments to scripts
– Scalac and OSGi
– Performance
■ Conclusion

12

Leverage existing tools
■ Scripts are valid Scala source entities
■ Tradeoff
– ceremony
package forum

import args._
// ...
}

■ Advantages
– Write, refactor and debug with Scala IDEs
– Compile with Scala compiler
– Unit testing

13

Unit testing
import args._

println {
<html>
<body>
<div id="Header">
</div>
<div id="Content">
</div>
</body>
</html>
}
}

14

Unit testing
import args._ class htmlArgs {
val node = new {
println { def apply(name: String) = "Scala scripting"
<html>
<body> }
<div id="Header"> val request = new { /* ... */ }
{ Calendar.getInstance.getTime } }
</div>
<div id="Content">
{ SearchBox.render(request) } new html(new htmlArgs)
</div>
</body>
</html>
}
}

14

Unit testing
import args._ class htmlArgs {
val node = new {
println { def apply(name: String) = "Scala scripting"
<html>
<body> }
<div id="Header"> val request = new { /* ... */ }
{ Calendar.getInstance.getTime } }
</div>
<div id="Content">
{ SearchBox.render(request) } new html(new htmlArgs)
</div>
</body>
</html>
}
<html>
} <body>
<div id="Header">
Welcome to the Scala scripting forum
Tue Mar 16 19:46:38 CET 2010
</div>
<div id="Content">

</div>
</body>
</html>

14

Passing arguments to Scripts
class ResettableOutStream extends OutputStream implements Resettable {
public void write(int b) throws IOException { /* ... */ }
public void reset() { /* ... */ }
}

OutputStream getResetableOutputStream() { /* ... */ }

bindings.put("output", getResetableOutputStream)

import args._

output.write(‘c’)
output.reset()
}

15

}



Where are the types?

import args._

output.reset()
}

15

}



Where are the types?

import args._
Bindings wrapper
provides static types
output.reset()
}

15

Bindings wrapper
■ No type information in javax.script.Bindings
– Generate bindings wrapper exposing static types
– Arguments appear to be of all accessible types
– Implicit conversions to the rescue
■ Least accessible types
– v: C, I1, ..., In
– Expose v with static type D of least accessible super type of C
– Expose v through implicit conversion to Ik if neither D nor any Im
(m ≠ k) implements Ik.

16

Bindings wrapper (cont.)
}


bindings.put("output", new ResettableOutStream)

17

}


bindings.put("output", new ResettableOutStream)

Bindings wrapper
class htmlArgs(bindings: Bindings) {
lazy val output = bindings.getValue("output").asInstanceOf[OutputStream]
implicit def outputStream2Resettable(x: OutputStream): Resettable =
x.asInstanceOf[Resettable]
}

17

■ Limitations
– Scala’s visibility modifiers not exposed through reflection
– Not yet working with parametrized types
– Ambiguities in generated implicit conversion

18

Scalac and OSGi
■ Scalac
– Requires compiler class path
– File system based
■ OSGi
– Provides class loaders
– Bundle based
■ Bridging the gap
– File system abstraction over OSGi bundles
– Implement scala.tools.nsc.io.AbstractFile
– Limitation: wiring probably not fully respected

19

Independent through configuration
■ Abstract implementation details into configuration class
– Default implementation for standalone usage
– Specialized implementations for Sling
– Set through ScriptEngineFactory or injected via OSGi service
lookup

X

Configuration
■ Scala compiler
– Per script engine
– scripting.scala.SettingsProvider
– Class and output paths: scala.tools.nsc.io.AbstractFile
– Settings: scala.tools.nsc.Settings
– Reporting: scala.tools.nsc.reporters.Reporter
■ Script entry point
– Per invocation
– scripting.scala.ScriptInfo

X

Performance
■ On the fly compilation is slow
– Cache pre compiled scripts
– Dependency on bindings: include bindings wrapper
– Work in progress

20

Conclusion
■ Scala is attractive for scripting
– Concise and versatile
– DSL capabilities
– Type safe
– XML literals for type safe templating
■ Impedance mismatches
– JSR-223: dynamic vs. static typing
– OSGi: runtime environment vs. compile time utility
– Performance: illusion of executing source code

21

References
■ Scala for Scripting
http://people.apache.org/~mduerig/scala4scripting/
■ Apache Sling
http://sling.apache.org/

■ Michael Dürig
michael.duerig@day.com
■ Day Software AG
http://www.day.com/
22

Scala for scripting

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (18)

Semelhante a Scala for scripting

Semelhante a Scala for scripting (20)

Mais de day

Mais de day (20)

Último

Último (20)

Scala for scripting