DDS_ReturnCode_t DDS_StringDataWriter_write (DDS_DataWriter dw, const char *data, const DDS_InstanceHandle_t h) { DDS_String s; s.value = (char *) data; return (DDS_DataWriter_write (dw, &s, h)); }
void DDS_Security_log (unsigned log_level, const char *message, const char *category) { struct timeval tv; FILE *f; struct tm tm_data, *tm; char tmbuf [40]; DDS_LogInfo log_info; if (!log_options_set || log_level < log_options.log_level) return; if (!log_options.log_file && !log_options.distribute) { log_printf (SEC_ID, log_level, "%s: %s\r\n", category, message); return; } if (log_options.log_file) { if (openf (f, logname, "a")) { gettimeofday (&tv, NULL); #ifdef _WIN32 _localtime32_s (&tm_data, &tv.tv_sec); tm = &tm_data; #else tm = localtime_r (&tv.tv_sec, &tm_data); if (!tm) { #ifdef LOG_DATE fprintf (f, "\?\?\?\?-\?\?\?-\?\? "); #endif fprintf (f, "\?\?:\?\?:\?\?.\?\?\? "); } else #endif { tmbuf [0] = '\0'; #ifdef LOG_DATE strftime (tmbuf, sizeof (tmbuf), "%Y-%m-%d ", tm); #endif strftime (&tmbuf [strlen (tmbuf)], sizeof (tmbuf) - strlen (tmbuf), "%H:%M:%S.", tm); snprintf (&tmbuf [strlen (tmbuf)], sizeof (tmbuf) - strlen (tmbuf), "%03lu ", (unsigned long) tv.tv_usec / 1000); fprintf (f, "%s", tmbuf); } fprintf (f, "%s: %s\r\n", category, message); fclose (f); } } if (log_options.distribute && log_writer) { log_info.log_level = log_level; log_info.message = (char *) message; log_info.category = (char *) category; DDS_DataWriter_write (log_writer, &log_info, 0); } }
DDS_ReturnCode_t DDS_KeyedStringDataWriter_write_string_w_key(DDS_DataWriter dw, const char *key, const char *str, const DDS_InstanceHandle_t h) { DDS_KeyedString ks; ks.key = (char *) key; ks.value = (char *) str; return (DDS_DataWriter_write (dw, &ks, h)); }
DDS_ReturnCode_t DDS_BytesDataWriter_write_w_bytes (DDS_DataWriter dw, const unsigned char *bytes, int offset, int length, const DDS_InstanceHandle_t h) { DDS_Bytes bs; bs.value._maximum = bs.value._length = length; bs.value._esize = 1; bs.value._own = 1; bs.value._buffer = (unsigned char *) bytes + offset; return (DDS_DataWriter_write (dw, &bs, h)); }
int dds_write ( dds_entity_t wr, const void *data) { DDS_ReturnCode_t result; DDS_REPORT_STACK(); result = DDS_DataWriter_write(wr, (const DDS_Sample)data, DDS_HANDLE_NIL); DDS_REPORT_FLUSH(wr, result != DDS_RETCODE_OK); return DDS_ERRNO(result, DDS_MOD_WRITER, DDS_ERR_Mx); }
DDS_ReturnCode_t DDS_KeyedBytesDataWriter_write_bytes_w_key (DDS_DataWriter dw, const char *key, const unsigned char *bytes, int offset, int length, const DDS_InstanceHandle_t h) { DDS_KeyedBytes kb; kb.key = (char *) key; kb.value._length = kb.value._maximum = length; kb.value._esize = 1; kb.value._own = 1; kb.value._buffer = (unsigned char *) bytes + offset; return (DDS_DataWriter_write (dw, &kb, h)); }
static void make_state_writer (int id) { DDS_DataWriterQos wr_qos; DDS_ReturnCode_t error; static DDS_InstanceHandle_t handle; MsgData_t data; printf ("Create Writer\r\n"); /* === create publisher === */ pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { fatal ("DDS_DomainParticipant_create_publisher () failed!"); DDS_DomainParticipantFactory_delete_participant (part); } /* Test get_qos() fynctionality. */ if ((error = DDS_Publisher_get_qos (pub, &pqos)) != DDS_RETCODE_OK) fatal ("DDS_Publisher_get_qos () failed (%s)!", DDS_error (error)); /* Setup writer QoS parameters. */ DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); /* === create the writer === */ wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = 1; wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; wr_qos.ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS; dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, sm); if (!dw) { fatal ("Unable to create a writer \r\n"); DDS_DomainParticipantFactory_delete_participant (part); } /* === While true, add sample, remove sample === */ if (tsm_type == 0) { data.key = id; data.counter = 100 + id; strcpy (data.message, "Hi folks!"); if (test == 3) { printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); return; } } else { if (test == 3) { _types1.i8 = key; printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &_types1); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &_types1, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &_types1, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); return; } } if (test == 0) { printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (2); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (2); if (reader) remove_state_reader (); } else if (test >= 1) { while (1) { printf ("Register instance\r\n"); handle = DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, handle))) printf ("Error writing data\r\n"); sleep (1); if (test == 1) { printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, handle))) printf ("Error unregistering instance\r\n"); } else { printf ("Dispose instance\r\n"); if ((error = DDS_DataWriter_dispose (dw, &data, handle))) printf ("Error disposing instance\r\n"); } sleep (1); } } }
DDS_ReturnCode_t DDS_BytesDataWriter_write (DDS_DataWriter dw, const DDS_Bytes *data, const DDS_InstanceHandle_t h) { return (DDS_DataWriter_write (dw, data, h)); }
DDS_ReturnCode_t DDS_KeyedStringDataWriter_write (DDS_DataWriter dw, const DDS_KeyedString *data, const DDS_InstanceHandle_t h) { return (DDS_DataWriter_write (dw, data, h)); }
int main(int argc, char* argv[]) { int startTime = mstime(); DDS_PoolConstraints reqs; DDS_DomainParticipant domainParticipant; DDS_Publisher publisher; DDS_Subscriber subscriber; DDS_ReturnCode_t retCode; char *configTopicName[nofConfigTopics]; DDS_Topic configTopic[nofConfigTopics]; DDS_Topic stateTopic[nofStateTopics]; DDS_Topic statisticTopic[nofStatisticTopics]; DDS_DataWriterQos dataWriterQos; DDS_DataWriter configDataWriter[nofConfigTopics]; DDS_DataWriter stateDataWriter[nofStateTopics]; DDS_DataWriter statisticDataWriter[nofStatisticTopics]; DDS_DataReaderQos dataReaderQos; DDS_DataReader configDataReader[nofConfigTopics]; acceptance_high_end_Config config; acceptance_high_end_State state; acceptance_high_end_Statistic statistic; DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances]; DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances]; DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances]; int i = 0; int j = 0; int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0; int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0; int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0; int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0; printf("[0] Config topics start at %d...\r\n", firstConfigTopic); printf("[0] State topics start at %d...\r\n", firstStateTopic); printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic); printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off"); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic); struct stat buf; if (stat(file_name, &buf)) { printf ("[%d] Waiting for %s\r\n", mstime() - startTime, file_name); do { sleep(1); } while (stat(file_name, &buf)); printf ("[%d] Got %s!\r\n", mstime() - startTime, file_name); } } DDS_program_name (&argc, argv); DDS_entity_name ("Technicolor Limits Component"); DDS_get_default_pool_constraints(&reqs, ~0, 100); #ifdef MINIMAL_POOLS configure_minimal_pool_constraints (&reqs); #else configure_optimal_pool_constraints (&reqs); #endif DDS_set_pool_constraints(&reqs); #ifdef DDS_DEBUG DDS_Debug_start (); #endif /* Create domain participant... */ domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0); if (!domainParticipant) { fprintf(stderr, "Error creating domain participant.\r\n"); return -1; } printf("[%d] Created domain participant.\r\n", mstime() - startTime); sleep(1); /* Create publisher... */ publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0); if (!publisher) { fprintf(stderr, "Error creating publisher.\r\n"); return -1; } printf("[%d] Created publisher.\r\n", mstime() - startTime); sleep(1); /* Create subscriber... */ subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0); if (!subscriber) { fprintf(stderr, "Error creating subscriber.\r\n"); return -1; } printf("[%d] Created subscriber.\r\n", mstime() - startTime); sleep(1); /* Register types... */ retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered config type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered state type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered statistic type.\r\n", mstime() - startTime); sleep(1); /* Create topics... */ for (i = 0; i < nofConfigTopics; i++) { char topicName[32]; sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i); configTopicName[i] = strdup (topicName); configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0); if (!configTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics); for (i = 0; i < nofStateTopics; i++) { char topicName[32]; sprintf(topicName, "StateTopic%d", firstStateTopic + i); stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0); if (!stateTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics); for (i = 0; i < nofStatisticTopics; i++) { char topicName[32]; sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i); statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0); if (!statisticTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics); sleep(1); /* Create data writers... */ DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0); if (!configDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics); DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofStateTopics; i++) { stateDataWriter[i] = DDS_Publisher_create_datawriter(publisher, stateTopic[i], &dataWriterQos, NULL, 0); if (!stateDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d state data writers.\r\n", mstime() - startTime, nofStateTopics); DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); for (i = 0; i < nofStatisticTopics; i++) { statisticDataWriter[i] = DDS_Publisher_create_datawriter(publisher, statisticTopic[i], &dataWriterQos, NULL, 0); if (!statisticDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d statistic data writers.\r\n", mstime() - startTime, nofStatisticTopics); sleep(1); /* Create data readers... */ DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, NULL, 0); if (!configDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics); sleep(1); /* Register instances... */ for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; configInstance[i][j] = DDS_DataWriter_register_instance(configDataWriter[i], &config); if (!configInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; stateInstance[i][j] = DDS_DataWriter_register_instance(stateDataWriter[i], &state); if (!stateInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; statisticInstance[i][j] = DDS_DataWriter_register_instance(statisticDataWriter[i], &statistic); if (!statisticInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); sleep(1); /* Publish samples... */ for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; retCode = DDS_DataWriter_write(configDataWriter[i], &config, configInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d config samples.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; retCode = DDS_DataWriter_write(stateDataWriter[i], &state, stateInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d state samples.\r\n", mstime() - startTime, nofStateTopics * nofStateInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; retCode = DDS_DataWriter_write(statisticDataWriter[i], &statistic, statisticInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d statistic samples.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); sleep(1); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic + nofConfigTopics); FILE *f = fopen(file_name, "w"); fclose(f); } // dbg_printf ("Zzzzzzz ... \r\n"); sleep(TEST_TIME); // dbg_printf ("... o?\r\n"); /* Delete contained entities... */ // printf (" -- deleting contained entities.\r\n"); retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting contained entities.\r\n"); return -1; } for (i = 0; i < nofConfigTopics; i++) free (configTopicName[i]); // printf (" -- contained entities deleted!\r\n"); // sleep(TEST_TIME); /* Delete domain participants... */ retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting domain participant.\r\n"); return -1; } printf ("[%d] comp completed successfully.\r\n", mstime() - startTime); return 0; }