haiku.git

/*
 * Copyright 2015, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "QueryList.h"

#include <pthread.h>

#include <Autolock.h>
#include <Debug.h>
#include <NodeMonitor.h>
#include <VolumeRoster.h>


static BLooper* sQueryLooper = NULL;
static pthread_once_t sInitOnce = PTHREAD_ONCE_INIT;


static void
initQueryLooper()
{
	sQueryLooper = new BLooper("query looper");
	sQueryLooper->Run();
}


// #pragma mark - QueryListener


QueryListener::~QueryListener()
{
}


// #pragma mark - QueryList


QueryList::QueryList()
	:
	fQuit(false),
	fListeners(5)
{
}


QueryList::~QueryList()
{
	fQuit = true;

	ThreadVector::const_iterator threadIterator = fFetchThreads.begin();
	for (; threadIterator != fFetchThreads.end(); threadIterator++) {
		wait_for_thread(*threadIterator, NULL);
	}

	QueryVector::iterator queryIterator = fQueries.begin();
	for (; queryIterator != fQueries.end(); queryIterator++) {
		delete *queryIterator;
	}
}


status_t
QueryList::Init(const char* predicate, BVolume* specificVolume)
{
	if (sQueryLooper == NULL)
		pthread_once(&sInitOnce, &initQueryLooper);

	if (Looper() != NULL)
		debugger("Init() called twice!");

	sQueryLooper->Lock();
	sQueryLooper->AddHandler(this);
	sQueryLooper->Unlock();

	if (specificVolume == NULL) {
		BVolumeRoster roster;
		BVolume volume;

		while (roster.GetNextVolume(&volume) == B_OK) {
			if (volume.KnowsQuery() && volume.KnowsAttr() && volume.KnowsMime())
				_AddVolume(volume, predicate);
		}
	} else
		_AddVolume(*specificVolume, predicate);

	return B_OK;
}


void
QueryList::AddListener(QueryListener* listener)
{
	BAutolock locker(this);

	// Add all entries that were already retrieved
	RefMap::const_iterator iterator = fRefs.begin();
	for (; iterator != fRefs.end(); iterator++) {
		listener->EntryCreated(*this, iterator->second, iterator->first.node);
	}

	fListeners.AddItem(listener);
}


void
QueryList::RemoveListener(QueryListener* listener)
{
	BAutolock locker(this);
	fListeners.RemoveItem(listener, false);
}


void
QueryList::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_QUERY_UPDATE:
		{
			int32 opcode = message->GetInt32("opcode", -1);
			int64 directory = message->GetInt64("directory", -1);
			int32 device = message->GetInt32("device", -1);
			int64 node = message->GetInt64("node", -1);

			if (opcode == B_ENTRY_CREATED) {
				const char* name = message->GetString("name");
				if (name != NULL) {
					entry_ref ref(device, directory, name);
					_AddEntry(ref, node);
				}
			} else if (opcode == B_ENTRY_REMOVED) {
				node_ref nodeRef(device, node);
				_RemoveEntry(nodeRef);
			}
			break;
		}

		default:
			BHandler::MessageReceived(message);
			break;
	}
}


void
QueryList::_AddEntry(const entry_ref& ref, ino_t node)
{
	BAutolock locker(this);

	// TODO: catch bad_alloc
	fRefs.insert(std::make_pair(node_ref(ref.device, node), ref));

	_NotifyEntryCreated(ref, node);
}


void
QueryList::_RemoveEntry(const node_ref& nodeRef)
{
	BAutolock locker(this);
	RefMap::iterator found = fRefs.find(nodeRef);
	if (found != fRefs.end())
		_NotifyEntryRemoved(nodeRef);
}


void
QueryList::_NotifyEntryCreated(const entry_ref& ref, ino_t node)
{
	ASSERT(IsLocked());

	int32 count = fListeners.CountItems();
	for (int32 index = 0; index < count; index++) {
		fListeners.ItemAt(index)->EntryCreated(*this, ref, node);
	}
}


void
QueryList::_NotifyEntryRemoved(const node_ref& nodeRef)
{
	ASSERT(IsLocked());

	int32 count = fListeners.CountItems();
	for (int32 index = 0; index < count; index++) {
		fListeners.ItemAt(index)->EntryRemoved(*this, nodeRef);
	}
}


void
QueryList::_AddVolume(BVolume& volume, const char* predicate)
{
	BQuery* query = new BQuery();
	if (query->SetVolume(&volume) != B_OK
		|| query->SetPredicate(predicate) != B_OK
		|| query->SetTarget(this) != B_OK) {
		delete query;
	}

	// TODO: catch bad_alloc
	fQueries.push_back(query);
	Lock();
	fQueryQueue.push_back(query);
	Unlock();

	thread_id thread = spawn_thread(_FetchQuery, "query fetcher",
		B_NORMAL_PRIORITY, this);
	if (thread >= B_OK) {
		resume_thread(thread);

		fFetchThreads.push_back(thread);
	}
}


/*static*/ status_t
QueryList::_FetchQuery(void* self)
{
	return static_cast<QueryList*>(self)->_FetchQuery();
}


status_t
QueryList::_FetchQuery()
{
	RefMap map;

	BAutolock locker(this);
	BQuery* query = fQueryQueue.back();
	fQueryQueue.pop_back();
	locker.Unlock();

	query->Fetch();

	entry_ref ref;
	while (!fQuit && query->GetNextRef(&ref) == B_OK) {
		BEntry entry(&ref);
		node_ref nodeRef;
		if (entry.GetNodeRef(&nodeRef) == B_OK)
			map.insert(std::make_pair(nodeRef, ref));
	}
	if (fQuit)
		return B_INTERRUPTED;

	locker.Lock();

	RefMap::const_iterator iterator = map.begin();
	for (; iterator != map.end(); iterator++) {
		_AddEntry(iterator->second, iterator->first.node);
	}

	return B_OK;
}