Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements. See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership. The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License. You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations under the License.
  */
 package org.apache.shindig.gadgets.oauth;
 
 
 import  com.google.inject.Inject;
 
 import  net.oauth.OAuthServiceProvider;
 
Higher-level interface that allows callers to store and retrieve OAuth-related data directly from GadgetSpecs, GadgetContexts, etc. See OAuthStore for a more detailed explanation of the OAuth Data Store.
 
 public class GadgetOAuthTokenStore {
 
   private final OAuthStore store;
   private final GadgetSpecFactory specFactory;

  
Public constructor.

Parameters:
store an OAuthStore that can store and retrieve OAuth tokens, as well as information about service providers.
 
   @Inject
   public GadgetOAuthTokenStore(OAuthStore storeGadgetSpecFactory specFactory) {
     this. = store;
     this. = specFactory;
   }

  
Retrieve an AccessorInfo and OAuthAccessor that are ready for signing OAuthMessages. To do this, we need to figure out: - what consumer key/secret to use for signing. - if an access token should be used for the request, and if so what it is. * - the OAuth request/authorization/access URLs. - what HTTP method to use for request token and access token requests - where the OAuth parameters are located. Note that most of that work gets skipped for signed fetch, we just look up the consumer key and secret for that. Signed fetch always sticks the parameters in the query string.
 
   public AccessorInfo getOAuthAccessor(SecurityToken securityToken,
       OAuthArguments argumentsOAuthClientState clientStateOAuthResponseParams responseParams)
       throws OAuthRequestException {
 
     AccessorInfoBuilder accessorBuilder = new AccessorInfoBuilder();
 
     // Pick up any additional information needed about the format of the request, either from
     // options to makeRequest, or options from the spec, or from sensible defaults.  This is how
     // we figure out where to put the OAuth parameters and what methods to use for the OAuth
     // URLs.
     OAuthServiceProvider provider = null;
     if (arguments.programmaticConfig()) {
       provider = loadProgrammaticConfig(argumentsaccessorBuilderresponseParams);
     } else if (arguments.mayUseToken()) {
       provider = lookupSpecInfo(securityTokenargumentsaccessorBuilderresponseParams);
     } else {
       // This is plain old signed fetch.
     }
 
     // What consumer key/secret should we use?
    ConsumerInfo consumer;
    try {
      consumer = .getConsumerKeyAndSecret(
          securityTokenarguments.getServiceName(), provider);
      accessorBuilder.setConsumer(consumer);
    } catch (GadgetException e) {
      throw responseParams.oauthRequestException(.,
          "Unable to retrieve consumer key"e);
    }
    // Should we use the OAuth access token?  We never do this unless the client allows it, and
    // if owner == viewer.
    if (arguments.mayUseToken()
        && securityToken.getOwnerId() != null
        && securityToken.getOwnerId().equals(securityToken.getViewerId())) {
      lookupToken(securityTokenconsumerargumentsclientStateaccessorBuilderresponseParams);
    }
    return accessorBuilder.create(responseParams);
  }

  
Lookup information contained in the gadget spec.
  private OAuthServiceProvider lookupSpecInfo(SecurityToken securityTokenOAuthArguments arguments,
      AccessorInfoBuilder accessorBuilderOAuthResponseParams responseParams)
      throws OAuthRequestException {
    GadgetSpec spec = findSpec(securityTokenargumentsresponseParams);
    OAuthSpec oauthSpec = spec.getModulePrefs().getOAuthSpec();
    if (oauthSpec == null) {
          "Failed to retrieve OAuth URLs, spec for gadget " +
          securityToken.getAppUrl() + " does not contain OAuth element.");
    }
    OAuthService service = oauthSpec.getServices().get(arguments.getServiceName());
    if (service == null) {
          "Failed to retrieve OAuth URLs, spec for gadget does not contain OAuth service " +
          arguments.getServiceName() + ".  Known services: " +
          StringUtils.join(oauthSpec.getServices().keySet(), ',') + '.');
    }
    // In theory some one could specify different parameter locations for request token and
    // access token requests, but that's probably not useful.  We just use the request token
    // rules for everything.
    accessorBuilder.setParameterLocation(
        getStoreLocation(service.getRequestUrl().responseParams));
    accessorBuilder.setMethod(getStoreMethod(service.getRequestUrl().responseParams));
    return new OAuthServiceProvider(
        service.getRequestUrl()..toJavaUri().toASCIIString(),
        service.getAuthorizationUrl().toJavaUri().toASCIIString(),
        service.getAccessUrl()..toJavaUri().toASCIIString());
  }
  private OAuthServiceProvider loadProgrammaticConfig(OAuthArguments arguments,
      AccessorInfoBuilder accessorBuilderOAuthResponseParams responseParams)
      throws OAuthRequestException {
    try {
      String paramLocationStr = arguments.getRequestOption(."");
      Location l = Location.parse(paramLocationStr);
      accessorBuilder.setParameterLocation(getStoreLocation(lresponseParams));
      String requestMethod = arguments.getRequestOption(."GET");
      Method m = Method.parse(requestMethod);
      accessorBuilder.setMethod(getStoreMethod(mresponseParams));
      String requestTokenUrl = arguments.getRequestOption(.);
      verifyUrl(requestTokenUrlresponseParams);
      String accessTokenUrl = arguments.getRequestOption(.);
      verifyUrl(accessTokenUrlresponseParams);
      String authorizationUrl = arguments.getRequestOption(.);
      verifyUrl(authorizationUrlresponseParams);
      return new OAuthServiceProvider(requestTokenUrlauthorizationUrlaccessTokenUrl);
    } catch (SpecParserException e) {
      // these exceptions have decent programmer readable messages
          e.getMessage());
    }
  }
  private void verifyUrl(String urlOAuthResponseParams responseParams)
      throws OAuthRequestException {
    if (url == null) {
      return;
    }
    Uri uri;
    try {
      uri = Uri.parse(url);
    } catch (Throwable t) {
          "Invalid url: " + url);
    }
    if (!uri.isAbsolute()) {
          "Invalid url: " + url);
    }
  }

  
Figure out the OAuth token that should be used with this request. We check for this in three places. In order of priority: 1) From information we cached on the client. We encrypt the token and cache on the client for performance. 2) From information we have in our persistent state. We persist the token server-side so we can look it up if necessary. 3) From information the gadget developer tells us to use (a preapproved request token.) Gadgets can be initialized with preapproved request tokens. If the user tells the service provider they want to add a gadget to a gadget container site, the service provider can create a preapproved request token for that site and pass it to the gadget as a user preference.
  private void lookupToken(SecurityToken securityTokenConsumerInfo consumerInfo,
      OAuthArguments argumentsOAuthClientState clientStateAccessorInfoBuilder accessorBuilder,
      OAuthResponseParams responseParams)
      throws OAuthRequestException {
    if (clientState.getRequestToken() != null) {
      // We cached the request token on the client.
      accessorBuilder.setRequestToken(clientState.getRequestToken());
      accessorBuilder.setTokenSecret(clientState.getRequestTokenSecret());
    } else if (clientState.getAccessToken() != null) {
      // We cached the access token on the client
      accessorBuilder.setAccessToken(clientState.getAccessToken());
      accessorBuilder.setTokenSecret(clientState.getAccessTokenSecret());
      accessorBuilder.setSessionHandle(clientState.getSessionHandle());
      accessorBuilder.setTokenExpireMillis(clientState.getTokenExpireMillis());
    } else {
      // No useful client-side state, check persistent storage
      TokenInfo tokenInfo;
      try {
        tokenInfo = .getTokenInfo(securityTokenconsumerInfo,
            arguments.getServiceName(), arguments.getTokenName());
      } catch (GadgetException e) {
        throw responseParams.oauthRequestException(.,
            "Unable to retrieve access token"e);
      }
      if (tokenInfo != null && tokenInfo.getAccessToken() != null) {
        // We have an access token in persistent storage, use that.
        accessorBuilder.setAccessToken(tokenInfo.getAccessToken());
        accessorBuilder.setTokenSecret(tokenInfo.getTokenSecret());
        accessorBuilder.setSessionHandle(tokenInfo.getSessionHandle());
        accessorBuilder.setTokenExpireMillis(tokenInfo.getTokenExpireMillis());
      } else {
        // We don't have an access token yet, but the client sent us a (hopefully) preapproved
        // request token.
        accessorBuilder.setRequestToken(arguments.getRequestToken());
        accessorBuilder.setTokenSecret(arguments.getRequestTokenSecret());
      }
    }
  }
      OAuthResponseParams responseParamsthrows OAuthRequestException {
    switch(location) {
    case :
      return .;
    case :
      return .;
    case :
      return .;
    }
    throw responseParams.oauthRequestException(.,
        "Unknown parameter location " + location);
  }
  private HttpMethod getStoreMethod(Method methodOAuthResponseParams responseParams)
      throws OAuthRequestException {
    switch(method) {
    case :
      return .;
    case :
      return .;
    }
    throw responseParams.oauthRequestException(."Unknown method " + method);
  }
  private GadgetSpec findSpec(final SecurityToken securityTokenfinal OAuthArguments arguments,
      OAuthResponseParams responseParamsthrows OAuthRequestException {
    try {
      GadgetContext context = new OAuthGadgetContext(securityTokenarguments);
      return .getGadgetSpec(context);
    } catch (IllegalArgumentException e) {
      throw responseParams.oauthRequestException(.,
          "Could not fetch gadget spec, gadget URI invalid."e);
    } catch (GadgetException e) {
      throw responseParams.oauthRequestException(.,
          "Could not fetch gadget spec"e);
    }
  }

  
Store an access token for the given user/gadget/service/token name
  public void storeTokenKeyAndSecret(SecurityToken securityTokenConsumerInfo consumerInfo,
      OAuthArguments argumentsTokenInfo tokenInfoOAuthResponseParams responseParams)
      throws OAuthRequestException {
    try {
      .setTokenInfo(securityTokenconsumerInfoarguments.getServiceName(),
          arguments.getTokenName(), tokenInfo);
    } catch (GadgetException e) {
      throw responseParams.oauthRequestException(.,
          "Unable to store access token"e);
    }
  }

  
Remove an access token for the given user/gadget/service/token name
  public void removeToken(SecurityToken securityTokenConsumerInfo consumerInfo,
      OAuthArguments argumentsOAuthResponseParams responseParamsthrows OAuthRequestException {
    try {
      .removeToken(securityTokenconsumerInfoarguments.getServiceName(),
          arguments.getTokenName());
    } catch (GadgetException e) {
      throw responseParams.oauthRequestException(.,
          "Unable to remove access token"e);
    }
  }
New to GrepCode? Check out our FAQ X