repos/DecentralizedMedia/DecentralizedMedia.cpp

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

#include <menes/c++/standard.hh>

#include <menes/api/pcre/regex.hpp>
#include <menes/app/simple.hpp>
#include <menes/dbi/driver.hpp>
#include <menes/hop/bind.hpp>
#include <menes/ios/helpers.hpp>
#include <menes/net/http/request.hpp>
#include <menes/net/http/response.hpp>
#include <menes/xml/document.hpp>
#include <menes/xml/parse.hpp>

#include "DecentralizedMedia.hpp"

int Main(const app::Options& options)
{
        api::Pcre::RegEx configuration_(_B("^-configuration=(.+)$")), extension(_B("^-extension=(.+)$")), local(_B("^-local=(.+)$")), player_("^-player=(.+)$");
        cse::String configuration(_B("DecentralizedMedia.xml"));
        ext::RedBlackSet<cse::String> extensions;
        ext::RedBlackSet<api::Path> locals;
        int player(0);

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

                if (match = configuration_(*arg))
                        configuration = match[1];
                else if (match = extension(*arg))
                        extensions.Insert(match[1]);
                else if (match = local(*arg))
                        locals.Insert(api::Path(match[1]).GetRealPath());
                else if (match = player_(*arg))
                        player = lexical_cast<int>(match[1]);
        }

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

        {
                api::Path media(_B("Media"));
        
                if (!media.Exists())
                        media.CreateDirectory();
        
                locals.Insert(media.GetRealPath());
        }

        _S<DecentralizedMedia> media(configuration, extensions, locals, player);

        media.Block();

        return 0;
}

DecentralizedMedia::DecentralizedMedia(const cse::String& configuration, const ext::RedBlackSet<cse::String>& extensions, const ext::RedBlackSet<api::Path>& locals, int player) : waf::Server(_B("Web")), connector(new _H<Connector>(configuration)), extensions(extensions), library(connector), player(connector, player)
{
        {
                _L<cse::String> args;

                _foreach (const ext::RedBlackSet<cse::String>, extension, extensions)
                        args.InsertLast(_S<ios::String>() << "-extension=" << *extension);

                _foreach (const ext::RedBlackSet<api::Path>, local, locals)
                        args.InsertLast(_S<ios::String>() << "-local=" << *local);

                _S<api::Process> media(_B("Util/media"), args);

                Media(*media.GetReader());

                media.Join();
        }

        {
                _L<cse::String> args;

                args.InsertLast(_B("-s"));
                args.InsertLast(_B("object/DecentralizedMedia.hh.gch"));
                args.InsertLast(_B("LOCALS=DecentralizedMedia.hh"));

                _S<api::Process> make(_B(CFG_GNU_MAKE), args);

                make.ClearWriter();

                _S<ios::String> error;

                ios::ReadToWrite(*make.GetReader(), error);

                if (make.Join() != 0)
                        throw ext::StringException(error);
        }

        AddPort(6996);
}

void DecentralizedMedia::Process(const net::Http::Request& request, net::Http::Response& response)
{
        api::Cout << request.client_ << _B(" ");

        if (request.method_ == _B("EXTENSIONS"))
        {
                api::Cout << "EXTENSIONS" << ios::NewLine;

                response.SetStatus(200);

                _foreach (const ext::RedBlackSet<cse::String>, extension, extensions)
                        response << *extension << ios::NewLineNoFlush;
        }
        else if (request.method_ == _B("MEDIA"))
        {
                api::Cout << "MEDIA" << ios::NewLine;

                if (!request.content_.IsEmpty())
                {
                        api::InternetAddress host(request.client_);

                        host.SetPort(6996);

                        Media(*request.content_, host);

                        response.SetStatus(204);
                }
                else
                        response.SetStatus(411);
        }
        else
                waf::Server::Process(request, response);
}

void DecentralizedMedia::Media(ios::Reader& media, const api::Address& host)
{
        _R<xml::Document> document(xml::Parse(media));
        api::Pcre::RegEx share("^[0-9a-f]+$");
        
        _foreach (const xml::NodeSet, folder, *document/"media"/"folder")
        {
                cse::String path(**folder/"path");

                if (api::Pcre::RegEx::Match match = share(path))
                {
                        _R<Share> share(new _H<Share>(connector, host, match[0]));

                        path = share->path.GetPath();

                        player.Add(share);
                }

                Media(*folder, path, path);
        }
}

void DecentralizedMedia::Media(const _R<xml::Node>& folder, const api::Path& path, const api::Path& root)
{
        MediaFolder(connector, path, root);

        _foreach (const xml::NodeSet, file, *folder/"file")
                MediaFile(connector, path.GetChild(**file/"path"), **file/"artist", **file/"title", **file/"album", **file/"genre", root);

        _foreach (const xml::NodeSet, folder_, *folder/"folder")
                Media(*folder_, path.GetChild(**folder_/"path"), root);
}
Revision:	555
Committed:	2005-07-10T21:18:35-07:00 (19 years, 11 months ago) by douglas
File size:	4272 byte(s)
Log Message:	Connector!
#	User	Rev	Content
1	douglas	464	// Decentralized Media
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	douglas	553	#include <menes/c++/standard.hh>
8	douglas	464
9	douglas	549	#include <menes/api/pcre/regex.hpp>
10			#include <menes/app/simple.hpp>
11			#include <menes/dbi/driver.hpp>
12			#include <menes/hop/bind.hpp>
13			#include <menes/ios/helpers.hpp>
14			#include <menes/net/http/request.hpp>
15			#include <menes/net/http/response.hpp>
16			#include <menes/xml/document.hpp>
17			#include <menes/xml/parse.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	555	api::Pcre::RegEx configuration_(_B("^-configuration=(.+)$")), extension(_B("^-extension=(.+)$")), local(_B("^-local=(.+)$")), player_("^-player=(.+)$");
24			cse::String configuration(_B("DecentralizedMedia.xml"));
25	douglas	534	ext::RedBlackSet<cse::String> extensions;
26	douglas	529	ext::RedBlackSet<api::Path> locals;
27	douglas	542	int player(0);
28	douglas	464
29	douglas	474	_foreach (const app::ArgumentList, arg, app::GetArguments())
30			{
31			api::Pcre::RegEx::Match match;
32
33	douglas	555	if (match = configuration_(*arg))
34			configuration = match[1];
35			else if (match = extension(*arg))
36	douglas	491	extensions.Insert(match[1]);
37	douglas	474	else if (match = local(*arg))
38	douglas	529	locals.Insert(api::Path(match[1]).GetRealPath());
39	douglas	542	else if (match = player_(*arg))
40			player = lexical_cast<int>(match[1]);
41	douglas	474	}
42
43			if (extensions.IsEmpty())
44	douglas	491	extensions.Insert(_B("mp3"));
45	douglas	474
46	douglas	529	{
47			api::Path media(_B("Media"));
48
49			if (!media.Exists())
50			media.CreateDirectory();
51
52			locals.Insert(media.GetRealPath());
53			}
54	douglas	491
55	douglas	555	_S<DecentralizedMedia> media(configuration, extensions, locals, player);
56	douglas	474
57	douglas	472	media.Block();
58
59	douglas	471	return 0;
60			}
61	douglas	469
62	douglas	555	DecentralizedMedia::DecentralizedMedia(const cse::String& configuration, const ext::RedBlackSet<cse::String>& extensions, const ext::RedBlackSet<api::Path>& locals, int player) : waf::Server(_B("Web")), connector(new _H<Connector>(configuration)), extensions(extensions), library(connector), player(connector, player)
63	douglas	471	{
64	douglas	517	{
65	douglas	534	_L<cse::String> args;
66	douglas	474
67	douglas	534	_foreach (const ext::RedBlackSet<cse::String>, extension, extensions)
68	douglas	507	args.InsertLast(_S<ios::String>() << "-extension=" << *extension);
69	douglas	474
70	douglas	529	_foreach (const ext::RedBlackSet<api::Path>, local, locals)
71	douglas	507	args.InsertLast(_S<ios::String>() << "-local=" << *local);
72	douglas	474
73	douglas	517	_S<api::Process> media(_B("Util/media"), args);
74	douglas	474
75	douglas	517	Media(*media.GetReader());
76	douglas	503
77	douglas	517	media.Join();
78	douglas	474	}
79
80	douglas	517	{
81	douglas	534	_L<cse::String> args;
82	douglas	517
83			args.InsertLast(_B("-s"));
84			args.InsertLast(_B("object/DecentralizedMedia.hh.gch"));
85	douglas	550	args.InsertLast(_B("LOCALS=DecentralizedMedia.hh"));
86	douglas	517
87	douglas	550	_S<api::Process> make(_B(CFG_GNU_MAKE), args);
88	douglas	517
89			make.ClearWriter();
90
91			_S<ios::String> error;
92
93			ios::ReadToWrite(*make.GetReader(), error);
94
95			if (make.Join() != 0)
96			throw ext::StringException(error);
97			}
98
99	douglas	471	AddPort(6996);
100			}
101	douglas	469
102	douglas	471	void DecentralizedMedia::Process(const net::Http::Request& request, net::Http::Response& response)
103			{
104	douglas	547	api::Cout << request.client_ << _B(" ");
105
106	douglas	531	if (request.method_ == _B("EXTENSIONS"))
107	douglas	474	{
108	douglas	507	api::Cout << "EXTENSIONS" << ios::NewLine;
109
110	douglas	474	response.SetStatus(200);
111
112	douglas	534	_foreach (const ext::RedBlackSet<cse::String>, extension, extensions)
113	douglas	476	response << *extension << ios::NewLineNoFlush;
114	douglas	474	}
115	douglas	531	else if (request.method_ == _B("MEDIA"))
116	douglas	474	{
117	douglas	507	api::Cout << "MEDIA" << ios::NewLine;
118
119	douglas	508	if (!request.content_.IsEmpty())
120	douglas	509	{
121	douglas	542	api::InternetAddress host(request.client_);
122	douglas	508
123	douglas	542	host.SetPort(6996);
124
125			Media(*request.content_, host);
126
127	douglas	509	response.SetStatus(204);
128			}
129			else
130	douglas	531	response.SetStatus(411);
131	douglas	474	}
132	douglas	471	else
133			waf::Server::Process(request, response);
134			}
135	douglas	507
136	douglas	547	void DecentralizedMedia::Media(ios::Reader& media, const api::Address& host)
137	douglas	507	{
138	douglas	541	_R<xml::Document> document(xml::Parse(media));
139	douglas	531	api::Pcre::RegEx share("^[0-9a-f]+$");
140	douglas	507
141			_foreach (const xml::NodeSet, folder, *document/"media"/"folder")
142			{
143	douglas	534	cse::String path(**folder/"path");
144	douglas	507
145	douglas	514	if (api::Pcre::RegEx::Match match = share(path))
146			{
147	douglas	555	_R<Share> share(new _H<Share>(connector, host, match[0]));
148	douglas	514
149			path = share->path.GetPath();
150
151	douglas	542	player.Add(share);
152	douglas	514	}
153
154			Media(*folder, path, path);
155	douglas	507	}
156			}
157
158	douglas	541	void DecentralizedMedia::Media(const _R<xml::Node>& folder, const api::Path& path, const api::Path& root)
159	douglas	507	{
160	douglas	555	MediaFolder(connector, path, root);
161	douglas	507
162			_foreach (const xml::NodeSet, file, *folder/"file")
163	douglas	555	MediaFile(connector, path.GetChild(file/"path"), file/"artist", file/"title", file/"album", **file/"genre", root);
164	douglas	507
165			_foreach (const xml::NodeSet, folder_, *folder/"folder")
166			Media(folder_, path.GetChild(*folder_/"path"), root);
167			}