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); }