def deltestdata_api():
    print 'deleting test data'
    for email2key in [redis_book_key_from_email,
                      redis_auth_key_from_email]:
        print email2key('[email protected]')
        redis.delete(email2key('[email protected]'))
    return jsonify({'ip': get_remote_ip()}), 200

def resubmit_jobs():
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    log.debug('_create_or_update_package')
    harvest_object_pending = redis.keys('harvest_object_id:*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key).seconds > 180: # 3 minuites for fetch and import max
            redis.rpush('harvest_object_id',
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    harvest_jobs_pending = redis.keys('harvest_job_id:*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key).seconds > 7200: # 3 hours for a gather
            redis.rpush('harvest_job_id',
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)

def generateSet(products,tmpSetName):
    '''
    Generate a temporary union set for the given products list.
    '''
    print "generateSet()"
    
    if len(products)==0:
        print "Parameter(products) is empty!"
        return None
    
    redis = brconfig.getRedis()
    pipe = redis.pipeline(transaction=True)    
    
    sets=[]
    for p in products:
        sets.append("ids:i:android.os.Build.PRODUCT:%s"%p)
        
    pipe.sunionstore(tmpSetName,sets)
    ret=pipe.execute()
    
    if ret[0]==0:
        redis.delete(tmpSetName)
        print "Generated an empty set!"
        return None
    else:  
        return tmpSetName

def resubmit_jobs():
    '''
    Examines the fetch and gather queues for items that are suspiciously old.
    These are removed from the queues and placed back on them afresh, to ensure
    the fetch & gather consumers are triggered to process it.
    '''
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    # fetch queue
    harvest_object_pending = redis.keys(get_fetch_routing_key() + ':*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 minutes for fetch and import max
        if (datetime.datetime.now() - date_of_key).seconds > 180:
            redis.rpush(get_fetch_routing_key(),
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    # gather queue
    harvest_jobs_pending = redis.keys(get_gather_routing_key() + ':*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 hours for a gather
        if (datetime.datetime.now() - date_of_key).seconds > 7200:
            redis.rpush(get_gather_routing_key(),
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)

def diagnose_cb():
  user_session = get_session(redis,request.values.get('CallSid'))
  symptom = urllib.unquote(request.args.get('symptom'))
  print symptom
  resp = twilio.twiml.Response()
  digit_pressed = request.values.get('Digits', None)
  if digit_pressed == "1":
    user_session['symptom_whitelist'].append(symptom)
    set_session(redis,request.values.get('CallSid'), user_session)
  else:
    user_session['symptom_blacklist'].append(symptom)
    set_session(redis,request.values.get('CallSid'), user_session)
  diseases = symptomelimination.calculate_probability_for_disease(user_session['location'], user_session['symptom_whitelist'])
  # its for the case that no user input is made (so people will not have a disease without symptom)
  if len(user_session['symptom_whitelist']) == 0:
    for disease in diseases:
      disease['probability'] = 0
  diseases = sorted(diseases, cmp=lambda x, y: cmp(y['probability'],x['probability']))
  for disease in diseases:
    print helpers.get_name_for_disease(disease['disease']), disease['probability']
  if user_session['question_count'] >= 3 and diseases[0]['probability'] > 0.8:
    resp.say("We have determined there is a high probability you have {0}".format(helpers.get_name_for_disease(diseases[0]['disease'])),**default_ops)
    resp.say("We suggest you seek medical attention as soon as possible",**default_ops)
    resp.hangup()
    redis.delete(request.values.get('CallSid'))
  elif user_session['question_count'] >= 7:
    resp.say("Sorry, we are unable to determine what you are sick with.",**default_ops)
    resp.redirect('/ems')
  else:
    resp.redirect('/diagnose')
  return str(resp)

	def DELETE(self, name):
		#params = web.input()
		#print params
		clipName = name
		redis.delete("cue:" + clipName)
		redis.save()
		cull_playlists(name)

def get_accessible_ids(token,ids=None):
    tmpSetName='tmp_%s'%str(uuid.uuid4())
    tmpSetName=getAccessibleSet(token,tmpSetName,ids=ids)
    if tmpSetName==None:
        return None
    else:
        redis=brconfig.getRedis()
        ret_ids=redis.smembers(tmpSetName)
        redis.delete(tmpSetName)
        return ret_ids

def rget(redis,key):
    str = redis.get(key)
    if str:
        try:
            object = Pickle.loads(str)
            return object
        except:
            print "fail removing" + key
            redis.delete(key)
    return False

def ems():
  print "Showing number to user"
  user_session = get_session(redis,request.values.get('CallSid'))
  number = helpers.get_phone_for_country(user_session['location'])
  print number
  resp = twilio.twiml.Response()
  resp.say("To get emergency medical attention in your country hang up and dial {0}".format(" ".join(list(str(number)))),**default_ops)
  resp.hangup()
  redis.delete(request.values.get('CallSid'))
  return str(resp)

 def remove(sid, realm):
     redis = get_redis()
     redis.delete("session-%s" % sid)
     try:
         s = Session.select().join(User).where(
             (Session.id == sid) & (User.realm == realm)).get()
         s.delete_instance()
         return True
     except Session.DoesNotExist:
         return False

    def _clear(self, pipe=None):
        """Helper for clear operations.

        :param pipe: Redis pipe in case update is performed as a part
                     of transaction.
        :type pipe: :class:`redis.client.StrictPipeline` or
                    :class:`redis.client.StrictRedis`
        """
        redis = pipe if pipe is not None else self.redis
        redis.delete(self.key)

def flush_dead_mappers(redis, mappers_key, ping_key):
    mappers = redis.smembers(mappers_key)
    for mapper in mappers:
        last_ping = redis.get(ping_key % mapper)
        if last_ping:
            now = datetime.now()
            last_ping = datetime.strptime(last_ping, DATETIME_FORMAT)
            if ((now - last_ping).seconds > TIMEOUT):
                logging.warning('MAPPER %s found to be inactive after %d seconds of not pinging back' % (mapper, TIMEOUT))
                redis.srem(mappers_key, mapper)
                redis.delete(ping_key % mapper)

def route_post_initialize():
    redis = get_redis()

    for key in redis.keys('isu4:*'):
        redis.delete(key)

    shutil.rmtree(get_dir('log'))

    response = make_response('OK')
    response.headers['Content-Type'] = 'text/plain'
    return response

def clean():
    for item in checklist:
        queued = item + ":requests"
        queued_num = redis.zcard(queued)
        if queued_num > 0:
            redis.delete(queued)
        cached = item + ":items"
        cached_num = redis.llen(cached)
        if cached_num > 0:
            redis.delete(cached)
    print("Clean all queued requests successfully!")

def hangup():
    try:
        From = request.args['From']
        CallUUID = request.args['CallUUID']

        if CallUUID == redis.get(From):
            redis.delete(From)

    except KeyError:
        pass
    
    return "Done"

def remove_building(building_identifier):
	status = False
	try:
		bldg = Building.query.filter_by(building_identifier = building_identifier).all()[0]
		db.session.delete(bldg)
		db.session.commit()
		if config.buildings_cache_enabled == True:
			redis.delete(building_identifier)
			redis.delete('buildings')
		status = True
	except Exception as ex:
		db.session.rollback()
		log.debug('remove_building(): error: ' + str(ex))
	return(status)

def clear_sub_nodes(type_name, hashcode):
    namehash = "%s:%s" % (type_name, hashcode)
    metahash = "%s:linked_fields:%s" % (type_name, hashcode)
    m_type = redis.type(metahash)
    if m_type == "list":
        for index in redis.lrange(metahash, 0, -1):
            i = int(index)
            clear_sub_nodes(type_name, redis.lindex(namehash, i))
    elif m_type == "hash":
        meta_dictionary = redis.hgetall(namehash)
        for key in meta_dictionary:
            linked_node_hash = meta_dictionary[key]
            clear_sub_nodes(type_name, linked_node_hash)
    redis.delete(namehash)
    redis.delete(metahash)

    def _xray_clean_up_entries_for_driver(self, driver_id):
        """Remove this driver's object/task entries from redis.

        Removes control-state entries of all tasks and task return
        objects belonging to the driver.

        Args:
            driver_id: The driver id.
        """

        xray_task_table_prefix = (
            ray.gcs_utils.TablePrefix_RAYLET_TASK_string.encode("ascii"))
        xray_object_table_prefix = (
            ray.gcs_utils.TablePrefix_OBJECT_string.encode("ascii"))

        task_table_objects = self.state.task_table()
        driver_id_hex = binary_to_hex(driver_id)
        driver_task_id_bins = set()
        for task_id_hex, task_info in task_table_objects.items():
            task_table_object = task_info["TaskSpec"]
            task_driver_id_hex = task_table_object["DriverID"]
            if driver_id_hex != task_driver_id_hex:
                # Ignore tasks that aren't from this driver.
                continue
            driver_task_id_bins.add(hex_to_binary(task_id_hex))

        # Get objects associated with the driver.
        object_table_objects = self.state.object_table()
        driver_object_id_bins = set()
        for object_id, _ in object_table_objects.items():
            task_id_bin = ray.raylet.compute_task_id(object_id).id()
            if task_id_bin in driver_task_id_bins:
                driver_object_id_bins.add(object_id.id())

        def to_shard_index(id_bin):
            return binary_to_object_id(id_bin).redis_shard_hash() % len(
                self.state.redis_clients)

        # Form the redis keys to delete.
        sharded_keys = [[] for _ in range(len(self.state.redis_clients))]
        for task_id_bin in driver_task_id_bins:
            sharded_keys[to_shard_index(task_id_bin)].append(
                xray_task_table_prefix + task_id_bin)
        for object_id_bin in driver_object_id_bins:
            sharded_keys[to_shard_index(object_id_bin)].append(
                xray_object_table_prefix + object_id_bin)

        # Remove with best effort.
        for shard_index in range(len(sharded_keys)):
            keys = sharded_keys[shard_index]
            if len(keys) == 0:
                continue
            redis = self.state.redis_clients[shard_index]
            num_deleted = redis.delete(*keys)
            logger.info("Removed {} dead redis entries of the driver from"
                        " redis shard {}.".format(num_deleted, shard_index))
            if num_deleted != len(keys):
                logger.warning("Failed to remove {} relevant redis entries"
                               " from redis shard {}.".format(
                                   len(keys) - num_deleted, shard_index))

def send_ui_reply():
	sms_id = request.form.get('sms_id')
	sms_reply = request.form.get('action')

	print "Here I am: SMS Id - %s" % sms_id

	if ((sms_reply != "") and (not sms_id.startswith("del"))):
		src = redis.hget(sms_id,'From')
		plivo_did = redis.hget(sms_id,'Plivo DID')
		redis.hset(sms_id,"Replied",'y')
		redis.save()
		send_auto_response(src, plivo_did, sms_reply, 'True')
	elif ((sms_reply != "") and (sms_reply == "del")):
		redis.delete(sms_id[4:])
		redis.save()
	return "OK"

    def _clean_up_entries_from_shard(self, object_ids, task_ids, shard_index):
        redis = self.state.redis_clients[shard_index]
        # Clean up (in the future, save) entries for non-empty objects.
        object_ids_locs = set()
        object_ids_infos = set()
        for object_id in object_ids:
            # OL.
            obj_loc = redis.zrange(OBJECT_LOCATION_PREFIX + object_id, 0, -1)
            if obj_loc:
                object_ids_locs.add(object_id)
            # OI.
            obj_info = redis.hgetall(OBJECT_INFO_PREFIX + object_id)
            if obj_info:
                object_ids_infos.add(object_id)

        # Form the redis keys to delete.
        keys = [TASK_TABLE_PREFIX + k for k in task_ids]
        keys.extend([OBJECT_LOCATION_PREFIX + k for k in object_ids_locs])
        keys.extend([OBJECT_INFO_PREFIX + k for k in object_ids_infos])

        if not keys:
            return
        # Remove with best effort.
        num_deleted = redis.delete(*keys)
        log.info(
            "Removed {} dead redis entries of the driver from redis shard {}.".
            format(num_deleted, shard_index))
        if num_deleted != len(keys):
            log.warning(
                "Failed to remove {} relevant redis entries"
                " from redis shard {}.".format(len(keys) - num_deleted))