def lookupEmail(userid):
    """
    Grabs email for the user based on LDAP attrs
    """
    try:
        logger.debug(type(userid))
        if isinstance(userid, WSGIRequest):
            raise Exception("WSGIRequest invalid.")
        attr = _search_ldap(userid)
        emailaddr = attr[0][1]["mail"][0]
        return emailaddr
    except Exception as e:
        logger.warn("Error occurred looking up email for user: %s" % userid)
        logger.exception(e)
        import traceback
        import sys
        import inspect

        s = inspect.stack()
        for i in range(0, 4):
            logger.debug(s[i])
        etype, value, tb = sys.exc_info()
        logger.error("TB = %s" % traceback.format_tb(tb))

        return None

def get_default_identity(username, provider=None):
    """
    Return the default identity given to the user-group for provider.
    """
    try:
        from core.models.group import get_user_group
        group = get_user_group(username)
        identities = group.identities.all()
        if provider:
            if provider.is_active():
                identities = identities.filter(provider=provider)
                return identities[0]
            else:
                logger.error("Provider provided for "
                             "get_default_identity is inactive.")
                raise "Inactive Provider provided for get_default_identity "
        else:
            default_provider = get_default_provider(username)
            default_identity = group.identities.filter(
                provider=default_provider)
            if not default_identity:
                logger.error("User %s has no identities on Provider %s" % (username, default_provider))
                raise "No Identities on Provider %s for %s" % (default_provider,username)
            #Passing
            default_identity = default_identity[0]
            logger.debug(
                "default_identity set to %s " %
                default_identity)
            return default_identity
    except Exception as e:
        logger.exception(e)
        return None

 def post(self, request, provider_id, identity_id, format=None):
     """
     Create a new identity member (ADMINS & OWNERS GROUP LEADERS ONLY)
     """
     user = request.user
     data = request.DATA
     try:
         identity = Identity.objects.get(id=identity_id)
         group_name = data['group']
         group = Group.objects.get(name=group_name)
         prov_member = identity.provider.share(group)
         id_member = identity.share(group)
     except ObjectDoesNotExist as odne:
         return failure_response(
             status.HTTP_404_NOT_FOUND,
             '%s does not exist.' % odne.message.split()[0])
     if not identity.can_share(user):
         logger.error("User %s cannot share identity %s. "
                      + "This incident will be reported")
         return failure_response(
             status.HTTP_401_UNAUTHORIZED,
             "User %s cannot remove sharing from identity %s. "
             + "This incident will be reported"
             % (user, identity_id))
     serializer = IdentitySerializer(id_member.identity)
     serialized_data = serializer.data
     return Response(serialized_data)

 def delete(self, request, provider_id,
            identity_id, group_name, format=None):
     """
     Unshare the identity
     """
     try:
         identity = Identity.objects.get(id=identity_id)
     except Identity.DoesNotExist:
         return failure_response(
             status.HTTP_404_NOT_FOUND,
             "Identity does not exist.")
     if not identity.can_share(user):
         logger.error("User %s cannot remove sharing from identity %s. "
                      + "This incident will be reported"
                      % (user, identity_id))
         return failure_response(
             status.HTTP_401_UNAUTHORIZED,
             "User %s cannot remove sharing from identity %s. "
             + "This incident will be reported"
             % (user, identity_id))
     group = Group.objects.get(name=group_name)
     id_member = identity.unshare(group)
     serializer = IdentitySerializer(id_member.identity)
     serialized_data = serializer.data
     return Response(serialized_data)

    def get(self, request, username):
        """
        Create a new token in the database on behalf of 'username'
        Returns success 201 Created - Body is JSON and contains
        """
        params = request.DATA
        user = request.user
        if user.username is not 'admin' and not user.is_superuser:
            logger.error("URGENT! User: %s is attempting to emulate a user!"
                         % user.username)
            return Response('Only admin and superusers can emulate accounts. '
                            'This offense has been reported',
                            status=status.HTTP_401_UNAUTHORIZED)
        if not AtmosphereUser.objects.filter(username=username):
            return Response("Username %s does not exist as an AtmosphereUser"
                            % username, status=status.HTTP_404_NOT_FOUND)

        #User is authenticated, username exists. Make a token for them.
        token = createAuthToken(username)
        expireTime = token.issuedTime + secrets.TOKEN_EXPIRY_TIME
        auth_json = {
            #Extra data passed only on emulation..
            'emulated_by': request.user.username,
            #Normal token data..
            'token': token.key,
            'username': token.user.username,
            'expires': expireTime.strftime("%b %d, %Y %H:%M:%S")
        }
        return Response(auth_json, status=status.HTTP_201_CREATED)

    def get(self, request, username):
        """
        Create a new token in the database on behalf of 'username'
        Returns success 201 Created - Body is JSON and contains
        """
        user = request.user
        if not username:
            return Response("Username was not provided",
                            status=status.HTTP_400_BAD_REQUEST)
        if user.username is not 'admin' and not user.is_superuser:
            logger.error("URGENT! User: %s is attempting to emulate a user!"
                         % user.username)
            return Response("Only admin and superusers can emulate accounts. "
                            "This offense has been reported",
                            status=status.HTTP_401_UNAUTHORIZED)
        if not AtmosphereUser.objects.filter(username=username):
            return Response("Username %s does not exist as an AtmosphereUser"
                            % username, status=status.HTTP_404_NOT_FOUND)

        # User is authenticated, username exists. Make a token for them.
        user_to_emulate = AtmosphereUser.objects.get_by_natural_key(username)
        token = get_or_create_token(user_to_emulate, issuer="DRF-EmulatedUser")
        expireTime = token.issuedTime + secrets.TOKEN_EXPIRY_TIME
        auth_json = {
            # Extra data passed only on emulation..
            "emulator": request.user.username,
            # Normal token data..
            "token": token.key,
            "username": token.user.username,
            "expires": expireTime.strftime("%b %d, %Y %H:%M:%S")
        }
        return Response(auth_json, status=status.HTTP_201_CREATED)

def get_default_provider(username):
    """
    Return default provider given
    """
    try:
        from core.models.group import get_user_group
        from core.models.provider import Provider
        group = get_user_group(username)
        provider_ids = group.current_identities.values_list(
            'provider',
            flat=True)
        provider = Provider.objects.filter(
            id__in=provider_ids,
            type__name="OpenStack")
        if provider:
            logger.debug("get_default_provider selected a new "
                         "Provider for %s: %s" % (username, provider))
            provider = provider[0]
        else:
            logger.error("get_default_provider could not find a new "
                         "Provider for %s" % (username,))
            return None
        return provider
    except Exception as e:
        logger.exception("get_default_provider encountered an error "
                         "for %s" % (username,))
        return None

def _get_cached(key, data_method, scrub_method, force=False):
    try:
        r = redis_connection()
        if force:
            _invalidate(key)
        data = r.get(key)
    except redis.exceptions.ConnectionError:
        logger.error(
            "EXTERNAL SERVICE redis-server IS NOT RUNNING! "
            "Somebody should turn it on!"
        )
        data = None
    if not data:
        data = data_method()
        scrub_method(data)
        logger.debug(
            "Updated redis({0}) using {1} and {2}".format(
                key, data_method, scrub_method
            )
        )
        r.set(key, pickle.dumps(data))
        r.expire(key, 30)
        return data
    logger.debug("Actual type {0}".format(type(data)))
    return pickle.loads(data)

def get_default_provider(username):
    """
    Return default provider given 
    """
    try:
        from core.models.group import get_user_group
        group = get_user_group(username)
        provider = group.providers.filter(
            Q(end_date=None) | Q(end_date__gt=timezone.now()),
            active=True, type__name="OpenStack")
        if provider:
            provider = provider[0]
        else:
            logger.error("get_default_provider could not find "
                         "a valid Provider")
            return None
        logger.debug(
            "default provider is %s " % provider)
        return provider
    except IndexError:
        logger.info("No provider found for %s" % username)
        return None
    except Exception, e:
        logger.exception(e)
        return None

def build_host_name(ip):
    """
    Build host name from the configuration in settings
    See:
    * INSTANCE_HOSTNAMING_FORMAT
    * INSTANCE_HOSTNAMING_DOMAIN (Required if you use `%(domain)s`)
    """
    # NOTE: This is a hack until we address 'provider specific' hostnaming
    if "114.5" in ip:
        return raw_hostname(ip)

    if not hasattr(settings, "INSTANCE_HOSTNAMING_FORMAT"):
        return raw_hostname(ip)
    if all((str_val not in settings.INSTANCE_HOSTNAMING_FORMAT) for str_val in ["one", "two", "three", "four"]):
        logger.error(
            "Invalid INSTANCE_HOSTNAMING_FORMAT: Expected string containing "
            "at least one of the IP octets. "
            "(ex:'vm%(three)s-%(four)s.%(domain)s')"
        )
    # IP --> octet_tuple (127,0,0,1)
    hostnaming_format_map = create_hostnaming_map(ip)
    try:
        return settings.INSTANCE_HOSTNAMING_FORMAT % hostnaming_format_map
    except (KeyError, TypeError) as exc:
        logger.error("Invalid INSTANCE_HOSTNAMING_FORMAT: %s" % exc)

def deploy_init_to(driverCls, provider, identity, instance_id,
                   username=None, password=None, redeploy=False,
                   *args, **kwargs):
    try:
        logger.debug("deploy_init_to task started at %s." % datetime.now())
        driver = get_driver(driverCls, provider, identity)
        instance = driver.get_instance(instance_id)
        if not instance:
            logger.debug("Instance has been teminated: %s." % instance_id)
            return
        image_metadata = driver._connection\
                               .ex_get_image_metadata(instance.machine)
        deploy_chain = get_deploy_chain(driverCls, provider, identity,
                                        instance, password, redeploy)
        logger.debug("Starting deploy chain for: %s." % instance_id)
        deploy_chain.apply_async()
        #Can be really useful when testing.
        #if kwargs.get('delay'):
        #    async.get()
        logger.debug("deploy_init_to task finished at %s." % datetime.now())
    except SystemExit:
        logger.exception("System Exits are BAD! Find this and get rid of it!")
        raise Exception("System Exit called")
    except NonZeroDeploymentException as non_zero:
        logger.error(str(non_zero))
        logger.error(non_zero.__dict__)
        raise
    except Exception as exc:
        logger.warn(exc)
        deploy_init_to.retry(exc=exc)

def get_default_identity(username, provider=None):
    """
    Return the default identity given to the user-group for provider.
    """
    try:
        from core.models.group import get_user_group
        group = get_user_group(username)
        identities = group.identities.all()
        if provider:
            if provider.is_active():
                identities = identities.filter(provider=provider)
                return identities[0]
            else:
                logger.error("Provider provided for "
                             "get_default_identity is inactive.")
                raise("Provider provided for get_default_identity "
                      "is inactive.")
        else:
            default_provider = get_default_provider(username)
            default_identity = group.identities.filter(
                provider=default_provider)[0]
            logger.debug(
                "default_identity set to %s " %
                default_identity)
            return default_identity
    except Exception, e:
        logger.exception(e)
        return None

    def put(self, request, provider_id, identity_id, machine_id):
        """
        TODO: Determine who is allowed to edit machines besides
            core_machine.owner
        """
        user = request.user
        data = request.DATA
        esh_driver = prepare_driver(request, provider_id, identity_id)
        if not esh_driver:
            return invalid_creds(provider_id, identity_id)
        esh_machine = esh_driver.get_machine(machine_id)
        core_machine = convert_esh_machine(esh_driver, esh_machine, provider_id)

        if not user.is_staff\
           and user is not core_machine.application.created_by:
            logger.error('Non-staff/non-owner trying to update a machine')
            return failure_response(
                status.HTTP_401_UNAUTHORIZED,
                'Only Staff and the machine Owner '
                + 'are allowed to change machine info.')
        core_machine.application.update(data)
        serializer = ProviderMachineSerializer(core_machine,
                                               data=data, partial=True)
        if serializer.is_valid():
            logger.info('metadata = %s' % data)
            update_machine_metadata(esh_driver, esh_machine, data)
            serializer.save()
            logger.info(serializer.data)
            return Response(serializer.data)
        return failure_response(
            status.HTTP_400_BAD_REQUEST,
            serializer.errors)

def o_callback_authorize(request):
    logger.info(request.__dict__)
    if 'code' not in request.GET:
        logger.info(request.__dict__)
        #TODO - Maybe: Redirect into a login
        return HttpResponse("")
    oauth_client = get_cas_oauth_client()
    oauth_code = request.GET['code']
    #Exchange code for ticket
    access_token, expiry_date = oauth_client.get_access_token(oauth_code)
    if not access_token:
        logger.info("The Code %s is invalid/expired. Attempting another login."
                    % oauth_code)
        return o_login_redirect(request)
    #Exchange token for profile
    user_profile = oauth_client.get_profile(access_token)
    if not user_profile or "id" not in user_profile:
        logger.error("AccessToken is producing an INVALID profile!"
                     " Check the CAS server and caslib.py for more"
                     " information.")
        #NOTE: Make sure this redirects the user OUT of the loop!
        return login(request)
    #ASSERT: A valid OAuth token gave us the Users Profile.
    # Now create an AuthToken and return it
    username = user_profile["id"]
    auth_token = obtainOAuthToken(username, access_token, expiry_date)
    #Set the username to the user to be emulated
    #to whom the token also belongs
    request.session['username'] = username
    request.session['token'] = auth_token.key
    logger.info("Returning user - %s - to application "
                % username)
    logger.info(request.session.__dict__)
    logger.info(request.user)
    return HttpResponseRedirect(settings.REDIRECT_URL+"/application/")

    def validate_input(self, user, data):
        error_map = {}

        name = data.get('name')
        identity_uuid = data.get('identity')
        source_alias = data.get('source_alias')
        size_alias = data.get('size_alias')
        if not name:
            error_map['name'] = "This field is required."
        if not identity_uuid:
            error_map['identity'] = "This field is required."
        if not source_alias:
            error_map['source_alias'] = "This field is required."
        if not size_alias:
            error_map['size_alias'] = "This field is required."

        if error_map:
            raise Exception(error_map)

        try:
            identity = Identity.objects.get(uuid=identity_uuid)
            # Staff or owner ONLY
            if not user.is_staff and identity.created_by != user:
                logger.error("User %s does not have permission to use identity %s" % (user, identity))
                raise Identity.DoesNotExist("You are not the owner")
        except Identity.DoesNotExist:
            error_map["identity"] = "The uuid (%s) is invalid." % identity_uuid
            raise Exception(error_map)
        return

 def delete_network(self, neutron, network_name):
     network_id = self.get_network_id(neutron, network_name)
     if network_id:
         try:
             return neutron.delete_network(network_id)
         except:
             logger.error("Problem deleting network: %s" % network_id)
             raise

 def delete_subnet(self, neutron, subnet_name):
     subnet_id = self.get_subnet_id(neutron, subnet_name)
     if subnet_id:
         try:
             return neutron.delete_subnet(subnet_id)
         except:
             logger.error("Problem deleting subnet: %s" % subnet_id)
             raise

 def delete_router(self, neutron, router_name):
     router_id = self.get_router_id(neutron, router_name)
     if router_id:
         try:
             return neutron.delete_router(router_id)
         except:
             logger.error("Problem deleting router: %s" % router_id)
             raise

 def get_config(self, section, config_key, default_value=None, raise_exc=True):
     try:
         value = self.cloud_config[section][config_key]
     except (KeyError, TypeError):
         logger.error("Cloud config ['%s']['%s'] is missing -- using default value (%s)" % (section, config_key, default_value))
         if not default_value and raise_exc:
             raise Exception("Cloud config ['%s']['%s'] is missing -- no default value provided" % (section, config_key))
         value = default_value
     return value

 def get_allocation(self, allocation_name):
     filtered_list = [
         a for a in self.get_all_allocations()
         if str(a['project']) == str(allocation_name)
     ]
     if len(filtered_list) > 1:
         logger.error(">1 value found for allocation %s" % allocation_name)
     if filtered_list:
         return filtered_list[0]
     return None