def client(self): """ Lazily load the Stormpath Client object we need to access the raw Stormpath SDK. """ ctx = stack.top if ctx is not None: if not hasattr(ctx, 'stormpath_client'): # If the user is specifying their credentials via a file path, # we'll use this. if self.app.config['STORMPATH_API_KEY_FILE']: ctx.stormpath_client = Client( api_key_file_location=self.app. config['STORMPATH_API_KEY_FILE'], ) # If the user isn't specifying their credentials via a file # path, it means they're using environment variables, so we'll # try to grab those values. else: ctx.stormpath_client = Client( id=self.app.config['STORMPATH_API_KEY_ID'], secret=self.app.config['STORMPATH_API_KEY_SECRET'], ) return ctx.stormpath_client
def client(self): """ Lazily load the Stormpath Client object we need to access the raw Stormpath SDK. """ ctx = stack.top if ctx is not None: if not hasattr(ctx, 'stormpath_client'): # Create our custom user agent. This allows us to see which # version of this SDK are out in the wild! user_agent = 'stormpath-flask/%s (flask %s)' % (__version__, flask_version) # If the user is specifying their credentials via a file path, # we'll use this. if self.app.config['STORMPATH_API_KEY_FILE']: ctx.stormpath_client = Client( api_key_file_location = self.app.config['STORMPATH_API_KEY_FILE'], user_agent = user_agent, ) # If the user isn't specifying their credentials via a file # path, it means they're using environment variables, so we'll # try to grab those values. else: ctx.stormpath_client = Client( id = self.app.config['STORMPATH_API_KEY_ID'], secret = self.app.config['STORMPATH_API_KEY_SECRET'], user_agent = user_agent, ) return ctx.stormpath_client
def test_base_url(self): client = Client(id=self.api_key_id, secret=self.api_key_secret) self.assertEqual(client.BASE_URL, 'https://api.stormpath.com/v1') client = Client(id=self.api_key_id, secret=self.api_key_secret, base_url='https://example.com') self.assertEqual(client.BASE_URL, 'https://example.com')
def test_auth_method(self, session): tenant_return = MagicMock( status_code=200, json=MagicMock( return_value={'applications': { 'href': 'applications' }})) app_return = MagicMock(status_code=200, json=MagicMock(return_value={'name': 'LCARS'})) with patch('stormpath.client.Auth.digest', new_callable=PropertyMock) \ as digest: with patch('stormpath.client.Auth.basic', new_callable=PropertyMock) as basic: client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}) session.return_value.request.return_value = tenant_return application = client.applications.get('application_url') session.return_value.request.return_value = app_return application.name self.assertTrue(digest.called) self.assertFalse(basic.called) digest.reset_mock() client = Client(api_key={ 'id': 'MyId', 'secret': 'Shush!' }, method='digest') session.return_value.request.return_value = tenant_return application = client.applications.get('application_url') session.return_value.request.return_value = app_return application.name self.assertTrue(digest.called) self.assertFalse(basic.called) digest.reset_mock() client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}) session.return_value.request.return_value = tenant_return application = client.applications.get('application_url') session.return_value.request.return_value = app_return application.name self.assertTrue(digest.called) self.assertFalse(basic.called) digest.reset_mock() client = Client(api_key={ 'id': 'MyId', 'secret': 'Shush!' }, method='basic') session.return_value.request.return_value = tenant_return application = client.applications.get('application_url') session.return_value.request.return_value = app_return application.name self.assertFalse(digest.called) self.assertTrue(basic.called)
def test_proxies(self, session, auth): proxies = { 'https': 'https://i-am-so-secure.com', 'http': 'http://i-want-to-be.secure.org'} client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}, proxies=proxies) self.assertEqual(client.data_store.executor.session.proxies, proxies) client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}) self.assertEqual(client.data_store.executor.session.proxies, {})
def test_digest_authentication(self): client = Client(id=self.api_key_id, secret=self.api_key_secret, scheme='SAuthc1') list(client.applications) client = Client(id=self.api_key_id + 'x', secret=self.api_key_secret + 'x', scheme='SAuthc1') with self.assertRaises(Error): list(client.applications)
def index(): if user.is_authenticated(): return redirect(url_for('success')) client = Client(api_key_file_location=app.config['STORMPATH_API_KEY_FILE']) a = client.applications.search(app.config['STORMPATH_APPLICATION'])[0] html = '' # delete user if it already exists email = '*****@*****.**' for i in a.accounts: if i.email == email: html = html + 'deleting account ' + i.email + '<br>' i.delete() # create the account password = '******' username = '******' html = html + 'creating account ' + email + '<br>' account = a.accounts.create({ 'given_name': 'John', 'surname': 'Doe', 'username': username, 'email': email, 'password': password, }) html = html + ''' Login using these credentials:<br> <b>%s <br></b> <b>%s <br></b> <a href="/login">Login</a> ''' % (email, password) return html
def test_digest_authentication_fails(self): client = Client(id=self.api_key_id + 'x', secret=self.api_key_secret + 'x', scheme='SAuthc1') # force the SDK to make a call to the server with self.assertRaises(Error): list(client.applications)
def test_basic_authentication_with_api_key_succeeds(self): api_key = { 'api_key_id': self.api_key_id, 'api_key_secret': self.api_key_secret } client = Client(api_key=api_key, scheme='basic') # force the SDK to make a call to the server list(client.applications)
def bootstrap_client(): """ Create a new Stormpath Client from environment variables. :rtype: obj :returns: A new Stormpath Client, fully initialized. """ return Client( id=environ.get('STORMPATH_API_KEY_ID'), secret=environ.get('STORMPATH_API_KEY_SECRET'), )
def test_cache_opts_with_different_cache_stores(self): cache_opts = { 'regions': { 'customData': { 'store': NullCacheStore, } } } client = Client(id=self.api_key_id, secret=self.api_key_secret, scheme=self.AUTH_SCHEME, cache_options=cache_opts) app_name = self.get_random_name() app = client.applications.create({ 'name': app_name, 'description': 'test app', 'custom_data': { 'a': 1 } }) href = app.href # this will cache application self.assertEqual(Application(client, href=href).name, app_name) # pretend that app name is changed elsewhere properties = app._get_properties() properties['name'] = 'changed %s' % app_name client.data_store.executor.post(app.href, properties) # we get stale, cached app name self.assertEqual(Application(client, href=href).name, app_name) # unless we refresh app.refresh() self.assertEqual( Application(client, href=href).name, properties['name']) # this will not cache custom data self.assertEqual(Application(client, href=href).custom_data['a'], 1) # pretend that app's custom data is changed elsewhere properties = app.custom_data._get_properties() properties['a'] = 2 client.data_store.executor.post(app.custom_data.href, properties) # we get fresh custom data self.assertEqual(Application(client, href=href).custom_data['a'], 2) app.delete()
def test_client(self): # get the client print 'STORMPATH_API_KEY_FILE =', STORMPATH_API_KEY_FILE print 'STORMPATH_APPLICATION =', STORMPATH_APPLICATION client = Client(api_key_file_location=STORMPATH_API_KEY_FILE) # get the app apps = client.applications.search(STORMPATH_APPLICATION) assert len(apps) == 1 app = apps[0] # delete user if it already exists email = '*****@*****.**' for i in app.accounts: print 'email', i.email if i.email == email: print 'deleting existing account', i i.delete() # create the account password = '******' print 'creating account', email account = app.accounts.create({ 'given_name': 'John', 'surname': 'Doe', 'username': '******', 'email': email, 'password': password, }) # authenticate app.authenticate_account(email, password) # bad authentication caught_bad_password = False try: app.authenticate_account(email, 'badpassword') except Error as re: # Will output: 400 print 'caught error', re.status # Will output: "Invalid username or password." print 'caught error', re.message # Will output: "mailto:[email protected]" print 'caught error', re.more_info caught_bad_password = True assert caught_bad_password # cleanup account.delete()
def setUp(self): self.apiKeyId = os.getenv("STORMPATH_SDK_TEST_API_KEY_ID") self.apiKeySecret = os.getenv("STORMPATH_SDK_TEST_API_KEY_SECRET") self.client = Client(api_key={ 'id': self.apiKeyId, 'secret': self.apiKeySecret }) self.created_accounts = [] self.created_applications = [] self.created_directories = [] self.created_group_memberships = [] self.created_groups = [] self.created_account_stores = []
def test_cache_options(self): client = Client(id=self.api_key_id, secret=self.api_key_secret, cache_options={ 'regions': { 'customData': { 'store': NullCacheStore } } }) self.assertIsInstance( client.data_store.cache_manager.caches['customData'].store, NullCacheStore)
def test_basic_authentication(self): client = Client(id=self.api_key_id, secret=self.api_key_secret, scheme='basic') list(client.applications) api_key = { 'api_key_id': self.api_key_id, 'api_key_secret': self.api_key_secret } client = Client(api_key=api_key, scheme='basic') list(client.applications) client = Client(api_key_id=self.api_key_id, api_key_secret=self.api_key_secret, scheme='basic') list(client.applications) client = Client(id=self.api_key_id + 'x', secret=self.api_key_secret + 'x', scheme='basic') with self.assertRaises(Error): list(client.applications)
def pytest_keyboard_interrupt(excinfo): collection_resources = ['applications', 'organizations', 'directories'] test_prefix = 'stormpath-sdk-python-test' auth_scheme = 'basic' base_url = getenv('STORMPATH_BASE_URL') api_key_id = getenv('STORMPATH_API_KEY_ID') api_key_secret = getenv('STORMPATH_API_KEY_SECRET') client = Client(id=api_key_id, secret=api_key_secret, base_url=base_url, scheme=auth_scheme) for collection in collection_resources: for resource in list(getattr(client, collection).search(test_prefix)): resource.delete()
def save(self): super(ChirperCreateForm, self).save() client = Client(api_key={ 'id': settings.STORMPATH_ID, 'secret': settings.STORMPATH_SECRET }) account_type = self.cleaned_data['account_type'] if account_type == 'Admins': admin_group = client.groups.get(settings.STORMPATH_ADMINISTRATORS) self.account.add_group(admin_group) self.account.save() elif account_type == 'Premiums': premium_group = client.groups.get(settings.STORMPATH_PREMIUMS) self.account.add_group(premium_group) self.account.save()
def test_resource_init_with_partial_href(self, session): session.return_value.request.return_value = MagicMock( status_code=200, json=MagicMock(return_value={'name': 'My Application'})) self.client = Client(api_key={ 'id': 'MyId', 'secret': 'Shush!' }, base_url='https://enterprise.stormpath.io/v1') r = Resource(self.client, href='/application/APP_UID') self.assertEqual(r.name, 'My Application') session.return_value.request.assert_called_once_with( 'GET', 'https://enterprise.stormpath.io/v1/application/APP_UID', params=None, allow_redirects=False, data=None)
def init(args): """Downloads and installs a Stormpath sample project for the given platform.""" from .main import USER_AGENT try: auth_args = init_auth(args) client = Client(user_agent=USER_AGENT, **auth_args) except ValueError as ex: get_logger().error(str(ex)) exit(1) type = args.get('<resource>') name = args.get('<attributes>') if name and len(name) > 0: name = name[0].split('name=')[1] sample_project = Project.create_from_type(type, name) sample_project.download() sample_project.create_app(client) sample_project.install()
'account': acc, 'group': group }) def render_nginx_conf(app, group): tpl = open(NGINX_CONF_IN).read() conf = tpl % { 'app_href': app.href, 'group_href': group.href } with open(NGINX_CONF, 'w') as fp: fp.write(conf) def render_apikey_properties(): tpl = open(APIKEY_PROPERTIES_IN).read() prop = tpl % os.environ with open(APIKEY_PROPERTIES, 'w') as fp: fp.write(prop) # if id/secret are not in environment, this will terminate the setup script c = Client() app = ensure_test_app(c) group = ensure_test_group(app) primary = ensure_test_account(app, PRIMARY_ACC_NAME) secondary = ensure_test_account(app, SECONDARY_ACC_NAME) ensure_account_in_group(c, group, primary) render_nginx_conf(app, group) render_apikey_properties()
from django.db import models from django.conf import settings from django_stormpath.models import StormpathUser from stormpath.client import Client CLIENT = Client(id=settings.STORMPATH_ID, secret=settings.STORMPATH_SECRET) class Chirp(models.Model): user = models.ForeignKey(settings.AUTH_USER_MODEL) message = models.TextField(max_length=160, verbose_name='') created_at = models.DateTimeField(auto_now_add=True) owner_is_admin = models.BooleanField(default=False) owner_is_premium = models.BooleanField(default=False) class Meta: ordering = ['-created_at'] class ChirperUser(StormpathUser): def is_admin(self): admin_group = CLIENT.groups.get(settings.STORMPATH_ADMINISTRATORS) return len(admin_group.accounts.search({'email': self.email})) def is_premium(self): premium_group = CLIENT.groups.get(settings.STORMPATH_PREMIUMS) return len(premium_group.accounts.search({'email': self.email}))
from stormpath.client import Client client = Client(id='xxx', secrety='yyy', scheme='basic')
from stormpath.cache.redis_store import RedisStore from stormpath.client import Client client = Client(id='xxx', secret='xxx', cache_options={ 'store': RedisStore, 'store_opts': { 'host': 'localhost', 'port': 6739, }, 'ttl': 300, 'tti': 300, })
def main(): arguments = docopt(__doc__) action = arguments.get('<action>') resource = arguments.get('<resource>') log = setup_output(arguments.get('--verbose')) arguments.update(get_context_dict()) arguments, resource, action = find_non_dash_arguments_and_default_action( arguments, resource, action) arguments = properly_support_boolean_values(arguments) arguments = check_primary_identifier_without_flags(arguments, resource, action) if not action: log.error(__doc__.strip('\n')) return -1 if action == 'help': log.error(__doc__.strip('\n')) return -1 if action not in AVAILABLE_ACTIONS: log.error( "Unknown action '{}'. See 'stormpath --help' for list of available actions." .format(action)) return -1 if action in LOCAL_ACTIONS: return 0 if AVAILABLE_ACTIONS[action](arguments) else -1 if not resource and action != STATUS_ACTION: if action == SET_ACTION: log.error( "A resource type is required. Available resources for the set command are: application, directory. Please see 'stormpath --help'" ) return -1 log.error( "A resource type is required. Available resources: {}. Please see 'stormpath --help'" .format(', '.join(sorted(AVAILABLE_RESOURCES.keys())))) return -1 if resource not in AVAILABLE_RESOURCES and action != STATUS_ACTION: log.error( "Unknown resource type '{}'. See 'stormpath --help' for list of available resource types." .format(resource)) return -1 try: auth_args = init_auth(arguments) client = Client(user_agent=USER_AGENT, **auth_args) except ValueError as ex: log.error(str(ex)) return -1 if action == STATUS_ACTION: return 0 if AVAILABLE_ACTIONS[action](client, arguments) else -1 try: res = AVAILABLE_RESOURCES[resource](client, arguments) except ValueError as ex: log.error(str(ex)) return -1 act = AVAILABLE_ACTIONS[action] try: result = act(res, arguments) except (StormpathError, ValueError) as ex: log.error(str(ex)) return -1 if result is not None and (isinstance(result, list) or isinstance( result, dict) or isinstance(result, types.GeneratorType)): output(result, show_links=arguments.get('--show-links', False), show_headers=arguments.get('--show-headers', False), output_json=arguments.get('--output-json', False)) return 0
import traceback from stormpath.client import Client from os import environ, path from Connector import Database from Validater import Validate from CustomException import ValidatorException DEBUG = True abspath = path.dirname(path.abspath(__file__)) # Create a new Stormpath Client. apiKeys = path.join(abspath, '../security/apiKey.properties') client = Client(api_key_file_location=apiKeys) href = environ['STORMPATH_APPLICATION_HREF'] # Retrieve our application stormApp = client.applications.get(href) class Registration(Database): """ A class that registers new student accounts To create a student account for a user, include this module and use methods to insert account information about user. """ def __init__(self): super(Registration, self).__init__() # Get connection & cursor from Database
def test_tenant_expansion(self): e = Expansion() e.add_property('bar', limit=5) client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}, expand=e) self.assertIsInstance(client.tenant._expand, Expansion)
from stormpath.cache.null_cache_store import NullCacheStore from stormpath.client import Client client = Client(id='xxx', secret='yyy', cache_options={'store': NullCacheStore})
from os.path import expanduser, join from stormpath.client import Client # This is the absolute path to the file ~/.stormpath/apiKey.properties # downloaded in the previous section. This will work on any OS. API_KEY_FILE = join(expanduser('~'), '.stormpath', 'apiKey.properties') client = Client(api_key_file=API_KEY_FILE)
from django.core.exceptions import ObjectDoesNotExist from django.db.models.signals import pre_save, pre_delete from django.contrib.auth.models import Group from django.dispatch import receiver from django import VERSION as django_version from stormpath.client import Client from stormpath.error import Error as StormpathError from django_stormpath import __version__ USER_AGENT = 'stormpath-django/%s django/%s' % (__version__, django_version) CLIENT = Client(id=settings.STORMPATH_ID, secret=settings.STORMPATH_SECRET, user_agent=USER_AGENT, cache_options=getattr(settings, 'STORMPATH_CACHE_OPTIONS', None)) APPLICATION = CLIENT.applications.get( settings.STORMPATH_APPLICATION) if settings.STORMPATH_APPLICATION else None class StormpathPermissionsMixin(PermissionsMixin): pass class StormpathUserManager(BaseUserManager): def create(self, *args, **kwargs): return self.create_user(*args, **kwargs)
""" from os import environ from sys import exit from flask import Flask, jsonify, request from stormpath.client import Client ##### GLOBALS app = Flask(__name__) try: stormpath_app = Client( id = environ.get('STORMPATH_API_KEY_ID'), secret = environ.get('STORMPATH_API_KEY_SECRET'), ).applications.search('flask-api-sample')[0] except: print "Error! Couldn't find the Stormpath application." exit(1) ##### API @app.route('/') def api(): """Simple API endpoint which requires user authention to access. Users can access this endpoint by using HTTP Basic Authentication when making their HTTP request to the service. We'll then use Stormpath's API to authenticate the user securely.