haiku.git

/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "PackageLinkDirectory.h"

#include <new>

#include <NodeMonitor.h>

#include <AutoDeleter.h>

#include "AutoPackageAttributeDirectoryCookie.h"
#include "DebugSupport.h"
#include "PackageLinksListener.h"
#include "StringConstants.h"
#include "Utils.h"
#include "Version.h"
#include "Volume.h"


PackageLinkDirectory::PackageLinkDirectory()
	:
	Directory(0),
		// the ID needs to be assigned later, when added to a volume
	fSelfLink(NULL),
	fSettingsLink(NULL)
{
	get_real_time(fModifiedTime);
}


PackageLinkDirectory::~PackageLinkDirectory()
{
	if (fSelfLink != NULL)
		fSelfLink->ReleaseReference();
	if (fSettingsLink != NULL)
		fSettingsLink->ReleaseReference();

	while (DependencyLink* link = fDependencyLinks.RemoveHead())
		link->ReleaseReference();
}


status_t
PackageLinkDirectory::Init(Package* package)
{
	// init the directory/node
	status_t error = Init(package->VersionedName());
	if (error != B_OK)
		RETURN_ERROR(error);

	// add the package
	AddPackage(package, NULL);

	return B_OK;
}


status_t
PackageLinkDirectory::Init(const String& name)
{
	return Directory::Init(name);
}


timespec
PackageLinkDirectory::ModifiedTime() const
{
	return fModifiedTime;
}


status_t
PackageLinkDirectory::OpenAttributeDirectory(AttributeDirectoryCookie*& _cookie)
{
	Package* package = fPackages.Head();
	if (package == NULL)
		return B_ENTRY_NOT_FOUND;

	AutoPackageAttributeDirectoryCookie* cookie = new(std::nothrow)
		AutoPackageAttributeDirectoryCookie();
	if (cookie == NULL)
		return B_NO_MEMORY;

	_cookie = cookie;
	return B_OK;
}


status_t
PackageLinkDirectory::OpenAttribute(const StringKey& name, int openMode,
	AttributeCookie*& _cookie)
{
	Package* package = fPackages.Head();
	if (package == NULL)
		return B_ENTRY_NOT_FOUND;

	return AutoPackageAttributes::OpenCookie(package, name, openMode, _cookie);
}


void
PackageLinkDirectory::AddPackage(Package* package,
	PackageLinksListener* listener)
{
	DirectoryWriteLocker writeLocker(this);

	// Find the insertion point in the list. We sort by mount type -- the more
	// specific the higher the priority.
	MountType mountType = package->Volume()->MountType();
	Package* otherPackage = NULL;
	for (PackageList::Iterator it = fPackages.GetIterator();
			(otherPackage = it.Next()) != NULL;) {
		if (otherPackage->Volume()->MountType() <= mountType)
			break;
	}

	fPackages.InsertBefore(otherPackage, package);
	package->SetLinkDirectory(this);

	if (package == fPackages.Head())
		_Update(listener);
}


void
PackageLinkDirectory::RemovePackage(Package* package,
	PackageLinksListener* listener)
{
	ASSERT(package->LinkDirectory() == this);

	DirectoryWriteLocker writeLocker(this);

	bool firstPackage = package == fPackages.Head();

	package->SetLinkDirectory(NULL);
	fPackages.Remove(package);

	if (firstPackage)
		_Update(listener);
}


void
PackageLinkDirectory::UpdatePackageDependencies(Package* package,
	PackageLinksListener* listener)
{
	ASSERT(package->LinkDirectory() == this);

	DirectoryWriteLocker writeLocker(this);

	// We only need to update, if that head package is affected.
	if (package != fPackages.Head())
		return;

	_UpdateDependencies(listener);
}


status_t
PackageLinkDirectory::_Update(PackageLinksListener* listener)
{
	// Always remove all dependency links -- if there's still a package, they
	// will be re-created below.
	while (DependencyLink* link = fDependencyLinks.RemoveHead())
		_RemoveLink(link, listener);

	// check, if empty
	Package* package = fPackages.Head();
	if (package == NULL) {
		// remove self and settings link
		_RemoveLink(fSelfLink, listener);
		fSelfLink = NULL;

		_RemoveLink(fSettingsLink, listener);
		fSettingsLink = NULL;

		return B_OK;
	}

	// create/update self and settings link
	status_t error = _CreateOrUpdateLink(fSelfLink, package,
		Link::TYPE_INSTALLATION_LOCATION, StringConstants::Get().kSelfLinkName,
		listener);
	if (error != B_OK)
		RETURN_ERROR(error);

	error = _CreateOrUpdateLink(fSettingsLink, package, Link::TYPE_SETTINGS,
		StringConstants::Get().kSettingsLinkName, listener);
	if (error != B_OK)
		RETURN_ERROR(error);

	// update the dependency links
	return _UpdateDependencies(listener);
}


status_t
PackageLinkDirectory::_UpdateDependencies(PackageLinksListener* listener)
{
	ASSERT_WRITE_LOCKED_RW_LOCK(&fLock);

	Package* package = fPackages.Head();
	if (package == NULL)
		return B_OK;

	// Iterate through the package's dependencies
	for (DependencyList::ConstIterator it
				= package->Dependencies().GetIterator();
			Dependency* dependency = it.Next();) {
		Resolvable* resolvable = dependency->Resolvable();
		Package* resolvablePackage = resolvable != NULL
			? resolvable->Package() : NULL;

		Node* node = FindChild(dependency->FileName());
		if (node != NULL) {
			// link already exists -- update
			DependencyLink* link = static_cast<DependencyLink*>(node);
			link->Update(resolvablePackage, listener);
		} else {
			// no link for the dependency yet -- create one
			DependencyLink* link = new(std::nothrow) DependencyLink(
				resolvablePackage);
			if (link == NULL)
				return B_NO_MEMORY;

			status_t error = link->Init(dependency->FileName());
			if (error != B_OK) {
				delete link;
				RETURN_ERROR(error);
			}

			AddChild(link);
			fDependencyLinks.Add(link);

			if (listener != NULL)
				listener->PackageLinkNodeAdded(link);
		}
	}

	return B_OK;
}


void
PackageLinkDirectory::_RemoveLink(Link* link, PackageLinksListener* listener)
{
	ASSERT_WRITE_LOCKED_RW_LOCK(&fLock);

	if (link != NULL) {
		if (listener != NULL)
			listener->PackageLinkNodeRemoved(link);

		RemoveChild(link);
		link->ReleaseReference();
	}
}


status_t
PackageLinkDirectory::_CreateOrUpdateLink(Link*& link, Package* package,
	Link::Type type, const String& name, PackageLinksListener* listener)
{
	ASSERT_WRITE_LOCKED_RW_LOCK(&fLock);

	if (link == NULL) {
		link = new(std::nothrow) Link(package, type);
		if (link == NULL)
			return B_NO_MEMORY;

		status_t error = link->Init(name);
		if (error != B_OK)
			RETURN_ERROR(error);

		AddChild(link);

		if (listener != NULL)
			listener->PackageLinkNodeAdded(link);
	} else {
		link->Update(package, listener);
	}

	return B_OK;
}