X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=saml%2Fsaml2%2Fmetadata%2Fimpl%2FChainingMetadataProvider.cpp;h=9f90400106739f1a9adc08bab4afc9feab566405;hb=a70e0c7f3c52bfd3ff1de84183de6cfe175fccc6;hp=e1100086e91210d6f54373fa9470f04910585061;hpb=9d8a89e650195f2b083af82f030aa0eceb75d9bb;p=shibboleth%2Fopensaml2.git

diff --git a/saml/saml2/metadata/impl/ChainingMetadataProvider.cpp b/saml/saml2/metadata/impl/ChainingMetadataProvider.cpp
index e110008..9f90400 100644
--- a/saml/saml2/metadata/impl/ChainingMetadataProvider.cpp
+++ b/saml/saml2/metadata/impl/ChainingMetadataProvider.cpp
@@ -1,5 +1,5 @@
 /*
- *  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.
@@ -24,12 +24,15 @@
 #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;
 
@@ -42,16 +45,18 @@ namespace opensaml {
     };
 };
 
-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)
                     );
@@ -61,12 +66,11 @@ ChainingMetadataProvider::ChainingMetadataProvider(const DOMElement* e) : Observ
                 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);
 }
@@ -77,14 +81,21 @@ ChainingMetadataProvider::~ChainingMetadataProvider()
     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()
@@ -102,17 +113,9 @@ void ChainingMetadataProvider::unlock()
     }
 }
 
-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
@@ -135,16 +138,18 @@ const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(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;
@@ -152,25 +157,27 @@ const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const char
         (*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);
 }