def test_build_header(self):
timestamp = utils.current_timestamp()
client = Client()
client.state_store = FileKeyValueStore(self.kv_store_path)
orderer_org_admin = get_orderer_org_admin(client)
orderer_org_admin_tx_context = \
TXContext(orderer_org_admin, Ecies(), {})
client.tx_context = orderer_org_admin_tx_context
orderer_org_admin_serialized = utils.create_serialized_identity(
orderer_org_admin)
serialized_identity = identities_pb2.SerializedIdentity()
serialized_identity.ParseFromString(orderer_org_admin_serialized)
proto_channel_header = utils.build_channel_header(
common_pb2.HeaderType.Value('CONFIG_UPDATE'),
orderer_org_admin_tx_context.tx_id,
self.channel_id,
timestamp
)
channel_header = utils.build_header(
orderer_org_admin_tx_context.identity,
proto_channel_header,
orderer_org_admin_tx_context.nonce
)
self.assertIsInstance(channel_header, common_pb2.Header)
def test_create_serialized_identity(self):
client = Client('test/fixtures/network.json')
orderer_org_admin = get_orderer_org_user(
state_store=client.state_store)
orderer_org_admin_serialized = utils.create_serialized_identity(
orderer_org_admin)
serialized_identity = identities_pb2.SerializedIdentity()
serialized_identity.ParseFromString(orderer_org_admin_serialized)
self.assertEqual(serialized_identity.mspid, self.orderer_org_mspid)
def test_create_serialized_identity(self):
client = Client()
client.state_store = FileKeyValueStore(self.kv_store_path)
orderer_org_admin = get_orderer_org_admin(client)
orderer_org_admin_serialized = utils.create_serialized_identity(
orderer_org_admin)
serialized_identity = identities_pb2.SerializedIdentity()
serialized_identity.ParseFromString(orderer_org_admin_serialized)
self.assertEqual(serialized_identity.mspid, self.orderer_org_mspid)
def __init__(self, user, crypto, tx_prop_req, prop_wait_time=-1):
"""
prop_wait_time (int): 제안 요청 대기 타임아웃
tx_prop_req (object): 트랜잭션 제안 요청
user: user 객체
crypto: crypto 객체
"""
self._tx_prop_req = tx_prop_req
self._user = user
self._crypto = crypto
self._identity = create_serialized_identity(user)
self._nonce = crypto.generate_nonce(24)
hash_func = crypto.hash
self._tx_id = hash_func(self._nonce + self._identity).hexdigest()
self._prop_wait_time = prop_wait_time
def __init__(self, user, crypto, tx_prop_req, prop_wait_time=-1):
""" Construct transaction context
Args:
prop_wait_time (int): proposal request wait timeout
tx_prop_req (object): transaction proposal request
user: user
crypto: crypto
"""
self._tx_prop_req = tx_prop_req
self._user = user
self._crypto = crypto
self._identity = create_serialized_identity(user)
self._nonce = crypto.generate_nonce(24)
hash_func = crypto.hash
self._tx_id = hash_func(self._nonce + self._identity).hexdigest()
self._prop_wait_time = prop_wait_time
def __init__(self, channel, user, crypto):
""" Construct transaction context
Args:
channel: channel
user: user
crypto: crypto
"""
self._user = user
self._channel = channel
self._need_verify = channel.name is not None and channel.name != ""
self._crypto = crypto
self._identity = create_serialized_identity(user)
self._nonce = crypto.generate_nonce(24)
hash_func = crypto.hash
self._tx_id = hash_func(self._nonce
+ self._identity).hexdigest()
def __init__(self, user, crypto, tx_prop_req, prop_wait_time=-1):
""" Construct transaction context
:param prop_wait_time: proposal request wait timeout
:param tx_prop_req: transaction proposal request
:param user: user
:param crypto: crypto
:return: The created TXContext instance or None
"""
self._tx_prop_req = tx_prop_req
self._user = user
self._crypto = crypto
self._identity = create_serialized_identity(user)
self._nonce = crypto.generate_nonce(24)
hash_func = crypto.hash
self._tx_id = hash_func(self._nonce + self._identity).hexdigest()
self._prop_wait_time = prop_wait_time
def _discovery(self,
requestor,
target,
local=False,
config=False,
interests=None):
"""Send a request from a target peer to discover information about the
network
Args:
requestor (instance): a user to make the request
target (instance): target peer to send discovery request
local (bool): include local endpoints in the query
config (bool): include channel configuration in the query
interests (list): interests about an endorsement for cc
Returns:
Response from Discovery Service
"""
auth = protocol_pb2.AuthInfo()
sig = utils.create_serialized_identity(requestor)
auth.client_identity = sig
# TODO: add tls certificate in client and there
discovery_req = protocol_pb2.Request()
discovery_req.authentication.CopyFrom(auth)
queries = []
if local:
q = protocol_pb2.Query()
queries.append(q)
local_peers = protocol_pb2.LocalPeerQuery()
q.local_peers.CopyFrom(local_peers)
_logger.info("DISCOVERY: adding local peers query")
else:
# It gives us state info about the channel
# in addition of LocalPeerQuery information
q = protocol_pb2.Query()
queries.append(q)
q.channel = self._name
peer_query = protocol_pb2.PeerMembershipQuery()
q.peer_query.CopyFrom(peer_query)
_logger.info("DISCOVERY: adding channel peers query")
if config:
q = protocol_pb2.Query()
queries.append(q)
q.channel = self._name
config_query = protocol_pb2.ConfigQuery()
q.config_query.CopyFrom(config_query)
_logger.info("DISCOVERY: adding config query")
if interests and len(interests) > 0:
q = protocol_pb2.Query()
queries.append(q)
q.channel = self._name
cc_interests = []
for interest in interests:
proto_interest = self._build_proto_cc_interest(interest)
cc_interests.append(proto_interest)
cc_query = protocol_pb2.ChaincodeQuery()
cc_query.interests.extend(cc_interests)
q.cc_query.CopyFrom(cc_query)
_logger.info("DISCOVERY: adding chaincodes/collection query")
discovery_req.queries.extend(queries)
request_bytes = discovery_req.SerializeToString()
sig = requestor.cryptoSuite.sign(requestor.enrollment.private_key,
request_bytes)
envelope = create_envelope(sig, request_bytes)
return target.send_discovery(envelope)
def join_channel(self, request):
"""
To join the peer to a channel.
Args:
request: the request to join a channel
Return:
True in sucess or False in failure
"""
_logger.debug('join_channel - start')
err_msg = None
if (not request):
err_msg = "Missing all required input request parameters"
if 'targets' not in request:
err_msg = "Missing peers parameter"
if 'block' not in request:
err_msg = "Missing genesis block parameter"
if 'tx_id' not in request:
err_msg = "Missing transaction id parameter"
if err_msg:
_logger.error('join_channel error: {}'.format(err_msg))
raise ValueError(err_msg)
tx_context = self._client.tx_context
chaincode_spec = create_chaincode_spec(request['block'], 'cscc',
"GOLANG")
extension = chaincode_spec.SerializeToString()
channel_header = build_channel_header(
common_pb2.HeaderType.Value('ENDORSER_TRANSACTION'),
tx_context.tx_id,
self.name,
current_timestamp(),
tx_context.epoch,
extension=extension)
creator = create_serialized_identity(tx_context.user)
header = build_header(creator, channel_header, tx_context.nonce)
proposal = build_cc_proposal(chaincode_spec, header, {})
try:
responses = send_transaction_proposal(proposal, header, tx_context,
request['targets'])
except Exception as e:
raise IOError("fail to send transanction proposal", e)
q = Queue(1)
for r in responses:
r.subscribe(on_next=lambda x: q.put(x),
on_error=lambda x: q.put(x))
res = q.get(timeout=5)
result = True and (res.response.status == 200)
_logger.info("The return status is:", result)
return result