def run_scenario_individual_enrollment():
psc = ProvisioningServiceClient.create_from_connection_string(PROVISIONING_CONNECTION_STRING)
att = AttestationMechanism.create_with_tpm(PROVISIONING_E2E_ENDORSEMENT_KEY)
ie = IndividualEnrollment(registration_id=REGISTRATION_ID, attestation=att)
#create
ret_ie = psc.create_or_update(ie)
assert ret_ie.registration_id == REGISTRATION_ID
#update
twin = InitialTwin.create(TAGS, DESIRED_PROPERTIES)
ret_ie.initial_twin = twin
capabilities = DeviceCapabilities.create(True)
ret_ie.capabilities = capabilities
ret_ie = psc.create_or_update(ret_ie)
assert ret_ie.registration_id == REGISTRATION_ID
assert ret_ie.initial_twin.tags == TAGS
assert ret_ie.initial_twin.desired_properties == DESIRED_PROPERTIES
assert ret_ie.capabilities.iot_edge == True
#get
ret_ie = psc.get_individual_enrollment(REGISTRATION_ID)
assert ret_ie.registration_id == REGISTRATION_ID
assert ret_ie.initial_twin.tags == TAGS
assert ret_ie.initial_twin.desired_properties == DESIRED_PROPERTIES
#get attestation mechanism
ret_am = psc.get_individual_enrollment_attestation_mechanism(REGISTRATION_ID)
assert ret_am.tpm.endorsement_key == PROVISIONING_E2E_ENDORSEMENT_KEY
#delete
psc.delete(ret_ie)
try:
ret_ie = psc.get_individual_enrollment(REGISTRATION_ID)
except ProvisioningServiceError:
pass
else:
raise AssertionError
#bulk enrollment
enrollments = []
for i in range(BULK_SIZE):
new = IndividualEnrollment(registration_id=REGISTRATION_ID + str(i), attestation=att)
enrollments.append(new)
bulk_op = BulkEnrollmentOperation(mode=BULKOP_CREATE, enrollments=enrollments)
res = psc.run_bulk_operation(bulk_op)
assert res.is_successful
#query
qs = QuerySpecification(query="*")
q = psc.create_individual_enrollment_query(qs)
q_results = q.next()
assert len(q_results) == BULK_SIZE
#cleanup
bulk_op = BulkEnrollmentOperation(mode=BULKOP_DELETE, enrollments=enrollments)
res = psc.run_bulk_operation(bulk_op)
assert res.is_successful
def run_scenario_individual_enrollment():
psc = ProvisioningServiceClient.create_from_connection_string(CONNECTION_STRING)
att = AttestationMechanism.create_with_tpm(ENDORSEMENT_KEY)
ie = IndividualEnrollment.create(REGISTRATION_ID, att)
#create
ret_ie = psc.create_or_update(ie)
assert ret_ie.registration_id == REGISTRATION_ID
#update
twin = InitialTwin.create(TAGS, DESIRED_PROPERTIES)
ret_ie.initial_twin = twin
ret_ie = psc.create_or_update(ret_ie)
assert ret_ie.registration_id == REGISTRATION_ID
assert ret_ie.initial_twin.tags == TAGS
assert ret_ie.initial_twin.desired_properties == DESIRED_PROPERTIES
#get
ret_ie = psc.get_individual_enrollment(REGISTRATION_ID)
assert ret_ie.registration_id == REGISTRATION_ID
assert ret_ie.initial_twin.tags == TAGS
assert ret_ie.initial_twin.desired_properties == DESIRED_PROPERTIES
#delete
psc.delete(ret_ie)
try:
ret_ie = psc.get_individual_enrollment(REGISTRATION_ID)
except ProvisioningServiceError:
pass
else:
raise AssertionError
#bulk enrollment
enrollments = []
for i in range(BULK_SIZE):
new = IndividualEnrollment.create(REGISTRATION_ID + str(i), att)
enrollments.append(new)
bulk_op = BulkEnrollmentOperation(CREATE, enrollments)
res = psc.run_bulk_operation(bulk_op)
assert res.is_successful
#query
qs = QuerySpecification("*")
q = psc.create_individual_enrollment_query(qs)
q_results = q.next()
assert len(q_results) == BULK_SIZE
#cleanup
bulk_op = BulkEnrollmentOperation(DELETE, enrollments)
res = psc.run_bulk_operation(bulk_op)
assert res.is_successful
def main():
connection_string = "[Connection String]"
endorsement_key = "[Endorsement Key]"
registration_id = "[Registration ID]"
#set up the provisioning service client
psc = ProvisioningServiceClient.create_from_connection_string(
connection_string)
#build IndividualEnrollment model
att = AttestationMechanism.create_with_tpm(endorsement_key)
ie = IndividualEnrollment.create(registration_id, att)
#create IndividualEnrollment on the Provisioning Service
ie = psc.create_or_update(ie)
six.print_(ie)
#get IndividualEnrollment from the Provisioning Service (note: this step is useless here, as ie is already up to date)
ie = psc.get_individual_enrollment(registration_id)
six.print_(ie)
#delete IndividualEnrollment from the Provisioning Service
psc.delete(ie)
#could also use psc.delete_individual_enrollment_by_param(ie.registration_id, ie.etag)
#bulk create IndividualEnrollments
enrollments = []
for i in range(5):
enrollments.append(
IndividualEnrollment.create(registration_id + str(i + 1), att))
bulk_op = BulkEnrollmentOperation("create", enrollments)
results = psc.run_bulk_operation(bulk_op)
six.print_(ie)
#make a Provisioning Service query
qs = QuerySpecification("*")
page_size = 2 #two results per page -> don't pass this parameter if you just want all of them at once
query = psc.create_individual_enrollment_query(qs, page_size)
results = []
for page in query:
results += page
#alternatively, call query.next() to get a new page
six.print_(results)
#delete the bulk created enrollments
bulk_op.mode = "delete"
psc.run_bulk_operation(bulk_op)
def setUp(self):
tpm_am = AttestationMechanism.create_with_tpm("my-ek")
self.ie = IndividualEnrollment.create("reg-id", tpm_am)
self.ret_ie = copy.deepcopy(self.ie._internal)
self.ret_ie.created_updated_time_utc = 1000
self.ret_ie.last_updated_time_utc = 1000
def test_ie_constructor_full_model(self):
tpm = genmodels.TpmAttestation(TEST_EK)
att = genmodels.AttestationMechanism(TPM_LABEL, tpm=tpm)
drs = genmodels.DeviceRegistrationState(TEST_REG_ID,
REG_STATUS_ASSIGNED)
twin = genmodels.InitialTwin()
capabilities = genmodels.DeviceCapabilities(False)
ie = genmodels.IndividualEnrollment(
TEST_REG_ID,
att,
capabilities=capabilities,
device_id=TEST_DEV_ID,
registration_state=drs,
iot_hub_host_name=TEST_HOST_NAME,
initial_twin=twin,
etag=TEST_ETAG,
provisioning_status=PROV_STATUS_ENABLED,
created_date_time_utc=TEST_TIME,
last_updated_date_time_utc=TEST_TIME2)
ret = IndividualEnrollment(ie)
self.assertIsInstance(ret, IndividualEnrollment)
self.assertIs(ret._internal, ie)
self.assertIsInstance(ret._att_wrapper, AttestationMechanism)
self.assertIs(ret._att_wrapper._internal, att)
self.assertIsInstance(ret._drs_wrapper, DeviceRegistrationState)
self.assertIs(ret._drs_wrapper._internal, drs)
self.assertIsInstance(ret._twin_wrapper, InitialTwin)
self.assertIs(ret._twin_wrapper._internal, twin)
self.assertIsInstance(ret._capabilities_wrapper, DeviceCapabilities)
self.assertIs(ret._capabilities_wrapper._internal, capabilities)
def setUp(self):
tpm_am = AttestationMechanism.create_with_tpm("my-ek")
self.ie = IndividualEnrollment.create("reg-id", tpm_am)
self.ret_ie = copy.deepcopy(self.ie._internal)
self.ret_ie.created_updated_time_utc = 1000
self.ret_ie.last_updated_time_utc = 1000
def get_individual_enrollment(self, registration_id):
"""
Retrieve an Individual Enrollment from the Provisioning Service
:param str registration_id: The registration id of the target Individual Enrollment
:returns: Individual Enrollment from the Provisioning Service corresponding to the given
registration id
:rtype: :class:`IndividualEnrollment<provisioningserviceclient.models.IndividualEnrollment>`
:raises: :class:ProvisioningServiceError
<provisioningserviceclient.ProvisioningServiceError>` if an error occurs on the
Provisioning Service
"""
custom_headers = {}
custom_headers[ProvisioningServiceClient.
authorization_header] = self._gen_sastoken_str()
try:
raw_resp = self._runtime_client.device_enrollment.get(
registration_id, custom_headers, True)
except genmodels.ProvisioningServiceErrorDetailsException as e:
raise ProvisioningServiceError(
self.err_msg_unexpected.format(e.response.status_code), e)
if not _is_successful(raw_resp.response.status_code):
raise ProvisioningServiceError(raw_resp.response.reason)
result = raw_resp.output
return IndividualEnrollment(result)
def setUp(self):
tpm = genmodels.TpmAttestation(TEST_EK)
self.gen_att = genmodels.AttestationMechanism(TPM_LABEL, tpm=tpm)
self.gen_drs = genmodels.DeviceRegistrationState(TEST_REG_ID, REG_STATUS_ASSIGNED)
self.gen_twin = genmodels.InitialTwin()
gen_ie = genmodels.IndividualEnrollment(TEST_REG_ID, self.gen_att, TEST_DEV_ID, self.gen_drs, \
TEST_HOST_NAME, self.gen_twin, TEST_ETAG, PROV_STATUS_ENABLED, TEST_TIME, TEST_TIME2)
self.ie = IndividualEnrollment(gen_ie)
def test_ie_constructor_min_model(self):
tpm = genmodels.TpmAttestation(TEST_EK)
att = genmodels.AttestationMechanism(TPM_LABEL, tpm=tpm)
ie = genmodels.IndividualEnrollment(TEST_REG_ID, att)
ret = IndividualEnrollment(ie)
self.assertIsInstance(ret, IndividualEnrollment)
self.assertIs(ret._internal, ie)
self.assertIsInstance(ret._att_wrapper, AttestationMechanism)
self.assertIs(ret._att_wrapper._internal, att)
self.assertIsNone(ret._drs_wrapper)
self.assertIsNone(ret._twin_wrapper)
def test_copy_and_unwrap_bulkop(self):
enrollments = []
for i in range(5):
att = AttestationMechanism.create_with_tpm("test-ek")
enrollments.append(IndividualEnrollment.create("reg-id" + str(i), att))
bulkop = BulkEnrollmentOperation("create", enrollments)
res = _copy_and_unwrap_bulkop(bulkop)
for i in range(len(res.enrollments)):
self.assertIs(res.enrollments[i], bulkop.enrollments[i]._internal)
def test_copy_and_unwrap_bulkop(self):
enrollments = []
for i in range(5):
att = AttestationMechanism.create_with_tpm("test-ek")
enrollments.append(
IndividualEnrollment.create("reg-id" + str(i), att))
bulkop = BulkEnrollmentOperation("create", enrollments)
res = _copy_and_unwrap_bulkop(bulkop)
for i in range(len(res.enrollments)):
self.assertIs(res.enrollments[i], bulkop.enrollments[i]._internal)
def setUp(self):
enrollments = []
for i in range(5):
att = AttestationMechanism.create_with_tpm("test-ek")
enrollments.append(IndividualEnrollment.create("reg-id" + str(i), att))
self.bulkop = BulkEnrollmentOperation("create", enrollments)
internal = []
for enrollment in self.bulkop.enrollments:
internal.append(enrollment._internal)
self.internal_bulkop = BulkEnrollmentOperation("create", internal)
self.bulkop_resp = BulkEnrollmentOperationResult(True)
def setUp(self):
enrollments = []
for i in range(5):
att = AttestationMechanism.create_with_tpm("test-ek")
enrollments.append(
IndividualEnrollment.create("reg-id" + str(i), att))
self.bulkop = BulkEnrollmentOperation("create", enrollments)
internal = []
for enrollment in self.bulkop.enrollments:
internal.append(enrollment._internal)
self.internal_bulkop = BulkEnrollmentOperation("create", internal)
self.bulkop_resp = BulkEnrollmentOperationResult(True)
def test_ie_constructor_full_model(self):
tpm = genmodels.TpmAttestation(TEST_EK)
att = genmodels.AttestationMechanism(TPM_LABEL, tpm=tpm)
drs = genmodels.DeviceRegistrationState(TEST_REG_ID, REG_STATUS_ASSIGNED)
twin = genmodels.InitialTwin()
ie = genmodels.IndividualEnrollment(TEST_REG_ID, att, TEST_DEV_ID, drs, TEST_HOST_NAME,
twin, TEST_ETAG, REG_STATUS_ASSIGNED, TEST_TIME, TEST_TIME2)
ret = IndividualEnrollment(ie)
self.assertIsInstance(ret, IndividualEnrollment)
self.assertIs(ret._internal, ie)
self.assertIsInstance(ret._att_wrapper, AttestationMechanism)
self.assertIs(ret._att_wrapper._internal, att)
self.assertIsInstance(ret._drs_wrapper, DeviceRegistrationState)
self.assertIs(ret._drs_wrapper._internal, drs)
self.assertIsInstance(ret._twin_wrapper, InitialTwin)
self.assertIs(ret._twin_wrapper._internal, twin)
def setUp(self):
enrollments = []
for i in range(5):
att = AttestationMechanism.create_with_tpm("test-ek")
tags_tc = TwinCollection(additional_properties=TAGS)
desired_properties_tc = TwinCollection(
additional_properties=DESIRED_PROPERTIES)
properties = InitialTwinProperties(desired=desired_properties_tc)
twin = genmodels.InitialTwin(tags=tags_tc, properties=properties)
twin_wrapper = InitialTwin._create_from_internal(twin)
enrollments.append(
IndividualEnrollment.create("reg-id" + str(i),
att,
initial_twin=twin_wrapper))
self.bulkop = BulkEnrollmentOperation("create", enrollments)
self.bulkop_resp = BulkEnrollmentOperationResult(is_successful=True)
def setUp(self):
self.am = AttestationMechanism.create_with_tpm("my-ek")
tags_tc = TwinCollection(additional_properties=TAGS)
desired_properties_tc = TwinCollection(
additional_properties=DESIRED_PROPERTIES)
properties = InitialTwinProperties(desired=desired_properties_tc)
twin = genmodels.InitialTwin(tags=tags_tc, properties=properties)
self.ie = IndividualEnrollment.create("reg-id",
self.am,
initial_twin=twin)
self.ret_ie = copy.deepcopy(self.ie)
self.ret_ie.created_updated_time_utc = 1000
self.ret_ie.last_updated_time_utc = 1000
twin_wrapper = InitialTwin._create_from_internal(self.ie.initial_twin)
self.ie.initial_twin = twin_wrapper
def test_ie_create_min_model(self):
att = AttestationMechanism.create_with_tpm(TEST_EK)
ret = IndividualEnrollment.create(TEST_REG_ID, att)
internal = ret._internal
self.assertIsInstance(ret, IndividualEnrollment)
self.assertEqual(internal.registration_id, TEST_REG_ID)
self.assertIsNone(internal.device_id)
self.assertIsNone(internal.iot_hub_host_name)
self.assertIsNone(internal.provisioning_status)
self.assertEqual(internal.attestation, att._internal)
self.assertIs(ret._att_wrapper, att)
self.assertIsNone(internal.initial_twin)
self.assertIsNone(ret._twin_wrapper)
self.assertIsNone(internal.registration_state)
self.assertIsNone(ret._drs_wrapper)
self.assertIsNone(internal.etag)
self.assertIsNone(internal.created_date_time_utc)
self.assertIsNone(internal.last_updated_date_time_utc)
def test_ie_create_full_model(self):
att = AttestationMechanism.create_with_tpm(TEST_EK)
ts = InitialTwin.create()
ret = IndividualEnrollment.create(TEST_REG_ID, att, TEST_DEV_ID, TEST_HOST_NAME, ts, \
PROV_STATUS_ENABLED)
internal = ret._internal
self.assertIsInstance(ret, IndividualEnrollment)
self.assertEqual(internal.registration_id, TEST_REG_ID)
self.assertEqual(internal.device_id, TEST_DEV_ID)
self.assertEqual(internal.iot_hub_host_name, TEST_HOST_NAME)
self.assertEqual(internal.provisioning_status, PROV_STATUS_ENABLED)
self.assertEqual(internal.attestation, att._internal)
self.assertIs(ret._att_wrapper, att)
self.assertEqual(internal.initial_twin, ts._internal)
self.assertIs(ret._twin_wrapper, ts)
self.assertIsNone(internal.registration_state)
self.assertIsNone(ret._drs_wrapper)
self.assertIsNone(internal.etag)
self.assertIsNone(internal.created_date_time_utc)
self.assertIsNone(internal.last_updated_date_time_utc)
from provisioningserviceclient import ProvisioningServiceClient, QuerySpecification, \
BulkEnrollmentOperation
from provisioningserviceclient.models import IndividualEnrollment, AttestationMechanism
if __name__ == '__main__':
connection_string = "[Connection String]"
endorsement_key = "[Endorsement Key]"
registration_id = "[Registration ID]"
#set up the provisioning service client
psc = ProvisioningServiceClient.create_from_connection_string(connection_string)
#build IndividualEnrollment model
att = AttestationMechanism.create_with_tpm(endorsement_key)
ie = IndividualEnrollment.create(registration_id, att)
#create IndividualEnrollment on the Provisioning Service
ie = psc.create_or_update(ie)
six._print(ie)
#get IndividualEnrollment from the Provisioning Service (note: this step is useless here, as ie is already up to date)
ie = psc.get_individual_enrollment(registration_id)
six._print(ie)
#delete IndividualEnrollment from the Provisioning Service
psc.delete(ie)
#could also use psc.delete_individual_enrollment_by_param(ie.registration_id, ie.etag)
#bulk create IndividualEnrollments
enrollments = []
