Ejemplo n.º 1
0
class Player(db.Model):
    name = db.StringProperty()
class Submission(BaseEntity):
    """Datastore model for a student work submission."""

    # Contents of the student submission. Max size is 1MB.
    contents = db.TextProperty()

    # Submission date
    updated_on = db.DateTimeProperty(indexed=True)

    # Key of the Student who wrote this submission.
    reviewee_key = KeyProperty(kind=models.Student.kind())
    # Identifier of the unit this review is a part of.
    unit_id = db.StringProperty(required=True)
    # Optional identifier of the component which submitted this data
    instance_id = db.StringProperty(required=False)

    def __init__(self, *args, **kwargs):
        """Constructs a new Submission."""
        assert not kwargs.get('key_name'), (
            'Setting key_name manually is not supported')
        reviewee_key = kwargs.get('reviewee_key')
        unit_id = kwargs.get('unit_id')
        instance_id = kwargs.get('instance_id')
        assert reviewee_key, 'Missing required property: reviewee_key'
        assert unit_id, 'Missing required_property: unit_id'
        kwargs['key_name'] = self.key_name(unit_id,
                                           reviewee_key,
                                           instance_id=instance_id)
        super(Submission, self).__init__(*args, **kwargs)

    @classmethod
    def _get_student_key(cls, value):
        return db.Key.from_path(models.Student.kind(), value)

    @classmethod
    def delete_by_reviewee_id(cls, user_id):
        student_key = cls._get_student_key(user_id)
        query = Submission.all(keys_only=True).filter('reviewee_key =',
                                                      student_key)
        db.delete(query.run())

    @classmethod
    def key_name(cls, unit_id, reviewee_key, instance_id=None):
        """Creates a key_name string for datastore operations.

        In order to work with the review subsystem, entities must have a key
        name populated from this method.

        Args:
            unit_id: string. The id of the unit this submission belongs to.
            reviewee_key: db.Key of models.models.Student. The author of the
                the submission.
            instance_id: string. The instance id of a component (e.g., file
                upload) which submitted the content.

        Returns:
            String.
        """
        if instance_id:
            return '(submission:%s:%s:%s)' % (unit_id, instance_id,
                                              reviewee_key.id_or_name())
        else:
            return '(submission:%s:%s)' % (unit_id, reviewee_key.id_or_name())

    @classmethod
    def get_key(cls, unit_id, reviewee_key, instance_id=None):
        """Returns a db.Key for a submission."""
        return db.Key.from_path(
            cls.kind(),
            cls.key_name(unit_id, reviewee_key, instance_id=instance_id))

    @classmethod
    def safe_key(cls, db_key, transform_fn):
        split_key = cls._split_key(db_key.name())
        if len(split_key) == 3:
            _, unit_id, student_key_str = split_key
            instance_id = None
        else:
            _, unit_id, instance_id, student_key_str = split_key

        student_key = db.Key.from_path(models.Student.kind(), student_key_str)
        safe_student_key = models.Student.safe_key(student_key, transform_fn)
        return db.Key.from_path(
            cls.kind(),
            cls.key_name(unit_id, safe_student_key, instance_id=instance_id))

    @classmethod
    def write(cls, unit_id, reviewee_key, contents, instance_id=None):
        """Updates or creates a student submission, and returns the key.

        Args:
            unit_id: string. The id of the unit this submission belongs to.
            reviewee_key: db.Key of models.models.Student. The author of the
                submission.
            contents: object. The contents of the submission, as a Python
                object. This will be JSON-transformed before it is stored.
            instance_id: string. The instance id of a component (e.g., file
                upload) which submitted the content.

        Returns:
            db.Key of Submission.
        """
        return cls(unit_id=str(unit_id),
                   reviewee_key=reviewee_key,
                   contents=transforms.dumps(contents),
                   instance_id=instance_id,
                   updated_on=datetime.datetime.utcnow()).put()

    @classmethod
    def get(cls, unit_id, reviewee_key, instance_id=None):
        submission_key = cls.get_key(unit_id,
                                     reviewee_key,
                                     instance_id=instance_id)
        submission = entities.get(submission_key)
        # For backward compatibility, if no entry is found with the instance_id
        # in the key, also look for an entry with no instance_id used.
        if submission is None and instance_id:
            submission = entities.get(cls.get_key(unit_id, reviewee_key))
        return submission

    @classmethod
    def get_contents(cls, unit_id, reviewee_key, instance_id=None):
        """Returns the de-JSONified contents of a submission."""
        submission_key = cls.get_key(unit_id,
                                     reviewee_key,
                                     instance_id=instance_id)
        contents = cls.get_contents_by_key(submission_key)
        # For backward compatibility, if no entry is found with the instance_id
        # in the key, also look for an entry with no instance_id used.
        if contents is None and instance_id:
            contents = cls.get_contents_by_key(
                cls.get_key(unit_id, reviewee_key))
        return contents

    @classmethod
    def get_contents_by_key(cls, submission_key):
        """Returns the contents of a submission, given a db.Key."""
        submission = entities.get(submission_key)
        return transforms.loads(submission.contents) if submission else None

    def for_export(self, transform_fn):
        model = super(Submission, self).for_export(transform_fn)
        model.reviewee_key = models.Student.safe_key(model.reviewee_key,
                                                     transform_fn)
        return model
Ejemplo n.º 3
0
class StemmedIndex(SearchIndex):
    """Index model for stemmed (inflected) search phrases."""
    parent_kind = db.StringProperty(required=True)
    phrases = db.StringListProperty(required=True)
Ejemplo n.º 4
0
class ShardState(db.Model):
    """Single shard execution state.

  The shard state is stored in the datastore and is later aggregated by
  controller task. Shard key_name is equal to shard_id.

  Properties:
    active: if we have this shard still running as boolean.
    counters_map: shard's counters map as CountersMap. Mirrors
      counters_map_json.
    mapreduce_id: unique id of the mapreduce.
    shard_id: unique id of this shard as string.
    shard_number: ordered number for this shard.
    result_status: If not None, the final status of this shard.
    update_time: The last time this shard state was updated.
    shard_description: A string description of the work this shard will do.
    last_work_item: A string description of the last work item processed.
  """

    RESULT_SUCCESS = "success"
    RESULT_FAILED = "failed"
    RESULT_ABORTED = "aborted"

    _RESULTS = frozenset([RESULT_SUCCESS, RESULT_FAILED, RESULT_ABORTED])

    # Functional properties.
    active = db.BooleanProperty(default=True, indexed=False)
    counters_map = JsonProperty(CountersMap,
                                default=CountersMap(),
                                indexed=False)
    result_status = db.StringProperty(choices=_RESULTS, indexed=False)

    # For UI purposes only.
    mapreduce_id = db.StringProperty(required=True)
    update_time = db.DateTimeProperty(auto_now=True, indexed=False)
    shard_description = db.TextProperty(default="")
    last_work_item = db.TextProperty(default="")

    def get_shard_number(self):
        """Gets the shard number from the key name."""
        return int(self.key().name().split("-")[-1])

    shard_number = property(get_shard_number)

    def get_shard_id(self):
        """Returns the shard ID."""
        return self.key().name()

    shard_id = property(get_shard_id)

    @classmethod
    def shard_id_from_number(cls, mapreduce_id, shard_number):
        """Get shard id by mapreduce id and shard number.

    Args:
      mapreduce_id: mapreduce id as string.
      shard_number: shard number to compute id for as int.

    Returns:
      shard id as string.
    """
        return "%s-%d" % (mapreduce_id, shard_number)

    @classmethod
    def get_key_by_shard_id(cls, shard_id):
        """Retrieves the Key for this ShardState.

    Args:
      shard_id: The shard ID to fetch.

    Returns:
      The Datatore key to use to retrieve this ShardState.
    """
        return db.Key.from_path(cls.kind(), shard_id)

    @classmethod
    def get_by_shard_id(cls, shard_id):
        """Get shard state from datastore by shard_id.

    Args:
      shard_id: shard id as string.

    Returns:
      ShardState for given shard id or None if it's not found.
    """
        return cls.get_by_key_name(shard_id)

    @classmethod
    def find_by_mapreduce_id(cls, mapreduce_id):
        """Find all shard states for given mapreduce.

    Args:
      mapreduce_id: mapreduce id.

    Returns:
      iterable of all ShardState for given mapreduce id.
    """
        return cls.all().filter("mapreduce_id =", mapreduce_id).fetch(99999)

    @classmethod
    def create_new(cls, mapreduce_id, shard_number):
        """Create new shard state.

    Args:
      mapreduce_id: unique mapreduce id as string.
      shard_number: shard number for which to create shard state.

    Returns:
      new instance of ShardState ready to put into datastore.
    """
        shard_id = cls.shard_id_from_number(mapreduce_id, shard_number)
        state = cls(key_name=shard_id, mapreduce_id=mapreduce_id)
        return state
Ejemplo n.º 5
0
class ShardState(db.Model):
  """Single shard execution state.

  The shard state is stored in the datastore and is later aggregated by
  controller task. ShardState key_name is equal to shard_id.

  Shard state contains critical state to ensure the correctness of
  shard execution. It is the single source of truth about a shard's
  progress. For example:
  1. A slice is allowed to run only if its payload matches shard state's
     expectation.
  2. A slice is considered running only if it has acquired the shard's lock.
  3. A slice is considered done only if it has successfully committed shard
     state to db.

  Properties about the shard:
    active: if we have this shard still running as boolean.
    counters_map: shard's counters map as CountersMap. All counters yielded
      within mapreduce are stored here.
    mapreduce_id: unique id of the mapreduce.
    shard_id: unique id of this shard as string.
    shard_number: ordered number for this shard.
    retries: the number of times this shard has been retried.
    result_status: If not None, the final status of this shard.
    update_time: The last time this shard state was updated.
    shard_description: A string description of the work this shard will do.
    last_work_item: A string description of the last work item processed.
    writer_state: writer state for this shard. The shard's output writer
      instance can save in-memory output references to this field in its
      "finalize" method.

   Properties about slice management:
    slice_id: slice id of current executing slice. A slice's task
      will not run unless its slice_id matches this. Initial
      value is 0. By the end of slice execution, this number is
      incremented by 1.
    slice_start_time: a slice updates this to now at the beginning of
      execution. If the transaction succeeds, the current task holds
      a lease of slice duration + some grace period. During this time, no
      other task with the same slice_id will execute. Upon slice failure,
      the task should try to unset this value to allow retries to carry on
      ASAP.
    slice_request_id: the request id that holds/held the lease. When lease has
      expired, new request needs to verify that said request has indeed
      ended according to logs API. Do this only when lease has expired
      because logs API is expensive. This field should always be set/unset
      with slice_start_time. It is possible Logs API doesn't log a request
      at all or doesn't log the end of a request. So a new request can
      proceed after a long conservative timeout.
    slice_retries: the number of times a slice has been retried due to
      processing data when lock is held. Taskqueue/datastore errors
      related to slice/shard management are not counted. This count is
      only a lower bound and is used to determined when to fail a slice
      completely.
    acquired_once: whether the lock for this slice has been acquired at
      least once. When this is True, duplicates in outputs are possible.
  """

  RESULT_SUCCESS = "success"
  RESULT_FAILED = "failed"


  RESULT_ABORTED = "aborted"

  _RESULTS = frozenset([RESULT_SUCCESS, RESULT_FAILED, RESULT_ABORTED])


  _MAX_STATES_IN_MEMORY = 10


  mapreduce_id = db.StringProperty(required=True)
  active = db.BooleanProperty(default=True, indexed=False)
  input_finished = db.BooleanProperty(default=False, indexed=False)
  counters_map = json_util.JsonProperty(
      CountersMap, default=CountersMap(), indexed=False)
  result_status = db.StringProperty(choices=_RESULTS, indexed=False)
  retries = db.IntegerProperty(default=0, indexed=False)
  writer_state = json_util.JsonProperty(dict, indexed=False)
  slice_id = db.IntegerProperty(default=0, indexed=False)
  slice_start_time = db.DateTimeProperty(indexed=False)
  slice_request_id = db.ByteStringProperty(indexed=False)
  slice_retries = db.IntegerProperty(default=0, indexed=False)
  acquired_once = db.BooleanProperty(default=False, indexed=False)


  update_time = db.DateTimeProperty(auto_now=True, indexed=False)
  shard_description = db.TextProperty(default="")
  last_work_item = db.TextProperty(default="")

  def __str__(self):
    kv = {"active": self.active,
          "slice_id": self.slice_id,
          "last_work_item": self.last_work_item,
          "update_time": self.update_time}
    if self.result_status:
      kv["result_status"] = self.result_status
    if self.retries:
      kv["retries"] = self.retries
    if self.slice_start_time:
      kv["slice_start_time"] = self.slice_start_time
    if self.slice_retries:
      kv["slice_retries"] = self.slice_retries
    if self.slice_request_id:
      kv["slice_request_id"] = self.slice_request_id
    if self.acquired_once:
      kv["acquired_once"] = self.acquired_once
    keys = list(kv.keys())
    keys.sort()

    result = "ShardState is {"
    for k in keys:
      result += k + ":" + str(kv[k]) + ","
    result += "}"
    return result

  def reset_for_retry(self):
    """Reset self for shard retry."""
    self.retries += 1
    self.last_work_item = ""
    self.active = True
    self.result_status = None
    self.input_finished = False
    self.counters_map = CountersMap()
    self.slice_id = 0
    self.slice_start_time = None
    self.slice_request_id = None
    self.slice_retries = 0
    self.acquired_once = False

  def advance_for_next_slice(self, recovery_slice=False):
    """Advance self for next slice.

    Args:
      recovery_slice: True if this slice is running recovery logic.
        See handlers.MapperWorkerCallbackHandler._attempt_slice_recovery
        for more info.
    """
    self.slice_start_time = None
    self.slice_request_id = None
    self.slice_retries = 0
    self.acquired_once = False
    if recovery_slice:
      self.slice_id += 2
    else:
      self.slice_id += 1

  def set_for_failure(self):
    self.active = False
    self.result_status = self.RESULT_FAILED

  def set_for_abort(self):
    self.active = False
    self.result_status = self.RESULT_ABORTED

  def set_input_finished(self):
    self.input_finished = True

  def is_input_finished(self):
    return self.input_finished

  def set_for_success(self):
    self.active = False
    self.result_status = self.RESULT_SUCCESS
    self.slice_start_time = None
    self.slice_request_id = None
    self.slice_retries = 0
    self.acquired_once = False

  def copy_from(self, other_state):
    """Copy data from another shard state entity to self."""
    for prop in list(self.properties().values()):
      setattr(self, prop.name, getattr(other_state, prop.name))

  def __eq__(self, other):
    if not isinstance(other, self.__class__):
      return False
    return self.properties() == other.properties()

  def get_shard_number(self):
    """Gets the shard number from the key name."""
    return int(self.key().name().split("-")[-1])

  shard_number = property(get_shard_number)

  def get_shard_id(self):
    """Returns the shard ID."""
    return self.key().name()

  shard_id = property(get_shard_id)

  @classmethod
  def kind(cls):
    """Returns entity kind."""
    return "_GAE_MR_ShardState"

  @classmethod
  def shard_id_from_number(cls, mapreduce_id, shard_number):
    """Get shard id by mapreduce id and shard number.

    Args:
      mapreduce_id: mapreduce id as string.
      shard_number: shard number to compute id for as int.

    Returns:
      shard id as string.
    """
    return "%s-%d" % (mapreduce_id, shard_number)

  @classmethod
  def get_key_by_shard_id(cls, shard_id):
    """Retrieves the Key for this ShardState.

    Args:
      shard_id: The shard ID to fetch.

    Returns:
      The Datatore key to use to retrieve this ShardState.
    """
    return db.Key.from_path(cls.kind(), shard_id)

  @classmethod
  def get_by_shard_id(cls, shard_id):
    """Get shard state from datastore by shard_id.

    Args:
      shard_id: shard id as string.

    Returns:
      ShardState for given shard id or None if it's not found.
    """
    return cls.get_by_key_name(shard_id)

  @classmethod
  def find_by_mapreduce_state(cls, mapreduce_state):
    """Find all shard states for given mapreduce.

    Deprecated. Use find_all_by_mapreduce_state.
    This will be removed after 1.8.9 release.

    Args:
      mapreduce_state: MapreduceState instance

    Returns:
      A list of ShardStates.
    """
    return list(cls.find_all_by_mapreduce_state(mapreduce_state))

  @classmethod
  def find_all_by_mapreduce_state(cls, mapreduce_state):
    """Find all shard states for given mapreduce.

    Args:
      mapreduce_state: MapreduceState instance

    Yields:
      shard states sorted by shard id.
    """
    keys = cls.calculate_keys_by_mapreduce_state(mapreduce_state)
    i = 0
    while i < len(keys):
      @db.non_transactional
      def no_tx_get(i):
        return db.get(keys[i:i+cls._MAX_STATES_IN_MEMORY])


      states = no_tx_get(i)
      for s in states:
        i += 1
        if s is not None:
          yield s

  @classmethod
  def calculate_keys_by_mapreduce_state(cls, mapreduce_state):
    """Calculate all shard states keys for given mapreduce.

    Args:
      mapreduce_state: MapreduceState instance

    Returns:
      A list of keys for shard states, sorted by shard id.
      The corresponding shard states may not exist.
    """
    if mapreduce_state is None:
      return []

    keys = []
    for i in range(mapreduce_state.mapreduce_spec.mapper.shard_count):
      shard_id = cls.shard_id_from_number(mapreduce_state.key().name(), i)
      keys.append(cls.get_key_by_shard_id(shard_id))
    return keys

  @classmethod
  def create_new(cls, mapreduce_id, shard_number):
    """Create new shard state.

    Args:
      mapreduce_id: unique mapreduce id as string.
      shard_number: shard number for which to create shard state.

    Returns:
      new instance of ShardState ready to put into datastore.
    """
    shard_id = cls.shard_id_from_number(mapreduce_id, shard_number)
    state = cls(key_name=shard_id,
                mapreduce_id=mapreduce_id)
    return state
Ejemplo n.º 6
0
class Users(db.Model):
    user_name = db.StringProperty(required=True)
    password = db.StringProperty(required=True)
    created = db.DateTimeProperty(auto_now_add=True)
    email = db.StringProperty()
Ejemplo n.º 7
0
class Item(db.Model):
  name = db.StringProperty(required = True)
Ejemplo n.º 8
0
class ART(db.Model):
	title=db.StringProperty()
	arttype=db.TextProperty()
	created=db.DateTimeProperty(auto_now_add=True)
Ejemplo n.º 9
0
class Vote(db.Model):
    user = db.StringProperty(required=True)
    issue = db.ReferenceProperty(Issue, required=True)
    timestamp = db.DateTimeProperty(auto_now_add=True)
Ejemplo n.º 10
0
class UserEvent(db.Expando):
    date = db.DateTimeProperty(auto_now_add=True)

    ev_type = db.IntegerProperty(required=True, indexed=True)
    requester = db.StringProperty(required=True, indexed=True)
Ejemplo n.º 11
0
class Client(db.Model):
    room_id = db.StringProperty()
    client_id = db.StringProperty()
    messages = db.ListProperty(db.Text)
    is_initiator = db.BooleanProperty()
Ejemplo n.º 12
0
class NewEntry(db.Model):
    title = db.StringProperty(required=True)
    entry = db.TextProperty(required=True)
    created = db.DateTimeProperty(auto_now_add=True)
    modified = db.DateTimeProperty(auto_now_add=True)
Ejemplo n.º 13
0
class Word(db.Model):
    word = db.StringProperty()
    exists = db.BooleanProperty()
Ejemplo n.º 14
0
class Guild(db.Model):
    name = db.StringProperty()
Ejemplo n.º 15
0
class StoredToken(db.Model):
    user_email = db.StringProperty(required=True)
    session_token = db.StringProperty(required=True)
    target_url = db.StringProperty(required=True)
Ejemplo n.º 16
0
class Post(db.Model):
    subject = db.StringProperty(required=True)
    content = db.TextProperty(required=True)
    created = db.DateTimeProperty(auto_now_add=True)
Ejemplo n.º 17
0
class Posts(db.Model):
    title = db.StringProperty(required=True)
    post = db.TextProperty(required=True)
    created = db.DateTimeProperty(auto_now_add=True)
Ejemplo n.º 18
0
class FlowerbedLog(db.Model):
    flowerbed = db.ReferenceProperty(indexed=False, reference_class=Flowerbed)
    owner = db.StringProperty()
    attackPlants = db.IntegerProperty(indexed=False)
    defensePlants = db.IntegerProperty(indexed=False)
    timestamp = db.DateTimeProperty(auto_now=True)
Ejemplo n.º 19
0
class ResourceStorage(db.Model):
    name = db.StringProperty(multiline=False)
    data = db.StringProperty(multiline=True)
Ejemplo n.º 20
0
class Bookmark(db.Model):
    owner = db.StringProperty(indexed=False)
    flowerbed = db.ReferenceProperty(indexed=False, reference_class=Flowerbed)
    timestamp = db.DateTimeProperty(indexed=False, auto_now=True)
Ejemplo n.º 21
0
class MapreduceState(db.Model):
    """Holds accumulated state of mapreduce execution.

  MapreduceState is stored in datastore with a key name equal to the
  mapreduce ID. Only controller tasks can write to MapreduceState.

  Properties:
    mapreduce_spec: cached deserialized MapreduceSpec instance. read-only
    active: if we have this mapreduce running right now
    last_poll_time: last time controller job has polled this mapreduce.
    counters_map: shard's counters map as CountersMap. Mirrors
      counters_map_json.
    chart_url: last computed mapreduce status chart url. This chart displays the
      progress of all the shards the best way it can.
    sparkline_url: last computed mapreduce status chart url in small format.
    result_status: If not None, the final status of the job.
    active_shards: How many shards are still processing.
    start_time: When the job started.
  """

    RESULT_SUCCESS = "success"
    RESULT_FAILED = "failed"
    RESULT_ABORTED = "aborted"

    _RESULTS = frozenset([RESULT_SUCCESS, RESULT_FAILED, RESULT_ABORTED])

    # Functional properties.
    mapreduce_spec = JsonProperty(MapreduceSpec, indexed=False)
    active = db.BooleanProperty(default=True, indexed=False)
    last_poll_time = db.DateTimeProperty(required=True)
    counters_map = JsonProperty(CountersMap,
                                default=CountersMap(),
                                indexed=False)
    app_id = db.StringProperty(required=False, indexed=True)

    # For UI purposes only.
    chart_url = db.TextProperty(default="")
    sparkline_url = db.TextProperty(default="")
    result_status = db.StringProperty(required=False, choices=_RESULTS)
    active_shards = db.IntegerProperty(default=0, indexed=False)
    failed_shards = db.IntegerProperty(default=0, indexed=False)
    aborted_shards = db.IntegerProperty(default=0, indexed=False)
    start_time = db.DateTimeProperty(auto_now_add=True)

    @classmethod
    def get_key_by_job_id(cls, mapreduce_id):
        """Retrieves the Key for a Job.

    Args:
      mapreduce_id: The job to retrieve.

    Returns:
      Datastore Key that can be used to fetch the MapreduceState.
    """
        return db.Key.from_path(cls.kind(), mapreduce_id)

    def set_processed_counts(self, shards_processed):
        """Updates a chart url to display processed count for each shard.

    Args:
      shards_processed: list of integers with number of processed entities in
        each shard
    """
        chart = google_chart_api.BarChart(shards_processed)
        if self.mapreduce_spec and shards_processed:
            chart.bottom.labels = [
                str(x) for x in xrange(self.mapreduce_spec.mapper.shard_count)
            ]
            chart.left.labels = ['0', str(max(shards_processed))]
            chart.left.min = 0
        self.chart_url = chart.display.Url(300, 200)

    def get_processed(self):
        """Number of processed entities.

    Returns:
      The total number of processed entities as int.
    """
        return self.counters_map.get(context.COUNTER_MAPPER_CALLS)

    processed = property(get_processed)

    @staticmethod
    def create_new(getkeyname=_get_descending_key,
                   gettime=datetime.datetime.now):
        """Create a new MapreduceState.

    Args:
      getkeyname: Used for testing.
      gettime: Used for testing.
    """
        state = MapreduceState(key_name=getkeyname(), last_poll_time=gettime())
        state.set_processed_counts([])
        return state
Ejemplo n.º 22
0
class Rule(db.Model):
    name = db.StringProperty(indexed=False)
    value = db.IntegerProperty(indexed=False)
    timestamp = db.DateTimeProperty(indexed=False, auto_now=True)
Ejemplo n.º 23
0
class MapreduceState(db.Model):
  """Holds accumulated state of mapreduce execution.

  MapreduceState is stored in datastore with a key name equal to the
  mapreduce ID. Only controller tasks can write to MapreduceState.

  Properties:
    mapreduce_spec: cached deserialized MapreduceSpec instance. read-only
    active: if this MR is still running.
    last_poll_time: last time controller job has polled this mapreduce.
    counters_map: shard's counters map as CountersMap. Mirrors
      counters_map_json.
    chart_url: last computed mapreduce status chart url. This chart displays the
      progress of all the shards the best way it can.
    sparkline_url: last computed mapreduce status chart url in small format.
    result_status: If not None, the final status of the job.
    active_shards: How many shards are still processing. This starts as 0,
      then set by KickOffJob handler to be the actual number of input
      readers after input splitting, and is updated by Controller task
      as shards finish.
    start_time: When the job started.
    writer_state: Json property to be used by writer to store its state.
      This is filled when single output per job. Will be deprecated.
      Use OutputWriter.get_filenames instead.
  """

  RESULT_SUCCESS = "success"
  RESULT_FAILED = "failed"
  RESULT_ABORTED = "aborted"

  _RESULTS = frozenset([RESULT_SUCCESS, RESULT_FAILED, RESULT_ABORTED])



  mapreduce_spec = json_util.JsonProperty(MapreduceSpec, indexed=False)
  active = db.BooleanProperty(default=True, indexed=False)
  last_poll_time = db.DateTimeProperty(required=True)
  counters_map = json_util.JsonProperty(
      CountersMap, default=CountersMap(), indexed=False)
  app_id = db.StringProperty(required=False, indexed=True)
  writer_state = json_util.JsonProperty(dict, indexed=False)
  active_shards = db.IntegerProperty(default=0, indexed=False)
  failed_shards = db.IntegerProperty(default=0, indexed=False)
  aborted_shards = db.IntegerProperty(default=0, indexed=False)
  result_status = db.StringProperty(required=False, choices=_RESULTS)


  chart_url = db.TextProperty(default="")
  chart_width = db.IntegerProperty(default=300, indexed=False)
  sparkline_url = db.TextProperty(default="")
  start_time = db.DateTimeProperty(auto_now_add=True)

  @classmethod
  def kind(cls):
    """Returns entity kind."""
    return "_GAE_MR_MapreduceState"

  @classmethod
  def get_key_by_job_id(cls, mapreduce_id):
    """Retrieves the Key for a Job.

    Args:
      mapreduce_id: The job to retrieve.

    Returns:
      Datastore Key that can be used to fetch the MapreduceState.
    """
    return db.Key.from_path(cls.kind(), str(mapreduce_id))

  @classmethod
  def get_by_job_id(cls, mapreduce_id):
    """Retrieves the instance of state for a Job.

    Args:
      mapreduce_id: The mapreduce job to retrieve.

    Returns:
      instance of MapreduceState for passed id.
    """
    return db.get(cls.get_key_by_job_id(mapreduce_id))

  def set_processed_counts(self, shards_processed):
    """Updates a chart url to display processed count for each shard.

    Args:
      shards_processed: list of integers with number of processed entities in
        each shard
    """
    chart = google_chart_api.BarChart(shards_processed)
    shard_count = len(shards_processed)

    if shards_processed:

      stride_length = max(1, shard_count / 16)
      chart.bottom.labels = []
      for x in range(shard_count):
        if (x % stride_length == 0 or
            x == shard_count - 1):
          chart.bottom.labels.append(x)
        else:
          chart.bottom.labels.append("")
      chart.left.labels = ["0", str(max(shards_processed))]
      chart.left.min = 0

    self.chart_width = min(700, max(300, shard_count * 20))
    self.chart_url = chart.display.Url(self.chart_width, 200)

  def get_processed(self):
    """Number of processed entities.

    Returns:
      The total number of processed entities as int.
    """
    return self.counters_map.get(context.COUNTER_MAPPER_CALLS)

  processed = property(get_processed)

  @staticmethod
  def create_new(mapreduce_id=None,
                 gettime=datetime.datetime.now):
    """Create a new MapreduceState.

    Args:
      mapreduce_id: Mapreduce id as string.
      gettime: Used for testing.
    """
    if not mapreduce_id:
      mapreduce_id = MapreduceState.new_mapreduce_id()
    state = MapreduceState(key_name=mapreduce_id,
                           last_poll_time=gettime())
    state.set_processed_counts([])
    return state

  @staticmethod
  def new_mapreduce_id():
    """Generate new mapreduce id."""
    return util._get_descending_key()

  def __eq__(self, other):
    if not isinstance(other, self.__class__):
      return False
    return self.properties() == other.properties()
Ejemplo n.º 24
0
class Item(db.Model):
    name = db.StringProperty()  #flower, flowerbed
    moneyPrice = db.IntegerProperty(indexed=False)
    flowerPrice = db.IntegerProperty(indexed=False)
class Review(BaseEntity):
    """Datastore model for a student review of a Submission."""

    # Contents of the student's review. Max size is 1MB.
    contents = db.TextProperty()

    # Key of the student whose work is being reviewed.
    reviewee_key = KeyProperty(kind=models.Student.kind())
    # Key of the Student who wrote this review.
    reviewer_key = KeyProperty(kind=models.Student.kind())
    # Identifier of the unit this review is a part of.
    unit_id = db.StringProperty(required=True)

    def __init__(self, *args, **kwargs):
        """Constructs a new Review."""
        assert not kwargs.get('key_name'), (
            'Setting key_name manually is not supported')
        reviewee_key = kwargs.get('reviewee_key')
        reviewer_key = kwargs.get('reviewer_key')
        unit_id = kwargs.get('unit_id')
        assert reviewee_key, 'Missing required property: reviewee_key'
        assert reviewer_key, 'Missing required property: reviewer_key'
        assert unit_id, 'Missing required_property: unit_id'
        kwargs['key_name'] = self.key_name(unit_id, reviewee_key, reviewer_key)
        super(Review, self).__init__(*args, **kwargs)

    @classmethod
    def key_name(cls, unit_id, reviewee_key, reviewer_key):
        """Creates a key_name string for datastore operations.

        In order to work with the review subsystem, entities must have a key
        name populated from this method.

        Args:
            unit_id: string. The id of the unit this review belongs to.
            reviewee_key: db.Key of models.models.Student. The student whose
                work is being reviewed.
            reviewer_key: db.Key of models.models.Student. The author of this
                the review.

        Returns:
            String.
        """
        return '(review:%s:%s:%s)' % (unit_id, reviewee_key, reviewer_key)

    @classmethod
    def safe_key(cls, db_key, transform_fn):
        _, unit_id, reviewee_key_str, reviewer_key_str = cls._split_key(
            db_key.name())
        reviewee_key = db.Key(encoded=reviewee_key_str)
        reviewer_key = db.Key(encoded=reviewer_key_str)
        safe_reviewee_key = models.Student.safe_key(reviewee_key, transform_fn)
        safe_reviewer_key = models.Student.safe_key(reviewer_key, transform_fn)
        return db.Key.from_path(
            cls.kind(),
            cls.key_name(unit_id, safe_reviewee_key, safe_reviewer_key))

    def for_export(self, transform_fn):
        model = super(Review, self).for_export(transform_fn)
        model.reviewee_key = models.Student.safe_key(model.reviewee_key,
                                                     transform_fn)
        model.reviewer_key = models.Student.safe_key(model.reviewer_key,
                                                     transform_fn)
        return model

    @classmethod
    def _get_student_key(cls, value):
        return db.Key.from_path(models.Student.kind(), value)

    @classmethod
    def delete_by_reviewee_id(cls, user_id):
        student_key = cls._get_student_key(user_id)
        query = Review.all(keys_only=True).filter('reviewee_key =',
                                                  student_key)
        db.delete(query.run())
Ejemplo n.º 26
0
class Backpack(db.Model):
    owner = db.StringProperty(indexed=False)
    name = db.StringProperty()  #Item.name
    amount = db.IntegerProperty(indexed=False)
    timestamp = db.DateTimeProperty(indexed=False, auto_now=True)
Ejemplo n.º 27
0
class LiteralIndex(SearchIndex):
    """Index model for non-inflected search phrases."""
    parent_kind = db.StringProperty(required=True)
    phrases = db.StringListProperty(required=True)
Ejemplo n.º 28
0
class BaseVolume(db.Model):
  """Base model for various types of volumes."""

  ESCROW_TYPE_NAME = 'base_volume'
  SECRET_PROPERTY_NAME = 'undefined'
  ALLOW_OWNER_CHANGE = False

  # True for only the most recently escrowed, unique volume_uuid.
  active = db.BooleanProperty(default=True)

  created = db.DateTimeProperty(auto_now_add=True)
  created_by = AutoUpdatingUserProperty()  # user that created the object.
  hostname = db.StringProperty()  # name of the machine with the volume.
  owner = db.StringProperty()
  volume_uuid = db.StringProperty()  # Volume UUID of the encrypted volume.
  tag = db.StringProperty(default='default')  # Key Slot

  def __eq__(self, other):
    for p in self.properties():
      if getattr(self, p) != getattr(other, p):
        return False
    return True

  def ToDict(self, skip_secret=False):
    volume = {p: str(getattr(self, p)) for p in self.properties()
              if not skip_secret or p != self.SECRET_PROPERTY_NAME}
    volume['id'] = str(self.key())
    volume['active'] = self.active  # store the bool, not string, value
    return volume

  def __ne__(self, other):
    return not self.__eq__(other)

  @classmethod
  def GetLatestByUuid(cls, volume_uuid, tag='default'):
    entity = cls.all().filter('tag =', tag).filter(
        'volume_uuid =', volume_uuid).order('-created').fetch(1)
    if not entity:
      return None
    return entity[0]

  def Clone(self):
    items = {p: getattr(self, p) for p in self.properties()}
    del items['created_by']
    del items['created']
    return self.__class__(**items)

  @db.transactional(xg=True)
  def _PutNewVolume(self, ancestor_key, *args, **kwargs):
    ancestor = self.get(ancestor_key)
    if not ancestor.active:
      raise self.ACCESS_ERR_CLS(
          'parent entity is inactive: %s.' % self.volume_uuid)
    ancestor.active = False
    super(BaseVolume, ancestor).put(*args, **kwargs)
    return super(BaseVolume, self).put(*args, **kwargs)

  def put(self, parent=None, *args, **kwargs):  # pylint: disable=g-bad-name
    """Disallow updating an existing entity, and enforce key_name.

    Args:
      parent: Optional. A Volume of the same type as the current instance.
        If passed then it is used as the parent entity for this instance.
      *args: Positional arguments to be passed to parent class' put method.
      **kwargs: Keyword arguments to be passed to parent class' put method.
    Returns:
      The key of the instance (either the existing key or a new key).
    Raises:
      DuplicateEntity: New entity is a duplicate of active volume with same
                       uuid.
      AccessError: required property was empty or not set.
    """
    model_name = self.__class__.__name__
    for prop_name in self.REQUIRED_PROPERTIES:
      if not getattr(self, prop_name, None):
        raise self.ACCESS_ERR_CLS('Required property empty: %s' % prop_name)

    if not self.active:
      raise self.ACCESS_ERR_CLS(
          'New entity is not active: %s' % self.volume_uuid)

    if self.has_key():
      raise self.ACCESS_ERR_CLS(
          'Key should be auto genenrated for %s.' % model_name)

    existing_entity = parent
    if not existing_entity:
      existing_entity = self.__class__.GetLatestByUuid(
          self.volume_uuid, tag=self.tag)
    if existing_entity:
      if not existing_entity.active:
        raise self.ACCESS_ERR_CLS(
            'parent entity is inactive: %s.' % self.volume_uuid)
      different_properties = []
      for prop in self.properties():
        if getattr(self, prop) != getattr(existing_entity, prop):
          different_properties.append(prop)

      if not different_properties or different_properties == ['created']:
        raise DuplicateEntity()

      if self.created > existing_entity.created:
        return self._PutNewVolume(existing_entity.key())
      else:
        logging.warning('entity from past')
        self.active = False

    return super(BaseVolume, self).put(*args, **kwargs)

  @property
  def secret(self):
    return getattr(self, self.SECRET_PROPERTY_NAME)

  @property
  def checksum(self):
    return hashlib.md5(self.secret).hexdigest()

  @classmethod
  def NormalizeHostname(cls, hostname, strip_fqdn=False):
    """Sanitizes a hostname for consistent search functionality.

    Args:
      hostname: str hostname to sanitize.
      strip_fqdn: boolean, if True removes fully qualified portion of hostname.
    Returns:
      str hostname.
    """
    # TODO(user): call this during escrow create, to sanitize before storage.
    if strip_fqdn:
      hostname = hostname.partition('.')[0]
    return hostname.lower()
Ejemplo n.º 29
0
class Entry(db.Model):
	title = db.StringProperty(required = True)
	body = db.TextProperty(required = True)
	created = db.DateTimeProperty(auto_now_add = True)
Ejemplo n.º 30
0
class BlogPost(db.Model):
    title = db.StringProperty(required=True)
    thoughts = db.TextProperty(required=True)
    created = db.DateTimeProperty(auto_now_add=True)