void MapBox::setProvider(const QString & providerId)
{
if (m_providerId == providerId)
return;
m_providerId = providerId;
createProvider();
}
ProviderPtr
ImporterManager::createProvider( QVariantMap config )
{
Controller *controller = Amarok::Components::statSyncingController();
// First, get rid of the old provider instance. Note: the StatSyncing::Config
// remembers the provider by the id, even when it's unregistered. After this
// block, old instance should be destroyed, its destructor called.
if( config.contains( "uid" ) )
{
const QString providerId = config.value( "uid" ).toString();
if( m_providers.contains( providerId ) )
{
ProviderPtr oldProvider = m_providers.take( providerId );
if( controller )
controller->unregisterProvider( oldProvider );
}
}
// Create a concrete provider using the config. The QueuedConnection in connect()
// is important, because on reconfigure we *destroy* the old provider instance
ImporterProviderPtr provider = newInstance( config );
if( !provider )
{
warning() << __PRETTY_FUNCTION__ << "created provider is null!";
return provider;
}
connect( provider.data(), SIGNAL(reconfigurationRequested(QVariantMap)),
SLOT(createProvider(QVariantMap)), Qt::QueuedConnection);
m_providers.insert( provider->id(), provider );
// Register the provider
if( controller )
{
controller->registerProvider( provider );
// Set provider to offline
if( Config *config = controller->config() )
{
config->updateProvider( provider->id(), provider->prettyName(),
provider->icon(), /*online*/ false );
config->save();
}
}
// Save the settings
KConfigGroup group = providerConfig( provider );
group.deleteGroup();
foreach( const QString &key, provider->m_config.keys() )
group.writeEntry( key, provider->m_config.value( key ) );
group.sync();
return provider;
}
HippoIpcController *
HippoIpcLocator::getController(const char *url)
{
HippoIpcController *controller = map_->get(url);
if (!controller) {
HippoIpcProvider *provider = createProvider(url);
controller = HippoIpcController::createInstance(provider);
map_->insert(url, provider, controller);
}
return controller;
}
CIMProvider* ProviderModule::load(const String& providerName)
{
// dynamically load the provider library
if (!_library.load())
{
throw Exception(MessageLoaderParms(
"ProviderManager.ProviderModule.CANNOT_LOAD_LIBRARY",
"ProviderLoadFailure ($0:$1):Cannot load library, error: $2",
_library.getFileName(),
providerName,
_library.getLoadErrorMessage()));
}
// find library entry point
CIMProvider * (*createProvider)(const String&) =
(CIMProvider* (*)(const String&))
_library.getSymbol("PegasusCreateProvider");
if (createProvider == 0)
{
_library.unload();
throw Exception(MessageLoaderParms(
"ProviderManager.ProviderModule.ENTRY_POINT_NOT_FOUND",
"ProviderLoadFailure ($0:$1):entry point not found.",
_library.getFileName(),
providerName));
}
// invoke the provider entry point
CIMProvider* provider = createProvider(providerName);
// test for the appropriate interface
if (dynamic_cast<CIMProvider *>(provider) == 0)
{
_library.unload();
throw Exception(MessageLoaderParms(
"ProviderManager.ProviderModule.PROVIDER_IS_NOT_A",
"ProviderLoadFailure ($0:$1):provider is not a CIMProvider.",
_library.getFileName(),
providerName));
}
return provider;
}
static void Test_ExtendSignature_useProvider(CuTest* tc, const char *uri_host, unsigned port, const char *user, const char *key, const char *pub_uri,
int (*createProvider)(KSI_CTX *ctx, KSI_NetworkClient **http),
int (*setPubfail)(KSI_NetworkClient *client, const char *url),
int (*setExtender)(KSI_NetworkClient *client, const char *url_host, unsigned port, const char *user, const char *pass)) {
int res = KSI_UNKNOWN_ERROR;
KSI_Signature *sig = NULL;
KSI_Signature *ext = NULL;
KSI_NetworkClient *client = NULL;
KSI_CTX *ctx = NULL;
/* Create the context. */
res = KSI_CTX_new(&ctx);
CuAssert(tc, "Unable to create ctx.", res == KSI_OK && ctx != NULL);
res = createProvider(ctx, &client);
CuAssert(tc, "Unable to create network client.", res == KSI_OK && client != NULL);
res = setExtender(client, uri_host, port, user, key);
CuAssert(tc, "Unable to set extender specific service information.", res == KSI_OK);
res = setPubfail(client, pub_uri);
CuAssert(tc, "Unable to set publications file url.", res == KSI_OK);
res = KSI_CTX_setNetworkProvider(ctx, client);
CuAssert(tc, "Unable to set new network client.", res == KSI_OK);
client = NULL;
res = KSI_Signature_fromFile(ctx, getFullResourcePath("resource/tlv/ok-sig-2014-07-01.1.ksig"), &sig);
CuAssert(tc, "Unable to set read signature from file.", res == KSI_OK && sig != NULL);
res = KSI_Signature_extend(sig, ctx, NULL, &ext);
CuAssert(tc, "The extending of signature must not fail.", res == KSI_OK && ext != NULL);
KSI_NetworkClient_free(client);
KSI_Signature_free(sig);
KSI_Signature_free(ext);
KSI_CTX_free(ctx);
return;
}
// The caller assumes the repsonsibility of making sure
// the libraryPath is correctly formatted
CIMIndicationConsumerProvider* ConsumerModule::load(
const String & consumerName,
const String & libraryPath)
{
PEG_METHOD_ENTER(TRC_LISTENER, "ConsumerModule::load");
// check whether the module is cached;
// if it's not already in memory, load it
if (!_library.isLoaded())
{
if (!FileSystem::exists(libraryPath) ||
!FileSystem::canRead(libraryPath))
{
throw Exception(
MessageLoaderParms(
"DynListener.ConsumerModule.INVALID_LIBRARY_PATH",
"The library ($0:$1) does not exist or cannot be read.",
libraryPath,
consumerName));
}
_library = DynamicLibrary(libraryPath);
}
PEG_TRACE((TRC_LISTENER,Tracer::LEVEL4,
"Loading library(consumer module): %s",
(const char*)consumerName.getCString()));
if (!_library.load())
{
throw Exception(
MessageLoaderParms(
"DynListener.ConsumerModule.CANNOT_LOAD_LIBRARY",
"Cannot load consumer library ($0:$1), load error $2",
_library.getFileName(),
consumerName,
_library.getLoadErrorMessage()));
}
PEG_TRACE((TRC_LISTENER,Tracer::LEVEL3,
"Successfully loaded library(consumer module) %s",
(const char*)consumerName.getCString()));
// locate the entry point
CIMProvider* (*createProvider)(const String&) =
(CIMProvider* (*)(const String&))
_library.getSymbol("PegasusCreateProvider");
if (!createProvider)
{
_library.unload();
throw Exception(
MessageLoaderParms(
"DynListener.ConsumerModule.ENTRY_POINT_NOT_FOUND",
"The entry point for consumer library ($0:$1) cannot be found.",
libraryPath,
consumerName));
}
// create the consumer provider
CIMProvider* providerRef = createProvider(consumerName);
if(!providerRef)
{
_library.unload();
throw Exception(
MessageLoaderParms(
"DynListener.ConsumerModule.CREATE_PROVIDER_FAILED",
"createProvider failed for consumer library ($0:$1)",
libraryPath,
consumerName));
}
// test for the appropriate interface
CIMIndicationConsumerProvider* consumerRef =
dynamic_cast<CIMIndicationConsumerProvider *>(providerRef);
if(!consumerRef)
{
_library.unload();
throw Exception(
MessageLoaderParms(
"DynListener.ConsumerModule.CONSUMER_IS_NOT_A",
"Consumer ($0:$1) is not a CIMIndicationConsumerProvider.",
libraryPath,
consumerName));
}
PEG_METHOD_EXIT();
return consumerRef;
}
