Merge pull request #237 from hyperledger/develop

Develop

.circleci/config.yml

@@ -0,0 +1,120 @@
+version: 2
+jobs:
+  build:
+    # must be IROHA_HOME:
+    working_directory: /opt/iroha
+    docker:
+      - image: warchantua/iroha-dev
+        environment:
+          IROHA_HOME: /opt/iroha
+          IROHA_BUILD: /tmp/build
+      - image: ubuntu:16.04
+    steps:
+      - checkout
+      - run:
+          name: ensure, required folders created
+          command: |
+            mkdir -p $IROHA_HOME
+            mkdir -p $IROHA_BUILD
+      - run:
+          name: cmake
+          command: |
+            cd $IROHA_BUILD
+            cmake $IROHA_HOME
+      - run:
+          name: make
+          command: |
+            cd $IROHA_BUILD
+            make -j2
+      - run:
+          name: run tests
+          command: |
+            TEST_FOLDER=$IROHA_BUILD/test_bin
+            total=0
+            for file in ${TEST_FOLDER}/*; do
+                # run test
+                ${file}
+                total=$((total + $?)) 
+            done
+            exit $total
+
+      # integrated into circle 2.0
+      - setup_docker_engine
+
+      ## At this step we have compiled and tested iroha. 
+      - run:
+          name: setup docker
+          command: |
+            set -ex
+            curl -L -o /tmp/docker.tgz https://get.docker.com/builds/Linux/x86_64/docker-17.03.0-ce.tgz
+            tar -xz -C /tmp -f /tmp/docker.tgz
+            mv /tmp/docker/* /usr/bin
+
+      - run:
+          name: setup docker-compose
+          command: |
+            set -ex
+            curl -L https://github.com/docker/compose/releases/download/1.11.2/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
+            chmod +x /usr/local/bin/docker-compose
+
+      - run:
+          name: build and push hyperledger/iroha-docker:$CIRCLE_BRANCH image
+          command: |
+            # replace all invalid characters to dots
+            TAG=$(echo $CIRCLE_BRANCH | sed "s/[^a-zA-Z0-9_\-\.]/./g")
+            export TAG=$TAG 
+
+            # directory, where iroha build files will reside
+            export RELEASE=$IROHA_HOME/docker/tiny/iroha
+            mkdir -p $RELEASE/lib
+            
+            # extract all libraries which use iroha:
+            LIBS=$(ldd $IROHA_BUILD/bin/iroha-main | cut -f 2 | cut -d " " -f 3)
+            
+            # copy libraries (-H = follow links)
+            cp -H $LIBS $RELEASE/lib
+            
+            # copy build artifacts
+            rsync -avr ${IROHA_BUILD}/bin ${RELEASE}
+            rsync -avr ${IROHA_HOME}/docker/tiny/scripts ${RELEASE}
+            mkdir -p ${RELEASE}/config
+            cp ${IROHA_HOME}/config/config.json ${RELEASE}/config/config.json
+            
+            # build image
+            cd $IROHA_HOME/docker/tiny
+            docker build -t hyperledger/iroha-docker:$TAG .
+            
+            # login
+            expect -c '\
+              set timeout 10
+              spawn docker login
+              expect "Username:*"
+              send -- "$env(DOCKER_USER)\r"
+              expect "Password:*"
+              send -- "$env(DOCKER_PASS)\r"
+              expect "*Login Succeeded*"'
+            
+            # and push
+            docker push hyperledger/iroha-docker:$TAG
+            
+            # clean up
+            rm -rf $RELEASE
+
+      ## At this step we have hyperledger/iroha-docker:$TAG image, we can test it now
+
+      ## you can use it by tag: 
+      ##   hyperledger/iroha-docker:$TAG
+      ## don't forget, that call docker run hyperledger/iroha-docker:$TAG is blocking. 
+      ## to make in unblocking, run with -d
+      ##
+      ## put your tests here as separate run command, here is the template:
+      #- run:
+      #    name: test name
+      #    command: |
+      #      test body (bash)
+      #      test body (bash)
+      #      don't forget to clean up after tests (if needed)
+
+
+
+

.gitignore

@@ -24,3 +24,4 @@ docker/build/iroha.tar
 cmake-build-debug/*
 external/*
 core/infra/protobuf
+docker/tiny/iroha/

README.md

@@ -19,9 +19,7 @@ Please include a developer certificate with pull requests: https://www.clahub.co
  - [Architecture](./docs/architecture.md)
  - [Build iroha in local environment](./docs/how_to_build.rst)
  - [Using docker to build iroha container](./docker/README.md)
- - [Using docker-compose to setup test network of N nodes on a single computer](./docs/docker_compose.md)
- - [Deploying a network of N nodes using docker swarm](./docs/docker_swarm.md)
- - [Deploying a network of N nodes without docker swarm](./docs/iroha_network.md)
+ - [Deploying a network of N nodes](./docs/iroha_network.md)
 
 # Authors
 
@@ -30,7 +28,7 @@ Please include a developer certificate with pull requests: https://www.clahub.co
 
 # License
 
-Copyright 2016 Soramitsu Co., Ltd.
+Copyright 2016, 2017 Soramitsu Co., Ltd.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

benchmark/crypto/CMakeLists.txt

@@ -2,10 +2,20 @@ include_directories(
   ${PROJECT_SOURCE_DIR}/core
 )
 
+# hash benchmark
 add_executable(hash_benchmark
   hash.cpp
 )
 target_link_libraries(hash_benchmark
   benchmark
   hash
 )
+
+
+# base64 benchmark
+add_executable(base64_benchmark
+  base64.cpp
+)
+target_link_libraries(base64_benchmark
+  benchmark
+)

benchmark/crypto/base64.cpp

@@ -0,0 +1,177 @@
+/**
+ * Copyright Soramitsu Co., Ltd. 2016 All Rights Reserved.
+ * http://soramitsu.co.jp
+ *
+ * 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.
+ */
+
+#include <benchmark/benchmark.h>
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <infra/crypto/base64.cpp>
+
+namespace v1 {
+    /* 
+    base64.cpp and base64.h
+
+    Copyright (C) 2004-2008 René Nyffenegger
+
+    This source code is provided 'as-is', without any express or implied
+    warranty. In no event will the author be held liable for any damages
+    arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+    1. The origin of this source code must not be misrepresented; you must not
+        claim that you wrote the original source code. If you use this source code
+        in a product, an acknowledgment in the product documentation would be
+        appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+        misrepresented as being the original source code.
+
+    3. This notice may not be removed or altered from any source distribution.
+
+    René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+  */
+
+  static const std::string base64_chars = 
+              "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+              "abcdefghijklmnopqrstuvwxyz"
+              "0123456789+/";
+
+
+  static inline bool is_base64(unsigned char c) {
+    return (isalnum(c) || (c == '+') || (c == '/'));
+  }
+
+  std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
+    std::string ret;
+    int i = 0;
+    int j = 0;
+    unsigned char char_array_3[3];
+    unsigned char char_array_4[4];
+
+    while (in_len--) {
+      char_array_3[i++] = *(bytes_to_encode++);
+      if (i == 3) {
+        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+        char_array_4[3] = char_array_3[2] & 0x3f;
+
+        for(i = 0; (i <4) ; i++)
+          ret += base64_chars[char_array_4[i]];
+        i = 0;
+      }
+    }
+
+    if (i)
+    {
+      for(j = i; j < 3; j++)
+        char_array_3[j] = '\0';
+
+      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+      char_array_4[3] = char_array_3[2] & 0x3f;
+
+      for (j = 0; (j < i + 1); j++)
+        ret += base64_chars[char_array_4[j]];
+
+      while((i++ < 3))
+        ret += '=';
+
+    }
+
+    return ret;
+
+  }
+
+  std::string base64_decode(std::string const& encoded_string) {
+    int in_len = encoded_string.size();
+    int i = 0;
+    int j = 0;
+    int in_ = 0;
+    unsigned char char_array_4[4], char_array_3[3];
+    std::string ret;
+
+    while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+      char_array_4[i++] = encoded_string[in_]; in_++;
+      if (i ==4) {
+        for (i = 0; i <4; i++)
+          char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+        for (i = 0; (i < 3); i++)
+          ret += char_array_3[i];
+        i = 0;
+      }
+    }
+
+    if (i) {
+      for (j = i; j <4; j++)
+        char_array_4[j] = 0;
+
+      for (j = 0; j <4; j++)
+        char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
+    }
+
+    return ret;
+  }
+} // namespace v1
+
+
+
+static std::vector<unsigned char> generate_sequence(size_t size){
+  std::vector<unsigned char> v(size);
+  unsigned int seed = 0;
+  for(int i=0; i<v[i]; i++){
+    v[i] = rand_r(&seed) & 0xFF;
+  }
+  return v;
+}
+
+#define MIN_SIZE (1 << 5)
+#define MAX_SIZE (1 << 10)
+
+static const std::vector<unsigned char> data = generate_sequence(MAX_SIZE);
+
+static void base64_v1_encode(benchmark::State& state) {
+  while (state.KeepRunning()) {
+    v1::base64_encode(data.data(), state.range(0));
+  }
+}
+
+static void base64_iroha_encode(benchmark::State& state) {
+  while (state.KeepRunning()) {
+    base64::vendor::base64_encode(data.data(), state.range(0));
+  }
+}
+
+BENCHMARK(base64_iroha_encode)->Range(MIN_SIZE, MAX_SIZE);
+BENCHMARK(base64_v1_encode)->Range(MIN_SIZE, MAX_SIZE);
+BENCHMARK_MAIN();