void
metadata_type_register (const gchar *name, gint type)
{
if (!metadataTypes)
metadata_init ();
g_hash_table_insert (metadataTypes, (gpointer)name, GINT_TO_POINTER (type));
}
gboolean
metadata_is_type_registered (const gchar *strid)
{
if (!metadataTypes)
metadata_init ();
if (g_hash_table_lookup (metadataTypes, strid))
return TRUE;
else
return FALSE;
}
static void handle_set_parameter_metadata(rtsp_conn_info *conn,
rtsp_message *req, rtsp_message *resp) {
char *cp = req->content;
int cl = req->contentlength;
metadata *meta = metadata_init();
unsigned int off = 8;
while (off < cl) {
char tag[5];
strncpy(tag, cp+off, 4);
tag[4] = '\0';
off += 4;
uint32_t vl = ntohl(*(uint32_t *)(cp+off));
off += sizeof(uint32_t);
char *val = malloc(vl+1);
strncpy(val, cp+off, vl);
val[vl] = '\0';
off += vl;
debug(2, "Tag: %s Content: %s\n", tag, val);
#if 0
if (!strncmp(tag, "asal ", 4) && meta->album == NULL) {
debug(1, "META Album: %s\n", val);
meta->album = strdup(val);
setAlbumConfig(meta->album);
} else if (!strncmp(tag, "asar ", 4) && meta->artist == NULL) {
debug(1, "META Artist: %s\n", val);
meta->artist = strdup(val);
setCreatorConfig(meta->artist);
} else if (!strncmp(tag, "ascm ", 4) && meta->comment == NULL) {
debug(1, "META Comment: %s\n", val);
meta->comment = strdup(val);
} else if (!strncmp(tag, "asgn ", 4) && meta->genre == NULL) {
debug(1, "META Genre: %s\n", val);
meta->genre = strdup(val);
} else if (!strncmp(tag, "minm ", 4) && meta->title == NULL) {
debug(1, "META Title: %s\n", val);
meta->title = strdup(val);
setTitleConfig(meta->title);
}
#endif
free(val);
}
// player_metadata(meta);
metadata_free(meta);
}
static gint
metadata_get_type (const gchar *name)
{
gint type;
if (!metadataTypes)
metadata_init ();
type = GPOINTER_TO_INT (g_hash_table_lookup (metadataTypes, (gpointer)name));
if (0 == type)
g_warning ("Unknown metadata type: %s, please report this Liferea bug!", name);
return type;
}
int main (int argc, char ** argv)
{
// loop
// 1. get the metadata catalog
// 2. select oldest version of one var
// 3. mark as in process in MD
// 4. retrieve list of chunks for this var
// 5. process
// 6. write out new chunks
// 7. make new MD entries
// 8. delete old var version
// end after x versions
int size;
int rank;
int rank_to_fail = -1;
if (argc > 1)
rank_to_fail = atoi (argv [1]);
memset (&timing, 0, sizeof (struct timing_metrics));
MPI_Init (&argc, &argv);
MPI_Comm_size (MPI_COMM_WORLD, &size);
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
// number of sub-coordinators (min 2, otherwise 256 procs per)
uint32_t num_groups = (size < 512) ? 2 : size / 256;
struct transaction_comm * comm_id; // which comm we initialized for transactions
struct md_config metadata_config;
struct metadata_server * md_server;
struct md_config metadata_config2;
struct metadata_server * md_server2;
struct ds_config datastore_config;
struct datastore_server * ds_server;
struct ds_config datastore_config2;
struct datastore_server * ds_server2;
// global setup for this communicator. num_groups will probably fold into
// itself shortly
comm_id = txn_init(MPI_COMM_WORLD, num_groups);
logger_init ((log_level) atoi (getenv ("NSSI_LOG_LEVEL")), NULL);
// for the sim to write to the first staging area
PERFORM (metadata_get_config_from_env ("METADATA_CONFIG_FILE", &metadata_config));
PERFORM (metadata_init (metadata_config.server_urls [0], &md_server));
// for the analysis code to write to the next step analysis process
PERFORM (metadata_get_config_from_env ("METADATA_CONFIG_FILE2", &metadata_config2));
PERFORM (metadata_init (metadata_config2.server_urls [0], &md_server2));
// for the sim to write to the first staging area
PERFORM (datastore_get_config_from_env ("DATASTORE_CONFIG_FILE", &datastore_config));
PERFORM (datastore_init (datastore_config.server_urls [0], &ds_server));
// for the analysis code to write to the next step analysis process
PERFORM (datastore_get_config_from_env ("DATASTORE_CONFIG_FILE2", &datastore_config2));
PERFORM (datastore_init (datastore_config2.server_urls [0], &ds_server2));
int rc = NSSI_OK;
uint32_t catalog_items = 0;
struct md_catalog_entry * entries = NULL;
uint32_t chunk_items = 0;
struct md_chunk_entry * chunks = NULL;
uint32_t var_version = 0;
uint64_t old_var_id = 0;
uint64_t new_var_id = 0;
const char * var_name = "A";
const char * var_path = "/";
uint64_t txid = 10;
txn_vote vote = TXN_VOTE_UNKNOWN;
transaction * mdtrans = NULL;
struct _subtxn
{
const char * name;
sub_transaction * sub;
} sub_txns [] = {{"metadata_catalog", NULL} // 0
,{"get_chunk_list",NULL} // 1
,{"processing_var",NULL} // 2
,{"datastore_get",NULL} // 3
,{"create_var",NULL} // 4
,{"datastore_put",NULL} // 5
,{"delete_var",NULL} // 6
,{"location_remove",NULL} // 7
,{"activate_var",NULL} // 8
,{"pre-begin-test",NULL} // 9
};
// create a transaction.
mdtrans = txn_create_transaction (comm_id, txid);
//============================================================================
if (rank == 0)
{
// begin the transaction. Any add_sub_txn before this will be done as a
// single action rather than individually
// create a sub transaction for the metadata_catalog call
sub_txns [0].sub = txn_create_sub_transaction(mdtrans, sub_txns [0].name, rank);
assert (sub_txns [0].sub);
// create a sub transaction for the metadata_get_chunk_list call
sub_txns [1].sub = txn_create_sub_transaction(mdtrans, sub_txns [1].name, rank);
assert (sub_txns [1].sub);
// Creating sub transaction for metadata_processing_var call.
sub_txns [2].sub = txn_create_sub_transaction(mdtrans, sub_txns [2].name, rank);
assert (sub_txns [2].sub);
// sub_txn [3] is _all
// create the new var that we are writing
sub_txns [4].sub = txn_create_sub_transaction(mdtrans, sub_txns [4].name, rank);
assert (sub_txns [4].sub);
// sub_txn [5] is _all
// delete the var once we are done processing and already wrote
sub_txns [6].sub = txn_create_sub_transaction(mdtrans, sub_txns [6].name, rank);
assert (sub_txns [6].sub);
// sub_txn [7] is _all
// delete the var once we are done processing and already wrote
sub_txns [8].sub = txn_create_sub_transaction(mdtrans, sub_txns [8].name, rank);
assert (sub_txns [8].sub);
}
// make one global sub-txn before the begin transaction to see if that works
sub_txns [9].sub = txn_create_sub_transaction_all(mdtrans, sub_txns [9].name, rank);
assert (sub_txns [9].sub);
//============================================================================
int pass = txn_begin_transaction(mdtrans);
assert (pass == TXN_SUCCESS);
if(pass != TXN_SUCCESS)
{
txn_finalize (comm_id, true);
mdtrans = NULL;
fprintf(stderr, "transaction could not be initialized.\n");
// do something to fail.
}
// get the first var at the root
// get the list of chunks
// scatter a chunk to each process for analysis routines
// mark the var as 'in process' hiding it from others
if (rank == 0)
{
// sub_txns [0]
PERFORM (rc = metadata_catalog (md_server, txid, &catalog_items, &entries));
PERFORM (print_catalog (catalog_items, entries));
// if it succeeded, then we can commit.
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [0].sub);
vote = TXN_VOTE_COMMIT;
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [0].sub);
vote = TXN_VOTE_ABORT;
}
#if DO_OPS
if (strcmp (entries [0].name, var_name) == 0 && vote == TXN_VOTE_COMMIT)
{
var_version = entries [0].version;
old_var_id = entries [0].var_id;
// sub_txns [1]
rc = metadata_get_chunk_list (md_server, txid, var_name, var_path, var_version, &chunk_items, &chunks);
print_chunks (chunk_items, chunks);
// if it's successful, we can commit this.
#endif
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [1].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [1].sub);
vote = TXN_VOTE_ABORT;
}
#if DO_OPS
MPI_Scatter (chunks, sizeof (struct md_chunk_entry), MPI_CHAR, MPI_IN_PLACE, sizeof (struct md_chunk_entry), MPI_CHAR, 0, MPI_COMM_WORLD);
}
#endif
if (vote == TXN_VOTE_COMMIT)
{
// sub_txn [2]
PERFORM (rc = metadata_processing_var (md_server, txid, var_name, var_path, var_version));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [2].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [2].sub);
vote = TXN_VOTE_ABORT;
}
}
}
else
{
chunks = (struct md_chunk_entry *) malloc (sizeof (struct md_chunk_entry));
#if DO_OPS
MPI_Scatter (NULL, 0, MPI_CHAR, chunks, sizeof (struct md_chunk_entry), MPI_CHAR, 0, MPI_COMM_WORLD);
#endif
}
size_t chunk_size;
void * chunk_data;
if (vote != TXN_VOTE_ABORT)
{
sub_txns [3].sub = txn_create_sub_transaction_all (mdtrans, sub_txns [3].name, rank);
assert (sub_txns [3].sub);
PERFORM (rc = datastore_location_get (ds_server, txid, chunks [0].chunk_id, chunks [0].connection, &chunk_size, &chunk_data));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [3].sub);
vote = TXN_VOTE_COMMIT;
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [3].sub);
vote = TXN_VOTE_ABORT;
}
}
// process the chunks
double * d = (double *) chunk_data;
size_t chunk_item_count = chunk_size / sizeof (double);
#if DO_OPS
for (int i = 0; i < chunk_item_count; i++)
{
d [i] *= rank; // just something stupid for now
}
#endif
// write to the next ds and md service
if (rank == 0)
{
PERFORM (rc = metadata_create_var (md_server2, txid, &new_var_id, &entries [0]));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [4].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [4].sub);
vote = TXN_VOTE_ABORT;
}
PERFORM (MPI_Bcast (&new_var_id, 1, MPI_UNSIGNED_LONG_LONG, 0, MPI_COMM_WORLD));
}
else
{
PERFORM (MPI_Bcast (&new_var_id, 1, MPI_UNSIGNED_LONG_LONG, 0, MPI_COMM_WORLD));
}
if (rank != rank_to_fail)
{
sub_txns [5].sub = txn_create_sub_transaction_all (mdtrans, sub_txns [5].name, rank);
}
if (rank != rank_to_fail)
{
assert (sub_txns [5].sub);
if (vote == TXN_VOTE_COMMIT)
{
PERFORM (rc = datastore_put (ds_server2, txid, &chunks [0].chunk_id, chunk_size, chunk_data));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [5].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [5].sub);
vote = TXN_VOTE_ABORT;
}
}
PERFORM (metadata_insert_chunk (md_server2, new_var_id, &chunks [0]));
// remove the chunks and md from the original set
if (rank == 0)
{
PERFORM (rc = metadata_delete_var (md_server, old_var_id, var_name, var_path, var_version));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [6].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [6].sub);
}
}
sub_txns [7].sub = txn_create_sub_transaction_all (mdtrans, sub_txns [7].name, rank);
assert (sub_txns [7].sub);
PERFORM (rc = datastore_location_remove (ds_server, chunks [0].connection, txid, chunks [0].chunk_id));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [7].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [7].sub);
}
if (rank == 0)
{
// activate the var in the new md
PERFORM (rc = metadata_activate_var (md_server2, txid, var_name, var_path, var_version));
PERFORM (rc = datastore_activate (ds_server2, txid, chunks [0].chunk_id));
if(rc == NSSI_OK)
{
txn_commit_sub_transaction (mdtrans, sub_txns [8].sub);
}
else
{
txn_abort_sub_transaction (mdtrans, sub_txns [8].sub);
}
}
txn_commit_sub_transaction (mdtrans, sub_txns [9].sub);
if (chunks)
free (chunks);
// see where things are now
if (entries)
free (entries);
#if 0
switch (vote)
{
case TXN_VOTE_COMMIT: printf ("rank: %d vote: TXN_VOTE_COMMIT\n", rank); fflush (stdout);
break;
case TXN_VOTE_ABORT: printf ("rank: %d vote: TXN_VOTE_ABORT\n", rank); fflush (stdout);
break;
case TXN_VOTE_UNKNOWN: printf ("rank: %d vote: TXN_VOTE_UNKNOWN\n", rank); fflush (stdout);
break;
}
#endif
pass = txn_vote_transaction(mdtrans, rank, vote);
if(pass == TXN_SUCCESS && vote == TXN_VOTE_COMMIT){
pass = txn_commit_transaction(mdtrans);
}else{
pass = txn_abort_transaction(mdtrans);
}
// if the protocol fails to commit after pass, then we have to abort.
txn_finalize_transaction (mdtrans);
// no need to do this within a transaction because it is read only and
// we do not need to read things in progress
if (rank == 0)
{
printf ("Metadata catalog 1:\n"); fflush (stdout);
PERFORM (rc = metadata_catalog (md_server, txid, &catalog_items, &entries));
print_catalog (catalog_items, entries);
if (entries)
free (entries);
printf ("Metadata catalog 2:\n"); fflush (stdout);
PERFORM (rc = metadata_catalog (md_server2, txid, &catalog_items, &entries));
print_catalog (catalog_items, entries);
if (entries)
free (entries);
}
// no need to block before the finalizes because only the root will do
// the actual shutdown.
// wait for everyone before shutting down MPI
MPI_Barrier (MPI_COMM_WORLD);
// clean up and shut down
PERFORM (datastore_finalize (ds_server, &datastore_config, rank == 0 ? true : false));
PERFORM (metadata_finalize (md_server, &metadata_config, rank == 0 ? true : false));
PERFORM (datastore_finalize (ds_server2, &datastore_config2, rank == 0 ? true : false));
PERFORM (metadata_finalize (md_server2, &metadata_config2, rank == 0 ? true : false));
// cleans up all initiazed comms. assume no server or managed elsewhere
txn_finalize (comm_id, false);
}
MPI_Finalize ();
}
void
showtime_init(void)
{
int r;
hts_mutex_init(&gconf.state_mutex);
hts_cond_init(&gconf.state_cond, &gconf.state_mutex);
gconf.exit_code = 1;
unicode_init();
/* Initialize property tree */
prop_init();
init_global_info();
/* Initiailize logging */
trace_init();
/* Callout framework */
callout_init();
/* Initialize htsmsg_store() */
htsmsg_store_init();
/* Notification framework */
notifications_init();
/* Initialize settings */
settings_init();
TRACE(TRACE_DEBUG, "core", "Loading resources from %s", showtime_dataroot());
/* Try to create cache path */
if(gconf.cache_path != NULL &&
(r = makedirs(gconf.cache_path)) != 0) {
TRACE(TRACE_ERROR, "cache", "Unable to create cache path %s -- %s",
gconf.cache_path, strerror(r));
gconf.cache_path = NULL;
}
/* Initialize sqlite3 */
db_init();
/* Initializte blob cache */
blobcache_init();
/* Try to create settings path */
if(gconf.persistent_path != NULL &&
(r = makedirs(gconf.persistent_path)) != 0) {
TRACE(TRACE_ERROR, "settings",
"Unable to create path for persistent storage %s -- %s",
gconf.persistent_path, strerror(r));
gconf.persistent_path = NULL;
}
/* Metadata init */
metadata_init();
metadb_init();
kvstore_init();
/* Metadata decoration init */
decoration_init();
/* Initialize keyring */
keyring_init();
#if ENABLE_LIBAV
/* Initialize libavcodec & libavformat */
av_lockmgr_register(fflockmgr);
av_log_set_callback(fflog);
av_register_all();
TRACE(TRACE_INFO, "libav", LIBAVFORMAT_IDENT", "LIBAVCODEC_IDENT", "LIBAVUTIL_IDENT);
#endif
/* Freetype */
#if ENABLE_LIBFREETYPE
freetype_init();
rasterizer_ft_init();
#endif
#if ENABLE_GLW
glw_settings_init();
#endif
fontstash_init();
/* Global keymapper */
keymapper_init();
/* Initialize media subsystem */
media_init();
/* Service handling */
service_init();
/* Initialize backend content handlers */
backend_init();
/* Initialize navigator */
nav_init();
/* Initialize audio subsystem */
audio_init();
/* Initialize plugin manager */
plugins_init(gconf.devplugin);
/* Start software installer thread (plugins, upgrade, etc) */
hts_thread_create_detached("swinst", swthread, NULL, THREAD_PRIO_LOW);
/* Internationalization */
i18n_init();
/* Video settings */
video_settings_init();
if(gconf.load_jsfile)
js_load(gconf.load_jsfile);
/* Various interprocess communication stuff (D-Bus on Linux, etc) */
init_group(INIT_GROUP_IPC);
/* Service discovery. Must be after ipc_init() (d-bus and threads, etc) */
if(!gconf.disable_sd)
sd_init();
/* Initialize various external APIs */
init_group(INIT_GROUP_API);
/* HTTP server and UPNP */
#if ENABLE_HTTPSERVER
http_server_init();
if(!gconf.disable_upnp)
upnp_init();
#endif
runcontrol_init();
}
void
main_init(void)
{
char errbuf[512];
hts_mutex_init(&gconf.state_mutex);
hts_cond_init(&gconf.state_cond, &gconf.state_mutex);
gconf.exit_code = 1;
asyncio_init_early();
init_group(INIT_GROUP_NET);
unicode_init();
/* Initialize property tree */
prop_init();
init_global_info();
/* Initiailize logging */
trace_init();
/* Callout framework */
callout_init();
prop_init_late();
/* Initialize htsmsg_store() */
htsmsg_store_init();
/* Notification framework */
notifications_init();
/* Initialize settings */
settings_init();
TRACE(TRACE_DEBUG, "core", "Loading resources from %s", app_dataroot());
TRACE(TRACE_DEBUG, "core", "Cache path: %s", gconf.cache_path);
/* Try to create cache path */
if(gconf.cache_path != NULL &&
fa_makedirs(gconf.cache_path, errbuf, sizeof(errbuf))) {
TRACE(TRACE_ERROR, "core", "Unable to create cache path %s -- %s",
gconf.cache_path, errbuf);
gconf.cache_path = NULL;
}
/* Initialize sqlite3 */
#if ENABLE_SQLITE
db_init();
#endif
/* Initializte blob cache */
blobcache_init();
TRACE(TRACE_DEBUG, "core", "Persistent path: %s", gconf.persistent_path);
/* Try to create settings path */
if(gconf.persistent_path != NULL &&
fa_makedirs(gconf.persistent_path, errbuf, sizeof(errbuf))) {
TRACE(TRACE_ERROR, "core",
"Unable to create path for persistent storage %s -- %s",
gconf.persistent_path, errbuf);
gconf.persistent_path = NULL;
}
/* Per-item key/value store */
kvstore_init();
/* Metadata init */
#if ENABLE_METADATA
metadata_init();
metadb_init();
decoration_init();
#endif
subtitles_init();
/* Initialize keyring */
keyring_init();
#if ENABLE_LIBAV
/* Initialize libavcodec & libavformat */
av_lockmgr_register(fflockmgr);
av_log_set_callback(fflog);
av_register_all();
TRACE(TRACE_INFO, "libav", LIBAVFORMAT_IDENT", "LIBAVCODEC_IDENT", "LIBAVUTIL_IDENT" cpuflags:0x%x", av_get_cpu_flags());
#endif
init_group(INIT_GROUP_GRAPHICS);
#if ENABLE_GLW
glw_settings_init();
#endif
/* Global keymapper */
keymapper_init();
/* Initialize media subsystem */
media_init();
/* Service handling */
service_init();
/* Initialize backend content handlers */
backend_init();
/* Initialize navigator */
nav_init();
/* Initialize audio subsystem */
audio_init();
/* Initialize plugin manager */
plugins_init(gconf.devplugins);
/* Start software installer thread (plugins, upgrade, etc) */
hts_thread_create_detached("swinst", swthread, NULL, THREAD_PRIO_BGTASK);
/* Internationalization */
i18n_init();
/* Video settings */
video_settings_init();
/* Various interprocess communication stuff (D-Bus on Linux, etc) */
init_group(INIT_GROUP_IPC);
/* Service discovery. Must be after ipc_init() (d-bus and threads, etc) */
if(!gconf.disable_sd)
sd_init();
/* Initialize various external APIs */
init_group(INIT_GROUP_API);
/* Asynchronous IO (Used by HTTP server, etc) */
asyncio_start();
runcontrol_init();
TRACE(TRACE_DEBUG, "SYSTEM", "Hashed device ID: %s", gconf.device_id);
if(gconf.device_type[0])
TRACE(TRACE_DEBUG, "SYSTEM", "Device type: %s", gconf.device_type);
}
