HLFV1 Beta and Query (We hope)

.gitignore

@@ -46,6 +46,9 @@ jspm_packages
 .DS_Store
 *.swp
 
+# vscode folder
+.vscode
+
 #generated jsdoc
 packages/composer-website/jekylldocs/jsdoc/
 

.travis.yml

@@ -7,7 +7,7 @@ matrix:
         - env: DOCS=full FC_TASK=docs
         - env: SYSTEST=embedded FC_TASK=systest
         - env: SYSTEST=hlf FC_TASK=systest
-        - env: SYSTEST=hlfv1 FC_TASK=systest
+        - env: SYSTEST=hlfv1_tls FC_TASK=systest
         - env: SYSTEST=proxy FC_TASK=systest
         - env: SYSTEST=web FC_TASK=systest
 dist: trusty

packages/composer-admin/api.txt

@@ -11,4 +11,5 @@ class AdminConnection {
    + Promise update(BusinessNetworkDefinition) 
    + Promise ping() 
    + Promise list() 
+   + Promise importIdentity(string,string,string,string) 
 }

packages/composer-admin/changelog.txt

@@ -11,6 +11,8 @@
 #
 # Note that the latest public API is documented using JSDocs and is available in api.txt.
 #
+Version 0.7.5 {3981adc1fb192a8e53d2250ea8feec9a} 2017-05-22
+- added importIdentity method.
 
 Version 0.3.7 {af35a7b1a5872beed588f70d3ee0f345} 2017-01-24
 - Move to single version

packages/composer-admin/lib/adminconnection.js

@@ -318,6 +318,32 @@ class AdminConnection {
         return this.connection.list(this.securityContext);
     }
 
+    /**
+     * import an identity into a profiles' wallet
+     *
+     * @param {string} connectionProfile Name of the connection profile
+     * @param {string} id The id to associate with this identity
+     * @param {string} publicKey The signer cert in PEM format
+     * @param {string} privateKey The private key in PEM format
+     * @returns {Promise} A promise which is resolved when the identity is imported
+     *
+     * @memberOf AdminConnection
+     */
+    importIdentity(connectionProfile, id, publicKey, privateKey) {
+        let savedConnectionManager;
+        return this.connectionProfileManager.getConnectionManager(connectionProfile)
+            .then((connectionManager) => {
+                savedConnectionManager = connectionManager;
+                return this.getProfile(connectionProfile);
+            })
+            .then((profileData) => {
+                return savedConnectionManager.importIdentity(profileData, id, publicKey, privateKey);
+            })
+            .catch((error) => {
+                throw new Error('failed to import identity. ' + error.message);
+            });
+    }
+
 }
 
 module.exports = AdminConnection;

packages/composer-admin/test/adminconnection.js

@@ -68,6 +68,7 @@ describe('AdminConnection', () => {
         mockConnectionManager.connect.resolves(mockConnection);
         adminConnection = new AdminConnection();
         sinon.stub(adminConnection.connectionProfileManager, 'connect').resolves(mockConnection);
+        sinon.stub(adminConnection.connectionProfileManager, 'getConnectionManager').resolves(mockConnectionManager);
         sinon.stub(adminConnection.connectionProfileStore, 'save').withArgs('testprofile', sinon.match.any).resolves();
         sinon.stub(adminConnection.connectionProfileStore, 'load').withArgs('testprofile').resolves(config);
         sinon.stub(adminConnection.connectionProfileStore, 'loadAll').resolves({ profile1: config, profile2: config2 });
@@ -253,4 +254,28 @@ describe('AdminConnection', () => {
 
     });
 
+    describe('#importIdentity', () => {
+        it('should be able to import an identity', () => {
+            mockConnectionManager.importIdentity = sinon.stub();
+            adminConnection.connection = mockConnection;
+            adminConnection.securityContext = mockSecurityContext;
+            return adminConnection.importIdentity('testprofile', 'anid', 'acerttosign', 'akey')
+            .then(() => {
+                sinon.assert.calledOnce(mockConnectionManager.importIdentity);
+                sinon.assert.calledWith(mockConnectionManager.importIdentity, config, 'anid', 'acerttosign', 'akey');
+            });
+        });
+
+        it('should throw an error if import fails', () => {
+            mockConnectionManager.importIdentity = sinon.stub();
+            mockConnectionManager.importIdentity.rejects(new Error('no identity imported'));
+            adminConnection.connection = mockConnection;
+            adminConnection.securityContext = mockSecurityContext;
+            return adminConnection.importIdentity('testprofile', 'anid', 'acerttosign', 'akey')
+            .should.be.rejectedWith(/no identity imported/);
+        });
+
+
+    });
+
 });

packages/composer-cli/cli.js

@@ -37,8 +37,9 @@ let results = yargs
     .version(function() {
         return getInfo('composer-cli')+
           getInfo('composer-admin')+getInfo('composer-client')+
-          getInfo('composer-common')+getInfo('composer-runtime')+
-          getInfo('composer-connector-hlfv1')+getInfo('composer-runtime-hlfv1');
+          getInfo('composer-common')+getInfo('composer-runtime-hlf')+
+          getInfo('composer-connector-hlf')+getInfo('composer-runtime-hlfv1')+
+          getInfo('composer-connector-hlfv1');
     })
     .describe('v', 'show version information')
     .command(

packages/composer-cli/lib/cmds/identity/importCommand.js

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+
+'use strict';
+
+const Import = require ('./lib/import.js');
+
+module.exports.command = 'import [options]';
+module.exports.describe = 'Import an identity to wallet defined by the connection profile';
+module.exports.builder = {
+    connectionProfileName: {alias: 'p', required: true, describe: 'The connection profile name', type: 'string' },
+    userId: { alias: 'u', required: true, describe: 'The user ID for the new identity', type: 'string' },
+    publicKeyFile: { alias: 'c', required: true, describe: 'File containing the public key', type: 'string' },
+    privateKeyFile: { alias: 'k', required: true, describe: 'File containing the private key', type: 'string' }
+};
+
+module.exports.handler = (argv) => {
+    argv.thePromise =  Import.handler(argv)
+    .then(() => {
+        console.log ('Command completed successfully.');
+    });
+    return argv.thePromise;
+};

packages/composer-cli/lib/cmds/identity/lib/import.js

@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+'use strict';
+
+const fs = require('fs');
+
+const cmdUtil = require('../../utils/cmdutils');
+
+/**
+ * <p>
+ * Composer "identity issue" command
+ * </p>
+ * <p><a href="diagrams/Deploy.svg"><img src="diagrams/deploy.svg" style="width:100%;"/></a></p>
+ * @private
+ */
+class Import {
+
+  /**
+    * Command process for deploy command
+    * @param {string} argv argument list from composer command
+    * @return {Promise} promise when command complete
+    */
+    static handler(argv) {
+        let userId;
+        let publicKeyFile;
+        let privateKeyFile;
+        let connectionProfileName;
+
+        userId = argv.userId;
+        publicKeyFile = argv.publicKeyFile;
+        privateKeyFile = argv.privateKeyFile;
+        connectionProfileName = argv.connectionProfileName;
+        let adminConnection = cmdUtil.createAdminConnection();
+        let signerCert;
+        let key;
+        try {
+            signerCert = fs.readFileSync(publicKeyFile).toString();
+        } catch(error) {
+            return Promise.reject(new Error('Unable to read public key file ' + publicKeyFile + '. ' + error.message));
+        }
+        try {
+            key = fs.readFileSync(privateKeyFile).toString();
+        } catch(error) {
+            return Promise.reject(new Error('Unable to read private key file ' + privateKeyFile + '. ' + error.message));
+        }
+        return adminConnection.importIdentity(connectionProfileName, userId, signerCert, key)
+            .then((result) => {
+                console.log(`An identity was imported with name '${userId}' successfully`);
+            });
+    }
+}
+
+module.exports = Import;

packages/composer-cli/test/identity/import.js

@@ -0,0 +1,115 @@
+/*
+ * 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.
+ */
+
+'use strict';
+
+const Client = require('composer-admin');
+
+const Import = require('../../lib/cmds/identity/importCommand.js');
+const CmdUtil = require('../../lib/cmds/utils/cmdutils.js');
+const fs = require('fs');
+
+const sinon = require('sinon');
+require('sinon-as-promised');
+const chai = require('chai');
+chai.should();
+chai.use(require('chai-as-promised'));
+
+const PROFILE_NAME = 'myprofile';
+const USER_ID = 'SuccessKid';
+const CERT_PATH = 'someCertPath';
+const KEY_PATH = 'someKeyPath';
+
+describe('composer identity import CLI unit tests', () => {
+
+    let sandbox;
+    let mockAdminConnection;
+
+    beforeEach(() => {
+        sandbox = sinon.sandbox.create();
+        mockAdminConnection = sinon.createStubInstance(Client.AdminConnection);
+        sandbox.stub(CmdUtil, 'createAdminConnection').returns(mockAdminConnection);
+        sandbox.stub(process, 'exit');
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    it('should import a new identity using the specified profile', () => {
+        let argv = {
+            connectionProfileName: PROFILE_NAME,
+            userId: USER_ID,
+            publicKeyFile: CERT_PATH,
+            privateKeyFile: KEY_PATH
+        };
+
+        let fsStub = sandbox.stub(fs, 'readFileSync').withArgs(CERT_PATH).returns('acert');
+        fsStub.withArgs(KEY_PATH).returns('akey');
+        mockAdminConnection.importIdentity.withArgs(PROFILE_NAME, USER_ID, 'acert', 'akey').resolves();
+        return Import.handler(argv)
+            .then(() => {
+                sinon.assert.calledOnce(mockAdminConnection.importIdentity);
+                sinon.assert.calledWith(mockAdminConnection.importIdentity, PROFILE_NAME, USER_ID, 'acert', 'akey');
+            });
+    });
+
+    it('should fail gracefully if importIdentity fails', () => {
+        let argv = {
+            connectionProfileName: PROFILE_NAME,
+            userId: USER_ID,
+            publicKeyFile: CERT_PATH,
+            privateKeyFile: KEY_PATH
+        };
+
+        let fsStub = sandbox.stub(fs, 'readFileSync').withArgs(CERT_PATH).returns('acert');
+        fsStub.withArgs(KEY_PATH).returns('akey');
+        mockAdminConnection.importIdentity.withArgs(PROFILE_NAME, USER_ID, 'acert', 'akey').rejects('some error');
+        return Import.handler(argv)
+            .should.be.rejectedWith(/some error/);
+    });
+
+    it('should fail gracefully if cert file cannot be found', () => {
+        let argv = {
+            connectionProfileName: PROFILE_NAME,
+            userId: USER_ID,
+            publicKeyFile: CERT_PATH,
+            privateKeyFile: KEY_PATH
+        };
+
+        let fsStub = sandbox.stub(fs, 'readFileSync').withArgs(CERT_PATH).throws(new Error('no file found'));
+        fsStub.withArgs(KEY_PATH).returns('akey');
+        mockAdminConnection.importIdentity.withArgs(PROFILE_NAME, USER_ID, 'acert', 'akey').resolves();
+        return Import.handler(argv)
+            .should.be.rejectedWith(/no file found/);
+
+    });
+
+    it('should fail gracefully if key file cannot be found', () => {
+        let argv = {
+            connectionProfileName: PROFILE_NAME,
+            userId: USER_ID,
+            publicKeyFile: CERT_PATH,
+            privateKeyFile: KEY_PATH
+        };
+
+        let fsStub = sandbox.stub(fs, 'readFileSync').withArgs(CERT_PATH).returns('acert');
+        fsStub.withArgs(KEY_PATH).throws(new Error('no key file found'));
+        mockAdminConnection.importIdentity.withArgs(PROFILE_NAME, USER_ID, 'acert', 'akey').resolves();
+        return Import.handler(argv)
+            .should.be.rejectedWith(/no key file found/);
+
+    });
+
+});

packages/composer-common/lib/connectionmanager.js

@@ -65,6 +65,20 @@ class ConnectionManager {
         return Promise.reject(new Error('abstract function called'));
     }
 
+    /**
+     * Import an identity into a profile wallet or keystore
+     *
+     * @param {object} profileDefinition the profile definition
+     * @param {string} id the id to associate with the identity
+     * @param {string} publicKey the public key
+     * @param {string} privateKey the private key
+     * @returns {Promise} a promise which resolves when the identity is imported
+     *
+     * @memberOf HLFConnectionManager
+     */
+    importIdentity(profileDefinition, id, publicKey, privateKey) {
+        return Promise.reject(new Error('Import identity not supported by this connection profile'));
+    }
     /**
      * Stop serialization of this object.
      * @return {Object} An empty object.

packages/composer-common/lib/connectionprofilemanager.js

@@ -166,7 +166,6 @@ class ConnectionProfileManager {
      * @abstract
      */
     connect(connectionProfile, businessNetworkIdentifier, additionalConnectOptions) {
-
         LOG.info('connect','Connecting using ' + connectionProfile, businessNetworkIdentifier);
 
         let connectOptions;