def __init__(self, path=None, name=None, egg=None):
   '''
   Try to register a new plugin.
   
   @path=Path to the plugin
   @name=Name of the plugin it self
   @egg=True if the plugin is stored into an egg file
   '''
   if not egg:
     self.path = os.path.join(path, name)
   else:
     self.path = path
   if not egg:
     self.name = 'plugins.%s' % name
   else:
     self.name = name
   self.egg = egg
   if not self.egg:
     self.__loadFromFile(self.path)
   else:
     self.__loadFromEgg(self.path)
   self.enabled = self.provides.get('enabled', False)
   self.__module = None
   self.__version = None
   self.__version_info = None
   self.__rpc = None
   logger.info("Plugin: %s registered" % self.name)

	def endConnection(self, exit=True):
		self.shellPushIntoHistory(time.time())
		
		time.sleep(2)
		if exit:
			logger.info("Sending exit")
			self.shellExit()

    def handle_connection(self, conn, remote):
        request = conn.recv(4096)
        conn.setblocking(0)
        command, url = request.splitlines()[0].split()[:2]
        if command.strip() != "GET":
            conn.shutdown(sk.SHUT_RDWR)
            conn.close()
            return True

        if url.strip() != "/":
            conn.shutdown(sk.SHUT_RDWR)
            conn.close()
            return True

        logger.info("Got a connection to the http stream, redirecting")
        host = ""
        for line in request.splitlines():
            if line.find("Host") > -1:
                host = line.strip().split()[1].split(":", 1)[0]

        conn.sendall("HTTP/1.0 200 OK\r\n")
        conn.sendall("Content-type:multipart/x-mixed-replace; boundary=--myboundary\r\n")
        conn.sendall("\r\n")
        self.clientsockets[remote] = conn
        logger.info("Connection ready for streamming")
        return True

def handle_file_failed(dongle, remote, pending, channel, files, ret, err, services):
    logger.info("handle file failed %s[%s]: %s" % (remote, channel, files))
    logger.debug(err)
    try:
        try_again = []
	rules = get_campaign_rule(files)
        if rules is None or len(rules)==0:
            raise Exception("Couldn't find rule")

        for rule in rules:
            record = save_file_failed(rule, dongle, ret, remote)

    	    # from here we try again either on timeout or if rejected count is 
    	    # smaller than filter
    	    if rule.tryAgain(record=record):
    		try_again.append(rule)

	# if we can't try again this method will raise an exception
	# and the try/catch will make sure the remote device gets out
	# of our pending list
    	if upload_after_rejected(try_again, services, dongle=dongle, remote=remote):
    	    return
    except Exception, err:
        logger.error("OOOPS!!!")
        logger.exception(err)

 def on_disconnect(self):
     a = [ p for p in pending if pending[p]==self]
     if len(a) > 0:
        logger.info("a client disconnected, clearing %s pending transactions" % len(a))
        for p in a:
            pending.pop(p)
     services.remove(self)

    def exposed_setConcurrent(self, val):
	'''
	Exposed method that lets the server tell us if we should do concurrent 
	scanning (all the scanners work at the same time), or sequence scanning.
	'''
        self.concurrent = val
        logger.info("setConcurrent %s" % val)

        def exposed_uploader_register(self, client = None,
    					    remote_quit=None, 
    					    dongles=None):
            global enabled
            all_dongles.update(dongles)
            self.dongles = set()
            self.add_dongle = async(client.add_dongle)
            self.upload = async(client.upload)
            self.remote_quit = async(remote_quit)
            self.refreshUploaders = async(client.refreshUploaders)

            self.uploader = client

            if not enabled:
                return

            if not db_ready():
        	return

            logger.info("uploader register")
            for dongle in dongles:
                self.dongles.add( str(dongle), )

            for dongle, max_conn, name in rpc.uploader.get_dongles(dongles):
                logger.info("%s: %s[%s]" % (dongle, name, max_conn))
                self.add_dongle(dongle, max_conn, name)
            self.refreshUploaders()

def handle_parent(signum, frame):
    '''
    When the parent gets the kill signal it will stop it self no forking more
    childrens.
    '''
    logger.info("Parent killed, doing exit")
    sys.exit(0)

def latest_picture(request):
    try:
	b = models.CameraRecord.objects.latest('time').picture.name
    except:
	b = None
    logger.info(b)
    return HttpResponse( json.dumps({'name': b}), 'application/json')

def handle_adapter_added_or_removed(path, signal):
    '''
    When ever a dongle is added or removed this function gets called, so we can
    restart the rpc client.
    '''
    logger.info("bluez.%s: %s" % (signal, path))
    stop()

def started(scanner, address):
    logger.info('scan_started %s' % address)
    dongle = ScannerBluetoothDongle.objects.get(address=address)
    record = DeviceRecord()
    record.action = signals.CYCLE_SCAN_DONGLE
    record.dongle = dongle
    record.save()

	def disconnect(self, force=False):
	    if not force:
		self.checkConnected("Can't close if it's opened");
	    logger.info("Closing socket");
	    self.socket.shutdown(socket.SHUT_RDWR);
	    self.socket.close()
	    self.socket = None

def handle_sdp_timeout(dongle, remote, pending):
    logger.info("SDP timeout: %s" % remote )
    pending.pop(remote)
    record = RemoteBluetoothDeviceSDPTimeout()
    record.dongle = UploaderBluetoothDongle.objects.get(address=dongle)
    record.setRemoteDevice(remote)
    record.save()

def __restart_server():
    logger.info("restarting server")
    try:
        server = rpyc.connect('localhost', 8010)
        server.root.restart()
    except:
        #could be that we're only running the web server
        pass

    def handle_name_owner_changed(self, own, old, new):
	''' detect if a name owner is gone, this prevents dead locks '''
	if own in self.connections:
	    if new is None or len(new) is 0:
		for client in self.connections[own]:
		    logger.info("%s lost connection, killing it" % client.path)
		    client.force_disconnect()
		self.connections[own] = None

def handle_sdp_norecord(dongle, remote, pending):
    logger.info("No SDP: %s" % remote)
    pending.pop(remote)
    remote=RemoteDevice.objects.filter(address=remote).get()
    if RemoteBluetoothDeviceNoSDP.objects.filter(remote=remote).count() == 0:
        record = RemoteBluetoothDeviceNoSDP()
        record.dongle = UploaderBluetoothDongle.objects.get(address=dongle)
        record.remote = remote
        record.save()

def db_ready():
    try:
        from openproximity.models import BluetoothDongle
        BluetoothDongle.objects.count()
        return True
    except Exception, err:
	logger.info("Database not ready")
	logger.exception(err)
	return False

 def __sanitize(self):
     try:
         if self.tree is None:
             self.__getXmlTree()
     except Exception, err:
         logger.info("failed while loading file settings, trying to simulate"
                 " config file")
         logger.exception(err)
         self.tree=etree.fromstring(DEFAULT)

def handle_file_uploaded(dongle, remote, pending, channel, files):
    logger.info("files uploaded: %s[%s]: %s" % ( remote, channel, files) )
    pending.pop(remote)
    for rule in get_campaign_rule(files):
	record = RemoteBluetoothDeviceFilesSuccess()
	record.dongle = UploaderBluetoothDongle.objects.get(address=dongle)
	record.campaign = rule
	record.setRemoteDevice(remote)
	record.save()

def configure_dongle(request, address=None):
    logger.info("configure_dongle %s" % address)
    
    errors = []
    messages = []
    form = None
    if request.method == "POST":
        form=DongleForm(request.POST)
        if form.is_valid():
            cd=form.cleaned_data
            add_dongle(
                cd['address'],
                cd['name'],
                cd["scan"],
                cd["upload"],
                cd["scan_pri"],
                cd["upload_max"],
            )
            return HttpResponseRedirect('/')
            #messages.append("Dongle Configured")

    scanner = None
    scanner_pri = 1
    uploader = None
    uploader_max = 7
    
    name = "OpenProximity 2.0"
    
    search=BluetoothDongle.objects.filter(address=address)
    if search.count()>0:
        dongle = search.all()[0]
        name=dongle.name
    
    search=ScannerBluetoothDongle.objects.filter(address=address)
    if search.count() > 0:
        scanner = True
        scanner_pri=search.get().priority
    
    search=UploaderBluetoothDongle.objects.filter(address=address)
    if search.count() > 0:
        uploader = True
        uploader_max=search.get().max_conn

    form = form or DongleForm( initial = { 
                                    'address': address, 
                                    'name': name,
                                     'scan': scanner,
                                     'scan_pri': scanner_pri,
                                     'upload': uploader,
                                     'upload_max': uploader_max})

    return render_to_response('op/dongle_form.html',
        { 
            'form':  form,
            'messages': messages,
        }, context_instance=RequestContext(request))