Ejemplo n.º 1
0
  //
  // Only for use by Ice.CommunicatorI
  //
  public Instance(Ice.Communicator communicator, Ice.InitializationData initData) {
    _state = StateActive;
    _initData = initData;

    try {
      if (_initData.properties == null) {
        _initData.properties = Ice.Util.createProperties();
      }

      synchronized (Instance.class) {
        if (!_oneOfDone) {
          String stdOut = _initData.properties.getProperty("Ice.StdOut");
          String stdErr = _initData.properties.getProperty("Ice.StdErr");

          java.io.PrintStream outStream = null;

          if (stdOut.length() > 0) {
            //
            // We need to close the existing stdout for JVM thread dump to go
            // to the new file
            //
            System.out.close();

            try {
              outStream = new java.io.PrintStream(new java.io.FileOutputStream(stdOut, true));
            } catch (java.io.FileNotFoundException ex) {
              throw new Ice.FileException(0, stdOut, ex);
            }

            System.setOut(outStream);
          }
          if (stdErr.length() > 0) {
            //
            // close for consistency with stdout
            //
            System.err.close();

            if (stdErr.equals(stdOut)) {
              System.setErr(outStream);
            } else {
              try {
                System.setErr(new java.io.PrintStream(new java.io.FileOutputStream(stdErr, true)));
              } catch (java.io.FileNotFoundException ex) {
                throw new Ice.FileException(0, stdErr, ex);
              }
            }
          }
          _oneOfDone = true;
        }
      }

      if (_initData.logger == null) {
        String logfile = _initData.properties.getProperty("Ice.LogFile");
        if (_initData.properties.getPropertyAsInt("Ice.UseSyslog") > 0
            && !System.getProperty("os.name").startsWith("Windows")) {
          if (logfile.length() != 0) {
            throw new Ice.InitializationException("Both syslog and file logger cannot be enabled.");
          }
          _initData.logger =
              new Ice.SysLoggerI(
                  _initData.properties.getProperty("Ice.ProgramName"),
                  _initData.properties.getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
        } else if (logfile.length() != 0) {
          _initData.logger =
              new Ice.LoggerI(_initData.properties.getProperty("Ice.ProgramName"), logfile);
        } else {
          _initData.logger = Ice.Util.getProcessLogger();
        }
      }

      _packages = validatePackages();

      _useApplicationClassLoader =
          _initData.properties.getPropertyAsInt("Ice.UseApplicationClassLoader") > 0;

      _traceLevels = new TraceLevels(_initData.properties);

      _defaultsAndOverrides = new DefaultsAndOverrides(_initData.properties, _initData.logger);

      _clientACM =
          new ACMConfig(
              _initData.properties,
              _initData.logger,
              "Ice.ACM.Client",
              new ACMConfig(
                  _initData.properties, _initData.logger, "Ice.ACM", new ACMConfig(false)));

      _serverACM =
          new ACMConfig(
              _initData.properties,
              _initData.logger,
              "Ice.ACM.Server",
              new ACMConfig(
                  _initData.properties, _initData.logger, "Ice.ACM", new ACMConfig(true)));

      {
        final int defaultMessageSizeMax = 1024;
        int num =
            _initData.properties.getPropertyAsIntWithDefault(
                "Ice.MessageSizeMax", defaultMessageSizeMax);
        if (num < 1 || num > 0x7fffffff / 1024) {
          _messageSizeMax = 0x7fffffff;
        } else {
          _messageSizeMax = num * 1024; // Property is in kilobytes, _messageSizeMax in bytes
        }
      }

      if (_initData.properties.getProperty("Ice.BatchAutoFlushSize").isEmpty()
          && !_initData.properties.getProperty("Ice.BatchAutoFlush").isEmpty()) {
        if (_initData.properties.getPropertyAsInt("Ice.BatchAutoFlush") > 0) {
          _batchAutoFlushSize = _messageSizeMax;
        } else {
          _batchAutoFlushSize = 0;
        }
      } else {
        int num =
            _initData.properties.getPropertyAsIntWithDefault("Ice.BatchAutoFlushSize", 1024); // 1MB
        if (num < 1) {
          _batchAutoFlushSize = num;
        } else if (num > 0x7fffffff / 1024) {
          _batchAutoFlushSize = 0x7fffffff;
        } else {
          _batchAutoFlushSize =
              num * 1024; // Property is in kilobytes, _batchAutoFlushSize in bytes
        }
      }

      _implicitContext =
          Ice.ImplicitContextI.create(_initData.properties.getProperty("Ice.ImplicitContext"));

      _routerManager = new RouterManager();

      _locatorManager = new LocatorManager(_initData.properties);

      _referenceFactory = new ReferenceFactory(this, communicator);

      _requestHandlerFactory = new RequestHandlerFactory(this);

      _proxyFactory = new ProxyFactory(this);

      boolean isIPv6Supported = Network.isIPv6Supported();
      boolean ipv4 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
      boolean ipv6 =
          _initData.properties.getPropertyAsIntWithDefault("Ice.IPv6", isIPv6Supported ? 1 : 0) > 0;
      if (!ipv4 && !ipv6) {
        throw new Ice.InitializationException("Both IPV4 and IPv6 support cannot be disabled.");
      } else if (ipv4 && ipv6) {
        _protocolSupport = Network.EnableBoth;
      } else if (ipv4) {
        _protocolSupport = Network.EnableIPv4;
      } else {
        _protocolSupport = Network.EnableIPv6;
      }
      _preferIPv6 = _initData.properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;

      _networkProxy = createNetworkProxy(_initData.properties, _protocolSupport);

      _endpointFactoryManager = new EndpointFactoryManager(this);

      ProtocolInstance tcpProtocolInstance =
          new ProtocolInstance(this, Ice.TCPEndpointType.value, "tcp", false);
      _endpointFactoryManager.add(new TcpEndpointFactory(tcpProtocolInstance));

      ProtocolInstance udpProtocolInstance =
          new ProtocolInstance(this, Ice.UDPEndpointType.value, "udp", false);
      _endpointFactoryManager.add(new UdpEndpointFactory(udpProtocolInstance));

      _pluginManager = new Ice.PluginManagerI(communicator, this);

      _outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);

      _servantFactoryManager = new ObjectFactoryManager();

      _objectAdapterFactory = new ObjectAdapterFactory(this, communicator);

      _retryQueue = new RetryQueue(this);

      //
      // If Ice.ThreadInterruptSafe is set or we're running on Android all
      // IO is done on the background thread. For Android we use the queue
      // executor as Android doesn't allow any network invocations on the main
      // thread even if the call is non-blocking.
      //
      if (_initData.properties.getPropertyAsInt("Ice.ThreadInterruptSafe") > 0
          || Util.isAndroid()) {
        _queueExecutor =
            new QueueExecutor(
                _initData.properties,
                Util.createThreadName(_initData.properties, "Ice.BackgroundIO"));
        _queueExecutorService = new QueueExecutorService(_queueExecutor);

        // Caching message buffers is not supported with background IO.
        _cacheMessageBuffers = 0;
      } else {
        _cacheMessageBuffers =
            _initData.properties.getPropertyAsIntWithDefault("Ice.CacheMessageBuffers", 2);
      }
    } catch (Ice.LocalException ex) {
      destroy();
      throw ex;
    }
  }