private static void printIdentityFacetOperation(System.IO.StringWriter s, BasicStream str)
{
try
{
Ice.Identity identity = new Ice.Identity();
identity.read__(str);
s.Write("\nidentity = " + str.instance().identityToString(identity));
string[] facet = str.readStringSeq();
s.Write("\nfacet = ");
if (facet.Length > 0)
{
s.Write(IceUtilInternal.StringUtil.escapeString(facet[0], ""));
}
string operation = str.readString();
s.Write("\noperation = " + operation);
}
catch (System.IO.IOException)
{
Debug.Assert(false);
}
}
public void invoke(ServantManager servantManager, BasicStream stream)
{
_is = stream;
int start = _is.pos();
//
// Read the current.
//
current_.id.read__(_is);
//
// For compatibility with the old FacetPath.
//
string[] facetPath = _is.readStringSeq();
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.MarshalException();
}
current_.facet = facetPath[0];
}
else
{
current_.facet = "";
}
current_.operation = _is.readString();
current_.mode = (Ice.OperationMode)(int) _is.readByte();
current_.ctx = new Dictionary <string, string>();
int sz = _is.readSize();
while (sz-- > 0)
{
string first = _is.readString();
string second = _is.readString();
current_.ctx[first] = second;
}
Ice.Instrumentation.CommunicatorObserver obsv = instance_.getObserver();
if (obsv != null)
{
// Read the encapsulation size.
int size = _is.readInt();
_is.pos(_is.pos() - 4);
observer_ = obsv.getDispatchObserver(current_, _is.pos() - start + size);
if (observer_ != null)
{
observer_.attach();
}
}
//
// Don't put the code above into the try block below. Exceptions
// in the code above are considered fatal, and must propagate to
// the caller of this operation.
//
if (servantManager != null)
{
servant_ = servantManager.findServant(current_.id, current_.facet);
if (servant_ == null)
{
locator_ = servantManager.findServantLocator(current_.id.category);
if (locator_ == null && current_.id.category.Length > 0)
{
locator_ = servantManager.findServantLocator("");
}
if (locator_ != null)
{
try
{
servant_ = locator_.locate(current_, out cookie_);
}
catch (Ice.UserException ex)
{
Ice.EncodingVersion encoding = _is.skipEncaps(); // Required for batch requests.
if (observer_ != null)
{
observer_.userException();
}
if (response_)
{
os_.writeByte(ReplyStatus.replyUserException);
os_.startWriteEncaps(encoding, Ice.FormatType.DefaultFormat);
os_.writeUserException(ex);
os_.endWriteEncaps();
if (observer_ != null)
{
observer_.reply(os_.size() - Protocol.headerSize - 4);
}
connection_.sendResponse(os_, compress_);
}
else
{
connection_.sendNoResponse();
}
if (observer_ != null)
{
observer_.detach();
observer_ = null;
}
connection_ = null;
return;
}
catch (System.Exception ex)
{
_is.skipEncaps(); // Required for batch requests.
handleException__(ex);
return;
}
}
}
}
try
{
if (servant_ != null)
{
//
// DispatchAsync is a "pseudo dispatch status", used internally only
// to indicate async dispatch.
//
if (servant_.dispatch__(this, current_) == Ice.DispatchStatus.DispatchAsync)
{
//
// If this was an asynchronous dispatch, we're done here.
//
return;
}
if (locator_ != null && !servantLocatorFinished__())
{
return;
}
}
else
{
//
// Skip the input parameters, this is required for reading
// the next batch request if dispatching batch requests.
//
_is.skipEncaps();
if (servantManager != null && servantManager.hasServant(current_.id))
{
throw new Ice.FacetNotExistException(current_.id, current_.facet, current_.operation);
}
else
{
throw new Ice.ObjectNotExistException(current_.id, current_.facet, current_.operation);
}
}
}
catch (System.Exception ex)
{
if (servant_ != null && locator_ != null && !servantLocatorFinished__())
{
return;
}
handleException__(ex);
return;
}
//
// Don't put the code below into the try block above. Exceptions
// in the code below are considered fatal, and must propagate to
// the caller of this operation.
//
Debug.Assert(connection_ != null);
if (response_)
{
if (observer_ != null)
{
observer_.reply(os_.size() - Protocol.headerSize - 4);
}
connection_.sendResponse(os_, compress_);
}
else
{
connection_.sendNoResponse();
}
if (observer_ != null)
{
observer_.detach();
observer_ = null;
}
connection_ = null;
}
public Reference create(Ice.Identity ident, BasicStream s)
{
//
// Don't read the identity here. Operations calling this
// constructor read the identity, and pass it as a parameter.
//
if (ident.name.Length == 0 && ident.category.Length == 0)
{
return(null);
}
//
// For compatibility with the old FacetPath.
//
string[] facetPath = s.readStringSeq();
string facet;
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.ProxyUnmarshalException();
}
facet = facetPath[0];
}
else
{
facet = "";
}
int mode = (int)s.readByte();
if (mode < 0 || mode > (int)Reference.Mode.ModeLast)
{
throw new Ice.ProxyUnmarshalException();
}
bool secure = s.readBool();
Ice.ProtocolVersion protocol;
Ice.EncodingVersion encoding;
if (!s.getReadEncoding().Equals(Ice.Util.Encoding_1_0))
{
protocol = new Ice.ProtocolVersion();
protocol.read__(s);
encoding = new Ice.EncodingVersion();
encoding.read__(s);
}
else
{
protocol = Ice.Util.Protocol_1_0;
encoding = Ice.Util.Encoding_1_0;
}
EndpointI[] endpoints = null;
string adapterId = "";
int sz = s.readSize();
if (sz > 0)
{
endpoints = new EndpointI[sz];
for (int i = 0; i < sz; i++)
{
endpoints[i] = instance_.endpointFactoryManager().read(s);
}
}
else
{
adapterId = s.readString();
}
return(create(ident, facet, (Reference.Mode)mode, secure, protocol, encoding, endpoints, adapterId, null));
}