cadi/oauth-enduser/src/test/java/org/onap/aaf/cadi/enduser/test/OAuthExample.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.cadi.enduser.test;
  23
  24 import java.io.IOException;
  25 import java.net.ConnectException;
  26 import java.security.GeneralSecurityException;
  27 import java.util.Date;
  28 import java.util.GregorianCalendar;
  29
  30 import org.onap.aaf.cadi.Access.Level;
  31 import org.onap.aaf.cadi.CadiException;
  32 import org.onap.aaf.cadi.LocatorException;
  33 import org.onap.aaf.cadi.PropAccess;
  34 import org.onap.aaf.cadi.aaf.Defaults;
  35 import org.onap.aaf.cadi.client.Future;
  36 import org.onap.aaf.cadi.client.Rcli;
  37 import org.onap.aaf.cadi.client.Result;
  38 import org.onap.aaf.cadi.client.Retryable;
  39 import org.onap.aaf.cadi.config.Config;
  40 import org.onap.aaf.cadi.oauth.TimedToken;
  41 import org.onap.aaf.cadi.oauth.TokenClient;
  42 import org.onap.aaf.cadi.oauth.TokenClientFactory;
  43 import org.onap.aaf.cadi.oauth.TzClient;
  44 import org.onap.aaf.cadi.util.FQI;
  45 import org.onap.aaf.misc.env.APIException;
  46 import org.onap.aaf.misc.env.util.Chrono;
  47
  48 import aafoauth.v2_0.Introspect;
  49 import aafoauth.v2_0.Token;
  50
  51
  52 public class OAuthExample {
  53         private static TokenClientFactory tcf;
  54         private static PropAccess access;
  55
  56         public final static void main(final String args[]) {
  57                 // These Objects are expected to be Long-Lived... Construct once
  58
  59                 // Property Access
  60                         // This method will allow you to set "cadi_prop_files" (or any other property) on Command line
  61                 access = new PropAccess(args);
  62
  63                         // access = PropAccess();
  64                         // Note: This style will load "cadi_prop_files" from VM Args
  65
  66                 // Token aware Client Factory
  67                 try {
  68                         tcf = TokenClientFactory.instance(access);
  69                 } catch (APIException | GeneralSecurityException | IOException | CadiException e1) {
  70                         access.log(e1, "Unable to setup OAuth Client Factory, Fail Fast");
  71                         System.exit(1);
  72                 }
  73
  74
  75                 // Obtain Endpoints for OAuth2 from Properties.  Expected is "cadi.properties" file, pointed to by "cadi_prop_files"
  76                 String tokenServiceURL = access.getProperty(Config.AAF_OAUTH2_TOKEN_URL,Defaults.OAUTH2_TOKEN_URL); // Default to AAF
  77                 String tokenIntrospectURL = access.getProperty(Config.AAF_OAUTH2_INTROSPECT_URL,Defaults.OAUTH2_INTROSPECT_URL); // Default to AAF);
  78                 // Get Hello Service
  79                 final String endServicesURL = access.getProperty(Config.AAF_OAUTH2_HELLO_URL,Defaults.HELLO_URL);
  80
  81                 final int CALL_TIMEOUT = Integer.parseInt(access.getProperty(Config.AAF_CALL_TIMEOUT,Config.AAF_CALL_TIMEOUT_DEF));
  82
  83                 try {
  84                         //////////////////////////////////////////////////////////////////////
  85                         // Scenario 1:
  86                         // Get and use an OAuth Client, which understands Token Management
  87                         //////////////////////////////////////////////////////////////////////
  88                         // Create a Token Client, that gets its tokens from expected OAuth Server
  89                         //   In this example, it is AAF, but it can be the Alternate OAuth
  90
  91                         TokenClient tc = tcf.newClient(tokenServiceURL); // can set your own timeout here (url, timeoutMilliseconds)
  92                         // Set your Application (MicroService, whatever) Credentials here
  93                         //   These are how your Application is known, particularly to the OAuth Server.
  94                         //   If AAF Token server, then its just the same as your other AAF MechID creds
  95                         //   If it is the Alternate OAUTH, you'll need THOSE credentials.  See that tool's Onboarding procedures.
  96                         String client_id = access.getProperty(Config.AAF_APPID);
  97                         if(client_id==null) {
  98                                 // For AAF, client_id CAN be Certificate.  This is not necessarily true elsewhere
  99                                 client_id = access.getProperty(Config.CADI_ALIAS);
 100                         }
 101                         String client_secret = access.getProperty(Config.AAF_APPPASS);
 102                         tc.client_creds(client_id, client_secret);
 103
 104                         // If you are working with Credentials the End User, set username/password as appropriate to the OAuth Server
 105                         // tc.password(end_user_id, end_user_password);
 106                         // IMPORTANT:
 107                         //   if you are setting client Credentials, you MAY NOT reuse this Client mid-transaction.  You CAN reuse after setting
 108                         //  tc.clearEndUser();
 109                         // You may want to see "Pooled Client" example, using special CADI utility
 110
 111                         // With AAF, the Scopes you put in are the AAF Namespaces you want access to.  Your Token will contain the
 112                         // AAF Permissions of the Namespaces (you can put in more than one), the user name (or client_id if no user_name),
 113                         // is allowed to see.
 114
 115                         // Here's a trick to get the namespace out of a Fully Qualified AAF Identity (your MechID)
 116                         String ns = FQI.reverseDomain(client_id);
 117                         System.out.printf("\nNote: The AAF Namespace of FQI (Fully Qualified Identity) %s is %s\n\n",client_id, ns);
 118
 119                         // Now, we can get a Token.  Note: for "scope", use AAF Namespaces to get AAF Permissions embedded in
 120                         // Note: getToken checks if Token is expired, if so, then refreshes before handing back.
 121                         Result<TimedToken> rtt = tc.getToken(ns,"org.onap.test");
 122
 123                         // Note: you can clear a Token's Disk/Memory presence by
 124                         //  1) removing the Token from the "token/outgoing" directory on the O/S
 125                         //  2) programmatically by calling "clearToken" with exact params as "getToken", when it has the same credentials set
 126                         //       tc.clearToken("org.onap.aaf","org.onap.test");
 127
 128                         // Result Object can be queried for success
 129                         if(rtt.isOK()) {
 130                                 TimedToken token = rtt.value;
 131                                 print(token); // Take a look at what's in a Token
 132
 133                                 // Use this Token in your client calls with "Tokenized Client" (TzClient)
 134                                 // These should NOT be used cross thread.
 135                                 TzClient helloClient = tcf.newTzClient(endServicesURL);
 136                                 helloClient.setToken(client_id, token);
 137
 138                                 // This client call style, "best" call with "Retryable" inner class covers finding an available Service
 139                                 // (when Multi-services exist) for the best service, based (currently) on distance.
 140                                 //
 141                                 // the "Generic" in Type gives a Return Value for the Code, which you can set on the "best" method
 142                                 // Note that variables used in the inner class from this part of the code must be "final", see "CALL_TIMEOUT"
 143                                 String rv = helloClient.best(new Retryable<String>() {
 144                                         @Override
 145                                         public String code(Rcli<?> client) throws CadiException, ConnectException, APIException {
 146                                                 Future<String> future = client.read("hello","text/plain");
 147                                                 // The "future" calling method allows you to do other processing, such as call more than one backend
 148                                                 // client before picking up the result
 149                                                 // If "get" matches the HTTP Code for the method (i.e. read HTTP Return value is 200), then
 150                                                 if(future.get(CALL_TIMEOUT)) {
 151                                                         // Client Returned expected value
 152                                                         return future.value;
 153                                                 } else {
 154                                                         throw new APIException(future.code()  + future.body());
 155                                                 }
 156                                         }
 157                                 });
 158
 159                                 // You want to do something with returned value.  Here, we say "hello"
 160                                 System.out.printf("\nPositive Response from Hello: %s\n",rv);
 161
 162
 163                                 //////////////////////////////////////////////////////////////////////
 164                                 // Scenario 2:
 165                                 // As a Service, read Introspection information as proof of Authenticated Authorization
 166                                 //////////////////////////////////////////////////////////////////////
 167                                 // CADI Framework (i.e. CadiFilter) works with the Introspection to drive the J2EE interfaces (
 168                                 // i.e. if(isUserInRole("ns.perm|instance|action")) {...
 169                                 //
 170                                 // Here, however, is a way to introspect via Java
 171                                 //
 172                                 // now, call Introspect (making sure right URLs are set in properties)
 173                                 // We need a Different Introspect TokenClient, because different Endpoint (and usually different Services)
 174                                 TokenClient tci = tcf.newClient(tokenIntrospectURL);
 175                                 tci.client_creds(client_id, client_secret);
 176                                 Result<Introspect> is = tci.introspect(token.getAccessToken());
 177                                 if(is.isOK()) {
 178                                         // Note that AAF will add JSON set of Permissions as part of "Content:", legitimate extension of OAuth Structure
 179                                         print(is.value); // do something with Introspect Object
 180                                 } else {
 181                                         access.printf(Level.ERROR, "Unable to introspect OAuth Token %s: %d %s\n",
 182                                                         token.getAccessToken(),rtt.code,rtt.error);
 183                                 }
 184                         } else {
 185                                 access.printf(Level.ERROR, "Unable to obtain OAuth Token: %d %s\n",rtt.code,rtt.error);
 186                         }
 187
 188                 } catch (CadiException | LocatorException | APIException | IOException e) {
 189                         e.printStackTrace();
 190                 }
 191         }
 192
 193         /////////////////////////////////////////////////////////////
 194         // Examples of Object Access
 195         /////////////////////////////////////////////////////////////
 196         private static void print(Token t) {
 197                 GregorianCalendar exp_date = new GregorianCalendar();
 198                 exp_date.add(GregorianCalendar.SECOND, t.getExpiresIn());
 199                 System.out.printf("Access Token\n\tToken:\t\t%s\n\tToken Type:\t%s\n\tExpires In:\t%d (%s)\n\tScope:\t\t%s\n\tRefresh Token:\t%s\n",
 200                 t.getAccessToken(),
 201                 t.getTokenType(),
 202                 t.getExpiresIn(),
 203                 Chrono.timeStamp(new Date(System.currentTimeMillis()+(t.getExpiresIn()*1000))),
 204                 t.getScope(),
 205                 t.getRefreshToken());
 206         }
 207
 208         private static void print(Introspect ti) {
 209                 if(ti==null || ti.getClientId()==null) {
 210                         System.out.println("Empty Introspect");
 211                         return;
 212                 }
 213                 Date exp = new Date(ti.getExp()*1000); // seconds
 214                 System.out.printf("Introspect\n"
 215                                 + "\tAccessToken:\t%s\n"
 216                                 + "\tClient-id:\t%s\n"
 217                                 + "\tClient Type:\t%s\n"
 218                                 + "\tActive:  \t%s\n"
 219                                 + "\tUserName:\t%s\n"
 220                                 + "\tExpires: \t%d (%s)\n"
 221                                 + "\tScope:\t\t%s\n"
 222                                 + "\tContent:\t%s\n",
 223                 ti.getAccessToken(),
 224                 ti.getClientId(),
 225                 ti.getClientType(),
 226                 ti.isActive()?Boolean.TRUE.toString():Boolean.FALSE.toString(),
 227                 ti.getUsername(),
 228                 ti.getExp(),
 229                 Chrono.timeStamp(exp),
 230                 ti.getScope(),
 231                 ti.getContent()==null?"":ti.getContent());
 232
 233                 System.out.println();
 234         }
 235
 236 }