Scripting engines in V2 distribution

[Brent Putman]

On 4/1/13 1:37 PM, Cantor, Scott wrote:
> Ok. That makes a lot more sense, but reinforces that us shipping an
> ancient copy from a dead source is probably a bad idea.
>

Yes, I agree.  I surmise (without really looking into it) that the whole
reason for existence for the scripting.dev.java.net stuff was from a
time when JSR-223 was new and both the scripting API (javax.script.*) as
well as the language-specific engines were a separate effort from the
actual language impls themselves.  When Java 6 shipped with the API
built-in, that removed a lot of the reason for it being a separate thing.



>> Now, whether we should start and/or continue shipping any of the
>> particular languages/engines in the IdP, as opposed to asking the
>> deployer to install what they want, is another (and different) question.
> Even if we did, it seems clear we'd want to get them from the proper
> sources. 



Absolutely. 


> I'm much more willing to consider that, but since I think the
> engines are probably somewhat coupled to the language jars from a
> versioning standpoint, that seems like a bad idea.


Yes, given the way things are now, shipping the engine is tantamount to
us shipping a particular version of the language, e.g. Groovy 2.1.2
rather than just "the Groovy engine".  One question is whether we should
try and do that, as opposed to letting the deployer plug in whatever
version they want, and allowing them to upgrade the scripting language
impl on their own schedule, etc.


> And I think Peter's observation about jython was that even though we ship
> jython-engine, that doesn't give you jython support until you add the rest
> of the code, I guess. I had assumed the engines were self-contained, but
> clearly not.


Yes.  I think the "old" situation is probably because of what I said
above, the engines were a separate effort from the JSR-223 people.  The
"new" situation is that languages seem to themselves now supply the
(apparently relatively small) bits to adapt it to the JSR-223 API.

And speaking of Jython -
http://wiki.python.org/jython/UserGuide#using-jsr-223  :

> As of Jython 2.5.1 an implementation of JSR 223 is bundled in
> jython.jar. Simply add jython to your CLASSPATH and ask for the python
> script engine.





>
> So seems this is pointless for us to keep including in the current form.


Probably so.  We don't need to ship the actual javax.script framework
JAR b/c it's in Java 6, and it's an open question as to whether we ship
any particular language impls.  Assuming that the other languages for
which we formerly shipped engines are like JRuby, Groovy and Jython, I
think at the moment I'd lean towards saying that we shouldn't, and just
let the deployer add what they want.  It's literally just dropping some
jars into the IdP's lib directory before re-making the war.


--Brent



-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://shibboleth.net/pipermail/dev/attachments/20130401/09c63e71/attachment-0001.html