public List<Station> getStations(Inputs input) { List<Station> ret = new List<Station>(); RegistryManager registry = new RegistryManager(); byte[] value = registry.getStations(input); int segmentLength = 40; int stationEndpoint = segmentLength * registry.getStationCount(input); for (int i = 8; i < stationEndpoint; i += segmentLength) { ArraySegment<byte> segment = new ArraySegment<byte>(value, i, segmentLength); Station s = new Station(); s.Input = input; s.PhysicalChannel = BitConverter.ToInt16(segment.Array, segment.Offset + (int)StationBytePositions.PhysicalChannel); s.VirtualChannel = BitConverter.ToInt16(segment.Array, segment.Offset + (int)StationBytePositions.VirtualChannel); s.SubChannel = segment.Array[segment.Offset + (int)StationBytePositions.SubChannel]; // TODO: (KJM 02/21/06) Figure out how to treat 0xFF as -1 rather than 255. int minorChannel = segment.Array[segment.Offset + (int)StationBytePositions.MinorChannel]; if (255 == minorChannel) { minorChannel = -1; } s.MinorChannel = minorChannel; // TODO: (KJM 02/21/06) Figure out a way of actually reading in the name without dying on channels without names. //s.Name = System.Text.Encoding.ASCII.GetString(segment.Array, segment.Offset + 16, 5); ret.Add(s); } return ret; }
public IotHubRepository(IConfigurationProvider configProvider) { // Temporary code to bypass https cert validation till DNS on IotHub is configured ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true; _iotHubConnectionString = configProvider.GetConfigurationSettingValue("iotHub.ConnectionString"); _deviceManager = RegistryManager.CreateFromConnectionString(_iotHubConnectionString); }
public static void Main() { BTV btv = new BTV(); List<Recording> recordings = btv.getRecordings(); // First clear out all the previous recordings, then schedule all the current recordings. RegistryManager registry = new RegistryManager(); registry.clearRecordings(); foreach (Recording r in recordings) { registry.scheduleRecording(r); } }
public static void Main(string[] args) { try { if ((args.Length == 0) || string.IsNullOrEmpty(args[0]) || args[0].Equals("localhost", StringComparison.OrdinalIgnoreCase)) { m_applicationName = Utils.GetHostName(); } else { m_applicationName = args[0]; } Trace("Publisher is starting up..."); ModuleConfiguration moduleConfiguration = new ModuleConfiguration(m_applicationName); m_configuration = moduleConfiguration.Configuration; m_configuration.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation); // start our server interface try { Trace("Starting server on endpoint " + m_configuration.ServerConfiguration.BaseAddresses[0].ToString() + "..."); m_server.Start(m_configuration); Trace("Server started."); } catch (Exception ex) { Trace("Starting server failed with: " + ex.Message); } // check if we also received an owner connection string string ownerConnectionString = string.Empty; if ((args.Length > 1) && !string.IsNullOrEmpty(args[1])) { ownerConnectionString = args[1]; } else { Trace("IoT Hub owner connection string not passed as argument."); // check if we have an environment variable to register ourselves with IoT Hub if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("_HUB_CS"))) { ownerConnectionString = Environment.GetEnvironmentVariable("_HUB_CS"); } } // register ourselves with IoT Hub if (ownerConnectionString != string.Empty) { Trace("Attemping to register ourselves with IoT Hub using owner connection string: " + ownerConnectionString); RegistryManager manager = RegistryManager.CreateFromConnectionString(ownerConnectionString); // remove any existing device Device existingDevice = manager.GetDeviceAsync(m_applicationName).Result; if (existingDevice != null) { manager.RemoveDeviceAsync(m_applicationName).Wait(); } Device newDevice = manager.AddDeviceAsync(new Device(m_applicationName)).Result; if (newDevice != null) { string hostname = ownerConnectionString.Substring(0, ownerConnectionString.IndexOf(";")); string deviceConnectionString = hostname + ";DeviceId=" + m_applicationName + ";SharedAccessKey=" + newDevice.Authentication.SymmetricKey.PrimaryKey; SecureIoTHubToken.Write(m_applicationName, deviceConnectionString); } else { Trace("Could not register ourselves with IoT Hub using owner connection string: " + ownerConnectionString); } } else { Trace("IoT Hub owner connection string not found, registration with IoT Hub abandoned."); } // try to read connection string from secure store and open IoTHub client Trace("Attemping to read connection string from secure store with certificate name: " + m_applicationName); string connectionString = SecureIoTHubToken.Read(m_applicationName); if (!string.IsNullOrEmpty(connectionString)) { Trace("Attemping to configure publisher with connection string: " + connectionString); m_deviceClient = DeviceClient.CreateFromConnectionString(connectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt); m_deviceClient.RetryPolicy = RetryPolicyType.Exponential_Backoff_With_Jitter; m_deviceClient.OpenAsync().Wait(); } else { Trace("Device connection string not found in secure store."); } // get a list of persisted endpoint URLs and create a session for each. try { // check if we have an env variable specifying the published nodes path, otherwise use current directory string publishedNodesFilePath = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + "publishednodes.json"; if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("_GW_PNFP"))) { publishedNodesFilePath = Environment.GetEnvironmentVariable("_GW_PNFP"); } Trace("Attemping to load nodes file from: " + publishedNodesFilePath); m_nodesLookups = JsonConvert.DeserializeObject <PublishedNodesCollection>(File.ReadAllText(publishedNodesFilePath)); Trace("Loaded " + m_nodesLookups.Count.ToString() + " nodes."); } catch (Exception ex) { Trace("Nodes file loading failed with: " + ex.Message); } foreach (NodeLookup nodeLookup in m_nodesLookups) { if (!m_endpointUrls.Contains(nodeLookup.EndPointURL)) { m_endpointUrls.Add(nodeLookup.EndPointURL); } } // connect to the other servers Trace("Attemping to connect to servers..."); try { List <Task> connectionAttempts = new List <Task>(); foreach (Uri endpointUrl in m_endpointUrls) { Trace("Connecting to server: " + endpointUrl); connectionAttempts.Add(EndpointConnect(endpointUrl)); } // Wait for all sessions to be connected Task.WaitAll(connectionAttempts.ToArray()); } catch (Exception ex) { Trace("Exception: " + ex.ToString() + "\r\n" + ex.InnerException != null ? ex.InnerException.ToString() : null); } // subscribe to preconfigured nodes Trace("Attemping to subscribe to published nodes..."); if (m_nodesLookups != null) { foreach (NodeLookup nodeLookup in m_nodesLookups) { try { CreateMonitoredItem(nodeLookup); } catch (Exception ex) { Trace("Unexpected error publishing node: " + ex.Message + "\r\nIgnoring node: " + nodeLookup.EndPointURL.AbsoluteUri + ", " + nodeLookup.NodeID.ToString()); } } } Task dequeueAndSendTask = null; var tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; Trace("Creating task to send OPC UA messages in batches to IoT Hub..."); try { dequeueAndSendTask = Task.Run(() => DeQueueMessagesAsync(token), token); } catch (Exception ex) { Trace("Exception: " + ex.ToString()); } Trace("Publisher is running. Press enter to quit."); Console.ReadLine(); foreach (Session session in m_sessions) { session.Close(); } //Send cancellation token and wait for last IoT Hub message to be sent. try { tokenSource.Cancel(); dequeueAndSendTask.Wait(); } catch (Exception ex) { Trace("Exception: " + ex.ToString()); } if (m_deviceClient != null) { m_deviceClient.CloseAsync().Wait(); } } catch (Exception e) { Trace(e, "Unhandled exception in Publisher, exiting!"); } }
public void Init() { string hubConnString = "HostName=lefitche-hub-3.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=wyT/feMmLKDj8wnWxLCHkQERmOUBWaeuLMDLDjAILug="; registryManager = RegistryManager.CreateFromConnectionString(hubConnString); }
public int RunCommand(CKAN.KSP ksp, object raw_options) { ShowOptions options = (ShowOptions)raw_options; if (options.Modname == null) { // empty argument user.RaiseMessage("show <module> - module name argument missing, perhaps you forgot it?"); return(Exit.BADOPT); } // Check installed modules for an exact match. var registry = RegistryManager.Instance(ksp).registry; var installedModuleToShow = registry.InstalledModule(options.Modname); if (installedModuleToShow != null) { // Show the installed module. return(ShowMod(installedModuleToShow)); } // Module was not installed, look for an exact match in the available modules, // either by "name" (the user-friendly display name) or by identifier CkanModule moduleToShow = registry .Available(ksp.Version()) .SingleOrDefault( mod => mod.name == options.Modname || mod.identifier == options.Modname ); if (moduleToShow == null) { // No exact match found. Try to look for a close match for this KSP version. user.RaiseMessage("{0} not found or installed.", options.Modname); user.RaiseMessage("Looking for close matches in available mods for KSP {0}.", ksp.Version()); Search search = new Search(user); var matches = search.PerformSearch(ksp, options.Modname); // Display the results of the search. if (!matches.Any()) { // No matches found. user.RaiseMessage("No close matches found."); return(Exit.BADOPT); } else if (matches.Count() == 1) { // If there is only 1 match, display it. user.RaiseMessage("Found 1 close match: {0}", matches[0].name); user.RaiseMessage(""); moduleToShow = matches[0]; } else { // Display the found close matches. string[] strings_matches = new string[matches.Count]; for (int i = 0; i < matches.Count; i++) { strings_matches[i] = matches[i].name; } int selection = user.RaiseSelectionDialog("Close matches", strings_matches); if (selection < 0) { return(Exit.BADOPT); } // Mark the selection as the one to show. moduleToShow = matches[selection]; } } return(ShowMod(moduleToShow)); }
public EncryptedFilesList() { InitializeComponent(); rm = new RegistryManager(); }
private async Task DeviceClient_Gives_ConnectionStatus_DeviceDisabled_Base( Client.TransportType protocol, Func <RegistryManager, string, Task> registryManagerOperation) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix + $"_{Guid.NewGuid()}").ConfigureAwait(false); string deviceConnectionString = testDevice.ConnectionString; var config = new Configuration.IoTHub.DeviceConnectionStringParser(deviceConnectionString); string deviceId = config.DeviceID; ConnectionStatus? status = null; ConnectionStatusChangeReason?statusChangeReason = null; int deviceDisabledReceivedCount = 0; using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, protocol)) { ConnectionStatusChangesHandler statusChangeHandler = (s, r) => { if (r == ConnectionStatusChangeReason.Device_Disabled) { status = s; statusChangeReason = r; deviceDisabledReceivedCount++; } }; deviceClient.SetConnectionStatusChangesHandler(statusChangeHandler); _log.WriteLine($"Created {nameof(DeviceClient)} ID={TestLogging.IdOf(deviceClient)}"); Console.WriteLine("DeviceClient OpenAsync."); await deviceClient.OpenAsync().ConfigureAwait(false); // Receiving the module twin should succeed right now. Console.WriteLine("ModuleClient GetTwinAsync."); var twin = await deviceClient.GetTwinAsync().ConfigureAwait(false); Assert.IsNotNull(twin); // Delete/disable the device in IoT Hub. This should trigger the ConnectionStatusChangesHandler. using (RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { await registryManagerOperation(registryManager, deviceId).ConfigureAwait(false); } // Artificial sleep waiting for the connection status change handler to get triggered. int sleepCount = 50; for (int i = 0; i < sleepCount; i++) { await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false); if (deviceDisabledReceivedCount == 1) { break; } } Assert.AreEqual(1, deviceDisabledReceivedCount); Assert.AreEqual(ConnectionStatus.Disconnected, status); Assert.AreEqual(ConnectionStatusChangeReason.Device_Disabled, statusChangeReason); } }
public DesiredPropertyUpdater(RegistryManager registryManager, ITwinTestResultHandler resultHandler, TwinState twinState) { this.registryManager = registryManager; this.resultHandler = resultHandler; this.twinState = twinState; }
public int RunCommand(CKAN.KSP ksp, object raw_options) { ReplaceOptions options = (ReplaceOptions)raw_options; if (options.ckan_file != null) { options.modules.Add(MainClass.LoadCkanFromFile(ksp, options.ckan_file).identifier); } if (options.modules.Count == 0 && !options.replace_all) { // What? No mods specified? User.RaiseMessage("Usage: ckan replace Mod [Mod2, ...]"); User.RaiseMessage(" or ckan replace --all"); return(Exit.BADOPT); } // Prepare options. Can these all be done in the new() somehow? var replace_ops = new RelationshipResolverOptions { with_all_suggests = options.with_all_suggests, with_suggests = options.with_suggests, with_recommends = !options.no_recommends, allow_incompatible = options.allow_incompatible }; var registry = RegistryManager.Instance(ksp).registry; var to_replace = new List <ModuleReplacement>(); if (options.replace_all) { log.Debug("Running Replace all"); var installed = new Dictionary <string, ModuleVersion>(registry.Installed()); foreach (KeyValuePair <string, ModuleVersion> mod in installed) { ModuleVersion current_version = mod.Value; if ((current_version is ProvidesModuleVersion) || (current_version is UnmanagedModuleVersion)) { continue; } else { try { log.DebugFormat("Testing {0} {1} for possible replacement", mod.Key, mod.Value); // Check if replacement is available ModuleReplacement replacement = registry.GetReplacement(mod.Key, ksp.VersionCriteria()); if (replacement != null) { // Replaceable log.InfoFormat("Replacement {0} {1} found for {2} {3}", replacement.ReplaceWith.identifier, replacement.ReplaceWith.version, replacement.ToReplace.identifier, replacement.ToReplace.version); to_replace.Add(replacement); } } catch (ModuleNotFoundKraken) { log.InfoFormat("{0} is installed, but it or its replacement is not in the registry", mod.Key); } } } } else { foreach (string mod in options.modules) { try { log.DebugFormat("Checking that {0} is installed", mod); CkanModule modToReplace = registry.GetInstalledVersion(mod); if (modToReplace != null) { log.DebugFormat("Testing {0} {1} for possible replacement", modToReplace.identifier, modToReplace.version); try { // Check if replacement is available ModuleReplacement replacement = registry.GetReplacement(modToReplace.identifier, ksp.VersionCriteria()); if (replacement != null) { // Replaceable log.InfoFormat("Replacement {0} {1} found for {2} {3}", replacement.ReplaceWith.identifier, replacement.ReplaceWith.version, replacement.ToReplace.identifier, replacement.ToReplace.version); to_replace.Add(replacement); } if (modToReplace.replaced_by != null) { log.InfoFormat("Attempt to replace {0} failed, replacement {1} is not compatible", mod, modToReplace.replaced_by.name); } else { log.InfoFormat("Mod {0} has no replacement defined for the current version {1}", modToReplace.identifier, modToReplace.version); } } catch (ModuleNotFoundKraken) { log.InfoFormat("{0} is installed, but its replacement {1} is not in the registry", mod, modToReplace.replaced_by.name); } } } catch (ModuleNotFoundKraken kraken) { User.RaiseMessage("Module {0} not found", kraken.module); } } } if (to_replace.Count() != 0) { User.RaiseMessage("\r\nReplacing modules...\r\n"); foreach (ModuleReplacement r in to_replace) { User.RaiseMessage("Replacement {0} {1} found for {2} {3}", r.ReplaceWith.identifier, r.ReplaceWith.version, r.ToReplace.identifier, r.ToReplace.version); } bool ok = User.RaiseYesNoDialog("\r\nContinue?"); if (!ok) { User.RaiseMessage("Replacements canceled at user request."); return(Exit.ERROR); } // TODO: These instances all need to go. try { ModuleInstaller.GetInstance(ksp, manager.Cache, User).Replace(to_replace, replace_ops, new NetAsyncModulesDownloader(User)); User.RaiseMessage("\r\nDone!\r\n"); } catch (DependencyNotSatisfiedKraken ex) { User.RaiseMessage("Dependencies not satisfied for replacement, {0} requires {1} {2} but it is not listed in the index, or not available for your version of KSP.", ex.parent, ex.module, ex.version); } } else { User.RaiseMessage("No replacements found."); return(Exit.OK); } return(Exit.OK); }
static void Main(string[] args) { Console.WriteLine("Enter IoT Hub connection string: "); _iotHubConnectionString = Console.ReadLine(); _registryManager = RegistryManager.CreateFromConnectionString(_iotHubConnectionString); Task.Run( async() => { while (true) { try { Console.WriteLine(); Console.WriteLine("Commands:"); Console.WriteLine("1: Register random devices"); Console.WriteLine("2: Send data from all devices"); Console.WriteLine("3: Remove all devices"); Console.WriteLine("4: Exit"); string command = Console.ReadLine(); switch (command) { case "1": Console.WriteLine("Number of devices?"); int num = Int32.Parse(Console.ReadLine()); await AddRandomDevicesAsync(num); break; case "2": Console.WriteLine("Number of messages?"); int nbMessages = Int32.Parse(Console.ReadLine()); await SendFromAllDevicesAsync(nbMessages); break; case "3": Console.WriteLine("Do you confirm? (y/n)"); var confirm = Console.ReadLine(); if (confirm != null && confirm.ToLower().Equals("y")) { var devices = await _registryManager.GetDevicesAsync(Int32.MaxValue); //var query = registryManager.CreateQuery("select * from devices"); //while (query.HasMoreResults) //{ // var page = await query.GetNextAsTwinAsync(); // foreach (var twin in page) // { // // do work on twin object // devices.Append(twin.) // } //} foreach (var device in devices) { await _registryManager.RemoveDeviceAsync(device.Id); } } break; case "4": return; default: break; } } catch (Exception ex) { Console.WriteLine("An error occured: {0}", ex.Message); } } } ).GetAwaiter().GetResult(); }
static DevicesController() { _registryManager = RegistryManager.CreateFromConnectionString(Settings.Instance.IotHubConnectionString); }
/// <summary> /// Constructor. /// </summary> public MainWindow() { // Initialize the UI InitializeComponent(); // Initialize timer for handling the state of the save button timer = new Timer(); timer.Tick += new EventHandler(resetSaveButtonText); timer.Interval = 500; // Make window unresizable this.FormBorderStyle = FormBorderStyle.FixedSingle; this.MaximizeBox = false; // Get the application settings from the settings file. this.m_Settings = SettingsManager.read(); if (this.m_Settings.IsValid) { // Check that the Imaris version stored in the file exists in // the registry. Otherwise inform the admin. RegistryManager manager = new RegistryManager(this.m_Settings.ImarisVersion); if (!manager.ImarisKeyExists()) { // Inform the user MessageBox.Show( "The Imaris version stored in the settings file does not have " + "the corresponding registry entries. This probably means that " + "the settings file is obsolete.\n\n" + "It is highly recommended to choose current Imaris executable " + "to manage and, if needed, reconfigure it.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } // Display the Imaris path on the button buttonImarisPath.Text = this.m_Settings.ImarisPath; // Fill in the list of products checkedListBoxProducts.Items.Clear(); foreach (String productName in this.m_Settings.ProductsWithEnabledState.Keys) { bool state; if (this.m_Settings.ProductsWithEnabledState.ContainsKey(productName)) { if (!this.m_Settings.ProductsWithEnabledState.TryGetValue(productName, out state)) { state = true; } } else { state = true; } // Add the product with the state read from the application settings checkedListBoxProducts.Items.Add(productName, state); } // Now set all other settings // TODO: Add all necessary checks // Texture cache if (this.m_Settings.TextureCache == -1) { numericTextureCache.Text = ""; } else { numericTextureCache.Value = this.m_Settings.TextureCache; } // Data cache if (this.m_Settings.DataCache == -1) { numericDataCache.Text = ""; } else { numericDataCache.Value = this.m_Settings.DataCache; } // Data cache file paths if (!this.m_Settings.DataBlockCachingFilePath.Equals("")) { String[] dataBlockCachingFilePathArray = this.m_Settings.DataBlockCachingFilePath.Split(';'); listCLFileCachePaths.Items.Clear(); foreach (String d in dataBlockCachingFilePathArray) { if (!d.Equals("")) { listCLFileCachePaths.Items.Add(d); } } } // XT folder paths if (!this.m_Settings.XTFolderPath.Equals("")) { String[] xtFolderPathArray = this.m_Settings.XTFolderPath.Split(';'); listCTXTPaths.Items.Clear(); foreach (String x in xtFolderPathArray) { if (!x.Equals("")) { listCTXTPaths.Items.Add(x); } } } // Python path if (!this.m_Settings.PythonPath.Equals("")) { buttonCTAddPythonPath.Text = this.m_Settings.PythonPath; } // Fiji path if (!this.m_Settings.FijiPath.Equals("")) { buttonCTAddFijiPath.Text = this.m_Settings.FijiPath; } // Enable save button this.buttonSave.Enabled = true; } }
public void InstallAndSortByCompat_WithAnyCompat_NoCrash() { /* * // An exception would be thrown at the bottom of this. * var main = new Main(null, new GUIUser(), false); * main.Manager = _manager; * // First sort by name * main.configuration.SortByColumnIndex = 2; * // Now sort by version * main.configuration.SortByColumnIndex = 6; * main.MarkModForInstall("kOS"); * * // Make sure we have one requested change * var changeList = main.mainModList.ComputeUserChangeSet() * .Select((change) => change.Mod.ToCkanModule()).ToList(); * * // Do the install * new ModuleInstaller(_instance.KSP, main.currentUser).InstallList( * changeList, * new RelationshipResolverOptions(), * new NetAsyncModulesDownloader(main.currentUser) * ); */ // Arrange DisposableKSP instance = new DisposableKSP(); RegistryManager registryManager = RegistryManager.Instance(instance.KSP); Registry registry = Registry.Empty(); FakeConfiguration config = new FakeConfiguration(instance.KSP, instance.KSP.Name); GameInstanceManager manager = new GameInstanceManager(new NullUser(), config); // A module with a ksp_version of "any" to repro our issue CkanModule anyVersionModule = TestData.DogeCoinFlag_101_module(); ModList modList = new ModList(null); DataGridView listGui = new DataGridView(); CKAN.ModuleInstaller installer = new CKAN.ModuleInstaller(instance.KSP, manager.Cache, manager.User); NetAsyncModulesDownloader downloader = new NetAsyncModulesDownloader(manager.User, manager.Cache); // Act // Install module and set it as pre-installed manager.Cache.Store(TestData.DogeCoinFlag_101_module(), TestData.DogeCoinFlagZip()); registry.RegisterModule(anyVersionModule, new string[] { }, instance.KSP, false); registry.AddAvailable(anyVersionModule); HashSet <string> possibleConfigOnlyDirs = null; installer.InstallList( new List <CkanModule> { anyVersionModule }, new RelationshipResolverOptions(), registryManager, ref possibleConfigOnlyDirs, downloader ); // This module is not for "any" version, // to provide another to sort against registry.AddAvailable(TestData.kOS_014_module()); // TODO: Refactor the column header code to allow mocking of the GUI without creating columns const int numCheckboxCols = 4; const int numTextCols = 10; listGui.Columns.AddRange( Enumerable.Range(1, numCheckboxCols) .Select(i => (DataGridViewColumn) new DataGridViewCheckBoxColumn()) .Concat(Enumerable.Range(1, numTextCols) .Select(i => new DataGridViewTextBoxColumn())) .ToArray()); // Assert (and Act a bit more) Assert.IsNotNull(instance.KSP); Assert.IsNotNull(manager); Assert.IsNotNull(modList); var modules = registry.available_modules .Select(mod => new GUIMod(mod.Value.Latest(), registry, instance.KSP.VersionCriteria())) .ToList(); listGui.Rows.AddRange(modList.ConstructModList(modules, null).ToArray()); // The header row adds one to the count Assert.AreEqual(modules.Count + 1, listGui.Rows.Count); // Sort by game compatibility, this is the fuse-lighting listGui.Sort(listGui.Columns[8], ListSortDirection.Descending); // Mark the mod for install, after completion we will get an exception var otherModule = modules.First(mod => mod.Identifier.Contains("kOS")); otherModule.IsInstallChecked = true; Assert.IsTrue(otherModule.IsInstallChecked); Assert.IsFalse(otherModule.IsInstalled); Assert.DoesNotThrow(() => { // Install the "other" module installer.InstallList( modList.ComputeUserChangeSet(null).Select(change => change.Mod).ToList(), new RelationshipResolverOptions(), registryManager, ref possibleConfigOnlyDirs, downloader ); // Now we need to sort // Make sure refreshing the GUI state does not throw a NullReferenceException listGui.Refresh(); }); instance.Dispose(); manager.Dispose(); config.Dispose(); }
public void setUp() { registry = new RegistryManager(); }
public DeviceTwinRepository(string iotHubConnectionString) { _iotHubConnectionString = iotHubConnectionString; _registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString); _jobClient = JobClient.CreateFromConnectionString(iotHubConnectionString); }
public IoTSetDeviceTwinAsyncCollector(RegistryManager registryManager, IoTSetDeviceTwinAttribute attribute) { // create client; this.registryManager = registryManager; }
/// <summary> /// Upgrade an installed module /// </summary> /// <param name="ksp">Game instance from which to remove</param> /// <param name="raw_options">Command line options object</param> /// <returns> /// Exit code for shell environment /// </returns> public int RunCommand(CKAN.KSP ksp, object raw_options) { UpgradeOptions options = (UpgradeOptions)raw_options; if (options.ckan_file != null) { options.modules.Add(MainClass.LoadCkanFromFile(ksp, options.ckan_file).identifier); } if (options.modules.Count == 0 && !options.upgrade_all) { // What? No files specified? User.RaiseMessage("Usage: ckan upgrade Mod [Mod2, ...]"); User.RaiseMessage(" or ckan upgrade --all"); if (AutoUpdate.CanUpdate) { User.RaiseMessage(" or ckan upgrade ckan"); } return(Exit.BADOPT); } if (!options.upgrade_all && options.modules[0] == "ckan" && AutoUpdate.CanUpdate) { User.RaiseMessage("Querying the latest CKAN version"); AutoUpdate.Instance.FetchLatestReleaseInfo(); var latestVersion = AutoUpdate.Instance.latestUpdate.Version; var currentVersion = new ModuleVersion(Meta.GetVersion(VersionFormat.Short)); if (latestVersion.IsGreaterThan(currentVersion)) { User.RaiseMessage("New CKAN version available - " + latestVersion); var releaseNotes = AutoUpdate.Instance.latestUpdate.ReleaseNotes; User.RaiseMessage(releaseNotes); User.RaiseMessage("\r\n"); if (User.RaiseYesNoDialog("Proceed with install?")) { User.RaiseMessage("Upgrading CKAN, please wait.."); AutoUpdate.Instance.StartUpdateProcess(false); } } else { User.RaiseMessage("You already have the latest version."); } return(Exit.OK); } User.RaiseMessage("\r\nUpgrading modules...\r\n"); try { HashSet <string> possibleConfigOnlyDirs = null; var regMgr = RegistryManager.Instance(ksp); var registry = regMgr.registry; if (options.upgrade_all) { var installed = new Dictionary <string, ModuleVersion>(registry.Installed()); var to_upgrade = new List <CkanModule>(); foreach (KeyValuePair <string, ModuleVersion> mod in installed) { ModuleVersion current_version = mod.Value; if ((current_version is ProvidesModuleVersion) || (current_version is UnmanagedModuleVersion)) { continue; } else { try { // Check if upgrades are available var latest = registry.LatestAvailable(mod.Key, ksp.VersionCriteria()); // This may be an unindexed mod. If so, // skip rather than crash. See KSP-CKAN/CKAN#841. if (latest == null || latest.IsDLC) { continue; } if (latest.version.IsGreaterThan(mod.Value)) { // Upgradable log.InfoFormat("New version {0} found for {1}", latest.version, latest.identifier); to_upgrade.Add(latest); } } catch (ModuleNotFoundKraken) { log.InfoFormat("{0} is installed, but no longer in the registry", mod.Key); } } } ModuleInstaller.GetInstance(ksp, manager.Cache, User).Upgrade(to_upgrade, new NetAsyncModulesDownloader(User, manager.Cache), ref possibleConfigOnlyDirs, regMgr); } else { // TODO: These instances all need to go. Search.AdjustModulesCase(ksp, options.modules); ModuleInstaller.GetInstance(ksp, manager.Cache, User).Upgrade(options.modules, new NetAsyncModulesDownloader(User, manager.Cache), ref possibleConfigOnlyDirs, regMgr); } } catch (ModuleNotFoundKraken kraken) { User.RaiseMessage("Module {0} not found", kraken.module); return(Exit.ERROR); } catch (InconsistentKraken kraken) { User.RaiseMessage(kraken.ToString()); return(Exit.ERROR); } catch (ModuleIsDLCKraken kraken) { User.RaiseMessage($"CKAN can't upgrade expansion '{kraken.module.name}' for you."); var res = kraken?.module?.resources; var storePagesMsg = new Uri[] { res?.store, res?.steamstore } .Where(u => u != null) .Aggregate("", (a, b) => $"{a}\r\n- {b}"); if (!string.IsNullOrEmpty(storePagesMsg)) { User.RaiseMessage($"To upgrade this expansion, download any updates from the store page from which you purchased it:\r\n{storePagesMsg}"); } return(Exit.ERROR); } User.RaiseMessage("\r\nDone!\r\n"); return(Exit.OK); }
/// <summary> /// Initialize the Screen /// </summary> /// <param name="mgr">Game instance manager containing the instances</param> /// <param name="k">Instance to edit</param> public GameInstanceEditScreen(GameInstanceManager mgr, GameInstance k) : base(mgr, k.Name, k.GameDir()) { ksp = k; try { // If we can't parse the registry, just leave the repo list blank registry = RegistryManager.Instance(ksp).registry; } catch { } // Show the repositories if we can if (registry != null) { // Need to edit a copy of the list so it doesn't save on cancel repoEditList = new SortedDictionary <string, Repository>(); foreach (var kvp in registry.Repositories) { repoEditList.Add(kvp.Key, new Repository( kvp.Value.name, kvp.Value.uri.ToString(), kvp.Value.priority )); } // Also edit copy of the compatible versions compatEditList = new List <GameVersion>(ksp.GetCompatibleVersions()); // I'm not a huge fan of this layout, but I think it's better than just a label AddObject(new ConsoleDoubleFrame( 1, repoFrameTop, -1, compatFrameBottom, compatFrameTop, () => $"Mod List Sources", () => $"Additional Compatible Versions", th => th.LabelFg )); repoList = new ConsoleListBox <Repository>( 3, repoListTop, -3, repoListBottom, new List <Repository>(repoEditList.Values), new List <ConsoleListBoxColumn <Repository> >() { new ConsoleListBoxColumn <Repository>() { Header = "Index", Renderer = r => r.priority.ToString(), Width = 7 }, new ConsoleListBoxColumn <Repository>() { Header = "Name", Renderer = r => r.name, Width = 16 }, new ConsoleListBoxColumn <Repository>() { Header = "URL", Renderer = r => r.uri.ToString(), Width = 50 } }, 1, 0, ListSortDirection.Ascending ); AddObject(repoList); repoList.AddTip("A", "Add"); repoList.AddBinding(Keys.A, (object sender, ConsoleTheme theme) => { LaunchSubScreen(theme, new RepoAddScreen(ksp.game, repoEditList)); repoList.SetData(new List <Repository>(repoEditList.Values)); return(true); }); repoList.AddTip("R", "Remove"); repoList.AddBinding(Keys.R, (object sender, ConsoleTheme theme) => { int oldPrio = repoList.Selection.priority; repoEditList.Remove(repoList.Selection.name); // Reshuffle the priorities to fill foreach (Repository r in repoEditList.Values) { if (r.priority > oldPrio) { --r.priority; } } repoList.SetData(new List <Repository>(repoEditList.Values)); return(true); }); repoList.AddTip("E", "Edit"); repoList.AddBinding(Keys.E, (object sender, ConsoleTheme theme) => { LaunchSubScreen(theme, new RepoEditScreen(ksp.game, repoEditList, repoList.Selection)); repoList.SetData(new List <Repository>(repoEditList.Values)); return(true); }); repoList.AddTip("-", "Up"); repoList.AddBinding(Keys.Minus, (object sender, ConsoleTheme theme) => { if (repoList.Selection.priority > 0) { Repository prev = SortedDictFind(repoEditList, r => r.priority == repoList.Selection.priority - 1); if (prev != null) { ++prev.priority; } --repoList.Selection.priority; repoList.SetData(new List <Repository>(repoEditList.Values)); } return(true); }); repoList.AddTip("+", "Down"); repoList.AddBinding(Keys.Plus, (object sender, ConsoleTheme theme) => { Repository next = SortedDictFind(repoEditList, r => r.priority == repoList.Selection.priority + 1); if (next != null) { --next.priority; } ++repoList.Selection.priority; repoList.SetData(new List <Repository>(repoEditList.Values)); return(true); }); compatList = new ConsoleListBox <GameVersion>( 3, compatListTop, -3, compatListBottom, compatEditList, new List <ConsoleListBoxColumn <GameVersion> >() { new ConsoleListBoxColumn <GameVersion>() { Header = "Version", Width = 10, Renderer = v => v.ToString(), Comparer = (a, b) => a.CompareTo(b) } }, 0, 0, ListSortDirection.Descending ); AddObject(compatList); compatList.AddTip("A", "Add"); compatList.AddBinding(Keys.A, (object sender, ConsoleTheme theme) => { CompatibleVersionDialog vd = new CompatibleVersionDialog(ksp.game); GameVersion newVersion = vd.Run(theme); DrawBackground(theme); if (newVersion != null && !compatEditList.Contains(newVersion)) { compatEditList.Add(newVersion); compatList.SetData(compatEditList); } return(true); }); compatList.AddTip("R", "Remove", () => compatList.Selection != null); compatList.AddBinding(Keys.R, (object sender, ConsoleTheme theme) => { compatEditList.Remove(compatList.Selection); compatList.SetData(compatEditList); return(true); }); } else { // Notify the user that the registry doesn't parse AddObject(new ConsoleLabel( 1, repoFrameTop, -1, () => $"Failed to extract mod list sources from {ksp.Name}." )); } }
static async Task <int> Main(string[] args) { var connectionString = Environment.GetEnvironmentVariable(IotHubConnectionStringEnvVar); if (string.IsNullOrWhiteSpace(connectionString)) { Console.Error.WriteLine($"Environment variable for '{IotHubConnectionStringEnvVar}' is not defined"); return(-1); } var devicePrefix = Environment.GetEnvironmentVariable(DevicePrefixEnvVar); if (string.IsNullOrWhiteSpace(devicePrefix)) { devicePrefix = "sim"; } if (!int.TryParse(Environment.GetEnvironmentVariable(DeviceCountEnvVar), out var deviceCount) || deviceCount < 1) { deviceCount = 1; } if (!int.TryParse(Environment.GetEnvironmentVariable(DeviceIndexEnvVar), out var deviceIndex) || deviceIndex < 0) { deviceIndex = 1; } bool isCreateOperation = true; if (string.Equals(Environment.GetEnvironmentVariable(OperationNameEnvVar), DeleteOperationNameEnvVar, StringComparison.OrdinalIgnoreCase)) { var isDeleteConfirmed = string.Equals(Environment.GetEnvironmentVariable(DeleteConfirmationEnvVar), DeleteConfirmationResponseEnvVar, StringComparison.OrdinalIgnoreCase); if (!isDeleteConfirmed) { Console.WriteLine($"Delete operations must be confirmed with an additional environment variable {DeleteConfirmationEnvVar}={DeleteConfirmationResponseEnvVar}"); return(-1); } isCreateOperation = false; } RegistryManager registryManager = null; try { registryManager = RegistryManager.CreateFromConnectionString(connectionString); } catch (Exception ex) { Console.Error.WriteLine("Failed connecting to IoT Hub registry, check the connection string value\n" + ex.ToString()); return(1); } try { await registryManager.OpenAsync(); } catch (Exception ex) { Console.Error.WriteLine("Failed connecting to IoT Hub registry.\n" + ex.ToString()); return(1); } var deviceIdCollection = Enumerable.Range(deviceIndex, deviceCount) .Select(n => $"{devicePrefix}{n.ToString("000000")}"); var registryManagerTasks = new List <Task>(); var stats = new DeviceProvisionStats(); if (isCreateOperation) { Console.WriteLine($"Starting device provisioning"); } else { Console.WriteLine($"Starting device deletion"); } var timer = Stopwatch.StartNew(); foreach (var partition in Partitioner.Create(deviceIdCollection).GetPartitions(ParallelizationLevel)) { if (isCreateOperation) { registryManagerTasks.Add(Task.Run(() => CreateDevicesAsync(partition, registryManager, stats))); } else { registryManagerTasks.Add(Task.Run(() => DeleteDevicesAsync(partition, registryManager, stats))); } } try { await Task.WhenAll(registryManagerTasks); } catch (Exception ex) { Console.Error.WriteLine(ex); } timer.Stop(); Console.WriteLine($"Finished device provisioning"); Console.WriteLine($"Device count = {deviceCount}"); Console.WriteLine($"Total devices created = {stats.TotalCreated}"); Console.WriteLine($"Total devices deleted = {stats.TotalDeleted}"); Console.WriteLine($"Total errors = {stats.TotalErrors}"); Console.WriteLine($"Time = {timer.ElapsedMilliseconds}ms"); return(0); }
public DeviceManager(IConfiguration config) { _serviceClient = ServiceClient.CreateFromConnectionString(config["Server:ServiceConnectionString"]); _registryManager = RegistryManager.CreateFromConnectionString(config["Server:RegistryConnectionString"]); }
public static async Task <TestModule> CreateAndConnect(RegistryManager rm, string hostName, string deviceId, string moduleId, ITransportSettings[] transportSettings) { string connStr = await RegistryManagerHelper.GetOrCreateModule(rm, hostName, deviceId, moduleId); return(await CreateAndConnect(connStr, transportSettings)); }
public AzureIoTHub(string connectionString) { registryManager = RegistryManager.CreateFromConnectionString(connectionString); Name = connectionString.Substring(connectionString.IndexOf('=') + 1); Name = Name.Substring(0, Name.IndexOf(".")); }
public static async System.Threading.Tasks.Task <HttpResponseMessage> RunAsync([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, TraceWriter log, ExecutionContext context) { var config = new ConfigurationBuilder() .SetBasePath(context.FunctionAppDirectory) .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables() .Build(); string connectionString = config.GetConnectionString("IoTHubConnectionString"); string deviceConfigurationUrl = Environment.GetEnvironmentVariable("DEVICE_CONFIG_LOCATION"); RegistryManager manager = RegistryManager.CreateFromConnectionString(connectionString); // parse query parameter var queryStrings = req.GetQueryParameterDictionary(); string deviceName = ""; string publishingUserName = ""; string publishingPassword = ""; string region = ""; string resetPin = ""; queryStrings.TryGetValue("deviceName", out deviceName); queryStrings.TryGetValue("publishingUserName", out publishingUserName); queryStrings.TryGetValue("publishingPassword", out publishingPassword); queryStrings.TryGetValue("region", out region); queryStrings.TryGetValue("resetPin", out resetPin); //Get function facade key var base64Auth = Convert.ToBase64String(Encoding.Default.GetBytes($"{publishingUserName}:{publishingPassword}")); var apiUrl = new Uri($"https://{Environment.GetEnvironmentVariable("WEBSITE_CONTENTSHARE")}.scm.azurewebsites.net/api"); var siteUrl = new Uri($"https://{Environment.GetEnvironmentVariable("WEBSITE_CONTENTSHARE")}.azurewebsites.net"); string JWT; using (var client = new HttpClient()) { client.DefaultRequestHeaders.Add("Authorization", $"Basic {base64Auth}"); var result = client.GetAsync($"{apiUrl}/functions/admin/token").Result; JWT = result.Content.ReadAsStringAsync().Result.Trim('"'); //get JWT for call funtion key } string facadeKey = ""; using (var client = new HttpClient()) { client.DefaultRequestHeaders.Add("Authorization", "Bearer " + JWT); string jsonResult = client.GetAsync($"{siteUrl}/admin/host/keys").Result.Content.ReadAsStringAsync().Result; dynamic resObject = JsonConvert.DeserializeObject(jsonResult); facadeKey = resObject.keys[0].value; } Device edgeGatewayDevice = new Device(deviceName); edgeGatewayDevice.Capabilities = new DeviceCapabilities() { IotEdge = true }; await manager.AddDeviceAsync(edgeGatewayDevice); string json = ""; //todo correct using (WebClient wc = new WebClient()) { json = wc.DownloadString(deviceConfigurationUrl); } json = json.Replace("[$region]", region); json = json.Replace("[$reset_pin]", resetPin); ConfigurationContent spec = JsonConvert.DeserializeObject <ConfigurationContent>(json); await manager.AddModuleAsync(new Module(deviceName, "LoRaWanNetworkSrvModule")); await manager.ApplyConfigurationContentOnDeviceAsync(deviceName, spec); Twin twin = new Twin(); twin.Properties.Desired = new TwinCollection(@"{FacadeServerUrl:'" + String.Format("https://{0}.azurewebsites.net/api/", GetEnvironmentVariable("FACADE_HOST_NAME")) + "',FacadeAuthCode: " + "'" + facadeKey + "'}"); var remoteTwin = await manager.GetTwinAsync(deviceName); await manager.UpdateTwinAsync(deviceName, "LoRaWanNetworkSrvModule", twin, remoteTwin.ETag); bool deployEndDevice = false; Boolean.TryParse(Environment.GetEnvironmentVariable("DEPLOY_DEVICE"), out deployEndDevice); //This section will get deployed ONLY if the user selected the "deploy end device" options. //Information in this if clause, is for demo purpose only and should not be used for productive workloads. if (deployEndDevice) { string OTAAdeviceId = "47AAC86800430028"; Device OTAADevice = new Device(OTAAdeviceId); await manager.AddDeviceAsync(OTAADevice); Twin OTAAendTwin = new Twin(); OTAAendTwin.Properties.Desired = new TwinCollection(@"{AppEUI:'BE7A0000000014E2',AppKey:'8AFE71A145B253E49C3031AD068277A1',GatewayID:''," + "SensorDecoder:'DecoderValueSensor'}"); var OTAARemoteTwin = await manager.GetTwinAsync(OTAAdeviceId); await manager.UpdateTwinAsync(OTAAdeviceId, OTAAendTwin, OTAARemoteTwin.ETag); string ABPdeviceId = "46AAC86800430028"; Device ABPDevice = new Device(ABPdeviceId); await manager.AddDeviceAsync(ABPDevice); Twin ABPTwin = new Twin(); ABPTwin.Properties.Desired = new TwinCollection(@"{AppSKey:'2B7E151628AED2A6ABF7158809CF4F3C',NwkSKey:'3B7E151628AED2A6ABF7158809CF4F3C',GatewayID:''," + "DevAddr:'0028B1B1',SensorDecoder:'DecoderValueSensor'}"); var ABPRemoteTwin = await manager.GetTwinAsync(ABPdeviceId); await manager.UpdateTwinAsync(ABPdeviceId, ABPTwin, ABPRemoteTwin.ETag); } var template = @"{'$schema': 'https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#', 'contentVersion': '1.0.0.0', 'parameters': {}, 'variables': {}, 'resources': []}"; HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK); response.Content = new StringContent(template, System.Text.Encoding.UTF8, "application/json"); return(response); }
static void Main(string[] args) { registryManager = RegistryManager.CreateFromConnectionString(Constants.connectionString); AddDeviceAsync().Wait(); Console.ReadLine(); }
public DeviceGetter(RegistryManager registryManager, ILoRaDeviceCacheStore cacheStore) { this.registryManager = registryManager; this.cacheStore = cacheStore; }
public FileManager() { fe = new FileEncrypter(); rm = new RegistryManager(); }
public DeviceIdentity() { // initialize to default values _connectionString = AzureIoTHub.GetConnectionString(); _registryManager = RegistryManager.CreateFromConnectionString(_connectionString); }
RegistryManager GetRegistryManager() { return(this.registryManager ?? (this.registryManager = RegistryManager.CreateFromConnectionString(this.Configuration.IoTHubConnectionString))); }
public CleanUpDevicesSample(RegistryManager rm) { _rm = rm ?? throw new ArgumentNullException(nameof(rm)); }
private void AddToStartup() { RegistryManager rm = new RegistryManager(); rm.AddItemToStartup(REGISTRY_STARTUP_VALUE_NAME, this.new_path, NO_MELT_ARG); }
public async Task TestEdgeHubConnection() { var twinMessageConverter = new TwinMessageConverter(); var twinCollectionMessageConverter = new TwinCollectionMessageConverter(); var messageConverterProvider = new MessageConverterProvider( new Dictionary <Type, IMessageConverter>() { { typeof(Client.Message), new DeviceClientMessageConverter() }, { typeof(Twin), twinMessageConverter }, { typeof(TwinCollection), twinCollectionMessageConverter } }); var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, new ClientProvider(), Option.None <UpstreamProtocol>()); var connectionManager = new ConnectionManager(cloudConnectionProvider); string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey"); Devices.IotHubConnectionStringBuilder iotHubConnectionStringBuilder = Devices.IotHubConnectionStringBuilder.Create(iotHubConnectionString); RegistryManager registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString); await registryManager.OpenAsync(); (string edgeDeviceId, string deviceConnStr) = await RegistryManagerHelper.CreateDevice("testHubEdgeDevice1", iotHubConnectionString, registryManager, true, false); try { string iothubHostName = iotHubConnectionStringBuilder.HostName; var identityFactory = new ClientCredentialsFactory(iothubHostName); string edgeHubConnectionString = $"{deviceConnStr};ModuleId={EdgeHubModuleId}"; IClientCredentials edgeHubCredentials = identityFactory.GetWithConnectionString(edgeHubConnectionString); Assert.NotNull(edgeHubCredentials); Assert.NotNull(edgeHubCredentials.Identity); // Set Edge hub desired properties await this.SetDesiredProperties(registryManager, edgeDeviceId); var endpointFactory = new EndpointFactory(connectionManager, new RoutingMessageConverter(), edgeDeviceId); var routeFactory = new EdgeRouteFactory(endpointFactory); var dbStoreProvider = new InMemoryDbStoreProvider(); IStoreProvider storeProvider = new StoreProvider(dbStoreProvider); IEntityStore <string, TwinInfo> twinStore = storeProvider.GetEntityStore <string, TwinInfo>("twins"); var twinManager = new TwinManager(connectionManager, twinCollectionMessageConverter, twinMessageConverter, Option.Some(twinStore)); var routerConfig = new RouterConfig(Enumerable.Empty <Route>()); TimeSpan defaultTimeout = TimeSpan.FromSeconds(60); var endpointExecutorFactory = new SyncEndpointExecutorFactory(new EndpointExecutorConfig(defaultTimeout, new FixedInterval(0, TimeSpan.FromSeconds(1)), defaultTimeout, true)); Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), iothubHostName, routerConfig, endpointExecutorFactory); IInvokeMethodHandler invokeMethodHandler = new InvokeMethodHandler(connectionManager); IEdgeHub edgeHub = new RoutingEdgeHub(router, new RoutingMessageConverter(), connectionManager, twinManager, edgeDeviceId, invokeMethodHandler); var versionInfo = new VersionInfo("v1", "b1", "c1"); // Create Edge Hub connection Try <ICloudProxy> edgeHubCloudProxy = await connectionManager.CreateCloudConnectionAsync(edgeHubCredentials); Assert.True(edgeHubCloudProxy.Success); EdgeHubConnection edgeHubConnection = await EdgeHubConnection.Create( edgeHubCredentials.Identity as IModuleIdentity, edgeHub, twinManager, connectionManager, edgeHubCloudProxy.Value, routeFactory, twinCollectionMessageConverter, twinMessageConverter, versionInfo ); await Task.Delay(TimeSpan.FromMinutes(1)); // Get and Validate EdgeHubConfig Option <EdgeHubConfig> edgeHubConfigOption = await edgeHubConnection.GetConfig(); Assert.True(edgeHubConfigOption.HasValue); EdgeHubConfig edgeHubConfig = edgeHubConfigOption.OrDefault(); Assert.Equal("1.0", edgeHubConfig.SchemaVersion); Assert.NotNull(edgeHubConfig.Routes); Assert.NotNull(edgeHubConfig.StoreAndForwardConfiguration); Assert.Equal(20, edgeHubConfig.StoreAndForwardConfiguration.TimeToLiveSecs); List <(string Name, string Value, Route Route)> routes = edgeHubConfig.Routes.ToList(); Assert.Equal(4, routes.Count); (string Name, string Value, Route Route)route1 = routes[0]; Assert.NotNull(route1); Assert.True(route1.Route.Endpoints.First().GetType() == typeof(CloudEndpoint)); Assert.Equal("route1", route1.Name); Assert.Equal("from /* INTO $upstream", route1.Value); (string Name, string Value, Route Route)route2 = routes[1]; Assert.NotNull(route2); Endpoint endpoint = route2.Route.Endpoints.First(); Assert.True(endpoint.GetType() == typeof(ModuleEndpoint)); Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id); Assert.Equal("route2", route2.Name); Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value); (string Name, string Value, Route Route)route3 = routes[2]; Assert.NotNull(route3); endpoint = route3.Route.Endpoints.First(); Assert.True(endpoint.GetType() == typeof(ModuleEndpoint)); Assert.Equal($"{edgeDeviceId}/module3/input1", endpoint.Id); Assert.Equal("route3", route3.Name); Assert.Equal("from /modules/module2 INTO BrokeredEndpoint(\"/modules/module3/inputs/input1\")", route3.Value); (string Name, string Value, Route Route)route4 = routes[3]; Assert.NotNull(route4); endpoint = route4.Route.Endpoints.First(); Assert.True(endpoint.GetType() == typeof(ModuleEndpoint)); Assert.Equal($"{edgeDeviceId}/module4/input1", endpoint.Id); Assert.Equal("route4", route4.Name); Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module4/inputs/input1\")", route4.Value); // Make sure reported properties were updated appropriately EdgeHubConnection.ReportedProperties reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId); Assert.Equal(200, reportedProperties.LastDesiredStatus.Code); Assert.NotNull(reportedProperties.Clients); Assert.Equal(0, reportedProperties.Clients.Count); Assert.Equal("1.0", reportedProperties.SchemaVersion); Assert.Equal(versionInfo, reportedProperties.VersionInfo); // Simulate a module and a downstream device that connects to Edge Hub. string moduleId = "module1"; string sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{edgeDeviceId}/modules/{moduleId}"); string moduleConnectionstring = $"HostName={iothubHostName};DeviceId={edgeDeviceId};ModuleId={moduleId};SharedAccessSignature={sasToken}"; IClientCredentials moduleClientCredentials = identityFactory.GetWithConnectionString(moduleConnectionstring); var moduleProxy = Mock.Of <IDeviceProxy>(d => d.IsActive); string downstreamDeviceId = "device1"; sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{downstreamDeviceId}"); string downstreamDeviceConnectionstring = $"HostName={iothubHostName};DeviceId={downstreamDeviceId};SharedAccessSignature={sasToken}"; IClientCredentials downstreamDeviceCredentials = identityFactory.GetWithConnectionString(downstreamDeviceConnectionstring); var downstreamDeviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive); // Connect the module and downstream device and make sure the reported properties are updated as expected. await connectionManager.AddDeviceConnection(moduleClientCredentials.Identity, moduleProxy); await connectionManager.AddDeviceConnection(downstreamDeviceCredentials.Identity, downstreamDeviceProxy); string moduleIdKey = $"{edgeDeviceId}/{moduleId}"; await Task.Delay(TimeSpan.FromSeconds(10)); reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId); Assert.Equal(2, reportedProperties.Clients.Count); Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[moduleIdKey].Status); Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc); Assert.Null(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc); Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[downstreamDeviceId].Status); Assert.NotNull(reportedProperties.Clients[downstreamDeviceId].LastConnectedTimeUtc); Assert.Null(reportedProperties.Clients[downstreamDeviceId].LastDisconnectTimeUtc); Assert.Equal(200, reportedProperties.LastDesiredStatus.Code); Assert.Equal("1.0", reportedProperties.SchemaVersion); Assert.Equal(versionInfo, reportedProperties.VersionInfo); // Update desired propertied and make sure callback is called with valid values bool callbackCalled = false; Task ConfigUpdatedCallback(EdgeHubConfig updatedConfig) { Assert.NotNull(updatedConfig); Assert.NotNull(updatedConfig.StoreAndForwardConfiguration); Assert.NotNull(updatedConfig.Routes); routes = updatedConfig.Routes.ToList(); Assert.Equal(4, routes.Count); route1 = routes[0]; Assert.NotNull(route1); Assert.True(route1.Route.Endpoints.First().GetType() == typeof(CloudEndpoint)); Assert.Equal("route1", route1.Name); Assert.Equal("from /* INTO $upstream", route1.Value); route2 = routes[1]; Assert.NotNull(route2); endpoint = route2.Route.Endpoints.First(); Assert.True(endpoint.GetType() == typeof(ModuleEndpoint)); Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id); Assert.Equal("route2", route2.Name); Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value); route3 = routes[2]; Assert.NotNull(route3); endpoint = route3.Route.Endpoints.First(); Assert.True(endpoint.GetType() == typeof(ModuleEndpoint)); Assert.Equal($"{edgeDeviceId}/module5/input1", endpoint.Id); Assert.Equal("route4", route3.Name); Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module5/inputs/input1\")", route3.Value); route4 = routes[3]; Assert.NotNull(route4); endpoint = route4.Route.Endpoints.First(); Assert.True(endpoint.GetType() == typeof(ModuleEndpoint)); Assert.Equal($"{edgeDeviceId}/module6/input1", endpoint.Id); Assert.Equal("route5", route4.Name); Assert.Equal("from /modules/module5 INTO BrokeredEndpoint(\"/modules/module6/inputs/input1\")", route4.Value); callbackCalled = true; return(Task.CompletedTask); } edgeHubConnection.SetConfigUpdatedCallback(ConfigUpdatedCallback); await this.UpdateDesiredProperties(registryManager, edgeDeviceId); await Task.Delay(TimeSpan.FromSeconds(5)); Assert.True(callbackCalled); reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId); Assert.Equal(200, reportedProperties.LastDesiredStatus.Code); Assert.NotNull(reportedProperties.Clients); Assert.Equal(2, reportedProperties.Clients.Count); Assert.Equal("1.0", reportedProperties.SchemaVersion); Assert.Equal(versionInfo, reportedProperties.VersionInfo); // Disconnect the downstream device and make sure the reported properties are updated as expected. await connectionManager.RemoveDeviceConnection(moduleIdKey); await connectionManager.RemoveDeviceConnection(downstreamDeviceId); await Task.Delay(TimeSpan.FromSeconds(10)); reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId); Assert.Equal(1, reportedProperties.Clients.Count); Assert.True(reportedProperties.Clients.ContainsKey(moduleIdKey)); Assert.False(reportedProperties.Clients.ContainsKey(downstreamDeviceId)); Assert.Equal(ConnectionStatus.Disconnected, reportedProperties.Clients[moduleIdKey].Status); Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc); Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc); Assert.Equal(200, reportedProperties.LastDesiredStatus.Code); Assert.Equal("1.0", reportedProperties.SchemaVersion); Assert.Equal(versionInfo, reportedProperties.VersionInfo); // If the edge hub restarts, clear out the connected devices in the reported properties. await EdgeHubConnection.Create(edgeHubCredentials.Identity as IModuleIdentity, edgeHub, twinManager, connectionManager, edgeHubCloudProxy.Value, routeFactory, twinCollectionMessageConverter, twinMessageConverter, versionInfo); await Task.Delay(TimeSpan.FromMinutes(1)); reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId); Assert.Null(reportedProperties.Clients); Assert.Equal("1.0", reportedProperties.SchemaVersion); Assert.Equal(versionInfo, reportedProperties.VersionInfo); } finally { try { await RegistryManagerHelper.RemoveDevice(edgeDeviceId, registryManager); } catch (Exception) { // ignored } } }
public async Task RegistryManager_ConfigurationOperations_Work() { // arrange bool configCreated = false; string configurationId = (_idPrefix + Guid.NewGuid()).ToLower(); // Configuration Id characters must be all lower-case. using var client = RegistryManager.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString); try { var expected = new Configuration(configurationId) { Priority = 2, Labels = { { "labelName", "labelValue" } }, TargetCondition = "*", Content = { DeviceContent = { { "properties.desired.x", 4L } }, }, Metrics = { Queries = { { "successfullyConfigured", "select deviceId from devices where properties.reported.x = 4" } } }, }; // act and assert Configuration addResult = await client.AddConfigurationAsync(expected).ConfigureAwait(false); configCreated = true; addResult.Id.Should().Be(configurationId); addResult.Priority.Should().Be(expected.Priority); addResult.TargetCondition.Should().Be(expected.TargetCondition); addResult.Content.DeviceContent.First().Should().Be(expected.Content.DeviceContent.First()); addResult.Metrics.Queries.First().Should().Be(expected.Metrics.Queries.First()); addResult.ETag.Should().NotBeNullOrEmpty(); Configuration getResult = await client.GetConfigurationAsync(configurationId).ConfigureAwait(false); getResult.Id.Should().Be(configurationId); getResult.Priority.Should().Be(expected.Priority); getResult.TargetCondition.Should().Be(expected.TargetCondition); getResult.Content.DeviceContent.First().Should().Be(expected.Content.DeviceContent.First()); getResult.Metrics.Queries.First().Should().Be(expected.Metrics.Queries.First()); getResult.ETag.Should().Be(addResult.ETag); IEnumerable <Configuration> listResult = await client.GetConfigurationsAsync(100).ConfigureAwait(false); listResult.Should().Contain(x => x.Id == configurationId); expected.Priority++; expected.ETag = getResult.ETag; Configuration updateResult = await client.UpdateConfigurationAsync(expected).ConfigureAwait(false); updateResult.Id.Should().Be(configurationId); updateResult.Priority.Should().Be(expected.Priority); updateResult.TargetCondition.Should().Be(expected.TargetCondition); updateResult.Content.DeviceContent.First().Should().Be(expected.Content.DeviceContent.First()); updateResult.Metrics.Queries.First().Should().Be(expected.Metrics.Queries.First()); updateResult.ETag.Should().NotBeNullOrEmpty().And.Should().NotBe(getResult.ETag, "The ETag should have changed after update"); } finally { if (configCreated) { // If this fails, we shall let it throw an exception and fail the test await client.RemoveConfigurationAsync(configurationId).ConfigureAwait(false); } } }
static async Task <IEnumerable <Device> > GetDevices(string iothubConString, int maxdevices = 500) { var registryManager = RegistryManager.CreateFromConnectionString(iothubConString); return(await registryManager.GetDevicesAsync(maxdevices)); // Time 1 sek }