def _process_object(self, object, fetch_proto=False): if isinstance(object, db.Model): obj = {'key':str(object.key()),'type':'model','kind':object.kind(),'app':object.key().app(),'parent':object.key().parent(),'properties':{}} if object.key().has_id_or_name(): obj['key'] = (str(object.key()), object.key().id_or_name()) if hasattr(object, pc_config.get('poly_class_field','data','_class_key_')): obj['class'] = '.'.join(getattr(object, pc_config.get('poly_class_field','data','_class_key_'))) for key, value in object.properties().items(): if value.__class__.__name__ == 'ReferenceProperty': continue obj['properties'][key] = {'type':value.__class__.__name__, 'value':str(getattr(object, key))} return obj elif isinstance(object, db.Key): obj = {'key':str(object),'type':'key','kind':object.kind(),'app':object.app(),'parent':object.parent()} if object.has_id_or_name(): obj['key'] = (str(object), object.id_or_name()) return obj
def provision_token(cls): key_value, key_hash = cls.provision_key_content( str(account_obj.key()), pc_config.get( "token_key_hash_algorithm", "security", pc_config.get("security", "key_default_hash_algorithm", "md5") ), ) return (key_value, Token(key_name=key_value, content=key_value, md5_hash=key_hash).put())
def provision_key_content( cls, salt="", algorithm=pc_config.get("key_default_hash_algorithm", "security", "sha256") ): hash_obj = hashlib.new(algorithm) hash_obj.update(str(salt) + ":::" + str(datetime.datetime.now().isoformat()) + str(random.random())) key_hash = hashlib.new("md5") key_hash.update(hash_obj.hexdigest()) return (hash_obj.hexdigest(), key_hash.hexdigest())
def provision_account_key(cls, account_obj=None, **kwargs): if account_obj is not None: key_value, key_hash = cls.provision_key_content( str(account_obj.key()), pc_config.get( "account_key_hash_algorithm", "security", pc_config.get("key_default_hash_algorithm", "security", "sha256"), ), ) return ( key_value, AccountKey( key_name=key_value, content=key_value, md5_hash=key_hash, account=account_obj, **kwargs ).put(), ) else: return False
def QueuedTransaction(mode, eta=None, decorators=None, retries=pc_config.get('default_retries','decorators.data.QueuedTransaction')): global _mode _mode = mode def _select_op(*args): global _mode worker = TransactionController.getTxnForDecorator(_mode) return worker return _select_op
def main(): application = webapp.WSGIApplication(ROUTES, debug=pc_config.get('debug','handlers',False)) wsgiref.handlers.CGIHandler().run(application)
import os, sys, logging import wsgiref.handlers from google.appengine.ext import webapp from ProvidenceClarity import pc_config from ProvidenceClarity.handlers import util, input, output, workers, admin, api from ProvidenceClarity.handlers.util import errors from ProvidenceClarity.handlers.input import receiver, fetcher from ProvidenceClarity.handlers.admin import data from ProvidenceClarity.handlers.workers import mail, xmpp, analyzer, data from ProvidenceClarity.handlers.api import data as data_api rp = pc_config.get('pc_url_prefix','handlers','/_pc') ROUTES = [ ## Admin Panel Handlers (rp+'/manage/*$',admin.IndexHandler), (rp+'/manage/data',admin.data.DataIndex), (rp+'/manage/data/(.+)/list',admin.data.DataList), (rp+'/manage/data/(.+)/create',admin.data.DataCreate), (rp+'/manage/data/(.+)/view/(.+)',admin.data.DataView), (rp+'/manage/data/(.+)/edit/(.+)',admin.data.DataEdit), (rp+'/manage/data/(.+)/delete/(.+)',admin.data.DataDelete), ## Data API Handlers (rp+'/api/data/list', data_api.MasterTypeListHandler), # master types list (rp+'/api/data/query', data_api.MasterQueryHandler), # raw GQL query endpoint (rp+'/api/data/(.+)/list',data_api.TypeListHandler), # listing a type
def render(self, tmpl, vars={}, **kwds): ######## // Page // ######## ######## // Caching // ######## global COMPILED_TEMPLATE_PATH if pc_config.get('page_caching','handlers',False) == True: if 'caching' not in kwds or kwds['caching'] == True: user = users.get_current_user() if user != None: key = str(tmpl)+'::'+str(user.user_id()) else: key = str(tmpl)+'::NOT_LOGGED_IN' cached_page = memcache.get(key) if cached_page != None: # append cached page header if debug headers are turned on if pc_config.get('debug_headers','handlers',False) == True: self.response.headers['X-PC-Is-Cached'] = "true" self.response.out.write(cached_page) return True # finish out if we write a cached page ######## // Prepare // ######## ######## // Variables // ######## ## init vars variables = {} ## prepare page variables sys = {'urls':{},'config':{},'security':{},'env':{},'version':VERSION,'subnav':False} sys['urls']['images'] = pc_config.get('images_url','handlers','/assets/images/static/') sys['urls']['script'] = pc_config.get('script_url','handlers','/assets/script/static/') sys['urls']['style'] = pc_config.get('style_url','handlers','/assets/style/static/') ## platform config sys['config'] = pc_config.dump() ## user & security variables if pc_config.get('enable_security','security',True) == True: sys['security']['user'] = users.get_current_user() sys['security']['permissions'] = {'sys_admin':users.is_current_user_admin()} sys['security']['logout_url'] = users.create_logout_url(pc_config.get('logout_destination','security','/')) sys['security']['login_url'] = users.create_login_url('/_pc/manage/') else: sys['security']['user'] = False sys['security']['permissions'] = {'sys_admin':False} sys['security']['logout_url'] = users.create_logout_url(pc_config.get('logout_destination','security','/')) sys['security']['login_url'] = users.create_login_url('/_pc/manage/') ## page variables if 'page' in kwds: variables['page'] = kwds['page'] ## environment variables for name in os.environ.keys(): sys['env'][name] = os.environ[name] ## add in sys variables['sys'] = sys ## add extra vars if len(vars) > 0: for var in vars.keys(): # pull subnav if key == 'subnav': sys['subnav'] = kwds['subnav'] else: variables[key] = kwds[key] ######## // Render // ######## ######## // Page // ######## ## get template root if COMPILED_TEMPLATE_PATH == None: source = PC_PATH if PC_PATH[-1] != '/': source = source+'/' template_root = pc_config.get('template_root','handlers',None) if template_root != None and isinstance(template_root, str): if source[-1] != '/' and template_root[0] != '/': template_root = template_root+'/' source = source+template_root if source[-1] != '/' and tmpl[0] != '/': source = source+'/' COMPILED_TEMPLATE_PATH = source source = source+tmpl else: source = COMPILED_TEMPLATE_PATH+tmpl logging.info('SOURCE: '+str(source)) ## set headers, render, and go self.render_raw(template.render(source,variables))
import logging, sys from . import DataManager from . import DataController from ProvidenceClarity import pc_config from ProvidenceClarity.data.proto import P do_log = pc_config.get('log_imports','api.data.proto.ProtoController',False) class ProtoController(DataController): @classmethod def import_helper(cls,name,fromlist=None): if do_log: logging.info("[i]: Import request: \'"+str(name)+"\' with fromlist \'"+str(fromlist)+"\'.") try: if fromlist is not None: _fromlist_i = [] if isinstance(fromlist, str): _fromlist_i[0] = fromlist elif isinstance(fromlist, list): _fromlist_i = fromlist for subitem in fromlist:
import logging import sys import os from google.appengine.ext import db from google.appengine.api import datastore from ProvidenceClarity.data.core import _PC_MODEL_BRANCH_POLY from ProvidenceClarity.data.core.model import Model from ProvidenceClarity.data.core.properties.polymodel import _ClassKeyProperty from ProvidenceClarity.data.core.properties.polymodel import _ModelPathProperty from ProvidenceClarity import pc_config from ProvidenceClarity.api.data import DataController _LOG_IMPORTS = pc_config.get('log_imports','data.core.polymodel.PolyModel',False) _PATH_SEPERATOR = pc_config.get('poly_path_seperator','api.data.core.polymodel.PolyModel',':') _KEY_NAME_SEPERATOR = pc_config.get('key_name_seperator','api.data.core.polymodel.PolyModel','//') _CLASS_KEY_PROPERTY = pc_config.get('poly_class_field','data','_class_key_') _PATH_KEY_PROPERTY = pc_config.get('poly_path_field','data','_class_path_') _class_map = {} ## +=+=+ Metaclass controlling the creation of Providence/Clarity polymodel objects. class PolymorphicModel(db.PropertiedClass): """ Populates properties like __root_class__ and __class_hierarchy__ and enforces logic about direct instantiation. """ def __init__(cls, name, bases, dct):
import logging from ProvidenceClarity import pc_config do_logging = pc_config.get("import_logging", "api.util", False) def import_helper(name, fromlist=None): global do_logging if do_logging: logging.debug("Import logging turned on for api.util.") if do_logging: logging.debug('Import request for name: "%s" with fromlist "%s".' % name, str(fromlist)) try: if fromlist is None: if isinstance(name, list): mod = __import__(".".join(name)) elif isinstance(name, str): mod = __import__(name) else: return False if do_logging: logging.debug('Import request successful. Returning "%s".' % str(mod)) else:
from google.appengine.ext import db from google.appengine.api import datastore_types from google.appengine.api import datastore_errors from ProvidenceClarity import pc_config _PATH_PREFIX = pc_config.get('path_prefix','data',False) _IMPORT_PREFIX = pc_config.get('import_prefix','data',False) ## +=+=+ Stores the Python package import path from the application root, for lazy-load on search. class _ModelPathProperty(db.StringProperty): def __init__(self, name, **kwargs): super(_ModelPathProperty, self).__init__(name=name, default=None, **kwargs) def __set__(self, *args): raise db.DerivedPropertyError('Model-path is a derived property and cannot be set.') def __get__(self, model_instance, model_class): if model_instance is None: return self # @TODO: make seperator customizable from some import/config return model_instance._getModelPath(':') ## +=+=+ Stores the polymodel class inheritance path. class _ClassKeyProperty(db.ListProperty): def __init__(self, name): super(_ClassKeyProperty, self).__init__(name=name,item_type=str,default=None)
import exceptions from ProvidenceClarity import PCController, PCAdapter, pc_config from ProvidenceClarity.data.data import ORIGIN_LIST, FORMAT_LIST, DataStub, DataBackend from ProvidenceClarity.data.core.model import Model from ProvidenceClarity.api.util import import_helper adapters = pc_config.get('adapters','api.storage',[]) class StorageController(PCController): @classmethod def loadAdapter(cls,name): global adapters if backend in adapters: adapter = import_helper(adapters[backend]) if adapter == False: raise exceptions.InvalidBackend() else: ### STOPPED HERE pass @classmethod def loadStubClass(cls,adapter): if isinstance(adapter, (str,basestring,unicode)):