🚀 go-pugleaf

Cześć.

Poszukuje inspiracji a być może gotowca. Ale to trudno powiedzieć. A 
chodzi o coś takiego:

Implementacja abstrkacyjnego filesystemu pracującego na urzeniau 
blokowym, do którego dostęp zapewniam ja, przez stosowane abstrkacje. 
Wykorzystać było by fajnie, ale najważniejsze to możliwośc podejrzenia 
rozwiązań.

Wiec to tak powinno wyglądać:

struct IFooFileSystem
{
	std::shared_ptr< IFile > openFile( std::string cosnt& _fileName, Flags 
_flags );

	bool fileExist( std::string const& _fileName );

	[...]
};

struct IBlockDevice
{
	std::shared_ptr< Block > readBlock( BlockIndes _index );

	void writeBlock( BlockIndes _index, Block& _block );
};

struct IFile
{
	void read(...);
	void seek(...);
	[...]
}

std::shared_ptr< IFooFileSystem >
createFileSystem( myBlockDevice );

Coś w ten deseń, czyli to ja dostaczam abstrakcje robiącą I/O na 
poziomie block/cluster a kod realizuje wysokopoziomowe operacje plikowe.

To nie musi być z czymkolwiek kompatybilne, nawet lepiej gdyby nie było. 
Musi być natomist komplenie nie zależne od czegokolwiek, czy to systemu 
czy zewnatrznych biblitek. I thread safe, będę jednoczesnie czytał i 
zapisywał wiele "plików" z róznych wątków. W zasadzie poza "plikami" 
reszta kompletnie zbędna, nie interesują mnie atrybuty czy nawet 
katalogi. Mocno uproszczony filesystem, coś w rodzaju wielu niezależnych 
strumieni w jednym kontenerze.

Mogę to napisać samodzielnie, ale zanim to zrobie: ktoś widział taki 
projekt lub część jakiegoś projektu?

Dla zastanawiajacych się po co mi to:

Jest *prawdziwy* plik. W moim kodzie jest konwertowany do urządzenia 
blokowego i wystawiany do tego mechanizmu fiesystemu.

Dzięki temu mogę w jednym pliku trzymac w środku wiele plików, 
bezustannie je czytajac i zmieniając. Ułatwi mi to pracę, ponieważ pliki 
te są trzymane razem, user nie może nic w nich popsuć, nie muszę 
bezustannie pakować/rozpakować jak robi np. OpenOffice (u nich 
kontenerem jest packer). Od razu gotowe do pracy.

Katalog odpada: user może w nim coś popsuć.

Ewentualne puchnięcie moża jakoś obejśc pisząc garbage collector 
trimujący ten "wirtualny filesystem" i przenoszący bloki w tle.

Coś podobnego robi np. VirtualBox ale nie chodzi o taki poziom emulacji 
dysków, to ma byc mała pierdoła do kodu który mam pod kontrolą.

Innymi słowy: czy ktoś widział tego typu wirtualny filesystem? 
Interesują mnie zagadnienia takie jak uproszczony wielodostęp czy 
realizacja kroniki. Chciałbym je poderzeć, ponieważ nie mam w tym 
doswiadczenia, pewnie napiszę to mało optymalnie.

Projekt Fuse nie nadaje się bez bardzo poważnego wrapowania. Ponadto ja 
nie potrzebuje wielu filesystemów, potrzebuje tylko jeden, o mało ważnej 
kompatybilności ze światem zewnętrznym. Taki FooFS.