Method createAIHandRCD
@param dmeId
@param definition
@param isToBeDeleted
@param restartFromStaleBackup
@return
961915
private AnycastInputHandler createAIHandRCD(SIBUuid8 dmeId, 
                                              SIBUuid12 gatheringTargetDestUuid,
                                              DestinationDefinition definition,
                                              boolean restartFromStaleBackup)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, 
                  "createAIHandRCD",
                  new Object[]{ 
                  dmeId,
                  gatheringTargetDestUuid,
                  definition,
                  Boolean.valueOf(restartFromStaleBackup)});
                  
    AnycastInputHandler aih = null;
    AIContainerItemStream aiContainerItemStream = null;
    PtoPReceiveMsgsItemStream rcdItemStream = null;
    String key = SIMPUtils.getRemoteGetKey(dmeId, gatheringTargetDestUuid);

    try
    {
      // check if either item stream already exists
      aiContainerItemStream = _aiContainerItemStreams.get(key);
      rcdItemStream = _rcdItemStreams.get(key);
      if (aiContainerItemStream == null || rcdItemStream == null)
      {
        LocalTransaction tran = _baseDestinationHandler.getTransactionManager().createLocalTransaction(true);

        // create aiContainerItemStream if necessary
        if (aiContainerItemStream == null)
        {
          aiContainerItemStream = new AIContainerItemStream(dmeId, gatheringTargetDestUuid, null, null, null);
          _baseDestinationHandler.addItemStream(aiContainerItemStream, (Transaction) tran);
        }

        // create rcdItemStream if necessary
        if (rcdItemStream == null)
        {
          rcdItemStream = new PtoPReceiveMsgsItemStream(_baseDestinationHandler, dmeId, null);
          _baseDestinationHandler.addItemStream(rcdItemStream, (Transaction) tran);
          
          // Configure destination depth parameters for the PtoPReceiveMsgsItemStream (defect 559096)
          // Set the default limits on the Itemstream
          rcdItemStream.setDefaultDestLimits();
          // Setup any message depth interval checking in line with 510343
          rcdItemStream.setDestMsgInterval();
        }

        tran.commit();
        
        // If commit succeeded, add streams to map
        _aiContainerItemStreams.put(key, aiContainerItemStream);
        _rcdItemStreams.put(key, rcdItemStream);
      }

      aih =
        new AnycastInputHandler(
          definition.getName(),
          definition.getUUID(),
          definition.isReceiveExclusive(),
          _messageProcessor,
          aiContainerItemStream,
          dmeId,
          gatheringTargetDestUuid,
          _destinationManager.getAsyncUpdateThread(),
          _baseDestinationHandler,
          restartFromStaleBackup);
      RemoteConsumerDispatcher rcd =
        new RemoteConsumerDispatcher(
          _baseDestinationHandler, definition.getName(),
          rcdItemStream,
          new ConsumerDispatcherState(),
          aih,
          _baseDestinationHandler.getTransactionManager(),
          definition.isReceiveExclusive());
      rcd.setReadyForUse();

      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        SibTr.debug(tc, "RCD created " + rcd);

    }
    catch (Exception e)
    {
      // Exception shouldn't occur so FFDC and rethrow as runtime exception
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.impl.destination.AbstractRemoteSupport.createAIHandRCD",
        "1:961:1.25",
        this);

      SIErrorException e2 =
        new SIErrorException(
          nls.getFormattedMessage(
            "INTERNAL_MESSAGING_ERROR_CWSIP0002",
            new Object[] { "com.ibm.ws.sib.processor.impl.destination.AbstractRemoteSupport.createAIHandRCD", "1:968:1.25", e },
            null),
        e);

      SibTr.exception(tc, e);
      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
        new Object[] {
          "com.ibm.ws.sib.processor.impl.destination.AbstractRemoteSupport.createAIHandRCD",
          "1:976:1.25",
          e });

      // Don't throw exception if destination is being deleted, it is a message store invalid add
      // operation, and we're not being reconstituted with startMode == JsConstants.ME_START_FLUSH
      // Defect 222966
      if (_toBeDeleted && e instanceof InvalidAddOperation && !restartFromStaleBackup)
      {
        // Not throwing exception, make sure we return null
        aih = null;
      }
      else
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "createAIHandRCD", aih);
        
        throw e2;
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createAIHandRCD", aih);

    return aih;
  }
1366508
@SneakyThrows
    private Integer tryReuseWorkerId() {
        val pidWorkerIds = jedis.lrange(PREFIX_PID, 0, -1);
        if (pidWorkerIds.size() == 0) {
            return null;
        }

        boolean locked = jedis.setnx(PREFIX_LOK, Pid.getPid() + "") == 1;
        if (!locked) {
            return null;
        }
        @Cleanup
        val i = new Closeable() {
            @Override
            public void close() {
                jedis.del(PREFIX_LOK);
            }
        };

        val workerId = findUsableWorkerId(pidWorkerIds);
        if (workerId == null) {
            return null;
        }

        jedis.set(PREFIX_USE + workerId, Pid.getPid() + "x" + Os.IP_STRING + "x" + Os.HOSTNAME);
        return Integer.parseInt(workerId);
    }
304149
public static <ReqT, RespT> ServerMethodDefinition<ReqT, RespT> create(
      MethodDescriptor<ReqT, RespT> method,
      ServerCallHandler<ReqT, RespT> handler) {
    return new ServerMethodDefinition<>(method, handler);
  }
936188
public MethodMetaArgs createinitMethod(HandlerMetaDef handlerMetaDef, EventModel em) {
		String p_methodName = handlerMetaDef.getInitMethod();
		if (p_methodName == null)
			return null;
		return createCRUDMethodMetaArgs(p_methodName, em);
	}
161346
public void markDestinationAsCleanUpPending(DestinationHandler dh)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "markDestinationAsCleanUpPending", dh);

        if (dh.isLink())
        {
            linkIndex.cleanup(dh);
        }
        else
        {
            destinationIndex.cleanup(dh);
        }

        //Start asynchDeletionThread if not already running
        startAsynchDeletion();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "markDestinationAsCleanUpPending");
    }
866909
protected JCATranWrapper createWrapper(int timeout, Xid xid, JCARecoveryData jcard) throws WorkCompletedException /* @512190C*/
    {
        return new JCATranWrapperImpl(timeout, xid, jcard); // @D240298C
    }
601195
public IndirectionHandler createIndirectionHandler(PBKey brokerKey, Identity id)
    {
        Object args[] = {brokerKey, id};

        try
        {
            return (IndirectionHandler) getIndirectionHandlerConstructor().newInstance(args);
        }
        catch(InvocationTargetException ex)
        {
            throw new PersistenceBrokerException("Exception while creating a new indirection handler instance", ex);
        }
        catch(InstantiationException ex)
        {
            throw new PersistenceBrokerException("Exception while creating a new indirection handler instance", ex);
        }
        catch(IllegalAccessException ex)
        {
            throw new PersistenceBrokerException("Exception while creating a new indirection handler instance", ex);
        }
    }
348826
public static ClientInterfaceHandleManager makeThreadSafeCIHM(
            boolean isAdmin, Connection connection, ClientInterfaceRepairCallback callback, AdmissionControlGroup acg)
    {
        return new ClientInterfaceHandleManager(isAdmin, connection, callback, acg) {
            @Override
            synchronized long getHandle(boolean isSinglePartition, int partitionId,
                    long clientHandle, int messageSize, long creationTimeNanos, String procName, long initiatorHSId,
                    boolean isShortCircuitRead) {
                return super.getHandle(isSinglePartition, partitionId,
                        clientHandle, messageSize, creationTimeNanos, procName, initiatorHSId, isShortCircuitRead);
            }
            @Override
            synchronized Iv2InFlight findHandle(long ciHandle) {
                return super.findHandle(ciHandle);
            }
            @Override
            synchronized Iv2InFlight removeHandle(long ciHandle) {
                return super.removeHandle(ciHandle);
            }
            @Override
            synchronized long getOutstandingTxns() {
                return super.getOutstandingTxns();
            }
            @Override
            synchronized void freeOutstandingTxns() {
                super.freeOutstandingTxns();
            }

            @Override
            synchronized List<Iv2InFlight> removeHandlesForPartitionAndInitiator(Integer partitionId,
                    Long initiatorHSId) {
                return super.removeHandlesForPartitionAndInitiator(partitionId, initiatorHSId);
            }

            @Override
            synchronized boolean shouldCheckThreadIdAssertion()
            {
                return false;
            }
        };
    }
65853
private static void createRestorerInstance() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createRestorerInstance");
    try {
      Class cls = Class.forName(SI_MESSAGE_HANDLE_RESTORER_CLASS);
      instance = (SIMessageHandleRestorer) cls.newInstance();
    }
    catch (Exception e) {
      FFDCFilter.processException(e, "com.ibm.wsspi.sib.core.SIMessageHandleRestorer.createRestorerInstance", "100");
       SibTr.error(tc,"UNABLE_TO_CREATE_HANDLERESTORER_CWSIB0010",e);
      NoClassDefFoundError ncdfe = new NoClassDefFoundError(e.getMessage());
      ncdfe.initCause(e);
      throw ncdfe;
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createRestorerInstance");
  }
813981
public final ControlResetRequestAckAck createNewControlResetRequestAckAck() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createNewControlResetRequestAckAck");
    ControlResetRequestAckAck msg = null;
    try {
      msg = new ControlResetRequestAckAckImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createNewControlResetRequestAckAck");
    return msg;
  }
479704
function wrappedGuidFn(context) {
    return function (callback) {
      // Skip the duplicate ID check if asked to
      if (flags.includes(FS_NODUPEIDCHECK)) {
        callback(null, guid());
        return;
      }

      // Otherwise (default) make sure this id is unused first
      function guidWithCheck(callback) {
        const id = guid();
        context.getObject(id, function (err, value) {
          if (err) {
            callback(err);
            return;
          }

          // If this id is unused, use it, otherwise find another
          if (!value) {
            callback(null, id);
          } else {
            guidWithCheck(callback);
          }
        });
      }
      guidWithCheck(callback);
    };
  }
596304
public synchronized OServerAdmin createDatabase(final String iDatabaseType, String iStorageMode) throws IOException {
    storage.checkConnection();

    try {
      if (storage.getName() == null || storage.getName().length() <= 0) {
        OLogManager.instance().error(this, "Cannot create unnamed remote storage. Check your syntax", OStorageException.class);
      } else {
        if (iStorageMode == null)
          iStorageMode = "csv";

        final OChannelBinaryClient network = storage.beginRequest(OChannelBinaryProtocol.REQUEST_DB_CREATE);
        try {
          network.writeString(storage.getName());
          if (network.getSrvProtocolVersion() >= 8)
            network.writeString(iDatabaseType);
          network.writeString(iStorageMode);
        } finally {
          storage.endRequest(network);
        }

        storage.getResponse(network);

      }

    } catch (Exception e) {
      OLogManager.instance().error(this, "Cannot create the remote storage: " + storage.getName(), e, OStorageException.class);
      storage.close(true);
    }
    return this;
  }
605746
public Token<DelegationTokenIdentifier> createDelegationToken(String renewer) throws IOException {
    Text renewerText = new Text();
    if (renewer != null) {
      renewerText.set(renewer);
    }

    DelegationTokenIdentifier tokenIdentifier =
        requireNonNull(createTokenIdentifier(renewerText), "Token identifier");

    Token<DelegationTokenIdentifier> token = new Token<>(tokenIdentifier, secretManager);
    token.setKind(getKind());
    token.setService(service);
    logger.atFine().log("Created token %s with token identifier %s", token, tokenIdentifier);
    return token;
  }
284275
public void restart_server() throws DevFailed {
        Util.out4.println("In DServer.restart_server() method");

        //
        // Reset initial state and status
        //

        set_state(DevState.ON);
        set_status("The device is ON");

        //
        // Destroy and recreate the muli attribute object
        //

        final MultiAttribute tmp = new MultiAttribute(device_name, get_device_class());
        set_device_attr(tmp);

        //
        // Deleting the dserver device is a specific case. We must also delete
        // all
        // TDSOM embedded in this server
        //

        if (class_list.isEmpty() == false) {

            //
            // Destroy already registered classes, devices and commands
            // To destroy already created devices, we must disconnect them from
            // the ORB
            // otherwise their reference count will never decrease to 0 and the
            // object will
            // not be eligable for garbage collection.
            //

            final int nb_class = class_list.size();
            final POA r_poa = Util.instance().get_poa();
            for (int j = 0; j < nb_class; j++) {
                final Vector v = ((DeviceClass) class_list.elementAt(j)).get_device_list();
                final int nb_dev = v.size();

                for (int k = 0; k < nb_dev; k++) {
                    final DeviceImpl dev = (DeviceImpl) v.elementAt(k);
                    if (dev.get_exported_flag() == true) {
                        dev.delete_device();
                        try {
                            r_poa.deactivate_object(((DeviceImpl) v.elementAt(k)).get_obj_id());
                        } catch (final WrongPolicy ex) {
                            ex.printStackTrace();
                        } catch (final ObjectNotActive ex) {
                            ex.printStackTrace();
                        }
                    }
                }
                v.removeAllElements();
                ((DeviceClass) class_list.elementAt(j)).initClass();
            }
            class_list.removeAllElements();
            System.out.println("DServer.restart_server - class list " + class_list);

        }

        // Restart everything
        init_device();

        // Restart polling (if any)
        Util.instance().polling_configure();
    }
1226373
def newDtd(self, name, ExternalID, SystemID):
        
        ret = libxml2mod.xmlNewDtd(self._o, name, ExternalID, SystemID)
        if ret is None:raise treeError('xmlNewDtd() failed')
        __tmp = xmlDtd(_obj=ret)
        return __tmp
166548
static function createMId( $nCenter = 0, $nNode = 0, $sSource = null, & $arrData = null )
	{
		return CDId::getInstance()->createId( $nCenter, $nNode, $sSource, $arrData );
	}
342936
@Help(
    help =
        "Resumes a NSR that failed while executing a script in a VNFR. The id in the URL specifies the Network Service Record that will be resumed."
  )
  public void resume(final String idNsr) throws SDKException {
    String url = idNsr + "/resume";
    requestPost(url);
  }