public void OnEnable()
{
c = target as ConnectionMonitor;
newHost = c.Host;
newFPort = c.FeedPort;
newGPort = c.GamePort;
sendTest = "UNITY MatchA oplayer ticTacToe 5000 5000";
}
public Heart(ConnectionMonitor connection, Configuration.EngineSection config)
{
if (config.Scheduler.Interval < 1) throw new ArgumentException("Cannot beat at a pace below 1 per second. Set engine.scheduler.interval to at least 1.", "config");
timer = new Timer(config.Scheduler.Interval * 1000);
timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
connection.Online += delegate { timer.Start(); };
connection.Offline += delegate { timer.Stop(); };
}
public ReceiveMessageState Initialise(IConnection connection, IEncryption decryptor, IRateLimiter limiter,
ConnectionMonitor peerMonitor, TorrentManager manager, byte[] buffer,
AsyncMessageReceivedCallback callback, object state)
{
Connection = connection;
Decryptor = decryptor;
Manager = manager;
Buffer = buffer;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
ManagerMonitor = manager == null ? null : manager.Monitor;
Callback = callback;
State = state;
return this;
}
public static bool SignIn(SignInTicket ticket, out int exitCode)
{
EnterpriseServer = null;
EnterpriseObjectStore = null;
exitCode = (int)LocalUIExitCode.Error;
// Ideally we'd get the user and check for permissions, etc. but that would be another server round trip
// and for now I'm doing it this way.
if (ticket.UserName.Equals(UserNames.SpotMonitorUserName, StringComparison.InvariantCultureIgnoreCase) ||
ticket.UserName.Equals(UserNames.AlertViewerUserName, StringComparison.InvariantCultureIgnoreCase))
{
exitCode = (int)LocalUIExitCode.IncorrectUserOrPassword;
ticket.Status(string.Format(Resources.UserDoesNotHavePermissionToSignInSpec_Text, ticket.UserName), true);
return false;
}
var credentials = ticket.Process(TicketFlags.NoUpgradeRedirect | TicketFlags.ConfigureLogging, out _os);
if (!credentials.Valid)
{
ticket.SetError(credentials);
return false;
}
if (credentials.AuthenticateType != AuthenticateType.EnterpriseServer)
{
ticket.SetError(Resources.NotEnterpriseServer_Text);
return false;
}
if (!handleEnterpriseSignIn(credentials, ticket, _os))
{
exitCode = (int)LocalUIExitCode.IncorrectUserOrPassword;
return false;
}
_ticket = ticket;
_enterpriseTimeOffset = TimeSpan.Zero;
object value;
if (credentials.TryGetValue(Credentials.TimeOffsetId, typeof(TimeSpan), out value))
{
_enterpriseTimeOffset = (TimeSpan)value;
//// we don't want to include the time zone difference in the ServerTimeOffset
//var timeZoneDelta = DateTimeOffset.Now.Offset - ActiveCoreTime.Offset;
////VideoOverseer.SetServerTimeOffset(_activeCoreTimeOffset + timeZoneDelta);
TimeUtils.ServerOffset = EnterpriseTime.Offset;
if (_os != null)
{
TimeUtils.ServerTimeZone = _os.TimeZoneData;
}
}
AppLogin.Initialize(credentials.UserGuid, ticket.UserName, ticket.Password, ticket.EngineerPassword, ticket.ConnectionSpeed);
SignInServer = ticket.Server;
AppLogin.MachineHardware = _ticket.Server.HardwareVersion;
AppLogin.StartedByShell = Runtime.IsLocalHost(SignInServer.HostAddress);
_monitor = ConnectionMonitor.GetConnectionMonitor(_ticket.Server);
_monitor.ConnectionStatusChanged += monitor_ConnectionStatusChanged;
UserName = credentials.GetString(Credentials.UserFullNameId);
LoginUserName = ticket.UserName;
EnterpriseName = Ticket.Server.DisplayName;
exitCode = (int)LocalUIExitCode.Ok;
return true;
}
public Tracker(Persistence.IPersister persister, IRepository <ContentDetail> detailRepository, N2.Web.IUrlParser urlParser, ConnectionMonitor connections, N2.Web.IErrorNotifier errorHandler, Configuration.EditSection config)
{
this.persister = persister;
this.detailRepository = detailRepository;
this.urlParser = urlParser;
this.errorHandler = errorHandler;
if (config.LinkTracker.Enabled)
{
connections.Online += delegate
{
persister.ItemSaving += persister_ItemSaving;
};
connections.Offline += delegate
{
persister.ItemSaving -= persister_ItemSaving;
};
}
}
public XmlInstallationManager(IHost host, IPersister persister, XmlContentRepository repository, ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, ContentActivator activator)
: base(connectionContext, importer, webContext, persister, activator)
{
this.host = host;
this.persister = persister;
this.repository = repository;
}
public NHInstallationManager(IHost host, DefinitionMap map, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext, ConnectionMonitor connectionContext, DatabaseSection config)
: base(connectionContext, importer, webContext, persister, activator)
{
this.host = host;
this.map = map;
this.activator = activator;
this.importer = importer;
this.persister = persister;
this.sessionProvider = sessionProvider;
this.configurationBuilder = configurationBuilder;
this.webContext = webContext;
this.connectionContext = connectionContext;
this.config = config;
this.isDatabaseFileSystemEnbled = config.Files.StorageLocation == FileStoreLocation.Database;
}
public RavenInstallationManager(IHost host, DefinitionMap map, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext, ConnectionMonitor connectionContext, DatabaseSection config, RavenConnectionProvider cp)
: base(connectionContext, importer, webContext, persister, activator)
{
this.cp = cp;
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualFolderInitializer"/> class.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="persister">The persister.</param>
/// <param name="fs">The fs.</param>
/// <param name="virtualNodes">The virtual nodes.</param>
/// <param name="editConfig">The edit config.</param>
public VirtualFolderInitializer(IHost host, IPersister persister, IFileSystem fs, VirtualNodeFactory virtualNodes, ConnectionMonitor monitor, UploadFolderSource folderSource, FolderNodeProvider nodeProvider)
{
this.host = host;
this.persister = persister;
this.virtualNodes = virtualNodes;
this.monitor = monitor;
this.folderSource = folderSource;
this.nodeProvider = nodeProvider;
}
public async Task DeleteConnectionMonitorTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = "westus2";
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string virtualMachineName = Recording.GenerateAssetName("azsmnet");
string networkInterfaceName = Recording.GenerateAssetName("azsmnet");
string networkSecurityGroupName = virtualMachineName + "-nsg";
//Deploy VM with a template
await CreateVm(
resourcesClient : ResourceManagementClient,
resourceGroupName : resourceGroupName,
location : location,
virtualMachineName : virtualMachineName,
storageAccountName : Recording.GenerateAssetName("azsmnet"),
networkInterfaceName : networkInterfaceName,
networkSecurityGroupName : networkSecurityGroupName,
diagnosticsStorageAccountName : Recording.GenerateAssetName("azsmnet"),
deploymentName : Recording.GenerateAssetName("azsmnet"),
adminPassword : Recording.GenerateAlphaNumericId("AzureSDKNetworkTest#")
);
Response <VirtualMachine> getVm = await ComputeManagementClient.VirtualMachines.GetAsync(resourceGroupName, virtualMachineName);
//Deploy networkWatcherAgent on VM
VirtualMachineExtension parameters = new VirtualMachineExtension(location)
{
Publisher = "Microsoft.Azure.NetworkWatcher",
TypeHandlerVersion = "1.4",
TypePropertiesType = "NetworkWatcherAgentWindows"
};
VirtualMachineExtensionsCreateOrUpdateOperation createOrUpdateOperation = await ComputeManagementClient.VirtualMachineExtensions.StartCreateOrUpdateAsync(resourceGroupName, getVm.Value.Name, "NetworkWatcherAgent", parameters);
await WaitForCompletionAsync(createOrUpdateOperation);
//TODO:There is no need to perform a separate create NetworkWatchers operation
//Create network Watcher
//string networkWatcherName = Recording.GenerateAssetName("azsmnet");
//NetworkWatcher properties = new NetworkWatcher { Location = location };
//await NetworkManagementClient.NetworkWatchers.CreateOrUpdateAsync("NetworkWatcherRG", "NetworkWatcher_westus2", properties);
string connectionMonitorName1 = Recording.GenerateAssetName("azsmnet");
string connectionMonitorName2 = Recording.GenerateAssetName("azsmnet");
ConnectionMonitor cm = new ConnectionMonitor
{
Location = location,
Source = new ConnectionMonitorSource(getVm.Value.Id),
Destination = new ConnectionMonitorDestination
{
Address = "bing.com",
Port = 80
},
MonitoringIntervalInSeconds = 30,
AutoStart = false
};
Operation <ConnectionMonitorResult> connectionMonitor1Operation = await NetworkManagementClient.ConnectionMonitors.StartCreateOrUpdateAsync("NetworkWatcherRG", "NetworkWatcher_westus2", connectionMonitorName1, cm);
await WaitForCompletionAsync(connectionMonitor1Operation);
Operation <ConnectionMonitorResult> connectionMonitor2Operation = await NetworkManagementClient.ConnectionMonitors.StartCreateOrUpdateAsync("NetworkWatcherRG", "NetworkWatcher_westus2", connectionMonitorName2, cm);
await WaitForCompletionAsync(connectionMonitor2Operation);
AsyncPageable <ConnectionMonitorResult> getConnectionMonitors1AP = NetworkManagementClient.ConnectionMonitors.ListAsync("NetworkWatcherRG", "NetworkWatcher_westus2");
Task <List <ConnectionMonitorResult> > getConnectionMonitors1 = getConnectionMonitors1AP.ToEnumerableAsync();
Assert.AreEqual(2, getConnectionMonitors1.Result.Count);
ConnectionMonitorsDeleteOperation connectionMonitorsDeleteOperation = await NetworkManagementClient.ConnectionMonitors.StartDeleteAsync("NetworkWatcherRG", "NetworkWatcher_westus2", connectionMonitorName2);
await WaitForCompletionAsync(connectionMonitorsDeleteOperation);
AsyncPageable <ConnectionMonitorResult> getConnectionMonitors2 = NetworkManagementClient.ConnectionMonitors.ListAsync("NetworkWatcherRG", "NetworkWatcher_westus2");
Has.One.EqualTo(getConnectionMonitors2);
}
public async Task PutConnectionMonitorTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = "westus2";
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string virtualMachineName = Recording.GenerateAssetName("azsmnet");
string networkInterfaceName = Recording.GenerateAssetName("azsmnet");
string networkSecurityGroupName = virtualMachineName + "-nsg";
//Deploy VM with a template
await CreateVm(
resourcesClient : ResourceManagementClient,
resourceGroupName : resourceGroupName,
location : location,
virtualMachineName : virtualMachineName,
storageAccountName : Recording.GenerateAssetName("azsmnet"),
networkInterfaceName : networkInterfaceName,
networkSecurityGroupName : networkSecurityGroupName,
diagnosticsStorageAccountName : Recording.GenerateAssetName("azsmnet"),
deploymentName : Recording.GenerateAssetName("azsmnet"),
adminPassword : Recording.GenerateAlphaNumericId("AzureSDKNetworkTest#")
);
Response <VirtualMachine> getVm = await ComputeManagementClient.VirtualMachines.GetAsync(resourceGroupName, virtualMachineName);
//Deploy networkWatcherAgent on VM
VirtualMachineExtension parameters = new VirtualMachineExtension(location)
{
Publisher = "Microsoft.Azure.NetworkWatcher",
TypeHandlerVersion = "1.4",
TypePropertiesType = "NetworkWatcherAgentWindows"
};
VirtualMachineExtensionsCreateOrUpdateOperation createOrUpdateOperation = await ComputeManagementClient.VirtualMachineExtensions.StartCreateOrUpdateAsync(resourceGroupName, getVm.Value.Name, "NetworkWatcherAgent", parameters);
await WaitForCompletionAsync(createOrUpdateOperation);
//TODO:There is no need to perform a separate create NetworkWatchers operation
//Create network Watcher
//string networkWatcherName = Recording.GenerateAssetName("azsmnet");
//NetworkWatcher properties = new NetworkWatcher { Location = location };
//await NetworkManagementClient.NetworkWatchers.CreateOrUpdateAsync("NetworkWatcherRG", "NetworkWatcher_westus2", properties);
string connectionMonitorName = "cm";
ConnectionMonitor cm = new ConnectionMonitor
{
Location = location,
Source = new ConnectionMonitorSource(getVm.Value.Id),
Destination = new ConnectionMonitorDestination
{
Address = "bing.com",
Port = 80
},
MonitoringIntervalInSeconds = 30
};
Operation <ConnectionMonitorResult> putConnectionMonitorOperation = await NetworkManagementClient.ConnectionMonitors.StartCreateOrUpdateAsync("NetworkWatcherRG", "NetworkWatcher_westus2", connectionMonitorName, cm);
Response <ConnectionMonitorResult> putConnectionMonitor = await WaitForCompletionAsync(putConnectionMonitorOperation);
Assert.AreEqual("Running", putConnectionMonitor.Value.MonitoringStatus);
Assert.AreEqual("centraluseuap", putConnectionMonitor.Value.Location);
Assert.AreEqual(30, putConnectionMonitor.Value.MonitoringIntervalInSeconds);
Assert.AreEqual(connectionMonitorName, putConnectionMonitor.Value.Name);
Assert.AreEqual(getVm.Value.Id, putConnectionMonitor.Value.Source.ResourceId);
Assert.AreEqual("bing.com", putConnectionMonitor.Value.Destination.Address);
Assert.AreEqual(80, putConnectionMonitor.Value.Destination.Port);
}
public void DeleteConnectionMonitorTest()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler3 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1, true);
var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
var computeManagementClient = NetworkManagementTestUtilities.GetComputeManagementClientWithHandler(context, handler3);
string location = "centraluseuap";
string resourceGroupName = TestUtilities.GenerateName();
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
string virtualMachineName = TestUtilities.GenerateName();
string networkInterfaceName = TestUtilities.GenerateName();
string networkSecurityGroupName = virtualMachineName + "-nsg";
//Deploy VM with a template
DeploymentUpdate.CreateVm(
resourcesClient: resourcesClient,
resourceGroupName: resourceGroupName,
location: location,
virtualMachineName: virtualMachineName,
storageAccountName: TestUtilities.GenerateName(),
networkInterfaceName: networkInterfaceName,
networkSecurityGroupName: networkSecurityGroupName,
diagnosticsStorageAccountName: TestUtilities.GenerateName(),
deploymentName: TestUtilities.GenerateName()
);
var getVm = computeManagementClient.VirtualMachines.Get(resourceGroupName, virtualMachineName);
//Deploy networkWatcherAgent on VM
VirtualMachineExtension parameters = new VirtualMachineExtension
{
Publisher = "Microsoft.Azure.NetworkWatcher",
TypeHandlerVersion = "1.4",
VirtualMachineExtensionType = "NetworkWatcherAgentWindows",
Location = location
};
var addExtension = computeManagementClient.VirtualMachineExtensions.CreateOrUpdate(resourceGroupName, getVm.Name, "NetworkWatcherAgent", parameters);
string networkWatcherName = TestUtilities.GenerateName();
NetworkWatcher properties = new NetworkWatcher
{
Location = location
};
//Create network Watcher
var createNetworkWatcher = networkManagementClient.NetworkWatchers.CreateOrUpdate(resourceGroupName, networkWatcherName, properties);
string connectionMonitorName1 = TestUtilities.GenerateName();
string connectionMonitorName2 = TestUtilities.GenerateName();
ConnectionMonitor cm = new ConnectionMonitor
{
Location = location,
Source = new ConnectionMonitorSource
{
ResourceId = getVm.Id
},
Destination = new ConnectionMonitorDestination
{
Address = "bing.com",
Port = 80
},
MonitoringIntervalInSeconds = 30,
AutoStart = false
};
var connectionMonitor1 = networkManagementClient.ConnectionMonitors.CreateOrUpdate(resourceGroupName, networkWatcherName, connectionMonitorName1, cm);
var connectionMonitor2 = networkManagementClient.ConnectionMonitors.CreateOrUpdate(resourceGroupName, networkWatcherName, connectionMonitorName2, cm);
var getConnectionMonitors1 = networkManagementClient.ConnectionMonitors.List(resourceGroupName, networkWatcherName);
Assert.Equal(2, getConnectionMonitors1.Count());
networkManagementClient.ConnectionMonitors.Delete(resourceGroupName, networkWatcherName, connectionMonitorName2);
var getConnectionMonitors2 = networkManagementClient.ConnectionMonitors.List(resourceGroupName, networkWatcherName);
Assert.Single(getConnectionMonitors2);
}
}
public void SetUp()
{
connectionStrategy = new Mock <IConnectionStateStrategy>();
connectionStrategy.Setup(x => x.IsAlive(Url)).Returns(false);
connectionMonitor = new ConnectionMonitor(Url, connectionStrategy.Object);
}
