Ejemplo n.º 1
0
def make_backup(cleanup=False, scheduler=False):
    """ Makes a backup of config file, removes all but the last 5 backups """

    if scheduler:
        backup_file = 'config.backup-{}.sched.ini'.format(helpers.now())
    else:
        backup_file = 'config.backup-{}.ini'.format(helpers.now())
    backup_folder = plexpy.CONFIG.BACKUP_DIR
    backup_file_fp = os.path.join(backup_folder, backup_file)

    # In case the user has deleted it manually
    if not os.path.exists(backup_folder):
        os.makedirs(backup_folder)

    plexpy.CONFIG.write()
    shutil.copyfile(plexpy.CONFIG_FILE, backup_file_fp)

    if cleanup:
        now = time.time()
        # Delete all scheduled backup older than BACKUP_DAYS.
        for root, dirs, files in os.walk(backup_folder):
            ini_files = [os.path.join(root, f) for f in files if f.endswith('.sched.ini')]
            for file_ in ini_files:
                if os.stat(file_).st_mtime < now - plexpy.CONFIG.BACKUP_DAYS * 86400:
                    try:
                        os.remove(file_)
                    except OSError as e:
                        logger.error("Tautulli Config :: Failed to delete %s from the backup folder: %s" % (file_, e))

    if backup_file in os.listdir(backup_folder):
        logger.debug("Tautulli Config :: Successfully backed up %s to %s" % (plexpy.CONFIG_FILE, backup_file))
        return True
    else:
        logger.error("Tautulli Config :: Failed to backup %s to %s" % (plexpy.CONFIG_FILE, backup_file))
        return False
Ejemplo n.º 2
0
def make_backup(cleanup=False, scheduler=False):
    """ Makes a backup of db, removes all but the last 5 backups """

    # Check the integrity of the database first
    integrity = (integrity_check()['integrity_check'] == 'ok')

    corrupt = ''
    if not integrity:
        corrupt = '.corrupt'
        plexpy.NOTIFY_QUEUE.put({'notify_action': 'on_plexpydbcorrupt'})

    if scheduler:
        backup_file = 'tautulli.backup-{}{}.sched.db'.format(
            helpers.now(), corrupt)
    else:
        backup_file = 'tautulli.backup-{}{}.db'.format(helpers.now(), corrupt)
    backup_folder = plexpy.CONFIG.BACKUP_DIR
    backup_file_fp = os.path.join(backup_folder, backup_file)

    # In case the user has deleted it manually
    if not os.path.exists(backup_folder):
        os.makedirs(backup_folder)

    db = MonitorDatabase()
    db.connection.execute('BEGIN IMMEDIATE')
    shutil.copyfile(db_filename(), backup_file_fp)
    db.connection.rollback()

    # Only cleanup if the database integrity is okay
    if cleanup and integrity:
        now = time.time()
        # Delete all scheduled backup older than BACKUP_DAYS.
        for root, dirs, files in os.walk(backup_folder):
            db_files = [
                os.path.join(root, f) for f in files if f.endswith('.sched.db')
            ]
            for file_ in db_files:
                if os.stat(
                        file_
                ).st_mtime < now - plexpy.CONFIG.BACKUP_DAYS * 86400:
                    try:
                        os.remove(file_)
                    except OSError as e:
                        logger.error(
                            "Tautulli Database :: Failed to delete %s from the backup folder: %s"
                            % (file_, e))

    if backup_file in os.listdir(backup_folder):
        logger.debug("Tautulli Database :: Successfully backed up %s to %s" %
                     (db_filename(), backup_file))
        return True
    else:
        logger.error("Tautulli Database :: Failed to backup %s to %s" %
                     (db_filename(), backup_file))
        return False
Ejemplo n.º 3
0
 def _similar_artists(self, callback, artist, threshold):
   """
     callback(artist, sim_artist, match, source)
   """
   timestamp = now()
   diff = timestamp - self.get_artist_timestamp(artist)
   if diff < threshold:
     self._logger.debug(u"similar_artists[%s]: looked up %d seconds ago" %
         (artist, diff))
     return
   self.set_artist_timestamp(artist, timestamp)
   try:
     self._logger.debug(u"similar_artists[%s]: lookup" % (artist))
     a = self._artist(artist)
     if a is None:
       self._logger.info(u"similar_artists[%s]: no result" % (artist))
       return
     else:
       p = a.similar
       self._logger.info(u"similar_artists[%s]: %d result(s)" % (artist, len(p)))
       for sim in p:
         callback(artist, sim.name.lower(), sim.stats.match, self._title)
   except URLError, e:
     self._logger.error(e)
     self._logger.info(u"similar_artists[%s]: no result" % (artist))
     return
Ejemplo n.º 4
0
    def save(self, *args, **kwargs):
        instance = super(Card, self).save(*args, **kwargs)

        if self.planned_start_time and self.planned_start_time.replace(tzinfo=utc) > now():
            from app import schedule_card_start_time
            schedule_card_start_time.apply_async(kwargs={'card_id': str(self.id)}, eta=self.planned_start_time)

        if self.planned_end_time and self.planned_end_time.replace(tzinfo=utc) > now():
            from app import schedule_card_end_time
            schedule_card_end_time.apply_async(kwargs={'card_id': str(self.id)}, eta=self.planned_end_time)

        if self.completed_at:
            self.completed_at = now()
            instance.save()

        return instance
Ejemplo n.º 5
0
 def _similar_tracks(self, callback, artist, title, threshold):
   timestamp = now()
   diff = timestamp - self.get_track_timestamp(artist, title)
   if diff < threshold:
     self._logger.debug(u"similar_tracks[%s-%s]: looked up %d seconds ago" %
         (artist, title, diff))
     return
   self.set_track_timestamp(artist, title, timestamp)
   try:
     self._logger.debug(u"similar_tracks[%s-%s]: lookup" % (artist, title))
     self._delay()
     a = en_song.search(title=title, artist=artist)
     try:
       p = en_playlist.static(type='song-radio', song_id=a[0].id, results=100)
       i = 100.0
       self._logger.info(u"similar_tracks[%s-%s]: %d result(s)" % (artist,
           title, len(p)))
       for song in p:
         callback(artist, title, song.artist_name.lower(), song.title.lower(),
             i / 100.0, self._title)
         i -= 1.0
     except IndexError:
       self._logger.info(u"similar_tracks[%s-%s]: no result" % (artist, title))
       return
   except Exception, e:
     self._logger.error(e)
     self._logger.info(u"similar_tracks[%s-%s]: no result" % (artist, title))
     return
Ejemplo n.º 6
0
def displace(name, target, location):

    # first, ensure that the target exists
    if not os.path.exists(target):
        print error + "  Target %s doesn't exist!"%target
        print "Try one of these:"
        listArtPaths()
        return


    # if it's a link, kill it
    if os.path.islink(location):
        bash("rm", location)

    # if a folder, move it out the way
    if os.path.exists(location):

        # create __displaced if not done so yet
        displaced = os.path.join(app_path, displacementFolder)
        if not os.path.exists(displaced):
            bash("mkdir", displaced)

        # move folder into displaced folder with datetime 
        displaced = os.path.join(app_path, displacementFolder, "%s-%s"%(name, now()))
        print warn + "  Moving %s folder to %s"%(location, displaced)
        bash("mv", location, displaced)

    # create the link
    bash("ln -sf", target, location) 
    bash("ls -al", location)
Ejemplo n.º 7
0
  def _similar_artists(self, callback, artist, threshold):
    timestamp = now()
    diff = timestamp - self.get_artist_timestamp(artist)
    if diff < threshold:
      self._logger.debug(u"similar_artists[%s]: looked up %d seconds ago" %
          (artist, diff))
      return
    self.set_artist_timestamp(artist, timestamp)

    try:
      self._logger.debug(u"similar_artists[%s]: lookup" % (artist))
      self._delay()
      a = en_artist.search(name=artist)
      try:
        i = 100.0
        p = a[0].get_similar(results=100)
        self._logger.info(u"similar_artists[%s]: %d result(s)" % (artist, len(p)))
        for sim in p:
          callback(artist, sim.name.lower(), i / 100.0, self._title)
          i -= 1.0
      except IndexError:
        self._logger.info(u"similar_artists[%s]: no result" % (artist))
        return
    except Exception, e:
      self._logger.error(e)
      self._logger.info(u"similar_artists[%s]: no result" % (artist))
      return
Ejemplo n.º 8
0
Archivo: library.py Proyecto: pscn/ads
  def track_played(self, track, skipped= False, locked=False):
    if not locked: self.acquire()
    if len(self._history) == 0 or self._history[0]['track'] != track:
      self._logger.error(u"played: no record of starting this track")
      if not locked: self.release()
      return

    if not skipped: self._lastplayed_track = track

    timestamp= now()
    self._history[0]['skipped']= skipped

    if len(self._history) > 1:
      for i in range(min(self.maxhistory, len(self._history) - 1)):
        if skipped and self._history[1+i]['skipped']: continue

        factor= self.__factor_relation(i, self.maxhistory)
        hist_track= self._history[1+i]['track']
        hist_skipped = self._history[1+i]['skipped']

        track_relation = TrackRelationFactory.get(track, hist_track)
        track_relation.update(not hist_skipped, factor)
        self._logger.info(u"relation updated: %s" % track_relation)

    self._relation_resetted = False
    self.update_ranking()
    if not locked: self.release()
Ejemplo n.º 9
0
 def __init__(self, fpath):
     try:
         self.added = now()
         self.finished = 0
         self.fullpath = fpath
         self.fileid = getNewFileID()
         tempMediainfo = MediaInfo.parse(self.fullpath)
         self.mediainfo = {}
         for track in tempMediainfo.tracks:
             if track.track_type not in self.mediainfo:
                 self.mediainfo[track.track_type] = track.to_data()
             else:
                 if track.track_type in ['Audio', 'Subtitle']:
                     if not isinstance(self.mediainfo[track.track_type], list):
                         tempTrack = self.mediainfo[track.track_type]
                         self.mediainfo[track.track_type] = []
                         self.mediainfo[track.track_type].append(tempTrack)
                     
                     self.mediainfo[track.track_type].append(track.to_data())
         
         self.outputfilename = pacvert.CONFIG.OUTPUT_DIRECTORY+'/'+generateOutputFilename(self.fullpath)
         self.createThumbs()
         self.crop = self.analyzeThumbs()
         self.deleteThumbs()
         self.updateStatus(2)
     except Exception as e:
         logger.error(e)            
Ejemplo n.º 10
0
 def __init__(self, trackA, trackB):
   self.trackA = trackA
   self.trackB = trackB
   self.ratingref = RatingFactory.get(0.7, 1.0)
   self.artistRelation = ArtistRelationFactory.get(trackA.artist, trackB.artist)
   self.lastused = now()
   TrackRelationFactory.save(self)
Ejemplo n.º 11
0
class Card(db.Document):
    STATUS_CHOICES = (
        ('todo', 'Todo'),
        ('in_progress', 'In progress'),
        ('in_review', 'In review'),
        ('done', 'Done'),
    )

    title = db.StringField(required=True, unique_with='board')
    content = db.StringField(required=True)
    created_at = db.DateTimeField(default=now())
    created_by = db.ReferenceField('User')
    completed_at = db.DateTimeField(required=False)
    planned_start_time = db.DateTimeField(required=False)
    planned_end_time = db.DateTimeField(required=False)
    status = db.StringField(choices=STATUS_CHOICES, default='todo')
    comments = db.ListField(db.ReferenceField('Comment'))
    board = db.ReferenceField('Board')

    def save(self, *args, **kwargs):
        instance = super(Card, self).save(*args, **kwargs)

        if self.planned_start_time and self.planned_start_time.replace(tzinfo=utc) > now():
            from app import schedule_card_start_time
            schedule_card_start_time.apply_async(kwargs={'card_id': str(self.id)}, eta=self.planned_start_time)

        if self.planned_end_time and self.planned_end_time.replace(tzinfo=utc) > now():
            from app import schedule_card_end_time
            schedule_card_end_time.apply_async(kwargs={'card_id': str(self.id)}, eta=self.planned_end_time)

        if self.completed_at:
            self.completed_at = now()
            instance.save()

        return instance
Ejemplo n.º 12
0
def main():
    parser = argparse.ArgumentParser()

    parser.add_argument(
        '-i', '--image', action='append',
        help='Image (name or ID) to use. Can be specified multiple times. '
             'If none are provided, uses "CC-CentOS7"',
    )
    parser.add_argument(
        '--key-name', type=str, default='default',
        help='SSH keypair name on OS used to create an instance.'
    )
    parser.add_argument(
        '--key-file', type=str,
        default=os.environ.get('KEY_FILE', '~/.ssh/id_rsa'),
        help='Path to SSH key associated with the key-name. If not provided, '
             'falls back to envvar KEY_FILE then to the string "~/.ssh/id_rsa"',
    )
    parser.add_argument(
        '-n', '--no-clean', action='store_true',
        help='Don\'t clean up the lease on a crash (allows for debugging)',
    )
    parser.add_argument(
        '-v', '--verbose', action='store_true',
        help='Increase verbosity',
    )
    add_arguments(parser)

    args = parser.parse_args()

    images = args.image
    if not images:
        images = ['CC-CentOS7', 'CC-Ubuntu16.04']
    if args.verbose:
        print('testing images: {}'.format(images))

    key_file = args.key_file
    key_file = os.path.expanduser(key_file)
    if args.verbose:
        print('key file: {}'.format(key_file))

    session, rc = session_from_args(args=args, rc=True)

    lease = Lease(
        keystone_session=session,
        name='test-lease-{}'.format(BUILD_TAG),
        length=datetime.timedelta(minutes=240),
        sequester=True,
        _no_clean=args.no_clean,
    )
    print(now(), 'Lease: {}'.format(lease))
    with lease:
        sleep = 0 # sleep between loops to let the instance get torn down
        for image in args.image:
            time.sleep(sleep)
            sleep = 30
            print('-'*80)
            print('Starting test with image "{}"'.format(image))
            test_simple(lease, session, rc, key_file, args.key_name, image=image)
Ejemplo n.º 13
0
Archivo: artist.py Proyecto: pscn/ads
 def update(self, diff, new, factor=1.0):
   if diff > 0.0: self.lastplayed = now()
   if new:
     self.track_cnt += 1
     diff += 0.5
   self.track_rating += diff
   if self.track_cnt > 0: self.rating = self.track_rating / self.track_cnt
   Logger.info(u"updated rating: %s" % self)
Ejemplo n.º 14
0
def _check_avail():
    global _data, _unavailable_data, _lock, _bootstrap_limit

    with _lock:
        if _data is _unavailable_data:
            if _bootstrap_limit <= helpers.now():
                _unavailable_data = None
            else:
                raise UnavailableDataError()
Ejemplo n.º 15
0
def _check_avail():
	global _data, _unavailable_data, _lock, _bootstrap_limit

	with _lock:
		if _data is _unavailable_data:
			if _bootstrap_limit <= helpers.now():
				_unavailable_data = None
			else:
				raise UnavailableDataError()
Ejemplo n.º 16
0
    def test_create_card(self, email_end_celery_task, email_start_celery_task):
        user, token = self.login_and_generate_jwt_token()
        board = self.create_dummy_board(created_by=user)

        response = self.app.post('/board/{}/card'.format(board.id),
                                 headers=self.auth_header(token),
                                 data=json.dumps({
                                     "title": "Test",
                                     "content": "Test"
                                 }))

        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.json.get('title'), "Test")
        self.assertEqual(response.json.get('board'), str(board.id))

        # Create card with planned start and end time
        start_time = now() + timedelta(days=1)
        end_time = now() + timedelta(days=7)
        response = self.app.post('/board/{}/card'.format(board.id),
                                 headers=self.auth_header(token),
                                 data=json.dumps({
                                     "title":
                                     self.get_random_string(),
                                     "content":
                                     self.get_random_string(),
                                     "planned_start_time":
                                     start_time.strftime("%d/%m/%Y %H:%M"),
                                     "planned_end_time":
                                     end_time.strftime("%d/%m/%Y %H:%M"),
                                 }))
        card = Card.objects.get(id=response.json.get('id'))
        self.assertEqual(start_time.strftime("%d/%m/%Y %H:%M"),
                         card.planned_start_time.strftime("%d/%m/%Y %H:%M"))
        self.assertEqual(end_time.strftime("%d/%m/%Y %H:%M"),
                         card.planned_end_time.strftime("%d/%m/%Y %H:%M"))

        email_start_celery_task.apply_async.assert_called_once_with(
            kwargs={'card_id': str(card.id)},
            eta=datetime.strptime(start_time.strftime("%d/%m/%Y %H:%M"),
                                  "%d/%m/%Y %H:%M"))
        email_end_celery_task.apply_async.assert_called_once_with(
            kwargs={'card_id': str(card.id)},
            eta=datetime.strptime(end_time.strftime("%d/%m/%Y %H:%M"),
                                  "%d/%m/%Y %H:%M"))
Ejemplo n.º 17
0
    def _write_tx(self, source, dest, amount, memo, ts=None):
        data = {
            'payer_id': source,
            'payee_id': dest,
            'amount': amount,
            'memo': memo,
            'tx_timestamp': ts if ts else h.now()
        }

        return self.db.transaction.upsert(data)
Ejemplo n.º 18
0
class Board(db.Document):
    STATUS_CHOICES = (
        ('active', 'Active'),
        ('archived', 'Archived'),
    )
    name = db.StringField(required=True, unique=True)
    status = db.StringField(choices=STATUS_CHOICES, default='active')
    created_at = db.DateTimeField(default=now())
    created_by = db.ReferenceField('User')
    cards = db.ListField(db.ReferenceField('Card'))
Ejemplo n.º 19
0
 def _to_escrow(self, moiner, amt):
     tx_msg = (f'Mining for {moiner}. Escrow group id: {self.pool_id}')
     if self._pay('pool', 'escrow', amt, tx_msg):
         self.db.escrow.upsert({
             'escrow_group_id': self.pool_id,
             'tx_timestamp': h.now(),
             'payer_id': 'pool',
             'payee_id': moiner,
             'amount': amt,
             'memo': tx_msg
         })
Ejemplo n.º 20
0
Archivo: library.py Proyecto: pscn/ads
 def track_started(self, track, locked=False):
   if not locked: self.acquire()
   self._logger.info(u"started: %s" % track)
   timestamp= now()
   self._playing_track = track
   # add this track to the history
   self._history.extendleft([{'track': track,'skipped':False}])
   self.lookup(track, locked=True)
   self.update_ranking(locked=True)
   # CONFIG: max history length?
   if len(self._history) > 100: self._history.pop()
   if not locked: self.release()
Ejemplo n.º 21
0
def schedule_card_end_time(card_id):
    from database.models import Card
    try:
        card = Card.objects.get(id=card_id)
    except DoesNotExist:
        return

    if not card.planned_end_time:
        return

    if now() > card.planned_end_time.replace(tzinfo=utc):
        send_mail("Please end card")
Ejemplo n.º 22
0
  def load_track(track):
    timestamp = datetime.utcnow()
    Logger.info(u"loading track: %s" % track)
    track_key = track.key()
    if TrackRelationFactory.__use_db:
      TrackRelationFactory.__db.execute(
          u"SELECT relation FROM track_relation "\
          "WHERE trackA = ? or trackB = ?", (track_key, track_key))
      row = TrackRelationFactory.__db.fetchone()
      while row:
        relation = pickle.loads(str(row[0]))
        TrackRelationFactory.register(relation)
        row = TrackRelationFactory.__db.fetchone()
    elif TrackRelationFactory.__use_fs:
      path = join(TrackRelationFactory.__path,
          track.artist.key(), track_key)
      if isdir(path):
        for entry in listdir(path):
          if not entry.endswith(u".pkl"): continue
          rel_key = entry[:-4]
          f = join(path, entry)
          if not isfile(f): continue

          load = False
          if not TrackRelationFactory.__lib.has_key(rel_key):
            load = True
          else:
            modtime = getmtime(f)
            relation = TrackRelationFactory.by_key(rel_key)
            if modtime != relation.lastmodified:
              TrackRelationFactory.forget(relation)
              load = True
              Logger.info(u"loading track: file has been modified %s" % f)

          if load: TrackRelationFactory.load_file(f)

    nof_entries = TrackRelationFactory.len()
    Logger.info(u"loading track: %s" % ((datetime.utcnow() - timestamp)))
    while nof_entries > TrackRelationFactory.__maxentries:
      too_delete = (nof_entries - TrackRelationFactory.__maxentries)
      Logger.info(u"forgetting %d track relations" % too_delete)
      min_used = now()
      for v in TrackRelationFactory.__lib.values():
        if v.lastused < min_used:
          min_used = v.lastused
      for v in TrackRelationFactory.__lib.values():
        if v.lastused == min_used:
          Logger.info(u"forgetting %s" % v)
          TrackRelationFactory.forget(v)
          too_delete -= 1
          if too_delete == 0: break
      nof_entries = TrackRelationFactory.len()
    Logger.info(u"track relations: %d" % nof_entries)
Ejemplo n.º 23
0
    def listening_for(self, message):
        if h.now() > self.next_pool:
            self._reset()

        _handle = False
        text = message.get('text')
        user = message.get('metadata', {}).get('source_user')

        if (isinstance(text, str) and user and user not in self.moined
                and user not in self.pool_excludes):
            _handle = 'moin' in text.lower()

        return _handle
Ejemplo n.º 24
0
    def listening_for(self, message):
        if h.now() > getattr(self, 'next_pool', 0):
            self._update_pool()

        _handle = False
        text = message.get('text')
        if isinstance(text, str):
            params = re.split(r'\s+', text.lower())
            if (len(params) > 1 and params[0] in self.triggers
                    and params[1] == 'pool'):
                _handle = True

        return _handle
Ejemplo n.º 25
0
  def load_artist(artist):
    timestamp = datetime.utcnow()
    Logger.info(u"loading artist: %s" % artist)
    artist_key = artist.key()
    if ArtistRelationFactory.__use_db:
      ArtistRelationFactory.__db.execute(
          u"SELECT relation FROM artist_relation "\
          "WHERE artistA = ? or artistB = ?", (artist_key, artist_key))
      row = ArtistRelationFactory.__db.fetchone()
      while row:
        relation = pickle.loads(str(row[0]))
        ArtistRelationFactory.register(relation)
        row = ArtistRelationFactory.__db.fetchone()
    if ArtistRelationFactory.__use_fs:
      path = join(ArtistRelationFactory.__path, artist_key)
      if isdir(path):
        for entry in listdir(path):
          if not entry.endswith(u".pkl"): continue
          rel_key = entry[:-4]
          f = join(path, entry)
          if not isfile(f): continue

          load = False
          if not ArtistRelationFactory.__lib.has_key(rel_key):
            load = True
          else:
            modtime = getmtime(f)
            relation = ArtistRelationFactory.by_key(rel_key)
            if modtime != relation.lastmodified:
              ArtistRelationFactory.forget(relation)
              load = True
              Logger.info(u"loading artist: file has been modified %s" % f)

          if load: ArtistRelationFactory.load_file(f)
    nof_entries = ArtistRelationFactory.len()
    Logger.info(u"loading artist: %s" % (datetime.utcnow() - timestamp))
    while nof_entries > ArtistRelationFactory.__maxentries:
      too_delete = (nof_entries - ArtistRelationFactory.__maxentries)
      Logger.info(u"forgetting %d artist relations" % too_delete)
      min_used = now()
      for v in ArtistRelationFactory.__lib.values():
        if v.lastused < min_used:
          min_used = v.lastused
      for v in ArtistRelationFactory.__lib.values():
        if v.lastused == min_used:
          Logger.info(u"forgetting %s" % v)
          ArtistRelationFactory.forget(v)
          too_delete -= 1
          if too_delete == 0: break
      nof_entries = ArtistRelationFactory.len()
    Logger.info(u"artist relations: %d" % nof_entries)
Ejemplo n.º 26
0
 def updateStatus(self, newVal):
     """
     Update status of scanned file and resort the queue.
     """
     logger.debug("Setting "+self.fullpath+" from status "+helpers.statusToString(self.status).lower()+" to "+helpers.statusToString(newVal).lower())
     
     # set status of element.
     self.status = newVal
     
     
     if newVal == 0: # active
         self.timestarted = now()
     elif newVal == 3: # finished
         self.deleteOriginal() # delete original if successful transcoded and file deletion is enabled.
         self.performRename() # rename file if file was renamed via webinterface
Ejemplo n.º 27
0
    def _update_pool(self):
        _now = h.now()
        if self.next_pool <= _now:
            self.next_pool = _now + (randint(4, 15) * 3600)
            amt = randint(25, 75) * 10
            pool_balance = self._get_balance('pool', True)

            if self._update_balance('pool', pool_balance + amt):
                if self._write_tx('None', 'pool', amt, 'daily pool deposit',
                                  _now):
                    self.db.pool_history.upsert({
                        'fillup_ts': _now,
                        'next_fillup_ts': self.next_pool,
                        'amount': amt
                    })
Ejemplo n.º 28
0
    def _get_time_to_next_fill_up(self):
        out = []
        _now = h.now()
        diff = self.next_pool - _now
        if diff < 60:
            return f'{diff} Seconds'

        hours = diff // 3600
        if hours:
            out.append(f'{hours} Hours')

        remain = diff % 3600
        minutes = remain // 60
        if minutes:
            out.append(f'{minutes} Minutes')

        return ', '.join(out)
Ejemplo n.º 29
0
    def log(self, message, level):

        logger = logging.getLogger('mylar')

        threadname = threading.currentThread().getName()

        if level != 'DEBUG':
            import helpers
            herp.LOG_LIST.insert(0, (helpers.now(), message, level, threadname))

        message = threadname + ' : ' + message

        if level == 'DEBUG':
            logger.debug(message)
        elif level == 'INFO':
            logger.info(message)
        elif level == 'WARNING':
            logger.warn(message)
        else:
            logger.error(message)
Ejemplo n.º 30
0
def save_configuration():
	global _data_dir

	# Don't write if there's no destination
	if _data_dir is None:
		return False

	rm_old_files()

	snapshot = {}
	# Get a raw copy of all data
	snapshot[ 'copy'] = data.get_copy()
	# Get current system state
	snapshot[ 'cluster'] = sync.cluster_state.get_state()

	# Write this configuration
	file_name = _data_dir + '/' +helpers.now().strftime( DATA_DIR_STRFTIME)
	with open(file_name, 'w') as f:
		f.write( helpers.dump_json( snapshot))
	return True
Ejemplo n.º 31
0
def save_configuration():
    global _data_dir

    # Don't write if there's no destination
    if _data_dir is None:
        return False

    rm_old_files()

    snapshot = {}
    # Get a raw copy of all data
    snapshot['copy'] = data.get_copy()
    # Get current system state
    snapshot['cluster'] = sync.cluster_state.get_state()

    # Write this configuration
    file_name = _data_dir + '/' + helpers.now().strftime(DATA_DIR_STRFTIME)
    with open(file_name, 'w') as f:
        f.write(helpers.dump_json(snapshot))
    return True
Ejemplo n.º 32
0
Archivo: file.py Proyecto: pscn/ads
 def played(self, factor=1.0):
   self.playcount += 1
   self.lastplayed = now()
   self.track.played(factor)
Ejemplo n.º 33
0
def main():
    parser = argparse.ArgumentParser()

    parser.add_argument(
        '-i',
        '--image',
        action='append',
        help='Image (name or ID) to use. Can be specified multiple times. '
        'If none are provided, uses "CC-CentOS7"',
    )
    parser.add_argument(
        '--key-name',
        type=str,
        default='default',
        help='SSH keypair name on OS used to create an instance.')
    parser.add_argument(
        '--key-file',
        type=str,
        default=os.environ.get('KEY_FILE', '~/.ssh/id_rsa'),
        help='Path to SSH key associated with the key-name. If not provided, '
        'falls back to envvar KEY_FILE then to the string "~/.ssh/id_rsa"',
    )
    parser.add_argument(
        '-n',
        '--no-clean',
        action='store_true',
        help='Don\'t clean up the lease on a crash (allows for debugging)',
    )
    parser.add_argument(
        '-v',
        '--verbose',
        action='store_true',
        help='Increase verbosity',
    )
    add_arguments(parser)

    args = parser.parse_args()

    images = args.image
    if not images:
        images = ['CC-CentOS7', 'CC-Ubuntu16.04']
    if args.verbose:
        print('testing images: {}'.format(images))

    key_file = args.key_file
    key_file = os.path.expanduser(key_file)
    if args.verbose:
        print('key file: {}'.format(key_file))

    session, rc = session_from_args(args=args, rc=True)

    lease = Lease(
        keystone_session=session,
        name='test-lease-{}'.format(BUILD_TAG),
        length=datetime.timedelta(minutes=240),
        sequester=True,
        _no_clean=args.no_clean,
    )
    print(now(), 'Lease: {}'.format(lease))
    with lease:
        sleep = 0  # sleep between loops to let the instance get torn down
        for image in args.image:
            time.sleep(sleep)
            sleep = 30
            print('-' * 80)
            print('Starting test with image "{}"'.format(image))
            test_simple(lease,
                        session,
                        rc,
                        key_file,
                        args.key_name,
                        image=image)
Ejemplo n.º 34
0
 def __init__(self):
     self.dob = now()
     self._current = self.get_current_state()
Ejemplo n.º 35
0
 def elapsed(self):
     e = int((now() - self.dob).total_seconds())
     # Handle time error margins that can cause this to be negative:
     return max(0, e)
Ejemplo n.º 36
0
 def _touch_last_push(self):
     self._last_push = helpers.now()
Ejemplo n.º 37
0
Archivo: artist.py Proyecto: pscn/ads
 def queued(self):
   self.lastqueued = now()
Ejemplo n.º 38
0
Archivo: file.py Proyecto: pscn/ads
 def queued(self):
   self.lastqueued = now()
   self.track.queued()
Ejemplo n.º 39
0
	def _touch_last_push(self):
		self._last_push = helpers.now()
Ejemplo n.º 40
0
Archivo: library.py Proyecto: pscn/ads
  def seed(self, track, locked=False):
    """Calculate relations based on track as seed.
    """
    if not locked: self.acquire()
    benchmark = Benchmark()
    timestamp = now()
    seed_track = set()
    seed_artist = set()
    if track:
      seed_track.add(track)
      seed_artist.add(track.artist)
      self.lookup(track, True)

    # check artist relations
    cnt = 0
    benchmark.start()
    tt = []
    for seed_a in seed_artist.union(self._seed_artists):
      self._logger.info(u'check artist relations for {}'.format(seed_a))
      for artist_relation in ArtistRelationFactory.by_artist(seed_a):
        cnt += 1
        other_artist = artist_relation.artistA
        if artist_relation.artistA.name == seed_a.name:
          other_artist = artist_relation.artistB

        other_artist.relation_sum += artist_relation.rating
        other_artist.relation_cnt += 1
        other_artist.relation = (other_artist.relation_sum /
            other_artist.relation_cnt)
        top_ten(tt, u'artist related with {}({}/{}={}) to {}'.format(
              scale_rating(artist_relation.rating),
              scale_rating(other_artist.relation_sum),
              scale_rating(other_artist.relation_cnt),
              scale_rating(other_artist.relation),
              other_artist), artist_relation.rating)

        artist_relation.lastused = timestamp
    top_ten_dump(tt, self._logger.info)

    self._logger.info(u"update ranking: check artist took %s" % benchmark)
    self._logger.info(u"updated %d artist(s)" % cnt)

    cnt = 0
    benchmark.start()
    tt = []
    for seed_t in seed_track.union(self._seed_tracks):
      self._logger.info(u'check track relations for {}'.format(seed_t))
      for track_relation in TrackRelationFactory.by_track(seed_t):
        other_track = track_relation.trackA
        if track_relation.trackA.title == seed_t.title and \
            track_relation.trackA.artist.name == seed_t.artist.name:
          other_track = track_relation.trackB
        cnt += 1
        if not track.ban:
          other_track.relation_sum += track_relation.rating
          other_track.relation_cnt += 1
          other_track.relation = (other_track.relation_sum /
              other_track.relation_cnt)
          top_ten(tt, u'track related with {} to {}'.format(
              scale_rating(track_relation.rating), other_track),
              track_relation.rating)

        track_relation.lastused = timestamp
    top_ten_dump(tt, self._logger.info)
    self._logger.info(u"update ranking: check track took %s" % benchmark)
    self._logger.info(u"updated %d track(s)" % cnt)
    if not locked: self.release()
Ejemplo n.º 41
0
Archivo: track.py Proyecto: pscn/ads
 def played(self, factor=1.0):
   self.lastplayed = now()
   self.update(True, factor)
Ejemplo n.º 42
0
Archivo: track.py Proyecto: pscn/ads
 def started(self):
   self.laststarted = now()
   self.artist.started()
Ejemplo n.º 43
0
Archivo: track.py Proyecto: pscn/ads
 def queued(self):
   self.lastqueued = now()
   self.artist.queued()
Ejemplo n.º 44
0
Archivo: file.py Proyecto: pscn/ads
 def started(self):
   self.laststarted = now()
   if self.track: self.track.started()
Ejemplo n.º 45
0
Archivo: artist.py Proyecto: pscn/ads
 def started(self):
   self.laststarted = now()
Ejemplo n.º 46
0
 def handle(self, message):
     response = self._format_get_pool()
     if response:
         self.next_pool = h.now() + 60
         opts = self.build_reply_opts(message)
         self.reply(message, response, opts)
Ejemplo n.º 47
0
Archivo: library.py Proyecto: pscn/ads
  def next_file(self, locked=False):
    self._logger.info(u"next file: start")
    if not locked: self.acquire()
    if not self._ranking_updated: self.update_ranking()
    best_ranking = 0
    best_tracks = []
    tt = []

    timestamp = now()

    # calculate last_*_timestamps (played / queued / started)
    track_lastplayed_timestamp = timestamp - self._thres_track_lastplayed
    track_laststarted_timestamp = timestamp - self._thres_track_laststarted
    track_lastqueued_timestamp = timestamp - self._thres_track_lastqueued
    artist_lastplayed_timestamp = timestamp - self._thres_artist_lastplayed
    artist_laststarted_timestamp = timestamp - self._thres_artist_laststarted
    artist_lastqueued_timestamp = timestamp - self._thres_artist_lastqueued

    has_active_tracks = False
    for track in TrackFactory.active_tracks():
      has_active_tracks = True
      artist = track.artist
      factor = 1.0
      if (track.lastplayed > track_lastplayed_timestamp):
        factor = min(factor,
            1.0 - ((1.0 * track.lastplayed - track_lastplayed_timestamp) /
            self._thres_track_lastplayed))
      if (artist.lastplayed > artist_lastplayed_timestamp):
        factor = min(factor,
            1.0 - ((1.0 * artist.lastplayed - artist_lastplayed_timestamp) /
            self._thres_artist_lastplayed))
      if (track.laststarted > track_laststarted_timestamp):
        factor = min(factor,
            1.0 - ((1.0 * track.laststarted - track_laststarted_timestamp) /
            self._thres_track_laststarted))
      if (artist.laststarted > artist_laststarted_timestamp):
        factor = min(factor,
            1.0 - ((1.0 * artist.laststarted - artist_laststarted_timestamp) /
            self._thres_artist_laststarted))
      if (track.lastqueued > track_lastqueued_timestamp):
        factor = min(factor,
            1.0 - ((1.0 * track.lastqueued - track_lastqueued_timestamp) /
            self._thres_track_lastqueued))
      if (artist.lastqueued > artist_lastqueued_timestamp):
        factor = min(factor,
            1.0 - ((1.0 * artist.lastqueued - artist_lastqueued_timestamp) /
            self._thres_artist_lastqueued))
      ranking = int(self._ranking_base * factor * track.ranking)

      if ranking > best_ranking:
        self._logger.debug("%2.2f (best=): %s" % (ranking, track))
        best_ranking = ranking
        best_tracks = [track]
      elif ranking == best_ranking:
        self._logger.debug("%2.2f (best+): %s" % (ranking, track))
        best_tracks.append(track)
      top_ten(tt, track, ranking)
    if not has_active_tracks:
      self._logger.error(u"No active tracks")
      if not locked: self.release()
      return None
    top_ten_dump(tt, self._logger.info, u"rank")
    self._logger.info("best tracks: %d" % (len(best_tracks)))
    best_track = choice(best_tracks)
    best_track.started()

    # pick the best file
    best_rating = 0.0
    best_files = []
    for file in best_track.files():
      if not file.active: continue
      t = file.playcount / (1.0 + file.skipcount)
      if t > best_rating:
        best_rating = t
        best_files = [file]
      elif t == best_rating:
        best_files.append(file)
    if not locked: self.release()
    self._logger.info(u"next file: stop")
    return choice(best_files)
Ejemplo n.º 48
0
	def _touch_last_reachable(self):
		self._reachable = True
		self._last_reachable = helpers.now()
Ejemplo n.º 49
0
class Comment(db.Document):
    content = db.StringField(required=True)
    created_at = db.DateTimeField(default=now())
    created_by = db.ReferenceField('User')
    card = db.ReferenceField('Card')
Ejemplo n.º 50
0
 def __init__(self, artistA, artistB):
   self.artistA = artistA
   self.artistB = artistB
   self.lastused = now()
   ArtistRelationFactory.save(self)
Ejemplo n.º 51
0
 def _touch_last_reachable(self):
     self._reachable = True
     self._last_reachable = helpers.now()