Пример #1
0
 def get(self, parent, update = False, **kwargs):
     res = Cache.get(COMMENTDB, parent, **kwargs)
     if not res or update:
         res = Transaction(COMMENTDB).query(parent = parent, **kwargs)
         if res == None:
             res = NoneResult
         Cache.set(COMMENTDB, parent, res,**kwargs)
     return None if res == NoneResult else res
Пример #2
0
 def get(self, parent, update = False, **kwargs):
     order = kwargs.pop('order', None)
     if not order:
         order = '-datetime'
     res = Cache.get(CALENDARDB, parent,order = order, **kwargs)
     if not res or update:
         res = Transaction(CALENDARDB).query(parent = parent, order = order,  **kwargs)
         Cache.set(CALENDARDB, parent, res if res else NoneResult, **kwargs)
     return None if res == NoneResult else res
Пример #3
0
 def insert(self, *cache: Cache):
     if cache.__len__() == 1:
         self.db_connection.insert(self.collection, cache[0].to_dict())
     elif cache.__len__() > 1:
         self.db_connection.insert_many(
             self.collection,
             list(map(lambda this_cache: this_cache.to_dict(), cache)))
     else:
         print("CacheDao#insert: Nothing to insert")
Пример #4
0
 def delete(self, *cache: Cache):
     if cache.__len__() == 1:
         self.db_connection.delete_one(self.collection, {
             "is_valid": cache[0].is_valid,
             "timestamp": cache[0].timestamp
         })
     elif cache.__len__() > 1:
         self.db_connection.delete_many(
             self.collection, {
                 'timestamp': {
                     "$set":
                     list(
                         map(lambda this_cache: this_cache.timestamp,
                             cache))
                 }
             })
Пример #5
0
    def run(self):
        cache = Cache(self.size,self.strategy)
        self.gen_frequencies()
        self.gen_file_list()

        for timeslot in range(self.timeslot):
            self.go_time()
            self.apply_epsilon()
            for hits in range(self.hits):
                choice = self.select_file()
                response = cache.append_item(choice)
                if(response):
                    self.log.insert_log(response,timeslot+1,'hit',cache.get_file_status())
                else:
                    self.log.insert_log(choice,timeslot+1,'miss',cache.get_file_status())
        self.log.end_write()
Пример #6
0
 def update(self, *cache: Cache):
     if cache.__len__() == 1:
         self.db_connection.find_and_update(
             self.collection, {'timestamp': cache[0].timestamp},
             {"$set": cache[0].to_dict()})
     elif cache.__len__() > 1:
         self.db_connection.update_many(
             self.collection, {
                 'timestamp': {
                     "$set":
                     list(
                         map(lambda this_cache: this_cache.timestamp,
                             cache))
                 }
             })
     else:
         print("CacheDao#update: Nothing to update")
Пример #7
0
 def get_valid_cache(self) -> Cache:
     last_available_cache = self._cache_dao.select_one({'is_valid': True})
     if last_available_cache is not None:
         if datetime.fromtimestamp(
                 datetime.timestamp(datetime.now()) -
                 last_available_cache.timestamp).time().hour > 1:
             last_available_cache.is_valid = False
             self._cache_dao.update(last_available_cache)
         return last_available_cache
     else:
         return Cache()
Пример #8
0
    def __init__(self, black_hole=None):
        self._side_length = 8
        self._cache = Cache.get_instance()
        self.field = [[Player.EMPTY] * self._side_length
                      for i in range(self._side_length)]

        half_length = self._side_length // 2

        self.field[half_length -
                   1][half_length -
                      1] = self.field[half_length][half_length] = Player.WHITE
        self.field[half_length -
                   1][half_length] = self.field[half_length][half_length -
                                                             1] = Player.BLACK
        self.black_hole = black_hole

        if black_hole is not None:
            (row, col) = black_hole
            self.field[row][col] = Player.HOLE
Пример #9
0
 def update_cache(self):
     self._cache_dao.insert(Cache())
Пример #10
0
 def select_many(self, ftr: dict) -> [Cache]:
     return list(
         map(lambda obj: Cache(obj["is_valid"], obj["timestamp"]),
             self.db_connection.select_many(self.collection, ftr)))
Пример #11
0
 def select_one(self, ftr: dict) -> Cache:
     cache = self.db_connection.select_one(self.collection, ftr)
     return Cache().from_dict(cache) if cache is not None else Cache()
Пример #12
0
 def get(self):
     li = Cache.select().where(Cache.submited == 0).limit(12)
     for o in li:
         o.submited = 1
         o.save()
     self.finish(data=dict(li=map(model_to_dict, li)))
Пример #13
0
def parseInputs():
    script, filename = argv

    txt = open(filename)

    lines = txt.read().split('\n')

    first_line = lines[0]

    (no_videos, no_endpoints, no_requests, no_caches,
     cache_size) = intTuple(first_line)

    video_size = intTuple(lines[1])

    debug("Video %d" % no_videos)
    debug("Videos size : ")
    debug(video_size)

    videos = []
    for i in range(no_videos):
        videos.append(Video(i, video_size[i]))
    debug(videos)

    caches = []
    for i in range(no_caches):
        caches.append(Cache(i, cache_size, []))

    debug(caches)

    idx = 2

    # loop endpoint
    endpoints = []
    endpoint_id = 0
    while (no_endpoints > 0):
        (latency_to_dc, no_caches) = intTuple(lines[idx])
        idx = idx + 1

        latency_to_caches = dict()
        for i in range(no_caches):
            (cache_server, latency) = intTuple(lines[idx])
            latency_to_caches[cache_server] = latency
            idx = idx + 1

        en = Endpoint(endpoint_id, latency_to_caches, latency_to_dc)
        endpoints.append(en)

        endpoint_id = endpoint_id + 1
        no_endpoints = no_endpoints - 1

    debug(endpoints)

    requests = []
    while (no_requests > 0):
        (video_id, endpoint_id, reqs) = intTuple(lines[idx])

        requests.append(Request(video_id, endpoint_id, reqs))
        idx = idx + 1
        no_requests = no_requests - 1

    debug(requests)

    idx = 2

    return (caches, endpoints, requests, videos)