From b04f5c2dc363f4472fe330d205165bac6daa0006 Mon Sep 17 00:00:00 2001 From: wyllys Date: Thu, 4 Sep 2014 14:42:20 -0400 Subject: [PATCH 1/9] Added support for LOCATE operation --- kmip/core/enums.py | 10 +++ kmip/core/messages/operations.py | 119 ++++++++++++++++++++++++++++++- kmip/core/repo/mem_repo.py | 7 ++ kmip/core/server.py | 17 +++++ kmip/demos/locate.py | 78 ++++++++++++++++++++ kmip/services/kmip_client.py | 55 ++++++++++++++ kmip/services/processor.py | 22 ++++++ kmip/services/results.py | 13 ++++ kmip/tests/core/test_server.py | 21 +++++- 9 files changed, 339 insertions(+), 3 deletions(-) create mode 100644 kmip/demos/locate.py mode change 100755 => 100644 kmip/services/processor.py diff --git a/kmip/core/enums.py b/kmip/core/enums.py index e29df2f..c481f65 100644 --- a/kmip/core/enums.py +++ b/kmip/core/enums.py @@ -559,3 +559,13 @@ class CryptographicUsageMask(Enum): TRANSLATE_DECRYPT = 0x00020000 TRANSLATE_WRAP = 0x00040000 TRANSLATE_UNWRAP = 0x00080000 + +# 9.1.3.2.33 +class ObjectGroupMember(Enum): + GROUP_MEMBER_FRESH = 0x00000001 + GROUP_MEMBER_DEFAULT = 0x00000002 + +# 9.1.3.3.2 +class StorageStatusMask(Enum): + ONLINE_STORAGE = 0x00000001 + ARCHIVAL_STORAGE = 0x00000002 diff --git a/kmip/core/messages/operations.py b/kmip/core/messages/operations.py index 3cf89e2..a129f5c 100644 --- a/kmip/core/messages/operations.py +++ b/kmip/core/messages/operations.py @@ -24,6 +24,7 @@ from kmip.core.objects import TemplateAttribute from kmip.core.primitives import Struct from kmip.core.primitives import Enumeration +from kmip.core.primitives import Integer from kmip.core.utils import BytearrayStream @@ -429,11 +430,125 @@ class DestroyResponsePayload(Struct): pass +class LocateRequestPayload(Struct): + + # 9.1.3.2.33 + class ObjectGroupMember(Enumeration): + ENUM_TYPE = enums.ObjectGroupMember + + def __init__(self, value=None): + super(self.__class__, self).__init__(value, + Tags.OBJECT_GROUP_MEMBER) + + class MaximumItems(Integer): + def __init__(self, value=None): + super(self.__class__, self).__init__(value, + Tags.MAXIMUM_ITEMS) + + # 9.1.3.3.2 + class StorageStatusMask(Enumeration): + ENUM_TYPE = enums.StorageStatusMask + + def __init__(self, value=None): + super(self.__class__, self).__init__(value, + Tags.STORAGE_STATUS_MASK) + + def __init__(self, maximum_items=None, storage_status_mask=None, + object_group_member=None, attributes=None): + super(self.__class__, self).__init__(enums.Tags.REQUEST_PAYLOAD) + self.maximum_items = maximum_items + self.storage_status_mask = storage_status_mask + self.object_group_member = object_group_member + self.attributes = attributes or [] + self.validate() + + def read(self, istream): + super(self.__class__, self).read(istream) + tstream = BytearrayStream(istream.read(self.length)) + if self.is_tag_next(Tags.MAXIMUM_ITEMS, tstream): + self.maximum_items = LocateRequestPayload.MaximumItems() + self.maximum_items.read() + if self.is_tag_next(Tags.STORAGE_STATUS_MASK, tstream): + self.storage_status_mask = LocateRequestPayload.StorageStatusMask() + self.storage_status_mask.read() + if self.is_tag_next(Tags.OBJECT_GROUP_MEMBER, tstream): + self.object_group_member = LocateRequestPayload.ObjectGroupMember() + self.object_group_member.read(tstream) + while self.is_tag_next(Tags.TEMPLATE_ATTRIBUTE, tstream): + attr = TemplateAttribute() + attr.read(tstream) + self.attributes.append(attr) + + self.validate() + + def write(self, ostream): + tstream = BytearrayStream() + if self.maximum_items is not None: + self.maximum_items.write(tstream) + if self.storage_status_mask is not None: + self.storage_status_mask.write(tstream) + if self.attributes is not None: + for a in self.attributes: + a.write(tstream) + + # Write the length and value of the request payload + self.length = tstream.length() + super(self.__class__, self).write(ostream) + ostream.write(tstream.buffer) + + def validate(self): + self._validate() + + def _validate(self): + # TODO Finish implementation. + pass + + +class LocateResponsePayload(Struct): + + def __init__(self, unique_identifiers=[]): + super(self.__class__, self).__init__(enums.Tags.RESPONSE_PAYLOAD) + self.unique_identifiers = unique_identifiers or [] + self.validate() + + def read(self, istream): + super(self.__class__, self).read(istream) + tstream = BytearrayStream(istream.read(self.length)) + + while self.is_tag_next(Tags.UNIQUE_IDENTIFIER, tstream): + ui = attributes.UniqueIdentifier() + ui.read(tstream) + self.unique_identifiers.append(ui) + + self.is_oversized(tstream) + self.validate() + + def write(self, ostream): + tstream = BytearrayStream() + + for ui in self.unique_identifier: + ui.write(tstream) + + # Write the length and value of the request payload + self.length = tstream.length() + super(self.__class__, self).write(ostream) + ostream.write(tstream.buffer) + + def validate(self): + self.__validate() + + def __validate(self): + # TODO (peter-hamilton) Finish implementation. + pass + + REQUEST_MAP = {enums.Operation.CREATE: CreateRequestPayload, enums.Operation.GET: GetRequestPayload, enums.Operation.DESTROY: DestroyRequestPayload, - enums.Operation.REGISTER: RegisterRequestPayload} + enums.Operation.REGISTER: RegisterRequestPayload, + enums.Operation.LOCATE: LocateRequestPayload} RESPONSE_MAP = {enums.Operation.CREATE: CreateResponsePayload, enums.Operation.GET: GetResponsePayload, + enums.Operation.REGISTER: RegisterResponsePayload, enums.Operation.DESTROY: DestroyResponsePayload, - enums.Operation.REGISTER: RegisterResponsePayload} + enums.Operation.LOCATE: LocateResponsePayload} diff --git a/kmip/core/repo/mem_repo.py b/kmip/core/repo/mem_repo.py index 8726f38..6d29e6a 100644 --- a/kmip/core/repo/mem_repo.py +++ b/kmip/core/repo/mem_repo.py @@ -45,3 +45,10 @@ class MemRepo(ManagedObjectRepo): return False del self.repo[uuid] return True + + def locate(self, maximum_items, storage_status_mask, + object_group_member, attributes): + # TODO - search objects, find one with matching attrs + if "1" in self.repo: + return [self.repo["1"]] + return None diff --git a/kmip/core/server.py b/kmip/core/server.py index 26b6e2d..1fa847e 100644 --- a/kmip/core/server.py +++ b/kmip/core/server.py @@ -47,6 +47,7 @@ from kmip.services.results import DestroyResult from kmip.services.results import GetResult from kmip.services.results import OperationResult from kmip.services.results import RegisterResult +from kmip.services.results import LocateResult class KMIP(object): @@ -68,6 +69,11 @@ class KMIP(object): def destroy(self, uuid, credential=None): raise NotImplementedError + def locate(self, maximum_items=None, storate_status_mask=None, + object_group_member=None, attributes=None, + credential=None): + raise NotImplementedError + class KMIPImpl(KMIP): @@ -248,6 +254,17 @@ class KMIPImpl(KMIP): ret_value = RS.SUCCESS return DestroyResult(ResultStatus(ret_value), uuid=uuid) + def locate(self, maximum_items=None, storage_status_mask=None, + object_group_member=None, attributes=None, + credential=None): + self.logger.debug('locate() called') + msg = 'locating object(s) from repo' + self.logger.debug(msg) + uuids = self.repo.locate(maximum_items, storage_status_mask, + object_group_member, attributes) + return LocateResult(ResultStatus(RS.SUCCESS), + locate_uuids=uuids) + def _validate_req_field(self, attrs, name, expected, msg, required=True): self.logger.debug('Validating attribute %s' % name) seen = False diff --git a/kmip/demos/locate.py b/kmip/demos/locate.py new file mode 100644 index 0000000..f8376e9 --- /dev/null +++ b/kmip/demos/locate.py @@ -0,0 +1,78 @@ +# Copyright (c) 2014 The Johns Hopkins University/Applied Physics Laboratory +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from kmip.core.enums import AttributeType +from kmip.core.enums import CredentialType +from kmip.core.enums import ObjectType +from kmip.core.enums import CryptographicAlgorithm +from kmip.core.enums import CryptographicUsageMask +from kmip.core.enums import NameType + +from kmip.core.attributes import Name + +from kmip.core.factories.attributes import AttributeFactory +from kmip.core.factories.credentials import CredentialFactory + +from kmip.core.objects import TemplateAttribute, Attribute + +from kmip.services.kmip_client import KMIPProxy + +import logging +import os + +if __name__ == '__main__': + f_log = os.path.join(os.path.dirname(__file__), '..', 'logconfig.ini') + logging.config.fileConfig(f_log) + logger = logging.getLogger(__name__) + + attribute_factory = AttributeFactory() + credential_factory = CredentialFactory() + + credential_type = CredentialType.USERNAME_AND_PASSWORD + credential_value = {'Username': 'Peter', 'Password': 'abc123'} + credential = credential_factory.create_credential(credential_type, + credential_value) + client = KMIPProxy() + client.open() + + object_type = ObjectType.SYMMETRIC_KEY + attribute_type = AttributeType.CRYPTOGRAPHIC_ALGORITHM + algorithm = attribute_factory.create_attribute(attribute_type, + CryptographicAlgorithm.AES) + mask_flags = [CryptographicUsageMask.ENCRYPT, + CryptographicUsageMask.DECRYPT] + attribute_type = AttributeType.CRYPTOGRAPHIC_USAGE_MASK + usage_mask = attribute_factory.create_attribute(attribute_type, + mask_flags) + name = Attribute.AttributeName('Name') + name_value = Name.NameValue('FOOBAR') + name_type = Name.NameType(NameType.UNINTERPRETED_TEXT_STRING) + value = Name(name_value=name_value, name_type=name_type) + nameattr = Attribute(attribute_name=name, attribute_value=value) + + attributes = [algorithm, usage_mask, nameattr] + + template_attribute = TemplateAttribute(attributes=attributes) + + result = client.create(object_type, template_attribute, + credential) + + attrs = [nameattr] + result = client.locate(attributes=attrs, credential=credential) + client.close() + + logger.debug('get() result status: {}'.format(result.result_status.enum)) + logger.debug('retrieved object type: {}'.format(result.object_type.enum)) + logger.debug('Located UUID: {}'.format(result.locate_uuids)) diff --git a/kmip/services/kmip_client.py b/kmip/services/kmip_client.py index 9cbb200..6c4d9aa 100644 --- a/kmip/services/kmip_client.py +++ b/kmip/services/kmip_client.py @@ -17,6 +17,7 @@ from kmip.services.results import CreateResult from kmip.services.results import GetResult from kmip.services.results import DestroyResult from kmip.services.results import RegisterResult +from kmip.services.results import LocateResult from kmip.core import attributes as attr @@ -93,6 +94,13 @@ class KMIPProxy(KMIP): secret=secret, credential=credential) + def locate(self, maximum_items=None, storage_status_mask=None, + object_group_member=None, attributes=None, credential=None): + return self._locate(maximum_items=maximum_items, + storage_status_mask=storage_status_mask, + object_group_member=object_group_member, + attributes=attributes, credential=credential) + def _create(self, object_type=None, template_attribute=None, @@ -263,6 +271,53 @@ class KMIPProxy(KMIP): payload_template_attribute) return result + def _locate(self, maximum_items=None, storage_status_mask=None, + object_group_member=None, attributes=[], credential=None): + + operation = Operation(OperationEnum.LOCATE) + + mxi = None + ssmask = None + objgrp = None + + if maximum_items is not None: + mxi = operations.LocateRequestPayload.MaximumItems(maximum_items) + if storage_status_mask is not None: + m = storage_status_mask + ssmask = operations.LocateRequestPayload.StorageStatusMask(m) + if object_group_member is not None: + o = object_group_member + objgrp = operations.LocateRequestPayload.ObjectGroupMember(o) + + payload = operations.LocateRequestPayload(maximum_items=mxi, + storage_status_mask=ssmask, + object_group_member=objgrp, + attributes=attributes) + + batch_item = messages.RequestBatchItem(operation=operation, + request_payload=payload) + + message = self._build_request_message(credential, [batch_item]) + self._send_message(message) + message = messages.ResponseMessage() + data = self._receive_message() + + message.read(data) + batch_items = message.batch_items + batch_item = batch_items[0] + payload = batch_item.response_payload + + if payload is None: + locate_uuids = None + else: + locate_uuids = payload.unique_identifiers + + result = LocateResult(batch_item.result_status, + batch_item.result_reason, + batch_item.result_message, + locate_uuids) + return result + def _build_request_message(self, credential, batch_items): protocol_version = ProtocolVersion.create(1, 1) diff --git a/kmip/services/processor.py b/kmip/services/processor.py old mode 100755 new mode 100644 index 8d2ed6b..bbdea42 --- a/kmip/services/processor.py +++ b/kmip/services/processor.py @@ -31,6 +31,7 @@ from kmip.core.messages.operations import CreateResponsePayload from kmip.core.messages.operations import GetResponsePayload from kmip.core.messages.operations import DestroyResponsePayload from kmip.core.messages.operations import RegisterResponsePayload +from kmip.core.messages.operations import LocateResponsePayload from kmip.core.enums import Operation from kmip.core.enums import ResultStatus as RS @@ -168,6 +169,8 @@ class Processor(object): return self._process_destroy_request(payload) elif op is Operation.REGISTER: return self._process_register_request(payload) + elif op is Operation.LOCATE: + return self._process_locate_request(payload) else: raise NotImplementedError() @@ -252,3 +255,22 @@ class Processor(object): template_attribute=template_attr) return (result_status, result_reason, result_message, resp_pl) + + def _process_locate_request(self, payload): + max_items = payload.maximum_items + storage_mask = payload.status_storage_mask + objgrp_member = payload.object_group_member + attributes = payload.attributes + + result = self._handler.locate(max_items, storage_mask, + objgrp_member, attributes) + + result_status = result.result_status + result_reason = result.result_reason + result_message = result.result_message + + uuids = result.locate_uuids + + resp_pl = LocateResponsePayload(unique_identifiers=uuids) + + return (result_status, result_reason, result_message, resp_pl) diff --git a/kmip/services/results.py b/kmip/services/results.py index 2ee6134..efa4b1d 100644 --- a/kmip/services/results.py +++ b/kmip/services/results.py @@ -125,3 +125,16 @@ class DestroyResult(OperationResult): self.uuid = uuid else: self.uuid = None + + +class LocateResult(OperationResult): + + def __init__(self, + result_status, + result_reason=None, + result_message=None, + locate_uuids=None): + super(self.__class__, self).__init__(result_status, + result_reason, + result_message) + self.locate_uuids = locate_uuids diff --git a/kmip/tests/core/test_server.py b/kmip/tests/core/test_server.py index 7a1ad46..c4dd248 100644 --- a/kmip/tests/core/test_server.py +++ b/kmip/tests/core/test_server.py @@ -20,6 +20,7 @@ from kmip.core.attributes import CryptographicLength from kmip.core.attributes import CryptographicUsageMask from kmip.core.attributes import UniqueIdentifier from kmip.core.attributes import ObjectType +from kmip.core.attributes import Name from kmip.core.enums import AttributeType from kmip.core.enums import CryptographicAlgorithm as CryptoAlgorithmEnum from kmip.core.enums import CryptographicUsageMask as CryptoUsageMaskEnum @@ -28,6 +29,7 @@ from kmip.core.enums import KeyFormatType as KeyFormatTypeEnum from kmip.core.enums import ObjectType as ObjectTypeEnum from kmip.core.enums import ResultReason from kmip.core.enums import ResultStatus +from kmip.core.enums import NameType from kmip.core.factories.attributes import AttributeFactory from kmip.core.keys import RawKey from kmip.core.messages.contents import KeyCompressionType @@ -35,6 +37,7 @@ from kmip.core.messages.contents import KeyFormatType from kmip.core.objects import KeyBlock from kmip.core.objects import KeyValueStruct from kmip.core.objects import TemplateAttribute +from kmip.core.objects import Attribute from kmip.core.secrets import SymmetricKey from kmip.core.server import KMIPImpl @@ -474,6 +477,14 @@ class TestKMIPServer(TestCase): crypto_length, usage) return SymmetricKey(key_block) + def _make_nameattr(self): + name = Attribute.AttributeName('Name') + name_value = Name.NameValue('TESTNAME') + name_type = Name.NameType(NameType.UNINTERPRETED_TEXT_STRING) + value = Name(name_value=name_value, name_type=name_type) + nameattr = Attribute(attribute_name=name, attribute_value=value) + return nameattr + def _get_attrs(self): attr_factory = AttributeFactory() algorithm = self._get_alg_attr(self.algorithm_name) @@ -483,7 +494,8 @@ class TestKMIPServer(TestCase): CryptoUsageMaskEnum.DECRYPT] usage_mask = attr_factory.create_attribute(attribute_type, mask_flags) - return [algorithm, usage_mask, length] + nameattr = self._make_nameattr() + return [algorithm, usage_mask, length, nameattr] def _get_alg_attr(self, alg=None): if alg is None: @@ -506,3 +518,10 @@ class TestKMIPServer(TestCase): return attribute.attribute_value.value ==\ attr_expected.attribute_value.value return False + + def test_locate(self): + self._create() + attrs = [self._make_nameattr()] + res = self.kmip.locate(attributes=attrs) + self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + 'locate result status did not return success') From a2b71a1f1c076a2702ec90887e96e0d2fba47abf Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Tue, 9 Sep 2014 00:14:02 -0400 Subject: [PATCH 2/9] Updated to address comments from first attempt --- kmip/core/attributes.py | 14 +- kmip/core/factories/attribute_values.py | 7 +- kmip/core/messages/operations.py | 7 +- kmip/core/server.py | 3 +- kmip/demos/locate.py | 11 +- kmip/services/kmip_client.py | 6 +- kmip/services/processor.py | 2 +- kmip/services/results.py | 4 +- kmip/tests/core/messages/test_messages.py | 212 +++++++++++++++++++++- kmip/tests/core/test_server.py | 24 +-- 10 files changed, 258 insertions(+), 32 deletions(-) diff --git a/kmip/core/attributes.py b/kmip/core/attributes.py index 4b4e8d1..41c067c 100644 --- a/kmip/core/attributes.py +++ b/kmip/core/attributes.py @@ -25,6 +25,7 @@ from kmip.core.primitives import Enumeration from kmip.core.primitives import TextString from kmip.core.utils import BytearrayStream +from enum import Enum # 3.1 @@ -54,6 +55,7 @@ class Name(Struct): super(self.__class__, self).__init__(tag=Tags.NAME) self.name_value = name_value self.name_type = name_type + self.validate() def read(self, istream): super(self.__class__, self).read(istream) @@ -88,8 +90,16 @@ class Name(Struct): @classmethod def create(cls, name_value, name_type): - value = cls.NameValue(name_value) - n_type = cls.NameType(name_type) + if isinstance(name_value, Name.NameValue): + value = name_value + elif isinstance(name_value, str): + value = cls.NameValue(name_value) + + if isinstance(name_type, Name.NameType): + n_type = name_type + elif isinstance(name_type, Enum): + n_type = cls.NameType(name_type) + return Name(name_value=value, name_type=n_type) diff --git a/kmip/core/factories/attribute_values.py b/kmip/core/factories/attribute_values.py index d0ab783..1136762 100644 --- a/kmip/core/factories/attribute_values.py +++ b/kmip/core/factories/attribute_values.py @@ -24,6 +24,7 @@ from kmip.core.attributes import CustomAttribute from kmip.core.attributes import Name from kmip.core.attributes import ObjectGroup from kmip.core.attributes import UniqueIdentifier +from kmip.core.attributes import ObjectType from kmip.core import utils @@ -125,15 +126,15 @@ class AttributeValueFactory(object): def _create_name(self, name): if name is not None: - name_value = name.get('name_value') - name_type = name.get('name_type') + name_value = name.name_value + name_type = name.name_type return Name.create(name_value, name_type) else: return Name() def _create_object_type(self, obj): - raise NotImplementedError() + return ObjectType() def _create_cryptographic_algorithm(self, alg): return CryptographicAlgorithm(alg) diff --git a/kmip/core/messages/operations.py b/kmip/core/messages/operations.py index a129f5c..974ce17 100644 --- a/kmip/core/messages/operations.py +++ b/kmip/core/messages/operations.py @@ -21,6 +21,7 @@ from kmip.core.enums import Tags from kmip.core.objects import KeyWrappingSpecification from kmip.core.objects import TemplateAttribute +from kmip.core.objects import Attribute from kmip.core.primitives import Struct from kmip.core.primitives import Enumeration @@ -474,8 +475,8 @@ class LocateRequestPayload(Struct): if self.is_tag_next(Tags.OBJECT_GROUP_MEMBER, tstream): self.object_group_member = LocateRequestPayload.ObjectGroupMember() self.object_group_member.read(tstream) - while self.is_tag_next(Tags.TEMPLATE_ATTRIBUTE, tstream): - attr = TemplateAttribute() + while self.is_tag_next(Tags.ATTRIBUTE, tstream): + attr = Attribute() attr.read(tstream) self.attributes.append(attr) @@ -526,7 +527,7 @@ class LocateResponsePayload(Struct): def write(self, ostream): tstream = BytearrayStream() - for ui in self.unique_identifier: + for ui in self.unique_identifiers: ui.write(tstream) # Write the length and value of the request payload diff --git a/kmip/core/server.py b/kmip/core/server.py index 1fa847e..6e9478f 100644 --- a/kmip/core/server.py +++ b/kmip/core/server.py @@ -262,8 +262,7 @@ class KMIPImpl(KMIP): self.logger.debug(msg) uuids = self.repo.locate(maximum_items, storage_status_mask, object_group_member, attributes) - return LocateResult(ResultStatus(RS.SUCCESS), - locate_uuids=uuids) + return LocateResult(ResultStatus(RS.SUCCESS), uuids=uuids) def _validate_req_field(self, attrs, name, expected, msg, required=True): self.logger.debug('Validating attribute %s' % name) diff --git a/kmip/demos/locate.py b/kmip/demos/locate.py index f8376e9..4bf72cb 100644 --- a/kmip/demos/locate.py +++ b/kmip/demos/locate.py @@ -16,6 +16,7 @@ from kmip.core.enums import AttributeType from kmip.core.enums import CredentialType from kmip.core.enums import ObjectType +from kmip.core.enums import ResultStatus from kmip.core.enums import CryptographicAlgorithm from kmip.core.enums import CryptographicUsageMask from kmip.core.enums import NameType @@ -73,6 +74,10 @@ if __name__ == '__main__': result = client.locate(attributes=attrs, credential=credential) client.close() - logger.debug('get() result status: {}'.format(result.result_status.enum)) - logger.debug('retrieved object type: {}'.format(result.object_type.enum)) - logger.debug('Located UUID: {}'.format(result.locate_uuids)) + logger.debug('locate() result status: {}'. + format(result.result_status.enum)) + if result.result_status.enum == ResultStatus.SUCCESS: + logger.debug('retrieved object type: {}'. + format(result.object_type.enum)) + logger.debug('Located UUIDs: {}'.format(','.join([u.value for u in + result.uuids]))) diff --git a/kmip/services/kmip_client.py b/kmip/services/kmip_client.py index 6c4d9aa..b075628 100644 --- a/kmip/services/kmip_client.py +++ b/kmip/services/kmip_client.py @@ -308,14 +308,14 @@ class KMIPProxy(KMIP): payload = batch_item.response_payload if payload is None: - locate_uuids = None + uuids = None else: - locate_uuids = payload.unique_identifiers + uuids = payload.unique_identifiers result = LocateResult(batch_item.result_status, batch_item.result_reason, batch_item.result_message, - locate_uuids) + uuids) return result def _build_request_message(self, credential, batch_items): diff --git a/kmip/services/processor.py b/kmip/services/processor.py index bbdea42..8601a2e 100644 --- a/kmip/services/processor.py +++ b/kmip/services/processor.py @@ -269,7 +269,7 @@ class Processor(object): result_reason = result.result_reason result_message = result.result_message - uuids = result.locate_uuids + uuids = result.uuids resp_pl = LocateResponsePayload(unique_identifiers=uuids) diff --git a/kmip/services/results.py b/kmip/services/results.py index efa4b1d..e77d836 100644 --- a/kmip/services/results.py +++ b/kmip/services/results.py @@ -133,8 +133,8 @@ class LocateResult(OperationResult): result_status, result_reason=None, result_message=None, - locate_uuids=None): + uuids=None): super(self.__class__, self).__init__(result_status, result_reason, result_message) - self.locate_uuids = locate_uuids + self.uuids = uuids diff --git a/kmip/tests/core/messages/test_messages.py b/kmip/tests/core/messages/test_messages.py index a2452c1..720d88c 100644 --- a/kmip/tests/core/messages/test_messages.py +++ b/kmip/tests/core/messages/test_messages.py @@ -47,6 +47,7 @@ from kmip.core.messages.operations import DestroyRequestPayload from kmip.core.messages.operations import RegisterRequestPayload from kmip.core.messages.operations import DestroyResponsePayload from kmip.core.messages.operations import RegisterResponsePayload +from kmip.core.messages.operations import LocateResponsePayload from kmip.core.primitives import TextString @@ -135,8 +136,23 @@ class TestRequestMessage(TestCase): b'\x42\x00\x5C\x05\x00\x00\x00\x04\x00\x00\x00\x14\x00\x00\x00\x00' b'\x42\x00\x79\x01\x00\x00\x00\x30\x42\x00\x94\x07\x00\x00\x00\x24' b'\x66\x62\x34\x62\x35\x62\x39\x63\x2D\x36\x31\x38\x38\x2D\x34\x63' - b'\x36\x33\x2D\x38\x31\x34\x32\x2D\x66\x65\x39\x63\x33\x32\x38\x31' - b'\x32\x39\x66\x63\x00\x00\x00\x00') + ) + # kmip-testcases-v1.1 section 3.1.3 + self.locate = ( + b'\x42\x00\x78\x01\x00\x00\x00\xd0\x42\x00\x77\x01\x00\x00\x00\x38' + b'\x42\x00\x69\x01\x00\x00\x00\x20\x42\x00\x6a\x02\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00\x42\x00\x6b\x02\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00\x42\x00\x0d\x02\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00\x42\x00\x0f\x01\x00\x00\x00\x88' + b'\x42\x00\x5c\x05\x00\x00\x00\x04\x00\x00\x00\x08\x00\x00\x00\x00' + b'\x42\x00\x79\x01\x00\x00\x00\x70\x42\x00\x08\x01\x00\x00\x00\x28' + b'\x42\x00\x0a\x07\x00\x00\x00\x0b\x4f\x62\x6a\x65\x63\x74\x20\x54' + b'\x79\x70\x65\x00\x00\x00\x00\x00\x42\x00\x0b\x05\x00\x00\x00\x04' + b'\x00\x00\x00\x02\x00\x00\x00\x00\x42\x00\x08\x01\x00\x00\x00\x38' + b'\x42\x00\x0a\x07\x00\x00\x00\x04\x4e\x61\x6d\x65\x00\x00\x00\x00' + b'\x42\x00\x0b\x01\x00\x00\x00\x20\x42\x00\x55\x07\x00\x00\x00\x04' + b'\x4b\x65\x79\x31\x00\x00\x00\x00\x42\x00\x54\x05\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00') def tearDown(self): super(TestRequestMessage, self).tearDown() @@ -802,6 +818,149 @@ class TestRequestMessage(TestCase): msg = "Bad request message write: encoding mismatch" self.assertEqual(self.register, result, msg) + def test_locate_request_read(self): + self.stream = BytearrayStream(self.locate) + + request_message = messages.RequestMessage() + request_message.read(self.stream) + + request_header = request_message.request_header + msg = "Bad request header type: expected {0}, received{0}" + self.assertIsInstance(request_header, messages.RequestHeader, + msg.format(messages.RequestHeader, + type(request_header))) + + protocol_version = request_header.protocol_version + msg = "Bad protocol version type: expected {0}, received {1}" + self.assertIsInstance(protocol_version, contents.ProtocolVersion, + msg.format(contents.ProtocolVersion, + type(protocol_version))) + + protocol_version_major = protocol_version.protocol_version_major + msg = "Bad protocol version major type: expected {0}, received {1}" + exp_type = contents.ProtocolVersion.ProtocolVersionMajor + rcv_type = type(protocol_version_major) + self.assertIsInstance(protocol_version_major, exp_type, + msg.format(exp_type, rcv_type)) + msg = "Bad protocol version major value: expected {0}, received {1}" + self.assertEqual(1, protocol_version_major.value, + msg.format(1, protocol_version_major.value)) + + protocol_version_minor = protocol_version.protocol_version_minor + msg = "Bad protocol version minor type: expected {0}, received {1}" + exp_type = contents.ProtocolVersion.ProtocolVersionMinor + rcv_type = type(protocol_version_minor) + self.assertIsInstance(protocol_version_minor, exp_type, + msg.format(exp_type, rcv_type)) + msg = "Bad protocol version minor value: expected {0}, received {1}" + self.assertEqual(1, protocol_version_minor.value, + msg.format(1, protocol_version_minor.value)) + + batch_count = request_header.batch_count + msg = "Bad batch count type: expected {0}, received {1}" + self.assertIsInstance(batch_count, contents.BatchCount, + msg.format(contents.BatchCount, + type(batch_count))) + msg = "Bad batch count value: expected {0}, received {1}" + self.assertEqual(1, batch_count.value, + msg.format(1, batch_count.value)) + + batch_items = request_message.batch_items + msg = "Bad batch items type: expected {0}, received {1}" + self.assertEquals(1, len(batch_items), + self.msg.format('batch items', 'length', + 1, len(batch_items))) + + batch_item = batch_items[0] + msg = "Bad batch item type: expected {0}, received {1}" + self.assertIsInstance(batch_item, messages.RequestBatchItem, + msg.format(messages.RequestBatchItem, + type(batch_item))) + + operation = batch_item.operation + msg = "Bad operation type: expected {0}, received {1}" + self.assertIsInstance(operation, contents.Operation, + msg.format(contents.Operation, + type(operation))) + + msg = "Bad operation value: expected {0}, received {1}" + exp_value = enums.Operation.LOCATE + rcv_value = operation.enum + self.assertEqual(exp_value, rcv_value, + msg.format(exp_value, rcv_value)) + + request_payload = batch_item.request_payload + msg = "Bad request payload type: expected {0}, received {1}" + exp_type = operations.LocateRequestPayload + rcv_type = type(request_payload) + self.assertIsInstance(request_payload, exp_type, + msg.format(exp_type, rcv_type)) + + attributes = request_payload.attributes + msg = "Bad attributes type: expected {0}, received {1}" + exp_type = list + rcv_type = type(attributes) + self.assertIsInstance(attributes, exp_type, + msg.format(exp_type, rcv_type)) + + self.assertEqual(2, len(attributes), + self.msg.format('attribute', 'length', + 2, len(attributes))) + + attribute_a = attributes[0] + self.assertIsInstance(attribute_a, objects.Attribute, + self.msg.format('attribute', 'type', + objects.Attribute, + type(attribute_a))) + + attribute_name = attribute_a.attribute_name + self.assertIsInstance(attribute_name, objects.Attribute.AttributeName, + self.msg.format('attribute name', 'type', + objects.Attribute.AttributeName, + type(attribute_name))) + self.assertEquals('Object Type', attribute_name.value, + self.msg.format('attribute name', 'value', + 'Object Type', + attribute_name.value)) + + attribute_value = attribute_a.attribute_value + exp_type = attr.Enumeration + rcv_type = type(attribute_value) + self.assertIsInstance(attribute_value, exp_type, + self.msg.format('attribute value', 'type', + exp_type, rcv_type)) + self.assertEquals(attribute_value.enum, enums.ObjectType.SYMMETRIC_KEY, + self.msg.format('ObjectType', 'value', + enums.ObjectType.SYMMETRIC_KEY, + attribute_value.enum)) + + attribute_b = attributes[1] + self.assertIsInstance(attribute_b, objects.Attribute, + self.msg.format('attribute', 'type', + objects.Attribute, + type(attribute_a))) + + attribute_name = attribute_b.attribute_name + self.assertIsInstance(attribute_name, objects.Attribute.AttributeName, + self.msg.format('attribute name', 'type', + objects.Attribute.AttributeName, + type(attribute_name))) + self.assertEquals('Name', attribute_name.value, + self.msg.format('attribute name', 'value', + 'Name', + attribute_name.value)) + attribute_value = attribute_b.attribute_value + + exp_type = Name + rcv_type = type(attribute_value) + self.assertIsInstance(attribute_value, exp_type, + self.msg.format('attribute value', 'type', + exp_type, rcv_type)) + self.assertEquals('Key1', attribute_value.name_value.value, + self.msg.format('name value', 'value', + 'Key1', + attribute_value.name_value.value)) + class TestResponseMessage(TestCase): @@ -872,6 +1031,20 @@ class TestResponseMessage(TestCase): b'\x66\x62\x34\x62\x35\x62\x39\x63\x2D\x36\x31\x38\x38\x2D\x34\x63' b'\x36\x33\x2D\x38\x31\x34\x32\x2D\x66\x65\x39\x63\x33\x32\x38\x31' b'\x32\x39\x66\x63\x00\x00\x00\x00') + # kmip-testcases-v1.1 section 3.1.3 + self.locate = ( + b'\x42\x00\x7b\x01\x00\x00\x00\xb0\x42\x00\x7a\x01\x00\x00\x00\x48' + b'\x42\x00\x69\x01\x00\x00\x00\x20\x42\x00\x6a\x02\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00\x42\x00\x6b\x02\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00\x42\x00\x92\x09\x00\x00\x00\x08' + b'\x00\x00\x00\x00\x4f\x9a\x54\xe6\x42\x00\x0d\x02\x00\x00\x00\x04' + b'\x00\x00\x00\x01\x00\x00\x00\x00\x42\x00\x0f\x01\x00\x00\x00\x58' + b'\x42\x00\x5c\x05\x00\x00\x00\x04\x00\x00\x00\x08\x00\x00\x00\x00' + b'\x42\x00\x7f\x05\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00' + b'\x42\x00\x7c\x01\x00\x00\x00\x30\x42\x00\x94\x07\x00\x00\x00\x24' + b'\x34\x39\x61\x31\x63\x61\x38\x38\x2d\x36\x62\x65\x61\x2d\x34\x66' + b'\x62\x32\x2d\x62\x34\x35\x30\x2d\x37\x65\x35\x38\x38\x30\x32\x63' + b'\x33\x30\x33\x38\x00\x00\x00\x00') def tearDown(self): super(TestResponseMessage, self).tearDown() @@ -1537,3 +1710,38 @@ class TestResponseMessage(TestCase): msg = "Bad response message write: encoding mismatch" self.assertEqual(self.register, result, msg) + + def test_locate_response_write(self): + prot_ver = contents.ProtocolVersion.create(1, 1) + + # Fri Apr 27 10:12:22 CEST 2012 + time_stamp = contents.TimeStamp(0x4f9a54e6) + + batch_count = contents.BatchCount(1) + resp_hdr = messages.ResponseHeader(protocol_version=prot_ver, + time_stamp=time_stamp, + batch_count=batch_count) + + operation = contents.Operation(enums.Operation.LOCATE) + result_status = contents.ResultStatus(enums.ResultStatus.SUCCESS) + uuid = attr.UniqueIdentifier('49a1ca88-6bea-4fb2-b450-7e58802c3038') + + resp_pl = LocateResponsePayload(unique_identifiers=[uuid]) + + batch_item = messages.ResponseBatchItem(operation=operation, + result_status=result_status, + response_payload=resp_pl) + + response_message = messages.ResponseMessage(response_header=resp_hdr, + batch_items=[batch_item]) + + response_message.write(self.stream) + + result = self.stream.read() + len_exp = len(self.locate) + len_rcv = len(result) + self.assertEqual(len_exp, len_rcv, + self.msg.format('response message', 'write', + len_exp, len_rcv)) + msg = "Bad response message write: encoding mismatch" + self.assertEqual(self.locate, result, msg) diff --git a/kmip/tests/core/test_server.py b/kmip/tests/core/test_server.py index c4dd248..71292b4 100644 --- a/kmip/tests/core/test_server.py +++ b/kmip/tests/core/test_server.py @@ -37,7 +37,6 @@ from kmip.core.messages.contents import KeyFormatType from kmip.core.objects import KeyBlock from kmip.core.objects import KeyValueStruct from kmip.core.objects import TemplateAttribute -from kmip.core.objects import Attribute from kmip.core.secrets import SymmetricKey from kmip.core.server import KMIPImpl @@ -477,14 +476,6 @@ class TestKMIPServer(TestCase): crypto_length, usage) return SymmetricKey(key_block) - def _make_nameattr(self): - name = Attribute.AttributeName('Name') - name_value = Name.NameValue('TESTNAME') - name_type = Name.NameType(NameType.UNINTERPRETED_TEXT_STRING) - value = Name(name_value=name_value, name_type=name_type) - nameattr = Attribute(attribute_name=name, attribute_value=value) - return nameattr - def _get_attrs(self): attr_factory = AttributeFactory() algorithm = self._get_alg_attr(self.algorithm_name) @@ -494,7 +485,10 @@ class TestKMIPServer(TestCase): CryptoUsageMaskEnum.DECRYPT] usage_mask = attr_factory.create_attribute(attribute_type, mask_flags) - nameattr = self._make_nameattr() + name_value = Name.NameValue(value='TESTNAME') + name_type = Name.NameType(value=NameType.UNINTERPRETED_TEXT_STRING) + value = Name.create(name_value, name_type) + nameattr = attr_factory.create_attribute(AttributeType.NAME, value) return [algorithm, usage_mask, length, nameattr] def _get_alg_attr(self, alg=None): @@ -521,7 +515,15 @@ class TestKMIPServer(TestCase): def test_locate(self): self._create() - attrs = [self._make_nameattr()] + + name_value = Name.NameValue(value='TESTNAME') + name_type = Name.NameType(value=NameType.UNINTERPRETED_TEXT_STRING) + value = Name.create(name_value, name_type) + + attr_factory = AttributeFactory() + nameattr = attr_factory.create_attribute(AttributeType.NAME, value) + + attrs = [nameattr] res = self.kmip.locate(attributes=attrs) self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, 'locate result status did not return success') From aa300b256cd4dfe7e717a5d8e424c986ab48ef12 Mon Sep 17 00:00:00 2001 From: Wyllys Date: Thu, 11 Sep 2014 18:04:22 -0400 Subject: [PATCH 3/9] Stub out server side locate operation. --- kmip/core/attributes.py | 19 +++++++++++++++++-- kmip/core/repo/mem_repo.py | 5 +---- kmip/core/server.py | 13 ++++++++++--- 3 files changed, 28 insertions(+), 9 deletions(-) diff --git a/kmip/core/attributes.py b/kmip/core/attributes.py index 41c067c..f73d4ff 100644 --- a/kmip/core/attributes.py +++ b/kmip/core/attributes.py @@ -85,8 +85,21 @@ class Name(Struct): self.__validate() def __validate(self): - # TODO (peter-hamilton) Finish implementation. - pass + name = self.__class__.__name__ + if self.name_value and \ + not isinstance(self.name_value, Name.NameValue) and \ + not isinstance(self.name_value, str): + member = 'name_value' + raise TypeError(msg.format('{}.{}'.format(name, member), + 'name_value', type(Name.NameValue), + type(name_type))) + if self.name_type and \ + not isinstance(self.name_type, Name.NameType) and \ + not isinstance(self.name_type, str): + member = 'name_type' + raise TypeError(msg.format('{}.{}'.format(name, member), + 'name_type', type(Name.NameType), + type(self.name_type))) @classmethod def create(cls, name_value, name_type): @@ -94,11 +107,13 @@ class Name(Struct): value = name_value elif isinstance(name_value, str): value = cls.NameValue(name_value) + # else: the __validate function will throw TypeError if isinstance(name_type, Name.NameType): n_type = name_type elif isinstance(name_type, Enum): n_type = cls.NameType(name_type) + # else: the __validate function will throw TypeError return Name(name_value=value, name_type=n_type) diff --git a/kmip/core/repo/mem_repo.py b/kmip/core/repo/mem_repo.py index 6d29e6a..1db2979 100644 --- a/kmip/core/repo/mem_repo.py +++ b/kmip/core/repo/mem_repo.py @@ -48,7 +48,4 @@ class MemRepo(ManagedObjectRepo): def locate(self, maximum_items, storage_status_mask, object_group_member, attributes): - # TODO - search objects, find one with matching attrs - if "1" in self.repo: - return [self.repo["1"]] - return None + raise NotImplementedError diff --git a/kmip/core/server.py b/kmip/core/server.py index 6e9478f..e297868 100644 --- a/kmip/core/server.py +++ b/kmip/core/server.py @@ -260,9 +260,16 @@ class KMIPImpl(KMIP): self.logger.debug('locate() called') msg = 'locating object(s) from repo' self.logger.debug(msg) - uuids = self.repo.locate(maximum_items, storage_status_mask, - object_group_member, attributes) - return LocateResult(ResultStatus(RS.SUCCESS), uuids=uuids) + try: + uuids = self.repo.locate(maximum_items, storage_status_mask, + object_group_member, attributes) + return LocateResult(ResultStatus(RS.SUCCESS), uuids=uuids) + except NotImplementedError: + msg = ResultMessage('Locate Operation Not Supported')) + reason = ResultReason(ResultReasonEnum.OPERATION_NOT_SUPPORTED) + return LocateResult(ResultStatus(RS.OPERATION_FAILED), + result_reason=reason, + result_message=msg) def _validate_req_field(self, attrs, name, expected, msg, required=True): self.logger.debug('Validating attribute %s' % name) From ceaff6d7ac215b2e3c7287b49479d2a51bb53ae6 Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Thu, 11 Sep 2014 18:15:52 -0400 Subject: [PATCH 4/9] Fixed typos --- kmip/core/attributes.py | 9 +++++---- kmip/core/server.py | 2 +- kmip/tests/core/test_server.py | 2 +- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/kmip/core/attributes.py b/kmip/core/attributes.py index f73d4ff..08bad52 100644 --- a/kmip/core/attributes.py +++ b/kmip/core/attributes.py @@ -86,20 +86,21 @@ class Name(Struct): def __validate(self): name = self.__class__.__name__ + msg = ErrorStrings.BAD_EXP_RECV if self.name_value and \ not isinstance(self.name_value, Name.NameValue) and \ not isinstance(self.name_value, str): member = 'name_value' raise TypeError(msg.format('{}.{}'.format(name, member), - 'name_value', type(Name.NameValue), - type(name_type))) + 'name_value', type(Name.NameValue), + type(self.name_value))) if self.name_type and \ not isinstance(self.name_type, Name.NameType) and \ not isinstance(self.name_type, str): member = 'name_type' raise TypeError(msg.format('{}.{}'.format(name, member), - 'name_type', type(Name.NameType), - type(self.name_type))) + 'name_type', type(Name.NameType), + type(self.name_type))) @classmethod def create(cls, name_value, name_type): diff --git a/kmip/core/server.py b/kmip/core/server.py index e297868..e45d4e2 100644 --- a/kmip/core/server.py +++ b/kmip/core/server.py @@ -265,7 +265,7 @@ class KMIPImpl(KMIP): object_group_member, attributes) return LocateResult(ResultStatus(RS.SUCCESS), uuids=uuids) except NotImplementedError: - msg = ResultMessage('Locate Operation Not Supported')) + msg = ResultMessage('Locate Operation Not Supported') reason = ResultReason(ResultReasonEnum.OPERATION_NOT_SUPPORTED) return LocateResult(ResultStatus(RS.OPERATION_FAILED), result_reason=reason, diff --git a/kmip/tests/core/test_server.py b/kmip/tests/core/test_server.py index 71292b4..59044ed 100644 --- a/kmip/tests/core/test_server.py +++ b/kmip/tests/core/test_server.py @@ -525,5 +525,5 @@ class TestKMIPServer(TestCase): attrs = [nameattr] res = self.kmip.locate(attributes=attrs) - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.OPERATION_FAILED, res.result_status.enum, 'locate result status did not return success') From e67f56ae56ea3e796685f8f4ce22f03d88164d6c Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Fri, 12 Sep 2014 12:55:18 -0400 Subject: [PATCH 5/9] Added TypeError exception to Name.create method --- kmip/core/attributes.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/kmip/core/attributes.py b/kmip/core/attributes.py index 08bad52..259910a 100644 --- a/kmip/core/attributes.py +++ b/kmip/core/attributes.py @@ -108,13 +108,25 @@ class Name(Struct): value = name_value elif isinstance(name_value, str): value = cls.NameValue(name_value) - # else: the __validate function will throw TypeError + else: + name = self.__class__.__name__ + msg = ErrorStrings.BAD_EXP_RECV + member = 'name_value' + raise TypeError(msg.format('{}.{}'.format(name, member), + 'name_value', type(Name.NameValue), + type(self.name_value))) if isinstance(name_type, Name.NameType): n_type = name_type elif isinstance(name_type, Enum): n_type = cls.NameType(name_type) - # else: the __validate function will throw TypeError + else: + name = self.__class__.__name__ + msg = ErrorStrings.BAD_EXP_RECV + member = 'name_type' + raise TypeError(msg.format('{}.{}'.format(name, member), + 'name_type', type(Name.NameType), + type(self.name_type))) return Name(name_value=value, name_type=n_type) From 6752b700c9e4a58d0a803c35e3ad5024dcdbc0ed Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Fri, 12 Sep 2014 13:00:15 -0400 Subject: [PATCH 6/9] flake8 fix --- kmip/core/attributes.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/kmip/core/attributes.py b/kmip/core/attributes.py index 259910a..1f3433b 100644 --- a/kmip/core/attributes.py +++ b/kmip/core/attributes.py @@ -92,15 +92,15 @@ class Name(Struct): not isinstance(self.name_value, str): member = 'name_value' raise TypeError(msg.format('{}.{}'.format(name, member), - 'name_value', type(Name.NameValue), - type(self.name_value))) + 'name_value', type(Name.NameValue), + type(self.name_value))) if self.name_type and \ not isinstance(self.name_type, Name.NameType) and \ not isinstance(self.name_type, str): member = 'name_type' raise TypeError(msg.format('{}.{}'.format(name, member), - 'name_type', type(Name.NameType), - type(self.name_type))) + 'name_type', type(Name.NameType), + type(self.name_type))) @classmethod def create(cls, name_value, name_type): @@ -109,24 +109,24 @@ class Name(Struct): elif isinstance(name_value, str): value = cls.NameValue(name_value) else: - name = self.__class__.__name__ + name = 'Name' msg = ErrorStrings.BAD_EXP_RECV member = 'name_value' raise TypeError(msg.format('{}.{}'.format(name, member), - 'name_value', type(Name.NameValue), - type(self.name_value))) + 'name_value', type(Name.NameValue), + type(name_value))) if isinstance(name_type, Name.NameType): n_type = name_type elif isinstance(name_type, Enum): n_type = cls.NameType(name_type) else: - name = self.__class__.__name__ + name = 'Name' msg = ErrorStrings.BAD_EXP_RECV member = 'name_type' raise TypeError(msg.format('{}.{}'.format(name, member), - 'name_type', type(Name.NameType), - type(self.name_type))) + 'name_type', type(Name.NameType), + type(name_type))) return Name(name_value=value, name_type=n_type) From 47032c9d85ebd4deb234ee59c3e50e47d8e87f2f Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Wed, 17 Sep 2014 15:25:58 -0400 Subject: [PATCH 7/9] Update locate.py removed Johns Hopkins copyright lines. --- kmip/demos/locate.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/kmip/demos/locate.py b/kmip/demos/locate.py index 4bf72cb..39cce31 100644 --- a/kmip/demos/locate.py +++ b/kmip/demos/locate.py @@ -1,6 +1,3 @@ -# Copyright (c) 2014 The Johns Hopkins University/Applied Physics Laboratory -# All Rights Reserved. -# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at From 61b3231e797cf74f866f31846b0c1dd6ffd7cf30 Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Wed, 17 Sep 2014 15:33:23 -0400 Subject: [PATCH 8/9] Removed name from TODO comment --- kmip/core/messages/operations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kmip/core/messages/operations.py b/kmip/core/messages/operations.py index 974ce17..4220d23 100644 --- a/kmip/core/messages/operations.py +++ b/kmip/core/messages/operations.py @@ -539,7 +539,7 @@ class LocateResponsePayload(Struct): self.__validate() def __validate(self): - # TODO (peter-hamilton) Finish implementation. + # TODO Finish implementation. pass From aa51f15bf006480947a2728479df9aac976ca79e Mon Sep 17 00:00:00 2001 From: Wyllys Ingersoll Date: Thu, 18 Sep 2014 10:17:52 -0400 Subject: [PATCH 9/9] Fixed broken destroy message in test --- kmip/tests/core/messages/test_messages.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/kmip/tests/core/messages/test_messages.py b/kmip/tests/core/messages/test_messages.py index 720d88c..f906a72 100644 --- a/kmip/tests/core/messages/test_messages.py +++ b/kmip/tests/core/messages/test_messages.py @@ -136,6 +136,8 @@ class TestRequestMessage(TestCase): b'\x42\x00\x5C\x05\x00\x00\x00\x04\x00\x00\x00\x14\x00\x00\x00\x00' b'\x42\x00\x79\x01\x00\x00\x00\x30\x42\x00\x94\x07\x00\x00\x00\x24' b'\x66\x62\x34\x62\x35\x62\x39\x63\x2D\x36\x31\x38\x38\x2D\x34\x63' + b'\x36\x33\x2D\x38\x31\x34\x32\x2D\x66\x65\x39\x63\x33\x32\x38\x31' + b'\x32\x39\x66\x63\x00\x00\x00\x00' ) # kmip-testcases-v1.1 section 3.1.3 self.locate = (