def setUp(self, wipe_all):
self.gopath_bak = os.environ.get('GOPATH', '')
gopath = os.path.normpath(
os.path.join(os.path.dirname(__file__),
"../test/fixtures/chaincode"))
os.environ['GOPATH'] = os.path.abspath(gopath)
if "LOCAL_DEPLOY" in os.environ:
LOCAL_DEPLOY = os.environ["LOCAL_DEPLOY"] == "True"
GCP_DEPLOY = not LOCAL_DEPLOY
self.channel_tx = \
E2E_CONFIG[NETWORK_NAME]['channel-artifacts']['channel.tx']
self.compose_file_path = \
E2E_CONFIG[NETWORK_NAME]['docker']['compose_file_trustas_gcp'] if GCP_DEPLOY else \
E2E_CONFIG[NETWORK_NAME]['docker']['compose_file_trustas_localhost']
self.config_yaml = \
E2E_CONFIG[NETWORK_NAME]['channel-artifacts']['config_yaml']
self.channel_profile = \
E2E_CONFIG[NETWORK_NAME]['channel-artifacts']['channel_profile']
self.client = Client('test/fixtures/trustas_net_gcp.json') if GCP_DEPLOY else \
Client('test/fixtures/network.json')
# Client('test/fixtures/local-10peers.json')
self.channel_name = "businesschannel" # default application channel
self.user = self.client.get_user('org1.example.com', 'Admin')
self.assertIsNotNone(self.user, 'org1 admin should not be None')
global ALIVE
ALIVE = True
# Boot up the testing network
self.start_test_env(wipe_all)
return HOST, NAME
def setUp(self):
self.gopath_bak = os.environ.get('GOPATH', '')
gopath = os.path.normpath(os.path.join(os.path.dirname(__file__),
"../../fixtures/chaincode"))
os.environ['GOPATH'] = os.path.abspath(gopath)
self.configtx_path = \
E2E_CONFIG['test-network']['channel-artifacts']['channel.tx']
self.peer0Org1_req_endpoint = E2E_CONFIG['test-network'][
'org1.example.com']['peers']['peer0']['grpc_request_endpoint']
self.peer0Org1_tls_certs = E2E_CONFIG['test-network'][
'org1.example.com']['peers']['peer0']['tls_cacerts']
self.peer0Org1_tls_hostname = E2E_CONFIG['test-network'][
'org1.example.com']['peers']['peer0']['server_hostname']
self.peer0Org2_req_endpoint = E2E_CONFIG['test-network'][
'org2.example.com']['peers']['peer0']['grpc_request_endpoint']
self.peer0Org2_tls_certs = E2E_CONFIG['test-network'][
'org2.example.com']['peers']['peer0']['tls_cacerts']
self.peer0Org2_tls_hostname = E2E_CONFIG['test-network'][
'org2.example.com']['peers']['peer0']['server_hostname']
self.compose_file_path = \
E2E_CONFIG['test-network']['docker']['compose_file_tls']
self.base_path = "/tmp/fabric-sdk-py"
self.kv_store_path = os.path.join(self.base_path, "key-value-store")
self.client = Client()
self.start_test_env()
def test_invoke(self):
self.shutdown_test_env()
self.start_test_env()
time.sleep(5)
client = Client()
chain = client.new_channel(CHAIN_ID)
client.set_state_store(file_key_value_store(self.kv_store_path))
chain.add_peer(Peer())
submitter = get_submitter()
signing_identity = submitter.signing_identity
# cc_invoke_req = create_invocation_proposal_req(
# CHAINCODE_NAME, CHAINCODE_VERSION, signing_identity,
# args=['move', 'a', 'b', '100'])
queue = Queue(1)
#
# chain.invoke_chaincode(cc_invoke_req) \
# .subscribe(lambda x: queue.put(x))
prop = queue.get(timeout=10)
proposal_bytes = prop.proposal_bytes
sig = prop.signature
# verify the signature against the hash of proposal_bytes
digest = signing_identity.msp.crypto_suite.hash(proposal_bytes)
self.assertEqual(
signing_identity.verify(str.encode(digest.hexdigest()), sig), True)
self.shutdown_test_env()
def test_create_new_chain(self):
client = Client()
test_chain = client.new_channel('test')
self.assertEqual(test_chain, client.get_channel('test'))
no_chain = client.get_channel('test1')
self.assertIsNone(no_chain)
def setUp(self):
self.gopath_bak = os.environ.get('GOPATH', '')
gopath = os.path.normpath(
os.path.join(os.path.dirname(__file__), "../fixtures/chaincode"))
os.environ['GOPATH'] = os.path.abspath(gopath)
self.channel_tx = \
E2E_CONFIG['test-network']['channel-artifacts']['channel.tx']
self.compose_file_path = \
E2E_CONFIG['test-network']['docker']['compose_file_mutual_tls']
self.config_yaml = \
E2E_CONFIG['test-network']['channel-artifacts']['config_yaml']
self.channel_profile = \
E2E_CONFIG['test-network']['channel-artifacts']['channel_profile']
self.client = Client('test/fixtures/network-mutual-tls.json')
with open('test/fixtures/network-mutual-tls.json') as f:
self.network_info = json.load(f)
self.channel_name = "businesschannel" # default application channel
self.user = self.client.get_user('org1.example.com', 'Admin')
self.assertIsNotNone(self.user, 'org1 admin should not be None')
# Boot up the testing network
self.shutdown_test_env()
self.start_test_env()
time.sleep(1)
def test_string_to_signature(self):
with open(self.channel_tx, 'rb') as f:
channel_tx = f.read()
channel_config = utils.extract_channel_config(channel_tx)
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_signature = client.sign_channel_config(
channel_config)
orderer_org_admin_signature_bytes = \
orderer_org_admin_signature.SerializeToString()
proto_signature = utils.string_to_signature(
[orderer_org_admin_signature_bytes])
self.assertIsInstance(proto_signature, list)
self.assertTrue(
'OrdererMSP' in proto_signature[0].signature_header.__str__())
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_new_chain(self):
client = Client()
client.set_state_store(file_key_value_store(self.kv_store_path))
test_chain = client.new_chain('test')
self.assertEqual(test_chain, client.get_chain('test'))
no_chain = client.get_chain('test1')
self.assertIsNone(no_chain)
def setUp(self):
super(ChannelEventHubTest, self).setUp()
self.client = Client('test/fixtures/network.json')
self.channel_name = "businesschannel" # default application channel
self.channel = self.client.new_channel(self.channel_name)
self.blocks = []
self.org = 'org1.example.com'
self.peer = self.client.get_peer('peer0.' + self.org)
self.org_admin = self.client.get_user(self.org, 'Admin')
self.loop = asyncio.get_event_loop()
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 setUp(self):
self.channel_tx = \
test_network['channel-artifacts']['channel.tx']
self.channel_name = \
test_network['channel-artifacts']['channel_id']
self.compose_file_path = \
test_network['docker']['compose_file_tls']
self.client = Client('test/fixtures/network.json')
self.start_test_env()
def setUp(self):
self.configtx_path = \
E2E_CONFIG['test-network']['channel-artifacts']['channel.tx']
self.orderer_tls_certs = \
E2E_CONFIG['test-network']['orderer']['tls_cacerts']
self.orderer_tls_hostname = \
E2E_CONFIG['test-network']['orderer']['server_hostname']
self.compose_file_path = \
E2E_CONFIG['test-network']['docker']['compose_file_tls']
self.base_path = "/tmp/fabric-sdk-py"
self.kv_store_path = os.path.join(self.base_path, "key-value-store")
self.client = Client()
self.start_test_env()
def setUp(self):
self.base_path = "/tmp/fabric-sdk-py"
self.kv_store_path = os.path.join(self.base_path, "key-value-store")
self.client = Client()
self.client.state_store = FileKeyValueStore(self.kv_store_path)
self.channel_tx = \
E2E_CONFIG['test-network']['channel-artifacts']['channel.tx']
self.channel_name = \
E2E_CONFIG['test-network']['channel-artifacts']['channel_id']
self.compose_file_path = \
E2E_CONFIG['test-network']['docker']['compose_file_tls']
self.start_test_env()
def setUp(self):
self.gopath_bak = os.environ.get('GOPATH', '')
gopath = os.path.normpath(
os.path.join(os.path.dirname(__file__),
"../../fixtures/chaincode"))
os.environ['GOPATH'] = os.path.abspath(gopath)
self.configtx_path = \
E2E_CONFIG['test-network']['channel-artifacts']['channel.tx']
self.compose_file_path = \
E2E_CONFIG['test-network']['docker']['compose_file_tls']
self.base_path = "/tmp/fabric-sdk-py"
self.kv_store_path = os.path.join(self.base_path, "key-value-store")
self.client = Client()
self.client.state_store = FileKeyValueStore(self.kv_store_path)
self.start_test_env()
def setUp(self):
self.gopath_bak = os.environ.get('GOPATH', '')
gopath = os.path.normpath(
os.path.join(os.path.dirname(__file__), "../fixtures/chaincode"))
os.environ['GOPATH'] = os.path.abspath(gopath)
self.channel_tx = \
E2E_CONFIG['test-network']['channel-artifacts']['channel.tx']
self.compose_file_path = \
E2E_CONFIG['test-network']['docker']['compose_file_tls']
self.client = Client('test/fixtures/network.json')
self.channel_name = "businesschannel" # default application channel
self.user = self.client.get_user('org1.example.com', 'Admin')
self.assertIsNotNone(self.user, 'org1 admin should not be None')
self.start_test_env()
def __init__(self, profile, channel_name, org_name, peer_name, user_name):
self.client = Client(profile)
self._channel_name = channel_name
self._org_name = org_name
self._peer_name = peer_name
self._user_name = user_name
self._user = self.client.get_user(self._org_name, self._user_name)
endpoint = self.client.get_net_info('peers', self._peer_name, 'url')
tlscert = self.client.get_net_info('peers', self._peer_name,
'tlsCACerts', 'path')
loop = asyncio.get_event_loop()
peer = create_peer(endpoint=endpoint, tls_cacerts=tlscert)
loop.run_until_complete(
self.client.init_with_discovery(self._user, peer,
self._channel_name))
self._channel = self.client.new_channel(self._channel_name)
def create_channel(self):
client = Client('test/fixtures/network.json')
logger.info("start to create channel")
request = build_channel_request(
client,
self.channel_tx,
self.channel_name)
q = Queue(1)
response = client._create_channel(request)
response.subscribe(on_next=lambda x: q.put(x),
on_error=lambda x: q.put(x))
status, _ = q.get(timeout=5)
self.assertEqual(status.status, 200)
logger.info("successfully create the channel: %s", self.channel_name)
client.state_store = None
def join_channel(self):
# sleep 5 seconds for channel created
time.sleep(5)
client = Client()
client.state_store = FileKeyValueStore(self.kv_store_path +
'join-channel')
channel = client.new_channel(self.channel_name)
logger.info("start to join channel")
orgs = ["org1.example.com", "org2.example.com"]
for org in orgs:
request = build_join_channel_req(org, channel, client)
assert (request)
# result = True and channel.join_channel(request)
logger.info("peers in org: %s join channel: %", org,
self.channel_name)
logger.info("joining channel tested succefully")
client.state_store = None
def create_channel(self):
client = Client()
client.state_store = FileKeyValueStore(self.kv_store_path +
'build-channel')
logger.info("start to create channel")
request = build_channel_request(client, self.channel_tx,
self.channel_name)
q = Queue(1)
response = client.create_channel(request)
response.subscribe(on_next=lambda x: q.put(x),
on_error=lambda x: q.put(x))
status, _ = q.get(timeout=5)
self.assertEqual(status.status, 200)
logger.info("successfully create the channel: %s", self.channel_name)
client.state_store = None
def test_install(self):
time.sleep(5)
client = Client()
chain = client.new_chain(CHAIN_ID)
client.set_state_store(file_key_value_store(self.kv_store_path))
chain.add_peer(Peer())
chain.add_orderer(Orderer())
submitter = get_submitter()
signing_identity = submitter.signing_identity
cc_install_req = create_installment_proposal_req(
CHAINCODE_NAME, CHAINCODE_PATH, CHAINCODE_VERSION)
queue = Queue(1)
chain.install_chaincode(cc_install_req, signing_identity) \
.subscribe(on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x))
response, _ = queue.get(timeout=5)
# TODO: create channel not implement yet
print(response.status)
self.assertEqual(404, response.status)
def test_string_to_signature(self):
with open(self.channel_tx, 'rb') as f:
channel_tx = f.read()
channel_config = utils.extract_channel_config(channel_tx)
client = Client('test/fixtures/network.json')
orderer_org_admin = get_orderer_org_user(
state_store=client.state_store)
orderer_org_admin_tx_context = \
TXContext(orderer_org_admin, Ecies(), {})
client.tx_context = orderer_org_admin_tx_context
orderer_org_admin_signature = client.sign_channel_config(
channel_config)
proto_signature = utils.string_to_signature(
[orderer_org_admin_signature])
self.assertIsInstance(proto_signature, list)
self.assertTrue(
'OrdererMSP' in proto_signature[0].signature_header.__str__())
def join_channel(self):
# wait for channel created
time.sleep(5)
client = Client('test/fixtures/network.json')
channel = client.new_channel(self.channel_name)
logger.info("start to join channel")
orgs = ["org1.example.com", "org2.example.com"]
done = True
for org in orgs:
client.state_store = FileKeyValueStore(
self.client.kv_store_path + org)
request = build_join_channel_req(org, channel, client)
done = done and channel.join_channel(request)
if done:
logger.info("peers in org: %s join channel: %s.",
org, self.channel_name)
if done:
logger.info("joining channel tested successfully.")
client.state_store = None
assert(done)
def setUp(self):
self.gopath_bak = os.environ.get('GOPATH', '')
gopath = os.path.normpath(
os.path.join(os.path.dirname(__file__), "../fixtures/chaincode"))
os.environ['GOPATH'] = os.path.abspath(gopath)
self.channel_tx = \
NET_CONFIG['channel-artifacts']['channel.tx']
self.compose_file_path = \
NET_CONFIG['docker']['compose_file_tls']
self.config_yaml = \
NET_CONFIG['channel-artifacts']['config_yaml']
self.channel_profile = \
NET_CONFIG['channel-artifacts']['channel_profile']
self.client = Client('test/fixtures/trustas-net.json')
self.channel_name = "businesschannel" # application channel
self.user = self.client.get_user('org1.example.com', 'Admin')
self.assertIsNotNone(self.user, 'org1 admin should not be None')
global ALIVE
ALIVE = True
# Boot up the testing network
self.start_test_env()
import os
from hfc.fabric.client import Client
from hfc.fabric_ca.caservice import ca_service
from hfc.fabric_network import wallet
"""
이 노드(하이퍼레저 net에 접속하는 클라이언트 노드)의 네트워크 설정 정보들
"""
HLF_NET_PATH="/opt/fixtures/network.json"
cli = Client(net_profile=HLF_NET_PATH)
class UserManage():
def __init__(self, ca_addr="localhost:7054",
ADMIN_ID="admin", ADMIN_SECRET="adminpw"):
if cli.CAs():
"client 객체에 CA 서버가 등록되어 있으면 그걸 사용"
self._ca_server = cli._CAs
else:
"CA 서버(컨테이너) 주소로 CA서버 객체 생성"
if os.getenv("CA_ADDR"):
self._ca_server = ca_service(os.getenv("CA_ADDR"))
else:
self._ca_server = ca_service(ca_addr)
"관리자 계정의 사용자 등록관리 객체를 CA 서버에서 얻어옴"
if self._ca_server:
self._admin_enroll_x509 = self._ca_server.enroll(ADMIN_ID,ADMIN_SECRET)
else:
self._admin_enroll_x509 = self._ca_server.enroll("admin","adminpw")
def setUp(self):
self.client = Client()
def test_create_client(self):
# TODO impl
client = Client()
client.set_state_store(file_key_value_store(self.kv_store_path))
self.fail()
def setUp(self):
self.client = Client('test/fixtures/network.json')
def test_create_client(self):
# TODO impl
Client()
self.fail()
