Java RunningState.STARTED属性代码示例

public void receive(ByteBuffer bb, String channelId) {
	if (getRunningState() == RunningState.STARTED) {
		
			receiving = true;
			synchronized (buffer) {

				try {
					if (buffer.remaining() < bb.remaining())
						log.error("The TCP/IP outbound transport is unable to keep up with the incoming data rate, dropping "
								+ bb.remaining() + " bytes.");
					else
						buffer.put(bb);
				} catch (BufferOverflowException ex) {
					log.error("The TCP/IP outbound transport is unable to keep up with the incoming data rate, dropping "
							+ bb.remaining() + " bytes.");
				}
			}
			wakupThread();
			
		}
	

}
 

@Override
public void afterPropertiesSet()
{
	try
	{
		readProperties();
		if( getRunningState() == RunningState.STARTED )
		{
			cleanup();
			applyProperties();
		}
	}catch( IOException ex )
	{
		errorMessage = ex.getMessage();
		log.error(errorMessage);
		setRunningState(RunningState.ERROR);
	}
}
 

private void startCleanUpThread()
{
	if (cleanupOldFeatures && !cleanupTimeField.isEmpty())
	{
		if (cleanupThread == null && (getRunningState() == RunningState.STARTED || getRunningState() == RunningState.STARTING))
		{
			cleanupThread = new CleanupThread();
			cleanupThread.setName("OutboundFeatureServiceCleanerThread-" + layerDescriptionForLogs);
			cleanupThread.setDaemon(true);
			cleanupThread.start();
		}
	}
	else
	{
		if (cleanupThread != null)
		{
			cleanupThread.dismiss();
			cleanupThread = null;
		}
	}
}
 

private void stop(boolean unregisterAsListener)
{
	if (getRunningState() == RunningState.STARTED)
	{
		setRunningState(RunningState.STOPPING);
		runThread.dismiss();
		runThread.interrupt();
		runThread = null;
	}
	setRunningState(RunningState.STOPPED);
	setErrorMessage(null);
	if (unregisterAsListener)
	{
		try
		{
			disconnectOBI();
			token = null;
		}
		catch (Throwable t)
		{
			// Chances are, system is shutting down and agsManager instance has gone away.
			LOGGER.info("STOP_ERROR", t.getMessage());
		}
	}
}
 

@Override
public void afterPropertiesSet()
{
	try
	{
		readProperties();
		if (getRunningState() == RunningState.STARTED)
		{
			cleanup();
			applyProperties();
		}
	}
	catch (Exception error)
	{
		errorMessage = error.getMessage();
		LOGGER.error(errorMessage, error);
		setRunningState(RunningState.ERROR);
	}
}
 

@Override
public void receive(ByteBuffer buffer, String channelId)
{
	if (this.getRunningState() == RunningState.STARTED)
	{
		try
		{
			String json = convertToString(buffer);
			DBObject dbObj = (DBObject) com.mongodb.util.JSON.parse(json);
			collection.insert(dbObj);
		}
		catch (Exception error)
		{
			LOGGER.error("RECEIVE_ERROR", error.getMessage());
			LOGGER.info(error.getMessage(), error);
		}
	}
}
 

@Override
public void receive(ByteBuffer buffer, String channelId)
{
	if (this.getRunningState() == RunningState.STARTED)
	{
		try
		{
			String json = convertToString(buffer);
			hdfsClient.send(json);
		}
		catch (Exception error)
		{
			LOGGER.error("RECEIVE_ERROR", error.getMessage());
			LOGGER.info(error.getMessage(), error);
		}
	}
}
 

@Override
public void receive(ByteBuffer bb, String channelid) {
	if (host != null || !host.isEmpty())
	{
		//byte[] data = new byte[bb.remaining()];
		//bb.get(data);
		if(this.getRunningState()==RunningState.STARTED){
			if(token == null)
			{
				doHttp("", RequestType.GENERATE_TOKEN);
			}
			try{
				CharsetDecoder decoder = getCharsetDecoder();
				CharBuffer charBuffer = decoder.decode(bb);
				String jsonString = charBuffer.toString();
				doHttp(jsonString, RequestType.UPDATE);
			}
			catch(Exception e)
			{
				String errorMsg = LOGGER.translate("BUFFER_PARSING_ERROR", e.getMessage());
				LOGGER.error(errorMsg);
				LOGGER.info(e.getMessage(), e);
				//errorMessage = errorMsg;
			}
		}
	}
	
}
 

public void run() {
	try {
		errorMessage = null;
		applyProperties();
		setRunningState(RunningState.STARTED);
		while (getRunningState() == RunningState.STARTED) {
			try {
				if (receiving) {
					synchronized (this) {
						
						activity = 0;
						while (activity > -1) {
							if(!socketOpened)
							{
								OpenSockets();
								socketOpened = true;
							}
							activity = manageAllSockets();

							if (haveDataInIndividualBuffers
									&& connectionBuffers.isEmpty())
								haveDataInIndividualBuffers = false;
							if (activity == 0
									&& !haveDataInIndividualBuffers) {
								receiving = false;
								activity = -1;
								closeConnection();
								socketOpened = false;
							}
							
						}
					}
				}
			} catch (Exception e) {
				log.error("Error trying to write buffer", e);
				setRunningState(RunningState.ERROR);
			}

		}
		cleanup();
		if (getRunningState() == RunningState.STOPPING)
			setRunningState(RunningState.STOPPED);
	}
	catch (Exception ex)
	{
		errorMessage = ex.getMessage();
		log.error("Exiting TCP Transport due to unforeseen error", ex);
		setRunningState(RunningState.ERROR);
		return;
	}
	
}
 

private void connectToAwsEventHub()
{
  String errorMessage = null;
  RunningState runningState = RunningState.STARTED;

  try
  {
    applyProperties();
    if (propertiesNeedUpdating)
    {
      cleanup();
      propertiesNeedUpdating = false;
    }

    // iot service type: IOT_TOPIC|IOT_DEVICE
    isEventHubType = AwsIoTServiceType.IOT_TOPIC.toString().equals(iotServiceType);

    // Get KeyStore credentials
    KeyStorePasswordPair pair = AwsIoTHubUtil.getKeyStorePasswordPair(x509Certificate, privateKey, null);

    // create AwsClient
    clientId = String.format("%s-%s", thingName, new BigInteger(128, new SecureRandom()).toString(32));
    awsClient = new AWSIotMqttClient(clientEndpoint, clientId, pair.keyStore, pair.keyPassword);
    if (awsClient == null)
    {
      runningState = RunningState.ERROR;
      errorMessage = LOGGER.translate("FAILED_TO_CREATE_EH_CLIENT", clientEndpoint);
      LOGGER.error(errorMessage);
    }

    // attach device
    if (!isEventHubType)
    {
      LOGGER.info(System.currentTimeMillis() + ": ClientId: " + ": Attaching device:" + geIoTDevice.getThingName());
      geIoTDevice = new AwsIoTHubDevice(thingName);
      awsClient.attach(geIoTDevice);
    }

    // connect
    LOGGER.info(System.currentTimeMillis() + ": ClientId: " + clientId + ": Connecting");
    awsClient.connect();
    LOGGER.info(System.currentTimeMillis() + ": ClientId: " + clientId + ": Connected");

    // geIoTDevice.delete(10000); // delete shadow

    // register topic handler
    iotTopic = new AwsIoTTopicListener(topicName, AWSIotQos.QOS0);
    awsClient.subscribe(iotTopic, true);
    LOGGER.info("Subscribed to topic:" + topicName);

    setErrorMessage(errorMessage);
    setRunningState(runningState);
  }
  catch (AWSIotException iote)
  {
    LOGGER.error("AWSIOT_INIT_ERROR", iote);
    setErrorMessage(iote.getMessage());
    setRunningState(RunningState.ERROR);
  }
  catch (Exception ex)
  {
    LOGGER.error("INIT_ERROR", ex);
    setErrorMessage(ex.getMessage());
    setRunningState(RunningState.ERROR);
  }
}
 

@Override
public synchronized boolean isRunning()
{
	return (getRunningState() == RunningState.STARTED);
}