Add this data to the backup stream.
@param strMessage the data to log.
196758
public void run()
    {
        Object objMessage = null;
        String[] files = this.getFileList();
        if (files == null)
            return;
        
        for (String strFile : files)
        {
            m_reader = this.getReader(strFile);
        
            try {
                while (true)
                {
                    objMessage = m_reader.readObject();
                    if (objMessage == null)
                        break;  // EOF = Done
                    
                    BaseBuffer buffer = new VectorBuffer((Vector)objMessage, BaseBuffer.PHYSICAL_FIELDS | BaseBuffer.MODIFIED_ONLY);
                    buffer.setHeaderCount(3);
                    String strTrxType = buffer.getHeader().toString();
                    String strTableName = buffer.getHeader().toString();
                    String strKey = buffer.getHeader().toString();
                    
                    try {
                        Record record = this.getRecord(strTableName);
                        if (record == null)
                        {
                        	ClassInfo recClassInfo = (ClassInfo)this.getMainRecord();
                            recClassInfo.addNew();
                            recClassInfo.setKeyArea(ClassInfo.CLASS_NAME_KEY);
                            recClassInfo.getField(ClassInfo.CLASS_NAME).setString(strTableName);
                            if (recClassInfo.seek(DBConstants.EQUALS))
                            {
                                strTableName = recClassInfo.getPackageName(null) + '.' + strTableName;
                                record = Record.makeRecordFromClassName(strTableName, this);
                                this.disableAllListeners(record);
                                record.setAutoSequence(false);
                            }
                            else
                            {
                                if (!NOTRX.equalsIgnoreCase(strTrxType))
                                    System.out.println("Error - table not found: " + strTableName);
                                continue;
                            }
                        }
                        record.addNew();
                        record.getCounterField().setString(strKey);
                        if (ProxyConstants.ADD.equalsIgnoreCase(strTrxType))
                        {
                            buffer.bufferToFields(record, DBConstants.DISPLAY, DBConstants.READ_MOVE);
                            record.add();
                        }
                        else if (ProxyConstants.SET.equalsIgnoreCase(strTrxType))
                        {
                            if (record.seek(DBConstants.EQUALS))
                            {
                                record.edit();
                                buffer.bufferToFields(record, DBConstants.DISPLAY, DBConstants.READ_MOVE);
                                record.set();
                            }
                            else
                                System.out.println("Error - record not found: " + strTableName + ", key: " + strKey);
                        }
                        else if (ProxyConstants.REMOVE.equalsIgnoreCase(strTrxType))
                        {
                            if (record.seek(DBConstants.EQUALS))
                            {
                                record.edit();
                                record.remove();
                            }
                            else
                                System.out.println("Error - record not found: " + strTableName + ", key: " + strKey);
                        }
                    } catch (DBException e) {
                        e.printStackTrace();
                        System.out.println("Error - record: " + strTableName + ", key: " + strKey + " trx type: " + strTrxType);
                    }
                    
                    System.out.println("trxType: " + strTrxType + " record: " + strTableName + " key: " + strKey);
                }
                m_reader.close();
                m_reader = null;
            
            } catch (EOFException e) {
                // Ok - Done
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
965972
private void addBestEffortMessage(SIMPMessage msgItem) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "addBestEffortMessage", new Object[] { msgItem });
    
    // Get the JsMessage as we need to update the Guaranteed fields
    JsMessage jsMsg = msgItem.getMessage();
 
    long tick = this.messageProcessor.nextTick();

    //Set a unique id in the message if explicitly told to or
    //if one has not already been set
    if(msgItem.getRequiresNewId()  ||  jsMsg.getSystemMessageId()==null)
    {
      jsMsg.setSystemMessageSourceUuid(this.messageProcessor.getMessagingEngineUuid());
      jsMsg.setSystemMessageValue(tick);
      msgItem.setRequiresNewId(false);
    }

    jsMsg.setGuaranteedValueEndTick(tick);
    jsMsg.setGuaranteedValueValueTick(tick);
    jsMsg.setGuaranteedValueRequestedOnly(false);

    // Keep MFP happy
    jsMsg.setGuaranteedValueStartTick(-1);
    jsMsg.setGuaranteedValueCompletedPrefix(-1);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "addBestEffortMessage");
  }
435723
@Override
    public void sendMessage(SyslogMessage message) throws IOException {
        sendCounter.incrementAndGet();
        long nanosBefore = System.nanoTime();

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            Writer out = new OutputStreamWriter(baos, UTF_8);
            message.toSyslogMessage(messageFormat, out);
            out.flush();

            if (logger.isLoggable(Level.FINEST)) {
                logger.finest("Send syslog message " + new String(baos.toByteArray(), UTF_8));
            }
            byte[] bytes = baos.toByteArray();

            DatagramPacket packet = new DatagramPacket(bytes, bytes.length, syslogServerHostnameReference.get(), syslogServerPort);
            datagramSocket.send(packet);
        } catch (IOException e) {
            sendErrorCounter.incrementAndGet();
            throw e;
        } catch (RuntimeException e) {
            sendErrorCounter.incrementAndGet();
            throw e;
        } finally {
            sendDurationInNanosCounter.addAndGet(System.nanoTime() - nanosBefore);
        }
    }
839292
private function _addError($strCommand, $strMessage)
    {
        $index = count($this->_arrErrorList) + 1;
        $this->_arrErrorList[$index]['command'] = $strCommand;
        $this->_arrErrorList[$index]['message'] = $strMessage;
        $this->_errors++;
    }
556061
public void addExtendedTraceDetail(SIBusMessage message)
  {
    if (message == null)
    {
      validateAndPutProperty("MessageTTL", "");
      validateAndPutProperty("RemainingTTL", "");
      validateAndPutProperty("FRP", "");
      validateAndPutProperty("RRP", "");
      validateAndPutProperty("ReplyDiscriminator", "");
      validateAndPutProperty("ReplyPriority", "");
      validateAndPutProperty("ReplyReliability", "");
      validateAndPutProperty("ReplyTTL", "");
    }
    else
    {
      validateAndPutProperty("MessageTTL", message.getTimeToLive());
      validateAndPutProperty("RemainingTTL", new Long(message.getRemainingTimeToLive()));
      validateAndPutProperty("FRP", message.getForwardRoutingPath());
      validateAndPutProperty("RRP", message.getReverseRoutingPath());
      validateAndPutProperty("ReplyDiscriminator", message.getReplyDiscriminator());
      validateAndPutProperty("ReplyPriority", message.getReplyPriority());
      validateAndPutProperty("ReplyReliability", message.getReplyReliability());
      validateAndPutProperty("ReplyTTL", message.getReplyTimeToLive());
    }
  }
842774
public void init(MessageDataParent messageDataParent, String strKey)
    {
        m_messageDataParent = messageDataParent;
        m_strKey = strKey;
        if (messageDataParent != null)
            messageDataParent.addMessageDataDesc(this);
    }
1258405
public void addString(String str) {
        if (mSize == mStrings.length) {
            String[] old = mStrings;
            int oldSize = old.length;
            mStrings = new String[oldSize + (oldSize << 1)];
            System.arraycopy(old, 0, mStrings, 0, oldSize);
        }
        mStrings[mSize++] = str;
    }
556670
public final void addStrings(Collection<String> strCollection)
    {
        if (sourceNode != null)
        {
            String previousString = "";

            //Add all the Strings in strCollection to the MDAG.
            for (String currentString : strCollection)
            {
                int mpsIndex = calculateMinimizationProcessingStartIndex(previousString, currentString);

                //If the _transition path of the previousString needs to be examined for minimization or
                //equivalence class representation after a certain point, call replaceOrRegister to do so.
                if (mpsIndex != -1)
                {

                    String transitionSubstring = previousString.substring(0, mpsIndex);
                    String minimizationProcessingSubString = previousString.substring(mpsIndex);
                    replaceOrRegister(sourceNode.transition(transitionSubstring), minimizationProcessingSubString);
                }
                /////

                addStringInternal(currentString);
                previousString = currentString;
            }
            /////

            //Since we delay the minimization of the previously-added String
            //until after we read the next one, we need to have a seperate
            //statement to minimize the absolute last String.
            replaceOrRegister(sourceNode, previousString);
        }
        else
        {
            unSimplify();
            addStrings(strCollection);
        }
    }
550217
private void send(AuditEventMessage msg, Destination<S> destination) throws Exception {
        if (EventUtils.isEmptyOrNull(msg)) {
            return;
        }
        // Serialize and format event message for syslog
        byte[] msgBytes = getTransportPayload(msg);
        if (EventUtils.isEmptyOrNull(msgBytes)) {
            return;
        }
        destination.write(msgBytes);
    }
656235
public String logMessage(String strTrxIDIn, BaseMessage trxMessage, String strMessageInfoType, String strMessageProcessType, String strMessageStatus, String strMessageDescription, String strMessageMimeType)
    {
        String strTrxID = strTrxIDIn;
        int iUserID = -1;
        String strContactType = null;
        String strContact = null;
        int iMessageReferenceID = -1;

        Task taskParent = this.getTask();
        Record recMessageLog = this.getRecord(MessageLog.MESSAGE_LOG_FILE);
        if (recMessageLog == null)
            recMessageLog = Record.makeRecordFromClassName(MessageLogModel.THICK_CLASS, this);
        try {
            if (strTrxID != null)
            {
                recMessageLog.getField(MessageLogModel.ID).setString(strTrxID);
                recMessageLog.setKeyArea(MessageLogModel.ID);
                if (recMessageLog.seek(null))
                {
                    recMessageLog.edit();
                }
                else
                    strTrxID = null;
            }
            if (strTrxID == null)
                recMessageLog.addNew();
            ReferenceField fldReference = (ReferenceField)recMessageLog.getField(MessageLogModel.MESSAGE_INFO_TYPE_ID);
            int iMessageInfoTypeID = fldReference.getIDFromCode(strMessageInfoType);
            fldReference.setValue(iMessageInfoTypeID);  // Message type
            fldReference = (ReferenceField)recMessageLog.getField(MessageLogModel.MESSAGE_TYPE_ID);
            int iMessageProcessTypeID = fldReference.getIDFromCode(strMessageProcessType);
            fldReference.setValue(iMessageProcessTypeID);  // Message type
            
            fldReference = (ReferenceField)recMessageLog.getField(MessageLogModel.MESSAGE_STATUS_ID);
            String objNativeMessage = null;
            if (objNativeMessage == null)
                if (trxMessage != null)
                    if (trxMessage.getExternalMessage() != null)
                        if (!MessageStatusModel.ERROR.equals(strMessageStatus))
                            objNativeMessage = trxMessage.getExternalMessage().toString();
            if (objNativeMessage == null)
                if (strMessageStatus == null)
                    strMessageStatus = MessageStatusModel.TRX_ID_HOLD;
            if (strMessageStatus == null)
                strMessageStatus = MessageStatusModel.UNKNOWN;
            int iMessageTimeout = 0;
            if (trxMessage != null)
                if (MessageStatusModel.SENT.equalsIgnoreCase(strMessageStatus))
                {
                    if ((trxMessage.getMessageHeader().get(TrxMessageHeader.MESSAGE_RESPONSE_ID) == null)
                        && (trxMessage.getMessageHeader().get(TrxMessageHeader.MESSAGE_RESPONSE_CODE) == null)
                        && (trxMessage.getMessageHeader().get(TrxMessageHeader.MESSAGE_RESPONSE_CLASS) == null))
                            strMessageStatus = MessageStatusModel.SENTOK;    // If I'm not expecting a response, status is sent okay.
                    else
                        if (trxMessage.getMessageHeader().get(TrxMessageHeader.MESSAGE_TIMEOUT) != null)
                        {
                            try {
                                iMessageTimeout = Integer.parseInt((String)trxMessage.getMessageHeader().get(TrxMessageHeader.MESSAGE_TIMEOUT));
                            } catch (NumberFormatException ex) {
                                iMessageTimeout = 0;
                            }
                        }
                }
            recMessageLog.getField(MessageLogModel.TIMEOUT_SECONDS).setValue(iMessageTimeout);
            if ((fldReference.isNull()) || (!MessageStatusModel.ERROR.equalsIgnoreCase(fldReference.getReference().getField(MessageStatusModel.CODE).toString())))
            {   // Can't change error status to something else
                int iMessageStatusID = fldReference.getIDFromCode(strMessageStatus);
                fldReference.setValue(iMessageStatusID);  // Message type
            }
            
            String strMessageTransport = this.getMessageTransportType();
            fldReference = (ReferenceField)recMessageLog.getField(MessageLogModel.MESSAGE_TRANSPORT_ID);
            int iMessageTransportID = fldReference.getIDFromCode(strMessageTransport);
            fldReference.setValue(iMessageTransportID);  // Message type
            
            String strReferenceType = null;
            int iMessageProcessInfoID = -1;

            if (!MessageStatusModel.ERROR.equals(strMessageStatus))
                if ((trxMessage != null) && (trxMessage.getMessageHeader() != null))
            {
                TrxMessageHeader trxMessageHeader = (TrxMessageHeader)trxMessage.getMessageHeader();
                if (strMessageDescription == null)
                    strMessageDescription = Utility.convertObjectToString(trxMessageHeader.get(TrxMessageHeader.DESCRIPTION));
                strContactType = Utility.convertObjectToString(trxMessageHeader.get(TrxMessageHeader.CONTACT_TYPE));
                if (strContactType != null)
                    if (strContactType.length() > 0)
                        if (!Utility.isNumeric(strContactType))
                {       // Convert the contact type from the record name to the ID.
                    Record recContactType = ((ReferenceField)recMessageLog.getField(MessageLogModel.CONTACT_TYPE_ID)).getReferenceRecord();
                    recContactType.setKeyArea(ContactTypeModel.CODE_KEY);
                    recContactType.getField(ContactTypeModel.CODE).setString(strContactType);
                    try {
                        if (recContactType.seek(null))
                        {   // Success
                            strContactType = recContactType.getField(ContactTypeModel.ID).toString();
                        }
                    } catch (DBException ex)    {
                        ex.printStackTrace();
                    }
                }
                strContact = Utility.convertObjectToString(trxMessageHeader.get(TrxMessageHeader.CONTACT_ID));
                Object objUserID = trxMessageHeader.get(DBParams.USER_ID);
                if (objUserID == null)
                    objUserID = trxMessageHeader.get(DBParams.USER_NAME);
                if (objUserID instanceof Integer)
                    iUserID = ((Integer)objUserID).intValue();
                else if (objUserID instanceof String)
                {
                    if (Utility.isNumeric((String)objUserID))
                        iUserID = Integer.parseInt((String)objUserID);
                    else
                    {
                        Record recUserInfo = Record.makeRecordFromClassName(UserInfoModel.THICK_CLASS, this);
                        if (((UserInfoModel)recUserInfo).getUserInfo((String)objUserID, false))
                            iUserID = (int)recUserInfo.getField(UserInfoModel.ID).getValue();
                        recUserInfo.free();
                    }
                }
                Object objMessageReferenceID = trxMessageHeader.get(TrxMessageHeader.REFERENCE_ID);
                if (objMessageReferenceID == null)
                	objMessageReferenceID = trxMessage.get(TrxMessageHeader.REFERENCE_ID);
                if (objMessageReferenceID instanceof Integer)
                    iMessageReferenceID = ((Integer)objMessageReferenceID).intValue();
                else if (objMessageReferenceID instanceof String)
                {
                    if (Utility.isNumeric((String)objMessageReferenceID))
                        iMessageReferenceID = Integer.parseInt((String)objMessageReferenceID);
                }
                if (trxMessageHeader.get(TrxMessageHeader.REFERENCE_TYPE) != null)
                	strReferenceType = (String)trxMessageHeader.get(TrxMessageHeader.REFERENCE_TYPE);
                if (strReferenceType == null)
                		strReferenceType = (String)trxMessage.get(TrxMessageHeader.REFERENCE_TYPE);
                if (trxMessageHeader.get(TrxMessageHeader.MESSAGE_PROCESS_INFO_ID) != null)
                {
                    Object objMessageProcessInfoID = trxMessageHeader.get(TrxMessageHeader.MESSAGE_PROCESS_INFO_ID);
                    if (objMessageProcessInfoID instanceof Integer)
                    	iMessageProcessInfoID = ((Integer)objMessageProcessInfoID).intValue();
                    else if (objMessageProcessInfoID instanceof String)
                    {
                        if (Utility.isNumeric((String)objMessageProcessInfoID))
                        	iMessageProcessInfoID = Integer.parseInt((String)objMessageProcessInfoID);
                    }
                }
            }

            if (iUserID != -1)
                recMessageLog.getField(MessageLogModel.USER_ID).setValue(iUserID);
            else if (taskParent != null)
                recMessageLog.getField(MessageLogModel.USER_ID).setString(((BaseApplication)taskParent.getApplication()).getUserID());

            if (strContactType != null)
                recMessageLog.getField(MessageLogModel.CONTACT_TYPE_ID).setString(strContactType);
            if (strContact != null)
                recMessageLog.getField(MessageLogModel.CONTACT_ID).setString(strContact);
            if (strMessageDescription != null)
                recMessageLog.getField(MessageLogModel.DESCRIPTION).setString(strMessageDescription);
            recMessageLog.getField(MessageLogModel.MESSAGE_TIME).setValue(DateTimeField.currentTime());
            if (iMessageProcessInfoID != -1)
                recMessageLog.getField(MessageLogModel.MESSAGE_PROCESS_INFO_ID).setValue(iMessageProcessInfoID);
            if (strReferenceType != null)
            	recMessageLog.getField(MessageLogModel.REFERENCE_TYPE).setString(strReferenceType);
            if (iMessageReferenceID != -1)
                recMessageLog.getField(MessageLogModel.REFERENCE_ID).setValue(iMessageReferenceID);
            if (strMessageInfoType != null)
                recMessageLog.getField(MessageLogModel.MESSAGE_DATA_TYPE).setString(strMessageInfoType);

            if (!MessageStatusModel.ERROR.equals(strMessageStatus))
                if (trxMessage != null)
            {
                recMessageLog.getField(MessageLogModel.MESSAGE_CLASS_NAME).setString(trxMessage.getClass().getName());
                if (trxMessage.getMessageHeader() != null)
                {
                    recMessageLog.getField(MessageLogModel.MESSAGE_HEADER_CLASS_NAME).setString(trxMessage.getMessageHeader().getClass().getName());
                    recMessageLog.getField(MessageLogModel.MESSAGE_QUEUE_NAME).setString(trxMessage.getMessageHeader().getQueueName());
                    recMessageLog.getField(MessageLogModel.MESSAGE_QUEUE_TYPE).setString(trxMessage.getMessageHeader().getQueueType());
                    Map<String,Object> propHeaderInfo = ((TrxMessageHeader)trxMessage.getMessageHeader()).getMessageInfoMap();
                    if (propHeaderInfo != null)
                        ((PropertiesField)recMessageLog.getField(MessageLogModel.MESSAGE_INFO_PROPERTIES)).setProperties(propHeaderInfo);
                    Map<String,Object> propMessageHeader = ((TrxMessageHeader)trxMessage.getMessageHeader()).getMessageHeaderMap();
                    if (propMessageHeader != null)
                        ((PropertiesField)recMessageLog.getField(MessageLogModel.MESSAGE_HEADER_PROPERTIES)).setProperties(propMessageHeader);
                    Map<String,Object> propHeaderTransport = ((TrxMessageHeader)trxMessage.getMessageHeader()).getMessageTransportMap();
                    if (propHeaderTransport != null)
                        ((PropertiesField)recMessageLog.getField(MessageLogModel.MESSAGE_TRANSPORT_PROPERTIES)).setProperties(propHeaderTransport);
                }
                String strMessage = trxMessage.getXML(false);
                recMessageLog.getField(MessageLogModel.XML_MESSAGE_DATA).setString(strMessage);
                if (trxMessage.getMessageDataDesc(null) != null)
                    recMessageLog.getField(MessageLogModel.MESSAGE_DATA_CLASS_NAME).setString(trxMessage.getMessageDataDesc(null).getClass().getName());
                if (trxMessage.getExternalMessage() != null)
                    recMessageLog.getField(MessageLogModel.EXTERNAL_MESSAGE_CLASS_NAME).setString(trxMessage.getExternalMessage().getClass().getName());
            }
            if (objNativeMessage != null)
                recMessageLog.getField(MessageLogModel.MESSAGE_DATA).setString(objNativeMessage.toString());

            if (MessageStatusModel.ERROR.equals(strMessageStatus))
                recMessageLog.getField(MessageLogModel.ERROR_TEXT).setString(strMessageDescription);

            if (strTrxID == null)
            {
                recMessageLog.add();
                strTrxID = recMessageLog.getLastModified(DBConstants.BOOKMARK_HANDLE).toString();
            }
            else
                recMessageLog.set();
            
        } catch (DBException ex)    {
            ex.printStackTrace();
            strTrxID = null;
        } finally {
            // No, leave it here!
            // recMessageLog.free();
        }
        
        if ((MessageStatusModel.TRX_ID_HOLD.equals(strMessageStatus)) || (strTrxIDIn == null))
            if (trxMessage != null)
                if (trxMessage.getMessageHeader() instanceof TrxMessageHeader)
                    ((TrxMessageHeader)trxMessage.getMessageHeader()).put(TrxMessageHeader.LOG_TRX_ID, strTrxID);

        return strTrxID;
    }
1228855
public void putString(String strValue)
    {
        Class<?> classData = this.getNativeClassType();
        Object objValue = null;
        try {
            objValue = DataConverters.convertObjectToDatatype(strValue, classData, null);
        } catch (Exception ex) {
            objValue = null;
        }
        if (this.getMessage() != null)
            this.getMessage().putNative(this.getFullKey(null), objValue);
    }
77615
private void prependMessage( String s )
    {
        if ( s == null )
            return;

        if ( message == null )
            message = s;
        else
            message = s + " : "+ message;
    }
162343
public void put(CommsByteBuffer msgBuffer, short msgBatch, boolean lastInBatch, boolean chunk)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "put", new Object[]{msgBuffer, msgBatch, lastInBatch, chunk});
      
      QueueData queueData = null;
      // If this data represents a chunk we need to read the flags from the buffer. This 
      // will indicate to us whether we need to create some new queue data to stash on the 
      // queue or 
      if (chunk)
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Dealing with a chunked message");
         
         // Get the flags from the buffer
         byte flags = msgBuffer.get();
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Flags:", ""+flags);
         
         // Is this the first chunk?
         if ((flags & CommsConstants.CHUNKED_MESSAGE_FIRST) == CommsConstants.CHUNKED_MESSAGE_FIRST)
         {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "First chunk received");
            
            // If it is, create some new queue data to place on the queue with the initial
            // chunk
            queueData = new QueueData(this, lastInBatch, chunk, msgBuffer);
            
            // Put the data to the queue
            queue.put(queueData, msgBatch);
         }
         else
         {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Middle / Last chunk received");
            
            // Otherwise, we need to append to the chunks already collected. We do this by
            // finding the chunk to append to. This will be the last message on the queue
            // (i.e. at the back). This works for all cases as an async consumer cannot be
            // driven concurrently (so the last incomplete message on the queue will be the
            // one we want).
            boolean lastChunk = ((flags & CommsConstants.CHUNKED_MESSAGE_LAST) == CommsConstants.CHUNKED_MESSAGE_LAST);
            queue.appendToLastMessage(msgBuffer, lastChunk);
         }
      }
      else
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Dealing with the entire message");
         
         queueData = new QueueData(this, lastInBatch, chunk, msgBuffer);
         
         // Put the data to the queue
         queue.put(queueData, msgBatch);
      }
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "put");
   }
72524
public void addMessageTransportType(BaseMessage externalTrxMessage)
    {
        String strTransportType = this.getMessageTransportType();
        Record recMessageTransport = this.getRecord(MessageTransportModel.MESSAGE_TRANSPORT_FILE);
        if (recMessageTransport == null)
            recMessageTransport = Record.makeRecordFromClassName(MessageTransportModel.THICK_CLASS, this);
        try {
            recMessageTransport.setKeyArea(MessageTransportModel.CODE_KEY);
            recMessageTransport.getField(MessageTransportModel.CODE).setString(strTransportType);
            if (recMessageTransport.seek(DBConstants.EQUALS))
            {   // Always
                TrxMessageHeader trxMessageHeader = (TrxMessageHeader)externalTrxMessage.getMessageHeader();
                if (trxMessageHeader == null)
                {
                    trxMessageHeader = new TrxMessageHeader(null, null);
                    externalTrxMessage.setMessageHeader(trxMessageHeader);
                }
                Map<String,Object> mapTransport = trxMessageHeader.getMessageTransportMap();
                if (mapTransport == null)
                    mapTransport = new HashMap<String,Object>();
                mapTransport.put(MessageTransportModel.TRANSPORT_ID_PARAM, recMessageTransport.getCounterField().toString());
                trxMessageHeader.setMessageTransportMap(mapTransport);
            }
        } catch (DBException ex) {
            ex.printStackTrace();
        }
    }
1020524
def write(self, msg):
        
        self._current_stream.write(msg)
        for log in self._logs.values():
            log.append(msg)
261048
public void addMessage(String message) {
    ActionMessages messages = (ActionMessages) next.get(Flash.MESSAGES);
    if (null == messages) {
      messages = new ActionMessages();
      put(Flash.MESSAGES, messages);
    }
    messages.getMessages().add(message);
  }
638646
public void add(String message, IOException cause) {
        causes.add(new IOException(message, cause));
    }