示例#1
1
        public static void Main(string[] args)
        {
            // Register Device with Azure
            registryManager = RegistryManager.CreateFromConnectionString(connectionString);
            RegisterDeviceAsync().Wait();

            Console.WriteLine("Simulated device\n");
            deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey));

            SendDeviceToCloudMessagesAsync();
            Console.ReadLine();

        }
示例#2
0
        static void Main( string[] args )
        {
            registryManager = RegistryManager.CreateFromConnectionString( connectionString );
            AddDeviceAsync( ).Wait( );

            Console.ReadLine( );
        }
示例#3
0
        private static async Task PrepareTestAsync()
        {
            kRegistryManager      = AZD.RegistryManager.CreateFromConnectionString(kIoTHubConnectionString);
            kDeviceConnectionList = new List <string>();
            kDevicesList          = new List <AZD.Device>();

            do
            {
                var devicesList = (await kRegistryManager.GetDevicesAsync(kDevicePageSize)).ToList();
                kDevicesList.AddRange(devicesList);

                if (kDevicesList.Count == kTotalDevices)
                {
                    break;
                }
            } while (true);

            for (int idx = 0; idx < kDevicesList.Count; ++idx)
            {
                try
                {
                    var device     = kDevicesList[idx];
                    var connString = device.Authentication.SymmetricKey.PrimaryKey;
                    connString = string.Format(kDeviceConnectionString, device.Id, connString);
                    Console.WriteLine(connString);

                    kDeviceConnectionList.Add(connString);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
示例#4
0
        /// <summary>
        /// Simulator a device
        /// </summary>
        /// <param name="args">Usage: sumulator {deviceid} {min} {max}</param>
        static void Main(string[] args)
        {
            #region added
            if (args.Length < 3)
            {
                Error("Usage: sumulator {deviceid} {max} {min}");
                Wait();
                return;
            }
            deviceId = args[0];
            max = int.Parse(args[2]);
            min = int.Parse(args[1]);
            run = true;
            connectionString = ConfigurationManager.AppSettings["iotHubConnectionString"];
            iotHubUri = ConfigurationManager.AppSettings["iotHubUri"];

            registryManager = RegistryManager.CreateFromConnectionString(connectionString);
            #endregion
            AddDeviceAsync().Wait();

            SendDeviceToCloudMessagesAsync();
            ReceiveCommandAsync();
            Wait("Press [ENTER] to exit...");
            run = false;
            RemoveDeviceAsync().Wait();
        }
示例#5
0
        private static async Task AddDevicesAsync()
        {
            kRegistryManager      = AZD.RegistryManager.CreateFromConnectionString(kIoTHubConnectionString);
            kDeviceConnectionList = new List <DeviceClient>();

            for (int idx = 0; idx < kTotalDevices; ++idx)
            {
                var deviceIdString = $"dev{idx}";
                try
                {
                    var device = await kRegistryManager.AddDeviceAsync(new AZD.Device(deviceIdString));

                    var connString = device.Authentication.SymmetricKey.PrimaryKey;
                    connString = string.Format(kDeviceConnectionString, deviceIdString, connString);

                    Console.WriteLine(connString);

                    kDeviceConnectionList.Add(DeviceClient.CreateFromConnectionString(connString));
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
        public  async static Task<string> AddDeviceAsync(string deviceId)
        {
            Device device;
            bool isNew = true;

            if(registryManager == null)
                registryManager = RegistryManager.CreateFromConnectionString(connectionString);
            
            try
            {
                device = await registryManager.AddDeviceAsync(new Device(deviceId));
            }
            catch (DeviceAlreadyExistsException)
            {
                device = await registryManager.GetDeviceAsync(deviceId);
                isNew = false;
            }

            if(isNew)
                Debug.WriteLine(string.Format("Generated device key: {0}", device.Authentication.SymmetricKey.PrimaryKey));
            else
                Debug.WriteLine(string.Format("Using existing device key: {0}", device.Authentication.SymmetricKey.PrimaryKey));

            return device.Authentication.SymmetricKey.PrimaryKey;

        }
 public DevicesProcessor(string iotHubConnenctionString, int devicesCount, string protocolGatewayName)
 {
     this.listOfDevices = new List<DeviceEntity>();
     this.iotHubConnectionString = iotHubConnenctionString;
     this.maxCountOfDevices = devicesCount;
     this.protocolGatewayHostName = protocolGatewayName;
     this.registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
 }
 public DeviceUpdateForm(RegistryManager manager, int maxDevices, string deviceID)
 {
     InitializeComponent();
     this.registryManager = manager;
     this.devicesMaxCount = maxDevices;
     this.selectedDeviceID = deviceID;
     updateControls(deviceID);
 }
示例#9
0
        //------------------------------------------------------------------------------------------------------------------------
        #endregion

        #region Functions
        //------------------------------------------------------------------------------------------------------------------------
        public static string AddDevice(string devname, string connectionstring)
        {
            //create registermanager
            registryManager = RegistryManager.CreateFromConnectionString(connectionstring);
            //add device  to registry identity -- get devkey
            var res = AddDeviceAsync(devname).Result;
            return res;
        }
示例#10
0
 public SASTokenForm(RegistryManager registryManager, int maxDevices, string iotHubHostName)
 {
     InitializeComponent();
     this.registryManager = registryManager;
     this.devicesMaxCount = maxDevices;
     this.iotHubHostName = iotHubHostName;
     initControls();
 }
示例#11
0
        public async Task OpenAsync()
        {
            serviceClient = Microsoft.Azure.Devices.ServiceClient.CreateFromConnectionString(serviceConnectionString);

            await serviceClient.OpenAsync();

            registryManager = Microsoft.Azure.Devices.RegistryManager.CreateFromConnectionString(ownerConnectionString);
            await registryManager.OpenAsync();
        }
 public IOTHubDeviceExplorer(string iotHubConnenctionString, int devicesCount, string protocolGatewayName)
 {
    
     this.iotHubConnectionString = iotHubConnenctionString;
     this.maxCountOfDevices = devicesCount;
     this.protocolGatewayHostName = protocolGatewayName;
     this.registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
     this.serviceClient = ServiceClient.CreateFromConnectionString(iotHubConnectionString);
 }
示例#13
0
        public static void Main(string[] args)
        {
            Console.WriteLine("Please enter your IoT Hub connection string:");
            string connectionString = Console.ReadLine();

            Console.WriteLine("Please enter your device Id:");
            string deviceId = Console.ReadLine();

            registryManager = RegistryManager.CreateFromConnectionString(connectionString);
            AddDeviceAsync(deviceId).Wait();
            Console.ReadLine();
        }
示例#14
0
        public async void GetDeviceListFromAzure()
        {
            registryManager = RegistryManager.CreateFromConnectionString(connectionString);
            IQuery        query        = registryManager.CreateQuery("select * from devices");
            List <Device> localDevices = new List <Device>();
            Device        currentDevice;

            try
            {
                while (query.HasMoreResults)
                {
                    IEnumerable <Twin> devices = await query.GetNextAsTwinAsync();

                    devices.ToList().ForEach(x =>
                    {
                        currentDevice = new Device()
                        {
                            Id                    = x.DeviceId,
                            Status                = (AzureIOT.Models.Status)x.Status,
                            LastActive            = x.LastActivityTime ?? DateTime.MinValue,
                            CloudToDeviceMessages = x.CloudToDeviceMessageCount ?? x.CloudToDeviceMessageCount.Value,
                            AuthType              = (AzureIOT.Models.AuthTypes)(x.AuthenticationType ?? x.AuthenticationType),
                            PrimaryThumbprint     = x.X509Thumbprint.PrimaryThumbprint,
                            SecondaryThumbprint   = x.X509Thumbprint.SecondaryThumbprint
                        };
                        localDevices.Add(currentDevice);
                        currentDevice = null;
                    });
                }
                this.deviceResponse = new Response <List <Device> >()
                {
                    Success        = true,
                    ResponseObject = localDevices
                };
            }
            catch (Exception ex)
            {
                List <AzureException> azureException = new List <AzureException>()
                {
                    new AzureException()
                    {
                        Exception = ex, Message = ex.Message
                    }
                };
                this.deviceResponse = new Response <List <Device> >()
                {
                    Success    = false,
                    Exceptions = azureException.ToArray()
                };
            }
        }
示例#15
0
        private static void Main(string[] args)
        {
            _registryManager = RegistryManager.CreateFromConnectionString(_connectionString);

            #region Menu

            bool exit = false;
            while (!exit)
            {
                Console.WriteLine("(A)dd a device.");
                Console.WriteLine("(L)ist devices.");
                Console.WriteLine("(R)emove a device.");
                Console.WriteLine("E(x)it.");
                Console.Write("Select an option: ");

                var choice = Console.ReadLine();
                Console.WriteLine();

                string deviceId;
                switch (choice)
                {
                    case "A":
                    case "a":
                        deviceId = PromptForDeviceId();
                        AddDeviceAsync(deviceId).Wait();
                        break;

                    case "L":
                    case "l":
                        ViewDevicesAsync().Wait();
                        break;

                    case "R":
                    case "r":
                        deviceId = PromptForDeviceId();
                        RemoveDeviceAsync(deviceId).Wait();
                        break;

                    case "X":
                    case "x":
                        exit = true;
                        break;

                    default:
                        break;
                }
            }

            #endregion
        }
        public void GetDeviceListFromAzure()
        {
            registryManager = RegistryManager.CreateFromConnectionString(connectionStringForPortal);
            List <Device> localDevices = new List <Device>();
            IEnumerable <Microsoft.Azure.Devices.Device> azureDevice = new List <Microsoft.Azure.Devices.Device>();// = registryManager.GetDevicesAsync(100);
            Task task = Task.Run(() => { azureDevice = registryManager.GetDevicesAsync(100).Result; });

            task.Wait();
            Device currentDevice;

            try
            {
                foreach (var x in azureDevice)
                {
                    currentDevice = new Device()
                    {
                        Id                    = x.Id,
                        Status                = (AzureIOT.Models.Status)x.Status,
                        LastActive            = x.ConnectionStateUpdatedTime,
                        CloudToDeviceMessages = x.CloudToDeviceMessageCount,
                        //AuthType = (AzureIOT.Models.AuthTypes)(x. ?? x.AuthenticationType),
                        PrimaryThumbprint   = x.Authentication != null ? x.Authentication.X509Thumbprint.PrimaryThumbprint : null,
                        SecondaryThumbprint = x.Authentication != null ? x.Authentication.X509Thumbprint.SecondaryThumbprint : null,
                    };
                    localDevices.Add(currentDevice);
                    currentDevice = null;
                }
                this.deviceResponse = new Response <List <Device> >()
                {
                    Success        = true,
                    ResponseObject = localDevices
                };
            }
            catch (Exception ex)
            {
                List <AzureException> azureException = new List <AzureException>()
                {
                    new AzureException()
                    {
                        Exception = ex, Message = ex.Message
                    }
                };
                this.deviceResponse = new Response <List <Device> >()
                {
                    Success    = false,
                    Exceptions = azureException.ToArray()
                };
            }
        }
示例#17
0
        public CreateDeviceForm(string iotHubConnectionString, int devicesMaxCount)
        {
            InitializeComponent();

            this.iotHubConnectionString = iotHubConnectionString;
            this.registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
            this.devicesMaxCount = devicesMaxCount;
            
            generateIDCheckBox.Checked = false;
            generateDeviceID = false;

            generateKeysCheckBox.Checked = true;
            generateDeviceKeys = true;
            autoGenerateDeviceKeys();
        }
        public Device DeviceDetail(string DeviceId)
        {
            registryManager = RegistryManager.CreateFromConnectionString(connectionStringForPortal);
            List <Device> localDevices = new List <Device>();
            IEnumerable <Microsoft.Azure.Devices.Device> azureDevice = new List <Microsoft.Azure.Devices.Device>();// = registryManager.GetDevicesAsync(100);
            Task task = Task.Run(() => { azureDevice = registryManager.GetDevicesAsync(100).Result; });

            task.Wait();

            try
            {
                Device currentDevice = new Device();
                foreach (var x in azureDevice)
                {
                    if (x.Id != DeviceId)
                    {
                        continue;
                    }
                    currentDevice = new Device()
                    {
                        Id                    = x.Id,
                        Status                = (AzureIOT.Models.Status)x.Status,
                        LastActive            = x.LastActivityTime,
                        ConnectionStatus      = (AzureIOT.Models.ConnectStatus)x.ConnectionState,
                        CloudToDeviceMessages = x.CloudToDeviceMessageCount,
                        //AuthType = (AzureIOT.Models.AuthTypes)(x. ?? x.AuthenticationType),
                        PrimaryThumbprint   = x.Authentication != null ? x.Authentication.X509Thumbprint.PrimaryThumbprint : null,
                        SecondaryThumbprint = x.Authentication != null ? x.Authentication.X509Thumbprint.SecondaryThumbprint : null,
                    };
                }
                return(currentDevice);
            }
            catch (DeviceAlreadyExistsException ex)
            {
                List <AzureException> exception = new List <AzureException>()
                {
                    new AzureException()
                    {
                        Exception = ex, Message = ex.Message
                    }
                };
                return(new Device()
                {
                });
            }
        }
示例#19
0
		static string connectionString = ""; // Example: HostName=PierceHub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=SPHff77vetNDgrZahijsTMhGqZd0MllkgG0JyLzfz2E=

		public static void Main(string[] args)
		{
			Console.WriteLine("Device Provisioning Tool");
			Console.WriteLine("Creating a unique device identity for device: coffeeMaker");
			registryManager = RegistryManager.CreateFromConnectionString(connectionString);
			AddDeviceAsync().Wait();
			Console.WriteLine("Creating a unique Shared Access Signature for your account:");

			var signature = new SharedAccessSignatureBuilder()
			{
				KeyName = policyName,
				Key = policyKey,
				Target = iotHubUrl,
				TimeToLive = TimeSpan.FromDays(365)
			}.ToSignature();

			Console.WriteLine(signature);
			Console.ReadLine();
		}
        public DashboardFacts GetDashboardFacts()
        {
            DashboardFacts facts = new DashboardFacts();

            registryManager = RegistryManager.CreateFromConnectionString(connectionStringForPortal);
            List <Device> localDevices = new List <Device>();
            IEnumerable <Microsoft.Azure.Devices.Device> azureDevice = new List <Microsoft.Azure.Devices.Device>();// = registryManager.GetDevicesAsync(100);
            Task task = Task.Run(() => { azureDevice = registryManager.GetDevicesAsync(100).Result; });

            task.Wait();

            try
            {
                facts.TotalDevices = azureDevice.Count();
                foreach (var x in azureDevice)
                {
                    if (x.ConnectionState == DeviceConnectionState.Connected)
                    {
                        facts.ConnectedDevices++;
                    }
                    else
                    {
                        facts.OfflineDevices++;
                    }
                    facts.TotalCloudToDeviceMessages = x.CloudToDeviceMessageCount;
                }
                return(facts);
            }
            catch (DeviceAlreadyExistsException ex)
            {
                List <AzureException> exception = new List <AzureException>()
                {
                    new AzureException()
                    {
                        Exception = ex, Message = ex.Message
                    }
                };
                return(facts);
            }
        }
示例#21
0
        private static async Task RemoveDevicesAsync()
        {
            kRegistryManager = AZD.RegistryManager.CreateFromConnectionString(kIoTHubConnectionString);

            do
            {
                var devicesList = (await kRegistryManager.GetDevicesAsync(kRemoveMaxCount)).ToList();
                if (devicesList?.Count == 0)
                {
                    break;
                }

                try
                {
                    await kRegistryManager.RemoveDevices2Async(devicesList);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }while (true);
        }
        static void Main(string[] args)
        {
            // initialize the configM microservice client sdk
            _configM = new ConfigM {ApiUrl = ConfigurationManager.AppSettings["ConfigM"]};

            // lookup the manifest for the device microservice
            var deviceManifest = _configM.GetByName("DeviceM");

            // initialize the device registery microservice client SDK
            _registryM = new DeviceM {ApiUrl = deviceManifest.lineitems[LineitemsKey.AdminAPI]};

            // get a list of all devices from the registry
            _devices = _registryM.GetAll();

            // initialize the IoT Hub registration manager
            _registryManager = RegistryManager.CreateFromConnectionString(ConfigurationManager.AppSettings["IoTHubConnStr"]);

            // register each device with IoT Hub
            foreach (var device in _devices.list)
            {
                AddDeviceAsync(device).Wait();
            }
        }
示例#23
0
 public AzureSubscriptionService(string constr = "HostName=iotHub4jbagz366jxyq.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=ijus5i/Z0Pr0EFHFQuNcK4kpqI+34rPmgz+VbTHFZUw=")
 {
     this.connectionString = constr;
     registryManager       = RegistryManager.CreateFromConnectionString(connectionString);
 }
 public IotDeviceService(RegistryManager registryManager)
 {
     _registryManager = registryManager;
 }
示例#25
0
        static async Task<string> selfRegisterAndSetConnString(string DeviceId)
        {
            Task<string> deviceConnString = null;
            try
            {
                registryManager = RegistryManager.CreateFromConnectionString(iotHubConnString);
                Device newDevice = new Device(DeviceId);

                await registryManager.AddDeviceAsync(newDevice);
                newDevice = await registryManager.GetDeviceAsync(DeviceId);
                newDevice.Authentication.SymmetricKey.PrimaryKey = CryptoKeyGenerator.GenerateKey(32);
                newDevice.Authentication.SymmetricKey.SecondaryKey = CryptoKeyGenerator.GenerateKey(32);
                newDevice = await registryManager.UpdateDeviceAsync(newDevice);

                string deviceInfo = String.Format("ID={0}\nPrimaryKey={1}\nSecondaryKey={2}", newDevice.Id, newDevice.Authentication.SymmetricKey.PrimaryKey, newDevice.Authentication.SymmetricKey.SecondaryKey);
                deviceConnString = Task.FromResult(string.Format("HostName={0};DeviceId={1};SharedAccessKey={2}", iotHubName, newDevice.Id, newDevice.Authentication.SymmetricKey.PrimaryKey));

            }
            catch (Exception ex)
            {
                Console.WriteLine("An error occured creating device:{0}", ex.ToString());
            }
            return deviceConnString.Result;
        }
 public IoTDeviceManager(string iotHubConnectionString)
 {
     registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
 }
 public DevicesController()
 {
     _manager = RegistryManager.CreateFromConnectionString(ConfigurationManager.ConnectionStrings["IoTHub"].ConnectionString);
 }
 public IotHubService(IAppConfiguration configuration)
 {
     _registryManager = AzureDevices.RegistryManager.CreateFromConnectionString(configuration.IotHubConnectionString);
 }
        private static void Main(string[] args)
        {
            Console.WriteLine("Enter IoT Hub connection string: ");
            connectionString = Console.ReadLine();

            Console.WriteLine("Enter Service Fabric cluster address where your IoT project is deployed (or blank for local): ");
            clusterAddress = Console.ReadLine();

            registryManager = RegistryManager.CreateFromConnectionString(connectionString);
            fabricClient = String.IsNullOrEmpty(clusterAddress)
                ? new FabricClient()
                : new FabricClient(clusterAddress);

            Task.Run(
                async () =>
                {
                    while (true)
                    {
                        try
                        {
                            devices = await registryManager.GetDevicesAsync(Int32.MaxValue);
                            tenants = (await fabricClient.QueryManager.GetApplicationListAsync())
                                .Where(x => x.ApplicationTypeName == Names.TenantApplicationTypeName)
                                .Select(x => x.ApplicationName.ToString().Replace(Names.TenantApplicationNamePrefix + "/", ""));

                            Console.WriteLine();
                            Console.WriteLine("Devices IDs: ");
                            foreach (Device device in devices)
                            {
                                Console.WriteLine(device.Id);
                            }

                            Console.WriteLine();
                            Console.WriteLine("Tenants: ");
                            foreach (string tenant in tenants)
                            {
                                Console.WriteLine(tenant);
                            }

                            Console.WriteLine();
                            Console.WriteLine("Commands:");
                            Console.WriteLine("1: Register a device");
                            Console.WriteLine("2: Register random devices");
                            Console.WriteLine("3: Send data from a device");
                            Console.WriteLine("4: Send data from all devices");
                            Console.WriteLine("5: Exit");

                            string command = Console.ReadLine();

                            switch (command)
                            {
                                case "1":
                                    Console.WriteLine("Make up a device ID: ");
                                    string deviceId = Console.ReadLine();
                                    await AddDeviceAsync(deviceId);
                                    break;
                                case "2":
                                    Console.WriteLine("How many devices? ");
                                    int num = Int32.Parse(Console.ReadLine());
                                    await AddRandomDevicesAsync(num);
                                    break;
                                case "3":
                                    Console.WriteLine("Tenant: ");
                                    string tenant = Console.ReadLine();
                                    Console.WriteLine("Device id: ");
                                    string deviceKey = Console.ReadLine();
                                    await SendDeviceToCloudMessagesAsync(deviceKey, tenant);
                                    break;
                                case "4":
                                    Console.WriteLine("Tenant: ");
                                    string tenantName = Console.ReadLine();
                                    Console.WriteLine("Iterations: ");
                                    int iterations = Int32.Parse(Console.ReadLine());
                                    await SendAllDevices(tenantName, iterations);
                                    break;
                                case "5":
                                    return;
                                default:
                                    break;
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Oops, {0}", ex.Message);
                        }
                    }
                })
                .GetAwaiter().GetResult();
        }
 public AzureSubscriptionService()
 {
     this.connectionStringForPortal  = ConfigurationManager.AppSettings["AzureSubscriptionStr"];
     this.connectionStringForStorage = ConfigurationManager.AppSettings["AzureStorageStr"];
     registryManager = RegistryManager.CreateFromConnectionString(connectionStringForPortal);
 }
 private void EnsureRegistryManagerInitialized()
 {
     if (registryManager == null)
     {
         lock (SyncRoot)
         {
             if (registryManager == null)
             {
                 var settings = Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
                 string iotHubconnectionString = settings["IoTHubConnectionString"];
                 //ConfigurationManager.AppSettings["IoTHubConnectionString"];
                 registryManager = RegistryManager.CreateFromConnectionString(iotHubconnectionString);
             }
         }
     }
 }