string gen_uuid() { ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance()->generate_UUID(uuid); return uuid.to_string()->c_str(); }
uint64 gen_uuid_hash() { ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance()->generate_UUID(uuid); return uuid.hash(); }
// // handle_data // void Console_Printer_DataSubscriber_i:: handle_data (const OASIS::SubscriberDataPacket & packet) { ACE_Utils::UUID einode; packet.einode >>= einode; std::cout << "received " << packet.data.length () << " bytes of data from " << *einode.to_string () << std::endl; }
// // insert // void Metametrics_Table:: insert (const ACE_Utils::UUID & uuid, const char * name, int version_major, int version_minor, const char * schema) { // First, let's make sure the typename is already in the database. this->insert_typename (name); // Now, let's insert the metametrics into the database. static const char * __sqlstr__ = "INSERT INTO oasis_metametrics " "(uuid, name, version_major, version_minor, schema) " "VALUES (?, (SELECT typeid FROM oasis_typenames WHERE typename = ?), ?, ?, ?)"; ADBC::SQLite::Query q (this->db_.get_connection ()); q.prepare (__sqlstr__); using ::ADBC::SQLite::Parameter_List; Parameter_List & params = q.parameters (); params[0].bind (uuid.to_string ()->c_str (), -1); params[1].bind (name, -1); params[2].bind (&version_major); params[3].bind (&version_minor); params[4].bind (schema, -1); // Execute the query. q.execute_no_record (); }
RPS_Monitor::RPS_Monitor (ServerRequestInterceptor * interceptor) : location_ (1), interceptor_ (interceptor), last_time_ (ACE_OS::gettimeofday ()), lock_ () { this->location_.length (1); ACE_Utils::UUID_GENERATOR::instance ()->init (); ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); this->location_[0].id = CORBA::string_dup (uuid.to_string ()->c_str ()); this->location_[0].kind = CORBA::string_dup ("UUID"); }
void Gate:: init (ConsumerAdmin_ptr consumer_admin, SupplierAdmin_ptr supplier_admin) { // Generate unique id. It is used to prevent event looping. // ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->init (); ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); id_ = string_alloc (ACE_Utils::truncate_cast<CORBA::ULong> ( uuid.to_string ()->length () + 2)); ACE_OS::strcpy (id_.inout (), "_"); ACE_OS::strcpy (id_.inout () + 1, uuid.to_string ()->rep ()); // ACE_DEBUG ((LM_DEBUG, "ID: %s\n", id_.in ())); // Obtain proxy consumer. // ProxyConsumer_var pc ( supplier_admin->obtain_notification_push_consumer ( STRUCTURED_EVENT, consumer_id_)); consumer_ = StructuredProxyPushConsumer::_narrow (pc.in ()); consumer_->connect_structured_push_supplier ( StructuredPushSupplier::_nil ()); // Register as consumer. // StructuredPushConsumer_var ref (_this ()); // Activate on default POA. ProxySupplier_var ps ( consumer_admin->obtain_notification_push_supplier ( STRUCTURED_EVENT, supplier_id_)); supplier_ = StructuredProxyPushSupplier::_narrow (ps.in ()); supplier_->connect_structured_push_consumer (ref.in ()); // Create tracker thread. // thread_mgr_.spawn (tracker_thunk, this); }
ACE_TCHAR * ACE::HTBP::ID_Requestor::get_HTID () { if (ACE::HTBP::ID_Requestor::htid_.length() != 0) return ACE::HTBP::ID_Requestor::htid_.rep(); ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, ACE::HTBP::ID_Requestor::htid_lock_, 0); if (ACE::HTBP::ID_Requestor::htid_.length() != 0) return ACE::HTBP::ID_Requestor::htid_.rep(); ACE_SOCK_Stream cli_stream; ACE_TCHAR * htid = 0; if (this->url_.length() == 0 || this->connect_to_server (&cli_stream) == -1 || this->send_request (&cli_stream) == -1) { ACE_Utils::UUID_Generator gen; ACE_Utils::UUID *uuid = gen.generate_UUID (); const ACE_CString *uuidstr = uuid->to_string(); ACE::HTBP::ID_Requestor::htid_ = ACE_TEXT_CHAR_TO_TCHAR (uuidstr->c_str()); delete uuid; return ACE::HTBP::ID_Requestor::htid_.rep(); } iovec recv_buf; ssize_t result = cli_stream.recvv (&recv_buf); cli_stream.close(); if (result > 0) { ACE_CString answer ((char *)recv_buf.iov_base,recv_buf.iov_len); ACE_CString::size_type start = answer.rfind (ACE_TEXT('\n')); if (start == ACE_CString::npos) start = 0; else start++; ACE::HTBP::ID_Requestor::htid_ = ACE_TEXT_CHAR_TO_TCHAR(answer.substr (start).c_str()); htid = ACE::HTBP::ID_Requestor::htid_.rep(); } return htid; }
void ErrorTraceHelper::log(ACE_Log_Priority priorty) { unsigned int i=0; ACSErr::ErrorTrace *c = m_errorTracePtr; char uuidBuf[40]; ACE_Utils::UUID* uuid = ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (); snprintf(uuidBuf, 40, "%s", uuid->to_string()->c_str()); delete uuid; if (!m_depth) return; while (c->previousError.length()!=0){ i++; log (c, m_depth-i, uuidBuf, priorty); c = &c->previousError[0]; } i++; log (c, m_depth-i, uuidBuf, priorty); }//log
void Locality_Splitter::finalize_sub_plan ( Deployment::DeploymentPlan &sub_plan, KEY &sub_plan_key) { DANCEX11_LOG_TRACE ("Locality_Splitter::finalize_sub_plan"); // check for availability of LocalityManager instance if (!sub_plan_key.has_locality_manager ()) { // add minimal default LocalityManager instance to sub plan uint32_t impl_index = sub_plan.implementation ().size (); sub_plan.implementation ().push_back (::Deployment::MonolithicDeploymentDescription ()); uint32_t inst_index = sub_plan.instance ().size (); sub_plan.instance ().push_back (::Deployment::InstanceDeploymentDescription ()); sub_plan.instance ().back ().implementationRef (impl_index); // set correct implementation type Deployment::Property exec_property; exec_property.name (IMPL_TYPE); exec_property.value () <<= DANCE_LOCALITYMANAGER; sub_plan.implementation ().back ().execParameter ().push_back (exec_property); // create unique name for Locality Manager ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); std::string lm_name ("Locality Manager ["); lm_name += uuid.to_string ()->c_str (); lm_name += "]"; sub_plan.instance ().back ().name (lm_name); DANCEX11_LOG_TRACE ("Locality_Splitter::finalize_sub_plan - " << "No locality manager found, created a default locality named<" << sub_plan.instance ().back ().name () << ">"); // add instance to sub plan key sub_plan_key.add_instance (inst_index); // mark as locality manager sub_plan_key.locality_manager_instance ( sub_plan_key.instances ().size () - 1); } }
ReplicaController:: ReplicaController (CORBA::ORB_ptr orb) : orb_ (CORBA::ORB::_duplicate (orb)) { try { CORBA::Object_var poa_object = orb_->resolve_initial_references ("RootPOA"); root_poa_ = PortableServer::POA::_narrow ( poa_object.in ()); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); ACE_OS::abort (); } // Generate member id ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->init (); ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); ACE_INET_Addr address (10000, "239.255.0.1"); ACE_DEBUG ((LM_DEBUG, "Becoming a member with id %s\n", uuid.to_string ()->c_str ())); ACE_auto_ptr_reset (group_, new ACE_TMCast::Group (address, uuid.to_string ()->c_str ())); int r = ACE_Thread_Manager::instance ()->spawn ( &ReplicaController::listener_thunk, this); if (r < 0) { orb_->shutdown (0); } }
::Stock::Cookie * StockDistributor_i::subscribe_notifier (::Stock::StockNameConsumer_ptr c, ::RTCORBA::Priority priority) { // Get mutual exclusion of the <subscribers_list_>. ACE_WRITE_GUARD_RETURN (ACE_RW_Thread_Mutex, g, lock_, 0); // Generate a unique id for the cookie. ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); // Create a new cookie object; initialize its value. Stock::Cookie_var cookie = new OBV_Stock::Cookie (); cookie->cookie_id (uuid.to_string ()->c_str ()); // Insert the cookie into the <subscribers_list_>. this->subscribers_list_[cookie->cookie_id ()] = std::make_pair (Stock::StockNameConsumer::_duplicate (c), priority); ACE_DEBUG ((LM_DEBUG, "Subscribing %s\n", cookie->cookie_id ())); return cookie._retn(); }
// // get_next // CORBA::Boolean CUTS_TestArchiveBrowser_i:: get_next (CUTS::TestProfiles_out profiles) { try { // Execute the prepared query. ADBC::Record & record = this->query_->execute (); // Count the number of record returned. size_t count = 0; for (; !record.done (); record.advance ()) ++ count; // Reset the cursor of the record. record.reset (); if (count) { // Allocate a new sequence for the profiles. ACE_NEW_THROW_EX (profiles, CUTS::TestProfiles (count), CORBA::NO_MEMORY ()); profiles->length (count); char name[256]; char uuid_str[37]; ACE_Utils::UUID uuid; int index = 0; // Copy each of test profile to the sequence. for ( ; !record.done (); record.advance ()) { record.get_data (2, name, sizeof (name)); record.get_data (3, uuid_str, sizeof (uuid_str)); // Conver the UUID from string format. uuid.from_string (uuid_str); // Save the profile in the collection. (*profiles)[index].uuid <<= uuid; (*profiles)[index].name = CORBA::string_dup (name); // Increment the index. ++ index; } // Increment the index count. this->index_ += count; } this->is_done_ = record.done (); return this->is_done_; } catch (const ADBC::Exception & ex) { ACE_ERROR ((LM_ERROR, "%T (%t) - %M - %s\n", ex.message ().c_str ())); throw CUTS::OperationFailed (); } }
MonolithicDeploymentDescription MDD_Handler::mono_deployment_description( const Deployment::MonolithicDeploymentDescription &src) { DANCE_TRACE("mono_deployment_description - reverse"); //Get the name and instantiate the mdd XMLSchema::string < ACE_TCHAR > name ( ACE_TEXT_CHAR_TO_TCHAR (src.name)); MonolithicDeploymentDescription mdd (name); //Get the source(s) from the IDL and store them size_t total = src.source.length(); for(size_t i = 0; i < total; i++) { XMLSchema::string< ACE_TCHAR > curr ( ACE_TEXT_CHAR_TO_TCHAR(src.source[i])); //mdd.add_source(curr); } //Get the artifactRef(s) from the IDL and store them total = src.artifactRef.length(); for(size_t j = 0; j < total; j++) { ACE_TString tmp; ADD_Handler::IDREF.find_ref(src.artifactRef[j], tmp); IdRef idref; idref.idref (tmp.c_str ()); //mdd.add_artifact (idref); } //Get the execParameter(s) from the IDL and store them total = src.execParameter.length(); for(size_t k = 0; k < total; k++) { //mdd.add_execParameter (Property_Handler:: //get_property (src.execParameter[k])); } //Get the deployRequirement(s) from the IDL and store them total = src.deployRequirement.length(); for(size_t l = 0; l < total; l++) { //mdd.add_deployRequirement(Req_Handler:: //get_requirement (src.deployRequirement[l])); } // Generate a UUID to use for the IDREF. ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); ACE_TString mdd_id (ACE_TEXT ("_")); mdd_id += ACE_TEXT_CHAR_TO_TCHAR (uuid.to_string ()->c_str ()); XMLSchema::ID< ACE_TCHAR > xml_id (mdd_id.c_str ()); // Bind the ref and set it in the IDD MDD_Handler::IDREF.bind_next_available (mdd_id); mdd.id (xml_id); return mdd; }