/*
- * Copyright 2001-2005 Internet2
+ * Copyright 2001-2007 Internet2
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "exceptions.h"
#include "saml2/metadata/ChainingMetadataProvider.h"
-#include <xmltooling/util/XMLHelper.h>
#include <xercesc/util/XMLUniDefs.hpp>
+#include <xmltooling/logging.h>
+#include <xmltooling/util/XMLHelper.h>
+
using namespace opensaml::saml2md;
using namespace opensaml;
using namespace xmlsignature;
+using namespace xmltooling::logging;
using namespace xmltooling;
using namespace std;
};
};
-static const XMLCh GenericMetadataProvider[] = UNICODE_LITERAL_16(M,e,t,a,d,a,t,a,P,r,o,v,i,d,e,r);
-static const XMLCh type[] = UNICODE_LITERAL_4(t,y,p,e);
+static const XMLCh _MetadataProvider[] = UNICODE_LITERAL_16(M,e,t,a,d,a,t,a,P,r,o,v,i,d,e,r);
+static const XMLCh type[] = UNICODE_LITERAL_4(t,y,p,e);
ChainingMetadataProvider::ChainingMetadataProvider(const DOMElement* e) : ObservableMetadataProvider(e), m_tlsKey(NULL)
{
- try {
- e = e ? xmltooling::XMLHelper::getFirstChildElement(e, GenericMetadataProvider) : NULL;
- while (e) {
- auto_ptr_char temp(e->getAttributeNS(NULL,type));
- if (temp.get()) {
+ Category& log=Category::getInstance(SAML_LOGCAT".Metadata.Chaining");
+ e = e ? XMLHelper::getFirstChildElement(e, _MetadataProvider) : NULL;
+ while (e) {
+ auto_ptr_char temp(e->getAttributeNS(NULL,type));
+ if (temp.get() && *temp.get()) {
+ try {
+ log.info("building MetadataProvider of type %s", temp.get());
auto_ptr<MetadataProvider> provider(
SAMLConfig::getConfig().MetadataProviderManager.newPlugin(temp.get(), e)
);
m_providers.push_back(provider.get());
provider.release();
}
- e = XMLHelper::getNextSiblingElement(e, GenericMetadataProvider);
+ catch (exception& ex) {
+ log.error("error building MetadataProvider: %s", ex.what());
+ }
}
- }
- catch (XMLToolingException&) {
- for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());
- throw;
+ e = XMLHelper::getNextSiblingElement(e, _MetadataProvider);
}
m_tlsKey = ThreadKey::create(NULL);
}
for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());
}
-void ChainingMetadataProvider::onEvent(MetadataProvider& provider)
+void ChainingMetadataProvider::onEvent(const ObservableMetadataProvider& provider) const
{
emitChangeEvent();
}
void ChainingMetadataProvider::init()
{
- for_each(m_providers.begin(), m_providers.end(), mem_fun<void,MetadataProvider>(&MetadataProvider::init));
+ for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
+ try {
+ (*i)->init();
+ }
+ catch (exception& ex) {
+ Category::getInstance(SAML_LOGCAT".Metadata").error("failure initializing MetadataProvider: %s", ex.what());
+ }
+ }
}
Lockable* ChainingMetadataProvider::lock()
}
}
-const KeyResolver* ChainingMetadataProvider::getKeyResolver() const
-{
- // Check for a locked provider.
- void* ptr=m_tlsKey->getData();
- return ptr ? reinterpret_cast<MetadataProvider*>(ptr)->getKeyResolver() : NULL;
-
-}
-
const XMLObject* ChainingMetadataProvider::getMetadata() const
{
- throw XMLToolingException("getMetadata operation not implemented on this provider.");
+ throw MetadataException("getMetadata operation not implemented on this provider.");
}
const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const
return NULL;
}
-const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const char* id, bool requireValidMetadata) const
+pair<const EntityDescriptor*,const RoleDescriptor*> ChainingMetadataProvider::getEntityDescriptor(const Criteria& criteria) const
{
// Clear any existing lock.
const_cast<ChainingMetadataProvider*>(this)->unlock();
// Do a search.
- const EntityDescriptor* ret=NULL;
+ pair<const EntityDescriptor*,const RoleDescriptor*> ret;
+ ret.first = NULL;
+ ret.second = NULL;
for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
(*i)->lock();
- if (ret=(*i)->getEntityDescriptor(id,requireValidMetadata)) {
+ if ((ret=(*i)->getEntityDescriptor(criteria)).first) {
// Save locked provider.
m_tlsKey->setData(*i);
return ret;
(*i)->unlock();
}
- return NULL;
+ return ret;
}
-const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const SAMLArtifact* artifact) const
+const Credential* ChainingMetadataProvider::resolve(const CredentialCriteria* criteria) const
{
- // Clear any existing lock.
- const_cast<ChainingMetadataProvider*>(this)->unlock();
+ // Check for a locked provider.
+ void* ptr=m_tlsKey->getData();
+ if (!ptr)
+ throw MetadataException("No locked MetadataProvider, where did the role object come from?");
- // Do a search.
- const EntityDescriptor* ret=NULL;
- for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
- (*i)->lock();
- if (ret=(*i)->getEntityDescriptor(artifact)) {
- // Save locked provider.
- m_tlsKey->setData(*i);
- return ret;
- }
- (*i)->unlock();
- }
+ return reinterpret_cast<MetadataProvider*>(ptr)->resolve(criteria);
+}
- return NULL;
+vector<const Credential*>::size_type ChainingMetadataProvider::resolve(
+ vector<const Credential*>& results, const CredentialCriteria* criteria
+ ) const
+{
+ // Check for a locked provider.
+ void* ptr=m_tlsKey->getData();
+ if (!ptr)
+ throw MetadataException("No locked MetadataProvider, where did the role object come from?");
+
+ return reinterpret_cast<MetadataProvider*>(ptr)->resolve(results, criteria);
}