public NavdataAcquisition(NetworkConfiguration configuration, Action<NavigationPacket> packetAcquired, Action onAcquisitionStarted, Action onAcquisitionStopped)
{
_configuration = configuration;
_packetAcquired = packetAcquired;
_onAcquisitionStarted = onAcquisitionStarted;
_onAcquisitionStopped = onAcquisitionStopped;
}
private static void DisplayConfiguration(NetworkConfiguration config)
{
Debug.WriteLine("");
Debug.WriteLine("Network Card: {0} (ver {1})", config.NetworkCardType, config.NetworkCardFirmwareVersion);
Debug.WriteLine("Transport Type: {0}", new object[] { config.TransportType.ToString().ToUpperInvariant() });
Debug.WriteLine("MAC Address: {0}", config.TerminalMACAddress);
Debug.WriteLine("IP Address/Port: {0}:{1}", config.TerminalIPAddress, config.TerminalPort);
Debug.WriteLine("Remote Address/Port: {0}:{1}", config.RemoteIPAddress, config.RemotePort);
Debug.WriteLine("Subnet Mask: {0}", config.SubnetMask);
Debug.WriteLine("Gateway Address: {0}", config.GatewayIPAddress);
Debug.WriteLine("Disconnect Time: {0} seconds", config.DisconnectTime.TotalSeconds);
Debug.WriteLine("Polling Interval: {0} seconds", config.PollingInterval.TotalSeconds);
Debug.WriteLine("Polling Enabled: {0}", config.EnablePolling);
Debug.WriteLine("DHCP Enabled: {0}", config.EnableDHCP);
Debug.WriteLine("MAC Sending Enabled: {0}", config.EnableSendMAC);
Debug.WriteLine("");
}
public VideoAcquisition(NetworkConfiguration configuration, Action<VideoPacket> videoPacketAcquired)
{
_configuration = configuration;
_videoPacketAcquired = videoPacketAcquired;
}
public void StartListening()
{
var config = new NetworkConfiguration(ip, port, 1); //just for one player
try
{
peer = new Peer(config);
peer.OnNewConnection += NewConnectionEventHandler;
peer.Start();
GameStatus = EGameStatus.CreatingNetwork;
}
catch (System.Exception ex)
{
Debug.LogWarning(ex.Message);
}
}
public RtspAudioVideoTestSuite(TestLaunchParam param)
: base(param)
{
NetConfig = new NetworkConfiguration(param, this);
}
/// <summary>
/// Rename and validate destination network configuration names.
/// </summary>
/// <param name="networkConfiguration">network configuration from the metadata</param>
private void RenameAndValidateDestNetworkConfigurationNames(NetworkConfiguration networkConfiguration)
{
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.VirtualNetwork.ToString());
if (networkConfiguration != null && networkConfiguration.VirtualNetworkConfiguration != null && !networkConfiguration.IsImported)
{
// Get destination subscription network configuration
NetworkGetConfigurationResponse destinationNetworkResponse = GetNetworkConfigurationFromMSAzure(
importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl);
NetworkConfiguration destinationNetConfiguration = null;
XmlSerializer serializer = new XmlSerializer(typeof(NetworkConfiguration));
if (destinationNetworkResponse != null && !(string.IsNullOrEmpty(destinationNetworkResponse.Configuration)))
{
var destinationReader = new StringReader(destinationNetworkResponse.Configuration);
destinationNetConfiguration = (NetworkConfiguration)serializer.Deserialize(destinationReader);
}
if (networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites)
{
virtualNetworkSite.name = GetDestinationResourceName(ResourceType.VirtualNetworkSite, virtualNetworkSite.name);
if (virtualNetworkSite.Location != null)
{
virtualNetworkSite.Location = importParameters.DestinationDCName;
}
virtualNetworkSite.AffinityGroup = GetDestinationResourceName(ResourceType.AffinityGroup, virtualNetworkSite.AffinityGroup);
if (virtualNetworkSite.DnsServersRef != null)
{
var dnsList =
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.
Where(x => virtualNetworkSite.DnsServersRef.
Any(x1 => x1.name == x.name)).ToArray();
virtualNetworkSite.DnsServersRef = (virtualNetworkSite.DnsServersRef.Select(s =>
{
s.name = GetDestinationResourceName(
ResourceType.DnsServer, s.name,
ResourceType.VirtualNetworkSite, virtualNetworkSite.name); return s;
})).ToArray();
dnsList = (dnsList.Select(s =>
{
s.name = GetDestinationResourceName(
ResourceType.DnsServer, s.name,
ResourceType.VirtualNetworkSite, virtualNetworkSite.name); return s;
})).ToArray();
}
if (virtualNetworkSite.Gateway != null && virtualNetworkSite.Gateway.ConnectionsToLocalNetwork != null &&
virtualNetworkSite.Gateway.ConnectionsToLocalNetwork.LocalNetworkSiteRef != null)
{
var localNetworkList =
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.
Where(x => virtualNetworkSite.Gateway.ConnectionsToLocalNetwork.LocalNetworkSiteRef.name == x.name).ToArray();
virtualNetworkSite.Gateway.ConnectionsToLocalNetwork.LocalNetworkSiteRef.name =
GetDestinationResourceName(ResourceType.LocalNetworkSite,
virtualNetworkSite.Gateway.ConnectionsToLocalNetwork.LocalNetworkSiteRef.name,
ResourceType.VirtualNetworkSite, virtualNetworkSite.name);
localNetworkList = (localNetworkList.Select(s =>
{
s.name = GetDestinationResourceName(
ResourceType.LocalNetworkSite, s.name,
ResourceType.VirtualNetworkSite, virtualNetworkSite.name); return s;
})).ToArray();
}
}
}
if (destinationNetConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null
&& destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
var networkNames =
(from dest in destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites
from vnet in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites
where (string.Compare(vnet.name, dest.name, StringComparison.CurrentCultureIgnoreCase) == 0)
select dest.name).ToArray();
if (networkNames != null && networkNames.Count() > 0)
{
throw new ValidationException(string.Format(StringResources.InvalidVirtualNetworkNameExist,
String.Join(", ", networkNames)));
}
}
// Check for unique name in virtual network names.
// If count doesn't match then virtual network name is duplicate
if (networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
if (networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.Select(
cs => cs.name).Distinct().Count() !=
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.Count())
{
throw new ValidationException(StringResources.DuplicateVirtualNetworkName);
}
}
if (networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
if (destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns != null && destinationNetConfiguration
.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
var dnsServerNames = (from dest in destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers
from dns in networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers
where (string.Compare(dns.name, dest.name, StringComparison.CurrentCultureIgnoreCase) == 0)
select dest.name).ToArray();
if (dnsServerNames != null && dnsServerNames.Count() > 0)
{
throw new ValidationException(string.Format(StringResources.InvalidDNSServerNameExist,
String.Join(", ", dnsServerNames)));
}
}
// Check for unique name in dns name.
// If count doesn't match then dns name is duplicate
if (networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Select(
cs => cs.name).Distinct().Count() != networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Count())
{
throw new ValidationException(StringResources.DuplicateDnsName);
}
}
if (networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
if (destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
var localNetworkNames = (from dest in destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites
from lnet in networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites
where (string.Compare(lnet.name, dest.name, StringComparison.CurrentCultureIgnoreCase) == 0)
select dest.name).ToArray();
if (localNetworkNames != null && localNetworkNames.Count() > 0)
{
throw new ValidationException(string.Format(StringResources.InvalidLocalNetworkNameExist,
String.Join(", ", localNetworkNames)));
}
}
// Check for unique name in local network names.
// If count doesn't match then local network name is duplicate
if (networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Select(
cs => cs.name).Distinct().Count() !=
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Count())
{
throw new ValidationException(StringResources.DuplicateLocalNetworkName);
}
}
}
Logger.Info(methodName, ProgressResources.ExecutionCompleted, ResourceType.VirtualNetwork.ToString());
}
public EndPointCollection(IServer server, IEnumerable <EndPointConfiguration> configuration, NetworkConfiguration networkConfiguration)
{
Server = server;
NetworkConfiguration = networkConfiguration;
foreach (var config in configuration)
{
Add(Start(config));
}
}
/// <summary>
/// Rollback all virtual networks
/// </summary>
/// <param name="networkConfiguration">Network configuration</param>
private void RollBackVirtualNetworks(NetworkConfiguration networkConfiguration)
{
Stopwatch swVirtualNetwork = new Stopwatch();
swVirtualNetwork.Start();
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.NetworkConfiguration.ToString());
// Get destination subscription network configuration
NetworkGetConfigurationResponse destinationNetworkResponse = GetNetworkConfigurationFromMSAzure(
importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl);
NetworkConfiguration destinationNetConfiguration = null;
XmlSerializer serializer = new XmlSerializer(typeof(NetworkConfiguration));
if (destinationNetworkResponse != null && !(string.IsNullOrEmpty(destinationNetworkResponse.Configuration)))
{
var destinationReader = new StringReader(destinationNetworkResponse.Configuration);
destinationNetConfiguration = (NetworkConfiguration)serializer.Deserialize(destinationReader);
}
try
{
if (networkConfiguration != null)
{
if (networkConfiguration.VirtualNetworkConfiguration != null)
{
if (networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null &&
destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites)
{
foreach (var dns in networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers)
{
string dnsDestination = resourceImporter.GetDestinationResourceName(ResourceType.DnsServer, dns.name,
ResourceType.VirtualNetworkSite,
resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite,
virtualNetworkSite.name));
if (!string.IsNullOrEmpty(dnsDestination))
{
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers =
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Where(s => s.name != dnsDestination).ToArray();
}
}
}
}
if (networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null &&
destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites)
{
foreach (var localNetwork in networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites)
{
string localNetworkDestination = resourceImporter.GetDestinationResourceName(ResourceType.LocalNetworkSite,
localNetwork.name,
ResourceType.VirtualNetworkSite,
resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite,
virtualNetworkSite.name));
if (!string.IsNullOrEmpty(localNetworkDestination))
{
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Where(s => s.name != localNetworkDestination).ToArray();
}
}
}
}
if (networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null &&
destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.
Where(x => !networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.
Any(x1 => resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite, x1.name) == x.name)).ToArray();
}
}
}
MemoryStream memoryStream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Encoding = Encoding.UTF8 });
serializer.Serialize(writer, destinationNetConfiguration);
using (var vnetClient = new NetworkManagementClient(importParameters.DestinationSubscriptionSettings.Credentials,
importParameters.DestinationSubscriptionSettings.ServiceUrl))
{
OperationStatusResponse response = Retry.RetryOperation(() => vnetClient.Networks.SetConfiguration(
new NetworkSetConfigurationParameters
{
Configuration = Encoding.UTF8.GetString(memoryStream.ToArray())
}), (BaseParameters)importParameters, ResourceType.NetworkConfiguration);
}
writer.Close();
memoryStream.Close();
resourceImporter.UpdateMedatadaFile(ResourceType.NetworkConfiguration, null, false);
Logger.Info(methodName, ProgressResources.RollbackVirtualNetworksWaiting, ResourceType.NetworkConfiguration.ToString());
dcMigrationManager.ReportProgress(ProgressResources.RollbackVirtualNetworksWaiting);
Task.Delay(Constants.DelayTimeInMilliseconds_Rollback).Wait();
Logger.Info(methodName, ProgressResources.RollbackVirtualNetwork, ResourceType.NetworkConfiguration.ToString());
swVirtualNetwork.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime,swVirtualNetwork.Elapsed.Days, swVirtualNetwork.Elapsed.Hours,
swVirtualNetwork.Elapsed.Minutes, swVirtualNetwork.Elapsed.Seconds), ResourceType.NetworkConfiguration.ToString());
}
catch (CloudException ex)
{
if (string.Compare(ex.Error.ToString(), Constants.ResourceNotFound, StringComparison.CurrentCultureIgnoreCase) != 0)
{
Logger.Error(methodName, ex, ResourceType.VirtualNetwork.ToString());
}
else
{
throw;
}
}
}
/// <summary>
/// Extension method for adding the jellyfin API to the service collection.
/// </summary>
/// <param name="serviceCollection">The service collection.</param>
/// <param name="pluginAssemblies">An IEnumerable containing all plugin assemblies with API controllers.</param>
/// <param name="config">The <see cref="NetworkConfiguration"/>.</param>
/// <returns>The MVC builder.</returns>
public static IMvcBuilder AddJellyfinApi(this IServiceCollection serviceCollection, IEnumerable <Assembly> pluginAssemblies, NetworkConfiguration config)
{
IMvcBuilder mvcBuilder = serviceCollection
.AddCors()
.AddTransient <ICorsPolicyProvider, CorsPolicyProvider>()
.Configure <ForwardedHeadersOptions>(options =>
{
// https://github.com/dotnet/aspnetcore/blob/master/src/Middleware/HttpOverrides/src/ForwardedHeadersMiddleware.cs
// Enable debug logging on Microsoft.AspNetCore.HttpOverrides.ForwardedHeadersMiddleware to help investigate issues.
options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
if (config.KnownProxies.Length == 0)
{
options.KnownNetworks.Clear();
options.KnownProxies.Clear();
}
else
{
AddProxyAddresses(config, config.KnownProxies, options);
}
// Only set forward limit if we have some known proxies or some known networks.
if (options.KnownProxies.Count != 0 || options.KnownNetworks.Count != 0)
{
options.ForwardLimit = null;
}
})
.AddMvc(opts =>
{
// Allow requester to change between camelCase and PascalCase
opts.RespectBrowserAcceptHeader = true;
opts.OutputFormatters.Insert(0, new CamelCaseJsonProfileFormatter());
opts.OutputFormatters.Insert(0, new PascalCaseJsonProfileFormatter());
opts.OutputFormatters.Add(new CssOutputFormatter());
opts.OutputFormatters.Add(new XmlOutputFormatter());
opts.ModelBinderProviders.Insert(0, new NullableEnumModelBinderProvider());
})
// Clear app parts to avoid other assemblies being picked up
.ConfigureApplicationPartManager(a => a.ApplicationParts.Clear())
.AddApplicationPart(typeof(StartupController).Assembly)
.AddJsonOptions(options =>
{
// Update all properties that are set in JsonDefaults
var jsonOptions = JsonDefaults.PascalCaseOptions;
// From JsonDefaults
options.JsonSerializerOptions.ReadCommentHandling = jsonOptions.ReadCommentHandling;
options.JsonSerializerOptions.WriteIndented = jsonOptions.WriteIndented;
options.JsonSerializerOptions.DefaultIgnoreCondition = jsonOptions.DefaultIgnoreCondition;
options.JsonSerializerOptions.NumberHandling = jsonOptions.NumberHandling;
options.JsonSerializerOptions.Converters.Clear();
foreach (var converter in jsonOptions.Converters)
{
options.JsonSerializerOptions.Converters.Add(converter);
}
// From JsonDefaults.PascalCase
options.JsonSerializerOptions.PropertyNamingPolicy = jsonOptions.PropertyNamingPolicy;
});
foreach (Assembly pluginAssembly in pluginAssemblies)
{
mvcBuilder.AddApplicationPart(pluginAssembly);
}
return(mvcBuilder.AddControllersAsServices());
}
internal RequestParser(NetworkConfiguration configuration)
{
Configuration = configuration;
}
/// <summary>
/// 构造函数，需要传入指令序列和网络配置
/// </summary>
/// <param name="configuration">指令序列</param>
/// <param name="commandQueue">网络配置</param>
/// <returns></returns>
public CommandSender(NetworkConfiguration configuration, ConcurrentQueue <AtCommand> commandQueue)
{
_configuration = configuration;
_commandQueue = commandQueue;
}
public DlnaEntryPoint(
IServerConfigurationManager config,
ILoggerFactory loggerFactory,
IServerApplicationHost appHost,
ISessionManager sessionManager,
IHttpClientFactory httpClientFactory,
ILibraryManager libraryManager,
IUserManager userManager,
IDlnaManager dlnaManager,
IImageProcessor imageProcessor,
IUserDataManager userDataManager,
ILocalizationManager localizationManager,
IMediaSourceManager mediaSourceManager,
IDeviceDiscovery deviceDiscovery,
IMediaEncoder mediaEncoder,
ISocketFactory socketFactory,
INetworkManager networkManager,
IUserViewManager userViewManager,
ITVSeriesManager tvSeriesManager)
{
_config = config;
_appHost = appHost;
_sessionManager = sessionManager;
_httpClientFactory = httpClientFactory;
_libraryManager = libraryManager;
_userManager = userManager;
_dlnaManager = dlnaManager;
_imageProcessor = imageProcessor;
_userDataManager = userDataManager;
_localization = localizationManager;
_mediaSourceManager = mediaSourceManager;
_deviceDiscovery = deviceDiscovery;
_mediaEncoder = mediaEncoder;
_socketFactory = socketFactory;
_networkManager = networkManager;
_logger = loggerFactory.CreateLogger <DlnaEntryPoint>();
ContentDirectory = new ContentDirectory.ContentDirectoryService(
dlnaManager,
userDataManager,
imageProcessor,
libraryManager,
config,
userManager,
loggerFactory.CreateLogger <ContentDirectory.ContentDirectoryService>(),
httpClientFactory,
localizationManager,
mediaSourceManager,
userViewManager,
mediaEncoder,
tvSeriesManager);
ConnectionManager = new ConnectionManager.ConnectionManagerService(
dlnaManager,
config,
loggerFactory.CreateLogger <ConnectionManager.ConnectionManagerService>(),
httpClientFactory);
MediaReceiverRegistrar = new MediaReceiverRegistrar.MediaReceiverRegistrarService(
loggerFactory.CreateLogger <MediaReceiverRegistrar.MediaReceiverRegistrarService>(),
httpClientFactory,
config);
Current = this;
_netConfig = config.GetConfiguration <NetworkConfiguration>("network");
_disabled = appHost.ListenWithHttps && _netConfig.RequireHttps;
if (_disabled && _config.GetDlnaConfiguration().EnableServer)
{
_logger.LogError("The DLNA specification does not support HTTPS.");
}
}
/// <summary>
/// 构造函数
///
/// </summary>
/// <param name="configuration">主机ip</param>
/// <param name="videoPacketAcquired">视频获取函数委托</param>
/// <returns></returns>
public VideoAcquisition(NetworkConfiguration configuration, Action <VideoPacket> videoPacketAcquired)
{
_configuration = configuration;
_videoPacketAcquired = videoPacketAcquired;
}
public WizardModule()
{
Get["/wizard/data"] = x => {
var timezones = Bash.Execute("timedatectl list-timezones --no-pager").SplitBash();
var hosts = CommandLauncher.Launch("cat-etc-hosts").ToArray();
var networks = CommandLauncher.Launch("cat-etc-networks").ToArray();
var resolv = CommandLauncher.Launch("cat-etc-resolv").ToArray();
var nsswitch = CommandLauncher.Launch("cat-etc-nsswitch").ToArray();
var hostnamectl = CommandLauncher.Launch("hostnamectl").ToList();
const StringSplitOptions ssoree = StringSplitOptions.RemoveEmptyEntries;
var model = new PageWizardModel {
Timezones = timezones,
NetworkInterfaceList = NetworkConfiguration.InterfacePhysical,
DomainInt = HostConfiguration.Host.InternalDomain,
DomainExt = HostConfiguration.Host.ExternalDomain,
Hosts = hosts.JoinToString(Environment.NewLine),
Networks = networks.JoinToString(Environment.NewLine),
Resolv = resolv.JoinToString(Environment.NewLine),
Nsswitch = nsswitch.JoinToString(Environment.NewLine),
StaticHostname = hostnamectl.First(_ => _.Contains("Static hostname:")).Split(new[] { ":" }, 2, ssoree)[1],
Chassis = hostnamectl.First(_ => _.Contains("Chassis:")).Split(new[] { ":" }, 2, ssoree)[1],
Deployment = hostnamectl.First(_ => _.Contains("Deployment:")).Split(new[] { ":" }, 2, ssoree)[1],
Location = hostnamectl.First(_ => _.Contains("Location:")).Split(new[] { ":" }, 2, ssoree)[1],
};
return(JsonConvert.SerializeObject(model));
};
Post["/wizard"] = x => {
ConsoleLogger.Log("[wizard] start basic configuration");
string password = Request.Form.Password;
var masterManager = new ManageMaster();
masterManager.ChangePassword(password);
ConsoleLogger.Log("[wizard] changed master password");
string hostname = Request.Form.Hostname;
string location = Request.Form.Location;
string chassis = Request.Form.Chassis;
string deployment = Request.Form.Deployment;
ConsoleLogger.Log($"[wizard] host info:\t{hostname}");
ConsoleLogger.Log($"[wizard] host info:\t{location}");
ConsoleLogger.Log($"[wizard] host info:\t{chassis}");
ConsoleLogger.Log($"[wizard] host info:\t{deployment}");
HostConfiguration.SetHostInfoName(hostname);
HostConfiguration.SetHostInfoChassis(chassis);
HostConfiguration.SetHostInfoDeployment(deployment);
HostConfiguration.SetHostInfoLocation(location);
HostConfiguration.ApplyHostInfo();
string timezone = Request.Form.Timezone;
HostConfiguration.SetTimezone(timezone);
HostConfiguration.ApplyTimezone();
string ntpServer = Request.Form.NtpServer;
HostConfiguration.SetNtpdate(ntpServer);
HostConfiguration.ApplyNtpdate();
string domainInt = Request.Form.DomainInt;
string domainExt = Request.Form.DomainExt;
string hosts = Request.Form.Hosts;
string networks = Request.Form.Networks;
string resolv = Request.Form.Resolv;
string nsswitch = Request.Form.Nsswitch;
HostConfiguration.SetNsHosts(hosts.Contains("\n")
? hosts.SplitToList("\n").ToArray()
: hosts.SplitToList(Environment.NewLine).ToArray());
HostConfiguration.ApplyNsHosts();
HostConfiguration.SetNsNetworks(networks.Contains("\n")
? networks.SplitToList("\n").ToArray()
: networks.SplitToList(Environment.NewLine).ToArray());
HostConfiguration.ApplyNsNetworks();
HostConfiguration.SetNsResolv(resolv.Contains("\n")
? resolv.SplitToList("\n").ToArray()
: resolv.SplitToList(Environment.NewLine).ToArray());
HostConfiguration.ApplyNsResolv();
HostConfiguration.SetNsSwitch(nsswitch.Contains("\n")
? nsswitch.SplitToList("\n").ToArray()
: nsswitch.SplitToList(Environment.NewLine).ToArray());
HostConfiguration.ApplyNsSwitch();
HostConfiguration.SetInternalDomain(domainInt);
HostConfiguration.SetExtenalDomain(domainExt);
ConsoleLogger.Log("[wizard] name services configured");
string Interface = Request.Form.Interface;
string txqueuelen = Request.Form.Txqueuelen;
string mtu = Request.Form.Mtu;
string mode = Request.Form.Mode;
string staticAddress = Request.Form.StaticAddress;
string staticRange = Request.Form.StaticRange;
var model = new NetworkInterfaceConfigurationModel {
Interface = Interface,
Mode = (NetworkInterfaceMode)Enum.Parse(typeof(NetworkInterfaceMode), mode),
Status = NetworkInterfaceStatus.Up,
StaticAddress = staticAddress,
StaticRange = staticRange,
Txqueuelen = txqueuelen,
Mtu = mtu,
Type = NetworkAdapterType.Physical
};
NetworkConfiguration.AddInterfaceSetting(model);
NetworkConfiguration.ApplyInterfaceSetting(model);
ConsoleLogger.Log($"[wizard] network configured at {Interface}");
HostConfiguration.SetHostAsConfigured();
ConsoleLogger.Log("[wizard] configuration complete");
return(HttpStatusCode.OK);
};
}
public ConfigurationAcquisition(NetworkConfiguration networkConfiguration, Action<ConfigurationPacket> configurationAcquired)
{
_networkConfiguration = networkConfiguration;
_configurationAcquired = configurationAcquired;
}
private void CreateRoom()
{
_maxPlayers = Configs.Get <int>(Configs.Char_MaxPlayers);
_cfg = new NetworkConfiguration(_maxPlayers, _port, Configs.Get <int>(Configs.Char_Tick), Constants.Characters, dispatcherAddress: Configs.Get <string>(Configs.Server_Host),
userDefinedAuthData: $"{ServersMgr.Dedicated}@{GetType().Name}{(ServersMgr.Dedicated ? string.Empty : $"@{ServersMgr.Master.Guid}")}",
/// <summary>
/// Creates virtual networks.
/// </summary>
/// <param name="networkConfiguration">Network configuration</param>
private void CreateVirtualNetworks(NetworkConfiguration networkConfiguration)
{
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Stopwatch swVirtualNet = new Stopwatch();
swVirtualNet.Start();
if (networkConfiguration != null && !networkConfiguration.IsImported)
{
Logger.Info(methodName, ProgressResources.ImportVirtualNetworkStarted, ResourceType.VirtualNetwork.ToString());
try
{
// Get destination subscription network configuration
NetworkGetConfigurationResponse destinationNetworkResponse = GetNetworkConfigurationFromMSAzure(
importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl);
NetworkConfiguration destinationNetConfiguration = null;
XmlSerializer serializer = new XmlSerializer(typeof(NetworkConfiguration));
if (destinationNetworkResponse != null && !(string.IsNullOrEmpty(destinationNetworkResponse.Configuration)))
{
var destinationReader = new StringReader(destinationNetworkResponse.Configuration);
destinationNetConfiguration = (NetworkConfiguration)serializer.Deserialize(destinationReader);
}
// Merge network configuration if destination subscription is already having networks.
if (destinationNetConfiguration != null)
{
if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers =
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Union(
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers
).ToArray();
}
else if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
(destinationNetConfiguration.VirtualNetworkConfiguration.Dns == null ||
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers == null)
&&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers =
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers;
}
if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Union(
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites).ToArray();
}
else if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites == null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites = networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites;
}
if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.Union(
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites).ToArray();
}
else if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites == null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites =
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites;
}
}
// else destination network configuration will have new network configuration only.
else
{
destinationNetConfiguration = networkConfiguration;
}
MemoryStream memoryStream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Encoding = Encoding.UTF8 });
serializer.Serialize(writer, destinationNetConfiguration);
using (var vnetClient = new NetworkManagementClient(importParameters.DestinationSubscriptionSettings.Credentials,
importParameters.DestinationSubscriptionSettings.ServiceUrl))
{
OperationStatusResponse response = Retry.RetryOperation(() =>
vnetClient.Networks.SetConfiguration(new NetworkSetConfigurationParameters
{
Configuration = Encoding.UTF8.GetString(memoryStream.ToArray())
}
), (BaseParameters)importParameters, ResourceType.NetworkConfiguration);
}
UpdateMedatadaFile(ResourceType.NetworkConfiguration);
writer.Close();
memoryStream.Close();
swVirtualNet.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ImportVirtualNetworkCompleted, swVirtualNet.Elapsed.Days,
swVirtualNet.Elapsed.Hours, swVirtualNet.Elapsed.Minutes, swVirtualNet.Elapsed.Seconds),
ResourceType.VirtualNetwork.ToString());
}
catch (Exception ex)
{
Logger.Error(methodName, ex, ResourceType.VirtualNetwork.ToString());
throw;
}
}
}
public CommandSender(NetworkConfiguration configuration, ConcurrentQueue<AtCommand> commandQueue)
{
_configuration = configuration;
_commandQueue = commandQueue;
}
public NetworkService(NetworkConfiguration configuration)
{
BaseUrl = configuration.BaseUrl;
_Configuration = configuration;
Init();
}
