zoe/trunk/Zoe.cpp

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

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

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

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

int main(int argc, char* argv[])
{
        Zoe::program = argv[0];

        for (int index(1); index < argc; ++index)
        {
                ext::String arg(argv[index]);
                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();
        }

        Zoe zoe;

        return 0;
}

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

        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()
{
        cerr << "Usage: " << Zoe::program << " [-config=config] [-collector] "
                "[-publisher] [-color] [-D]\n";

        exit(1);
}

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(_S(" (") + 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) cerr << "config = " << config << '\n';

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

        login = std::string(*zoe/"login");
        password = std::string(*zoe/"password");
        database.driver = std::string(*zoe/"database"/"driver");
        database.host = std::string(*zoe/"database"/"host");
        database.user = std::string(*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 = std::string(*zoe/"database"/"password");

        database.db = std::string(*zoe/"database"/"db");

        if (debug) 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";

        std::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);

                this->buddies.insert(buddy_);
        }

        if (debug)
        {
                cerr << "buddies = {\n";

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

                cerr << "}\n";
        }

        if (debug) cerr << "collector = " << lexical_cast<ext::String>(collector)
                << "\npublisher = " << lexical_cast<ext::String>(publisher)
                << "\ncolor = " << lexical_cast<ext::String>(color) << '\n';
}

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