zoe/trunk/Zoe.cpp

// Zoe AIM Away Message RSS Feed Generator
//
// Seth King and Douglas Thrift
//
// $Id$

#include "Matcher/Matcher.hpp"
#include "Collector.hpp"
#include "Publisher.hpp"

#include <menes-api/exename.hpp>
#include <menes-app/application.hpp>
#include <menes-ios/stdadapters.hpp>

#include <algorithm>
#include <cstring>
#include <iterator>

extern "C"
{
#include <pwd.h>
#include <sys/utsname.h>
#include <unistd.h>
}

struct ZoeCommand : public app::Application
{
        virtual int Run(const app::ArgumentList& args)
        {
                Zoe::program = api::GetExecutablePath().GetName();

                _foreach (app::ArgumentList, arg, args)
                {
                        Matcher matcher;

                        if (*arg == matcher("^-config=(.*)$"))
                        {
                                Zoe::config = matcher[1];
                        }
                        else if (*arg == "-collector")
                        {
                                if (!Zoe::collector) Zoe::collector = true;
                        }
                        else if (*arg == "-publisher")
                        {
                                if (!Zoe::publisher) Zoe::publisher = true;
                        }
                        else if (*arg == "-color")
                        {
                                if (!Zoe::color) Zoe::color = true;
                        }
                        else if (*arg == "-D")
                        {
                                if (!Zoe::debug) Zoe::debug = true;
                        }
                        else
                        {
                                Zoe::usage();

                                return 1;
                        }
                }

                Zoe zoe;

                return 0;
        }
} zoe;

Zoe::Zoe()
{
        if (!(collector || publisher))
        {
                usage();

                return;
        }
        
        configure();

        Collector collector(login, password, buddies, database, Zoe::collector);
        Publisher publisher(buddies, database, Zoe::publisher);
}

bool Zoe::debug(false), Zoe::collector(false), Zoe::publisher(false),
        Zoe::color(false);
ext::String Zoe::program, Zoe::config("zoe.xml");

void Zoe::usage()
{
        api::Cerr << "Usage: " << Zoe::program << " [-config=config] [-collector] [-publisher] [-color] [-D]\n";
}

ext::String Zoe::generator(Generator generator)
{
        ext::String generator_(generator == all || generator == agent ? "Zoe" : "");

        switch (generator)
        {
        case all:
                generator_.InsertAllLast("/0.9");
        case agent:
                {
                        ::utsname system;

                        ::uname(&system);

                        generator_.InsertAllLast(ios::String() << " (" << system.sysname);
                }

                if (generator == agent)
                {
                        generator_.InsertAllLast(")");

                        break;
                }
                else generator_.InsertAllLast("; ");
        case url:
                generator_.InsertAllLast("http://computers.douglasthrift.net/zoe.xml");

                if (generator == all) generator_.InsertAllLast(")");

                break;
        case version:
                generator_ = "0.9";
        }

        return generator_;
}

void Zoe::configure()
{
        if (debug) api::Cerr << "config = " << config << "\n";

        ext::Handle<xml::Document> document(xml::Parse(config));
        ext::Handle<xml::Node> zoe(*document/"zoe");

        login = *zoe/"login";
        password = *zoe/"password";
        database.driver = *zoe/"database"/"driver";
        database.host = *zoe/"database"/"host";
        database.user = *zoe/"database"/"user";

        if ((*zoe/"database"/"password").IsEmpty())
        {
                ext::String prompt(database.user + (!database.host.IsEmpty() ? "@" : "")
                        + database.host + (!database.user.IsEmpty() ? "'s " : "")
                        + "Database Password: ");
                char* password(getpass(prompt.NullTerminate()));

                database.password = password;

                for (size_t index(std::strlen(password)); index > 0; --index)
                        password[index - 1] = '\0';
        }
        else database.password = *zoe/"database"/"password";

        database.db = *zoe/"database"/"db";

        if (debug) api::Cerr << "login = " << login << "\npassword = "
                << std::string(password.GetSize(), '*') << "\ndatabase = {\n"
                << "   driver = " << database.driver << "\n   host = " << database.host
                << "\n   user = " << database.user << "\n"
                << "   password = " << std::string(database.password.GetSize(), '*')
                << "\n   db = " << database.db << "\n}\n";

        ext::String link(*zoe/"link");
        xml::NodeSet buddies(*zoe/"buddy");

        for (xml::NodeSet::Iterator buddy(buddies.Begin()); buddy != buddies.End();
                ++buddy)
        {
                Buddy buddy_(**buddy/"login", **buddy/"rss", **buddy/"atom",
                        !(**buddy/"link").IsEmpty() ? **buddy/"link" : (link
                        + ext::String(**buddy/"login") + ".html"));

                this->buddies.insert(buddy_);
        }

        initialize();

        if (debug)
        {
                api::Cerr << "buddies = {\n";

                for (std::set<Buddy>::const_iterator buddy(this->buddies.begin());
                        buddy != this->buddies.end(); ++buddy)
                {
                        api::Cerr << "   " << *buddy << " = {\n      rss = "
                                << buddy->getRss() << "\n      atom = " << buddy->getAtom()
                                << "\n      link = " << buddy->getLink() << "\n      id = "
                                << buddy->getId() << "\n   }\n";
                }

                api::Cerr << "}\n";
        }

        if (debug) api::Cerr << "collector = " << collector << "\npublisher = "
                << publisher << "\ncolor = " << color << "\n";
}

void Zoe::initialize()
{
        ext::Handle<dbi::Driver> driver(dbi::GetDriver(database.driver));
        ext::Handle<dbi::Connection> db(driver->Connect(database.host,
                database.user, database.password, database.db));
        ext::Handle<dbi::ResultSet> buddies(db->Execute("SELECT * FROM buddies"));
        std::set<Buddy> buddies_;

        while (buddies->MoveNext())
        {
                if (this->buddies.find(buddies->GetString("buddy")) != this->buddies.end())
                {
                        Buddy buddy(*this->buddies.find(buddies->GetString("buddy")));

                        buddy.setId(lexical_cast<ext::Uuid>(buddies->GetString("id")));
                        buddies_.insert(buddy);
                }
        }

        std::vector<Buddy> difference;

        set_difference(this->buddies.begin(), this->buddies.end(), buddies_.begin(),
                buddies_.end(), std::insert_iterator<std::vector<Buddy> >(difference,
                difference.begin()));

        for (std::vector<Buddy>::iterator buddy(difference.begin());
                buddy != difference.end(); ++buddy)
        {
                ext::Uuid id(api::Uuid::CreateSequential());

//              api::Uuid::CreateSequential(id);

                buddy->setId(id);
                db->Execute("INSERT INTO buddies (id, buddy) VALUES ('"
                        + lexical_cast<ext::String>(id) + "', '" + ext::String(*buddy)
                        + "')");
                
                buddies_.insert(*buddy);
        }

        this->buddies = buddies_;
}
Revision:	70
Committed:	2004-12-16T11:43:53-08:00 (20 years, 6 months ago) by douglas
File size:	5661 byte(s)
Log Message:	Fixit.
#	User	Rev	Content
1	douglas	5	// Zoe AIM Away Message RSS Feed Generator
2			//
3			// Seth King and Douglas Thrift
4			//
5			// $Id$
6
7	douglas	69	#include "Matcher/Matcher.hpp"
8	douglas	13	#include "Collector.hpp"
9			#include "Publisher.hpp"
10	douglas	5
11	douglas	58	#include <menes-api/exename.hpp>
12			#include <menes-app/application.hpp>
13	douglas	63	#include <menes-ios/stdadapters.hpp>
14	douglas	58
15	douglas	21	#include <algorithm>
16			#include <cstring>
17			#include <iterator>
18
19			extern "C"
20			{
21			#include <pwd.h>
22	douglas	25	#include <sys/utsname.h>
23	douglas	21	#include <unistd.h>
24			}
25
26	douglas	58	struct ZoeCommand : public app::Application
27	douglas	5	{
28	douglas	58	virtual int Run(const app::ArgumentList& args)
29	douglas	7	{
30	douglas	67	Zoe::program = api::GetExecutablePath().GetName();
31	douglas	7
32	douglas	70	_foreach (app::ArgumentList, arg, args)
33	douglas	7	{
34	douglas	58	Matcher matcher;
35
36	douglas	70	if (arg == matcher("^-config=(.)$"))
37	douglas	58	{
38			Zoe::config = matcher[1];
39			}
40	douglas	70	else if (*arg == "-collector")
41	douglas	58	{
42			if (!Zoe::collector) Zoe::collector = true;
43			}
44	douglas	70	else if (*arg == "-publisher")
45	douglas	58	{
46			if (!Zoe::publisher) Zoe::publisher = true;
47			}
48	douglas	70	else if (*arg == "-color")
49	douglas	58	{
50			if (!Zoe::color) Zoe::color = true;
51			}
52	douglas	70	else if (*arg == "-D")
53	douglas	58	{
54			if (!Zoe::debug) Zoe::debug = true;
55			}
56	douglas	70	else
57			{
58			Zoe::usage();
59
60			return 1;
61			}
62	douglas	7	}
63
64	douglas	58	Zoe zoe;
65	douglas	7
66	douglas	58	return 0;
67			}
68			} zoe;
69	douglas	7
70	douglas	12	Zoe::Zoe()
71	douglas	7	{
72	douglas	70	if (!(collector \|\| publisher))
73			{
74			usage();
75
76			return;
77			}
78	douglas	43
79	douglas	7	configure();
80	douglas	8
81	douglas	21	Collector collector(login, password, buddies, database, Zoe::collector);
82			Publisher publisher(buddies, database, Zoe::publisher);
83	douglas	7	}
84
85	douglas	38	bool Zoe::debug(false), Zoe::collector(false), Zoe::publisher(false),
86	douglas	58	Zoe::color(false);
87	douglas	7	ext::String Zoe::program, Zoe::config("zoe.xml");
88
89	douglas	43	void Zoe::usage()
90			{
91	douglas	70	api::Cerr << "Usage: " << Zoe::program << " [-config=config] [-collector] [-publisher] [-color] [-D]\n";
92	douglas	43	}
93
94	douglas	36	ext::String Zoe::generator(Generator generator)
95	douglas	25	{
96	douglas	36	ext::String generator_(generator == all \|\| generator == agent ? "Zoe" : "");
97	douglas	25
98	douglas	36	switch (generator)
99			{
100			case all:
101			generator_.InsertAllLast("/0.9");
102			case agent:
103			{
104	douglas	70	::utsname system;
105	douglas	25
106	douglas	70	::uname(&system);
107	douglas	36
108	douglas	69	generator_.InsertAllLast(ios::String() << " (" << system.sysname);
109	douglas	36	}
110
111			if (generator == agent)
112			{
113			generator_.InsertAllLast(")");
114
115			break;
116			}
117			else generator_.InsertAllLast("; ");
118			case url:
119			generator_.InsertAllLast("http://computers.douglasthrift.net/zoe.xml");
120
121			if (generator == all) generator_.InsertAllLast(")");
122
123			break;
124			case version:
125			generator_ = "0.9";
126			}
127
128			return generator_;
129	douglas	25	}
130
131	douglas	7	void Zoe::configure()
132			{
133	douglas	60	if (debug) api::Cerr << "config = " << config << "\n";
134	douglas	21
135	douglas	7	ext::Handle<xml::Document> document(xml::Parse(config));
136			ext::Handle<xml::Node> zoe(*document/"zoe");
137
138	douglas	52	login = *zoe/"login";
139			password = *zoe/"password";
140			database.driver = *zoe/"database"/"driver";
141			database.host = *zoe/"database"/"host";
142			database.user = *zoe/"database"/"user";
143	douglas	7
144	douglas	21	if ((*zoe/"database"/"password").IsEmpty())
145			{
146	douglas	38	ext::String prompt(database.user + (!database.host.IsEmpty() ? "@" : "")
147			+ database.host + (!database.user.IsEmpty() ? "'s " : "")
148			+ "Database Password: ");
149	douglas	21	char* password(getpass(prompt.NullTerminate()));
150
151			database.password = password;
152
153	douglas	38	for (size_t index(std::strlen(password)); index > 0; --index)
154			password[index - 1] = '\0';
155	douglas	21	}
156	douglas	52	else database.password = *zoe/"database"/"password";
157	douglas	21
158	douglas	52	database.db = *zoe/"database"/"db";
159	douglas	21
160	douglas	60	if (debug) api::Cerr << "login = " << login << "\npassword = "
161	douglas	38	<< std::string(password.GetSize(), '*') << "\ndatabase = {\n"
162	douglas	54	<< " driver = " << database.driver << "\n host = " << database.host
163	douglas	60	<< "\n user = " << database.user << "\n"
164	douglas	38	<< " password = " << std::string(database.password.GetSize(), '*')
165			<< "\n db = " << database.db << "\n}\n";
166	douglas	21
167	douglas	52	ext::String link(*zoe/"link");
168	douglas	12	xml::NodeSet buddies(*zoe/"buddy");
169
170	douglas	38	for (xml::NodeSet::Iterator buddy(buddies.Begin()); buddy != buddies.End();
171			++buddy)
172			{
173	douglas	39	Buddy buddy_(buddy/"login", buddy/"rss", **buddy/"atom",
174	douglas	46	!(buddy/"link").IsEmpty() ? buddy/"link" : (link
175	douglas	52	+ ext::String(**buddy/"login") + ".html"));
176	douglas	39
177			this->buddies.insert(buddy_);
178	douglas	38	}
179	douglas	21
180	douglas	60	initialize();
181
182	douglas	21	if (debug)
183	douglas	12	{
184	douglas	60	api::Cerr << "buddies = {\n";
185	douglas	21
186	douglas	38	for (std::set<Buddy>::const_iterator buddy(this->buddies.begin());
187			buddy != this->buddies.end(); ++buddy)
188			{
189	douglas	60	api::Cerr << " " << *buddy << " = {\n rss = "
190			<< buddy->getRss() << "\n atom = " << buddy->getAtom()
191			<< "\n link = " << buddy->getLink() << "\n id = "
192			<< buddy->getId() << "\n }\n";
193	douglas	38	}
194	douglas	21
195	douglas	60	api::Cerr << "}\n";
196	douglas	12	}
197	douglas	13
198	douglas	60	if (debug) api::Cerr << "collector = " << collector << "\npublisher = "
199			<< publisher << "\ncolor = " << color << "\n";
200	douglas	7	}
201	douglas	21
202			void Zoe::initialize()
203			{
204	douglas	59	ext::Handle<dbi::Driver> driver(dbi::GetDriver(database.driver));
205			ext::Handle<dbi::Connection> db(driver->Connect(database.host,
206	douglas	38	database.user, database.password, database.db));
207	douglas	21	ext::Handle<dbi::ResultSet> buddies(db->Execute("SELECT * FROM buddies"));
208			std::set<Buddy> buddies_;
209
210			while (buddies->MoveNext())
211			{
212	douglas	50	if (this->buddies.find(buddies->GetString("buddy")) != this->buddies.end())
213			{
214			Buddy buddy(*this->buddies.find(buddies->GetString("buddy")));
215	douglas	21
216	douglas	50	buddy.setId(lexical_cast<ext::Uuid>(buddies->GetString("id")));
217			buddies_.insert(buddy);
218			}
219	douglas	21	}
220
221			std::vector<Buddy> difference;
222
223	douglas	38	set_difference(this->buddies.begin(), this->buddies.end(), buddies_.begin(),
224			buddies_.end(), std::insert_iterator<std::vector<Buddy> >(difference,
225			difference.begin()));
226	douglas	21
227	douglas	38	for (std::vector<Buddy>::iterator buddy(difference.begin());
228			buddy != difference.end(); ++buddy)
229	douglas	21	{
230	douglas	62	ext::Uuid id(api::Uuid::CreateSequential());
231	douglas	21
232	douglas	62	// api::Uuid::CreateSequential(id);
233	douglas	21
234			buddy->setId(id);
235	douglas	38	db->Execute("INSERT INTO buddies (id, buddy) VALUES ('"
236			+ lexical_cast<ext::String>(id) + "', '" + ext::String(*buddy)
237			+ "')");
238	douglas	21
239			buddies_.insert(*buddy);
240			}
241
242			this->buddies = buddies_;
243			}