def resolve_type(self, type_id): key = "%s_issue_types_and_subtasks" % self.cache_prefix the_types = cache.get(key) the_types = None if the_types: try: the_types = pickle.loads(the_types) except pickle.UnpicklingError: the_types = None if the_types is None: self.logger.warn("Cache miss for %s" % key) the_types = self.service.getIssueTypes() the_types = [self.object_to_dict(t) for t in the_types] the_subtask_types = self.service.getSubTaskIssueTypes() the_subtask_types = [ self.object_to_dict(st) for st in the_subtask_types ] the_types.extend(the_subtask_types) cache.set(key, pickle.dumps(the_types)) the_type = [t for t in the_types if t['id'] == type_id] try: return the_type[0] except IndexError: type_help = ["%s -- %s" % (t['id'], t['name']) for t in the_types] self.logger.warn("Couldn't find type_id: %s in %s" % (type_id, type_help)) return {}
def resolve_type(self, type_id): key = "%s_issue_types_and_subtasks" % self.cache_prefix the_types = cache.get(key) the_types = None if the_types: try: the_types = pickle.loads(the_types) except pickle.UnpicklingError: the_types = None if the_types == None: self.logger.warn("Cache miss for %s" % key) the_types = self.service.getIssueTypes() the_types = [self.object_to_dict(t) for t in the_types] the_subtask_types = self.service.getSubTaskIssueTypes() the_subtask_types = [self.object_to_dict(st) for st in the_subtask_types] the_types.extend(the_subtask_types) cache.set(key, pickle.dumps(the_types)) the_type = [t for t in the_types if t['id'] == type_id] try: return the_type[0] except IndexError: type_help = ["%s -- %s" % (t['id'], t['name']) \ for t in the_types] self.logger.warn("Couldn't find type_id: %s in %s" % (type_id, type_help)) return {}
def connect(self): auth_key = "offline_auth_%s" % self.cache_prefix auth = cache.get(auth_key) client = self.clients.get(self.wsdl_url, None) if not client: from suds.client import Client client = Client(self.wsdl_url) #We cache the client because there's #major overhead in instantiating #and the initial connection #and since this mostly is run #by a long running celeryd #process a simple in-memory #cache suffices self.clients[self.wsdl_url] = client if not auth: self.logger.warn("Cache miss for %s" % auth_key) auth = client.service.login(self.username, self.password) cache.set(auth_key, auth, 60 * 60) # Cache for an hour self.auth = auth self._service = client.service
def b64_image_src(self): from kardboard.app import cache image_src = cache.get(self.cache_key) if not image_src: b64_image_src = "data:image/png;base64,%s" r = requests.post(self.BASE_URL, data='&'.join(self.get_url_bits())) b64_image_src = b64_image_src % base64.b64encode(r.content) cache.set(self.cache_key, b64_image_src, 60 * 10) image_src = b64_image_src return image_src
def resolve_status(self, status_id): key = "%s_statuses" % self.cache_prefix statuses = cache.get(key) if statuses: try: statuses = pickle.loads(statuses) except pickle.UnpicklingError: statuses = None if not statuses: self.logger.warn("Cache miss for %s" % key) statuses = self.service.getStatuses() statuses = [self.object_to_dict(s) for s in statuses] cache.set(key, pickle.dumps(statuses)) status = [s for s in statuses if s.get('id') == status_id] try: return status[0] except IndexError: self.logger.warn("Couldn't find status_id: %s in %s" % (status_id, statuses)) return {}
def resolve_resolution(self, resolution_id): key = "%s_resolutions" % self.cache_prefix resolutions = cache.get(key) if resolutions: try: resolutions = pickle.loads(resolutions) except pickle.UnpicklingError: resolutions = None if not resolutions: self.logger.warn("Cache miss for %s" % key) resolutions = self.service.getResolutions() resolutions = [self.object_to_dict(r) for r in resolutions] cache.set(key, pickle.dumps(resolutions)) resolution = [r for r in resolutions if r.get('id') == resolution_id] try: return resolution[0] except IndexError: self.logger.warn("Couldn't find resolution_id: %s in %s" % (resolution_id, resolutions)) return {}