com.zeroc.IceInternal.ProxyFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ice Show documentation
Ice is a comprehensive RPC framework that helps you build distributed applications with minimal effort using familiar object-oriented idioms
There is a newer version: 3.7.10
Show newest version
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//

package com.zeroc.IceInternal;

import com.zeroc.Ice.OperationInterruptedException;

public final class ProxyFactory
{
    public com.zeroc.Ice.ObjectPrx
    stringToProxy(String str)
    {
        Reference ref = _instance.referenceFactory().create(str, null);
        return referenceToProxy(ref);
    }

    public String
    proxyToString(com.zeroc.Ice.ObjectPrx proxy)
    {
        if(proxy != null)
        {
            com.zeroc.Ice._ObjectPrxI h = (com.zeroc.Ice._ObjectPrxI)proxy;
            return h._getReference().toString();
        }
        else
        {
            return "";
        }
    }

    public com.zeroc.Ice.ObjectPrx
    propertyToProxy(String prefix)
    {
        String proxy = _instance.initializationData().properties.getProperty(prefix);
        Reference ref = _instance.referenceFactory().create(proxy, prefix);
        return referenceToProxy(ref);
    }

    public java.util.Map
    proxyToProperty(com.zeroc.Ice.ObjectPrx proxy, String prefix)
    {
        if(proxy != null)
        {
            com.zeroc.Ice._ObjectPrxI h = (com.zeroc.Ice._ObjectPrxI)proxy;
            return h._getReference().toProperty(prefix);
        }
        else
        {
            return new java.util.HashMap<>();
        }
    }

    public com.zeroc.Ice.ObjectPrx
    streamToProxy(com.zeroc.Ice.InputStream s)
    {
        com.zeroc.Ice.Identity ident = com.zeroc.Ice.Identity.ice_read(s);
        Reference ref = _instance.referenceFactory().create(ident, s);
        return referenceToProxy(ref);
    }

    public com.zeroc.Ice.ObjectPrx
    referenceToProxy(Reference ref)
    {
        if(ref != null)
        {
            com.zeroc.Ice._ObjectPrxI proxy = new com.zeroc.Ice._ObjectPrxI();
            proxy._setup(ref);
            return proxy;
        }
        else
        {
            return null;
        }
    }

    public int
    checkRetryAfterException(com.zeroc.Ice.LocalException ex, Reference ref, Holder sleepInterval, int cnt)
    {
        TraceLevels traceLevels = _instance.traceLevels();
        com.zeroc.Ice.Logger logger = _instance.initializationData().logger;

        //
        // We don't retry batch requests because the exception might have caused
        // all the requests batched with the connection to be aborted and we
        // want the application to be notified.
        //
        if(ref.getMode() == Reference.ModeBatchOneway || ref.getMode() == Reference.ModeBatchDatagram)
        {
            throw ex;
        }

        //
        // If it's a fixed proxy, retrying isn't useful as the proxy is tied to
        // the connection and the request will fail with the exception.
        //
        if (ref instanceof FixedReference)
        {
            throw ex;
        }

        if(ex instanceof com.zeroc.Ice.ObjectNotExistException)
        {
            com.zeroc.Ice.ObjectNotExistException one = (com.zeroc.Ice.ObjectNotExistException)ex;

            if(ref.getRouterInfo() != null && one.operation.equals("ice_add_proxy"))
            {
                //
                // If we have a router, an ObjectNotExistException with an
                // operation name "ice_add_proxy" indicates to the client
                // that the router isn't aware of the proxy (for example,
                // because it was evicted by the router). In this case, we
                // must *always* retry, so that the missing proxy is added
                // to the router.
                //

                ref.getRouterInfo().clearCache(ref);

                if(traceLevels.retry >= 1)
                {
                    String s = "retrying operation call to add proxy to router\n" + ex.toString();
                    logger.trace(traceLevels.retryCat, s);
                }

                if(sleepInterval != null)
                {
                    sleepInterval.value = 0;
                }
                return cnt; // We must always retry, so we don't look at the retry count.
            }
            else if(ref.isIndirect())
            {
                //
                // We retry ObjectNotExistException if the reference is
                // indirect.
                //

                if(ref.isWellKnown())
                {
                    LocatorInfo li = ref.getLocatorInfo();
                    if(li != null)
                    {
                        li.clearCache(ref);
                    }
                }
            }
            else
            {
                //
                // For all other cases, we don't retry ObjectNotExistException.
                //
                throw ex;
            }
        }
        else if(ex instanceof com.zeroc.Ice.RequestFailedException)
        {
            //
            // For all other cases, we don't retry  ObjectNotExistException
            //
            throw ex;
        }

        //
        // There is no point in retrying an operation that resulted in a
        // MarshalException. This must have been raised locally (because
        // if it happened in a server it would result in an
        // UnknownLocalException instead), which means there was a problem
        // in this process that will not change if we try again.
        //
        // The most likely cause for a MarshalException is exceeding the
        // maximum message size, which is represented by the subclass
        // MemoryLimitException. For example, a client can attempt to send
        // a message that exceeds the maximum memory size, or accumulate
        // enough batch requests without flushing that the maximum size is
        // reached.
        //
        // This latter case is especially problematic, because if we were
        // to retry a batch request after a MarshalException, we would in
        // fact silently discard the accumulated requests and allow new
        // batch requests to accumulate. If the subsequent batched
        // requests do not exceed the maximum message size, it appears to
        // the client that all of the batched requests were accepted, when
        // in reality only the last few are actually sent.
        //
        if(ex instanceof com.zeroc.Ice.MarshalException)
        {
            throw ex;
        }

        //
        // Don't retry if the communicator is destroyed, object adapter is deactivated,
        // or connection is manually closed.
        //
        if(ex instanceof com.zeroc.Ice.CommunicatorDestroyedException ||
           ex instanceof com.zeroc.Ice.ObjectAdapterDeactivatedException ||
           ex instanceof com.zeroc.Ice.ConnectionManuallyClosedException)
        {
            throw ex;
        }

        //
        // Don't retry invocation timeouts.
        //
        if(ex instanceof com.zeroc.Ice.InvocationTimeoutException ||
           ex instanceof com.zeroc.Ice.InvocationCanceledException)
        {
            throw ex;
        }

        //
        // Don't retry on OperationInterruptedException.
        //
        if(ex instanceof OperationInterruptedException)
        {
            throw ex;
        }

        ++cnt;
        assert(cnt > 0);

        int interval;
        if(cnt == (_retryIntervals.length + 1) && ex instanceof com.zeroc.Ice.CloseConnectionException)
        {
            //
            // A close connection exception is always retried at least once, even if the retry
            // limit is reached.
            //
            interval = 0;
        }
        else if(cnt > _retryIntervals.length)
        {
            if(traceLevels.retry >= 1)
            {
                String s = "cannot retry operation call because retry limit has been exceeded\n" + ex.toString();
                logger.trace(traceLevels.retryCat, s);
            }
            throw ex;
        }
        else
        {
            interval = _retryIntervals[cnt - 1];
        }

        if(traceLevels.retry >= 1)
        {
            String s = "retrying operation call";
            if(interval > 0)
            {
                s += " in " + interval + "ms";
            }
            s += " because of exception\n" + ex;
            logger.trace(traceLevels.retryCat, s);
        }

        sleepInterval.value = interval;
        return cnt;
    }

    //
    // Only for use by Instance.
    //
    ProxyFactory(Instance instance)
    {
        _instance = instance;

        String[] arr = _instance.initializationData().properties.getPropertyAsList("Ice.RetryIntervals");

        if(arr.length > 0)
        {
            _retryIntervals = new int[arr.length];

            for(int i = 0; i < arr.length; i++)
            {
                int v;

                try
                {
                    v = Integer.parseInt(arr[i]);
                }
                catch(NumberFormatException ex)
                {
                    v = 0;
                }

                //
                // If -1 is the first value, no retry and wait intervals.
                //
                if(i == 0 && v == -1)
                {
                    _retryIntervals = new int[0];
                    break;
                }

                _retryIntervals[i] = v > 0 ? v : 0;
            }
        }
        else
        {
            _retryIntervals = new int[1];
            _retryIntervals[0] = 0;
        }
    }

    private Instance _instance;
    private int[] _retryIntervals;
}