public static IWebHost BuildWebHost(string[] args)
{
return(WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>()
.UseUrls("http://localhost:" + PortUtils.FindAvailablePortIncrementally(5050))
.Build());
}
public void PortTest1()
{
// (Moritz Eberl) At least for my machine
Assert.IsFalse(PortUtils.IsPortFree(1115));
Assert.IsTrue(PortUtils.IsPortFree(11150));
}
public static IPublishSubscribe Auto(string clusterId)
{
ILoggerFactory loggerFactory = new LoggerFactory().AddConsole(LogLevel.Debug);
Log.SetLoggerFactory(loggerFactory);
ISerializer <byte[]> serializer = new MessagePackSerializer();
IPublishSubscribe pubSub = new PublishSubscribeBuilder(new WireSerializer())
.SetClusterName(clusterId)
.SetSerializer(serializer)
.SetLoggerFactory(loggerFactory)
.ProtoActorPublishSubscribe()
//.GrpcPublishSubscribe(seedsEndpointObservable: Observable.Return(new[]
//{
// new DnsEndPoint("localhost", 35000),
// new DnsEndPoint("localhost", 35001),
// new DnsEndPoint("localhost", 35002),
// new DnsEndPoint("localhost", 35003)
//}))
.Build();
//ClusterBuilder.RunSeededLocalCluster(clusterId);
Cluster.Start("Abe", "localhost", PortUtils.FindAvailablePortIncrementally(36002), new ConsulProvider(new ConsulProviderOptions()));
return(pubSub);
}
public string GetNativeConnectionString(string instanceName, string username = "******", string password = "******")
{
Virtuoso v = _instances[instanceName];
int? port = PortUtils.GetPort(v.Configuration.Parameters.ServerPort);
return("Server=localhost:" + port + ";uid=" + username + ";pwd=" + password + ";Charset=utf-8");
}
public ICollection <HostUrlDetails> GetDetails()
{
var list = new List <HostUrlDetails>();
if (Urls == null)
{
int port = Port > 0 ? Port.Value : FindFreeTcpPort();
string protocol = UseSSL ? "https" : "http";
list.Add(new HostUrlDetails {
IsHttps = UseSSL, Url = $"{protocol}://{LOCALHOST}:{port}", Protocol = protocol, Host = LOCALHOST, Port = port
});
}
else
{
foreach (string url in Urls)
{
PortUtils.TryExtract(url, out bool isHttps, out string protocol, out string host, out int port);
list.Add(new HostUrlDetails {
IsHttps = isHttps, Url = url, Protocol = protocol, Host = host, Port = port
});
}
}
return(list);
}
public string GetConnectionString(string instanceName, string username = "******", string password = "******")
{
Virtuoso v = _instances[instanceName];
int?port = PortUtils.GetPort(v.Configuration.Parameters.ServerPort);
return(string.Format("provider=virtuoso;host=localhost;port={0};uid={1};pw={2}", port, username, password));
}
private int FindFreeTcpPort()
{
#if USE_ASPNETCORE || NETSTANDARD2_0 || NETSTANDARD2_1
return(0);
#else
return(PortUtils.FindFreeTcpPort());
#endif
}
private Task RunHost(CancellationToken token)
{
try
{
var appLifetime = (IApplicationLifetime)_host.Services.GetService(typeof(IApplicationLifetime));
appLifetime.ApplicationStarted.Register(() =>
{
var addresses = _host.ServerFeatures
.Get <Microsoft.AspNetCore.Hosting.Server.Features.IServerAddressesFeature>()
.Addresses;
foreach (string address in addresses)
{
Urls.Add(address.Replace("0.0.0.0", "localhost").Replace("[::]", "localhost"));
PortUtils.TryExtract(address, out bool isHttps, out string protocol, out string host, out int port);
Ports.Add(port);
}
IsStarted = true;
});
#if NETSTANDARD1_3
_logger.Info("WireMock.Net server using netstandard1.3");
#elif NETSTANDARD2_0
_logger.Info("WireMock.Net server using netstandard2.0");
#elif NETSTANDARD2_1
_logger.Info("WireMock.Net server using netstandard2.1");
#elif NETCOREAPP3_1
_logger.Info("WireMock.Net server using .NET Core 3.1");
#elif NET5_0
_logger.Info("WireMock.Net server using .NET 5.0");
#elif NET46
_logger.Info("WireMock.Net server using .NET Framework 4.6.1 or higher");
#endif
#if NETSTANDARD1_3
return(Task.Run(() =>
{
_host.Run(token);
}));
#else
return(_host.RunAsync(token));
#endif
}
catch (Exception e)
{
_runningException = e;
_logger.Error(e.ToString());
IsStarted = false;
return(Task.CompletedTask);
}
}
public static IDisposable RunSeededLocalCluster(string clusterId = null,
int port = 36100)
{
IPAddress ipAddress = NetworkUtils.GetLocalIpAddress().First();
int serverPort = PortUtils.FindAvailablePortIncrementally(port);
IPEndPoint[] seedsEndpoints = { new IPEndPoint(ipAddress, port), new IPEndPoint(ipAddress, serverPort) };
global::Proto.Cluster.Cluster.Start(clusterId, ipAddress.ToString(), serverPort,
new SeededLocalClusterProvider(Observable.Return(seedsEndpoints.Distinct())));
return(new AnonymousDisposable(() => global::Proto.Cluster.Cluster.Shutdown()));
}
public BusinessApiTests()
{
int port = PortUtils.FindFreeTcpPort();
Configuration config = new Configuration();
config.BasePath = "http://localhost:" + port;
config.ApiKey.Add("x-trulioo-api-key", TEST_API_KEY);
businessApi = new BusinessApi(config);
mockServer = WireMockServer.Start(port);
}
public Task StartAsync()
{
_host = new WebHostBuilder()
.ConfigureServices(services =>
{
services.AddSingleton(_options.FileSystemHandler);
services.AddSingleton(_options);
services.AddSingleton <IMappingMatcher, MappingMatcher>();
services.AddSingleton <IOwinRequestMapper, OwinRequestMapper>();
services.AddSingleton <IOwinResponseMapper, OwinResponseMapper>();
})
.Configure(appBuilder =>
{
appBuilder.UseMiddleware <GlobalExceptionMiddleware>();
_options.PreWireMockMiddlewareInit?.Invoke(appBuilder);
appBuilder.UseMiddleware <WireMockMiddleware>();
_options.PostWireMockMiddlewareInit?.Invoke(appBuilder);
})
.UseKestrel(options =>
{
#if NETSTANDARD1_3
if (_urls.Any(u => u.StartsWith("https://", StringComparison.OrdinalIgnoreCase)))
{
options.UseHttps(PublicCertificateHelper.GetX509Certificate2());
}
#else
// https://docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel?tabs=aspnetcore2x
foreach (string url in _urls.Where(u => u.StartsWith("http://", StringComparison.OrdinalIgnoreCase)))
{
PortUtils.TryExtract(url, out string protocol, out string host, out int port);
options.Listen(System.Net.IPAddress.Any, port);
}
foreach (string url in _urls.Where(u => u.StartsWith("https://", StringComparison.OrdinalIgnoreCase)))
{
PortUtils.TryExtract(url, out string protocol, out string host, out int port);
options.Listen(System.Net.IPAddress.Any, port, listenOptions =>
{
listenOptions.UseHttps(PublicCertificateHelper.GetX509Certificate2());
});
}
#endif
})
#if NETSTANDARD1_3
.UseUrls(_urls)
#endif
.Build();
return(RunHost(_cts.Token));
}
public static void Validate(IContainPort instance)
{
if ((1 > instance.Port) || (49151 < instance.Port))
{
throw new EngineValidationException("Port number is not between 1 and 65535");
}
if (!PortUtils.CheckAvailable(instance.Port))
{
throw new EngineValidationException($"Port {instance.Port} is not available");
}
}
public static void Validate(IHttpInstance instance)
{
if (instance.Port < 1 || instance.Port > 49151)
{
throw new EngineValidationException("Port number is not between 1 and 49151");
}
if (!PortUtils.CheckAvailable(instance.Port))
{
throw new EngineValidationException($"Port {instance.Port} is not available");
}
}
public static IRuleBuilderOptions <T, string> PortAvailable <T>(this IRuleBuilder <T, string> ruleBuilder)
{
return(ruleBuilder.Must((t, port) =>
{
if (int.TryParse(port, out var result))
{
return PortUtils.CheckAvailable(result);
}
return false;
})
.WithMessage(MSG_PORT_IN_USE));
}
/// <summary>
/// 初始化udp
/// </summary>
public void Connect()
{
udpClient = new UdpClient(PortUtils.GetNewPort());
UdpState s = new UdpState();
s.e = e;
s.u = udpClient;
udpClient.BeginReceive(new AsyncCallback(ReceiveBuffer), s);
EventSystem.RegisterEvent(EventID.send_udp_buffer, SendBuffer);
EventSystem.RegisterEvent(EventID.receive_udp_buffer, ReceiveUdpBuffer);
//去初始udp
EventSystem.DispatchEvent(EventID.udp_init_success);
}
public void PortUtils_TryExtract_InvalidUrl_Returns_False()
{
// Assign
string url = "test";
// Act
bool result = PortUtils.TryExtract(url, out string proto, out string host, out int port);
// Assert
Check.That(result).IsFalse();
Check.That(proto).IsNull();
Check.That(host).IsNull();
Check.That(port).IsEqualTo(default(int));
}
public void PortUtils_TryExtract_ValidUrl1_Returns_True()
{
// Assign
string url = "https://wiremock.net:5000";
// Act
bool result = PortUtils.TryExtract(url, out string proto, out string host, out int port);
// Assert
Check.That(result).IsTrue();
Check.That(proto).IsEqualTo("https");
Check.That(host).IsEqualTo("wiremock.net");
Check.That(port).IsEqualTo(5000);
}
public bool Start(bool waitOnStartup = true, TimeSpan?timeout = null)
{
_job = new Job();
STARTUPINFO si = new STARTUPINFO();
si.wShowWindow = 0;
PROCESS_INFORMATION pi = new PROCESS_INFORMATION();
bool success = Win32Process.CreateProcess(Executable, string.Format("{0} {1}", Executable, Parameter),
IntPtr.Zero, IntPtr.Zero, false,
ProcessCreationFlags.NORMAL_PRIORITY_CLASS |
ProcessCreationFlags.CREATE_NO_WINDOW |
ProcessCreationFlags.STARTF_USESTDHANDLES |
ProcessCreationFlags.CREATE_BREAKAWAY_FROM_JOB,
IntPtr.Zero, _workingDir.FullName, ref si, out pi);
_job.AddProcess(pi.hProcess);
_process = Process.GetProcessById((int)pi.dwProcessId);
if (success && waitOnStartup)
{
double time = 0;
if (timeout.HasValue)
{
time = timeout.Value.TotalMilliseconds;
}
while (!_serverStartOccured)
{
_serverStartOccured = !PortUtils.IsPortFree(Port);
if (!_serverStartOccured)
{
Thread.Sleep(10);
if (timeout.HasValue)
{
time -= 10;
if (time <= 0)
{
break;
}
}
}
}
}
return(success);
}
public void PortUtils_TryExtract_Https0_0_0_0_Returns_True()
{
// Assign
string url = "https://0.0.0.0:5000";
// Act
bool result = PortUtils.TryExtract(url, out bool isHttps, out string proto, out string host, out int port);
// Assert
Check.That(result).IsTrue();
Check.That(proto).IsEqualTo("https");
Check.That(host).IsEqualTo("0.0.0.0");
Check.That(port).IsEqualTo(5000);
}
public RTPServer GetOrAddServer(string videoId)
{
if (_rtpServers.ContainsKey(videoId))
{
return(_rtpServers[videoId]);
}
else
{
int port = PortUtils.GetFreeRTPPort();
RTPServer rs = new RTPServer(port, videoId);
rs.TargetsCleared += Rs_TargetsCleared;
_rtpServers[videoId] = rs;
return(rs);
}
}
public void PortUtils_TryExtract_Https_Returns_True()
{
// Assign
string url = "https://wiremock.net:5000";
// Act
bool result = PortUtils.TryExtract(url, out bool isHttps, out string proto, out string host, out int port);
// Assert
result.Should().BeTrue();
isHttps.Should().BeTrue();
proto.Should().Be("https");
host.Should().Be("wiremock.net");
port.Should().Be(5000);
}
public MongoDbServerProcess CreateMongoDbServerProcess()
{
var host = "127.0.0.1";
var port = PortUtils.GetFreePortNumber();
var workingDirectory = getTempWorkingDirectory();
return(new MongoDbServerProcess()
{
WorkingDirectory = workingDirectory,
FileName = getMongoDbDeamonPath(),
Arguments = getMongoDbServerArguments(port, host, workingDirectory),
ServerPort = port,
ServerHost = host
});
}
public void PortUtils_TryExtract_UrlIsMissingPort_Returns_False()
{
// Assign
string url = "http://0.0.0.0";
// Act
bool result = PortUtils.TryExtract(url, out bool isHttps, out string proto, out string host, out int port);
// Assert
result.Should().BeFalse();
isHttps.Should().BeFalse();
proto.Should().BeNull();
host.Should().BeNull();
port.Should().Be(default(int));
}
public VncServer(int listenerPort = 0)
: base(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
working = true;
ListenerPortOfServer = listenerPort;
if (listenerPort == 0)
{
listenerPort = PortUtils.GetFreePort();
}
Bind(new IPEndPoint(IPAddress.Any, listenerPort));
Listen(Constants.MAX_PENDING_CONNECTION);
DataArrived += new DataArrivedEventHandler(DataArrivedHandler);
Task.Factory.StartNew(() => { ListenerEngine(); });
Task.Factory.StartNew(() => { ScreenSender(); });
}
public static void Validate(IDatabaseMaintenanceSupport instance)
{
if (!instance.DatabaseMaintenancePort.HasValue)
{
throw new EngineValidationException("Maintenance port number is not set");
}
if (instance.DatabaseMaintenancePort < 1 || instance.DatabaseMaintenancePort > 49151)
{
throw new EngineValidationException("Maintenance port number is not between 1 and 49151");
}
if (!PortUtils.CheckAvailable(instance.DatabaseMaintenancePort.Value))
{
throw new EngineValidationException($"Port {instance.DatabaseMaintenancePort} is not available");
}
}
public ProtoClusterRxBroker(IClusterProvider clusterProvider)
{
Props props = Actor.FromProducer(() => new BrokerMasterActor());
Remote.RegisterKnownKind(nameof(BrokerMasterActor), props);
Serialization.RegisterFileDescriptor(BrokerReflection.Descriptor);
Remote.Start("127.0.0.1", PortUtils.FindAvailablePort());
//Cluster.Start("MyCluster", clusterProvider);
//PID brokerMasterPid = Cluster.GetAsync("Master", nameof(BrokerMasterActor)).Result;
//Cluster.GetAsync("Master2", nameof(BrokerMasterActor)).Wait();
//Cluster.GetAsync("Master" + Guid.NewGuid(), nameof(BrokerMasterActor)).Wait();
//props = Actor.FromProducer(() => new BrokerActor(brokerMasterPid));
//_brokerPid = Actor.SpawnNamed(props, "Broker");
}
public OrleansStartup(string clusterName)
{
ILoggerFactory loggerFactory = new NullLoggerFactory();
ISerializer <byte[]> serializer = new MessagePackSerializer();
PublishSubscribe = new PublishSubscribeBuilder(new WireSerializer())
.SetLoggerFactory(loggerFactory)
.SetSerializer(serializer)
.ProtoActorPublishSubscribe()
.Build();
// Start ProtoActor Cluster
int serverPort = PortUtils.FindAvailablePortIncrementally(41000);
Cluster.Start("unique", "127.0.0.1", serverPort,
new SeededLocalClusterProvider(Observable.Return(new[] { new IPEndPoint(IPAddress.Loopback, 41000) })));
}
public OwinSelfHost([NotNull] IWireMockMiddlewareOptions options, [NotNull] params string[] uriPrefixes)
{
Check.NotNull(options, nameof(options));
Check.NotNullOrEmpty(uriPrefixes, nameof(uriPrefixes));
_logger = options.Logger ?? new WireMockConsoleLogger();
foreach (string uriPrefix in uriPrefixes)
{
Urls.Add(uriPrefix);
PortUtils.TryExtract(uriPrefix, out string protocol, out string host, out int port);
Ports.Add(port);
}
_options = options;
}
/// <summary>
/// Starts the
/// </summary>
public bool Start(bool waitOnStartup = true, TimeSpan?timeout = null)
{
bool res = false;
if (_starter == null)
{
int?port;
if (AutoPort)
{
do
{
port = 35000 + _rnd.Next(10, 60);
} while (!PortUtils.TestPort(port.Value));
Configuration.Parameters.ServerPort = string.Format("localhost:{0}", port.Value);
Configuration.SaveConfigFile();
}
else
{
port = PortUtils.GetPort(_config.Parameters.ServerPort);
if (!port.HasValue)
{
throw new ArgumentException("No valid port given.");
}
}
_config.Locked = true;
string param = "";
if (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX)
{
_starter = new UnixVirtuosoStarter(port.Value, _binary.Directory, _configFile.Directory);
param = string.Format("-f -c \"{0}\"", _configFile.FullName);
}
else
{
_starter = new Win32VirtuosoStarter(port.Value, _binary.Directory, _configFile.Directory);
param = string.Format("-f -c \"{0}\"", _configFile.FullName);
}
_starter.Executable = _binary.FullName;
_starter.Parameter = param;
res = _starter.Start(waitOnStartup, timeout);
}
return(res);
}
protected override void ProcessRecord()
{
foreach (var port in Port)
{
try
{
WriteObject(new PsPortAvailability
{
Port = port,
Available = PortUtils.CheckAvailable(port)
});
}
catch (Exception ex)
{
WriteError(new ErrorRecord(ex, null, ErrorCategory.InvalidOperation, port));
}
}
}
