def get_cache_con():
	if not cache_con_map.has_key(threading._get_ident()):
		cache_con = sqlite.connect(":memory:")
		cur = cache_con.cursor()
		cur.execute("create table plugin_result_cache(url string, timestamp long, content string)")
		cur.close()
		cache_con_map[threading._get_ident()] = cache_con
	con = cache_con_map[threading._get_ident()]
	return con

def findphoto(bs,url):
    global x
    jieguo=bs.findAll(name ="img",attrs={"src":re.compile(r"^http://")})  #re.compile(r"^http://")
    for temp in jieguo:
        print "find picture %s"% temp["src"]
        print threading._get_ident()
        if(re.compile(r"http://").findall(temp["src"])):
            download(temp["src"])                            #下载方式一
        else:
            print "\n\n\n\n\n\n\n"
            b=urlparse.urlparse(url)
            tempurl=b[0]+r"://"+b[1]+r"/"+temp["src"]
            print tempurl
            download(tempurl)

    def request(self, clientAddress, remoteHost, scheme="http"):
        """Obtain an HTTP Request object.
        
        clientAddress: the (IP address, port) of the client
        remoteHost: the IP address of the client
        scheme: either "http" or "https"; defaults to "http"
        """
        if self.state == STOPPED:
            raise cherrypy.NotReady("The CherryPy server has stopped.")
        elif self.state == STARTING:
            raise cherrypy.NotReady("The CherryPy server could not start.")

        threadID = threading._get_ident()
        if threadID not in self.seen_threads:

            if cherrypy.codecoverage:
                from cherrypy.lib import covercp

                covercp.start()

            i = len(self.seen_threads) + 1
            self.seen_threads[threadID] = i

            for func in self.on_start_thread_list:
                func(i)

        r = self.request_class(clientAddress[0], clientAddress[1], remoteHost, scheme)
        cherrypy.serving.request = r
        cherrypy.serving.response = self.response_class()
        return r

 def get_repository(self, authname):
     if not self._connector:
         candidates = []
         for connector in self.connectors:
             for repos_type_, prio in connector.get_supported_types():
                 if self.repository_type != repos_type_:
                     continue
                 heappush(candidates, (-prio, connector))
         if not candidates:
             raise TracError('Unsupported version control system "%s". '
                             'Check that the Python bindings for "%s" are '
                             'correctly installed.' %
                             ((self.repository_type,)*2))
         self._connector = heappop(candidates)[1]
     db = self.env.get_db_cnx() # prevent possible deadlock, see #4465
     try:
         self._lock.acquire()
         tid = threading._get_ident()
         if tid in self._cache:
             repos = self._cache[tid]
         else:
             rtype, rdir = self.repository_type, self.repository_dir
             repos = self._connector.get_repository(rtype, rdir, authname)
             self._cache[tid] = repos
         return repos
     finally:
         self._lock.release()

def currentThread():
    from threading import _get_ident, _active, _DummyThread

    try:
        return _active[_get_ident()]
    except KeyError:
        return _DummyThread()

 def release(self):
     if self.__owner != _get_ident():
         raise RuntimeError("cannot release un-aquired lock")
     self.__count -= 1
     if not self.__count:
         self.__owner = None
         self.__block.release()

 def request(self, local_host, remote_host, scheme="http",
             server_protocol="HTTP/1.1"):
     """Obtain and return an HTTP Request object. (Core)
     
     local_host should be an http.Host object with the server info.
     remote_host should be an http.Host object with the client info.
     scheme: either "http" or "https"; defaults to "http"
     """
     if self.state == STOPPED:
         req = NotReadyRequest("The CherryPy engine has stopped.")
     elif self.state == STARTING:
         req = NotReadyRequest("The CherryPy engine could not start.")
     else:
         # Only run on_start_thread_list if the engine is running.
         threadID = threading._get_ident()
         if threadID not in self.seen_threads:
             i = len(self.seen_threads) + 1
             self.seen_threads[threadID] = i
             
             for func in self.on_start_thread_list:
                 func(i)
         req = self.request_class(local_host, remote_host, scheme,
                                  server_protocol)
     resp = self.response_class()
     cherrypy.serving.load(req, resp)
     self.servings.append((req, resp))
     return req

  def __bootstrap(self):
    try:
      self._set_ident()
      self._Thread__started.set()
      threading._active_limbo_lock.acquire()
      threading._active[self._Thread__ident] = self
      del threading._limbo[self]
      threading._active_limbo_lock.release()

      if threading._trace_hook:
        sys.settrace(threading._trace_hook)
      if threading._profile_hook:
        sys.setprofile(threading._profile_hook)

      try:
        self.run()
      finally:
        self._Thread__exc_clear()
    finally:
      with threading._active_limbo_lock:
        self._Thread__stop()
        try:
          del threading._active[threading._get_ident()]
        except:
          pass

 def get_connection(self):
     key = self.dbpath + str(threading._get_ident())
     if key in _MAP_OF_CONNECTIONS:
         return _MAP_OF_CONNECTIONS[key]
     conn = sqlite3.connect(self.dbpath)
     print "Trying to open", self.dbpath
     _MAP_OF_CONNECTIONS[key] = conn
     return conn

 def shutdown(self, tid=None):
     if tid:
         assert tid == threading._get_ident()
         try:
             self._lock.acquire()
             self._cache.pop(tid, None)
         finally:
             self._lock.release()

    def getInstance(create=True):
        tid = threading._get_ident()
        instance = DALManager._instances.get(tid)

        if not instance and create:
            minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
            instance = DBConnection(minfo)
            DALManager._instances[tid] = instance
        return instance

    def startRequest( self ):
        """Initialise the DB and starts a new transaction.
        """

        conn = self._getConnObject()
        if conn is None:
            self._conn[threading._get_ident()]=self._db.open()
            Logger.get('dbmgr').debug('Allocated connection for thread %s - table size is %s' % (threading._get_ident(), len(self._conn)))
        else:
            Logger.get('dbmgr').debug('Reused connection for thread %s - table size is %s' % (threading._get_ident(), len(self._conn)))

 def acquire(self,blocking=True,timeout=None):
     me = _get_ident()
     if self.__owner == me:
         self.__count += 1
         return True
     if self.__block.acquire(blocking,timeout):
         self.__owner = me
         self.__count = 1
         return True
     return False

	def gotThreadMsg(self, msg=None):
		
		from ctypes import CDLL
		SYS_gettid = 4222
		libc = CDLL("libc.so.6")
		tid = libc.syscall(SYS_gettid)
		splog('SP: Worker got message: ', currentThread(), _get_ident(), self.ident, os.getpid(), tid )
		
		data = self.__messages.pop()
		if callable(self.callback):
			self.callback(data)

 def __repr__(self, _repr_running={}):
     'od.__repr__() <==> repr(od)'
     call_key = id(self), _get_ident()
     if call_key in _repr_running:
         return '...'
     _repr_running[call_key] = 1
     try:
         if not self:
             return '%s()' % (self.__class__.__name__,)
         return '%s(%r)' % (self.__class__.__name__, self.items())
     finally:
         del _repr_running[call_key]

 def release(self):
     if not self.is_locked:
         return False
     ident = threading._get_ident()
     ot = self.owner_thread
     if ident != self.current_owner:
         return False
     self.lock_count -= 1
     if self.lock_count == 0:
         self.current_owner = None
         self.__lock.release()
     return True

def __ThreadIDPrint():
    msg = ''
    if not Debug_Setting.Thread_ID_Show:
        return msg
    thread_name = threading.currentThread().getName()
    if thread_name is None:
        thread_name = ''
    msg += '[Thread:%d\t' % threading._get_ident()
    if Debug_Setting.Thread_Name_Show:
        msg += '%s\t' % thread_name
    msg += ']\t'
    return msg

	def run(self):
		
		from ctypes import CDLL
		SYS_gettid = 4222
		libc = CDLL("libc.so.6")
		tid = libc.syscall(SYS_gettid)
		splog('SP: Worker got message: ', currentThread(), _get_ident(), self.ident, os.getpid(), tid )
		
		while not self.__queue.empty():
			
			# NOTE: we have to check this here and not using the while to prevent the parser to be started on shutdown
			if not self.__running: break
			
			item = self.__queue.pop()
			
			splog('SP: Worker is processing')
			
			result = None
			
			try:
				result = item.identifier.getEpisode(
					item.name, item.begin, item.end, item.service
				)
			except Exception, e:
				splog("SP: Worker: Exception:", str(e))
				
				# Exception finish job with error
				result = str(e)
			
			config.plugins.seriesplugin.lookup_counter.value += 1
			
			if result and len(result) == 4:
				splog("SP: Worker: result callback")
				season, episode, title, series = result
				season = int(CompiledRegexpNonDecimal.sub('', season))
				episode = int(CompiledRegexpNonDecimal.sub('', episode))
				title = title.strip()
				if config.plugins.seriesplugin.replace_chars.value:
					repl = re.compile('['+config.plugins.seriesplugin.replace_chars.value.replace("\\", "\\\\\\\\")+']')
					
					splog("SP: refactor title", title)
					title = repl.sub('', title)
					splog("SP: refactor title", title)
					
					splog("SP: refactor series", series)
					series = repl.sub('', series)
					splog("SP: refactor series", series)
				self.__messages.push( (item.callback, (season, episode, title, series)) )
			else:
				splog("SP: Worker: result failed")
				self.__messages.push( (item.callback, result) )
			self.__pump.send(0)

 def wrlock(self, blocking=True):
     """
     Get a Write lock
     """
     me = _get_ident()
     with self.lock:
         while not self._wrlock(me):
             if not blocking:
                 return False
             self.nw += 1
             self.wcond.wait()
             self.nw -= 1
     return True

 def acquire_thread(self):
     """Run 'start_thread' listeners for the current thread.
     
     If the current thread has already been seen, any 'start_thread'
     listeners will not be run again.
     """
     thread_ident = threading._get_ident()
     if thread_ident not in self.threads:
         # We can't just use _get_ident as the thread ID
         # because some platforms reuse thread ID's.
         i = len(self.threads) + 1
         self.threads[thread_ident] = i
         self.bus.publish('start_thread', i)