838 lines
29 KiB
C#
838 lines
29 KiB
C#
/*
|
|
* Copyright (c) 2015 iTAC Software AG, Germany. All Rights Reserved.
|
|
*
|
|
* This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
|
|
* printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
|
|
* without the written permission of iTAC Software AG.
|
|
*/
|
|
using com.itac.mes.tools;
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
|
|
using com.itac.mes.commonsmt.data;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Threading;
|
|
|
|
|
|
namespace com.itac.mes.commonsmt
|
|
{
|
|
|
|
/// <summary>
|
|
/// documentation for the namespace
|
|
/// </summary>
|
|
[System.Runtime.CompilerServices.CompilerGenerated]
|
|
class NamespaceDoc
|
|
{
|
|
}
|
|
|
|
public class MyEventArgs : EventArgs
|
|
{
|
|
public TraceEventType traceEventType;
|
|
public String message;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public delegate void MyEventHandler(Object sender, MyEventArgs e);
|
|
|
|
/// <summary>
|
|
/// Class level summary documentation goes here.</summary>
|
|
/// <remarks>
|
|
/// Longer comments can be associated with a type or member through
|
|
/// the remarks tag.</remarks>
|
|
public class MesServices : IMesServices
|
|
{
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public event MyEventHandler OnLog;
|
|
|
|
|
|
/// <summary>
|
|
/// return this value in {@link MesResponse#setTotalResult(int)}
|
|
/// {@link MesResponse#getTotalResult()} for any request
|
|
/// which was processed successfully.
|
|
/// All returned values are be valid.</summary>
|
|
public static int MES_RESULT_OK = 0;
|
|
|
|
/// <summary>
|
|
/// return this value in {@link MesResponse#setTotalResult(int)}/{@link MesResponse#getTotalResult()} for any request
|
|
/// which was NOT processed successfully. Not all returned values must be valid, depends on the request.
|
|
///
|
|
/// @see separate calls in {@link IMesServices#} for detailled information.
|
|
/// </summary>
|
|
public static int MES_RESULT_NOT_OK = 1;
|
|
// allowed port range
|
|
private static int MIN_PORT = 1023;
|
|
private static int MAX_PORT = 49150;
|
|
// 10 minutes default
|
|
private static int DEFAULT_REFRESH_INTERVAL = 600000;
|
|
|
|
|
|
// some bool flags for operation
|
|
private Boolean configured;
|
|
private Boolean active;
|
|
|
|
// every call to a mes host needs an own id; the id does not change when a call is completed on a failover host
|
|
private RequestIdGenerator idGenerator = new RequestIdGenerator();
|
|
// the invocation handler accepts all calls from the failoverProxy
|
|
private FailoverInvocationHandler failoverInvocationHandler;
|
|
// this proxy delegates the calls to all known failover hosts
|
|
private IMesServices failoverProxy;
|
|
// update Thread counter
|
|
private int runCounter;
|
|
/// <summary>
|
|
/// do not marshal objects but print as xml
|
|
/// </summary>
|
|
private ItacXmlSerializer serializer = new ItacXmlSerializer();
|
|
//// failover detection
|
|
private static int updateThreadCount;
|
|
private Thread failoverUpdateThread;
|
|
private int refreshFailoverhostsInterval;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesServices(String hostname, int port, int refreshFailoverhostsInterval)
|
|
{
|
|
setConfigured(false);
|
|
setActive(false);
|
|
//// create and initialize the failover proxy
|
|
failoverInvocationHandler = new FailoverInvocationHandler(OnLog);
|
|
// create the proxy and set the delegate
|
|
failoverProxy = (IMesServices)new FailoverProxy(typeof(IMesServices), failoverInvocationHandler).GetTransparentProxy();
|
|
// check hostname
|
|
if (!isHostNameValid(hostname))
|
|
{
|
|
log(TraceEventType.Error, "hostname must not be null or empty");
|
|
return;
|
|
}
|
|
// check port range
|
|
if (!isPortValid(port))
|
|
{
|
|
log(TraceEventType.Error, String.Format("value {0} is out of range {1}..{2}", port, MIN_PORT, MAX_PORT));
|
|
return;
|
|
}
|
|
// check refresh interval
|
|
if (!isRefreshIntervalValid(refreshFailoverhostsInterval))
|
|
{
|
|
log(TraceEventType.Error, "value {0} is out of valid values [-1], [0], [>60000]");
|
|
return;
|
|
}
|
|
setRefreshFailoverhostsInterval(refreshFailoverhostsInterval);
|
|
|
|
setConfigured(true);
|
|
FailoverHost failoverHost = new FailoverHost();
|
|
failoverHost.setHostname(hostname);
|
|
failoverHost.setPort(port);
|
|
|
|
failoverInvocationHandler.setFailover(new FailoverHost[] { failoverHost });
|
|
}
|
|
|
|
protected void setRefreshFailoverhostsInterval(int refreshFailoverhostsInterval)
|
|
{
|
|
this.refreshFailoverhostsInterval = refreshFailoverhostsInterval;
|
|
}
|
|
|
|
protected Boolean isPortValid(int newPort)
|
|
{
|
|
Boolean result = newPort >= MIN_PORT && newPort <= MAX_PORT;
|
|
return result;
|
|
}
|
|
|
|
protected Boolean isHostNameValid(String hostname)
|
|
{
|
|
return hostname != null && hostname.Length != 0;
|
|
}
|
|
|
|
protected Boolean isRefreshIntervalValid(long refreshFailoverhostsInterval)
|
|
{
|
|
return refreshFailoverhostsInterval == -1 || refreshFailoverhostsInterval == 0 || refreshFailoverhostsInterval > 60000;
|
|
}
|
|
|
|
protected void setActive(Boolean active)
|
|
{
|
|
if (!this.active && active)
|
|
{
|
|
log(TraceEventType.Information, "setting MesServices active");
|
|
}
|
|
else if (this.active && !active)
|
|
{
|
|
log(TraceEventType.Information, "setting MesServices inactive");
|
|
}
|
|
this.active = active;
|
|
}
|
|
|
|
protected Boolean isActive()
|
|
{
|
|
return active;
|
|
}
|
|
|
|
protected Boolean isConfigured()
|
|
{
|
|
return configured;
|
|
}
|
|
|
|
protected void setConfigured(Boolean configured)
|
|
{
|
|
if (!this.configured && configured)
|
|
{
|
|
log(TraceEventType.Information, "setting MesServices configured");
|
|
}
|
|
else if (this.configured && !configured)
|
|
{
|
|
log(TraceEventType.Information, "setting MesServices unconfigured");
|
|
}
|
|
this.configured = configured;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Vorbedingungen sind dass der Request gesetzt ist, sowie die Konfiguration und die aktivierung des Plugin
|
|
/// </summary>
|
|
/// <param name="mesResponse"> Parameter description for s goes here.</param>
|
|
/// <param name="mesRequest"> Parameter description for s goes here.</param>
|
|
/// <seealso cref="System.String">
|
|
/// You can use the cref attribute on any tag to reference a type or member
|
|
/// and the compiler will check that the reference exists. </seealso>
|
|
private void checkPreconditions(MesResponse mesResponse, MesRequest mesRequest) /* throws CogiscanException */{
|
|
checkRequestPreconditons(mesRequest);
|
|
if (mesResponse == null)
|
|
{
|
|
throw new PluginException(ResponseDetail.RESPONSE_IS_NULL, "response is null");
|
|
}
|
|
// requestId aus Request in den Response uebernehmen
|
|
mesResponse.setRequestId(mesRequest.getRequestId());
|
|
// Konfigurationsprobleme checken
|
|
if (!isConfigured())
|
|
{
|
|
throw new PluginException(ResponseDetail.PLUGIN_NOT_CONFIGURED, "plugin is not yet configured");
|
|
}
|
|
if (!isActive())
|
|
{
|
|
throw new PluginException(ResponseDetail.PLUGIN_NOT_ACTIVE, "plugin is not yet active");
|
|
}
|
|
setResponseValues(mesResponse, new ResponseDetail("", ResponseDetail.OK));
|
|
}
|
|
|
|
private void checkRequestPreconditons(MesRequest mesRequest)
|
|
{
|
|
if (mesRequest == null)
|
|
{
|
|
throw new PluginException(ResponseDetail.REQUEST_IS_NULL, "the request is null");
|
|
}
|
|
if (mesRequest.getRequestId() <= 0)
|
|
{
|
|
mesRequest.setRequestId(idGenerator.getNextId());
|
|
}
|
|
if (mesRequest.getEventDate() == null || mesRequest.getEventDate().Ticks == 0)
|
|
{
|
|
mesRequest.setEventDate(DateTime.Now);
|
|
}
|
|
// Request ausgeben
|
|
logRequest(mesRequest);
|
|
}
|
|
|
|
/**
|
|
* finalizing means closing communication channel and loggin response Object
|
|
*
|
|
* @param connection
|
|
* the used connection
|
|
* @param responseObject
|
|
* the responseObject
|
|
*/
|
|
private void finalizeRequest(MesResponse responseObject)
|
|
{
|
|
logResponse(responseObject);
|
|
}
|
|
|
|
// * gets a new communication cahnnel with specified name
|
|
// *
|
|
// * @param channelName
|
|
// * the name for the channel
|
|
// * @param connectionListener
|
|
// * @return
|
|
// * @throws IOException
|
|
// eine neue socket zum DataInterface als Client aufmachen. ?ber diese Verbindung werden alle Events zum
|
|
// Datainterface ?bertragen
|
|
// Returned nie einen Null-Wert
|
|
/// <summary>
|
|
/// Description for SomeMethod.</summary>
|
|
/// You can use the cref attribute on any tag to reference a type or member
|
|
/// and the compiler will check that the reference exists.
|
|
private void log(TraceEventType traceEventType, string message)
|
|
{
|
|
if (OnLog == null) { return; }
|
|
MyEventArgs myEventArgs = new MyEventArgs();
|
|
myEventArgs.message = "iTAC.MES.Suite SMT-Plugin:" + message;
|
|
myEventArgs.traceEventType = traceEventType;
|
|
OnLog(this, myEventArgs);
|
|
}
|
|
|
|
// convenient method
|
|
private ErrorDetail getErrorDetail(String detail, int code)
|
|
{
|
|
ErrorDetail errorDetail = new ErrorDetail();
|
|
errorDetail.setCode(code);
|
|
errorDetail.setDetail(detail);
|
|
return errorDetail;
|
|
}
|
|
|
|
private void handleThrowable(MesResponse response, Exception throwable)
|
|
{
|
|
response.setTotalResult(MesServices.MES_RESULT_NOT_OK);
|
|
if (throwable is PluginException)
|
|
{
|
|
setResponseValues(response, ((PluginException)throwable).getResponseDetail());
|
|
}
|
|
else if (throwable is IOException)
|
|
{
|
|
ErrorDetail[] details = response.getErrorDetails();
|
|
addError(ref details, getErrorDetail(throwable.Message, ResponseDetail.COMMUNICATION_FAILURE));
|
|
response.setErrorDetails(details);
|
|
}
|
|
else
|
|
{
|
|
ErrorDetail[] details = response.getErrorDetails();
|
|
addError(ref details, getErrorDetail(throwable.Message, ResponseDetail.PROCESSED_WITH_EXCEPTION));
|
|
response.setErrorDetails(details);
|
|
}
|
|
}
|
|
|
|
private void logResponse(MesResponse mesResponse)
|
|
{
|
|
if (mesResponse == null)
|
|
{
|
|
log(TraceEventType.Information, "finish empty response");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
String v = serializer.serialize(mesResponse).ToString();
|
|
log(TraceEventType.Verbose, "finish response " + mesResponse.getRequestId() + " (" + mesResponse.GetType().Name + ")"
|
|
+ " with code " + mesResponse.getTotalResult() + "\n" + v);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
log(TraceEventType.Verbose, "finish request " + mesResponse.getRequestId() + " with code " + mesResponse.getTotalResult() + "\ncannot log response message");
|
|
}
|
|
}
|
|
|
|
private void logRequest(MesRequest mesRequest)
|
|
{
|
|
if (mesRequest == null)
|
|
{
|
|
log(TraceEventType.Information, "finish empty request");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
String v = serializer.serialize(mesRequest).ToString();
|
|
log(TraceEventType.Verbose, "finish request " + mesRequest.getRequestId() + " (" + mesRequest.GetType().Name + ")" + "\n" + v);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
log(TraceEventType.Verbose, "finish request " + mesRequest.getRequestId() + "\ncannot log request message");
|
|
}
|
|
}
|
|
|
|
private void setResponseValues(MesResponse response, ResponseDetail responseDetail)
|
|
{
|
|
if (responseDetail.getCode() == ResponseDetail.OK)
|
|
{
|
|
response.setTotalResult(MesServices.MES_RESULT_OK);
|
|
return;
|
|
}
|
|
response.setTotalResult(MesServices.MES_RESULT_NOT_OK);
|
|
|
|
ErrorDetail[] details = response.getErrorDetails();
|
|
addError(ref details, getErrorDetail(responseDetail.getText(), responseDetail.getCode()));
|
|
response.setErrorDetails(details);
|
|
}
|
|
|
|
protected IMesServices getFailoverProxy()
|
|
{
|
|
return failoverProxy;
|
|
}
|
|
|
|
#region IMesServices_Member
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="createContainerRequest"></param>
|
|
/// <returns></returns>
|
|
public CreateContainerResponse mesCreateContainer(CreateContainerRequest createContainerRequest)
|
|
{
|
|
CreateContainerResponse responseObject = new CreateContainerResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, createContainerRequest);
|
|
responseObject = getFailoverProxy().mesCreateContainer(createContainerRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
public CreateMslContainerResponse mesCreateMslContainer(CreateMslContainerRequest createMslContainerRequest)
|
|
{
|
|
CreateMslContainerResponse responseObject = new CreateMslContainerResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, createMslContainerRequest);
|
|
responseObject = getFailoverProxy().mesCreateMslContainer(createMslContainerRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public CheckContainerResponse mesCheckContainer(CheckContainerRequest checkContainerRequest)
|
|
{
|
|
CheckContainerResponse responseObject = new CheckContainerResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, checkContainerRequest);
|
|
responseObject = getFailoverProxy().mesCheckContainer(checkContainerRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
|
|
return responseObject;
|
|
}
|
|
|
|
public CheckMslContainerResponse mesCheckMslContainer(CheckMslContainerRequest checkMslContainerRequest)
|
|
{
|
|
CheckMslContainerResponse responseObject = new CheckMslContainerResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, checkMslContainerRequest);
|
|
responseObject = getFailoverProxy().mesCheckMslContainer(checkMslContainerRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public PlacementRecipeCheckResponse mesCheckPlacementRecipe(PlacementRecipeCheckRequest placementRecipeCheckRequest)
|
|
{
|
|
PlacementRecipeCheckResponse responseObject = new PlacementRecipeCheckResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, placementRecipeCheckRequest);
|
|
responseObject = getFailoverProxy().mesCheckPlacementRecipe(placementRecipeCheckRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
|
|
public InterlockingResponse mesInterlocking(InterlockingRequest interlockingRequest)
|
|
{
|
|
InterlockingResponse responseObject = new InterlockingResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, interlockingRequest);
|
|
responseObject = getFailoverProxy().mesInterlocking(interlockingRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// <param name="name">description</param>
|
|
/// <returns>description</returns>
|
|
/// <seealso cref="MesRequest"/>
|
|
/// </summary>
|
|
public PanelInfoResponse mesPanelInformation(PanelInfoRequest infoRequest)
|
|
{
|
|
PanelInfoResponse responseObject = new PanelInfoResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, infoRequest);
|
|
responseObject = getFailoverProxy().mesPanelInformation(infoRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
|
|
public MesResponse mesItemProduced(ItemProducedRequest itemProducedRequest)
|
|
{
|
|
MesResponse responseObject = new MesResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, itemProducedRequest);
|
|
responseObject = getFailoverProxy().mesItemProduced(itemProducedRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesResponse mesMachineState(MachineStatusRequest machineStatus)
|
|
{
|
|
MesResponse responseObject = new MesResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, machineStatus);
|
|
responseObject = getFailoverProxy().mesMachineState(machineStatus);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesResponse mesMachineMessage(MachineMessageRequest machineMessage)
|
|
{
|
|
MesResponse responseObject = new MesResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, machineMessage);
|
|
responseObject = getFailoverProxy().mesMachineMessage(machineMessage);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesFailoverResponse mesGetFailoverList(MesRequest mesRequest)
|
|
{
|
|
MesFailoverResponse responseObject = new MesFailoverResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, mesRequest);
|
|
responseObject = getFailoverProxy().mesGetFailoverList(mesRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesResponse mesMaterialConsumed(MaterialConsumedRequest materialConsumedRequest)
|
|
{
|
|
MesResponse responseObject = new MesResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, materialConsumedRequest);
|
|
responseObject = getFailoverProxy().mesMaterialConsumed(materialConsumedRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
|
|
public MesConfigurationResponse mesGetConfiguration(MesRequest mesRequest)
|
|
{
|
|
MesConfigurationResponse responseObject = new MesConfigurationResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, mesRequest);
|
|
responseObject = getFailoverProxy().mesGetConfiguration(mesRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
finalizeRequest(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
|
|
public MesResponse mesStart(MesStartRequest mesRequest)
|
|
{
|
|
checkRequestPreconditons(mesRequest);
|
|
MesResponse responseObject = new MesResponse();
|
|
responseObject.setRequestId(mesRequest.getRequestId());
|
|
try
|
|
{
|
|
if (!isConfigured())
|
|
{
|
|
throw new PluginException(ResponseDetail.MES_NOT_CONFIGURED_PROPERLY, "");
|
|
}
|
|
|
|
if (isActive())
|
|
{
|
|
setResponseValues(responseObject, new ResponseDetail("", ResponseDetail.OK));
|
|
return responseObject;
|
|
}
|
|
|
|
|
|
// append own assembly vresion to mesStart message
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
responseObject = getFailoverProxy().mesStart(mesRequest);
|
|
stopWatch.Stop();
|
|
long millies = stopWatch.ElapsedMilliseconds;
|
|
log(TraceEventType.Information, "roundtrip = " + (millies) + " milliseconds");
|
|
if (responseObject.getTotalResult() == MES_RESULT_OK)
|
|
{
|
|
setActive(true);
|
|
startUpdateThread();
|
|
}
|
|
}
|
|
catch (PluginException cse)
|
|
{
|
|
handleThrowable(responseObject, cse);
|
|
}
|
|
finally
|
|
{
|
|
logResponse(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesResponse mesGetStatus(MesRequest mesRequest)
|
|
{
|
|
MesResponse responseObject = new MesResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, mesRequest);
|
|
responseObject = getFailoverProxy().mesGetStatus(mesRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
logResponse(responseObject);
|
|
}
|
|
return responseObject;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MesResponse mesStop(MesRequest mesRequest)
|
|
{
|
|
MesResponse responseObject = new MesResponse();
|
|
try
|
|
{
|
|
checkPreconditions(responseObject, mesRequest);
|
|
responseObject = getFailoverProxy().mesStop(mesRequest);
|
|
}
|
|
catch (Exception throwable)
|
|
{
|
|
handleThrowable(responseObject, throwable);
|
|
}
|
|
finally
|
|
{
|
|
logResponse(responseObject);
|
|
}
|
|
setActive(false);
|
|
stopUpdateThread();
|
|
return responseObject;
|
|
}
|
|
|
|
#endregion IMesServices_Member
|
|
|
|
#region UpdateThread
|
|
public void failoverThreadProc()
|
|
{
|
|
log(TraceEventType.Information, Thread.CurrentThread.Name + "renew failoverHost list thread started, call #" + (++runCounter));
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
mesGetFailoverList(new MesRequest());
|
|
log(TraceEventType.Information, Thread.CurrentThread.Name + "renew failoverHost list finished");
|
|
int millies = refreshFailoverhostsInterval;
|
|
if (millies == -1)
|
|
{
|
|
millies = DEFAULT_REFRESH_INTERVAL;
|
|
}
|
|
TimeSpan ts = TimeSpan.FromMilliseconds(millies);
|
|
log(TraceEventType.Information, Thread.CurrentThread.Name + "next failover resolving in " + ts.ToString());
|
|
Thread.Sleep(millies);
|
|
}
|
|
catch (ThreadAbortException)
|
|
{
|
|
log(TraceEventType.Error, Thread.CurrentThread.Name + "interrupted or failed");
|
|
break;
|
|
}
|
|
catch (ThreadInterruptedException)
|
|
{
|
|
log(TraceEventType.Error, Thread.CurrentThread.Name + "interrupted");
|
|
break;
|
|
}
|
|
}
|
|
log(TraceEventType.Information, Thread.CurrentThread.Name + "closed");
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.Synchronized)]
|
|
protected Thread getUpdateThread()
|
|
{
|
|
String threadName = "failoverUpdateThread#" + (updateThreadCount++);
|
|
Thread failoverUpdateThread = new Thread(new ThreadStart(failoverThreadProc));
|
|
|
|
// threadName) {
|
|
|
|
|
|
//};
|
|
log(TraceEventType.Error, Thread.CurrentThread.Name + "created");
|
|
return failoverUpdateThread;
|
|
}
|
|
|
|
protected void startUpdateThread()
|
|
{
|
|
// if connection is established and OK start observation thread
|
|
if (failoverUpdateThread == null)
|
|
{
|
|
failoverUpdateThread = getUpdateThread();
|
|
failoverUpdateThread.Start();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* the current active channel was closed (port closed on DataInterface)
|
|
*
|
|
* @param channelName
|
|
*/
|
|
protected void stopUpdateThread()
|
|
{
|
|
log(TraceEventType.Information, " was closed by iTAC.MES.Suite DataInterface");
|
|
|
|
// den Ueberwachungsthread stoppen
|
|
if (failoverUpdateThread != null)
|
|
{
|
|
log(TraceEventType.Information, " stop " + failoverUpdateThread.Name + " now");
|
|
failoverUpdateThread.Interrupt();
|
|
failoverUpdateThread = null;
|
|
}
|
|
}
|
|
private void addError(ref ErrorDetail[] errorDetail1, ErrorDetail errorDetail2)
|
|
{
|
|
if (errorDetail1 == null)
|
|
{
|
|
errorDetail1 = new ErrorDetail[0];
|
|
}
|
|
int newArrSize = errorDetail1.Length + 1;
|
|
Array.Resize<ErrorDetail>(ref errorDetail1, newArrSize);
|
|
errorDetail1[newArrSize - 1] = errorDetail2;
|
|
}
|
|
#endregion UpdateThread
|
|
|
|
}
|
|
|
|
}
|