void serialize_certificate(Archive& archive, Connection & connection, std::set<boost::uint32_t>& localities, parcel const& p) { // We send the certificate corresponding to the originating locality // of the parcel if this is the first message over this connection // or if the originating locality is not the current one. boost::uint32_t locality_id = naming::get_locality_id_from_gid(p.get_parcel_id()); error_code ec(lightweight); boost::uint32_t this_locality_id = get_locality_id(ec); if (ec) { // this should only happen during bootstrap HPX_ASSERT(hpx::is_starting()); this_locality_id = locality_id; } bool has_certificate = false; if ((connection.first_message_ || locality_id != this_locality_id) && localities.find(locality_id) == localities.end()) { // the first message must originate from this locality HPX_ASSERT(!connection.first_message_ || locality_id == this_locality_id); components::security::signed_certificate const& certificate = hpx::get_locality_certificate(locality_id, ec); if (!ec) { has_certificate = true; if (locality_id == this_locality_id) connection.first_message_ = false; archive << has_certificate << certificate; // keep track of all certificates already prepended for this message localities.insert(locality_id); } else { // if the certificate is not available we have to still be on // the 'first' message (it's too early for a certificate) HPX_ASSERT(connection.first_message_); archive << has_certificate; } } else { archive << has_certificate; } }
void parcelport::put_parcel(parcel const& p, write_handler_type const& f) { typedef pending_parcels_map::iterator iterator; typedef pending_parcels_map::mapped_type mapped_type; naming::locality locality_id = p.get_destination_locality(); naming::gid_type parcel_id = p.get_parcel_id(); // enqueue the incoming parcel ... { lcos::local::spinlock::scoped_lock l(mtx_); mapped_type& e = pending_parcels_[locality_id]; e.first.push_back(p); e.second.push_back(f); } get_connection_and_send_parcels(locality_id, parcel_id); }
boost::shared_ptr<parcel_buffer_type> get_buffer(parcel const & p, std::size_t arg_size) { // generate the name for this data_buffer std::string data_buffer_name(p.get_parcel_id().to_string()); if(!buffer_) { // clear and preallocate out_buffer_ (or fetch from cache) buffer_ = boost::make_shared<parcel_buffer_type>( get_data_buffer((arg_size * 12) / 10 + 1024, data_buffer_name) ); } else { buffer_->data_ = get_data_buffer((arg_size * 12) / 10 + 1024, data_buffer_name); } return buffer_; }
void parcelhandler::put_parcel(parcel& p, write_handler_type f) { // properly initialize parcel init_parcel(p); std::vector<naming::gid_type> const& gids = p.get_destinations(); std::vector<naming::address>& addrs = p.get_destination_addrs(); if (1 == gids.size()) { if (!addrs[0]) resolver_.resolve(gids[0], addrs[0]); } else { boost::dynamic_bitset<> locals; resolver_.resolve(gids, addrs, locals); } if (!p.get_parcel_id()) p.set_parcel_id(parcel::generate_unique_id()); pp_.put_parcel(p, f); }
bool add_parcel(parcel const& p) { naming::gid_type id(p.get_parcel_id()); // Add parcel to queue. { mutex_type::scoped_lock l(mtx_); std::pair<parcel_map_type::iterator, bool> ret = parcels_.insert(parcel_map_type::value_type(id, p)); if (!ret.second) { HPX_THROW_EXCEPTION(bad_parameter, "global_parcelhandler_queue::add_parcel", "Could not add received parcel to the parcelhandler " "queue"); return false; } } // do some work (notify event handlers) HPX_ASSERT(ph_ != 0); notify_(*ph_, id); return true; }