Issue 797: locally constrained (orb_revision) Source: (, ) Nature: Uncategorized Issue Severity: Significant Summary: Summary: What is the consensus for the notation to use for interfaces to objects that are in the orb but not outside. We use to call them psuedo objects. During the last talk I got the feel that there are three options: 1. //PIDL 2. "psuedo" keyword placed before "interface" 3. //locally constrained Resolution: Revised Text: Actions taken: December 9, 1997: received issue December 23, 1997: closed issue December 23, 1997: moved issue to orb_revision October 30, 2000: closed issue Discussion: End of Annotations:===== Return-Path: X-Authentication-Warning: greene.case.syr.edu: polar owned process doing -bs Date: Tue, 9 Dec 1997 09:49:38 -0500 (EST) From: Polar Humenn X-Sender: polar@greene.case.syr.edu To: sec-rev@omg.org Subject: locally constrained What is the consensus for the notation to use for interfaces to objects that are in the orb but not outside. We use to call them psuedo objects. During the last talk I got the feel that there are three options: 1. //PIDL 2. "psuedo" keyword placed before "interface" 3. //locally constrained >From a compiler perspective, I like the "psuedo" keyword approach (option 2), becuase then the IDL to target language compilers have a directive in the syntax not to generate the CORBA marshalling stubs, and unmarshalling skeletons. They will just create the target language's mapping of the interface to code representing the object. I'll go with the consensus. So, what is it? Later, -Polar ------------------------------------------------------------------- Polar Humenn BlackWatch Technology, Inc. Chief Science Officer 2-212 Center for Science & Technology mailto:polar@blackwatch.com CASE Center/Syracuse University Phone: 315-443-3171 Syracuse, NY 13244-4100 Fax: 315-443-4745 http://www.blackwatch.com Return-Path: Sender: jis@fpk.hp.com Date: Tue, 09 Dec 1997 11:04:35 -0500 From: Jishnu Mukerji Organization: Hewlett-Packard New Jersey Labs To: Polar Humenn Cc: sec-rev@omg.org Subject: Re: locally constrained References: Polar Humenn wrote: > > What is the consensus for the notation to use for interfaces to > objects > that are in the orb but not outside. We use to call them psuedo > objects. > > During the last talk I got the feel that there are three options: > > 1. //PIDL > 2. "psuedo" keyword placed before "interface" > 3. //locally constrained > > >From a compiler perspective, I like the "psuedo" keyword approach > (option > 2), becuase then the IDL to target language compilers have a > directive in > the syntax not to generate the CORBA marshalling stubs, and > unmarshalling > skeletons. They will just create the target language's mapping of > the > interface to code representing the object. > > I'll go with the consensus. So, what is it? "pseudo" is not an IDL keyword. It appears only in the C++ language mapping chapters, plus a few leakages into a couple of other areas. Your case is very simple. The entire "interceptor" module is internal to the ORB and hence everything in it is "locality contrained". If we are to follow the AB directive and practice established by the POA chapter on this matter the only admissible designation is "locality constrained". Consequently, that is the general approach that I will take in the final edit. Jishnu. -- Jishnu Mukerji Systems Architect Open Systems Software Division Email: jis@fpk.hp.com Hewlett-Packard New Jersey Labs, Tel: +1 973 443 7528 300 Campus Drive, 2E-62, Fax: +1 973 443 7422 Florham Park, NJ 07932, USA. Return-Path: From: "Daniel R. Frantz" To: "'Polar Humenn'" , "sec-rev@omg.org" Subject: RE: locally constrained Date: Tue, 9 Dec 1997 11:25:22 -0500 >-----Original Message----- >From: Polar Humenn [SMTP:polar@blackwatch.com] > >What is the consensus for the notation to use for interfaces to objects >that are in the orb but not outside. We use to call them psuedo objects. > >During the last talk I got the feel that there are three options: > >1. //PIDL >2. "psuedo" keyword placed before "interface" >3. //locally constrained >... >I'll go with the consensus. So, what is it? There is NO consensus on PIDL or pseudo objects as a whole, and certainly not on any syntax. There has been discussion of this issue in some recent RFP groups but we've all been dancing around it. I would guess that the security revision task force isn't the place to resolve the issue because it's much wider than security alone and because it's a subject larger than what an RTF is supposed to take on. Pseudo objects and PIDL are not just an issue of "objects that are in the orb but not outside". There's a green paper on pseudo objects, om/96-1 0-07, that describes several reasons for their use, only one of which is "locally constrained". Off the top of my head, I can think of "special language mapping needed for efficiency", singularity (only one of an object type can exist), pass-by-value semantics, and non-objectness of the entity being described. I'm sure that paper has others. The last couple of RFPs to address the issue have described some of their objects using "real IDL" (meaning that they are "real/righteous" objects in all their behaviors except...) and then added the semantic mantra of "locality constrained" to indicate that the object being described can't be passed outside the address space. It is up to the ORB to enforce that restriction. For example, Portability stated that a MARSHAL exception is raised for them. I guess this means we have a "silent consensus" to use this approach for this particular part of the pseudo object issue, but that's only part of the whole PIDL/Pseudo problem. Dan Return-Path: Date: Tue, 09 Dec 1997 11:51:18 -0500 From: Melony Katz Organization: Concept 5 Technologies To: Polar Humenn CC: Jishnu Mukerji , sec-rev@omg.org Subject: Re: locally constrained References: <348D6C13.1CB87AF@fpk.hp.com> I also recall from my notes that we agreed that the best option under the current circumstances (current IDL syntax, etc.) is a comment specifying which objects are locally contrained. -- Melony Jishnu Mukerji wrote: > Polar Humenn wrote: > > > > What is the consensus for the notation to use for interfaces to > objects > > that are in the orb but not outside. We use to call them psuedo > objects. > > > > During the last talk I got the feel that there are three options: > > > > 1. //PIDL > > 2. "psuedo" keyword placed before "interface" > > 3. //locally constrained > > > > >From a compiler perspective, I like the "psuedo" keyword approach > (option > > 2), becuase then the IDL to target language compilers have a > directive in > > the syntax not to generate the CORBA marshalling stubs, and > unmarshalling > > skeletons. They will just create the target language's mapping of > the > > interface to code representing the object. > > > > I'll go with the consensus. So, what is it? > > "pseudo" is not an IDL keyword. It appears only in the C++ language > mapping chapters, plus a few leakages into a couple of other areas. > Your > case is very simple. The entire "interceptor" module is internal to > the > ORB and hence everything in it is "locality contrained". If we are > to > follow the AB directive and practice established by the POA chapter > on > > this matter the only admissible designation is "locality > constrained". > > Consequently, that is the general approach that I will take in the > final > edit. > > Jishnu. > > -- > Jishnu Mukerji > Systems Architect > Open Systems Software Division > > Email: jis@fpk.hp.com Hewlett-Packard New Jersey Labs, > Tel: +1 973 443 7528 300 Campus Drive, 2E-62, > Fax: +1 973 443 7422 Florham Park, NJ 07932, USA. Return-Path: Date: Tue, 09 Dec 1997 11:51:18 -0500 From: Melony Katz Organization: Concept 5 Technologies To: Polar Humenn CC: Jishnu Mukerji , sec-rev@omg.org Subject: Re: locally constrained References: <348D6C13.1CB87AF@fpk.hp.com> I also recall from my notes that we agreed that the best option under the current circumstances (current IDL syntax, etc.) is a comment specifying which objects are locally contrained. -- Melony Jishnu Mukerji wrote: > Polar Humenn wrote: > > > > What is the consensus for the notation to use for interfaces to > objects > > that are in the orb but not outside. We use to call them psuedo > objects. > > > > During the last talk I got the feel that there are three options: > > > > 1. //PIDL > > 2. "psuedo" keyword placed before "interface" > > 3. //locally constrained > > > > >From a compiler perspective, I like the "psuedo" keyword approach > (option > > 2), becuase then the IDL to target language compilers have a > directive in > > the syntax not to generate the CORBA marshalling stubs, and > unmarshalling > > skeletons. They will just create the target language's mapping of > the > > interface to code representing the object. > > > > I'll go with the consensus. So, what is it? > > "pseudo" is not an IDL keyword. It appears only in the C++ language > mapping chapters, plus a few leakages into a couple of other areas. > Your > case is very simple. The entire "interceptor" module is internal to > the > ORB and hence everything in it is "locality contrained". If we are > to > follow the AB directive and practice established by the POA chapter > on > > this matter the only admissible designation is "locality > constrained". > > Consequently, that is the general approach that I will take in the > final > edit. > > Jishnu. > > -- > Jishnu Mukerji > Systems Architect > Open Systems Software Division > > Email: jis@fpk.hp.com Hewlett-Packard New Jersey Labs, > Tel: +1 973 443 7528 300 Campus Drive, 2E-62, > Fax: +1 973 443 7422 Florham Park, NJ 07932, USA. Return-Path: Date: Wed, 10 Dec 1997 09:14:27 -0500 From: Ken Geisinger Organization: Concept 5 Technologies To: orbos@omg.org, ab@omg.org, sec-rev@omg.org Subject: Re: locally constrained References: <199712091718.JAA05774@wheel.dcn.davis.ca.us> Jeffrey Mischkinsky wrote: > > 'Polar Humenn' writes: > > > > > > What is the consensus for the notation to use for interfaces to > objects > > that are in the orb but not outside. We use to call them psuedo > objects. > > > > During the last talk I got the feel that there are three options: > > > > 1. //PIDL > > 2. "psuedo" keyword placed before "interface" > > 3. //locally constrained > > > > >From a compiler perspective, I like the "psuedo" keyword approach > (option > > 2), becuase then the IDL to target language compilers have a > directive in > > the syntax not to generate the CORBA marshalling stubs, and > unmarshalling > > skeletons. They will just create the target language's mapping of > the > > interface to code representing the object. > > > > I'll go with the consensus. So, what is it? > This is a fairly complext topic :-) > However, > pseudo is NOT an IDL keyword. It may not be used in (legal) IDL > and > will > be rejected by conformant IDL compilers. > It was used in the C++ mapping (and possibly > a few other places) as a syntactic shorthand in place of > laboriously > specifying the c++ language mapping for each pseudo object. Its > use > is very confusing, as people read a lot more into it. > In the Java language mapping, I decided to bite the bullet and > eliminated its use and just completely the language mapping for > each > piece > of PIDL. > > There are no rules for PIDL--each instance of its use must have > its > language mapping individually specified for each language. > The approach adopted in the portability spec, where they wanted to > describe > behavior using real IDL, but needed to add "one little > constraint", > they > simply added some additional description of behavior to "locally > constrained" > objects. > Namely, an attempt to pass them "non-locally" would raise an > (MARSHAL i > think) exception. > At this time, i would highly recommend continuing this practice if > that > captures the desired behavior. > jeff > Sorry, but I must comment on this. I find this practice to be dangerous in that, unless the Portability specification has changed, it only suggests the existence of "locality constrained interfaces". Unfortunately, the specification then uses this concept everywhere. I continue to point to paragraph 1.2.2.5 which states: "... At the time of this writing, the ORBOS TF is discussing potential formal mechanisms for specifying and implementing such objects. ...If and when they do exist, they should be applied to the local interfaces described in this specification [ORB Portability]." In other words, we are suggesting specifiying interfaces as local without any specification stating exactly what that means and how it should be handled by the IDL compiler. It is also possible that the keyword in the IDL is "pseudo" thereby linking Polar's options 2 and 3. So, we can't say either is correct or wrong at this time. BTW: I have copied the AB and ORBOS groups on this since I think some clear statement from these groups is necessary on what to do in lieu of PIDL or a formal "Psuedo Object" specification. > > > > Later, > > -Polar > > > > > ------------------------------------------------------------------- > > Polar Humenn BlackWatch Technology, Inc. > > Chief Science Officer 2-212 Center for Science & > Technology > > mailto:polar@blackwatch.com CASE Center/Syracuse University > > Phone: 315-443-3171 Syracuse, NY 13244-4100 > > Fax: 315-443-4745 http://www.blackwatch.com > > > > > > -- > Jeff Mischkinsky > jmischki@dcn.davis.ca.us +1 530-758-9850 > jeffm@visigenic.com +1 650-312-5158 -- --------------------------------- | The opinions expressed above Ken Geisinger | are my own and not necessarily Sr. Software Integration Engineer | those of the company to which Concept Five Technologies, Inc. | I am employed. --------------------------------- | Return-Path: Sender: jis@fpk.hp.com Date: Tue, 23 Dec 1997 16:51:57 -0500 From: Jishnu Mukerji Reply-To: jis@fpk.hp.com Organization: Hewlett-Packard New Jersey Labs To: Juergen Boldt Cc: issues@omg.org, sec-rev@omg.org Subject: Re: issue797 References: <3.0.32.19971223140231.00be0040@emerald.omg.org> Juergen Boldt wrote: > This is issue # 797 > > locally constrained > > What is the consensus for the notation to use for interfaces to objects > that are in the orb but not outside. We use to call them psuedo objects. > During the last talk I got the feel that there are three options: > > 1. //PIDL > 2. "psuedo" keyword placed before "interface" > 3. //locally constrained > I can state exactly what is being done in Security Revision 1.2. Interfaces that are locality constrained are being documented as such. The IDL for such interfaces has the line that introduces the interface marked with a // locality constrained comment. The // PIDL comment is not being used in the Security revision at all. Core changes that are going into chapters that use the // PIDL convention abides by that convention in those chapters. In new chapters that contain stuff that is entirely internal to the ORB (e.g. the Interceptor chapter) there is a note in the introduction section saying everything defined in the chapter is internal to the ORB and locality constrained and then there is no further annotation in the IDL. Nowehere is the "pseudo" pseudo-keyword used in anything emanating from the Security RTF. This issue has actually been resolved in this way for quite a while in the Security RTF. This issue on the whole does not have anything to do with Security and hence does not belong to the Security RTF. So please close the issue or at least move it out of the Security RTF's list perhaps to the ORB RTFs list with that annotation. Thank you. Jishnu. -- Jishnu Mukerji Systems Architect Advanced Development CSO Tahoe Software Technology Center Email: jis@fpk.hp.com Hewlett-Packard New Jersey Labs, Tel: +1 973 443 7528 300 Campus Drive, 2E-62, Fax: +1 973 443 7422 Florham Park, NJ 07932, USA.