[JBoss JIRA] Created: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
5:31 p.m.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:28 a.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem commented on SEAMFACES-185:
-----------------------------------------
This would be a great feature to add!
In terms of looking up the project stage from the context param, we could always look in
the web.xml manually from within the CDI extension.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:43 a.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey Brian,
thanks for your feedback. So I'll start to build a prototype for this.
BTW: What's the recommended way to obtain the ServletContext from within a CDI
extension?
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:10 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey all,
I just finished a first version of this extension. It seems to work very well. Here a
small description of the implementation:
I added the following annotations:
* {{@Development}}
* {{@Production}}
* {{@UnitTest}}
* {{@SystemTest}}
Users can place these annotations on beans to restrict the bean to a certain project
stage. If at least one of these annotations is present on a type and the extension detects
a different project stage, the type gets vetoed.
The extension uses a SPI called {{ProjectStageDetector}} to obtain the project stage the
JSF implementation will use (as CDI starts up before JSF). There are currently three
implementations for the project stage lookup, executed in the order of their appearance in
this list:
# Read a custom system property {{org.jboss.seam.faces.PROJECT_STAGE}}. This detector runs
first so that users are able to manually overwrite the project stage the other detectors
find.
# Parse the web.xml file of the webapp and search for the standard context parameter for
the project stage.
# Try to find the project stage by doing a JNDI lookup for the standard JNDI name.
A small note on the second detector. This one was the most difficult to implement. The
main reason for this is that the ServletContext isn't available when CDI bootstraps.
Therefore I wasn't able to use the standard Servlet API to read the context parameter
or get an InputStream for the web.xml. Instead I used a trick to read web.xml. I'm
checking whether the context classloader is an URLClassLoader. If so, I try to find the
URL of the {{/WEB-INF/classes/}} directory and then create a relative URL for web.xml by
appending {{../web.xml}} to that URL. I know that is a horrible hack! :(
Unfortunately this way of finding web.xml doesn't work on all containers. I verified
that it is working fine in:
Glassfish 3.1.1
Tomcat 7.0.x
Jetty 8.x
But unfortunately it don't work in JBoss AS6 and AS7 as their ClassLoader
implementations do not extend URLClassLoader. I know this is really bad, but I currently
see no other way of solving the issue of accessing web.xml. Do you have any further ideas?
However, I think that finding web.xml this way (working in some containers) is better than
to don't support project stages specified in web.xml at all, as it is quite common to
specify the project stage there.
You can find the current state of my work on GitHub:
https://github.com/chkal/seam-faces/tree/stages
It would be great if I could get some feedback from you guys. Do you like the annotation
naming and the way I use a SPI for detecting the project stage? If you like it, I could
start adding some more tests and adding a discription to the documentation.
Thanks :)
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:28 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem commented on SEAMFACES-185:
-----------------------------------------
Great work! This will indeed be a very useful feature, I'm sure!
The Annotation names look great to me, but we really need to improve the portability of
reading the web.xml.
In Servlet environments, we can simply delegate to the ServletContext, as that will start
before CDI. For EE environments, we may have to come up with implementation specific
providers.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:14 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem commented on SEAMFACES-185:
-----------------------------------------
I've filed some related Spec issues:
# [SERVLET_SPEC-9|http://java.net/jira/browse/SERVLET_SPEC-9]: Make web.xml accessible
prior to ServletContext initialisation
# CDI-152: Access the web.xml from CDI extensions
In the mean time, we can look at creating a portable solution in Seam Servlet, which this
CDI extension could leverage. I filed SEAMSERVLET-45 to address this requirement.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:18 a.m.
New subject: [JBoss JIRA] Updated: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem updated SEAMFACES-185:
------------------------------------
Fix Version/s: 3.1.0.Tracking
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
7:23 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey Brian,
thanks for filing the spec issues. I really think Seam Servlet would be a great place to
implement something for obtaining the ServletContext from within CDI extensions.
However I think this won't be easy. I experimented a bit with a ThreadLocal to save
the ServletContext from a ServletContextListener executed before CDI bootstraps, but I
didn't find a nice way to clean up this ThreadLocale and therefore this would create
memory leaks.
Perhaps someone would like to to take a look at this during the [Seam Faces Community Hack
Night|http://blog.bleathem.ca/2011/09/seam-faces-community-hack-night.html]? You can find
the code in the [stages] branch here:
https://github.com/chkal/seam-faces/
Any feedback is welcome! :)
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:45 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem commented on SEAMFACES-185:
-----------------------------------------
Stuart Douglas suggests (on #seam-dev, 09/Sep/11):
{quote}
using getResource() to get the location of a known resource (e.g. the extension class
itself)
then from there figure out the path to the web.xml
{quote}
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:47 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem commented on SEAMFACES-185:
-----------------------------------------
Dan Allen suggests (during jbf2f):
{quote}
Copy the web.xml during project build, into an accessible location.
{quote}
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:53 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey Brian! Thanks for posting the two suggestions here. I think Stuart's suggestion
looks very promising. In some way it is similar to the workaround I've first
implemented (see my second comment regarding the {URLClassLoader} hack). I'll try to
find some time on the weekend to play with this new idea! I'll come back to you as
soon as I have some results!
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:53 p.m.
New subject: [JBoss JIRA] Issue Comment Edited: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth edited comment on SEAMFACES-185 at 9/15/11 11:52 AM:
-------------------------------------------------------------------------
Hey Brian! Thanks for posting the two suggestions here. I think Stuart's suggestion
looks very promising. In some way it is similar to the workaround I've first
implemented (see my second comment regarding the {{URLClassLoader}} hack). I'll try to
find some time on the weekend to play with this new idea! I'll come back to you as
soon as I have some results!
was (Author: chkal):
Hey Brian! Thanks for posting the two suggestions here. I think Stuart's
suggestion looks very promising. In some way it is similar to the workaround I've
first implemented (see my second comment regarding the {URLClassLoader} hack). I'll
try to find some time on the weekend to play with this new idea! I'll come back to you
as soon as I have some results!
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:49 a.m.
New subject: [JBoss JIRA] Commented: (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey all!
I spent some more work on this issue and I'm very content with the results. I added a
SPI called {{WebXmlLocator}}. There are currently two implementations:
* The first implementation only works if the current context classloader is a
{{URLClassLoader}}. This class uses {{URLClassLoader.getURLs()}} to find the {{classes}}
directory which is then used to find {{web.xml}}
* The new implementation uses Stuart's approach. It uses {{getResource()}} to get the
URL of the its own class file and tries to locate {{WEB-INF/lib}} by looking at this URL.
This implementation works fine on AS6/AS7 which don't use {{URLClassLoader}}.
I did some intensive testing with different containers. I can confirm that the current
code supports the following containers:
* JBoss AS 7.1.0-SNAPSHOT
* JBoss AS 7.0.2
* JBoss AS 6.0.0
* Apache Tomcat 7.0.20
* Glassfish 3.1.1
* Jetty 8.0.0
* Maven Jetty Plugin ({{mvn jetty:run}})
I would be great if somebody of you could have a look at my branch. I created a pull
request to simplify the review process.
https://github.com/seam/faces/pull/55
Just a few notes regarding my branch:
* I only added new classes and didn't change existing code except for the
provider-configuration file
* All code is documented and formatted according to the JBoss Community code conventions
* The branch includes a simple Arquillian test that checks that the default project stage
is used if not JNDI entry or web.xml is found.
* I added some simple unit tests for some classes to the impl module. So I had to add
junit there again. I hope this is OK. I don't think that simple unit tests belong to
the testsuite module.
* I also added a new chapter about this feature to the documentation.
I'm looking forward to get any kind of feedback!
Thanks
Christian
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:09 a.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem resolved SEAMFACES-185.
-------------------------------------
Assignee: Christian Kaltepoth
Resolution: Done
Fantastic contribution - thanks Christian! The code is clear, well commented, and the
documentation provided is great.
Thanks again!
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.Tracking
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:11 a.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Brian Leathem updated SEAMFACES-185:
------------------------------------
Fix Version/s: 3.1.0.CR1
(was: 3.1.0.Tracking)
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.CR1
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:07 p.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey Brian! Thank you very much for reviewing and merging my patch. I'm glad to hear
you like it! :)
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.CR1
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:07 a.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Jason Porter updated SEAMFACES-185:
-----------------------------------
Fix Version/s: 3.1.0.Beta4
(was: 3.1.0.CR1)
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.Beta4
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:06 a.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Bernard Labno commented on SEAMFACES-185:
-----------------------------------------
I've tried this cool feature, but can't make it work. I'm setting up the stage
using JNDI (AS7.1.0.Beta1) with following entry in web.xml:
<resource-env-ref>
<resource-env-ref-name>jsf/ProjectStage</resource-env-ref-name>
<resource-env-ref-type>java.lang.String</resource-env-ref-type>
<lookup-name>java:/jsf/ProjectStage</lookup-name>
</resource-env-ref>
During bean processing by extension the java:comp/env/jsf/ProjectStage is not available,
thus extension always thinks it's Production phase.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.Beta4
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:36 a.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Hey Bernard,
thanks for bringing this up.
you wrote that the JNDI entry is not available during the extension processing. Did you
confirm this by looking at the TRACE logs? If so, could you post them? It would also be
interesting to know if the lookup works if it is done after the application has started
from an action method or something like that.
Thanks
Christian
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.Beta4
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:23 a.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Bernard Labno commented on SEAMFACES-185:
-----------------------------------------
For now I can only tell you that my observations are from debugging (i've put
breakpoints). So during bean processing the JNDI seems to be not set yet but later on i.e.
during commandButton click in JSF app the "java:comp/env/jsf/ProjectStage" is
correctly set in JNDI.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.Beta4
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
6:47 p.m.
New subject: [JBoss JIRA] (SEAMFACES-185) Add support for activating beans based on the JSF project stage
[
https://issues.jboss.org/browse/SEAMFACES-185?page=com.atlassian.jira.plu...
]
Christian Kaltepoth commented on SEAMFACES-185:
-----------------------------------------------
Thanks for sharing your observations. For me it looks like this may be a problem with AS7
then. I'll try to build an Arquillian test that reproduces this.
Add support for activating beans based on the JSF project stage
---------------------------------------------------------------
Key: SEAMFACES-185
URL: https://issues.jboss.org/browse/SEAMFACES-185
Project: Seam Faces
Issue Type: Feature Request
Affects Versions: 3.0.2
Reporter: Christian Kaltepoth
Assignee: Christian Kaltepoth
Fix For: 3.1.0.Beta4
Hey all,
I think it would be a great enhancement if Seam Faces could support activation of beans
only in specific JSF project stages. MyFaces CODI supports a similar feature with the
{{@ProjectStageActivated}} annotation.
Examples:
{code}
@ProductionStage
@ApplicationScoped
public class ProductionEntityManagerProducer {
...
}
@DevelopmentStage
@ApplicationScoped
public class DevelopmentEntityManagerProducer {
...
}
{code}
Another very interesting usecase would be to enable specific interceptors/decorators only
in development stage. This could be used for debugging stuff that is only interesting
during development.
I think this could be easily implenented using an CDI extension that vetos beans that do
not match the active project stage. The only problem I'm seeing is that we will need
the JSF project stage in an very early stage during application startup (actually before
JSF started up). This means that we would have to determine the project stage JSF will use
ourselves.
The JSF spec describes that the project stage can either be set with a servlet context
parameter or using JNDI. If the latter one is uses, we could simply do a JNDI lookup in
the extension. No problem here. If the developer uses a servlet context parameter the
situation will become more problematic, because we will need a reference to the
ServletContext in the extension.
What do you think of this feature? Would it be useful? Any further ideas for the
implementation?
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.jboss.org/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
4558
days inactive
4727
days old
20 comments
7 participants
participants (7)
-
Bernard Labno (Commented) (JIRA) -
Brian Leathem (JIRA)
-
Brian Leathem (Resolved) (JIRA)
-
Brian Leathem (Updated) (JIRA)
-
Christian Kaltepoth (Commented) (JIRA)
-
Christian Kaltepoth (JIRA)
-
Jason Porter (Updated) (JIRA)