OASIS Mailing List ArchivesView the OASIS mailing list archive below
or browse/search using MarkMail.

 


Help: OASIS Mailing Lists Help | MarkMail Help

sca-j message

[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]


Subject: RE: [sca-j] ISSUE 3 - Local services expose implementation classes as theirtype


We're talking past each other.

If all we want is to define the exposed services then why don't we just use
the @service annotation.  There's nothing in the definition of @service
that mandates remotable.  It is placed on the impl and not the intf, but
that's not a big deal since we're talking about local components that are
already tightly coupled anyway.  I'm really trying hard to avoid
introducing yet another annotation.


To a specific point you made below:

>> We do allow services with local
>> interfaces, but we haven't mentioned that such services aren't allowed
>> to have bindings.  This might be a good thing to add, but it is
>> unrelated to this issue.
I simply disagree with you on this point.  If this is an issue about local
interfaces. Let's nail down all the local interface issues.  The addition
of the support you describe will necessarily magnify this problem, so we
should address it.  If we can really morph this into being less about local
components then I would agree with you.

I agree that the assembly spec should not define @Remotable, but that's a
different issue IMO. :-)

Dave Booz
STSM, SCA and WebSphere Architecture
Co-Chair OASIS SCA-Policy TC
"Distributed objects first, then world hunger"
Poughkeepsie, NY (845)-435-6093  or  8-295-6093
e-mail:booz@us.ibm.com
http://washome.austin.ibm.com/xwiki/bin/view/SCA2Team/WebHome


                                                                           
             "Michael Rowley"                                              
             <mrowley@bea.com>                                             
                                                                        To 
             11/14/2007 04:34          David Booz/Poughkeepsie/IBM@IBMUS   
             AM                                                         cc 
                                       <sca-j@lists.oasis-open.org>        
                                                                   Subject 
                                       RE: [sca-j] ISSUE 3 - Local         
                                       services expose implementation      
                                       classes as their type               
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           





I don't consider this to be a way of marking an interface as local
(since that is true without this annotation).  It is only for marking
the interface as "SCA".  We know the remotable interfaces that are
intended for use by SCA, but we don't know the local interfaces that are
intended for use by SCA.  This is just fulfilling that.

I don't believe this belongs in the assembly spec, but then I don't
really believe that the existing section of the assembly spec, titled
"Local and Remotable Interfaces", is right since it defines the
@Remotable annotation.  That really belongs to the Java TC (IMO).

BTW, I don't understand your comment that we don't require that you look
at the definition of interfaces.  You certainly have to look at the
interface in order to determine that wiring is valid.  Regarding
bindings, what do we do now?  We do allow services with local
interfaces, but we haven't mentioned that such services aren't allowed
to have bindings.  This might be a good thing to add, but it is
unrelated to this issue.

Michael


-----Original Message-----
From: David Booz [mailto:booz@us.ibm.com]
Sent: Wednesday, November 07, 2007 4:00 PM
To: Michael Rowley
Cc: sca-j@lists.oasis-open.org
Subject: RE: [sca-j] ISSUE 3 - Local services expose implementation
classes as their type

This would still require some change in Assembly.  You're suggesting
that
the application of a binding to a service or reference requires
introspection of the interface definition language in order to know that
the application is valid.  We don't say this anywhere in the assembly
spec,
wrt remotability.

My original question was more along the lines of considering language
neutrality.  There are non-Java languages which support the local/remote
concept that we're talking about here, but may not be able to express it
in
the IDL itself.  Therefore, we should consider adding this capability to
the SCDL.  I understand that the context of this issue is a Java to SCDL
mapping problem, but it does raise larger questions.


Dave Booz
STSM, SCA and WebSphere Architecture
Co-Chair OASIS SCA-Policy TC
"Distributed objects first, then world hunger"
Poughkeepsie, NY (845)-435-6093  or  8-295-6093
e-mail:booz@us.ibm.com
http://washome.austin.ibm.com/xwiki/bin/view/SCA2Team/WebHome




             "Michael Rowley"

             <mrowley@bea.com>


To
             11/05/2007 11:53          David
Booz/Poughkeepsie/IBM@IBMUS,
             AM                        <sca-j@lists.oasis-open.org>


cc



Subject
                                       RE: [sca-j] ISSUE 3 - Local

                                       services expose implementation

                                       classes as their type


















inline...

      -----Original Message-----
      From: David Booz [mailto:booz@us.ibm.com]
      Sent: Thursday, November 01, 2007 12:55 PM
      To: sca-j@lists.oasis-open.org
      Subject: RE: [sca-j] ISSUE 3 - Local services expose
implementation
      classes as their type

      I think we haven't completely dealt with this issue of local
      interfaces. In
      the context of this proposal, I have to raise the question of why
      there is
      no corresponding assembly model change.

I don't believe a change to the assembly model is needed.  The @Local
annotation does not actually change the semantics of an interface.
Merely
_not_ having an @Remotable also means that the interface is local.
However, by using @Local, you are causing classes that implement that
interface to have a <service> declaration generated for it, where it
wouldn't have had a service declared if there hadn't been a @Local
annotation.  It also plays a documentation role - making it clearer that
the interface is purposefully using local semantics (the @Remotable
annotation wasn't just forgotten).

        What does the generated
      componentType look like when used with  @Local interfaces?

A service declaration for each implemented interface that had been
marked
@Local, pointing to that interface for its type.


      Is it legal to
      specify a <sca:binding/> on the <sca:service/> that is derived
from
      implementing an @Local interface?

The main reason I would think that the answer is "no", is that I don't
think it makes sense for local communication by-reference calls to go
through a binding.  Can you think of a case where that would be useful?

      If not, how do you know it's local?

Because of the @Local annotation on the interface that is referenced.
(Although, perhaps I didn't understand your question.)

      This is certainly a problem in the existing spec, so maybe this is
a
      new
      issue, we can discuss on the call.

Michael


      Dave Booz
      STSM, SCA and WebSphere Architecture
      Co-Chair OASIS SCA-Policy TC
      "Distributed objects first, then world hunger"
      Poughkeepsie, NY (845)-435-6093  or  8-295-6093
      e-mail:booz@us.ibm.com
      http://washome.austin.ibm.com/xwiki/bin/view/SCA2Team/WebHome


                   "Michael Rowley"
                   <mrowley@bea.com>
      To
                   10/18/2007 02:48          "Michael Rowley"
      <mrowley@bea.com>,
                   PM
<sca-j@lists.oasis-open.org>
      cc

      Subject
                                             RE: [sca-j] ISSUE 3 - Local
                                             services expose
implementation
                                             classes as their type





      PROPOSAL:

      Introduce a new interface annotation called @Local.  If a
component
      implementation implements an interface that has been marked as
      @Local, then
      the component type will include a service whose type is that
      (non-remotable) interface.  In this way, the @Local annotation is
      similar
      to the @Remotable annotation, but without implying remote-call
      semantics.

      The rules for generating services for a class that does not
include
      the
      @Service annotation are the following:

      1) If the class implements interfaces, generate services for each
      implemented interface that has been marked as either @Remotable or
      @Local,
      where the type of the service is that interface.  Any implemented
      interfaces that have not been marked as either @Remotable or
@Local
      do not
      have services generated for them.

      2) If none of the interfaces implemented by the class has been
marked
      as
      @Remotable or @Local, then generate a service for each implemented
      interface that is not a "marker interface" (i.e. an interface with
no
      methods, like Serializable).

      3) If the class implements no interfaces, then it offers a single
      service
      whose type is that class.


      Michael



                  From: Barack, Ron [mailto:ron.barack@sap.com]
                  Sent: Thursday, October 04, 2007 5:27 AM.
                  To: sca-j@lists.oasis-open.org
                  Subject: [sca-j] ISSUE LOGGED: JAVA-3: Local services
      expose
                  implementation classes as their type

                  http://www.osoa.org/jira/browse/JAVA-3


                  Von:: Michael Rowley [mailto:mrowley@bea.com]
                  Gesendet: Mittwoch, 26. September 2007 00:22.
                  An: sca-j@lists.oasis-open.org
                  Betreff: [sca-j] NEW ISSUE: Local services expose
                  implementation classes as their type

                  TARGET: Java Common Annotations and APIs specification
                          Java Component Implementation Specification
                              Section titled: "Local and Remotable
      Services"

                  DESCRIPTION:

                  Currently, this section states the following:

                     If an implementation class has implemented
interfaces
      that
                     are not decorated with an @Remotable annotation,
the
      class
                     is considered to implement a single local service
      whose type
                     is defined by the class.

                  This is unfortunate, since the extremely common
pattern
      of:

                     class FooImpl implements Foo {}

                  Will result in a component that offers a service whose
      type is
                  FooImpl (assuming that Foo hasn't been marked as
      @Remotable).

                  It should be possible for this pattern to result in a
      service
                  whose type is the Foo interface.'

                  PROPOSAL:

                  Introduce a new interface annotation called @Local.
If a
                  component implementation implements an interface that
has
      been
                  marked as @Local, then the component type will include
a
                  service whose type is that interface.




[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]