示例#1
0
    def get(self):
        try:
            namespace_manager.set_namespace(self.request.get('namespace'))

            blocks_data_version_client = \
                self.request.get('blocksDataVersion')
            camera_data_version_client = \
                self.request.get('cameraDataVersion')
            block_properties_data_version_client = \
                self.request.get('blockPropertiesDataVersion')
            new_block_data_version_client = \
                self.request.get('newBlockDataVersion')
            prerender_mode_data_version_client = \
                self.request.get('prerenderModeDataVersion')
            callback = self.request.get('callback')

            data = db.run_in_transaction \
                (self.transaction,
                 blocks_data_version_client,
                 camera_data_version_client,
                 block_properties_data_version_client,
                 new_block_data_version_client,
                 prerender_mode_data_version_client)
            dump_jsonp(self, data, callback)
        except Exception, e:
            logging.error('Could not retrieve data: ' + str(e))
示例#2
0
    def get(self):
        try:
            namespace_manager.set_namespace(self.request.get('namespace'))

            data = {
                'camera_pos': [
                    float(self.request.get('camera.x')),
                    float(self.request.get('camera.y')),
                    float(self.request.get('camera.z'))
                ],
                'camera_a_x':
                float(self.request.get('camera.aX')),
                'camera_a_y':
                float(self.request.get('camera.aY')),
                'camera_a_z':
                float(self.request.get('camera.aZ')),
                'camera_fl':
                float(self.request.get('camera.fl')),
                'camera_sensor_resolution':
                float(self.request.get('camera.sensorResolution'))
            }
            callback = self.request.get('callback')
            db.run_in_transaction(self.transaction, data)
            dump_jsonp(self, {}, callback)
        except Exception, e:
            logging.error('Could not update camera data: ' + str(e))
示例#3
0
    def get_overrides(cls, force_update=False):
        """Returns current property overrides, maybe cached."""

        now = long(time.time())
        age = now - cls.last_update_time
        max_age = UPDATE_INTERVAL_SEC.get_value(cls.db_overrides)
        if force_update or age < 0 or age >= max_age:
            # Value of '0' disables all datastore overrides.
            if UPDATE_INTERVAL_SEC.get_value() == 0:
                cls.db_overrides = {}
                return cls.db_overrides

            # Load overrides from a datastore.
            try:
                old_namespace = namespace_manager.get_namespace()
                try:
                    namespace_manager.set_namespace(
                        appengine_config.DEFAULT_NAMESPACE_NAME)

                    cls.load_from_db()
                finally:
                    namespace_manager.set_namespace(old_namespace)
            except Exception as e:  # pylint: disable-msg=broad-except
                logging.error('Failed to load properties from a database: %s.',
                              str(e))
            finally:
                # Avoid overload and update timestamp even if we failed.
                cls.last_update_time = now
                cls.update_index += 1

        return cls.db_overrides
示例#4
0
 def post(self):
     """
     CREATE a new Game entity 
     """
     self.record_usage()
     namespace_manager.set_namespace(users.get_current_user().user_id())
     param_map = {}
     param_map['player_faction'] = self.request.get('player_faction')
     param_map['player_warcaster'] = self.request.get('player_warcaster')
     param_map['opponent_name'] = self.request.get('opponent_name', '')
     param_map['opponent_faction'] = self.request.get('opponent_faction')
     param_map['opponent_warcaster'] = self.request.get(
         'opponent_warcaster')
     param_map['result'] = self.request.get('result')
     param_map['size'] = int(self.request.get('size', 0))
     param_map['won'] = self.request.get('won') == 'true'
     param_map['draw'] = self.request.get('draw') == 'true'
     param_map['teaching'] = self.request.get('teaching') == 'true'
     param_map['location'] = self.request.get('location', '')
     param_map['game_type'] = self.request.get('game_type', '')
     date = self.request.get('date')
     try:
         real_date = datetime.datetime.strptime(date, '%m/%d/%Y')
     except (ValueError):
         real_date = datetime.datetime.strptime(date, '%Y-%m-%d')
     param_map['date'] = real_date
     param_map['created_at'] = datetime.datetime.now()
     logging.error(param_map)
     game = Game(**param_map)
     game.put()
     self.response.out.write(game.key.urlsafe())
    def setUp(self):
        super(CertificateCriteriaTestCase, self).setUp()

        self.base = '/' + self.COURSE_NAME
        context = actions.simple_add_course(
            self.COURSE_NAME, '*****@*****.**', 'Certificate Criteria')

        self.old_namespace = namespace_manager.get_namespace()
        namespace_manager.set_namespace('ns_%s' % self.COURSE_NAME)

        self.course = courses.Course(None, context)
        self.course.save()
        actions.login(self.STUDENT_EMAIL)
        actions.register(self, self.STUDENT_EMAIL)
        self.student = (
            models.StudentProfileDAO.get_enrolled_student_by_email_for(
                self.STUDENT_EMAIL, context))

        # Override course.yaml settings by patching app_context.
        self.get_environ_old = sites.ApplicationContext.get_environ
        self.certificate_criteria = []

        def get_environ_new(app_context):
            environ = self.get_environ_old(app_context)
            environ['certificate_criteria'] = self.certificate_criteria
            return environ

        sites.ApplicationContext.get_environ = get_environ_new
示例#6
0
 def delete(self, regexp):
     # NOTE(andrin): When a counter is deleted and used again afterwards
     #               it will not be harvested in the following case:
     #               - Instance A deletes counter C.
     #               - Instance B has C still in self.known_counter_names_
     #                 and increments C without updating the CounterNamesShards.
     #               - Instance A generates the harvest report and wont find C.
     #               To fix this issue, we reload the DefaultCounterNamesManager
     #               once a day.
     #               To fix this issue manually, you can just deploy a new
     #               version of your app.
     namespace = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(self.namespace)
         to_delete = []
         matcher = re.compile("(" + regexp + ")$")
         for name in self.all():
             if matcher.match(name):
                 to_delete += [name]
         for shard in CounterNamesShard.all():
             dirty = False
             for name in to_delete:
                 if name in shard.names:
                     shard.names.remove(name)
                     dirty = True
             if dirty:
                 shard.put()
         for name in to_delete:
             if name in self.known_counter_names_:
                 self.known_counter_names_.remove(name)
         return to_delete
     finally:
         namespace_manager.set_namespace(namespace)
示例#7
0
def outputPLstats(keyname, namespace = ''):
    import processDesires
    originalNamespace = namespace_manager.get_namespace()
    namespace_manager.set_namespace(namespace)
    try:
        meta = meSchema.metaAlg.get_by_key_name(keyname)
        trades = eval(meta.CashDelta)
        if namespace == '':
            stockList = ['HBC','CME','GOOG','INTC']
        else:
            stockList = [namespace]
        tradeDict = {}
        for stock in stockList:
            tradeDict[stock] = {'P':0.0,'L':0.0,'Ptrades':[],'Ltrades':[]}
        for trade in trades:
            stock = trade['Symbol']
            if not (trade['PandL'] <= -10.0 and trade['PandL'] >= -14.0) and trade['PandL'] - 10.0 > 0.0:
                tradeDict[stock]['P'] += trade['PandL'] - 10.0
                tradeDict[stock]['Ptrades'].append(trade['PandL'] - 10.0)
            elif not (trade['PandL'] <= -10.0 and trade['PandL'] >= -14.0) and trade['PandL'] - 10.0 < 0.0:
                tradeDict[stock]['L'] += trade['PandL'] - 10.0
                tradeDict[stock]['Ltrades'].append(trade['PandL'] - 10.0)
        for stock in tradeDict:
            try:
                stdDevP, meanP = processDesires.getStandardDeviationMean(tradeDict[stock]['Ptrades'])
                stdDevL, meanL = processDesires.getStandardDeviationMean(tradeDict[stock]['Ltrades'])
                print stock, ':', tradeDict[stock]['P'], ':', max(tradeDict[stock]['Ptrades']),
                print ':', len(tradeDict[stock]['Ptrades']), ':', meanP, ' stdDev:', stdDevP
                print stock, ':', tradeDict[stock]['L'], ':', min(tradeDict[stock]['Ltrades']),
                print ':', len(tradeDict[stock]['Ltrades']), ':', meanL, ' stdDev:', stdDevL
            except:
                print 'Error Encountered!'
    finally:
        namespace_manager.set_namespace(originalNamespace)
示例#8
0
    def init_xsrf_secret_if_none(cls):
        """Verifies that non-default XSRF secret exists; creates one if not."""

        # Any non-default value is fine.
        if XSRF_SECRET.value and XSRF_SECRET.value != XSRF_SECRET.default_value:
            return

        # All property manipulations must run in the default namespace.
        old_namespace = namespace_manager.get_namespace()
        try:
            namespace_manager.set_namespace(
                appengine_config.DEFAULT_NAMESPACE_NAME)

            # Look in the datastore directly.
            entity = ConfigPropertyEntity.get_by_key_name(XSRF_SECRET.name)
            if not entity:
                entity = ConfigPropertyEntity(key_name=XSRF_SECRET.name)

            # Any non-default non-None value is fine.
            if (entity.value and not entity.is_draft and
                (str(entity.value) != str(XSRF_SECRET.default_value))):
                return

            # Initialize to random value.
            entity.value = base64.urlsafe_b64encode(
                os.urandom(XSRF_SECRET_LENGTH))
            entity.is_draft = False
            entity.put()
        finally:
            namespace_manager.set_namespace(old_namespace)
示例#9
0
    def post(self):

        userNamespace = namespace_manager.get_namespace()
        namespace_manager.set_namespace('')

        results = {'result': False}
        user = self.current_user

        action = self.request.get('action')
        if (action == 'createPrivateArea'):
            # Anyone can create a private area
            newName = self.request.get('privateAreaName')
            newDisplayName = self.request.get('privateAreaDisplayName')
            results = self.createPrivateArea(newName, newDisplayName)
        elif (action == 'saveUsers'):
            if user.isAdmin:
                users = json.loads(self.request.get('newUserValues'))
                results = self.saveUsers(users)
            else:
                results['error'] = "User must be admin."
        resultJSON = json.dumps(results)
        self.response.headers[
            "Content-Type"] = 'application/json; charset=utf-8'
        self.response.out.write(resultJSON)

        namespace_manager.set_namespace(userNamespace)
  def put_copy(self, src, dst):
    """Copy file from src to dst.

    Metadata is copied.

    Args:
      src: /bucket/filename. This file must exist.
      dst: /bucket/filename
    """
    common.validate_file_path(src)
    common.validate_file_path(dst)


    ns = namespace_manager.get_namespace()
    try:
      namespace_manager.set_namespace('')
      src_blobkey = self._filename_to_blobkey(src)
      source = _AE_GCSFileInfo_.get_by_key_name(src_blobkey)
      token = self._filename_to_blobkey(dst)
      new_file = _AE_GCSFileInfo_(key_name=token,
                                  filename=dst,
                                  finalized=True)
      new_file.options = source.options
      new_file.etag = source.etag
      new_file.size = source.size
      new_file.creation = datetime.datetime.utcnow()
      new_file.put()
    finally:
      namespace_manager.set_namespace(ns)


    local_file = self.blob_storage.OpenBlob(src_blobkey)
    self.blob_storage.StoreBlob(token, local_file)
  def post_start_creation(self, filename, options):
    """Start object creation with a POST.

    This implements the resumable upload XML API.

    Only major limitation of current implementation is that we don't
    support multiple upload sessions for the same GCS file. Previous
    _AE_GCSFileInfo (which represents either a finalized file, or
    an upload session) will be removed when a new upload session is
    created.

    Args:
      filename: gcs filename of form /bucket/filename.
      options: a dict containing all user specified request headers.
        e.g. {'content-type': 'foo', 'x-goog-meta-bar': 'bar'}.

    Returns:
      a token (blobkey) used for continuing upload.
    """
    ns = namespace_manager.get_namespace()
    try:
      namespace_manager.set_namespace('')
      common.validate_file_path(filename)
      token = self._filename_to_blobkey(filename)
      gcs_file = _AE_GCSFileInfo_.get_by_key_name(token)

      self._cleanup_old_file(gcs_file)
      new_file = _AE_GCSFileInfo_(key_name=token,
                                  filename=filename,
                                  finalized=False)
      new_file.options = options
      new_file.put()
      return token
    finally:
      namespace_manager.set_namespace(ns)
示例#12
0
    def MakeFollows(self):
        """
        # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        ADD FOLLOWS FOR ADMIN USERS
        # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
        """
        nextURL = None
        firstURL = self.request.get('nexturl')
        query = PointRoot.query().order(PointRoot.url)
        if firstURL:
            query = query.filter(PointRoot.url >= firstURL)
        pointRoots = query.fetch(11)
        if len(pointRoots) == 11:
            nextURL = pointRoots[-1].url
            pointRootsToReview = pointRoots[:10]
        else:
            pointRootsToReview = pointRoots

        i = 0
        for pointRoot in pointRootsToReview:
            pointRootKey = pointRoot.key
            followers = {}

            versions = pointRoot.getAllVersions()
            for point in versions:
                if point.version == 1:
                    followers[point.authorURL] = 'created'
                elif not point.authorURL in followers:
                    followers[point.authorURL] = 'edited'

            for comment in pointRoot.getComments():
                if not comment.userUrl in followers:
                    followers[comment.userUrl] = 'commented'

            logging.info('ROOT: %s FOLLOWERS: %s' %
                         (pointRoot.url, str(followers)))
            for url in followers.iterkeys():
                followType = followers[url]
                previousNamespace = namespace_manager.get_namespace()
                if previousNamespace and previousNamespace != '':
                    namespace_manager.set_namespace('')  # DEFAULT NAMESPACE
                    usr = WhysaurusUser.getByUrl(url)
                    namespace_manager.set_namespace(previousNamespace)
                else:
                    usr = WhysaurusUser.getByUrl(url)
                logging.info('Trying to follow for U:%s, R:%s, T:%s' %
                             (url, pointRoot.url, followType))
                f = None
                f = Follow.createFollow(usr.key, pointRootKey, followType)
                if f:
                    i = i + 1
                    logging.info('ADDED follow for U:%s, R:%s, T:%s' %
                                 (url, pointRoot.url, followType))

        logging.info('Added %d follows' % i)
        if nextURL:
            t = Task(url="/MakeFollows", params={'nexturl': nextURL})
            t.add(queue_name="notifications")
            logging.info('Requeing MakeFollows task to start at url %s ' %
                         nextURL)
示例#13
0
文件: utils.py 项目: twiffy/eabooc
    def init_xsrf_secret_if_none(cls):
        """Verifies that non-default XSRF secret exists; creates one if not."""

        # Any non-default value is fine.
        if XSRF_SECRET.value and XSRF_SECRET.value != XSRF_SECRET.default_value:
            return

        # All property manipulations must run in the default namespace.
        old_namespace = namespace_manager.get_namespace()
        try:
            namespace_manager.set_namespace(
                appengine_config.DEFAULT_NAMESPACE_NAME)

            # Look in the datastore directly.
            entity = ConfigPropertyEntity.get_by_key_name(XSRF_SECRET.name)
            if not entity:
                entity = ConfigPropertyEntity(key_name=XSRF_SECRET.name)

            # Any non-default non-None value is fine.
            if (entity.value and not entity.is_draft and
                (str(entity.value) != str(XSRF_SECRET.default_value))):
                return

            # Initialize to random value.
            entity.value = base64.urlsafe_b64encode(
                os.urandom(XSRF_SECRET_LENGTH))
            entity.is_draft = False
            entity.put()
        finally:
            namespace_manager.set_namespace(old_namespace)
 def setUp(self):
     unittest.TestCase.setUp(self)
     self.appid = "testapp"
     os.environ["APPLICATION_ID"] = self.appid
     os.environ["AUTH_DOMAIN"] = "gmail.com"
     self.resetDatastore()
     namespace_manager.set_namespace(None)
 def post(self):
   ns = self.request.get('ns')
   namespace_manager.set_namespace(ns)
   greeting = Greeting(key_name = self.request.get('key'))
   greeting.content = self.request.get('value')
   key = greeting.put()
   self.response.out.write("success!")
示例#16
0
def timeseries_query(timeseries):
    project_id = list(field.value for field in timeseries.fields
                      if field.key == 'project_id')
    if not project_id:
        raise ndb.Return()
    project_id = project_id[0]
    namespace_manager.set_namespace('projects.%s' % project_id)
    query = TimeSeriesModel.query()
    fieldmodels = []
    for field in timeseries.fields:
        fieldmodels.append(FieldModel(field_key=field.key, value=field.value))
    for fieldmodel in fieldmodels:
        query = query.filter(TimeSeriesModel.fields == fieldmodel)
    query = query.filter(TimeSeriesModel.metric == timeseries.metric)
    ts = yield query.get_async()
    if ts == None:
        ts = TimeSeriesModel(points=[],
                             fields=fieldmodels,
                             metric=timeseries.metric)
    ts.update_timestamp()
    ts.points = [
        PointModel(time=point.time, value=point.value)
        for point in timeseries.points
    ]
    yield ts.put_async()
    raise ndb.Return()
示例#17
0
def outputPerStockHistoryForChart(keyname):
    from math import floor,ceil
    
    originalNamespace = namespace_manager.get_namespace()
    try:
        namespace_manager.set_namespace('')
        meta = meSchema.metaAlg.get_by_key_name(keyname)
    finally:
        namespace_manager.set_namespace(originalNamespace)
    stopSteps = []
    history = eval(meta.history)
    for hist in history:
        stopSteps.append(hist['step'])
    stopSteps.sort()
    trades = eval(meta.CashDelta)
    returnDict = {'HBC':{},'CME':{},'GOOG':{},'INTC':{}}
    for stopStep in stopSteps:
        for key in returnDict:
            returnDict[key][stopStep] = 0.0
    for trade in trades:
        tradeIndex = (trade['step'] - stopSteps[0])/400.0
        stopStep = stopSteps[int(ceil(tradeIndex))]
        returnDict[trade['Symbol']][stopStep] += trade['PandL']
    for stock in returnDict:
        print stock,':',
        for step in stopSteps:
            print returnDict[stock][step],
        print
示例#18
0
    def get(self, vendorid, deviceid):
        try:
            namespace_manager.set_namespace(vendorid)
        except:
            self.error(400)
            return

        if not validate_did(deviceid):
            self.error(400)
            return

        deviceid = deviceid.lower()
        node = DeviceNode.get_by_id(deviceid)
        last_update = None
        if node is not None:
            last_update = datetime.datetime.now() - node.last_seen
        logging.info('last_update: ' + str(last_update))

        clientid = vendorid + deviceid
        token = channel.create_channel(clientid)
        # logging.info('token ' + token)

        template_values = {
            'token': token,
            'vendorid': vendorid,
            'deviceid': deviceid,
            'node': node,
            'last_update': fuzzy_readable_time(last_update),
        }

        template = JINJA_ENVIRONMENT.get_template('index.html')
        self.response.write(template.render(template_values))

        return
示例#19
0
文件: tests.py 项目: ksh/gpitraining
    def test_config_visible_from_any_namespace(self):
        """Test that ConfigProperty is visible from any namespace."""

        assert (
            config.UPDATE_INTERVAL_SEC.value ==
            config.UPDATE_INTERVAL_SEC.default_value)
        new_value = config.UPDATE_INTERVAL_SEC.default_value + 5

        # Add datastore override for known property.
        prop = config.ConfigPropertyEntity(
            key_name=config.UPDATE_INTERVAL_SEC.name)
        prop.value = str(new_value)
        prop.is_draft = False
        prop.put()

        # Check visible from default namespace.
        config.Registry.last_update_time = 0
        assert config.UPDATE_INTERVAL_SEC.value == new_value

        # Check visible from another namespace.
        old_namespace = namespace_manager.get_namespace()
        try:
            namespace_manager.set_namespace(
                'ns-test_config_visible_from_any_namespace')

            config.Registry.last_update_time = 0
            assert config.UPDATE_INTERVAL_SEC.value == new_value
        finally:
            namespace_manager.set_namespace(old_namespace)
示例#20
0
    def post(self):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        bandid = self.request.get('bandid')
        logging.info('bandid: ' + bandid)
        try:
            namespace_manager.set_namespace(bandid)
        except:
            self.error(400);
            return

        name = self.request.get('name')
        interpreter = self.request.get('interpreter')
        comment = self.request.get('comment')
        song = SongNode.get_by_id(name+interpreter)
        if not song:
            self.error(404)
            
        song.comments.append(comment + ' (' + user.nickname() + ')')
        song.put()
        song_url=urllib.quote('/' + bandid + '/song/' + song.name + '/' + song.interpreter)
        send_notifications(song,'http://' + self.request.host + song_url, 'comment', user)
        self.redirect(song_url)
示例#21
0
def convertMetaAlgToMetaAlgStats(startStep, stopStep, technique, namespace):
    namespace_manager.set_namespace(namespace)
    try:
        query = meSchema.metaAlg.all().filter('startStep =', startStep).filter('stopStep =', stopStep).filter('technique =', technique)
        results = query.fetch(500)
        if len(results) == 0:
            return
        percentReturns = []
        Positive = 0
        for metaAlg in results:
            percentReturns.append(metaAlg.percentReturn)
            if metaAlg.percentReturn >= 0:
                Positive += 1
        Min = min(percentReturns)
        Max = max(percentReturns)
        n = len(percentReturns)
        Mean = sum(percentReturns)/n
        percentReturns.sort()
        if n%2 == 0:
            mid = n/2
            Median = (percentReturns[mid-1] + percentReturns[mid])/2
        else:
            Median = percentReturns[n/2]
        PercentPositive = Positive/float(n)
        stepRange = stopStep - startStep
        key_name = str(stepRange).rjust(7,'0') + '-' + str(startStep).rjust(7,'0') + '-' + str(stopStep).rjust(7,'0') + '-' + technique
        metaAlgStat = meSchema.metaAlgStat(key_name = key_name,
                                           Min = Min, Median = Median, Mean = Mean, Max = Max,
                                           Positive = PercentPositive, stopStep = stopStep,
                                           startStep = startStep, stepRange = stepRange, technique = technique)
        db.put(metaAlgStat)
    finally:
        namespace_manager.set_namespace('')
示例#22
0
def update_note_parents(entity):
	"""Update note parents property"""
	namespace = namespace_manager.get_namespace()
	if namespace != 'newyear':
		namespace_manager.set_namespace('newyear')
	entity.parents = get_note_parents(entity)
	yield op.db.Put(entity)
示例#23
0
def add_event(customer_id, content_id, time, user_ip, user_user_agent,
              user_location):
    """Store event and content name in Datastore"""

    log.info(
        "customer_id: {}, content_id {}, event_time {}, ip {}, user_agent {}, "
        "location {}".format(
            customer_id, content_id, time, user_ip, user_user_agent,
            user_location))

    previous_namespace = namespace_manager.get_namespace()
    try:
        namespace_manager.set_namespace(customer_id)
        load_content_name_if_needed(content_id)
        ndb_model.Event(
            content_id=content_id,
            time=datetime.datetime.fromtimestamp(time / 1000.0),
            user_ip=user_ip,
            user_user_agent=user_user_agent,
            user_location=user_location).put()
        log.info("Stored Event entity")
        return True
    except Exception as ex:
        log.warning("Unable to store entity")
        log.warning(ex.message)
        return False
    finally:
        namespace_manager.set_namespace(previous_namespace)
示例#24
0
def push_batch():
  """Push all the events that have been caused by this request."""
  batch = flask.g.get('events', None)
  setattr(flask.g, 'events', None)
  if batch is None:
    return

  logging.info('Sending %d events to proxy', len(batch))
  pusher_shim = pusher_client.get_client()

  # Now figure out what channel to post these to.
  # Building id should always be in the namespace
  # for any request which triggers events.
  # So we use the namespace.  Horrid.
  assert namespace_manager.get_namespace() != ''
  building_id = namespace_manager.get_namespace()

  try:
    namespace_manager.set_namespace(None)
    proxies = Proxy.query(Proxy.building_id == building_id).iter()
    for proxy in proxies:
      channel_id = 'private-%s' % proxy.key.string_id()
      logging.info('Pushing %d events to channel %s', len(batch), channel_id)
      pusher_shim.push(channel_id, batch)
  finally:
    namespace_manager.set_namespace(building_id)
示例#25
0
def dashboard(self):

    status = []
    cquery = CronUrlDB3.all()
    for cronUrlDB in cquery:
      namespace_manager.set_namespace(str(cronUrlDB.key()))
      query = StatDB3.all()
      if query.count() > 0:
        n_errors = 0
        n_retrys = 0
        for statDB in query:
          n_errors += statDB.n_errors
          n_retrys += statDB.n_retrys
        if n_errors > 4:
          image = 'level3.png'
        elif n_errors > 1:
          image = 'level2.png'
        elif n_retrys > 0:
          image = 'level1.png'
        else:
          image = 'level0.png'
      else:
        image = 'level.png'
      status.append((cronUrlDB, image))

    namespace_manager.set_namespace('') # remove namespace

    template_values = {
      'style': style,
      'header': header(self),
      'footer': footer(self),
      'urlDBs': UrlDB.all(),
      'status': status,
    }
    printHtml(self, 'checkurl.html', template_values)
  def post_attendance(self, request):
    """Register whether or not a single student attended class.
    
    Arguments
      request: an AttendanceRecord message.

    Returns:
      An instance of message_types.VoidMessage.
    """
    current_user = endpoints.get_current_user()
    app_id = os.environ['APPLICATION_ID']
    if app_id.startswith('dev~') or app_id == 'testbed-test':
      email = '*****@*****.**'
    else:
      if current_user is None:
        raise endpoints.UnauthorizedException('Invalid token.')
      email = current_user.email()

    domain = email.split('@')[1]
    if domain == 'gmail.com': domain = ''
    namespace_manager.set_namespace(domain)

    student_key = ndb.Key('Student', request.student)
    student = student_key.get()
    if not student:
      raise endpoints.BadRequestException('No student: %s' % request.student)
    classname_key = ndb.Key('Class', request.classname)
    classname = classname_key.get()
    if not classname:
      raise endpoints.BadRequestException('No class: %s' % request.classname)

    if not AttendanceAPI.is_enrolled(classname, student_key):
      raise endpoints.BadRequestException(
        'Student %s is not enrolled in class %s' % (student_key, classname.name))

    today = AttendanceAPI.today_as_ordinal(classname.timezone)
    if request.date != today:
      raise endpoints.BadRequestException('Date must be %s, but is: %s' 
                                          % (today, request.date))

    logging.info('Updating class: %s student: %s date: %s user: %s attend: %s' % 
                 (classname.name, request.student, request.date, 
                  email, request.attended))

    attendance_key = ndb.Key('Class', request.classname, 
                             'Attendance', request.date)
    attendance = attendance_key.get()
    if not attendance:
      attendance = Attendance(key=attendance_key, attending=[])
    if request.attended:
      if not AttendanceAPI.is_present(attendance, student_key):
        attendance.attending.append(StudentPresent(student=student_key))
        attendance.put()
    else:
      try:
        attendance.attending.remove(student_present)
        attendance.put()
      except ValueError:
        pass
    return message_types.VoidMessage()
示例#27
0
    def get(self, bandid):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        logging.info('bandid: ' + bandid)
        try:
            namespace_manager.set_namespace(bandid)
        except:
            self.error(400);
            return

        conf = Configuration.get_by_id("singleton")
        if user not in conf.users:
            conf.users.append(user)
            # TODO: For now users are authenticated by default.  This should
            # probably be a configuration parameter.
            conf.auth_users.append(user)
            conf.put()
        ranking_query = SongNode.query().order(-SongNode.vote_cnt)
        ranking_query = ranking_query.filter(SongNode.vote_cnt < conf.votes_to_graduate)
        songs = ranking_query.fetch(50)

        template_values = {
            'is_admin': conf.admin == user,
            'songs': songs,
            'band_name': conf.name,
            'bandid': bandid,
            'logout_uri': users.create_login_url(self.request.uri),
            'votes_to_graduate': conf.votes_to_graduate
        }

        template = JINJA_ENVIRONMENT.get_template('ranking.html')
        self.response.write(template.render(template_values))
示例#28
0
    def post(self):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        bandid = self.request.get('bandid')
        logging.info('bandid: ' + bandid)
        try:
            namespace_manager.set_namespace(bandid)
        except:
            self.error(400);
            return

        conf = Configuration.get_by_id("singleton")
        if user not in conf.auth_users:
            logging.info("letting an unauthed users vote... for now")

        votes = self.request.get_all('votes')
        for songid in votes:
            logging.info('songid:' + songid + 'len: ' + str(len(songid)))
            song = SongNode.get_by_id(songid)
            song_url=urllib.quote('/' + bandid + '/song/' + song.name + '/' + song.interpreter)
            if user not in song.votes:
                send_notifications(song,'http://' + self.request.host + song_url, 'vote', user)
                song.votes.append(user)
                song.vote_cnt += 1
                song.graduated = song.vote_cnt >= VOTES_TO_GRADUATE
                song.put()

        self.redirect('/' + bandid + '/thanks')
示例#29
0
    def get(self, bandid, name, interpreter):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        logging.info('bandid: ' + bandid)
        try:
            namespace_manager.set_namespace(bandid)
        except:
            self.error(400);
            return

        song = SongNode.get_by_id(name+interpreter)
        if not song:
            logging.error("Cant find song id = " + name + interpreter)
            self.error(404);
            return

        template_values = {
            'song': song,
            'last_update': fuzzy_readable_time(datetime.datetime.now() - song.last_update),
            'bandid': bandid,
            'user_has_voted': user in song.votes
        }

        template = JINJA_ENVIRONMENT.get_template('song.html')
        self.response.write(template.render(template_values))
示例#30
0
    def get(self, bandid):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        logging.info('bandid: ' + bandid)
        try:
            namespace_manager.set_namespace(bandid)
        except:
            self.error(400);
            return
        
        conf = Configuration.get_by_id("singleton")

        if conf.admin == None:
            conf.admin = user
            conf.put()

        if conf.admin != user:
            self.error(401);
            return

        template_values = {
            'admin': conf.admin,
            'users': conf.users,
            'auth_users': conf.auth_users,
            'bandid': bandid,
        }

        template = JINJA_ENVIRONMENT.get_template('config.html')
        self.response.write(template.render(template_values))
示例#31
0
    def post(self):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))
        votes_to_graduate = self.request.get('votes_to_graduate')
        name = self.request.get('name')
        bandid = urllib.quote(name.replace(' ', '-').lower())
        if not name or not votes_to_graduate or Bands.get_by_id(bandid):
            msg = "Requested group exists already"
	else:
            msg = "New band created successfully"
            Bands(id=bandid).put()
            namespace_manager.set_namespace(bandid)
            conf = Configuration(id="singleton")
            conf.name = name
            conf.votes_to_graduate = int(votes_to_graduate)
            conf.put()

        template_values = {
            'bandid': bandid,
            'name': name,
            'votes_to_graduate': votes_to_graduate,
            'msg': msg 
        }

        template = JINJA_ENVIRONMENT.get_template('confirm.html')
        self.response.write(template.render(template_values))
    def testGenerator(self):
        """Test generator functionality."""
        expected_keys = []
        for _ in range(0, 100):
            expected_keys.append(TestEntity().put())

        namespace_manager.set_namespace("google")
        for _ in range(0, 100):
            expected_keys.append(TestEntity().put())
        namespace_manager.set_namespace(None)

        kranges = [
            key_range.KeyRange(
                key_start=key(25), key_end=key(50), direction="ASC", include_start=False, include_end=True
            ),
            key_range.KeyRange(
                key_start=key(110, namespace="google"),
                key_end=key(150, namespace="google"),
                direction="ASC",
                include_start=False,
                include_end=True,
                namespace="google",
            ),
        ]
        query_range = input_readers.DatastoreKeyInputReader(ENTITY_KIND, kranges, 50)

        keys = []

        for k in query_range:
            keys.append(k)

        self.assertEquals(65, len(keys))
        self.assertEquals(expected_keys[25:50] + expected_keys[110:150], keys)
示例#33
0
    def testNamespaces(self):
        """Tests namespace support."""

        from google.appengine.api import namespace_manager

        namespace = namespace_manager.get_namespace()

        class Author(db.Model):
            name = db.StringProperty()

        class Book(db.Model):
            title = db.StringProperty()

        try:
            namespace_manager.set_namespace("testing")
            a = Author(name="Douglas Adams", key_name="douglasadams")
            a.put()

            b = Book(parent=a, title="Last Chance to See")
            b.put()

            query = Book.all().filter("title =", "Last Chance to See")
            self.assertEqual(query.get().title, b.title)
        finally:
            namespace_manager.set_namespace(namespace)

        query = Book.all().filter("title =", "Last Chance to See")
        self.assertEqual(query.get(), None)
示例#34
0
 def MakeLinksAllAreas(self):
     q = PrivateArea.query()
     for pa in q.iter():
         logging.info("Kicking off the make links for private area: " +
                      pa.name)
         namespace_manager.set_namespace(pa.name)
         self.MakeLinks()
示例#35
0
    def setUp(self):
        super(NewsTestBase, self).setUp()
        self.base = '/' + self.COURSE_NAME
        self.app_context = actions.simple_add_course(
            self.COURSE_NAME, self.ADMIN_EMAIL, 'Title')
        self.maxDiff = None  # Show full text expansion of expect mismatches.

        # Simplify equivalence checks by supplying a deep comparator, rather
        # than getting object instance equality comparison.
        def news_items_are_equal(thing_one, thing_two):
            return (thing_one.resource_key == thing_two.resource_key and
                    thing_one.when == thing_two.when and
                    thing_one.url == thing_two.url and
                    thing_one.labels == thing_two.labels)
        news.NewsItem.__eq__ = news_items_are_equal
        news.NewsItem.__repr__ = lambda x: x.__dict__.__repr__()
        def seen_items_are_equal(thing_one, thing_two):
            return (thing_one.resource_key == thing_two.resource_key and
                    abs((thing_one.when - thing_two.when).total_seconds()) < 2)
        news.SeenItem.__eq__ = seen_items_are_equal
        news.SeenItem.__repr__ = lambda x: x.__dict__.__repr__()
        news.I18nTitleRegistry.register(
            'test', lambda x: 'Test Item ' + x.split(':', 1)[1])

        self.old_namespace = namespace_manager.get_namespace()
        namespace_manager.set_namespace(self.NAMESPACE)

        # News is always enabled during own-module tests so that we do not
        # accumulate any regressions within ourselves.  Other modules are
        # free to simply disable if they wish.
        self.save_is_enabled = news.is_enabled
        news.is_enabled = lambda: True
        if not news.custom_module.enabled:
            news.custom_module.enable()
示例#36
0
    def get_overrides(cls, force_update=False):
        """Returns current property overrides, maybe cached."""

        now = long(time.time())
        age = now - cls.last_update_time
        max_age = UPDATE_INTERVAL_SEC.get_value(db_overrides=cls.db_overrides)
        if force_update or age < 0 or age >= max_age:
            # Value of '0' disables all datastore overrides.
            if UPDATE_INTERVAL_SEC.get_value() == 0:
                cls.db_overrides = {}
                return cls.db_overrides

            # Load overrides from a datastore.
            try:
                old_namespace = namespace_manager.get_namespace()
                try:
                    namespace_manager.set_namespace(
                        appengine_config.DEFAULT_NAMESPACE_NAME)

                    cls.load_from_db()
                finally:
                    namespace_manager.set_namespace(old_namespace)
            except Exception as e:  # pylint: disable-msg=broad-except
                logging.error(
                    'Failed to load properties from a database: %s.', str(e))
            finally:
                # Avoid overload and update timestamp even if we failed.
                cls.last_update_time = now
                cls.update_index += 1

        return cls.db_overrides
    def setUp(self):
        super(ExtraTabsTests, self).setUp()

        self.base = '/' + COURSE_NAME
        app_context = actions.simple_add_course(
            COURSE_NAME, ADMIN_EMAIL, 'Extra Tabs Course')
        self.old_namespace = namespace_manager.get_namespace()
        namespace_manager.set_namespace('ns_%s' % COURSE_NAME)

        self.course = courses.Course(None, app_context)

        courses.Course.ENVIRON_TEST_OVERRIDES = {
            'course': {
                'extra_tabs': [
                    {
                        'label': 'FAQ',
                        'position': 'left',
                        'visibility': 'all',
                        'url': '',
                        'content': 'Frequently asked questions'},
                    {
                        'label': 'Resources',
                        'position': 'right',
                        'visibility': 'student',
                        'url': 'http://www.example.com',
                        'content': 'Links to resources'}]
            }
        }
        self.faq_url = 'modules/extra_tabs/render?index=0'

        actions.login(STUDENT_EMAIL, is_admin=False)
        actions.register(self, STUDENT_NAME)
示例#38
0
	def post(self):
		
		logging.info('self.request')
		logging.info(self.request)

		token = self.request.get('token')
		version = self.request.get('appver')
		if not version:
			version = 0
		path = self.request.path
		pathArray = path.split("/")
		apiVersion = int(pathArray[2])
		aID = pathArray[3]
		cTime = int(time.time())
		auInfo={}
		aInfo={}
		param={}
		allresult={}
		gdNamespace = namespace_manager.get_namespace()
		appNamespace = 'APP_'+aID




		namespace_manager.set_namespace(gdNamespace)
		#find app
		try:
			aInfo = DB_App.get_by_id(aID)
		except Exception, e:
			self.printError("dont find app1",100,aInfo.secretKey)
			return
示例#39
0
    def process(self, resource_id, *args, **kwargs):
        from voluptuous import Schema
        from google.appengine.api import namespace_manager

        namespace_manager.set_namespace('_x_')

        session_store = sessions.get_store(request=self.request)
        session = session_store.get_session()

        if not 'u' in session:
            self.about(403)
            return

        obj = json.loads(self.request.body)
        schema = Schema(self.schema, extra=True)

        try:
            obj = schema(obj)
        except:
            logging.exception('validation failed')

        session_store = sessions.get_store()
        session = session_store.get_session()

        school_key = ndb.Key(urlsafe = session.get('s'))

        obj['school'] = school_key

        entity = self.entity.from_dict(obj)
        entity.put()

        self.write_json_response(entity.to_dict())
示例#40
0
def claim_proxy():
  """Claim the given proxy id for the current user."""
  body = flask.request.get_json()
  if body is None:
    flask.abort(400, 'JSON body and mime type required.')

  proxy_id = body.get('proxy_id', None)
  if proxy_id is None or proxy_id == '':
    flask.abort(400, 'proxy_id required.')

  # this will run as a user, so we don't need to authenticate
  # it (already done in main).  Running in users namespace.
  assert namespace_manager.get_namespace() != ''
  building_id = namespace_manager.get_namespace()

  # We need to reset the namespace to access the proxies
  namespace_manager.set_namespace(None)
  proxy = Proxy.get_by_id(proxy_id)
  if proxy == None:
    logging.info('Proxy \'%s\' not found', proxy_id)
    flask.abort(404)

  if proxy.building_id is not None:
    flask.abort(400, 'Proxy already claimed')

  proxy.building_id = building_id
  proxy.put()
  return ('', 201)
示例#41
0
 def run_tasks(self, url=None, queue_name=None, method='POST', response_status_code=200, **kwargs):
     """
     Helper method to execute a specific group of tasks
     :param user:
     :param queue_name:
     :param queue_url:
     :param kwargs:
     :return:
     """
     from google.appengine.api import namespace_manager
     tasks = self.taskqueue_stub.get_filtered_tasks(url=url,
                                                    queue_names=[queue_name])
     for task in tasks:
         namespace = task.headers.get('X-AppEngine-Current-Namespace', '')
         previous_namespace = namespace_manager.get_namespace()
         try:
             namespace_manager.set_namespace(namespace)
             headers = {
                     k: v for k, v in task.headers.iteritems()
                     if k.startswith('X-AppEngine')}
             if method == 'PUT':
                 response = self.testapp.put(url, task.payload, headers=headers, status='*')
             else:
                 response = self.testapp.post(url, task.payload, headers=headers, status='*')
         finally:
             namespace_manager.set_namespace(previous_namespace)
示例#42
0
 def get(self,propkey):
     #memcache namespace changes UNTESTED FIXME
     propkey = sanitizeinputwords(propkey)
     major_ver, minor_ver = os.environ.get('CURRENT_VERSION_ID').rsplit('.', 1)
     namespace_manager.set_namespace(major_ver)
     logging.debug("namespace: " + major_ver)
     p = memcache.get(propkey)
     if p is not None:
         logging.debug("from memcache: " + propkey)
         self.response.headers["Content-Type"] = "application/json"
         self.response.out.write(json.dumps(p, sort_keys=True,indent=4, separators=(',', ': ')))
     else:
         detailurl = "http://my.appleton.org/Propdetail.aspx?PropKey=" + str(propkey)
         datagroups = []
         try:
             docroot = lxml.html.fromstring(urllib2.urlopen(detailurl).read())
             tables = docroot.xpath("//table[@class='t1']")
             for table in tables:
                 ths = table.xpath("./tr/th") #assuming single <th> per table
                 for th in ths:
                     if th is not None:
                         lxml.etree.strip_tags(th, 'a', 'b', 'br', 'span', 'strong')
                         if th.text:
                             thkey = re.sub('\W', '', th.text).lower() #nospaces all lower
                             datagroups.append(thkey)
                             if th.text.strip() == "Businesses":
                                 logging.debug("found Business <th>")
                                 tdkey = "businesses"
                                 businesslist = []
                                 tds = table.xpath("./tr/td")
                                 if tds is not None:
                                     for td in tds:
                                         lxml.etree.strip_tags(td, 'a', 'b', 'br', 'span', 'strong')
                                         businesslist.append(td.text.strip())
                                 logging.debug("businesslist: " + str(businesslist))
                             datadict = {}
                             tdcounter = 0
                             tds = table.xpath("./tr/td")
                             if tds is not None:
                                 for td in tds:
                                     lxml.etree.strip_tags(td, 'a', 'b', 'br', 'span', 'strong')
                                     if tdcounter == 0:
                                         tdkey = re.sub('\W', '', td.text).lower() if td.text else ''
                                         tdcounter += 1
                                     else:
                                         tdvalue = td.text.strip().title() if td.text else ''
                                         tdvalue = " ".join(tdvalue.split()) #remove extra whitespace
                                         tdcounter = 0
                                         #when the source tr + td are commented out lxml still sees them. PREVENT!
                                         if tdkey == '' and tdvalue == '':
                                             break
                                         else:
                                             datadict[tdkey] = tdvalue
                                 datagroups.append(datadict)
             logging.debug("setting memcache for key: " + propkey)
             memcache.add(str(propkey),datagroups)
             self.response.headers["Content-Type"] = "application/json"
             self.response.out.write(json.dumps(datagroups, sort_keys=True,indent=4, separators=(',', ': ')))
         except urllib2.HTTPError, response:
             self.response.out.write( 'error - Scrape: ' + str(response))
  def post_start_creation(self, filename, options):
    """Start object creation with a POST.

    This implements the resumable upload XML API.

    Only major limitation of current implementation is that we don't
    support multiple upload sessions for the same GCS file. Previous
    _AE_GCSFileInfo (which represents either a finalized file, or
    an upload session) will be removed when a new upload session is
    created.

    Args:
      filename: gcs filename of form /bucket/filename.
      options: a dict containing all user specified request headers.
        e.g. {'content-type': 'foo', 'x-goog-meta-bar': 'bar'}.

    Returns:
      a token (blobkey) used for continuing upload.
    """
    ns = namespace_manager.get_namespace()
    try:
      namespace_manager.set_namespace('')
      common.validate_file_path(filename)
      token = self._filename_to_blobkey(filename)
      gcs_file = _AE_GCSFileInfo_.get_by_key_name(token)

      self._cleanup_old_file(gcs_file)
      new_file = _AE_GCSFileInfo_(key_name=token,
                                  filename=filename,
                                  finalized=False)
      new_file.options = options
      new_file.put()
      return token
    finally:
      namespace_manager.set_namespace(ns)
示例#44
0
 def wrapped_method(*args, **kwargs):
   original_namespace = namespace_manager.get_namespace()
   try:
     namespace_manager.set_namespace(DATASTORE_NAMESPACE)
     return original_method(*args, **kwargs)
   finally:
     namespace_manager.set_namespace(original_namespace)
    def setUp(self):
        super(CertificateCriteriaTestCase, self).setUp()
        self.base = '/' + self.COURSE_NAME
        context = actions.simple_add_course(
            self.COURSE_NAME, self.ADMIN_EMAIL, 'Certificate Criteria')

        self.old_namespace = namespace_manager.get_namespace()
        namespace_manager.set_namespace('ns_%s' % self.COURSE_NAME)

        self.course = courses.Course(None, context)
        self.course.save()
        self.TEST_USER = actions.login('*****@*****.**')
        actions.register(self, self.TEST_USER.email())
        self.student = (
            models.StudentProfileDAO.get_enrolled_student_by_user_for(
                self.TEST_USER, context))

        # Override course.yaml settings by patching app_context.
        self.get_environ_old = sites.ApplicationContext.get_environ
        self.certificate_criteria = []

        def get_environ_new(app_context):
            environ = self.get_environ_old(app_context)
            environ['certificate_criteria'] = self.certificate_criteria
            return environ

        sites.ApplicationContext.get_environ = get_environ_new
示例#46
0
 def Projects(self, sub):
     if sub != None:
         namespace_manager.set_namespace(None)
         rootUser = UserProfile.all().filter("user", users.get_current_user()).get()
         if rootUser != None:
             return rootUser.projects
     return "" if self.projects is None else self.projects  # should be blank...
示例#47
0
    def processOfRequest(self):
        self.response.headers['Content-Type'] = 'application/json'
        #		if self.checkAccessIPAddress() == False:
        #			return
        try:
            is_login, user_email = self.checkLogin(not_redirect=True)
            if is_login == False:
                self._code = 403
                self._msg = self.getMsg('MSG_NOT_LOGINED')
                self.responseAjaxResult()
                return

            # Requestからvoにセット
            req = UcfVoInfo.setRequestToVo(self)

            start = int(req['start'])
            limit = int(req['limit'])

            namespace_manager.set_namespace('')

            sk_target_domain = UcfUtil.getHashStr(req,
                                                  'sk_target_domain').lower()
            q = sateraito_func.AddOnHistory.all()
            if sk_target_domain != '':
                q.filter('target_domain >= ', sk_target_domain)
                q.filter('target_domain < ',
                         ''.join(sk_target_domain + u'\uFFE0'))
            count = 0
            fetch_data = None
            count = q.count()
            fetch_data = q.fetch(limit, start)
            result_list = []
            for entry in fetch_data:
                vo = {}
                vo['target_domain'] = UcfUtil.nvl(entry.target_domain)
                vo['application_id'] = UcfUtil.nvl(entry.application_id)
                vo['is_available'] = UcfUtil.nvl(entry.is_available)
                vo['reason'] = UcfUtil.nvl(entry.reason)
                vo['ip_address'] = UcfUtil.nvl(entry.ip_address)
                vo['user_id'] = UcfUtil.nvl(entry.user_id)
                vo['log_text'] = UcfUtil.nvl(entry.log_text)
                vo['user_agent'] = UcfUtil.nvl(entry.user_agent)
                #vo['result_code'] = UcfUtil.nvl(entry.result_code)
                #vo['result_message'] = UcfUtil.nvl(entry.result_message)
                vo['created_date'] = UcfUtil.nvl(
                    UcfUtil.getLocalTime(entry.created_date, self._timezone))
                vo['updated_date'] = UcfUtil.nvl(
                    UcfUtil.getLocalTime(entry.updated_date, self._timezone))
                result_list.append(vo)

            ret_value = {'all_count': str(count), 'records': result_list}

            self._code = 0
            self.responseAjaxResult(ret_value)

        except BaseException, e:
            self.outputErrorLog(e)
            self._code = 999
            self.responseAjaxResult()
示例#48
0
    def addIfNew(self, names):
        new_names = []
        fresh = None
        for name in names:
            if name not in self.known_counter_names_:
                if fresh == None:
                    fresh = self.all()
                    if name not in fresh:
                        new_names += [name]
                else:
                    new_names += [name]
        if new_names:
            namespace = namespace_manager.get_namespace()
            try:
                namespace_manager.set_namespace(self.namespace)
                if self.last_shard_ == None:
                    CounterNamesShard.get_or_insert("0")
                    self.last_shard_ = 0
                ADD_SUCCESS = 1
                ADD_FULL = 2
                ADD_FAIL = 3

                def addNames(key, names):
                    record = db.get(key)
                    local_names = set(record.names)
                    for name in names:
                        if name not in local_names:
                            local_names.add(name)
                            record.names += [name]
                    try:
                        record.put()
                        return ADD_SUCCESS
                    except (RequestTooLargeError, ValueError):
                        if len(names) == len(record.names):
                            return ADD_FAIL
                        else:
                            return ADD_FULL

                result = None
                try:
                    result = db.run_in_transaction(
                        addNames,
                        db.Key.from_path('CounterNamesShard',
                                         str(self.last_shard_)), new_names)
                except:
                    result = ADD_FAIL
                if result == ADD_FULL:
                    CounterNamesShard.get_or_insert(str(self.last_shard_ + 1))
                    self.addIfNew(names)
                if result == ADD_SUCCESS:
                    logging.info("Registered new counter names: %s." %
                                 ",".join(new_names))
                else:
                    logging.warning(
                        "Coudn't register counter names: %s. (Will retry next time)"
                        % ",".join(new_names))
            finally:
                namespace_manager.set_namespace(namespace)
        return (not not fresh, len(new_names))
示例#49
0
 def persist_namespace(self):
     forced_namespace = self.request.get("namespace")
     log.info('forced namespace'.format(forced_namespace))
     namespace_manager.set_namespace(forced_namespace)
     self.response.set_cookie('namespace',
                              forced_namespace,
                              expires=datetime.datetime.now() +
                              datetime.timedelta(days=365))
示例#50
0
    def __init__(self, request=None, response=None):
        from sosbeacon.group import Group
        from sosbeacon.group import group_schema
        from google.appengine.api import namespace_manager
        namespace_manager.set_namespace('_x_')

        super(GroupHandler, self).__init__(Group, group_schema, request,
                                           response)
示例#51
0
def stats_v1():
    namespace_manager.set_namespace('VER_2')
    data = {
        "version": namespace_manager.get_namespace(),
        "views": Version.get_by_id('v2').views,
        "likes": Version.get_by_id('v2').likes
    }
    return jsonify(data)
示例#52
0
文件: db.py 项目: stn/vocabulary
 def put_multi_with_namespace(cls, words):
     user = users.get_current_user()
     previous_namespace = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(user.email().translate(NAMESPACE_TRANS))
         ndb.put_multi(words)
     finally:
         namespace_manager.set_namespace(previous_namespace)
示例#53
0
文件: db.py 项目: stn/vocabulary
 def put_with_namespace(cls, coll):
     user = users.get_current_user()
     previous_namespace = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(user.email().translate(NAMESPACE_TRANS))
         coll.put()
     finally:
         namespace_manager.set_namespace(previous_namespace)
示例#54
0
def update_memcache(server_name, host_item=None):
    namespace_manager.set_namespace("shared.host")
    memcache_key = "shared.host.info." + server_name
    if host_item is None:
        host_item = HostInformation.get_or_insert(host=server_name)
    memcache.set(key=memcache_key, value=host_item, time=3600)
    namespace_manager.set_namespace(host_item.namespace)
    return host_item
示例#55
0
 def non_transactional_submit(self):
     old_namespace = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(self._namespace)
         DurableJobEntity._create_job(self._job_name)
         deferred.defer(self.main)
     finally:
         namespace_manager.set_namespace(old_namespace)
示例#56
0
 def get_enrolled_student_by_email_for(cls, email, app_context):
     """Returns student for a specific course."""
     old_namespace = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(app_context.get_namespace_name())
         return Student.get_enrolled_student_by_email(email)
     finally:
         namespace_manager.set_namespace(old_namespace)
示例#57
0
 def Projects(self, sub):
     if sub != None:
         namespace_manager.set_namespace(None)
         rootUser = UserProfile.all().filter(
             'user', users.get_current_user()).get()
         if rootUser != None:
             return rootUser.projects
     return '' if self.projects is None else self.projects  # should be blank...
示例#58
0
def CopyIntoNamespace(e, ns):
    namespace_manager.set_namespace(ns)
    np = e.__class__()
    for aen, aep in e.__dict__['_entity'].iteritems():
        av = getattr(e, aen)
        setattr(np, aen, av)
    np.put()
    return np
示例#59
0
 def newfunc(*args, **kwargs):
     """Set proper namespace for each method call."""
     old_namespace = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(self._ns)
         return attr(*args, **kwargs)
     finally:
         namespace_manager.set_namespace(old_namespace)
 def CreateInNamespace(self, namespace):
     old_ns = namespace_manager.get_namespace()
     try:
         namespace_manager.set_namespace(namespace)
         pet = Pet()
         pet.put()
     finally:
         namespace_manager.set_namespace(old_ns)