protected void Page_Load(object sender, EventArgs e)
{
try
{
pmtMessage1 = this.GetLocalResourceObject(Pre + "_pmtMessage1").ToString();
pmtMessage2 = this.GetLocalResourceObject(Pre + "_pmtMessage2").ToString();
pmtMessage3 = this.GetLocalResourceObject(Pre + "_pmtMessage3").ToString();
//pmtMessage4 = this.GetLocalResourceObject(Pre + "_pmtMessage4").ToString();
//pmtMessage5 = this.GetLocalResourceObject(Pre + "_pmtMessage5").ToString();
//pmtMessage6 = this.GetLocalResourceObject(Pre + "_pmtMessage6").ToString();
iForwarder = (IForwarder)ServiceAgent.getInstance().GetMaintainObjectByName<IForwarder>(WebConstant.MaintainForwarderObject);
if (!this.IsPostBack)
{
userName = Master.userInfo.UserId;
this.HiddenUserName.Value = userName;
initLabel();
today = iForwarder.GetCurDate().ToString("yyyy-MM-dd");
this.dUploadDate.Text = today;
bindTable(null, DEFAULT_ROWS);
setColumnWidth();
}
}
catch (FisException ex)
{
showErrorMessage(ex.mErrmsg);
}
catch (Exception ex)
{
showErrorMessage(ex.Message);
}
}
public static ushort SendSubscriptionRequest(this IForwarder forwarder, IEnumerable <SubscriptionRequest> requests)
{
var request = CreateSubscribeRequest(requests);
forwarder.Dispatch(request);
return(request.Id);
}
public HttpForwarderHubLifetimeManager(
MessageSenderHubLifetimeManager <THub> messageSender,
IForwarder forwarder)
{
_messageSender = messageSender;
_forwarder = forwarder;
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
iForwarder = (IForwarder)ServiceAgent.getInstance().GetMaintainObjectByName<IForwarder>(WebConstant.MaintainForwarderObject);
if (!this.IsPostBack)
{
System.Configuration.Configuration config = WebConfigurationManager.OpenWebConfiguration("~");
HttpRuntimeSection section = (HttpRuntimeSection)config.GetSection("system.web/httpRuntime");
double maxFileSize = Math.Round(section.MaxRequestLength / 1024.0, 1);
this.hidFileMaxSize.Value = maxFileSize.ToString();
this.Title = this.GetLocalResourceObject(Pre + "_title").ToString();
initLabel();
userName = Request.QueryString["userName"];
userName = StringUtil.decode_URL(userName);
this.HiddenUserName.Value = userName;
}
pmtMessage1 = this.GetLocalResourceObject(Pre + "_pmtMessage1").ToString();
this.hidMsg1.Value = pmtMessage1;
}
catch (FisException ex)
{
showErrorMessage(ex.mErrmsg);
}
catch (Exception ex)
{
showErrorMessage(ex.Message);
}
}
public LcdpServer(ILcdpPacketSerializer lcdpPacketSerializer, IListener listener, IForwarder forwarder, IResolver resolver)
{
this.lcdpPacketSerializer = lcdpPacketSerializer;
this.listener = listener;
this.forwarder = forwarder;
this.messages = new ConcurrentDictionary<string, LcdpMessage>();
this.ChunkExpirationTimeMilliseconds = 5000;
this.compressors = new Dictionary<byte, ICompressor>();
this.serializers = new Dictionary<byte, ISerializer>();
for(byte b = 0; b < byte.MaxValue; ++b)
{
ICompressor compressor = resolver.Resolve<ICompressor>(b.ToString());
if (compressor != null)
{
compressors[b] = compressor;
}
ISerializer serializer = resolver.Resolve<ISerializer>(b.ToString());
if (serializer != null)
{
serializers[b] = serializer;
}
}
}
/// <summary>
/// Use the arguments to create the forwarder and set the other options
/// </summary>
/// <param name="arguments">The argument list to use</param>
/// <returns>If it was a success or not</returns>
static bool CreateResources(string[] arguments)
{
(bool success, string outIp, int inPort, int outPort, string comName, int baudRate, bool debug, bool copyPast) = LoadArguments(arguments);
if (success)
{
copypastForwarder = copyPast;
Program.Debug = debug;
if (debug)
{
Console.WriteLine("Creating UDP clients");
}
recievingUdp = new UdpClient(inPort);
sendingUdp = new UdpClient(outIp, outPort);
if (debug)
{
Console.WriteLine("Doing serial name check");
}
if (!SerialPort.GetPortNames().Contains(comName))
{
Console.WriteLine($"Could not find a serial port with the name '{comName}'");
return(false);
}
else
{
if (debug)
{
Console.WriteLine("Creating and opening serial port");
}
port = new SerialPort(comName)
{
BaudRate = baudRate,
};
port.Open();
cancellationToken = new CancellationTokenSource();
if (copypastForwarder)
{
forwarder = new BasicForwarder(port, sendingUdp, recievingUdp, cancellationToken.Token);
}
else
{
forwarder = new SmartForwarder(port, sendingUdp, recievingUdp, cancellationToken.Token);
}
forwarder.Start();
return(true);
}
}
else
{
return(false);
}
}
public void CreateContext(string channelId, string channelRef, string transactionId, string HAPIObjectName)
{
this.channelId = channelId;
this.channelRef = channelRef;
this.transactionId = transactionId;
this.HAPIObjectName = HAPIObjectName;
try
{
GetWebConfig(channelId, out forwarder, out debugTransaction, out debugMessages, out transactionFile, out directory, out userdata);
}
catch (Exception e)
{
Exception WebConfigError = new Exception("WebConfigError: File format error", e);
throw (WebConfigError);
}
if (string.IsNullOrEmpty(debugTransaction))
{
Exception WebConfigContentsMissing = new Exception("WebConfigError: No entry matches ChannelId or entry incomplete");
throw (WebConfigContentsMissing);
}
LogTransaction("Enter");
switch (forwarder)
{
case "NullForwarder":
{
forwarderClass = new NullForwarder();
}
break;
default:
throw new Exception("Unknown forwarder: " + forwarder);
break;
}
if (forwarderClass != null)
{
forwarderClass.CreateContext(userdata, HAPIObjectName);
}
}
public BufferedForwarder(IForwarder innerForwarder)
{
this.InnerForwarder = innerForwarder;
}
internal static void ReadBufferAsync(IForwarder forwarder, IBufferReader bufferReader)
{
var buffer = bufferReader.Read();
var packet = Deserialize(buffer, out var bytesConsumed);
if (bytesConsumed == 0)
{
return;
}
switch (packet)
{
case Connect connect:
forwarder.Dispatch(connect);
break;
case ConnAck connAck:
forwarder.Dispatch(connAck);
break;
case Disconnect disconnect:
forwarder.Dispatch(disconnect);
break;
case PubAck pubAck:
forwarder.Dispatch(pubAck);
break;
case PubRel pubRel:
forwarder.Dispatch(pubRel);
break;
case PubRec pubRec:
forwarder.Dispatch(pubRec);
break;
case PubComp pubComp:
forwarder.Dispatch(pubComp);
break;
case PingReq pingReq:
forwarder.Dispatch(pingReq);
break;
case PingResp pingResp:
forwarder.Dispatch(pingResp);
break;
case Subscribe subscribe:
forwarder.Dispatch(subscribe);
break;
case SubAck subAck:
forwarder.Dispatch(subAck);
break;
case Unsubscribe unsubscribe:
forwarder.Dispatch(unsubscribe);
break;
case UnsubAck unsubAck:
forwarder.Dispatch(unsubAck);
break;
}
bufferReader.Advance(bytesConsumed);
}
/// <summary>
/// 转发
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="remote"></param>
/// <param name="messageID"></param>
/// <param name="extraMessage"></param>
/// <param name="messageBody"></param>
/// <param name="forwarder"></param>
public virtual void Forward <T>(T bufferReceiver, int messageID, ReadOnlyMemory <byte> extraMessage, ReadOnlyMemory <byte> messageBody, IForwarder forwarder)
where T : IRemoteID, IUID <int>
{
RoutingInformationModifier modifier = extraMessage;
if (modifier.Mode == RouteMode.Null)
{
modifier.Identifier = bufferReceiver.UID;
}
else if (modifier.Mode == RouteMode.Find)
{
modifier = new RoutingInformationModifier(extraMessage);
modifier.AddNode(bufferReceiver, forwarder);
}
else
{
modifier = new RoutingInformationModifier(extraMessage);
modifier.MoveCursorNext();
}
forwarder.SendAsync(Pack(messageID, extraMessage: modifier, messageBody.Span));
modifier.Dispose();
}
public AzureServiceBusHubLifetimeManagerTests()
{
_forwarder = A.Fake <IForwarder>();
_messageSender = A.Fake <MessageSenderHubLifetimeManager <TestHub> >();
_lifetimeManager = new HttpForwarderHubLifetimeManager <TestHub>(_messageSender, _forwarder);
}
public ConsoleAgentHost(IForwarder forwarder)
{
_forwarder = forwarder;
}
public static void SendDisconnectRequest(this IForwarder forwarder) => forwarder.Dispatch(Disconnect.Instance);
public static void SendConnectionRequest(this IForwarder forwarder, MqttConnectionSettings connectionSettings)
{
var connectPacket = CreateConnectPacket(connectionSettings);
forwarder.Dispatch(connectPacket);
}
public MessageForwarder(IForwarder <T> forwarder)
{
Ensure.NotNull(forwarder, "forwarder");
_forwarder = forwarder;
}
public void RegisterForwarder <T>(IForwarder <T> forwarder) where T : Message
{
Ensure.NotNull(forwarder, "forwarder");
_forwarders.Add(typeof(T), new MessageForwarder <T>(forwarder));
}
/// <summary>
/// 转发
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bufferReceiver"></param>
/// <param name="messageID"></param>
/// <param name="extraMessage"></param>
/// <param name="messageBody"></param>
/// <param name="forwarder"></param>
public virtual void Forward <T>(T bufferReceiver, int messageID, ReadOnlyMemory <byte> extraMessage, ReadOnlyMemory <byte> messageBody, IForwarder forwarder)
where T : IRemoteID, IUID <int>
{
RoutingInformationModifier modifier = extraMessage;
switch (modifier.Mode)
{
case EnumRouteMode.Null:
{
modifier.Identifier = bufferReceiver.UID;
break;
}
case EnumRouteMode.Find:
{
modifier = new RoutingInformationModifier(extraMessage);
modifier.AddNode(bufferReceiver, forwarder);
break;
}
case EnumRouteMode.Backward:
case EnumRouteMode.Forward:
default:
{
modifier = new RoutingInformationModifier(extraMessage);
modifier.MoveCursorNext();
break;
}
}
using (modifier)
{
forwarder.SendAsync(Pack(messageID, extraMessage: modifier, messageBody.Span));
}
}
public ForwardingServer(IListener listener, ISerializer deserializer, IForwarder forwarder, ILogger logger)
: base(listener, logger)
{
this.Forwarder = forwarder;
this.Deserializer = deserializer;
}
