コード例 #1
0
ファイル: resolver.py プロジェクト: rvsiy/rez
 def _releases_since_solve(key, data):
     _, release_times_dict, _ = data
     for package_name, release_time in release_times_dict.iteritems():
         time_ = get_last_release_time(package_name, self.package_paths)
         if time_ != release_time:
             self._print(
                 "A newer version of %r (%d) has been released since the "
                 "resolve was cached (latest release in cache was %d) "
                 "(entry: %r)", package_name, time_, release_time, key)
             return True
     return False
コード例 #2
0
ファイル: resolver.py プロジェクト: skral/rez
 def _releases_since_solve(key, data):
     _, release_times_dict, _ = data
     for package_name, release_time in release_times_dict.iteritems():
         time_ = get_last_release_time(package_name, self.package_paths)
         if time_ != release_time:
             self._print(
                 "A newer version of %r (%d) has been released since the "
                 "resolve was cached (latest release in cache was %d) "
                 "(entry: %r)", package_name, time_, release_time, key)
             return True
     return False
コード例 #3
0
ファイル: resolver.py プロジェクト: skral/rez
    def _set_cached_solve(self, solver_dict):
        """Store a solve to memcached.

        If there is NOT a resolve timestamp:
            - store the solve to a non-timestamped entry.

        If there IS a resolve timestamp (let us call this T):
            - if NO newer package in the solve has been released since T,
              - then store the solve to a non-timestamped entry;
            - else:
              - store the solve to a timestamped entry.
        """
        if self.status_ != ResolverStatus.solved:
            return  # don't cache failed solves

        if not (self.caching and self.memcached_servers):
            return

        # most recent release times get stored with solve result in the cache
        releases_since_solve = False
        release_times_dict = {}
        variant_states_dict = {}

        for variant in self.resolved_packages_:
            time_ = get_last_release_time(variant.name, self.package_paths)

            # don't cache if a release time isn't known
            if time_ == 0:
                self._print(
                    "Did not send memcache key: a repository could "
                    "not provide a most recent release time for %r",
                    variant.name)
                return

            if self.timestamp and self.timestamp < time_:
                releases_since_solve = True

            release_times_dict[variant.name] = time_
            repo = variant.resource._repository
            variant_states_dict[variant.name] = \
                repo.get_variant_state_handle(variant.resource)

        timestamped = (self.timestamp and releases_since_solve)
        key = self._memcache_key(timestamped=timestamped)
        data = (solver_dict, release_times_dict, variant_states_dict)
        with self._memcached_client() as client:
            client.set(key, data)
        self._print("Sent memcache key: %r", key)
コード例 #4
0
ファイル: resolver.py プロジェクト: rvsiy/rez
    def _set_cached_solve(self, solver_dict):
        """Store a solve to memcached.

        If there is NOT a resolve timestamp:
            - store the solve to a non-timestamped entry.

        If there IS a resolve timestamp (let us call this T):
            - if NO newer package in the solve has been released since T,
              - then store the solve to a non-timestamped entry;
            - else:
              - store the solve to a timestamped entry.
        """
        if self.status_ != ResolverStatus.solved:
            return  # don't cache failed solves

        if not (self.caching and self.memcached_servers):
            return

        # most recent release times get stored with solve result in the cache
        releases_since_solve = False
        release_times_dict = {}
        variant_states_dict = {}

        for variant in self.resolved_packages_:
            time_ = get_last_release_time(variant.name, self.package_paths)

            # don't cache if a release time isn't known
            if time_ == 0:
                self._print("Did not send memcache key: a repository could "
                            "not provide a most recent release time for %r",
                            variant.name)
                return

            if self.timestamp and self.timestamp < time_:
                releases_since_solve = True

            release_times_dict[variant.name] = time_
            repo = variant.resource._repository
            variant_states_dict[variant.name] = \
                repo.get_variant_state_handle(variant.resource)

        timestamped = (self.timestamp and releases_since_solve)
        key = self._memcache_key(timestamped=timestamped)
        data = (solver_dict, release_times_dict, variant_states_dict)
        with self._memcached_client() as client:
            client.set(key, data)
        self._print("Sent memcache key: %r", key)