Python Cache.isCacheStale方法代碼示例

# 需要導入模塊: from cache import Cache [as 別名]
# 或者: from cache.Cache import isCacheStale [as 別名]
class CachingWatchInterface(WatchInterface):
    cw = None

    # load saved state to simulate Walrus
    def __init__(self, watchinterface, config):
        self.cw = watchinterface
        pollfreq = config.getint('server', 'pollfreq')
        try:
            freq = config.getint('server', 'pollfreq.metrics')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.metrics = Cache(freq)

    ##
    # cloud watch methods
    ##
    def get_metric_statistics(self, period, start_time, end_time, metric_name, namespace, statistics, dimensions=None, unit=None, callback=None):
        params = {'period':period, 'start_time':start_time, 'end_time':end_time, 'metric_name':metric_name,
                  'namespace':namespace, 'statistics':statistics, 'dimensions':dimensions, 'unit':unit}
        Threads.instance().runThread(self.__get_metric_statistics_cb__, (params, callback))

    def __get_metric_statistics_cb__(self, kwargs, callback):
        try:
            ret = self.cw.get_metric_statistics(kwargs['period'], kwargs['start_time'], kwargs['end_time'],
                            kwargs['metric_name'], kwargs['namespace'], kwargs['statistics'],
                            kwargs['dimensions'], kwargs['unit'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def list_metrics(self, next_token=None, dimensions=None, metric_name=None, namespace=None, callback=None):
        if self.metrics.isCacheStale():
            params = {'next_token':next_token, 'dimensions':dimensions, 'metric_name':metric_name, 'namespace':namespace}
            Threads.instance().runThread(self.__list_metrics_cb__, (params, callback))
        else:
            callback(Response(data=self.metrics.values))

    def __list_metrics_cb__(self, kwargs, callback):
        try:
            self.metrics.values = self.cw.list_metrics(kwargs['next_token'], kwargs['dimensions'],
                                       kwargs['metric_name'], kwargs['namespace'])
            Threads.instance().invokeCallback(callback, Response(data=self.metrics.values))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def put_metric_data(self, namespace, name, value=None, timestamp=None, unit=None, dimensions=None, statistics=None, callback=None):
        params = {'namespace':namespace, 'name':name, 'value':value, 'timestamp':timestamp,
                  'unit':unit, 'dimensions':dimensions, 'statistics':statistics}
        Threads.instance().runThread(self.__put_metric_data_cb__, (params, callback))

    def __put_metric_data_cb__(self, kwargs, callback):
        try:
            ret = self.cw.put_metric_data(kwargs['namespace'], kwargs['name'], kwargs['value'],
                                       kwargs['timestamp'], kwargs['unit'], kwargs['dimensions'],
                                       kwargs['statistics'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

# 需要導入模塊: from cache import Cache [as 別名]
# 或者: from cache.Cache import isCacheStale [as 別名]
class CachingWalrusInterface(WalrusInterface):
    walrus = None

    # load saved state to simulate Walrus
    def __init__(self, walrusinterface, config):
        self.walrus = walrusinterface
        pollfreq = config.getint('server', 'pollfreq')
        try:
            freq = config.getint('server', 'pollfreq.buckets')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.buckets = Cache(freq)
        try:
            freq = config.getint('server', 'pollfreq.objects')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.objects = Cache(freq)

    def get_all_buckets(self, callback):
        # if cache stale, update it
        if self.buckets.isCacheStale():
            Threads.instance().runThread(self.__get_all_buckets_cb__, ({}, callback))
        else:
            callback(Response(data=self.buckets.values))

    def __get_all_buckets_cb__(self, kwargs, callback):
        try:
            self.buckets.values = self.walrus.get_all_buckets()
            Threads.instance().invokeCallback(callback, Response(data=self.buckets.values))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def get_all_objects(self, bucket, callback):
        # if cache stale, update it
        if self.objects.isCacheStale():
            Threads.instance().runThread(self.__get_all_objects_cb__, ({'bucket':bucket}, callback))
        else:
            callback(Response(data=self.objects.values))

    def __get_all_objects_cb__(self, kwargs, callback):
        try:
            self.buckets.values = self.walrus.get_all_objects(kwargs['bucket'])
            Threads.instance().invokeCallback(callback, Response(data=self.objects.values))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

# 需要導入模塊: from cache import Cache [as 別名]
# 或者: from cache.Cache import isCacheStale [as 別名]
class CachingClcInterface(ClcInterface):
    clc = None

    # load saved state to simulate CLC
    def __init__(self, clcinterface, config):
        self.clc = clcinterface
        pollfreq = config.getint('server', 'pollfreq')
        try:
            freq = config.getint('server', 'pollfreq.zones')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.zones = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.images')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.images = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.instances')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.instances = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.keypairs')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.keypairs = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.groups')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.groups = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.addresses')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.addresses = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.volumes')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.volumes = Cache(freq)

        try:
            freq = config.getint('server', 'pollfreq.snapshots')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.snapshots = Cache(freq)

    def get_cache_summary(self):
        summary = {'zone':self.zones.isCacheFresh(),
                   'image':self.images.isCacheFresh(),
                   'instance':self.instances.isCacheFresh(),
                   'keypair':self.keypairs.isCacheFresh(),
                   'sgroup':self.groups.isCacheFresh(),
                   'volume':self.volumes.isCacheFresh(),
                   'snapshot':self.snapshots.isCacheFresh(),
                   'eip':self.addresses.isCacheFresh()}
        return summary

    def __normalize_instances__(self, instances):
        ret = []
        if not(instances):
            return []
        for res in instances:
            if issubclass(res.__class__, EC2Object):
                for inst in res.instances:
                    inst.reservation_id = res.id
                    inst.owner_id = res.owner_id
                    inst.groups = res.groups
                    if res.groups:
                        inst.group_name = res.groups[0].id
                    ret.append(inst)
            else:
                for inst in res['instances']:
                    inst['reservation_id'] = res['id']
                    inst['owner_id'] = res['owner_id']
                    inst['groups'] = res['groups']
                    if res['groups']:
                        inst['group_name'] = res['groups'][0]['id']
                    ret.append(inst)
        return ret

    def get_all_zones(self, callback):
        # if cache stale, update it
        if self.zones.isCacheStale():
            Threads.instance().runThread(self.__get_all_zones_cb__, ({}, callback))
        else:
            callback(Response(data=self.zones.values))

    def __get_all_zones_cb__(self, kwargs, callback):
        try:
            self.zones.values = self.clc.get_all_zones()
            Threads.instance().invokeCallback(callback, Response(data=self.zones.values))
#.........這裏部分代碼省略.........

# 需要導入模塊: from cache import Cache [as 別名]
# 或者: from cache.Cache import isCacheStale [as 別名]
class CachingScaleInterface(ScaleInterface):
    scaling = None

    # load saved state to simulate Walrus
    def __init__(self, scaleinterface, config):
        self.scaling = scaleinterface
        pollfreq = config.getint('server', 'pollfreq')
        try:
            freq = config.getint('server', 'pollfreq.scalinggroups')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.groups = Cache(freq)
        try:
            freq = config.getint('server', 'pollfreq.scalinginstances')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.instances = Cache(freq)
        try:
            freq = config.getint('server', 'pollfreq.launchconfigs')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.launchconfigs = Cache(freq)

    ##
    # autoscaling methods
    ##
    def create_auto_scaling_group(self, as_group, callback=None):
        self.groups.expireCache()
        params = {'as_group':as_group}
        Threads.instance().runThread(self.__create_auto_scaling_group_cb__, (params, callback))

    def __create_auto_scaling_group_cb__(self, kwargs, callback):
        try:
            ret = self.scaling.create_auto_scaling_group(kwargs['as_group'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def delete_auto_scaling_group(self, name, force_delete=False, callback=None):
        self.groups.expireCache()
        params = {'name':name, 'force_delete':force_delete}
        Threads.instance().runThread(self.__delete_auto_scaling_group_cb__, (params, callback))

    def __delete_auto_scaling_group_cb__(self, kwargs, callback):
        try:
            ret = self.scaling.delete_auto_scaling_group(kwargs['name'], kwargs['force_delete'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def get_all_groups(self, names=None, max_records=None, next_token=None, callback=None):
        if self.groups.isCacheStale():
            params = {'names':names, 'max_records':max_records, 'next_token':next_token}
            Threads.instance().runThread(self.__get_all_groups_cb__, (params, callback))
        else:
            callback(Response(data=self.groups.values))

    def __get_all_groups_cb__(self, kwargs, callback):
        try:
            self.groups.values = self.scaling.get_all_groups(kwargs['names'],
                                    kwargs['max_records'], kwargs['next_token'])
            Threads.instance().invokeCallback(callback, Response(data=self.groups.values))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def get_all_autoscaling_instances(self, instance_ids=None, max_records=None, next_token=None, callback=None):
        if self.instances.isCacheStale():
            params = {'instance_ids':instance_ids, 'max_records':max_records,
                      'next_token':next_token}
            Threads.instance().runThread(self.__get_all_autoscaling_instances_cb__,
                                    (params, callback))
        else:
            callback(Response(data=self.instances.values))

    def __get_all_autoscaling_instances_cb__(self, kwargs, callback):
        try:
            self.instances.values = self.scaling.get_all_autoscaling_instances(
                                            kwargs['instance_ids'],
                                            kwargs['max_records'], kwargs['next_token'])
            Threads.instance().invokeCallback(callback, Response(data=self.instances.values))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def set_desired_capacity(self, group_name, desired_capacity, honor_cooldown=False, callback=None):
        self.groups.expireCache()
        params = {'group_name':group_name, 'desired_capacity':desired_capacity,
                  'honor_cooldown':honor_cooldown}
        Threads.instance().runThread(self.__set_desired_capacity_cb__, (params, callback))

    def __set_desired_capacity_cb__(self, kwargs, callback):
        try:
            ret = self.scaling.set_desired_capacity(kwargs['group_name'],
                            kwargs['desired_capacity'], kwargs['honor_cooldown'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def set_instance_health(self, instance_id, health_status, should_respect_grace_period=True, callback=None):
        params = {'instance_id':instance_id, 'health_status':health_status,
                  'should_respect_grace_period':should_respect_grace_period}
#.........這裏部分代碼省略.........

# 需要導入模塊: from cache import Cache [as 別名]
# 或者: from cache.Cache import isCacheStale [as 別名]
class CachingBalanceInterface(BalanceInterface):
    bal = None

    # load saved state to simulate Walrus
    def __init__(self, balanceinterface, config):
        self.bal = balanceinterface
        pollfreq = config.getint('server', 'pollfreq')
        try:
            freq = config.getint('server', 'pollfreq.balancers')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.balancers = Cache(freq)
        try:
            freq = config.getint('server', 'pollfreq.elb_instances')
        except ConfigParser.NoOptionError:
            freq = pollfreq
        self.instances = Cache(freq)

    ##
    # elb methods
    ##
    def create_load_balancer(self, name, zones, listeners, subnets=None,
                             security_groups=None, scheme='internet-facing', callback=None):
        self.balancers.expireCache()
        params = {'name':name, 'zones':zones, 'listeners':listeners, 'subnets':subnets,
                  'security_groups':security_groups, 'scheme':scheme}
        Threads.instance().runThread(self.__create_load_balancer_cb__, (params, callback))
    
    def __create_load_balancer_cb__(self, kwargs, callback):
        try:
            ret = self.bal.create_load_balancer(kwargs['name'], kwargs['zones'], kwargs['listeners'],
                                    kwargs['subnets'], kwargs['security_groups'], kwargs['scheme'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def delete_load_balancer(self, name, callback=None):
        self.balancers.expireCache()
        params = {'name':name}
        Threads.instance().runThread(self.__delete_load_balancer_cb__, (params, callback))

    def __delete_load_balancer_cb__(self, kwargs, callback):
        try:
            ret = self.bal.delete_load_balancer(kwargs['name'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def get_all_load_balancers(self, load_balancer_names=None, callback=None):
        if self.balancers.isCacheStale():
            params = {'load_balancer_names':load_balancer_names}
            Threads.instance().runThread(self.__get_all_load_balancers_cb__, (params, callback))
        else:
            callback(Response(data=self.balancers.values))

    def __get_all_load_balancers_cb__(self, kwargs, callback):
        try:
            self.balancers.values = self.bal.get_all_load_balancers(kwargs['load_balancer_names'])
            Threads.instance().invokeCallback(callback, Response(data=self.balancers.values))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def deregister_instances(self, load_balancer_name, instances, callback=None):
        params = {'load_balancer_name':load_balancer_name, 'instances':instances}
        Threads.instance().runThread(self.__deregister_instances_cb__, (params, callback))

    def __deregister_instances_cb__(self, kwargs, callback):
        try:
            ret = self.bal.deregister_instances(kwargs['load_balancer_name'], kwargs['instances'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def register_instances(self, load_balancer_name, instances, callback=None):
        params = {'load_balancer_name':load_balancer_name, 'instances':instances}
        Threads.instance().runThread(self.__register_instances_cb__, (params, callback))

    def __register_instances_cb__(self, kwargs, callback):
        try:
            ret = self.bal.register_instances(kwargs['load_balancer_name'], kwargs['instances'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def create_load_balancer_listeners(self, name, listeners, callback=None):
        params = {'name':name, 'listeners':listeners}
        Threads.instance().runThread(self.__create_load_balancer_listeners_cb__, (params, callback))

    def __create_load_balancer_listeners_cb__(self, kwargs, callback):
        try:
            ret = self.bal.create_load_balancer_listeners(kwargs['name'], kwargs['listeners'])
            Threads.instance().invokeCallback(callback, Response(data=ret))
        except Exception as ex:
            Threads.instance().invokeCallback(callback, Response(error=ex))

    def delete_load_balancer_listeners(self, name, ports, callback=None):
        params = {'name':name, 'ports':ports}
        Threads.instance().runThread(self.__delete_load_balancer_listeners_cb__, (params, callback))

    def __delete_load_balancer_listeners_cb__(self, kwargs, callback):
#.........這裏部分代碼省略.........