public CollectorLog(ITransporter transporter)
{
_transporter = transporter;
_appsUsed = new List<uint>(200);
_appUsedTimes = new List<float>(200);
_appNames = new Dictionary<string, uint>(200);
}
private void UpdateConnection(int tryNum = 0)
{
tryNum++;
try
{
if (transporter != null)
{
transporter.Dispose();
}
logger.LogInformation($"try get new transporter try {tryNum}");
transporter = providerTransporterCreator();
transporter.OnNeedNewInstance += NeedNewInstance;
transporter.OnConnectionLost += () =>
{
Console.WriteLine("CONNECTION LOST :( try to reconnect");
UpdateConnection(tryNum);
};
}
catch (SocketException sockEx)
{
logger.LogWarning(sockEx, "Error while connecting to remote host");
UpdateConnection(tryNum);
}
catch (AggregateException aggrEx)
{
logger.LogWarning(aggrEx, "Error while connecting to remote host");
UpdateConnection(tryNum);
}
catch (Exception ex)
{
logger.LogError(ex, "Unexpected error while creating ITransporter");
throw;
}
}
public PomeloClient(ClientProtocolType type = ClientProtocolType.NORMAL,
byte[] clientcert = null, string clientpwd = "", string cathumbprint = null)
{
this.client_type = type;
switch (this.client_type)
{
case ClientProtocolType.TLS:
{
transport = new TransporterSSL(clientcert, clientpwd, cathumbprint);
}
break;
case ClientProtocolType.NORMAL:
{
transport = new TransporterTCP();
}
break;
default:
break;
}
this.protocol = new Protocol(transport, processMessage, OnProtocolClose);
this.transport.setOnStateChanged(OnTransportStateChange);
eventManager = new EventManager();
}
public CollectorLog(ITransporter transporter)
{
_transporter = transporter;
_appsUsed = new List <uint>(200);
_appUsedTimes = new List <float>(200);
_appNames = new Dictionary <string, uint>(200);
}
internal static object Create(Type workerType, ITransporter transporter, long serviceId, bool disposeWrapped = false)
{
CheckType(workerType);
return(proxyGenerator.CreateInterfaceProxyWithoutTarget(
workerType,
new RemoteWorker(transporter, serviceId, disposeWrapped)));
}
public static ITransporter GetTransporter(AssetBundleManagerConfig cfg)
{
ITransporter transporter = null;
switch (cfg.bundleTarget)
{
case AssetBundleTarget.ASSET_BUNDLE_FOLDER:
case AssetBundleTarget.STREAMING_ASSETS:
transporter = new TransportFromDisk();
break;
case AssetBundleTarget.LOCAL_SERVER:
case AssetBundleTarget.REMOTE_SERVER:
case AssetBundleTarget.OBB:
case AssetBundleTarget.ON_DEMAND_RESOURCES:
case AssetBundleTarget.APP_SLICING:
transporter = new TransportFromWeb();
break;
}
if (transporter == null)
{
Debug.LogError(
"Could not get Transporter using AssetBundleTarget option. " +
"AssetBundleConfig.bundleTarget value is " +
Enum.GetName(typeof(AssetBundleTarget), cfg.bundleTarget));
}
return(transporter);
}
public MUnitServer(ITestEngine testEngine, ITransporter serverWorker)
: base(testEngine, serverWorker)
{
_logger.TestResultsEvent += TestResultEventHandlerAsync;
_logger.TestStartEvent += this.TestStartEventHandler;
_logger.TestEndEvent += this.TestEndEventHandler;
}
/// <summary>
/// Initializes a new instance of the <see cref="MUnitWire"/> class.
/// </summary>
/// <param name="testEngine"> Test engine supported by this transporter. </param>
/// <param name="transporter"> Transporter used for IPC. </param>
public MUnitWire(ITestEngine testEngine, ITransporter transporter)
{
ThrowUtilities.NullArgument(testEngine, nameof(testEngine));
ThrowUtilities.NullArgument(transporter, nameof(transporter));
_logger = testEngine.Logger;
_transporter = transporter;
_testEngine = testEngine;
}
public TransportDispatcher(ITransporter transporter)
{
this.transporter = transporter;
transmitTimer = new Timer(100);
transmitTimer.Elapsed += this.OnTimeTxQueue;
transmitTimer.Enabled = true;
sequenceNumber = 0;
guaranteedCmdRetry = 0;
}
public Protocol(ITransporter transproter, Action <Message> messageProcessor, Action onProtoClose)
{
this.transporter = transproter;
this.transporter.onReceive(this.processMessage);
this.onProtocolClose += onProtoClose;
this.messageProcessor += messageProcessor;
this.handshake = new HandShakeService(this);
this.state = ProtocolState.ready;
}
private RemoteWorker(ITransporter transporter, long objectId, bool wrapped)
{
this.transporter = transporter;
this.objectId = objectId;
this.wrapped = wrapped;
transporter.OnReceiveResult += Transporter_OnReceiveResult;
transporter.OnConnectionLost += () =>
{
Console.WriteLine("client connection aborted");
aborted = true;
};
}
public MoleculerService(ILogger <MoleculerService> logger, IApplicationLifetime appLifetime, ITransporter transporter, LocalActionServicesLoader localServices, IServiceExecutor executor, IServiceLocator serviceLocator)
{
_logger = logger;
_appLifetime = appLifetime;
_transporter = transporter;
_localServices = localServices;
_executor = executor;
_serviceLocator = serviceLocator;
_serviceInfo = new ServiceInfo();
FillHostInfo();
}
/// <summary>
/// Send the audit
/// </summary>
private static void SendAudit(AuditMessage message)
{
var endpoint = new Uri(ConfigurationManager.AppSettings["arrEndpoint"]);
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(endpoint.Host), endpoint.Port);
ITransporter transport = null;
switch (endpoint.Scheme)
{
case "udp":
transport = new UdpSyslogTransport(ipep);
break;
case "tcp":
transport = new TcpSyslogTransport(ipep);
break;
case "stcp":
String localCertHash = ConfigurationManager.AppSettings["myCertificateHash"],
remoteCertHash = ConfigurationManager.AppSettings["remoteCertificateHash"];
// Certs
X509Certificate2 localCert = null, remoteCert = null;
if (localCertHash != null)
{
string[] parts = localCertHash.Split(',');
StoreLocation loc = (StoreLocation)Enum.Parse(typeof(StoreLocation), parts[0]);
StoreName name = (StoreName)Enum.Parse(typeof(StoreName), parts[1]);
localCert = MllpMessageSender.FindCertificate(name, loc, X509FindType.FindByThumbprint, parts[2]);
}
if (remoteCertHash != null)
{
string[] parts = remoteCertHash.Split(',');
StoreLocation loc = (StoreLocation)Enum.Parse(typeof(StoreLocation), parts[0]);
StoreName name = (StoreName)Enum.Parse(typeof(StoreName), parts[1]);
remoteCert = MllpMessageSender.FindCertificate(name, loc, X509FindType.FindByThumbprint, parts[2]);
}
transport = new STcpSyslogTransport(ipep)
{
ClientCertificate = localCert,
ServerCertificate = remoteCert
};
break;
}
// Now now now... we send
transport.SendMessage(message);
}
/// <summary>
/// Creates a new instance of the ATNA audit service
/// </summary>
public AtnaAuditService()
{
this.m_configuration = ApplicationServiceContext.Current.GetService <IConfigurationManager>().GetSection <AtnaConfigurationSection>();
switch (this.m_configuration.Transport)
{
case AtnaTransportType.File:
this.m_transporter = new FileSyslogTransport()
{
EndPoint = this.m_configuration.AuditTarget,
MessageFormat = this.m_configuration.Format
};
break;
case AtnaTransportType.Stcp:
this.m_transporter = new STcpSyslogTransport()
{
ClientCertificate = this.m_configuration?.ClientCertificate?.Certificate,
EndPoint = this.m_configuration.AuditTarget,
MessageFormat = this.m_configuration.Format,
ServerCertificate = this.m_configuration?.ServerCertificate?.Certificate
};
break;
case AtnaTransportType.Tcp:
this.m_transporter = new TcpSyslogTransport()
{
EndPoint = this.m_configuration.AuditTarget,
MessageFormat = this.m_configuration.Format,
};
break;
case AtnaTransportType.Udp:
this.m_transporter = new UdpSyslogTransport()
{
EndPoint = this.m_configuration.AuditTarget,
MessageFormat = this.m_configuration.Format,
};
break;
default:
throw new InvalidOperationException($"Invalid transport type {this.m_configuration.Transport}");
}
}
/// <summary>
/// Initialises a new instance of the <see cref="Bus"/> class.
/// </summary>
/// <param name="hostAddress">The address this service bus can be reached.</param>
/// <param name="transporter">The protocol to use to communicate with other <see cref="IServiceBus"/>es.</param>
/// <param name="queueManager">The message persistence service to use.</param>
/// <param name="log">The <see cref="log4net.ILog"/> to use with this service bus instance.</param>
internal Bus(Uri hostAddress, ITransporter transporter, IQueueManager queueManager, ILog log)
{
this._disposed = false;
this.PeerAddress = hostAddress;
this._transport = transporter;
this._queueManager = queueManager;
this._messageRouter = new MessageRouter(this._queueManager, this);
this._logger = log;
this._loggingEventHandler = new LoggingEventHandler(this);
this.RegisterSystemMessages();
this.RegisterSystemEventHandlers();
this.RegisterInternalEvents();
}
public bool Init(NodeGraph g, INode upstream, Vector3 start, INode downstream, Vector3 end)
{
if (upstream == null || downstream == null)
{
return(false);
}
// Create transport connector
var connector = new Connector(upstream.GetNode(), downstream.GetNode());
if (!g.AddConnector(connector))
{
return(false);
}
startPosition = start;
endPosition = end;
sqrMagnitude = (end - start).sqrMagnitude;
length = Graph.DistanceToConnectorLength(Vector3.Distance(start, end));
step = Vector3.Lerp(Vector3.zero, end - start, (float)1 / length);
velocity = step * ((float)speed / ticker.UpdatesPerTick);
transporter = new SupplyChain.Transporter(connector, ticker, length, rate.Get(), speed);
transporter.PacketsMoved += TransporterOnPacketsMoved;
transporter.Disconnected += TransporterOnDisconnected;
// Set collider
lineCollider.SetCollider(start, end, transform.position.z);
// Display line
lr.enabled = false;
lr.positionCount = 2;
lr.SetPosition(0, start);
lr.SetPosition(1, end);
lr.enabled = true;
rotation = Quaternion.FromToRotation(Vector2.up, end - start);
return(true);
}
public void Update()
{
if (freeStreams == 0)
{
return;
}
for (int i = 0; i < loadOps.numSpawned; ++i)
{
BundleLoadOperation op = loadOps.GetInstance(i);
// This prevents the manager from loading bundles from a single loadop in parallell
// Should check number of bundles left to load.
// A LoadOp is not necessarily done just because there are no mor bundles to load.
//if (op.bundlesLeftToLoad == 0) {
// continue;
//}
if (!op.canLoadBundle)
{
continue;
}
if (freeStreams == 0)
{
return;
}
// Debug.Log("LoadOp "+i+" has "+op.bundlesLeftToLoad+" bundles left to load");
// Debug.Log("LoadOp "+i+" is ready");
ITransporter transporter = BundlesHelper.GetTransporter(config);
// Debug.Log("Got transporter "+transporter.GetType());
// Debug.Log("Start transporter on stream "+streams.Count);
string path = BundlesHelper.GetPath(config, BundlesHelper.GetPlatformName());
streams.Add(loader.StartCoroutine(transporter.Load(op, streams.Count, path)));
// Debug.Log("Streams: "+streams.Count);
--freeStreams;
// Debug.Log("Started loading stream. Streams: "+streams.Count+" free streams: "+freeStreams);
}
}
private IExchangeServer CreateServer(URL url)
{
// send readonly event when server closes, it's enabled by default
url = url.AddParameterIfAbsent(Constants.ChannelReadonlyeventSentKey, "true");
// enable heartbeat by default
url = url.AddParameterIfAbsent(Constants.HeartbeatKey, Constants.DefaultHeartbeat.ToString());
var str = url.GetParameter(Constants.ServerKey, Constants.DefaultRemotingServer);
ITransporter transporter = null;
if (!string.IsNullOrEmpty(str))
{
transporter = ObjectFactory.GetInstance <ITransporter>(str);
}
if (transporter == null)
{
throw new Exception("Unsupported server type: " + str + ", url: " + url);
}
url = url.AddParameter(Constants.CodecKey, DubboCodec.Name);
IExchangeServer server;
try
{
server = Exchangers.BindAsync(url, RequestHandler()).Result;
}
catch (RemotingException e)
{
throw new Exception("Fail to start server(url: " + url + ") " + e.Message);
}
str = url.GetParameter(Constants.ClientKey, "");
if (!string.IsNullOrEmpty(str))
{
var supportedTypes = ObjectFactory.GetTypeKeys <ITransporter>();
if (!supportedTypes.Contains(str))
{
throw new Exception("Unsupported client type: " + str);
}
}
return(server);
}
public bool Equals(ITransporter other)
{
return(Equals(this, other));
}
public Stream Read(ITransporter transporter, StreamPipeline pipeline)
{
//TODO ExceptionHandling
return(transporter.Read());
}
public void Write(ITransporter transporter, StreamPipeline pipeline, Stream content)
{
//TODO ExceptionHandling
transporter.Write(content);
}
public DataSet Read(IFormatter formatter, ITransporter transporter, StreamPipeline pipeline)
{
//TODO ExceptionHandling
return(formatter.ReadFromStream(transporter.Read()));
}
public void Write(IFormatter formatter, ITransporter transporter, StreamPipeline pipeline, DataSet dataSet)
{
//TODO ExceptionHandling
transporter.Write(formatter.WriteToStream(dataSet));
}
public Collector(ITransporter transporter)
: this(new WindowsOperatingSystem(), new CollectorLog(transporter))
{
}
public Collector(ITransporter transporter)
: this(new WindowsOperatingSystem(), new CollectorLog(transporter))
{
}
/// <summary>
/// Initialises a new instance of the <see cref="TransportConfiguration"/> class.
/// </summary>
/// <param name="hostAddress">The <see cref="IHostAddressConfiguration"/>.</param>
/// <param name="transporter">The <see cref="ITransporter"/> for the <see cref="IServiceBus"/> to use.</param>
public TransportConfiguration(IHostAddressConfiguration hostAddress, ITransporter transporter)
: base(hostAddress)
{
this.Transporter = transporter;
}
public Capture(TimeSpan timeToCapture, WebCam camera, ITransporter transporter)
{
_timeToCapture = timeToCapture;
_camera = camera;
_transporter = transporter;
}
public InstanceWrapper(CodeInvoker invoker, ITransporter transporter)
: this(invoker)
{
transporter.OnReceiveMessge += RecieveMessage;
this.transporter = transporter;
}
void INetworkModuleBase.SetTransporter(ITransporter transporter)
{
this.transporter = transporter;
}
/// <summary>
/// Initializes a new instance of the <see cref="MUnitClient"/> class.
/// </summary>
/// <param name="testEngine"> Test engine supported by this transporter. </param>
/// <param name="transporter"> Transporter used for IPC. </param>
public MUnitClient(ITestEngine testEngine, ITransporter transporter)
: base(testEngine, transporter)
{
}
/// <summary>
/// Initialises a new instance of the <see cref="TransportConfiguration"/> class.
/// </summary>
/// <param name="hostAddress">The <see cref="IHostAddressConfiguration"/>.</param>
/// <param name="transporter">The <see cref="ITransporter"/> for the <see cref="IServiceBus"/> to use.</param>
public TransportConfiguration(IHostAddressConfiguration hostAddress, ITransporter transporter)
: base(hostAddress)
{
this.Transporter = transporter;
}
public Transportation(ITransporter t) => _tporter = t;
public Context(ITransporter transporter, IServiceLocator locator)
{
_transporter = transporter;
_locator = locator;
_transporter.ResponseReceived += _transporter_ResponseReceived;
}
void INetworkModule <TState> .SetTransporter(ITransporter transporter)
{
this.transporter = transporter;
}
