diff options
Diffstat (limited to 'libtransport/src/hicn')
9 files changed, 270 insertions, 42 deletions
diff --git a/libtransport/src/hicn/transport/core/manifest.h b/libtransport/src/hicn/transport/core/manifest.h index 9f7dc5984..9650de94d 100644 --- a/libtransport/src/hicn/transport/core/manifest.h +++ b/libtransport/src/hicn/transport/core/manifest.h @@ -85,6 +85,10 @@ class Manifest : public Base { return Encoder::getManifestHeaderSize(); } + static std::size_t getManifestEntrySize() { + return Encoder::getManifestEntrySize(); + } + Manifest &setManifestType(ManifestType type) { manifest_type_ = type; encoder_.setManifestType(manifest_type_); @@ -142,4 +146,4 @@ class Manifest : public Base { } // end namespace core -} // end namespace transport
\ No newline at end of file +} // end namespace transport diff --git a/libtransport/src/hicn/transport/core/manifest_format.h b/libtransport/src/hicn/transport/core/manifest_format.h index 00782f14d..451e3db6a 100644 --- a/libtransport/src/hicn/transport/core/manifest_format.h +++ b/libtransport/src/hicn/transport/core/manifest_format.h @@ -135,6 +135,10 @@ class ManifestEncoder { static std::size_t getManifestHeaderSize() { return Implementation::getManifestHeaderSizeImpl(); } + + static std::size_t getManifestEntrySize() { + return Implementation::getManifestEntrySizeImpl(); + } }; template <typename Implementation> @@ -193,4 +197,4 @@ class ManifestDecoder { } // namespace core -} // namespace transport
\ No newline at end of file +} // namespace transport diff --git a/libtransport/src/hicn/transport/core/manifest_format_fixed.cc b/libtransport/src/hicn/transport/core/manifest_format_fixed.cc index b97aa7079..f5e31d784 100644 --- a/libtransport/src/hicn/transport/core/manifest_format_fixed.cc +++ b/libtransport/src/hicn/transport/core/manifest_format_fixed.cc @@ -140,6 +140,10 @@ std::size_t FixedManifestEncoder::getManifestHeaderSizeImpl() { return sizeof(ManifestHeader); } +std::size_t FixedManifestEncoder::getManifestEntrySizeImpl() { + return sizeof(ManifestEntry); +} + FixedManifestDecoder::FixedManifestDecoder(Packet &packet) : packet_(packet), manifest_header_(reinterpret_cast<ManifestHeader *>( @@ -219,4 +223,4 @@ uint32_t FixedManifestDecoder::getFinalBlockNumberImpl() const { } // end namespace core -} // end namespace transport
\ No newline at end of file +} // end namespace transport diff --git a/libtransport/src/hicn/transport/core/manifest_format_fixed.h b/libtransport/src/hicn/transport/core/manifest_format_fixed.h index c9bc3f8e5..2c6e2bced 100644 --- a/libtransport/src/hicn/transport/core/manifest_format_fixed.h +++ b/libtransport/src/hicn/transport/core/manifest_format_fixed.h @@ -116,6 +116,8 @@ class FixedManifestEncoder : public ManifestEncoder<FixedManifestEncoder> { static std::size_t getManifestHeaderSizeImpl(); + static std::size_t getManifestEntrySizeImpl(); + private: void addSuffixHashBytes(uint32_t suffix, const uint8_t *hash, std::size_t length); @@ -166,4 +168,4 @@ class FixedManifestDecoder : public ManifestDecoder<FixedManifestDecoder> { } // namespace core -} // namespace transport
\ No newline at end of file +} // namespace transport diff --git a/libtransport/src/hicn/transport/interfaces/socket_producer.cc b/libtransport/src/hicn/transport/interfaces/socket_producer.cc index 8f8fc1a79..5cf40cd1c 100644 --- a/libtransport/src/hicn/transport/interfaces/socket_producer.cc +++ b/libtransport/src/hicn/transport/interfaces/socket_producer.cc @@ -38,6 +38,8 @@ ProducerSocket::ProducerSocket(asio::io_service &io_service) registration_status_(REGISTRATION_NOT_ATTEMPTED), making_manifest_(false), hash_algorithm_(HashAlgorithm::SHA_256), + suffix_manifest_(core::NextSegmentCalculationStrategy::INCREMENTAL, 0), + suffix_content_(core::NextSegmentCalculationStrategy::INCREMENTAL, 0), on_interest_input_(VOID_HANDLER), on_interest_dropped_input_buffer_(VOID_HANDLER), on_interest_inserted_input_buffer_(VOID_HANDLER), @@ -151,33 +153,32 @@ uint32_t ProducerSocket::produce(Name content_name, return 0; } - // Copy the atomic variable to ensure always the same value during the a - // production + // Copy the atomic variables to ensure they keep the same value + // during the production std::size_t data_packet_size = data_packet_size_; uint32_t content_object_expiry_time = content_object_expiry_time_; - HashAlgorithm algo = hash_algorithm_; + HashAlgorithm hash_algo = hash_algorithm_; bool making_manifest = making_manifest_; + utils::SuffixContent suffix_content = suffix_content_; + utils::SuffixManifest suffix_manifest = suffix_manifest_; std::shared_ptr<utils::Identity> identity; getSocketOption(GeneralTransportOptions::IDENTITY, identity); auto buffer_size = buffer->length(); - const std::size_t hash_size = 32; - int bytes_segmented = 0; std::size_t header_size; std::size_t manifest_header_size = 0; std::size_t signature_length = 0; std::uint32_t final_block_number = 0; - uint64_t free_space_for_content = 0; core::Packet::Format format; - - uint32_t current_segment = start_offset; std::shared_ptr<ContentObjectManifest> manifest; bool is_last_manifest = false; std::unique_ptr<utils::CryptoHash> zero_hash; + suffix_content.updateSuffix(start_offset); + suffix_content.setUsingManifest(making_manifest); // TODO Manifest may still be used for indexing if (making_manifest && !identity) { @@ -210,35 +211,37 @@ uint32_t ProducerSocket::produce(Name content_name, } header_size = core::Packet::getHeaderSizeFromFormat(format, signature_length); - free_space_for_content = data_packet_size - header_size; - uint32_t number_of_segments = uint32_t(std::ceil(double(buffer_size) / double(free_space_for_content))); - if (free_space_for_content * number_of_segments < buffer_size) { number_of_segments++; } // TODO allocate space for all the headers - if (making_manifest) { - auto segment_in_manifest = static_cast<float>( + uint32_t segment_in_manifest = static_cast<uint32_t>( std::floor(double(data_packet_size - manifest_header_size - ContentObjectManifest::getManifestHeaderSize()) / - (4.0 + 32.0)) - + ContentObjectManifest::getManifestEntrySize()) - 1.0); - auto number_of_manifests = static_cast<uint32_t>( + uint32_t number_of_manifests = static_cast<uint32_t>( std::ceil(float(number_of_segments) / segment_in_manifest)); final_block_number = number_of_segments + number_of_manifests - 1; + suffix_manifest.updateSuffix(start_offset); + suffix_manifest.setNbSegments(segment_in_manifest); + suffix_content.updateSuffix(start_offset + 1); + suffix_content.setNbSegments(segment_in_manifest); + manifest.reset(ContentObjectManifest::createManifest( - content_name.setSuffix(current_segment++), + content_name.setSuffix(suffix_manifest.getSuffix()), core::ManifestVersion::VERSION_1, core::ManifestType::INLINE_MANIFEST, - hash_algorithm_, is_last_manifest, content_name, + hash_algo, is_last_manifest, content_name, core::NextSegmentCalculationStrategy::INCREMENTAL, identity->getSignatureLength())); manifest->setLifetime(content_object_expiry_time); + suffix_manifest++; if (is_last) { manifest->setFinalBlockNumber(final_block_number); @@ -249,7 +252,7 @@ uint32_t ProducerSocket::produce(Name content_name, uint8_t hash[hash_size]; std::memset(hash, 0, hash_size); zero_hash = std::make_unique<utils::CryptoHash>( - hash, hash_size, static_cast<utils::CryptoHashType>(algo)); + hash, hash_size, static_cast<utils::CryptoHashType>(hash_algo)); } for (unsigned int packaged_segments = 0; @@ -258,42 +261,41 @@ uint32_t ProducerSocket::produce(Name content_name, if (manifest->estimateManifestSize(2) > data_packet_size - manifest_header_size) { // Add next manifest - manifest->addSuffixHash(current_segment, *zero_hash); - + manifest->addSuffixHash(suffix_manifest.getSuffix(), *zero_hash); // Send the current manifest manifest->encode(); - identity->getSigner().sign(*manifest); - passContentObjectToCallbacks(manifest); // Create new manifest. The reference to the last manifest has been // acquired in the passContentObjectToCallbacks function, so we can // safely release this reference manifest.reset(ContentObjectManifest::createManifest( - content_name.setSuffix(current_segment), + content_name.setSuffix(suffix_manifest.getSuffix()), core::ManifestVersion::VERSION_1, - core::ManifestType::INLINE_MANIFEST, hash_algorithm_, - is_last_manifest, content_name, - core::NextSegmentCalculationStrategy::INCREMENTAL, + core::ManifestType::INLINE_MANIFEST, hash_algo, is_last_manifest, + content_name, core::NextSegmentCalculationStrategy::INCREMENTAL, identity->getSignatureLength())); manifest->setLifetime(content_object_expiry_time); + if (is_last) { manifest->setFinalBlockNumber(final_block_number); } else { manifest->setFinalBlockNumber(std::numeric_limits<uint32_t>::max()); } - current_segment++; + + suffix_manifest++; } } auto content_object = std::make_shared<ContentObject>( - content_name.setSuffix(current_segment), format); + content_name.setSuffix(suffix_content.getSuffix()), format); content_object->setLifetime(content_object_expiry_time); auto b = buffer->cloneOne(); b->trimStart(free_space_for_content * packaged_segments); b->trimEnd(b->length()); + if (TRANSPORT_EXPECT_FALSE(packaged_segments == number_of_segments - 1)) { b->append(buffer_size - bytes_segmented); bytes_segmented += (int)(buffer_size - bytes_segmented); @@ -313,14 +315,14 @@ uint32_t ProducerSocket::produce(Name content_name, if (making_manifest) { using namespace std::chrono_literals; - utils::CryptoHash hash = content_object->computeDigest(hash_algorithm_); - manifest->addSuffixHash(current_segment, hash); + utils::CryptoHash hash = content_object->computeDigest(hash_algo); + manifest->addSuffixHash(suffix_content.getSuffix(), hash); } else if (identity) { identity->getSigner().sign(*content_object); } - current_segment++; passContentObjectToCallbacks(content_object); + suffix_content++; } if (making_manifest) { @@ -329,7 +331,7 @@ uint32_t ProducerSocket::produce(Name content_name, } if (!is_last) { - manifest->addSuffixHash(current_segment, *zero_hash); + manifest->addSuffixHash(suffix_content.getSuffix(), *zero_hash); } manifest->encode(); @@ -344,7 +346,7 @@ uint32_t ProducerSocket::produce(Name content_name, }); } - return current_segment - start_offset; + return suffix_content.getSuffix() - start_offset; } void ProducerSocket::asyncProduce(ContentObject &content_object) { @@ -880,4 +882,4 @@ asio::io_service &ProducerSocket::getIoService() { return io_service_; } } // namespace interface -} // end namespace transport
\ No newline at end of file +} // end namespace transport diff --git a/libtransport/src/hicn/transport/interfaces/socket_producer.h b/libtransport/src/hicn/transport/interfaces/socket_producer.h index 709a2582b..952587b70 100644 --- a/libtransport/src/hicn/transport/interfaces/socket_producer.h +++ b/libtransport/src/hicn/transport/interfaces/socket_producer.h @@ -18,6 +18,7 @@ #include <hicn/transport/interfaces/socket.h> #include <hicn/transport/utils/content_store.h> #include <hicn/transport/utils/event_thread.h> +#include <hicn/transport/utils/suffix_strategy.h> #include <atomic> #include <cmath> @@ -190,6 +191,8 @@ class ProducerSocket : public Socket<BasePortal>, std::atomic<utils::CryptoSuite> crypto_suite_; utils::SpinLock identity_lock_; std::shared_ptr<utils::Identity> identity_; + utils::SuffixManifest suffix_manifest_; + utils::SuffixContent suffix_content_; // callbacks ProducerInterestCallback on_interest_input_; @@ -220,8 +223,8 @@ class ProducerSocket : public Socket<BasePortal>, /* Condition variable for the wait */ std::condition_variable cv; bool done = false; - io_service_.dispatch([&socket_option_key, &socket_option_value, - &mtx, &cv, &result, &done, &func]() { + io_service_.dispatch([&socket_option_key, &socket_option_value, &mtx, &cv, + &result, &done, &func]() { std::unique_lock<std::mutex> lck(mtx); done = true; result = func(socket_option_key, socket_option_value); @@ -247,4 +250,4 @@ class ProducerSocket : public Socket<BasePortal>, } // namespace interface -} // namespace transport
\ No newline at end of file +} // namespace transport diff --git a/libtransport/src/hicn/transport/utils/CMakeLists.txt b/libtransport/src/hicn/transport/utils/CMakeLists.txt index 4ce1e537f..cbbca86ed 100644 --- a/libtransport/src/hicn/transport/utils/CMakeLists.txt +++ b/libtransport/src/hicn/transport/utils/CMakeLists.txt @@ -19,6 +19,7 @@ list(APPEND SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/signer.cc ${CMAKE_CURRENT_SOURCE_DIR}/verifier.cc ${CMAKE_CURRENT_SOURCE_DIR}/identity.cc + ${CMAKE_CURRENT_SOURCE_DIR}/suffix_strategy.cc ${CMAKE_CURRENT_SOURCE_DIR}/log.cc ${CMAKE_CURRENT_SOURCE_DIR}/membuf.cc ${CMAKE_CURRENT_SOURCE_DIR}/content_store.cc @@ -46,6 +47,7 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/crypto_hash.h ${CMAKE_CURRENT_SOURCE_DIR}/crypto_hash_type.h ${CMAKE_CURRENT_SOURCE_DIR}/identity.h + ${CMAKE_CURRENT_SOURCE_DIR}/suffix_strategy.h ${CMAKE_CURRENT_SOURCE_DIR}/conversions.h ${CMAKE_CURRENT_SOURCE_DIR}/linux.h ${CMAKE_CURRENT_SOURCE_DIR}/log.h @@ -78,4 +80,4 @@ if(NOT WIN32) endif() set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE) -set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
\ No newline at end of file +set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE) diff --git a/libtransport/src/hicn/transport/utils/suffix_strategy.cc b/libtransport/src/hicn/transport/utils/suffix_strategy.cc new file mode 100644 index 000000000..f3bcc4562 --- /dev/null +++ b/libtransport/src/hicn/transport/utils/suffix_strategy.cc @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2017-2019 Cisco and/or its affiliates. + * 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 <hicn/transport/utils/suffix_strategy.h> + +using transport::core::NextSegmentCalculationStrategy; + +namespace utils { +std::uint32_t SuffixManifest::getNextSuffix() { + uint32_t next_suffix; + + switch (suffix_stragegy_) { + case NextSegmentCalculationStrategy::INCREMENTAL: + if (!nb_segments_) { + throw errors::RuntimeException( + "The number of segments in a manifest must be set " + "before assigning incremental suffixes."); + } + /* The current manifest's suffix + the number of segments in a */ + /* manifest give the suffix of the last segment in the manifest. */ + /* The next manifest's suffix is therefore that number plus one. */ + next_suffix = suffix_ + nb_segments_ + 1; + break; + + default: + throw errors::RuntimeException("Unknown suffix strategy."); + } + + return next_suffix; +} + +std::uint32_t SuffixContent::getNextSuffix() { + uint32_t next_suffix; + + switch (suffix_stragegy_) { + case NextSegmentCalculationStrategy::INCREMENTAL: + next_suffix = suffix_ + 1; + if (making_manifest_) { + if (!nb_segments_) { + throw errors::RuntimeException( + "The number of segments in a manifest must be set " + "before assigning incremental suffixes."); + } + + content_counter_++; + /* If the counter have reached the manifest's capacity, + * it means that the next suffix will be a manifest, so we skip it. */ + if (content_counter_ % nb_segments_ == 0) { + next_suffix++; + content_counter_ = 0; + } + } + break; + + default: + throw errors::RuntimeException("Unknown suffix strategy."); + } + + return next_suffix; +} +} // namespace utils diff --git a/libtransport/src/hicn/transport/utils/suffix_strategy.h b/libtransport/src/hicn/transport/utils/suffix_strategy.h new file mode 100644 index 000000000..99e557380 --- /dev/null +++ b/libtransport/src/hicn/transport/utils/suffix_strategy.h @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2017-2019 Cisco and/or its affiliates. + * 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. + */ + +#pragma once + +#include <hicn/transport/core/manifest_format.h> + +namespace utils { +class SuffixStrategy { + public: + SuffixStrategy( + transport::core::NextSegmentCalculationStrategy suffix_stragegy, + std::uint32_t start_offset) + : suffix_stragegy_(suffix_stragegy), + suffix_(start_offset), + nb_segments_(0) {} + + transport::core::NextSegmentCalculationStrategy getSuffixStrategy() { + return suffix_stragegy_; + } + + std::uint32_t getSuffix() { return suffix_; } + + virtual std::uint32_t getNextSuffix() = 0; + + void updateSuffix(std::uint32_t new_suffix) { suffix_ = new_suffix; } + + std::size_t getNbSegments() { return nb_segments_; } + + void setNbSegments(std::size_t nb_segments) { nb_segments_ = nb_segments; } + + void reset(std::uint32_t reset_suffix) { + suffix_ = reset_suffix; + nb_segments_ = 0; + } + + ~SuffixStrategy() {} + + protected: + transport::core::NextSegmentCalculationStrategy suffix_stragegy_; + std::uint32_t suffix_; + std::size_t nb_segments_; +}; + +class SuffixManifest : public SuffixStrategy { + public: + SuffixManifest( + transport::core::NextSegmentCalculationStrategy suffix_stragegy, + std::uint32_t start_offset) + : SuffixStrategy(suffix_stragegy, start_offset) {} + + std::uint32_t getNextSuffix(); + + SuffixManifest operator++() { + uint32_t next_suffix = getNextSuffix(); + updateSuffix(next_suffix); + return SuffixManifest(suffix_stragegy_, next_suffix); + } + + SuffixManifest operator++(int) { + SuffixManifest temp_suffix(suffix_stragegy_, suffix_); + uint32_t next_suffix = getNextSuffix(); + updateSuffix(next_suffix); + return temp_suffix; + } + + SuffixManifest operator+(uint32_t shift) { + for (uint32_t i = 0; i < shift; i++) { + updateSuffix(getNextSuffix()); + } + return SuffixManifest(suffix_stragegy_, getSuffix()); + } +}; + +class SuffixContent : public SuffixStrategy { + public: + SuffixContent(transport::core::NextSegmentCalculationStrategy suffix_stragegy, + std::uint32_t start_offset, bool making_manifest) + : SuffixStrategy(suffix_stragegy, start_offset), + making_manifest_(making_manifest), + content_counter_(0) {} + + SuffixContent(transport::core::NextSegmentCalculationStrategy suffix_stragegy, + std::uint32_t start_offset) + : SuffixContent(suffix_stragegy, start_offset, false) {} + + std::uint32_t getNextSuffix(); + + SuffixContent operator++() { + uint32_t next_suffix = getNextSuffix(); + updateSuffix(next_suffix); + return SuffixContent(suffix_stragegy_, next_suffix, making_manifest_); + } + + SuffixContent operator++(int) { + SuffixContent temp_suffix(suffix_stragegy_, suffix_, making_manifest_); + uint32_t next_suffix = getNextSuffix(); + updateSuffix(next_suffix); + return temp_suffix; + } + + SuffixContent operator+(uint32_t shift) { + for (uint32_t i = 0; i < shift; i++) { + updateSuffix(getNextSuffix()); + } + return SuffixContent(suffix_stragegy_, getSuffix(), making_manifest_); + } + + void setUsingManifest(bool value) { making_manifest_ = value; } + + void reset(std::uint32_t reset_suffix) { + SuffixStrategy::reset(reset_suffix); + content_counter_ = 0; + } + + protected: + bool making_manifest_; + /* content_counter_ keeps track of the number of segments */ + /* between two manifests */ + uint32_t content_counter_; +}; +} // namespace utils |