repos/DecentralizedMedia/DecentralizedMedia.cpp

// Decentralized Media
//
// Douglas Thrift
//
// $Id$

#include <menes/standard.hh>

#include <menes-api/pcre/regex.hpp>
#include <menes-api/realpath.hpp>
#include <menes-app/simple.hpp>
#include <menes-dbi/driver.hpp>
#include <menes-dbi/resultset.hpp>
#include <menes-etl/fnbind.hpp>
#include <menes-ios/helpers.hpp>
#include <menes-net/http/request.hpp>
#include <menes-net/http/response.hpp>

#include "DecentralizedMedia.hpp"

int Main(const app::Options& options)
{
        ext::RedBlackSet<ext::String> extensions, locals;
        api::Pcre::RegEx extension(_B("^-extension=(.+)$")), local(_B("^-local=(.+)$"));

        _foreach (const app::ArgumentList, arg, app::GetArguments())
        {
                api::Pcre::RegEx::Match match;

                if (match = extension(*arg))
                        extensions.Insert(match[1]);
                else if (match = local(*arg))
                        locals.Insert(api::RealPath(match[1]));
        }

        if (extensions.IsEmpty())
                extensions.Insert(_B("mp3"));

        if (!api::Path(_B("Media")).Exists())
                api::Posix::CheckError(::mkdir("Media", 0755));

        locals.Insert(api::RealPath(_B("Media")));

        _S<DecentralizedMedia> media(extensions, locals);

        media.Block();

        return 0;
}

DecentralizedMedia::DecentralizedMedia(const ext::RedBlackSet<ext::String>& extensions, const ext::RedBlackSet<ext::String>& locals) : waf::Server(_B("Web")), process(bmp.IsRunning() ? NULL : new api::Process(_B("/usr/X11R6/bin/beep-media-player"))), connection(dbi::GetDriver("pgsql")->Connect("", "douglas", "", "media")), extensions(extensions)
{
        connection->Execute(_B("UPDATE files SET live = FALSE"));

        _foreach (const ext::RedBlackSet<ext::String>, local, locals)
                MediaFolder(connection, *local, *local);

        {
                _L<ext::String> args(locals.Begin(), locals.End());

                args.InsertLast(_B("-type"));
                args.InsertLast(_B("d"));

                _foreach (const ext::RedBlackSet<ext::String>, extension, extensions)
                {
                        args.InsertLast(_B("-or"));
                        args.InsertLast(_B("-iname"));
                        args.InsertLast(_S<ios::String>() << _B("*.") << *extension);
                }

                _H<api::Process> find(new api::Process(_B("/usr/bin/find"), args));
                ext::String file;
                api::Path root;

                while (ios::ReadLine(*find->GetReader(), file))
                        if (locals.Contains(file))
                                root = file;
                        else
                        {
                                api::Path path(file);

                                if (path.IsDirectory())
                                        MediaFolder(connection, path, root);
                                else
                                        MediaFile(connection, path, ext::EmptyString, ext::EmptyString, ext::EmptyString, ext::EmptyString, root);
                        }

                find->Join();
        }

        AddPort(6996);
}

DecentralizedMedia::~DecentralizedMedia()
{
        if (!process.IsEmpty())
        {
                _H<api::Thread> thread(new api::Thread(etl::BindAll(&DecentralizedMedia::Destroy, this)));

                bmp.Quit();

                thread->Join();
        }
}

_L<ext::String> DecentralizedMedia::GetArtists() const
{
        _H<dbi::ResultSet> artists_(connection->Execute(_B("SELECT DISTINCT artist FROM files WHERE live = TRUE")));
        _L<ext::String> artists;

        while (artists_->MoveNext())
                artists.InsertLast(artists_->GetString(_B("artist")));

        return artists;
}

_L<ext::String> DecentralizedMedia::GetTitles() const
{
        _H<dbi::ResultSet> titles_(connection->Execute(_B("SELECT DISTINCT title FROM files WHERE live = TRUE")));
        _L<ext::String> titles;

        while (titles_->MoveNext())
                titles.InsertLast(titles_->GetString(_B("title")));

        return titles;
}

_L<ext::String> DecentralizedMedia::GetAlbums() const
{
        _H<dbi::ResultSet> albums_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
        _L<ext::String> albums;

        while (albums_->MoveNext())
                albums.InsertLast(albums_->GetString(_B("album")));

        return albums;
}

_L<ext::String> DecentralizedMedia::GetGenres() const
{
        _H<dbi::ResultSet> genres_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
        _L<ext::String> genres;

        while (genres_->MoveNext())
                genres.InsertLast(genres_->GetString(_B("genre")));

        return genres;
}

_L<MediaFolder> DecentralizedMedia::GetFolders() const
{
        _H<dbi::ResultSet> paths(connection->Execute(_B("SELECT DISTINCT root FROM files WHERE live = TRUE")));
        _L<MediaFolder> folders;

        while (paths->MoveNext())
                folders.InsertLast(MediaFolder(connection, paths->GetString(_B("path"))));

        return folders;
}

void DecentralizedMedia::Process(const net::Http::Request& request, net::Http::Response& response)
{
        if (request.method_ == _B("EXTENSIONS"))
        {
                response.SetStatus(200);

                _foreach (const ext::RedBlackSet<ext::String>, extension, extensions)
                        response << *extension << ios::NewLineNoFlush;
        }
        else if (request.method_ == _B("MEDIA"))
        {
                // XXX: implement
        }
        else
                waf::Server::Process(request, response);
}
Revision:	503
Committed:	2005-06-18T01:34:41-07:00 (20 years ago) by douglas
File size:	4573 byte(s)
Log Message:	Meep!
#	User	Rev	Content
1	douglas	464	// Decentralized Media
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	douglas	470	#include <menes/standard.hh>
8	douglas	464
9	douglas	474	#include <menes-api/pcre/regex.hpp>
10	douglas	497	#include <menes-api/realpath.hpp>
11	douglas	471	#include <menes-app/simple.hpp>
12	douglas	484	#include <menes-dbi/driver.hpp>
13			#include <menes-dbi/resultset.hpp>
14	douglas	471	#include <menes-etl/fnbind.hpp>
15	douglas	474	#include <menes-ios/helpers.hpp>
16	douglas	471	#include <menes-net/http/request.hpp>
17			#include <menes-net/http/response.hpp>
18	douglas	470
19	douglas	471	#include "DecentralizedMedia.hpp"
20	douglas	464
21	douglas	471	int Main(const app::Options& options)
22	douglas	464	{
23	douglas	491	ext::RedBlackSet<ext::String> extensions, locals;
24	douglas	474	api::Pcre::RegEx extension(_B("^-extension=(.+)$")), local(_B("^-local=(.+)$"));
25	douglas	464
26	douglas	474	_foreach (const app::ArgumentList, arg, app::GetArguments())
27			{
28			api::Pcre::RegEx::Match match;
29
30			if (match = extension(*arg))
31	douglas	491	extensions.Insert(match[1]);
32	douglas	474	else if (match = local(*arg))
33	douglas	497	locals.Insert(api::RealPath(match[1]));
34	douglas	474	}
35
36			if (extensions.IsEmpty())
37	douglas	491	extensions.Insert(_B("mp3"));
38	douglas	474
39	douglas	493	if (!api::Path(_B("Media")).Exists())
40			api::Posix::CheckError(::mkdir("Media", 0755));
41	douglas	491
42	douglas	497	locals.Insert(api::RealPath(_B("Media")));
43	douglas	493
44	douglas	481	_S<DecentralizedMedia> media(extensions, locals);
45	douglas	474
46	douglas	472	media.Block();
47
48	douglas	471	return 0;
49			}
50	douglas	469
51	douglas	491	DecentralizedMedia::DecentralizedMedia(const ext::RedBlackSet<ext::String>& extensions, const ext::RedBlackSet<ext::String>& locals) : waf::Server(_B("Web")), process(bmp.IsRunning() ? NULL : new api::Process(_B("/usr/X11R6/bin/beep-media-player"))), connection(dbi::GetDriver("pgsql")->Connect("", "douglas", "", "media")), extensions(extensions)
52	douglas	471	{
53	douglas	503	connection->Execute(_B("UPDATE files SET live = FALSE"));
54
55	douglas	495	_foreach (const ext::RedBlackSet<ext::String>, local, locals)
56	douglas	497	MediaFolder(connection, local, local);
57	douglas	493
58	douglas	474	{
59	douglas	491	_L<ext::String> args(locals.Begin(), locals.End());
60	douglas	474
61	douglas	493	args.InsertLast(_B("-type"));
62			args.InsertLast(_B("d"));
63
64	douglas	491	_foreach (const ext::RedBlackSet<ext::String>, extension, extensions)
65	douglas	474	{
66	douglas	493	args.InsertLast(_B("-or"));
67	douglas	492	args.InsertLast(_B("-iname"));
68	douglas	474	args.InsertLast(_S<ios::String>() << _B(".") << extension);
69			}
70
71			_H<api::Process> find(new api::Process(_B("/usr/bin/find"), args));
72			ext::String file;
73	douglas	503	api::Path root;
74	douglas	474
75	douglas	503	while (ios::ReadLine(*find->GetReader(), file))
76			if (locals.Contains(file))
77			root = file;
78			else
79			{
80			api::Path path(file);
81	douglas	474
82	douglas	503	if (path.IsDirectory())
83			MediaFolder(connection, path, root);
84			else
85			MediaFile(connection, path, ext::EmptyString, ext::EmptyString, ext::EmptyString, ext::EmptyString, root);
86			}
87
88	douglas	474	find->Join();
89			}
90
91	douglas	471	AddPort(6996);
92			}
93	douglas	469
94	douglas	471	DecentralizedMedia::~DecentralizedMedia()
95	douglas	469	{
96	douglas	471	if (!process.IsEmpty())
97			{
98			_H<api::Thread> thread(new api::Thread(etl::BindAll(&DecentralizedMedia::Destroy, this)));
99	douglas	470
100	douglas	471	bmp.Quit();
101	douglas	469
102	douglas	471	thread->Join();
103			}
104	douglas	464	}
105	douglas	471
106	douglas	491	_L<ext::String> DecentralizedMedia::GetArtists() const
107			{
108			_H<dbi::ResultSet> artists_(connection->Execute(_B("SELECT DISTINCT artist FROM files WHERE live = TRUE")));
109			_L<ext::String> artists;
110
111			while (artists_->MoveNext())
112			artists.InsertLast(artists_->GetString(_B("artist")));
113
114			return artists;
115			}
116
117			_L<ext::String> DecentralizedMedia::GetTitles() const
118			{
119			_H<dbi::ResultSet> titles_(connection->Execute(_B("SELECT DISTINCT title FROM files WHERE live = TRUE")));
120			_L<ext::String> titles;
121
122			while (titles_->MoveNext())
123			titles.InsertLast(titles_->GetString(_B("title")));
124
125			return titles;
126			}
127
128			_L<ext::String> DecentralizedMedia::GetAlbums() const
129			{
130			_H<dbi::ResultSet> albums_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
131			_L<ext::String> albums;
132
133			while (albums_->MoveNext())
134			albums.InsertLast(albums_->GetString(_B("album")));
135
136			return albums;
137			}
138
139			_L<ext::String> DecentralizedMedia::GetGenres() const
140			{
141			_H<dbi::ResultSet> genres_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
142			_L<ext::String> genres;
143
144			while (genres_->MoveNext())
145			genres.InsertLast(genres_->GetString(_B("genre")));
146
147			return genres;
148			}
149
150			_L<MediaFolder> DecentralizedMedia::GetFolders() const
151			{
152			_H<dbi::ResultSet> paths(connection->Execute(_B("SELECT DISTINCT root FROM files WHERE live = TRUE")));
153			_L<MediaFolder> folders;
154
155			while (paths->MoveNext())
156			folders.InsertLast(MediaFolder(connection, paths->GetString(_B("path"))));
157
158			return folders;
159			}
160
161	douglas	471	void DecentralizedMedia::Process(const net::Http::Request& request, net::Http::Response& response)
162			{
163	douglas	474	if (request.method_ == _B("EXTENSIONS"))
164			{
165			response.SetStatus(200);
166
167	douglas	492	_foreach (const ext::RedBlackSet<ext::String>, extension, extensions)
168	douglas	476	response << *extension << ios::NewLineNoFlush;
169	douglas	474	}
170			else if (request.method_ == _B("MEDIA"))
171			{
172			// XXX: implement
173			}
174	douglas	471	else
175			waf::Server::Process(request, response);
176			}